@opengeni/react 6.8.0 → 6.9.1-canary.41937124785001

package/src/app/lib/agent-capabilities.tsx

@@ -16,6 +16,7 @@ import {
   AGENT_CAPABILITY_IDS,
   allAgentCapabilities,
   noneAgentCapabilities,
+  savedRequestBaseCapabilities,
   type AgentCapabilities,
   type AgentCapabilityId,
   type AgentCapabilityStartingPoint,
@@ -38,7 +39,11 @@ export type AgentCapabilityGroup = {
 
 /** Three groups, in the order people scan them. Every capability appears once. */
 export const AGENT_CAPABILITY_GROUPS: readonly AgentCapabilityGroup[] = [
-  { id: "conversation", label: "Conversation", capabilities: ["humanInput", "webSearch", "media"] },
+  {
+    id: "conversation",
+    label: "Conversation",
+    capabilities: ["humanInput", "notifications", "webSearch", "media"],
+  },
   {
     id: "work",
     label: "Work",
@@ -53,6 +58,7 @@ export const AGENT_CAPABILITY_GROUPS: readonly AgentCapabilityGroup[] = [
       "workspaceFiles",
       "workspaceConnectors",
       "workspaceAdmin",
+      "privacyFacts",
     ],
   },
 ];
@@ -131,7 +137,16 @@ export function capabilityAvailability(
   };
 }
 
-export function baseCapabilities(from: AgentCapabilityStartingPoint): ResolvedAgentCapabilities {
+/**
+ * A request's starting capabilities. `saved` is a workspace default or a
+ * schedule's stored request, which keeps its earlier meaning (see
+ * `savedRequestBaseCapabilities`), matching the server.
+ */
+export function baseCapabilities(
+  from: AgentCapabilityStartingPoint,
+  options: { saved?: boolean | undefined } = {},
+): ResolvedAgentCapabilities {
+  if (options.saved) return savedRequestBaseCapabilities(from);
   return from === "all" ? allAgentCapabilities() : noneAgentCapabilities();
 }
 
@@ -151,6 +166,11 @@ function applyToggles(
     if (id === "skills") next.skills = value as AgentSkillsCapability;
     else next[id] = value as boolean;
   }
+  // Matches the server: turning human input off also turns notifications off
+  // unless the toggles name them.
+  if (toggles.humanInput === false && toggles.notifications === undefined) {
+    next.notifications = false;
+  }
   return next;
 }
 
@@ -161,7 +181,7 @@ function applyToggles(
  */
 export function draftFromRequest(
   capabilities: AgentCapabilities | undefined,
-  options: { legacyHumanInputOff?: boolean | undefined } = {},
+  options: { legacyHumanInputOff?: boolean | undefined; saved?: boolean | undefined } = {},
 ): AgentCapabilityDraft {
   const from: AgentCapabilityStartingPoint =
     capabilities === undefined
@@ -173,8 +193,11 @@ export function draftFromRequest(
     capabilities === undefined || typeof capabilities === "string"
       ? {}
       : (({ from: _from, ...rest }) => rest)(capabilities);
-  const values = applyToggles(baseCapabilities(from), toggles);
-  if (options.legacyHumanInputOff && toggles.humanInput === undefined) values.humanInput = false;
+  const values = applyToggles(baseCapabilities(from, { saved: options.saved }), toggles);
+  if (options.legacyHumanInputOff && toggles.humanInput === undefined) {
+    values.humanInput = false;
+    if (toggles.notifications === undefined) values.notifications = false;
+  }
   return { from, values };
 }
 
@@ -191,8 +214,9 @@ export function draftFromResolved(config: ResolvedAgentConfig): AgentCapabilityD
 export function requestFromDraft(
   draft: AgentCapabilityDraft,
   availability?: CapabilityAvailability,
+  options: { saved?: boolean | undefined } = {},
 ): AgentCapabilities {
-  const base = baseCapabilities(draft.from);
+  const base = baseCapabilities(draft.from, options);
   const toggles: AgentCapabilityToggles = {};
   for (const id of AGENT_CAPABILITY_IDS) {
     const value = draft.values[id];
@@ -264,7 +288,10 @@ export function workspaceAgentDefaultsDraft(input: {
   capabilities: AgentCapabilities | undefined;
   legacyHumanInputOff: boolean;
 }): AgentCapabilityDraft {
-  return draftFromRequest(input.capabilities, { legacyHumanInputOff: input.legacyHumanInputOff });
+  return draftFromRequest(input.capabilities, {
+    legacyHumanInputOff: input.legacyHumanInputOff,
+    saved: true,
+  });
 }
 
 /** Tool owner in product words, for the Technical details list. */

package/src/app/lib/session-branch-cache.tsx

@@ -42,6 +42,7 @@ export function sessionBranchSummaryKey(session: Session, readRevision = 0): str
     stats.queuedDescendants,
     stats.attentionDescendants,
     stats.pausedDescendants,
+    stats.pausedWorkDescendants ?? 0,
     stats.failedDescendants,
     stats.unreadFailedDescendants ?? stats.failedDescendants,
     stats.unreadDescendants ?? 0,

package/src/app/lib/session-pins.tsx

@@ -510,6 +510,7 @@ function sameTreeStats(a: SessionTreeStats | undefined, b: SessionTreeStats | un
     a.queuedDescendants === b.queuedDescendants &&
     a.attentionDescendants === b.attentionDescendants &&
     a.pausedDescendants === b.pausedDescendants &&
+    (a.pausedWorkDescendants ?? 0) === (b.pausedWorkDescendants ?? 0) &&
     a.failedDescendants === b.failedDescendants &&
     (a.unreadFailedDescendants ?? a.failedDescendants) ===
       (b.unreadFailedDescendants ?? b.failedDescendants) &&

package/src/app/lib/session-row-paused.test.tsx

@@ -0,0 +1,183 @@
+import { describe, expect, test } from "bun:test";
+import { renderToStaticMarkup } from "react-dom/server";
+
+import { RailTrailingMetadata } from "../components/rail/session-row-content";
+import { prunePinnedSubtrees, summarizeRailNodes, summarizeRailRow } from "./sessions-group";
+import type { Session } from "../types";
+
+/*
+ * Pause parks a chat's work for Resume. Its sidebar row shows a still pause
+ * mark instead of the working spinner, or nothing at all.
+ */
+
+function control(state: "active" | "paused"): Session["effectiveControl"] {
+  return {
+    state,
+    controlVersion: 0,
+    controlEtag: `${state}-0`,
+    directState: state,
+    primaryBlocker: null,
+    additionalBlockerCount: 0,
+    blockers: [],
+    resumeOptions: [],
+    override: null,
+    settlement: null,
+  } as Session["effectiveControl"];
+}
+
+function tree(overrides: Partial<NonNullable<Session["treeStats"]>> = {}): Session["treeStats"] {
+  return {
+    directChildren: 0,
+    totalDescendants: 0,
+    runningDescendants: 0,
+    queuedDescendants: 0,
+    waitingDescendants: 0,
+    attentionDescendants: 0,
+    pausedDescendants: 0,
+    failedDescendants: 0,
+    unreadDescendants: 0,
+    unreadFailedDescendants: 0,
+    truncated: false,
+    ...overrides,
+  } as Session["treeStats"];
+}
+
+function session(patch: Partial<Session> & Pick<Session, "id">): Session {
+  return {
+    accountId: "account-1",
+    workspaceId: "workspace-1",
+    status: "idle",
+    activeTurnId: null,
+    initialMessage: "hi",
+    title: null,
+    parentSessionId: null,
+    channelId: null,
+    pinned: false,
+    pinnedAt: null,
+    pinVersion: 0,
+    unread: false,
+    createdBy: { kind: "subject", subjectId: "user:test" },
+    effectiveControl: control("active"),
+    treeStats: tree(),
+    createdAt: "2026-11-02T12:00:00.000Z",
+    updatedAt: "2026-11-02T13:00:00.000Z",
+    ...patch,
+  } as Session;
+}
+
+const row = (value: Session) => ({ session: value, children: [], hasActiveDescendant: false });
+
+describe("a paused chat in the sidebar", () => {
+  test("its turn parked by Pause shows paused, not working", () => {
+    // Pause interrupts the running turn and parks it: idle, turn still open.
+    const parked = session({
+      id: "parked",
+      status: "idle",
+      activeTurnId: "turn-1",
+      effectiveControl: control("paused"),
+    });
+    expect(summarizeRailRow(row(parked))).toEqual({
+      kind: "paused",
+      count: 1,
+      total: 1,
+      label: "1 paused",
+    });
+  });
+
+  test("a running chat held by its parent's pause shows paused", () => {
+    const held = session({ id: "held", status: "queued", effectiveControl: control("paused") });
+    expect(summarizeRailRow(row(held)).kind).toBe("paused");
+  });
+
+  test("a paused chat with nothing in progress shows no marker", () => {
+    const done = session({ id: "done", status: "idle", effectiveControl: control("paused") });
+    expect(summarizeRailRow(row(done)).kind).toBe("neutral");
+  });
+
+  test("a paused chat waiting for input, or ending, shows no paused marker", () => {
+    const waiting = session({
+      id: "waiting",
+      status: "idle",
+      inputWait: { deadlineAt: "2026-11-02T14:00:00.000Z", reason: "sleep" },
+      effectiveControl: control("paused"),
+    });
+    expect(summarizeRailRow(row(waiting)).kind).not.toBe("paused");
+    for (const status of ["cancelled", "failed"] as const) {
+      const ending = session({
+        id: status,
+        status,
+        activeTurnId: "turn-1",
+        effectiveControl: control("paused"),
+      });
+      expect(summarizeRailRow(row(ending)).kind).not.toBe("paused");
+    }
+  });
+
+  test("a parent of paused workers shows them paused, and working ones first", () => {
+    const parent = session({
+      id: "manager",
+      treeStats: tree({
+        directChildren: 3,
+        totalDescendants: 3,
+        pausedDescendants: 3,
+        pausedWorkDescendants: 2,
+      }),
+    });
+    expect(summarizeRailNodes([row(parent)])).toMatchObject({ kind: "paused", label: "2 paused" });
+
+    const busy = session({
+      ...parent,
+      treeStats: tree({ ...parent.treeStats, runningDescendants: 1, totalDescendants: 4 }),
+    });
+    expect(summarizeRailNodes([row(busy)])).toMatchObject({ kind: "active", label: "1 working" });
+  });
+
+  test("an unread reply outranks paused workers but not the chat's own paused turn", () => {
+    const stats = tree({ directChildren: 1, totalDescendants: 1, pausedWorkDescendants: 1 });
+    const manager = session({ id: "manager", unread: true, treeStats: stats });
+    expect(summarizeRailRow(row(manager))).toMatchObject({
+      kind: "unread",
+      label: "1 unread · 1 paused",
+    });
+    const parked = session({
+      id: "parked",
+      unread: true,
+      activeTurnId: "turn-1",
+      effectiveControl: control("paused"),
+    });
+    expect(summarizeRailRow(row(parked)).kind).toBe("paused");
+  });
+
+  test("a pinned paused worker leaves its parent's paused count", () => {
+    const worker = session({
+      id: "worker",
+      parentSessionId: "manager",
+      pinned: true,
+      activeTurnId: "turn-1",
+      effectiveControl: control("paused"),
+    });
+    const manager = session({
+      id: "manager",
+      treeStats: tree({
+        directChildren: 1,
+        totalDescendants: 1,
+        pausedDescendants: 1,
+        pausedWorkDescendants: 1,
+      }),
+    });
+    const pruned = prunePinnedSubtrees({
+      session: manager,
+      children: [row(worker)],
+      hasActiveDescendant: false,
+    });
+    expect(pruned?.session.treeStats?.pausedWorkDescendants).toBe(0);
+  });
+
+  test("the marker is a still pause mark, never the spinner", () => {
+    const markup = renderToStaticMarkup(
+      <RailTrailingMetadata summary={{ kind: "paused", count: 1, total: 1, label: "1 paused" }} />,
+    );
+    expect(markup).toContain("data-og-rail-paused");
+    expect(markup).not.toContain("animate-spin");
+  });
+});

package/src/app/lib/sessions-group-channels.test.ts

@@ -285,7 +285,7 @@ describe("summarizeRailNodes", () => {
     });
   });
 
-  test("does not count a paused queued child as working", () => {
+  test("shows a paused queued child as paused, not working", () => {
     const forest = buildRailForest([
       session({ id: "root" }),
       session({
@@ -299,10 +299,10 @@ describe("summarizeRailNodes", () => {
 
     expect(forest.running).toEqual([]);
     expect(summarizeRailNodes(nodes)).toEqual({
-      kind: "neutral",
-      count: 0,
+      kind: "paused",
+      count: 1,
       total: 2,
-      label: "Read",
+      label: "1 paused",
     });
   });
 

package/src/app/lib/sessions-group.tsx

@@ -73,6 +73,7 @@ export type RailAggregateStatusKind =
   | "active"
   | "queued"
   | "waiting"
+  | "paused"
   | "unread"
   | "active_work"
   | "neutral";
@@ -103,6 +104,8 @@ export type RailStatusCounts = {
   queued: number;
   /** Idle sessions parked on their own wake-up (input or timer), not executing. */
   waiting: number;
+  /** Paused sessions whose work is parked for Resume. */
+  paused: number;
   unread: number;
   activeWork: number;
 };
@@ -122,6 +125,7 @@ export function sessionProjectTotals(
     active: 0,
     queued: 0,
     waiting: 0,
+    paused: 0,
     unread: 0,
     activeWork: 0,
   });
@@ -137,6 +141,7 @@ export function sessionProjectTotals(
       ...group,
       active: group.active - waiting,
       waiting,
+      paused: 0,
       sendFailed: 0,
     });
   }
@@ -173,11 +178,32 @@ function ownRailStatusCounts(
         ? 1
         : 0,
     waiting: sessionInputWait(session) ? 1 : 0,
+    paused: hasPausedWork(session) ? 1 : 0,
     unread: session.unread ? 1 : 0,
     activeWork: session.activelyWorking ? 1 : 0,
   };
 }
 
+/**
+ * Work a pause holds for Resume: a turn still open, queued or running. A
+ * paused chat with nothing in progress shows no marker, nor does one that
+ * needs the person or is ending (Cancel also pauses while the turn stops).
+ * Matches the server's `treeStats.pausedWorkDescendants`.
+ */
+function hasPausedWork(session: Session): boolean {
+  return (
+    !hasActiveEffectiveControl(session) &&
+    session.status !== "requires_action" &&
+    session.status !== "cancelled" &&
+    session.status !== "failed" &&
+    (Boolean(session.activeTurnId) ||
+      session.status === "running" ||
+      session.status === "recovering" ||
+      session.status === "queued" ||
+      session.status === "waiting_capacity")
+  );
+}
+
 function addRailStatusCounts(target: RailStatusCounts, source: RailStatusCounts): void {
   target.total += source.total;
   target.sendFailed += source.sendFailed;
@@ -187,6 +213,7 @@ function addRailStatusCounts(target: RailStatusCounts, source: RailStatusCounts)
   target.active += source.active;
   target.queued += source.queued;
   target.waiting += source.waiting;
+  target.paused += source.paused;
   target.unread += source.unread;
   target.activeWork += source.activeWork;
 }
@@ -211,6 +238,7 @@ function railStatusCounts(
       active: summary.active - waiting,
       queued: summary.queued,
       waiting,
+      paused: 0,
       unread: summary.unread,
       activeWork: summary.activeWork,
     };
@@ -225,6 +253,7 @@ function railStatusCounts(
       "active",
       "queued",
       "waiting",
+      "paused",
       "unread",
       "activeWork",
     ] as const)
@@ -244,6 +273,7 @@ function railStatusCounts(
     counts.active += stats.runningDescendants;
     counts.queued += stats.queuedDescendants;
     counts.waiting += stats.waitingDescendants ?? 0;
+    counts.paused += stats.pausedWorkDescendants ?? 0;
     counts.unread += stats.unreadDescendants ?? 0;
     counts.activeWork += stats.activelyWorkingDescendants ?? 0;
 
@@ -298,6 +328,7 @@ export function summarizeRailNodes(
     active: 0,
     queued: 0,
     waiting: 0,
+    paused: 0,
     unread: 0,
     activeWork: 0,
   };
@@ -318,8 +349,8 @@ export function summarizeRailNodes(
  * covers stays in its label ("1 unread · 2 working"), and an expanded row's
  * workers keep their own markers. The chat's own running or queued turn keeps
  * its spinner: progress it posts mid-turn can leave it unread, and the answer
- * arrives when that turn ends. Anything that needs you, a failure and an
- * unsent message still come first. Section headers and Site rows summarize
+ * arrives when that turn ends; its own paused turn likewise stays paused.
+ * Anything that needs you, a failure and an unsent message still come first. Section headers and Site rows summarize
  * many chats and keep the plain order.
  */
 export function summarizeRailRow(
@@ -330,10 +361,16 @@ export function summarizeRailRow(
   const counts = railStatusCounts(node, localDeliveryAttention);
   const summary = summarizeRailStatusCounts(counts, now);
   if (node.siteGroup || !node.session.unread) return summary;
-  if (summary.kind !== "active" && summary.kind !== "queued" && summary.kind !== "waiting")
+  if (
+    summary.kind !== "active" &&
+    summary.kind !== "queued" &&
+    summary.kind !== "waiting" &&
+    summary.kind !== "paused"
+  )
     return summary;
   const own = ownRailStatusCounts(node.session, localDeliveryAttention);
-  if (own.active > 0 || own.queued > 0) return summary;
+  if (own.active > 0 || own.queued > 0 || (summary.kind === "paused" && own.paused > 0))
+    return summary;
   return {
     kind: "unread",
     count: counts.unread,
@@ -402,6 +439,14 @@ export function summarizeRailStatusCounts(
       label: `${counts.waiting} waiting to resume`,
     };
   }
+  if (counts.paused > 0) {
+    return {
+      kind: "paused",
+      count: counts.paused,
+      total: counts.total,
+      label: `${counts.paused} paused`,
+    };
+  }
   if (counts.unread > 0) {
     return {
       kind: "unread",
@@ -1120,6 +1165,7 @@ type RemovedCounts = {
   waiting: number;
   attention: number;
   paused: number;
+  pausedWork: number;
   failed: number;
   unreadFailed: number;
   unread: number;
@@ -1134,6 +1180,7 @@ function emptyRemovedCounts(): RemovedCounts {
     waiting: 0,
     attention: 0,
     paused: 0,
+    pausedWork: 0,
     failed: 0,
     unreadFailed: 0,
     unread: 0,
@@ -1148,6 +1195,7 @@ function addRemovedCounts(target: RemovedCounts, source: RemovedCounts): void {
   target.waiting += source.waiting;
   target.attention += source.attention;
   target.paused += source.paused;
+  target.pausedWork += source.pausedWork;
   target.failed += source.failed;
   target.unreadFailed += source.unreadFailed;
   target.unread += source.unread;
@@ -1164,6 +1212,7 @@ function subtreeCounts(node: SessionTreeNode): RemovedCounts {
     waiting: sessionInputWait(node.session) ? 1 : 0,
     attention: awaitsPerson(node.session) ? 1 : 0,
     paused: node.session.effectiveControl?.state === "paused" ? 1 : 0,
+    pausedWork: hasPausedWork(node.session) ? 1 : 0,
     failed: status === "failed" ? 1 : 0,
     unreadFailed: status === "failed" && node.session.unread ? 1 : 0,
     unread: node.session.unread ? 1 : 0,
@@ -1177,6 +1226,7 @@ function subtreeCounts(node: SessionTreeNode): RemovedCounts {
     counts.waiting += stats.waitingDescendants ?? 0;
     counts.attention += stats.attentionDescendants;
     counts.paused += stats.pausedDescendants;
+    counts.pausedWork += stats.pausedWorkDescendants ?? 0;
     counts.failed += stats.failedDescendants;
     counts.unreadFailed += stats.unreadFailedDescendants ?? stats.failedDescendants;
     counts.unread += stats.unreadDescendants ?? 0;
@@ -1219,6 +1269,14 @@ function prunePinnedSubtreesWithCounts(
             : {}),
           attentionDescendants: Math.max(0, stats.attentionDescendants - removed.attention),
           pausedDescendants: Math.max(0, stats.pausedDescendants - removed.paused),
+          ...(stats.pausedWorkDescendants !== undefined
+            ? {
+                pausedWorkDescendants: Math.max(
+                  0,
+                  stats.pausedWorkDescendants - removed.pausedWork,
+                ),
+              }
+            : {}),
           failedDescendants: Math.max(0, stats.failedDescendants - removed.failed),
           ...(stats.unreadFailedDescendants !== undefined
             ? {