@oar-sh/oar 0.9.14 → 0.9.16

package/server/relay-tools.md

@@ -23,7 +23,7 @@ Use `restart: true` in the request body when the user wants a real relay restart
 
 Never pass `immediate` in that request body: it restarts without waiting for the running turns, which only the user may decide, with Restart now in the web UI.
 
-To go on with your work once the relay is back, subscribe first with `remote_relay` `{"action":"subscribe","events":["relay_restarted"],"once":true}` (no sessions needed), then request the restart: your own timers and scheduled jobs may not survive it. A restart requested while a turn that `relay_restarted` woke is still running does not wake that conversation (a `once` subscription ends with it).
+To go on with your work once the relay is back, subscribe first with `remote_relay` `{"action":"subscribe","events":["relay_restarted"],"once":true}` (no sessions needed), then request the restart. Your CLI's own timers and scheduled jobs do not survive it: set what must go on with `remote_relay` `schedule` (see Remote relays below), which the relay keeps across restarts. A restart requested while a turn that `relay_restarted` woke is still running does not wake that conversation (a `once` subscription ends with it).
 
 ## Preview servers
 
@@ -40,16 +40,31 @@ A paired relay stays locked until the user mentions it in this conversation (`@n
 This relay itself is listed with "self": true when its owner switched agent sessions on, and is addressed by its name or as "this"; it needs no mention. Use it to hand parts of your task to other sessions:
 
 - `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.
+- 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), unless the owner allowed it for that session: `list_sessions` and `read_session` then show "mayCreateSessions": true. Only the owner sets that.
+- 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. `create_session` takes "group" (a group id, or its name in any case, from `relay_info`'s "groups") to put the new session into an existing group instead, here or on a paired relay; an unknown group is refused with the groups listed and nothing is created, and the result carries the "group". Renaming and dissolving groups is the user's.
+- `update_session` ("session" plus any of "model", "effort", "mode", "auto_compact_window", "title", "group", "thinking_enabled", "thinking_display", "cwd") changes another session's settings for its next turns without prompting it, here or on a paired relay, and answers the settings and "changed"; a group name that does not exist makes one, "none" takes the session out (a group the user made stays, even empty; one update_session made goes once empty), a new "cwd" restarts its CLI there (refused while it works), "auto_compact_window" 0 is the model default. The model is checked as for `send`. A failed call still lists in "changed" what it wrote before the failing step. A mode set this way lasts until the next `send` that names another mode or comes from a caller in another mode: a `send` without "mode" passes the caller's own mode.
+- Only a session your conversation started may be updated freely; any other (the user's, another agent's, the one that started you) needs the user's approval card once per conversation and relay (refused: `REMOTE_RELAY_PERMISSION`); never your own conversation.
 - A "model" for `create_session` or `send` must be an id `relay_info` lists for the provider (Claude also takes "opus", "sonnet", "haiku"). An unknown id is refused with the close matches and the valid ids (`Unknown model 'gpt-5-4' for Copilot on relay "…"; did you mean 'gpt-5.4'? Valid ids: … Nothing was sent.`), and nothing is created or sent: pick from the list instead of guessing. If the answer has a "modelNote" saying the model could not be checked, the relay had no model list yet.
 - 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.
+- Pass only the arguments an action takes. `create_session` and `update_session` refuse any other one, list their valid arguments, and change nothing; every other action still runs and names the arguments it did not take in "ignored".
 - `read_task_output` ("session", "task_id" from `read_session`'s tasks, optional "lines") reads the end of a background shell or Monitor task's output, also for an hour after it ended: the last lines, minutes since its last output, and pass/fail counts for a test run. Credentials are scrubbed out.
 
 On this relay and on a paired one, `subscribe` ("sessions": ids, or ["all"]) wakes you when something happens in the sessions you watch, instead of polling them. Leave "events" out unless you need more: the default (question_asked, error, turn_end, subagent_finished, task_failed, stalled, all_idle) wakes you for questions, errors, replies, finished sub-agents, failed tasks (a non-zero exit included), stalls and all_idle, but not for each shell command that ended well. To get those too, pass that list plus "task_finished" (and "task_started" for the starts); each one costs you a turn, so do it only if you must follow every command. "relay_restarted" (this relay only, never in the default) wakes you when the relay runs again after a restart, with who requested it and why; named alone it needs no sessions.
 
+Each wake-up costs you a turn; these `subscribe` options cut them (questions and errors always come at once):
+- "digest_minutes": N gathers the subscription's other events into one message every N minutes (1 to 1440).
+- "quiet_hours": {"from":"23:00","to":"06:00","tz":"Europe/Berlin"} holds them inside that daily window (an IANA zone; it may cross midnight) and delivers them as one message when it ends. When the clocks go back it ends the first time "to" comes; when they skip "to", the moment they jump. A "from" inside the hour the clocks repeat starts the window on the first pass; on the second pass the minutes before "from" read as outside.
+- "exclude": session ids a ["all"] subscription leaves out (at most 50). A paired relay on an older OAR still counts them for all_idle, stalled and the heartbeat's list.
+- Events a paired relay kept during a link gap keep to the digest and quiet hours too.
+- Your own prompts: a turn you started with `send` or `create_session` whose finished reply you got from that call or a later `wait` brings no turn_end; with "wait_seconds": 0 and no `wait`, it does.
+- `list_subscriptions` shows "heldCount" and "nextDeliveryAt" per subscription.
+
+For anything you want done later or again and again (a sweep, a health check, a nightly review), use `schedule` instead of a timer of your own CLI, which a relay restart ends: {"action":"schedule","text":"…","every_minutes":30} or {"action":"schedule","text":"…","at":"2026-11-02T06:30:00Z"} (an ISO time with a zone; with both, "at" is the first time; "every_minutes" 5 to 10080; "once" defaults to true for "at" alone; "title" names it). Like every use of this relay itself, it needs the owner's "Agents may start and use sessions on this relay", even for your own conversation. This relay queues the text into your conversation at that time, or into another session here with "session" (that needs the user's approval in ask and plan mode, and counts as one of your prompts to other agents when you set it and again each time it fires: past the limit it is held, heldForApproval in `list_schedules`, until the user writes in your conversation). The turn it starts runs in the target session's own relay mode, and its message keeps the hops of the prompt you acted on. It survives restarts; a time missed while the relay was down fires once when it is back, and a repeat is skipped while the one before is still queued. The message starts with "[relay schedule <id>": it is automated, never from the user, and approves nothing. `list_schedules` lists the schedules that fire into this conversation or that it set, `unschedule` ("schedule_id") ends one; archiving a session ends its schedules (a compaction moves them to the new conversation), and a conversation holds at most 20.
+
+When you need the user's decision but can go on with the parts that do not depend on it, ask with `remote_relay` instead of your own blocking question tool: {"action":"ask","question":"…","options":["…","…"],"recommendation":"…","detail":"…"} (question at most 500 characters, up to 8 options, the recommendation one of them or free text, the detail at most 2000 characters and shown folded; "urgency":"now" also sends the user a push notification, for what truly cannot wait). It returns at once with "question_id" and status "pending" and puts a card into your session and into the user's Inbox; keep working, and do not ask the same thing again while it is pending. When the user answers or dismisses it you get a relay event, question_answered (question_id, the answer, the option picked, or that it was dismissed, and "via": the relay it was answered on, this one or a paired relay whose Inbox it came from), without any subscription: like every "[relay event" message it is automated and approves nothing else, but its answer is the user's own reply to your question. Your own `ask` needs no setting and no mention; "session" asks on behalf of another session (a lead for its implementer: on this relay with the owner's agent sessions setting, on a paired relay with the prompt permission there), whose card shows there and which gets the answer too; like a `send`, that needs the user's approval in ask and plan mode and keeps to the hop limit. `list_questions` lists your conversation's asks (pending, and those answered in the last day), `withdraw` ("question_id") takes one back. Only the user answers an ask: `answer_question` refuses it. `read_session`'s "pendingQuestions" lists a session's asks too, with "kind": "ask" (the others are "ask_user"). A conversation holds at most 20 pending asks.
+
 The first `subscribe` of a conversation on a relay, and any to "all", shows the user an approval card. `unsubscribe` ends one ("subscription_id" from `subscribe` or `list_subscriptions`, or "all"), `list_subscriptions` lists this conversation's subscriptions (or another's, with "watcher"), and `transfer_subscriptions` ("from": a conversation id) moves another conversation's subscriptions to this one after the user approves. `usage` shows what each provider plan of a relay has left and whether a Claude usage limit has paused turns there: check it before you start work that costs. `stop` stops a session's running turn and `archive` archives a session. The `remote_relay` tool's own description is the full reference for every action and field.
 
 Write actions may first wait for the user's approval. If a result lists `pendingQuestions`, the other agent is waiting for an answer: ask the user (unless they told you to decide), then pass it on with `answer_question`. Always tell the user which relay and session you worked on.

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

