@oar-sh/oar 0.9.14 → 0.9.16

package/server/migrations/0023-relay-asks.mjs

@@ -0,0 +1,141 @@
+'use strict';
+
+/**
+ * Migration: questions that don't block (services/relay-ask-service.mjs).
+ *
+ * `relay_asks`: one row per question an agent asked the owner with
+ * remote_relay's `ask`. Not a `relay_questions` row: those belong to a turn
+ * (queue_id) that waits on them; an ask belongs to a session and blocks
+ * nothing.
+ *
+ * - `relay_id`: 'self' for an ask kept here (its session lives on this
+ *   relay); a paired relay's registry id for this relay's copy of an ask its
+ *   agent put on that relay (a mirror: `remote_id` is the ask's id there, and
+ *   this relay looks for the answer until it has it).
+ * - `conversation_id`: the session the ask is in (on that relay for a
+ *   mirror, `conversation_title` its title there).
+ * - `created_by`: the conversation here whose agent asked (NULL when a paired
+ *   relay's agent did; `creator_json` then names that relay and its
+ *   conversation, `{ relayId, relayName, conversationId, conversationTitle }`).
+ * - `question`, `options_json`, `recommendation`, `detail`, `urgency`
+ *   ('normal' | 'now'): as the agent wrote them, checked
+ *   (shared/relay-asks.mjs).
+ * - `status`: pending, answered, dismissed, withdrawn (by the agent that
+ *   asked), cancelled (its session was archived or deleted); `answer`,
+ *   `choice`, `answered_at`, `answered_via` (the relay whose Inbox it came
+ *   from, NULL for this relay's own UI).
+ * - `notified_at`: when the asking side was told the outcome (for a mirror:
+ *   when its creator here got question_answered).
+ *
+ * Additive and idempotent. Safe to run on every boot.
+ *
+ * Usage: node server/migrations/0023-relay-asks.mjs [path/to/copilot.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+
+export const RELAY_ASK_COLUMNS = Object.freeze([
+  'id',
+  'relay_id',
+  'remote_id',
+  'conversation_id',
+  'conversation_title',
+  'created_by',
+  'creator_json',
+  'question',
+  'options_json',
+  'recommendation',
+  'detail',
+  'urgency',
+  'status',
+  'answer',
+  'choice',
+  'answered_at',
+  'answered_via',
+  'notified_at',
+  'created_at',
+  'updated_at',
+]);
+
+function tableExists(db, name) {
+  return !!db
+    .prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`)
+    .get(name);
+}
+
+/** What keeps the service from using the table: '' when nothing does. */
+export function relayAsksTableProblem(db) {
+  if (!tableExists(db, 'relay_asks')) return 'no relay_asks table';
+  const present = new Set(db.prepare(`PRAGMA table_info(relay_asks)`).all().map((column) => column.name));
+  const missing = RELAY_ASK_COLUMNS.filter((name) => !present.has(name));
+  return missing.length ? `relay_asks lacks ${missing.join(', ')}` : '';
+}
+
+export function migrateRelayAsks(db) {
+  let tablesAdded = 0;
+  if (!tableExists(db, 'relay_asks')) {
+    db.exec(`
+      CREATE TABLE relay_asks (
+        id                  TEXT PRIMARY KEY,
+        relay_id            TEXT NOT NULL DEFAULT 'self',
+        remote_id           TEXT,
+        conversation_id     TEXT NOT NULL,
+        conversation_title  TEXT,
+        created_by          TEXT,
+        creator_json        TEXT,
+        question            TEXT NOT NULL,
+        options_json        TEXT,
+        recommendation      TEXT,
+        detail              TEXT,
+        urgency             TEXT NOT NULL DEFAULT 'normal' CHECK (urgency IN ('normal', 'now')),
+        status              TEXT NOT NULL DEFAULT 'pending'
+                            CHECK (status IN ('pending', 'answered', 'dismissed', 'withdrawn', 'cancelled')),
+        answer              TEXT,
+        choice              TEXT,
+        answered_at         TEXT,
+        answered_via        TEXT,
+        notified_at         TEXT,
+        created_at          TEXT NOT NULL,
+        updated_at          TEXT NOT NULL,
+        CHECK (relay_id = 'self' OR remote_id IS NOT NULL)
+      )
+    `);
+    tablesAdded += 1;
+  }
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_relay_asks_status ON relay_asks(relay_id, status, created_at)`);
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_relay_asks_conversation ON relay_asks(conversation_id, status)`);
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_relay_asks_creator ON relay_asks(created_by, status)`);
+  db.exec(`CREATE UNIQUE INDEX IF NOT EXISTS idx_relay_asks_remote ON relay_asks(relay_id, remote_id) WHERE remote_id IS NOT NULL`);
+  return { applied: tablesAdded > 0, tablesAdded };
+}
+
+function defaultDbPath() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, '..', 'data', 'copilot.db');
+}
+
+export function migrate(dbPath, options = {}) {
+  const db = new Database(dbPath, options);
+  try {
+    return migrateRelayAsks(db);
+  } finally {
+    db.close();
+  }
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  const dbPath = process.argv[2] ? path.resolve(process.argv[2]) : defaultDbPath();
+  try {
+    const result = migrate(dbPath);
+    console.log(`Migration 0023 on ${dbPath}`);
+    console.log(result.applied ? `  relay asks: tables added ${result.tablesAdded}` : '  skipped: nothing to change');
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0023 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}

package/server/public/app/ask-user-view.js

@@ -16,6 +16,7 @@ import { isChatInteractionHeld } from './selection-guard.mjs';
 import { questionCardHeadLabel } from './conversation-provider-indicator.mjs';
 import { questionAcceptsFreeText } from './question-answer-rule.mjs';
 import { beginOwnSend, followsTranscriptEnd, refreshJumpButton, scrollAfterOwnSend } from './transcript-jump-bottom-view.mjs';
+import { renderSessionAskCards } from './inbox-ui.js';
 
 let relayQuestionRenderHash = '';
 let renderedRelayQuestionIds = new Set();
@@ -215,6 +216,8 @@ function scrollQuestionCardIntoMessages(el, target) {
 export function renderRelayQuestions() {
   const el = document.getElementById('messages');
   if (!el) return;
+  // The questions that don't block go first: the cards a turn waits on stay last.
+  renderSessionAskCards();
   const previousScrollTop = el.scrollTop;
   // A card is shown to a reader who is at the end. Anyone further up stays
   // where they are; the jump-to-bottom button says that a question waits.

package/server/public/app/bootstrap.js

@@ -238,6 +238,7 @@ import { initScrollbarHover } from './scrollbar-hover.mjs';
 import {
   autoCompactWindowNotes,
   renderAutoCompactControlHtml,
+  renderAgentSessionsControlHtml,
   renderAutoCompactNotesHtml,
   renderContextUsageHtml,
   renderThinkingControlHtml,
@@ -401,6 +402,8 @@ import { openStopSharingConfirmation } from './shared-conversations-settings.js'
 import { showAbout, syncAboutMenuLabel } from './about-ui.js';
 import { syncConversationOriginHeader } from './conversation-origin-ui.js';
 import { loadRelayEventSubscriptions, onRelayEventSubscriptionsChanged, syncRelayEventHeader } from './relay-event-subscriptions-ui.js';
+import { loadRelaySchedules, onRelaySchedulesChanged, syncRelayScheduleHeader } from './relay-schedules-ui.js';
+import { leaveInboxView, startInbox, toggleInboxView } from './inbox-ui.js';
 import {
   previewAgentSessionsMaxWait,
   saveAgentSessionsMaxWait,
@@ -3346,6 +3349,41 @@ function initAttributionControl() {
   });
 }
 
+// The owner's "agents in this conversation may start sessions" in the 🧠
+// modal: one request per change; the store follows the answer (other tabs
+// follow the socket event).
+let agentSessionsControlUpdateInFlight = false;
+function initAgentSessionsControl() {
+  const body = document.getElementById('summary-modal-body');
+  if (!body || body.dataset.agentSessionsControlBound === 'true') return;
+  body.dataset.agentSessionsControlBound = 'true';
+  body.addEventListener('change', async (event) => {
+    const box = event.target?.closest?.('#ctx-may-create-sessions');
+    if (!box) return;
+    const convId = String(box.dataset.conversationId || '').trim();
+    if (!convId || agentSessionsControlUpdateInFlight) return;
+    const wanted = box.checked === true;
+    agentSessionsControlUpdateInFlight = true;
+    box.disabled = true;
+    try {
+      const response = await updateConversationPreferences(convId, { clientId: CLIENT_ID, mayCreateSessions: wanted });
+      if (!response) throw new Error('The relay refused the change');
+      const stored = response.mayCreateSessions === true;
+      if (conversations[convId]) conversations[convId] = { ...conversations[convId], mayCreateSessions: stored };
+      box.checked = stored;
+      showTransientRelayNotice(stored
+        ? 'Agents in this conversation may now start sessions.'
+        : 'Agents in this conversation can no longer start sessions.');
+    } catch (error) {
+      box.checked = !wanted;
+      showTransientRelayNotice(`Could not change the setting: ${error?.message || error}`);
+    } finally {
+      box.disabled = false;
+      agentSessionsControlUpdateInFlight = false;
+    }
+  });
+}
+
 function initThinkingControl() {
   const body = document.getElementById('summary-modal-body');
   if (!body || body.dataset.thinkingBound === '1') return;
@@ -3511,14 +3549,21 @@ async function loadContextSummaryAndRender(convId) {
     enabled: payload.thinkingEnabled !== false,
     display: payload.thinkingDisplay || 'summarized',
   };
+  // For a session an agent started (any provider): may its agents start
+  // sessions? Only meaningful there, so only shown there.
+  const settingsConversationId = String(payload.resolvedConversationId || trimmedConvId || '').trim();
+  const settingsConversation = settingsConversationId ? conversations[settingsConversationId] : null;
+  const agentSessionsHtml = settingsConversation?.origin
+    ? renderAgentSessionsControlHtml({ conversationId: settingsConversationId, mayCreateSessions: settingsConversation.mayCreateSessions === true })
+    : '';
   const detailText = String(payload.text || '').trim();
   // The structured breakdown is the answer; the runtime's own text dump stays
   // available underneath for the details it carries that categories don't.
   const bodyHtml = usageHtml
-    ? `${usageHtml}${autoCompactHtml}${thinkingHtml}${attributionHtml}${detailText
+    ? `${usageHtml}${autoCompactHtml}${thinkingHtml}${attributionHtml}${agentSessionsHtml}${detailText
       ? `<details class="ctx-usage-raw"><summary>Raw details</summary><pre>${escHtml(detailText)}</pre></details>`
       : ''}`
-    : `${autoCompactHtml}${thinkingHtml}${attributionHtml}<pre>${escHtml(detailText || 'No context data available.')}</pre>`;
+    : `${autoCompactHtml}${thinkingHtml}${attributionHtml}${agentSessionsHtml}<pre>${escHtml(detailText || 'No context data available.')}</pre>`;
 
   renderSummaryModalContent({
     title: 'Context usage',
@@ -4387,6 +4432,8 @@ function syncChatTitleControls() {
   syncConversationOriginHeader();
   // Relay events: "watching N sessions" on a watcher, "watched" on a watched one.
   syncRelayEventHeader();
+  // Relay schedules: "N scheduled" with its list and Cancel buttons.
+  syncRelayScheduleHeader();
   syncChatTitleWatcherIndicator();
 }
 
@@ -4884,6 +4931,7 @@ async function initApp() {
   initAutoCompactWindowControl();
   initThinkingControl();
   initAttributionControl();
+  initAgentSessionsControl();
   initModeSelector();
   initModelSelector();
   initReasoningSelector();
@@ -4965,6 +5013,11 @@ async function initApp() {
   // The sidebar's "watched" badges follow the subscriptions.
   onRelayEventSubscriptionsChanged(() => renderConvList());
   void loadRelayEventSubscriptions();
+  // The sidebar's "scheduled" markers follow the schedules.
+  onRelaySchedulesChanged(() => renderConvList());
+  void loadRelaySchedules();
+  // The Inbox's count, and the cards of questions that don't block.
+  startInbox();
   const pushConversationId = consumePushConversationDeepLink();
   if (pushConversationId) {
     await openConversation(pushConversationId).catch(() => {});
@@ -5165,7 +5218,12 @@ window.toggleArchivedConversations = toggleArchivedConversations;
 window.refreshNewConversationCloudRepoList = refreshNewConversationCloudRepoList;
 window.openConversation = openConversation;
 window.openOriginConversation = openOriginConversation;
-window.toggleStatusView = toggleStatusView;
+// The Inbox and Status share the transcript's place: opening one leaves the other.
+window.toggleStatusView = () => {
+  leaveInboxView();
+  return toggleStatusView();
+};
+window.toggleInboxView = toggleInboxView;
 window.refreshConversations = refreshConversations;
 window.renderConvList = renderConvList;
 window.handleAttachmentInput = handleAttachmentInput;

package/server/public/app/context-usage-view.mjs

@@ -350,6 +350,23 @@ ${renderThinkingButtons('display', THINKING_DISPLAY_CHOICES, displayKey)}
   `;
 }
 
+/**
+ * The owner's switch for a session an agent started: may its agents start
+ * sessions themselves (the remote_relay tool's one-level rule lifted for it)?
+ * Only the owner sets it; no agent can.
+ */
+export function renderAgentSessionsControlHtml({ conversationId = '', mayCreateSessions = false } = {}) {
+  return `
+    <div class="ctx-agent-sessions">
+      <label class="ctx-agent-sessions-row">
+        <input type="checkbox" id="ctx-may-create-sessions" data-conversation-id="${escapeHtml(conversationId)}"${mayCreateSessions === true ? ' checked' : ''}>
+        <span>Agents in this conversation may start sessions (even though an agent started it)</span>
+      </label>
+      <div class="ctx-thinking-note">An agent started this session, so its agents cannot start sessions of their own unless you allow it here. The limit of sessions at work, your Allow for the first one and the relay's "Agents may start and use sessions" setting still apply.</div>
+    </div>
+  `;
+}
+
 // A model limit is a round figure: 1M rather than 1.0M.
 function formatModelLimit(value) {
   const n = toNullableNumber(value);

package/server/public/app/conversation-group-order.mjs

@@ -210,12 +210,47 @@ export function pageConversationRows(rows, groups = null, { limit = 40, beforeCo
  * `isOpen(groupId, group)` decides the fold; `matches(row)` keeps rows that
  * match a filter (a group shows when any row matches: its head as context
  * with the matching members, or whole when the head or its name matches).
+ *
+ * With `emptyGroups`, an owner's group an agent emptied (`keptEmptyAt`, no
+ * row here) shows too: a head item without members (`group.empty`), placed
+ * by the time it was emptied; under a filter only when its name matches.
  */
 export function arrangeConversationList(rows, groups = null, {
   isOpen = () => true,
   matches = null,
   groupNameMatches = null,
+  emptyGroups = false,
 } = {}) {
+  const items = arrangeGroupedRows(rows, groups, { isOpen, matches, groupNameMatches });
+  if (!emptyGroups || !groups) return items;
+  const present = new Set((Array.isArray(rows) ? rows : []).map(rowGroupId).filter(Boolean));
+  const entries = typeof groups.entries === 'function' && typeof groups.get === 'function' ? [...groups.entries()] : Object.entries(groups);
+  const kept = entries
+    .map(([id, info]) => ({ id: toText(id), info }))
+    .filter(({ id, info }) => id && toText(info?.keptEmptyAt) && !present.has(id))
+    .filter(({ info }) => !matches || (typeof groupNameMatches === 'function' && groupNameMatches(info, null)))
+    .map(({ id, info }) => ({
+      kind: 'head',
+      conversation: null,
+      group: { id, info, head: null, members: [], activityMs: parseConversationTimeMs(info.keptEmptyAt), open: false, contextOnly: false, empty: true },
+    }))
+    .sort((a, b) => (b.group.activityMs - a.group.activityMs) || b.group.id.localeCompare(a.group.id));
+  if (!kept.length) return items;
+  // Merged in by time, before the first row or group that is older.
+  const timeOf = (item) => (item.kind === 'head' ? item.group.activityMs : rowOwnTimeMs(item.conversation));
+  const out = [];
+  let next = 0;
+  for (const item of items) {
+    if (item.kind !== 'member') {
+      while (next < kept.length && kept[next].group.activityMs > timeOf(item)) out.push(kept[next++]);
+    }
+    out.push(item);
+  }
+  while (next < kept.length) out.push(kept[next++]);
+  return out;
+}
+
+function arrangeGroupedRows(rows, groups, { isOpen, matches, groupNameMatches }) {
   const ordered = orderConversationRows(rows, groups);
   const activity = groupActivityTimes(ordered);
   const items = [];