@desplega.ai/agent-swarm 2.3.0 → 2.4.1

package/src/be/db.ts

@@ -10,7 +10,7 @@ import {
 import { realtimeBus } from "../realtime/bus";
 import { slackChannelFromContextKey } from "../tasks/slack-routing";
 import { _resolveIntegrationType, emitIntegrationConnected, telemetry } from "../telemetry";
-import { scheduleOrgDomainRecompute } from "../telemetry-identity";
+import { invalidateTelemetryUserRole, scheduleOrgDomainRecompute } from "../telemetry-identity";
 import {
   emitTaskTelemetry,
   type TaskTelemetryEvent,
@@ -195,6 +195,7 @@ import {
 } from "./db/context-versions";
 import { clearAgentModelProfileOnOverrideChange } from "./db/model-profiles";
 import { getDb, getDbClient } from "./db/runtime";
+import { type SessionViewer, sessionViewerCondition } from "./db/session-visibility";
 import { classifyTaskHumanFree, reclassifyTaskHumanFree } from "./db/tasks/human-free";
 import {
   type AgentTaskRow,
@@ -203,6 +204,7 @@ import {
   findExistingLinearTrackerContextWork,
   getTaskById,
   getTasksByAgentId,
+  readableSessionCondition,
   rowToAgentTask,
   rowToAgentTaskSummary,
 } from "./db/tasks/read";
@@ -2081,13 +2083,17 @@ export async function getPendingSteeringForTask(taskId: string): Promise<Steerin
   return await getSteeringMessagesForTask(taskId, { status: "pending" });
 }
 
-export async function getPendingSteeringForAgent(agentId: string): Promise<SteeringMessage[]> {
+export async function getPendingSteeringForAgent(
+  agentId: string,
+  readableBy?: { userId: string | null },
+): Promise<SteeringMessage[]> {
+  const readable = readableBy ? readableSessionCondition(readableBy.userId, "t.id") : undefined;
   const rows = await getDbClient().query<TaskSteeringMessageRow>(
     `${STEERING_MESSAGE_SELECT}
        JOIN agent_tasks t ON t.id = m.task_id
-       WHERE t.agentId = ? AND m.status = 'pending'
+       WHERE t.agentId = ? AND m.status = 'pending'${readable ? ` AND ${readable.sql}` : ""}
        ORDER BY m.created_at ASC, m.rowid ASC`,
-    [agentId],
+    [agentId, ...(readable?.params ?? [])],
   );
   return rows.map(rowToSteeringMessage);
 }
@@ -2185,27 +2191,33 @@ export async function hasPendingSteering(taskId: string): Promise<boolean> {
 // Combined Queries (Agent with Tasks)
 // ============================================================================
 
-export async function getAgentWithTasks(id: string): Promise<AgentWithTasks | null> {
+export async function getAgentWithTasks(
+  id: string,
+  readableBy?: { userId: string | null },
+): Promise<AgentWithTasks | null> {
   return await getDbClient().transaction(
     async () => {
       const agent = await getAgentById(id);
       if (!agent) return null;
 
-      const tasks = await getTasksByAgentId(id);
+      const tasks = await getTasksByAgentId(id, readableBy);
       return { ...agent, tasks };
     },
     { readOnly: true },
   );
 }
 
-export async function getAllAgentsWithTasks(opts?: { slim?: boolean }): Promise<AgentWithTasks[]> {
+export async function getAllAgentsWithTasks(opts?: {
+  slim?: boolean;
+  readableBy?: { userId: string | null };
+}): Promise<AgentWithTasks[]> {
   return await getDbClient().transaction(
     async () => {
       const agents = await getAllAgents({ slim: opts?.slim ?? false });
       return await Promise.all(
         agents.map(async (agent) => ({
           ...agent,
-          tasks: await getTasksByAgentId(agent.id),
+          tasks: await getTasksByAgentId(agent.id, opts?.readableBy),
         })),
       );
     },
@@ -2268,10 +2280,16 @@ export async function createLogEntry(entry: {
   return rowToAgentLog(row);
 }
 
-export async function getLogsByAgentId(agentId: string): Promise<AgentLog[]> {
+export async function getLogsByAgentId(
+  agentId: string,
+  readableBy?: { userId: string | null },
+): Promise<AgentLog[]> {
+  const readable = readableBy
+    ? readableSessionCondition(readableBy.userId, "agent_log.taskId", { nullable: true })
+    : undefined;
   const rows = await getDbClient().query<AgentLogRow>(
-    "SELECT * FROM agent_log WHERE agentId = ? ORDER BY createdAt DESC",
-    [agentId],
+    `SELECT * FROM agent_log WHERE agentId = ?${readable ? ` AND ${readable.sql}` : ""} ORDER BY createdAt DESC`,
+    [agentId, ...(readable?.params ?? [])],
   );
   return rows.map(rowToAgentLog);
 }
@@ -2315,16 +2333,24 @@ export async function getLogsByEventType(eventType: AgentLogEventType): Promise<
   return rows.map(rowToAgentLog);
 }
 
-export async function getAllLogs(limit?: number): Promise<AgentLog[]> {
+export async function getAllLogs(
+  limit?: number,
+  readableBy?: { userId: string | null },
+): Promise<AgentLog[]> {
+  const readable = readableBy
+    ? readableSessionCondition(readableBy.userId, "agent_log.taskId", { nullable: true })
+    : undefined;
+  const readableParams = readable?.params ?? [];
   if (limit) {
     const rows = await getDbClient().query<AgentLogRow>(
-      "SELECT * FROM agent_log WHERE eventType != 'agent_status_change' ORDER BY createdAt DESC LIMIT ?",
-      [limit],
+      `SELECT * FROM agent_log WHERE eventType != 'agent_status_change'${readable ? ` AND ${readable.sql}` : ""} ORDER BY createdAt DESC LIMIT ?`,
+      [...readableParams, limit],
     );
     return rows.map(rowToAgentLog);
   }
   const rows = await getDbClient().query<AgentLogRow>(
-    "SELECT * FROM agent_log ORDER BY createdAt DESC",
+    `SELECT * FROM agent_log${readable ? ` WHERE ${readable.sql}` : ""} ORDER BY createdAt DESC`,
+    readableParams,
   );
   return rows.map(rowToAgentLog);
 }
@@ -5820,8 +5846,13 @@ export interface ConcurrentContext {
  * Returns processing inbox messages, recent task delegations by leads,
  * and currently active (in-progress) tasks across the swarm.
  */
-export async function getConcurrentContext(): Promise<ConcurrentContext> {
+export async function getConcurrentContext(readableBy?: {
+  userId: string | null;
+}): Promise<ConcurrentContext> {
   const client = getDbClient();
+  const readable = readableBy ? readableSessionCondition(readableBy.userId, "t.id") : undefined;
+  const readableSql = readable ? ` AND ${readable.sql}` : "";
+  const readableParams = readable?.params ?? [];
 
   // 1. Inbox messages currently being processed (status = 'processing')
   const processingInboxMessages = await client.query<{
@@ -5850,9 +5881,9 @@ export async function getConcurrentContext(): Promise<ConcurrentContext> {
        FROM agent_tasks t
        LEFT JOIN agents a ON t.agentId = a.id
        WHERE t.createdAt > ?
-         AND t.creatorAgentId IN (SELECT id FROM agents WHERE isLead = 1)
+         AND t.creatorAgentId IN (SELECT id FROM agents WHERE isLead = 1)${readableSql}
        ORDER BY t.createdAt DESC`,
-    [fiveMinutesAgo],
+    [fiveMinutesAgo, ...readableParams],
   );
 
   // 3. Currently in-progress tasks across the swarm
@@ -5868,8 +5899,9 @@ export async function getConcurrentContext(): Promise<ConcurrentContext> {
     `SELECT t.id, t.task, t.agentId, a.name as agentName, t.status, t.createdAt, t.progress
        FROM agent_tasks t
        LEFT JOIN agents a ON t.agentId = a.id
-       WHERE t.status = 'in_progress'
+       WHERE t.status = 'in_progress'${readableSql}
        ORDER BY t.createdAt DESC`,
+    readableParams,
   );
 
   return {
@@ -7157,15 +7189,27 @@ export async function deleteActiveSessionById(id: string): Promise<boolean> {
   return result.changes > 0;
 }
 
-export async function getActiveSessions(agentId?: string): Promise<ActiveSession[]> {
+export async function getActiveSessions(
+  agentId?: string,
+  readableBy?: { userId: string | null },
+): Promise<ActiveSession[]> {
+  const conditions: string[] = [];
+  const params: string[] = [];
   if (agentId) {
-    return await getDbClient().query<ActiveSession>(
-      "SELECT * FROM active_sessions WHERE agentId = ? ORDER BY startedAt DESC",
-      [agentId],
-    );
+    conditions.push("agentId = ?");
+    params.push(agentId);
+  }
+  if (readableBy) {
+    const readable = readableSessionCondition(readableBy.userId, "active_sessions.taskId", {
+      nullable: true,
+    });
+    conditions.push(readable.sql);
+    params.push(...readable.params);
   }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
   return await getDbClient().query<ActiveSession>(
-    "SELECT * FROM active_sessions ORDER BY startedAt DESC",
+    `SELECT * FROM active_sessions ${where} ORDER BY startedAt DESC`,
+    params,
   );
 }
 
@@ -12310,7 +12354,7 @@ export async function updateUser(
   id: string,
   data: Partial<{
     name: string;
-    email: string;
+    email: string | null;
     role: string;
     notes: string;
     emailAliases: string[];
@@ -12375,7 +12419,12 @@ export async function updateUser(
     `UPDATE users SET ${sets.join(", ")} WHERE id = ? RETURNING *`,
     params,
   );
-  if (row) getDbClient().afterCommit(scheduleOrgDomainRecompute);
+  if (row) {
+    getDbClient().afterCommit(() => {
+      invalidateTelemetryUserRole(id);
+      scheduleOrgDomainRecompute();
+    });
+  }
   return row ? rowToUser(row) : null;
 }
 
@@ -12512,7 +12561,12 @@ export async function deleteUser(id: string, replacementUserId?: string): Promis
     await reclassifyTaskHumanFree(reclassifySeedIds);
 
     const result = await tx.run("DELETE FROM users WHERE id = ?", [id]);
-    if (result.changes > 0) getDbClient().afterCommit(scheduleOrgDomainRecompute);
+    if (result.changes > 0) {
+      getDbClient().afterCommit(() => {
+        invalidateTelemetryUserRole(id);
+        scheduleOrgDomainRecompute();
+      });
+    }
     return result.changes > 0;
   });
 }
@@ -12905,6 +12959,8 @@ interface ListRecentSessionsOpts {
   contextKeyPrefix?: string;
   /** When true, return slim `SessionListItemSummary` rows (default: full). */
   slim?: boolean;
+  /** Restrict to sessions this viewer may open (session sharing). */
+  viewer?: SessionViewer;
 }
 
 export async function listRecentSessions(
@@ -12923,7 +12979,7 @@ export async function listRecentSessions(
   const requestedByUserId = opts?.requestedByUserId?.trim() || undefined;
 
   const conditions: string[] = ["r.parentTaskId IS NULL"];
-  const params: (string | number)[] = [];
+  const params: (string | number | null)[] = [];
 
   if (sources.length > 0) {
     conditions.push(`r.source IN (${sources.map(() => "?").join(", ")})`);
@@ -12942,6 +12998,11 @@ export async function listRecentSessions(
     conditions.push(`r.contextKey LIKE ? ESCAPE '\\'`);
     params.push(literalPrefixPattern(opts.contextKeyPrefix));
   }
+  if (opts?.viewer) {
+    const viewer = sessionViewerCondition(opts.viewer);
+    conditions.push(viewer.sql);
+    params.push(...viewer.params);
+  }
   params.push(limit, offset);
 
   const rootRows = await getDbClient().query<
@@ -13013,35 +13074,43 @@ export async function listRecentSessions(
  * a plain count, no recursive chain walk needed.
  */
 export async function countSessions(
-  opts?: Pick<ListRecentSessionsOpts, "source" | "q" | "requestedByUserId" | "contextKeyPrefix">,
+  opts?: Pick<
+    ListRecentSessionsOpts,
+    "source" | "q" | "requestedByUserId" | "contextKeyPrefix" | "viewer"
+  >,
 ): Promise<number> {
   const sources = opts?.source?.filter((s) => s.length > 0) ?? [];
   const q = opts?.q?.trim();
   const requestedByUserId = opts?.requestedByUserId?.trim() || undefined;
 
-  const conditions: string[] = ["parentTaskId IS NULL"];
-  const params: string[] = [];
+  const conditions: string[] = ["r.parentTaskId IS NULL"];
+  const params: (string | null)[] = [];
 
   if (sources.length > 0) {
-    conditions.push(`source IN (${sources.map(() => "?").join(", ")})`);
+    conditions.push(`r.source IN (${sources.map(() => "?").join(", ")})`);
     params.push(...sources);
   }
   if (q && q.length > 0) {
-    conditions.push("(lower(task) LIKE ? OR lower(COALESCE(title, '')) LIKE ?)");
+    conditions.push("(lower(r.task) LIKE ? OR lower(COALESCE(r.title, '')) LIKE ?)");
     const like = `%${q.toLowerCase()}%`;
     params.push(like, like);
   }
   if (requestedByUserId) {
-    conditions.push("requestedByUserId = ?");
+    conditions.push("r.requestedByUserId = ?");
     params.push(requestedByUserId);
   }
   if (opts?.contextKeyPrefix) {
-    conditions.push(`contextKey LIKE ? ESCAPE '\\'`);
+    conditions.push(`r.contextKey LIKE ? ESCAPE '\\'`);
     params.push(literalPrefixPattern(opts.contextKeyPrefix));
   }
+  if (opts?.viewer) {
+    const viewer = sessionViewerCondition(opts.viewer);
+    conditions.push(viewer.sql);
+    params.push(...viewer.params);
+  }
 
   const row = await getDbClient().get<{ count: number }>(
-    `SELECT COUNT(*) AS count FROM agent_tasks WHERE ${conditions.join(" AND ")}`,
+    `SELECT COUNT(*) AS count FROM agent_tasks r WHERE ${conditions.join(" AND ")}`,
     params,
   );
   return row?.count ?? 0;

package/src/be/events.ts

@@ -1,6 +1,7 @@
 import type { EventCategory, EventName, EventSource, EventStatus, SwarmEvent } from "../types";
 import { type ScrubbedText, scrubObject, scrubSecrets } from "../utils/secret-scrubber";
 import { getDbClient } from "./db";
+import { readableSessionCondition } from "./db/tasks/read";
 import type { DbExecutor } from "./db-client";
 import { breaksJsonValidity } from "./scrub-json";
 import { recordSkillInvocation } from "./skill-invocations";
@@ -262,10 +263,20 @@ export async function getEventsFiltered(filters: {
    * the agent's event history.
    */
   latestPerDataField?: { events: EventName[]; dataFields: string[] };
+  /** Only events outside sessions this user may not read; `userId: null` is a guest. */
+  readableBy?: { userId: string | null };
 }): Promise<SwarmEvent[]> {
   const conditions: string[] = [];
   const params: (string | number)[] = [];
 
+  if (filters.readableBy) {
+    const readable = readableSessionCondition(filters.readableBy.userId, "events.taskId", {
+      nullable: true,
+    });
+    conditions.push(readable.sql);
+    params.push(...readable.params);
+  }
+
   if (filters.category) {
     conditions.push("category = ?");
     params.push(filters.category);

package/src/be/fleet-benchmark-stats.ts

@@ -5,15 +5,20 @@
  * registered agent count (the same count `org.snapshot` reports as
  * `agents_total`).
  *
- * Null when that start is unknown: no accepted event is recorded yet, or the
- * earliest one is inside the window.
+ * Comparisons require a known ingest start. With telemetry off, callers can
+ * use the local 30-day window without an ingest anchor.
  */
-import { fleetCountStart, type LocalFleetStats } from "../fleet-benchmark";
+import { FLEET_WINDOW_DAYS, fleetCountStart, type LocalFleetStats } from "../fleet-benchmark";
 import { getDbClient } from "./db/runtime";
 import { getTelemetryIngestAnchor } from "./telemetry-ingest-anchor";
 
-export async function getLocalFleetStats(now = new Date()): Promise<LocalFleetStats | null> {
-  const start = fleetCountStart(await getTelemetryIngestAnchor(), now);
+export async function getLocalFleetStats(
+  now = new Date(),
+  { requireIngestAnchor = true } = {},
+): Promise<LocalFleetStats | null> {
+  const start = requireIngestAnchor
+    ? fleetCountStart(await getTelemetryIngestAnchor(), now)
+    : new Date(now.getTime() - FLEET_WINDOW_DAYS * 86_400_000);
   if (!start) return null;
   const since = start.toISOString();
   const client = getDbClient();

package/src/be/migrations/230_session_shares.sql

@@ -0,0 +1,23 @@
+-- Session sharing. A session is a root task (parentTaskId IS NULL) plus its
+-- descendants. A root with no active row stays private to its owner
+-- (agent_tasks.requestedByUserId); a root with no owner stays open to all.
+--
+-- Rows are never deleted: revoking sets revokedAt/revokedBy, and an access
+-- change revokes the active row and inserts a new one in one transaction, so
+-- every row for a root is its share history. userId NULL means everyone.
+CREATE TABLE session_shares (
+  id TEXT PRIMARY KEY,
+  rootTaskId TEXT NOT NULL REFERENCES agent_tasks(id) ON DELETE CASCADE,
+  userId TEXT REFERENCES users(id),
+  access TEXT NOT NULL CHECK (access IN ('read', 'write')),
+  createdAt TEXT NOT NULL,
+  revokedAt TEXT,
+  revokedBy TEXT REFERENCES users(id),
+  created_by TEXT REFERENCES users(id),
+  updated_by TEXT REFERENCES users(id)
+);
+
+-- At most one active row per (root, target); revoked rows pile up beside it.
+CREATE UNIQUE INDEX session_shares_active
+  ON session_shares(rootTaskId, COALESCE(userId, '*')) WHERE revokedAt IS NULL;
+CREATE INDEX session_shares_user ON session_shares(userId) WHERE revokedAt IS NULL;

package/src/be/models-catalog.ts

@@ -27,6 +27,10 @@ export const CATALOG_PROVIDER_IDS = [
   "openai",
   "amazon-bedrock",
   "opencode",
+  // OpenCode Go is opencode's first-party subscription provider, a sibling of
+  // its Zen section (`opencode`). models.dev lists it, so projecting it gives
+  // `opencode-go/<model>` ids their context window and reasoning facts.
+  "opencode-go",
   ...openAICompatibleProviderIds(),
 ] as const;
 

package/src/be/onboarding.ts

@@ -498,6 +498,12 @@ function deriveState(
   if (state.steps.connect.status !== "done") {
     changed = completeStep(state, "connect", "api_key", true, events) || changed;
   }
+  // A name saved anywhere (setup, the org-name popup, Settings, the API) names
+  // the swarm. The old setup default "Your Swarm" does not count.
+  const orgName = process.env.SWARM_ORG_NAME?.trim();
+  if (state.steps.name.status !== "done" && orgName && orgName !== "Your Swarm") {
+    changed = completeStep(state, "name", "custom_name", true, events) || changed;
+  }
   if (
     state.steps.ai.status !== "done" &&
     signals.providers.some((entry) => entry.state === "verified")

package/src/be/rbac-roles.ts

@@ -35,6 +35,8 @@ export const BUILTIN_ROLES = [
       "task.action.own",
       "task.fs.mutate",
       "favorite.write.own",
+      "session.share",
+      "session.presence",
     ],
   },
 ] satisfies (BuiltinRoleDefinition & { isBuiltin: true })[];

package/src/be/scripts/typecheck.ts

@@ -419,6 +419,19 @@ export interface SwarmSdk {
     query: string;
     params?: Record<string, string | number | boolean>;
   }): Promise<unknown>;
+  app_rows_list(args: {
+    appId: string;
+    model: string;
+    equals?: Record<string, string | number | boolean>;
+    sort?: \`\${string}:asc\` | \`\${string}:desc\`;
+    limit?: number;
+  }): Promise<unknown>;
+  app_row_get(args: { appId: string; model: string; rowId: string }): Promise<unknown>;
+  app_row_create(args: { appId: string; model: string; values: Record<string, unknown> }): Promise<unknown>;
+  app_rows_create(args: { appId: string; model: string; rows: Record<string, unknown>[] }): Promise<unknown>;
+  app_row_patch(args: { appId: string; model: string; rowId: string; values: Record<string, unknown> }): Promise<unknown>;
+  app_row_delete(args: { appId: string; model: string; rowId: string }): Promise<unknown>;
+  app_rows_delete(args: { appId: string; model: string; equals: Record<string, string | number | boolean>; limit?: number }): Promise<unknown>;
   app_rollback(args: {
     appId: string;
     version: number;