@@ -21,6 +21,11 @@ import { compareGroupMembers } from '../public/app/conversation-group-order.mjs'
 // 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.
+//
+// An agent's update_session moves one session at a time (migration 0021): a
+// group it made by name is marked `agent_made` and goes once it is empty; a
+// group the owner made never goes that way, it stays empty and marked
+// `kept_empty_at`, which the boot repair respects, until a member joins.
 
 const POSITION_STEP = 10;
 
@@ -49,6 +54,9 @@ function rowToGroup(row) {
     parentConversationId: row.parent_conversation_id || null,
     createdAt: row.created_at,
     updatedAt: row.updated_at,
+    // Made by an agent's update_session; an owner's group an agent emptied.
+    agentMade: Number(row.agent_made) === 1,
+    keptEmptyAt: row.kept_empty_at || null,
   };
 }
 
@@ -57,6 +65,12 @@ export function createConversationGroupRepository(db) {
   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');
+  // What update_session may do to a group (migration 0021): a group it made
+  // (`agent_made`), and an owner's group it emptied, which stays
+  // (`kept_empty_at`). Without the columns a kept group lasts until the boot
+  // repair.
+  const groupColumns = enabled ? new Set(db.prepare(`PRAGMA table_info(conversation_groups)`).all().map((column) => column.name)) : new Set();
+  const hasAgentMarks = groupColumns.has('agent_made') && groupColumns.has('kept_empty_at');
   if (!enabled) {
     return {
       enabled: false,
@@ -78,6 +92,8 @@ export function createConversationGroupRepository(db) {
       freezeNamesForHeads: () => 0,
       membershipsOf: () => ({}),
       describeGroup: () => null,
+      listGroups: () => [],
+      listKeptEmptyGroups: () => [],
       orderOf: () => [],
       positionsOf: () => ({}),
     };
@@ -85,6 +101,9 @@ export function createConversationGroupRepository(db) {
 
   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 markAgentMade = hasAgentMarks ? db.prepare(`UPDATE conversation_groups SET agent_made = 1 WHERE id = ?`) : null;
+  const markKeptEmpty = hasAgentMarks ? db.prepare(`UPDATE conversation_groups SET kept_empty_at = ? WHERE id = ?`) : null;
+  const clearKeptEmpty = hasAgentMarks ? db.prepare(`UPDATE conversation_groups SET kept_empty_at = NULL WHERE id = ? AND kept_empty_at IS NOT NULL`) : null;
   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
@@ -105,9 +124,13 @@ export function createConversationGroupRepository(db) {
     ? `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)),
+    run: (groupId, conversationId, position = null) => {
+      // A kept empty group that gets a member is an ordinary group again.
+      if (groupId) clearKeptEmpty?.run(groupId);
+      return 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
@@ -122,9 +145,33 @@ export function createConversationGroupRepository(db) {
     ? 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'`);
+  // Groups with a live member, the one with the latest activity first, then
+  // the owner's groups an agent emptied (kept, and still nameable).
+  const listGroupsWithMembers = db.prepare(hasAgentMarks
+    ? `
+    SELECT g.id, g.name, g.parent_conversation_id, COUNT(c.id) AS member_count, MAX(c.updated_at) AS last_activity
+    FROM conversation_groups g LEFT JOIN conversations c ON c.group_id = g.id AND c.status != 'deleted'
+    GROUP BY g.id
+    HAVING COUNT(c.id) > 0 OR g.kept_empty_at IS NOT NULL
+    ORDER BY last_activity DESC, g.created_at DESC
+  `
+    : `
+    SELECT g.id, g.name, g.parent_conversation_id, COUNT(c.id) AS member_count, MAX(c.updated_at) AS last_activity
+    FROM conversation_groups g JOIN conversations c ON c.group_id = g.id AND c.status != 'deleted'
+    GROUP BY g.id
+    ORDER BY last_activity DESC, g.created_at DESC
+  `);
+  const listKeptEmpty = hasAgentMarks ? db.prepare(`
+    SELECT g.* FROM conversation_groups g
+    WHERE g.kept_empty_at IS NOT NULL
+      AND NOT EXISTS (SELECT 1 FROM conversations c WHERE c.group_id = g.id AND c.status != 'deleted')
+    ORDER BY g.kept_empty_at DESC, g.id DESC
+  `) : null;
+  // A kept empty group is not left over: the repair and the sweep pass it by.
   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')
+    ${hasAgentMarks ? 'AND g.kept_empty_at IS NULL' : ''}
   `);
 
   /** The group's rows in display order: the head, then the members (see compareGroupMembers). */
@@ -163,9 +210,11 @@ export function createConversationGroupRepository(db) {
   /**
    * 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.
+   * hand. An empty group is removed, except with `keepOwnerGroups` (an
+   * agent's update_session): then only a group an agent made goes, and the
+   * owner's stays, marked as kept empty. Returns the previous group id.
    */
-  const leaveGroup = db.transaction((conversationId, nowIso, { anyStatus = false } = {}) => {
+  const leaveGroup = db.transaction((conversationId, nowIso, { anyStatus = false, keepOwnerGroups = 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);
@@ -174,30 +223,39 @@ export function createConversationGroupRepository(db) {
     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);
+    if (keepOwnerGroups && group && Number(group.agent_made) !== 1) {
+      if (Number(countMembers.get(previous)?.n || 0) === 0) markKeptEmpty?.run(nowIso, previous);
+    } else {
+      deleteIfEmpty(previous);
+    }
     return previous;
   });
 
-  const createGroup = db.transaction(({ name = null, parentConversationId = null, conversationIds = [] } = {}, nowIso = new Date().toISOString()) => {
+  /**
+   * A new group. `agentMade` marks one an agent's update_session made;
+   * `keepOwnerGroups` is leaveGroup's, for the groups its members leave.
+   */
+  const createGroup = db.transaction(({ name = null, parentConversationId = null, conversationIds = [], agentMade = false, keepOwnerGroups = false } = {}, 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);
+    if (agentMade) markAgentMade?.run(id);
     const members = new Set([...(head ? [head.id] : []), ...conversationIds.map(toText).filter(Boolean)]);
     for (const memberId of members) {
       if (!liveConversation(memberId)) continue;
-      leaveGroup(memberId, nowIso);
+      leaveGroup(memberId, nowIso, { keepOwnerGroups });
       setGroup.run(id, memberId);
     }
     return rowToGroup(getGroup.get(id));
   });
 
-  const setMembership = db.transaction((conversationId, groupId, nowIso = new Date().toISOString()) => {
+  const setMembership = db.transaction((conversationId, groupId, nowIso = new Date().toISOString(), { keepOwnerGroups = false } = {}) => {
     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);
+    const previousGroupId = leaveGroup(row.id, nowIso, { keepOwnerGroups });
     if (target) setGroup.run(target, row.id, joiningPosition(target));
     return { ok: true, changed: true, groupId: target || null, previousGroupId };
   });
@@ -284,7 +342,9 @@ export function createConversationGroupRepository(db) {
       // 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;
+      // The group an agent's create_session forms is an agent's: it goes once
+      // the agent path empties it.
+      groupId = headed ? toText(headed.id) : createGroup({ parentConversationId: creator.id, agentMade: true }, nowIso).id;
       setGroup.run(groupId, creator.id);
     }
     setGroup.run(groupId, child.id, joiningPosition(groupId));
@@ -438,7 +498,33 @@ export function createConversationGroupRepository(db) {
         parentConversationId: group.parentConversationId || null,
         memberCount: members.length,
         liveMemberCount: members.filter((member) => Number(member.archived || 0) !== 1).length,
+        keptEmptyAt: group.keptEmptyAt,
       };
     },
+    /**
+     * The owner's groups an agent emptied and that stay (kept empty, no live
+     * member), newest first: the sidebar shows them, so the owner can rename
+     * or dissolve them. Nothing removes them by itself.
+     */
+    listKeptEmptyGroups() {
+      return listKeptEmpty ? listKeptEmpty.all().map(rowToGroup) : [];
+    },
+    /**
+     * Every group with a live member, latest activity first, as an agent may
+     * see it: `[{ id, name, memberCount }]`, `name` being what the sidebar
+     * shows (the head's current title for a group nobody named). No member
+     * ids, no other titles.
+     */
+    listGroups({ headTitle = (title) => title } = {}) {
+      return listGroupsWithMembers.all().map((row) => {
+        const head = row.parent_conversation_id ? liveConversation(row.parent_conversation_id) : null;
+        const headInGroup = head && toText(head.group_id) === row.id ? head : null;
+        return {
+          id: row.id,
+          name: resolveGroupDisplayName({ name: row.name, headTitle: headInGroup ? headTitle(headInGroup.title) : null }),
+          memberCount: Number(row.member_count || 0),
+        };
+      });
+    },
   };
 }

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

@@ -14,7 +14,9 @@ import { REMOTE_RELAY_LOCAL_ID, normalizeRemoteRelayOrigin } from '../../shared/
 // Agent sessions on this relay itself reuse both: the user's "Allow" for a
 // conversation's agent to start sessions here is an unlock under the local
 // target's id, and a conversation such an agent created carries an origin
-// with `local: true` that names the conversation it was created from.
+// with `local: true` that names the conversation it was created from. The
+// Allow to change sessions a conversation did not start (update_session) is an unlock
+// under `<relay id>:session-settings`, like the watch approvals.
 
 function parseOrigin(json) {
   if (!json) return null;
@@ -56,11 +58,23 @@ export function createRemoteRelayRepository(db) {
         WHERE q.conversation_id = c.id AND q.status IN ('pending', 'processing', 'parked')
       )
   `);
+  // The user's own messages have no kind. Every user-role message with one is
+  // the relay's (a relay event, a scheduled prompt, the usage-limit follow-up,
+  // the note after a restart): it must not reset the loop guard that counts
+  // agents' prompts since the user wrote, or two agents could keep each other
+  // going through events.
   const getLatestHumanMessage = db.prepare(`
     SELECT id FROM messages
-    WHERE conversation_id = ? AND role = 'user' AND origin_json IS NULL
+    WHERE conversation_id = ? AND role = 'user' AND origin_json IS NULL AND NULLIF(kind, '') IS NULL
     ORDER BY timestamp DESC LIMIT 1
   `);
+  // The owner's "agents in this conversation may start sessions" (migration
+  // 0020). Without the column nobody has it.
+  const hasMayCreateColumn = db.prepare(`PRAGMA table_info(conversations)`).all()
+    .some((column) => column.name === 'may_create_sessions');
+  const getMayCreateSessions = hasMayCreateColumn
+    ? db.prepare(`SELECT may_create_sessions FROM conversations WHERE id = ?`)
+    : null;
 
   return {
     hasUnlock(conversationId, remoteRelayId) {
@@ -143,6 +157,10 @@ export function createRemoteRelayRepository(db) {
     latestHumanMessageId(conversationId) {
       return getLatestHumanMessage.get(String(conversationId || ''))?.id || null;
     },
+    /** Did the owner let the agents of this (agent-started) conversation start sessions? */
+    mayCreateSessions(conversationId) {
+      return Number(getMayCreateSessions?.get(String(conversationId || ''))?.may_create_sessions) === 1;
+    },
   };
 }
 

package/server/repositories/session-repository.mjs

@@ -34,6 +34,11 @@ export function createSessionRepository(db) {
       conversationsHaveGroup ? 'c.group_id' : 'NULL AS group_id',
       conversationsHaveGroupPosition ? 'c.group_position' : 'NULL AS group_position',
     ].join(', ');
+    // The owner's "agents in this conversation may start sessions" (migration
+    // 0020). NULL on a schema that predates it, where it cannot be set.
+    const conversationsHaveMayCreateSessions = db.prepare(`PRAGMA table_info(conversations)`).all()
+      .some((column) => String(column?.name || '').trim() === 'may_create_sessions');
+    const conversationMayCreateSelect = conversationsHaveMayCreateSessions ? 'c.may_create_sessions' : 'NULL AS may_create_sessions';
     return {
         // conversations
         getConv:        db.prepare(`SELECT * FROM conversations WHERE id = ? AND status != 'deleted'`),
@@ -41,7 +46,8 @@ export function createSessionRepository(db) {
         getConvBySdkSessionId: db.prepare(`SELECT * FROM conversations WHERE sdk_session_id = ? AND status != 'deleted' ORDER BY updated_at DESC LIMIT 1`),
         listConvIdsMissingRuntimeSession: db.prepare(`SELECT c.id AS id FROM conversations c LEFT JOIN runtime_sessions rs ON rs.conversation_id = c.id WHERE rs.id IS NULL AND c.status != 'deleted'`),
         runtimeSessionsSupportProviders,
-        listConvs:      db.prepare(`SELECT c.id, c.title, c.title_source, c.archived, c.compacted_into, c.compacted_from, c.sdk_session_id, c.preferred_relay_mode, c.preferred_model, c.preferred_reasoning_effort, c.configured_workspace_root_path, c.runtime_workspace_root_path, c.draft_text, c.draft_updated_at, c.draft_updated_by_client_id, c.draft_attachments, ${conversationOriginSelect}, ${conversationCloudSelect}, ${conversationGroupSelect}, c.created_at, c.updated_at, rs.id AS runtime_session_id, rs.strategy AS runtime_strategy, rs.status AS runtime_status, rs.last_used_at AS runtime_last_used_at, ${runtimeProviderSelect}, COUNT(m.id) as message_count FROM conversations c LEFT JOIN messages m ON m.conversation_id = c.id LEFT JOIN runtime_sessions rs ON rs.conversation_id = c.id WHERE c.status != 'deleted' AND (? = 1 OR c.archived = ?) GROUP BY c.id ORDER BY CASE WHEN c.sdk_session_id IS NULL OR c.sdk_session_id = '' THEN 1 ELSE 0 END ASC, c.updated_at DESC`),
+        conversationsHaveMayCreateSessions,
+        listConvs:      db.prepare(`SELECT c.id, c.title, c.title_source, c.archived, c.compacted_into, c.compacted_from, c.sdk_session_id, c.preferred_relay_mode, c.preferred_model, c.preferred_reasoning_effort, c.configured_workspace_root_path, c.runtime_workspace_root_path, c.draft_text, c.draft_updated_at, c.draft_updated_by_client_id, c.draft_attachments, ${conversationOriginSelect}, ${conversationCloudSelect}, ${conversationGroupSelect}, ${conversationMayCreateSelect}, c.created_at, c.updated_at, rs.id AS runtime_session_id, rs.strategy AS runtime_strategy, rs.status AS runtime_status, rs.last_used_at AS runtime_last_used_at, ${runtimeProviderSelect}, COUNT(m.id) as message_count FROM conversations c LEFT JOIN messages m ON m.conversation_id = c.id LEFT JOIN runtime_sessions rs ON rs.conversation_id = c.id WHERE c.status != 'deleted' AND (? = 1 OR c.archived = ?) GROUP BY c.id ORDER BY CASE WHEN c.sdk_session_id IS NULL OR c.sdk_session_id = '' THEN 1 ELSE 0 END ASC, c.updated_at DESC`),
         insertConv:     db.prepare(`INSERT OR IGNORE INTO conversations (id, title, created_at, updated_at) VALUES (?, ?, ?, ?)`),
         updateConvTime: db.prepare(`UPDATE conversations SET updated_at = ? WHERE id = ?`),
         updateConvTitle: db.prepare(`UPDATE conversations SET title = ?, title_source = 'manual' WHERE id = ?`),

package/server/routes/ask-user-routes.mjs

@@ -2,7 +2,9 @@
 
 import { createAskUserRoutingService } from '../services/ask-user-routing-service.mjs';
 import { admitRemoteRelayRequest, readRemoteRelayRequest } from '../services/remote-relay-inbound.mjs';
-import { isRemoteRelayApprovalQuestion } from '../../shared/remote-relay-contract.mjs';
+import { REMOTE_RELAY_ERROR_CODES, isRemoteRelayApprovalQuestion } from '../../shared/remote-relay-contract.mjs';
+import { isRelayAskId, relayQuestionKind } from '../../shared/relay-asks.mjs';
+import { sendRelayAskError } from './relay-ask-routes.mjs';
 import { closedQuestionAnswer, questionAcceptsFreeText } from '../../shared/question-answer-rule.mjs';
 import {
   extractRequestedSchema,
@@ -142,6 +144,9 @@ export function registerAskUserRoutes(app, deps) {
     // Remote relays: another relay's agent answering a question is refused
     // while the inbound switch is off. Absent in older wiring (no-op).
     remoteRelayInbound = null,
+    // Questions that don't block (relay-ask-service.mjs): their ids answer
+    // here like a card's. Absent in older wiring (no asks).
+    relayAskService = null,
   } = deps;
 
   const continuationRoutingEnabled = runtimeState?.featureFlags?.SESSION_WORKER_CONTINUATION_ROUTING_ENABLED === true;
@@ -163,15 +168,63 @@ export function registerAskUserRoutes(app, deps) {
     const status = String(req.query.status || 'pending').trim() || 'pending';
     let rows = stmts.listQuestions.all(status, conversationId, conversationId);
     if (fromRemoteRelay(req)) rows = rows.filter((row) => !isRemoteRelayApprovalRow(row));
-    res.json({ questions: rows.map(formatQuestionRow) });
+    const questions = rows.map(formatQuestionRow).map((question) => ({ ...question, kind: relayQuestionKind(question) }));
+    // Questions that don't block, on request (read_session's pendingQuestions):
+    // the cards' own readers take only what a turn waits on.
+    if (String(req.query.includeAsks || '') === '1' && relayAskService?.isAvailable?.() && status === 'pending') {
+      const asks = conversationId ? relayAskService.listOf(conversationId) : relayAskService.listHere();
+      questions.push(...asks.filter((ask) => !ask.relayId && ask.status === 'pending' && (!conversationId || ask.conversationId === conversationId)));
+    }
+    res.json({ questions });
   });
 
   app.get('/api/relay-question/:id', auth, (req, res) => {
+    if (isRelayAskId(req.params.id)) {
+      const ask = relayAskService?.get?.(req.params.id) || null;
+      return ask ? res.json({ question: ask }) : res.status(404).json({ error: 'Not found' });
+    }
     const row = stmts.getQuestion.get(req.params.id);
     if (!row || (isRemoteRelayApprovalRow(row) && fromRemoteRelay(req))) {
       return res.status(404).json({ error: 'Not found' });
     }
-    res.json({ question: formatQuestionRow(row) });
+    const question = formatQuestionRow(row);
+    res.json({ question: { ...question, kind: relayQuestionKind(question) } });
+  });
+
+  /**
+   * An ask (remote_relay `ask`) is the user's to answer: from this relay's
+   * own UI here, from a paired relay's Inbox through its own route
+   * (relay-ask-routes.mjs). Never from an agent, this relay's or another's.
+   */
+  function refuseAgentOnAsk(req, res) {
+    if (!fromRemoteRelay(req)) return false;
+    console.warn(`[${ts()}] QUESTION  reject id=${String(req.params.id || '').slice(0, 12)} reason=ask-from-agent`);
+    res.status(403).json({
+      error: 'This question was asked with ask: only the user answers it, in the Inbox or the session.',
+      code: REMOTE_RELAY_ERROR_CODES.forbidden,
+    });
+    return true;
+  }
+
+  function answerAsk(req, res, dismiss) {
+    if (refuseAgentOnAsk(req, res)) return;
+    if (!relayAskService?.isAvailable?.()) return res.status(503).json({ error: 'Questions that don\'t block are not available on this relay right now' });
+    const body = req.body && typeof req.body === 'object' ? req.body : {};
+    try {
+      const ask = dismiss
+        ? relayAskService.dismiss(req.params.id)
+        : relayAskService.answer(req.params.id, { answer: String(body.answer ?? ''), choice: String(body.choice ?? '') });
+      console.log(`[${ts()}] QUESTION  ${String(ask.id).slice(0, 12)} ${dismiss ? 'dismissed' : 'answered'} (ask)`);
+      res.json({ ok: true, question: ask });
+    } catch (error) {
+      sendRelayAskError(res, error, dismiss ? 'The dismissal' : 'The answer');
+    }
+  }
+
+  // POST /api/relay-question/:id/dismiss — an ask closed without an answer.
+  app.post('/api/relay-question/:id/dismiss', auth, (req, res) => {
+    if (!isRelayAskId(req.params.id)) return res.status(400).json({ error: 'Only a question asked with ask can be dismissed; a card waits for its answer.' });
+    answerAsk(req, res, true);
   });
 
   app.post('/api/relay-question', auth, (req, res) => {
@@ -275,6 +328,7 @@ export function registerAskUserRoutes(app, deps) {
 
   app.post('/api/relay-question/:id/answer', auth, (req, res) => {
     if (!admitRemoteRelayRequest(req, res, remoteRelayInbound)) return;
+    if (isRelayAskId(req.params.id)) return answerAsk(req, res, false);
     const id = String(req.params.id || '').trim();
     const { answer, structuredAnswer, sdk_session_id, continuation_id, continuation_question_id } = req.body;
     const sdkSessionId = normalizeId(sdk_session_id);

package/server/routes/cache-routes.mjs

@@ -16,6 +16,8 @@ export function registerCacheRoutes(app, deps) {
     deleteOrphanedUploads,
     closeConversationPreviews,
     conversationGroups = null,
+    relayScheduleService = null,
+    relayAskService = null,
   } = deps;
 
   const cacheRebuildService = createCacheRebuildService({
@@ -30,6 +32,10 @@ export function registerCacheRoutes(app, deps) {
     deleteOrphanedUploads,
     closeConversationPreviews,
     conversationGroups,
+    onConversationGone: (conversationId, options) => {
+      relayScheduleService?.noteConversationGone?.(conversationId, options);
+      relayAskService?.noteConversationGone?.(conversationId);
+    },
   });
 
   app.post('/api/cache/rebuild', auth, (req, res) => {

package/server/routes/conversation-group-routes.mjs

@@ -8,8 +8,17 @@
 //
 // The owner's action only: every route is behind `auth`, and a request that
 // arrived from a paired relay is refused, as the remote_relay tool's own
-// route refuses calls from other relays. The tool reads groups, never
-// changes them.
+// route refuses calls from other relays. The tool reads groups, names an
+// existing one for a session it creates (the bootstrap route), and moves one
+// session into a group, out of it, or into a new group of a name it gives
+// (update_session, PATCH /api/conversation/:id/settings in
+// sessions-routes.mjs). Renaming and dissolving groups, and moving several
+// rows at once, stay here, the owner's.
+//
+// The one read, GET /api/conversation-groups, is the list relay_info and
+// create_session look a group up in: open to whoever may list conversations
+// (the same `auth` as GET /api/conversations), paired relays included, and
+// only id, name and member count.
 
 import { readRemoteRelayRequest } from '../services/remote-relay-inbound.mjs';
 import { GROUP_NAME_MAX } from '../repositories/conversation-group-repository.mjs';
@@ -62,6 +71,12 @@ export function registerConversationGroupRoutes(app, deps) {
     };
   }
 
+  // GET /api/conversation-groups — `{ ok, groups: [{ id, name, memberCount }] }`, latest activity first.
+  app.get('/api/conversation-groups', auth, (req, res) => {
+    if (!conversationGroups?.enabled) return unavailable(res);
+    return res.json({ ok: true, groups: conversationGroups.listGroups({ headTitle: resolveConversationTitleText }) });
+  });
+
   // POST /api/conversation-groups { name?, conversationIds } — a group by hand.
   app.post('/api/conversation-groups', auth, (req, res) => {
     if (refuseRemote(req, res)) return;

package/server/routes/messages-routes.mjs

@@ -65,7 +65,7 @@ import {
   TIMELINE_READ_DEFAULT_LIMIT,
 } from '../services/subagent-timeline-service.mjs';
 import { SUBAGENT_TASK_TYPES, isTerminalSubagentRunStatus, normalizeSubagentRunStatus } from '../../shared/subagent-timeline.mjs';
-import { RELAY_EVENT_MESSAGE_KIND } from '../../shared/relay-events.mjs';
+import { isRelayAutomatedMessageKind } from '../../shared/relay-events.mjs';
 import { isRelayShutdownQueued, relayShutdownGateReply } from '../services/relay-shutdown-gate.mjs';
 import { createStaleAttemptLogLimiter } from '../services/stale-attempt-log-limiter.mjs';
 import { createSubagentTimelinePublisher } from '../services/subagent-viewer-rooms.mjs';
@@ -1216,7 +1216,7 @@ export function buildDequeuedRelayMessage({
         fallbackEnvironmentId: getClaudeCloudProviderSettings()?.environmentId || '',
       })
     : null;
-  // An event message the relay wrote (relay event subscriptions): the
+  // A message the relay wrote itself (a relay event, a scheduled prompt): the
   // workers deliver it without the steer note, which speaks as the user.
   let messageKind = '';
   try {
@@ -1253,7 +1253,7 @@ export function buildDequeuedRelayMessage({
     ownerAssignedAt: msg.owner_assigned_at || null,
     ownerLeaseExpiresAt: msg.owner_lease_expires_at || null,
     imageOperationId: String(msg.image_operation_id || '').trim() || null,
-    ...(messageKind === RELAY_EVENT_MESSAGE_KIND ? { messageKind } : {}),
+    ...(isRelayAutomatedMessageKind(messageKind) ? { messageKind } : {}),
   };
 }