@desplega.ai/agent-swarm 2.2.0 → 2.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@desplega.ai/agent-swarm",
-  "version": "2.2.0",
+  "version": "2.4.0",
   "description": "agent-swarm.dev — an open-source operating system for AI work: a lead agent breaks goals into tasks, routes them to specialized workers such as Claude Code or Codex, runs each worker in an isolated container, and preserves shared memory, tools, schedules, and review gates so delegated work compounds across sessions.",
   "keywords": [
     "agent-swarm.dev",
@@ -209,7 +209,7 @@
     "@chat-adapter/teams": "4.41.1",
     "@chat-adapter/telegram": "4.41.1",
     "@cursor/sdk": "1.0.38",
-    "@desplega.ai/agent-fs-just-bash": "0.17.0",
+    "@desplega.ai/agent-fs-just-bash": "0.18.4",
     "@desplega.ai/business-use": "^0.4.2",
     "@earendil-works/pi-agent-core": "^1.3.0",
     "@earendil-works/pi-ai": "^1.3.0",

package/src/apps/action-caller.ts

@@ -0,0 +1,6 @@
+export type AppActionCaller = {
+  kind: "user" | "agent" | "operator" | "guest";
+  id: string | null;
+  name?: string;
+  pageId?: string;
+};

package/src/apps/script-types.ts

@@ -8,6 +8,13 @@ const APP_TYPES_PREAMBLE = `// ── Swarm Apps: generated per-app types (sourc
 // Rows are the app's declared columns plus the 5 system columns. Query
 // overloads narrow only when appId AND query are string literals.
 
+export type AppActionCaller = {
+  kind: "user" | "agent" | "operator" | "guest";
+  id: string | null;
+  name?: string;
+  pageId?: string;
+};
+
 export interface SwarmAppQueryResult<Row> {
   success: boolean;
   status: number;
@@ -175,9 +182,8 @@ function renderQuery(
 }
 
 function renderApp(app: AppRecord, namespace: string): string {
-  // Reserve the generated alias so a model named `actionName` dedupes to
-  // `ActionName_2` instead of colliding with `type ActionName`.
-  const modelNames = new Set<string>(["ActionName"]);
+  // Reserve action types so model names cannot collide with them.
+  const modelNames = new Set<string>(["ActionName", "ActionArgs", "AppActionCaller"]);
   const renderedModels = Object.entries(app.definition.models).map(([modelName, model]) =>
     renderModel(modelName, model, modelNames),
   );
@@ -202,6 +208,13 @@ ${renderedModels.map((model) => model.source).join("\n\n")}
 
   /** Declared actions. Invocation is REST-only: POST /api/apps/<id>/actions/<name>. */
   export type ActionName = ${actionType};
+
+  /** Script action arguments include server-stamped app and caller context. */
+  export interface ActionArgs {
+    app: { id: ${JSON.stringify(app.id)} };
+    caller: AppActionCaller;
+    [key: string]: unknown;
+  }
 }
 
 export interface SwarmSdk {

package/src/be/asset-key-audit.ts

@@ -90,9 +90,7 @@ function auditKeyRow(
 
 type AttachmentMappingAuditRow = {
   attachment_id: string;
-  task_key: string;
   mapping_id: string | null;
-  mapping_key: string | null;
 };
 
 type MappingSourceAuditRow = {
@@ -118,9 +116,7 @@ export function auditAssetKeys(db: Database): AssetKeyAuditResult {
     .prepare<AttachmentMappingAuditRow, []>(
       `SELECT
          a.id AS attachment_id,
-         t."key" AS task_key,
-         m.id AS mapping_id,
-         m."key" AS mapping_key
+         m.id AS mapping_id
        FROM task_attachments a
        JOIN agent_tasks t ON t.id = a.task_id
        LEFT JOIN asset_key_mappings m
@@ -132,6 +128,9 @@ export function auditAssetKeys(db: Database): AssetKeyAuditResult {
          AND COALESCE(NULLIF(a.provider_key, ''), a.path) IS NOT NULL`,
     )
     .all();
+  // One file has one mapping, which follows its source attachment (checked below). Other
+  // tasks may attach the same file from any namespace, and a mapping detached from its
+  // deleted source keeps its own namespace, so neither is drift.
   for (const row of attachmentMappings) {
     if (!row.mapping_id) {
       issues.push({
@@ -141,14 +140,6 @@ export function auditAssetKeys(db: Database): AssetKeyAuditResult {
         entityId: row.attachment_id,
         message: "Agent-fs attachment has no logical namespace mapping.",
       });
-    } else if (row.mapping_key !== row.task_key) {
-      issues.push({
-        severity: "warning",
-        code: "provider-mapping-drift",
-        entityType: "file",
-        entityId: row.mapping_id,
-        message: "Provider mapping namespace differs from its parent task namespace.",
-      });
     }
   }
 

package/src/be/db/active-sessions.ts

@@ -1,3 +1,4 @@
+import type { ActiveSession } from "../../types";
 import { getDbClient } from "./runtime";
 
 /**
@@ -28,3 +29,7 @@ export async function refreshActiveSessionOnActivity(
   );
   return result.changes > 0;
 }
+
+export async function getActiveSessionById(id: string): Promise<ActiveSession | null> {
+  return getDbClient().get<ActiveSession>("SELECT * FROM active_sessions WHERE id = ?", [id]);
+}

package/src/be/db/session-visibility.ts

@@ -0,0 +1,29 @@
+/**
+ * Session-list visibility for session sharing. `all`: sessions the viewer
+ * owns, ownerless sessions, and sessions shared with the viewer or everyone.
+ * `mine`: owned by the viewer. `shared`: owned by someone else and shared with
+ * the viewer or everyone. A null `userId` (a guest page session) owns nothing.
+ */
+export type SessionViewer = { userId: string | null; scope: "all" | "mine" | "shared" };
+
+/** SQL condition + params restricting root tasks (alias `r`) to what `viewer` may open. */
+export function sessionViewerCondition(viewer: SessionViewer): {
+  sql: string;
+  params: (string | null)[];
+} {
+  const shared = `EXISTS (SELECT 1 FROM session_shares s
+      WHERE s.rootTaskId = r.id AND s.revokedAt IS NULL AND (s.userId IS NULL OR s.userId = ?))`;
+  if (viewer.scope === "mine") {
+    return { sql: "r.requestedByUserId = ?", params: [viewer.userId] };
+  }
+  if (viewer.scope === "shared") {
+    return {
+      sql: `(r.requestedByUserId IS NOT NULL AND r.requestedByUserId IS NOT ? AND ${shared})`,
+      params: [viewer.userId, viewer.userId],
+    };
+  }
+  return {
+    sql: `(r.requestedByUserId IS NULL OR r.requestedByUserId = ? OR ${shared})`,
+    params: [viewer.userId, viewer.userId],
+  };
+}

package/src/be/db/tasks/read.ts

@@ -556,10 +556,14 @@ export async function hasNonTerminalRerouteDecisionChild(parentId: string): Prom
   return row !== undefined && row !== null;
 }
 
-export async function getTasksByAgentId(agentId: string): Promise<AgentTask[]> {
+export async function getTasksByAgentId(
+  agentId: string,
+  readableBy?: { userId: string | null },
+): Promise<AgentTask[]> {
+  const readable = readableBy ? readableSessionCondition(readableBy.userId) : undefined;
   const rows = await getDbClient().query<AgentTaskRow>(
-    "SELECT * FROM agent_tasks WHERE agentId = ? ORDER BY createdAt DESC",
-    [agentId],
+    `SELECT * FROM agent_tasks WHERE agentId = ?${readable ? ` AND ${readable.sql}` : ""} ORDER BY createdAt DESC`,
+    [agentId, ...(readable?.params ?? [])],
   );
   return rows.map(rowToAgentTask);
 }
@@ -642,6 +646,48 @@ export interface TaskFilters {
   limit?: number;
   offset?: number;
   includeHeartbeat?: boolean;
+  /** Only tasks of sessions this user may read; `userId: null` is a guest. */
+  readableBy?: { userId: string | null };
+}
+
+/**
+ * The SQL twin of `sessionAccessForRoot` (../../session-shares). A session's
+ * root is its topmost existing task; the session is hidden when the root has
+ * an owner other than the user and no active share names the user or
+ * everyone. Descending from hidden roots is linear in their tasks at any chain
+ * depth, and as a WHERE term it keeps paging and `COUNT(*)` on the same rows.
+ * `parentTaskId` is fixed at insert to an existing task, so no parent cycle
+ * (which would have no root) can form.
+ *
+ * `taskIdColumn` applies the same filter to any table keyed by task id. A
+ * nullable column keeps its task-less rows: they belong to no session.
+ */
+export function readableSessionCondition(
+  userId: string | null,
+  taskIdColumn = "agent_tasks.id",
+  opts: { nullable?: boolean } = {},
+): { sql: string; params: string[] } {
+  const otherOwner = userId
+    ? "r.requestedByUserId IS NOT NULL AND r.requestedByUserId != ?"
+    : "r.requestedByUserId IS NOT NULL";
+  const shareMatch = userId ? "(s.userId IS NULL OR s.userId = ?)" : "s.userId IS NULL";
+  const notHidden = `${taskIdColumn} NOT IN (
+      WITH RECURSIVE hidden(id) AS (
+        SELECT r.id FROM agent_tasks r
+        WHERE (r.parentTaskId IS NULL
+            OR NOT EXISTS (SELECT 1 FROM agent_tasks p WHERE p.id = r.parentTaskId))
+          AND ${otherOwner}
+          AND NOT EXISTS (SELECT 1 FROM session_shares s
+            WHERE s.rootTaskId = r.id AND s.revokedAt IS NULL AND ${shareMatch})
+        UNION ALL
+        SELECT c.id FROM agent_tasks c JOIN hidden ON c.parentTaskId = hidden.id
+      )
+      SELECT id FROM hidden
+    )`;
+  return {
+    sql: opts.nullable ? `(${taskIdColumn} IS NULL OR ${notHidden})` : notHidden,
+    params: userId ? [userId, userId] : [],
+  };
 }
 
 export function getAllTasks(filters?: TaskFilters): Promise<AgentTask[]>;
@@ -756,6 +802,12 @@ export async function getAllTasks(
     );
   }
 
+  if (filters?.readableBy) {
+    const readable = readableSessionCondition(filters.readableBy.userId);
+    conditions.push(readable.sql);
+    params.push(...readable.params);
+  }
+
   const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
   const limit = filters?.limit ?? 25;
   const offset = filters?.offset ?? 0;
@@ -916,6 +968,12 @@ export async function getTasksCount(
     );
   }
 
+  if (filters?.readableBy) {
+    const readable = readableSessionCondition(filters.readableBy.userId);
+    conditions.push(readable.sql);
+    params.push(...readable.params);
+  }
+
   const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
   const query = `SELECT COUNT(*) as count FROM agent_tasks ${whereClause}`;
 

package/src/be/db/tasks/write.ts

@@ -27,6 +27,7 @@ import {
   type AgentTaskRow,
   getTaskById,
   NEVER_STARTED_TASK_STATUSES,
+  readableSessionCondition,
   rowToAgentTask,
 } from "./read";
 
@@ -1019,12 +1020,16 @@ export async function resumeTask(taskId: string): Promise<AgentTask | null> {
  * Used on startup to resume tasks that were interrupted by deployment.
  * Returns tasks ordered by creation time (oldest first for FIFO).
  */
-export async function getPausedTasksForAgent(agentId: string): Promise<AgentTask[]> {
+export async function getPausedTasksForAgent(
+  agentId: string,
+  readableBy?: { userId: string | null },
+): Promise<AgentTask[]> {
+  const readable = readableBy ? readableSessionCondition(readableBy.userId) : undefined;
   const rows = await getDbClient().query<AgentTaskRow>(
     `SELECT * FROM agent_tasks
-       WHERE agentId = ? AND status = 'paused'
+       WHERE agentId = ? AND status = 'paused'${readable ? ` AND ${readable.sql}` : ""}
        ORDER BY createdAt ASC, rowid ASC`,
-    [agentId],
+    [agentId, ...(readable?.params ?? [])],
   );
   return rows.map(rowToAgentTask);
 }
@@ -1093,15 +1098,19 @@ export async function resetOrphanedInProgressTasksForAgent(
  * Used by hooks to detect task cancellation and stop the worker loop.
  * Returns tasks cancelled within the last 5 minutes.
  */
-export async function getRecentlyCancelledTasksForAgent(agentId: string): Promise<AgentTask[]> {
+export async function getRecentlyCancelledTasksForAgent(
+  agentId: string,
+  readableBy?: { userId: string | null },
+): Promise<AgentTask[]> {
   const fiveMinutesAgo = new Date(Date.now() - 5 * 60 * 1000).toISOString();
+  const readable = readableBy ? readableSessionCondition(readableBy.userId) : undefined;
   const rows = await getDbClient().query<AgentTaskRow>(
     `SELECT * FROM agent_tasks
        WHERE agentId = ?
        AND status = 'cancelled'
-       AND finishedAt > ?
+       AND finishedAt > ?${readable ? ` AND ${readable.sql}` : ""}
        ORDER BY finishedAt DESC`,
-    [agentId, fiveMinutesAgo],
+    [agentId, fiveMinutesAgo, ...(readable?.params ?? [])],
   );
   return rows.map(rowToAgentTask);
 }