@desplega.ai/agent-swarm 2.7.2 → 2.7.3

package/src/be/migrations/253_session_summaries.sql

@@ -0,0 +1,300 @@
+-- Session summaries: one narrow row per session root, kept exact by triggers.
+--
+-- A session is a root task (parentTaskId IS NULL) plus every task reachable
+-- through parentTaskId. The session list, count and tree walk that chain with
+-- a recursive CTE on every request (src/be/db/session-tree.ts). These tables
+-- store the walk's result so the read path can skip it:
+--
+-- - session_members(taskId, rootId): the root of every chain task. A task
+--   whose parent is missing belongs to no session, as in the chain walk.
+-- - session_summaries(rootId, ...): copies of the root columns the list
+--   filters on, plus the chain aggregates the list, count and tree read.
+--
+-- Nothing reads these tables yet. The read path switches over in a later
+-- change, after a production drift check against the chain walk
+-- (sessionSummaryDriftQuery in src/be/db/session-summaries.ts).
+--
+-- Consistency rules:
+-- - Inserts and progress writes update a summary incrementally (the hot path).
+-- - Rare, non-monotonic changes recompute the whole chain through the
+--   session_summary_recompute view, the one copy of the recompute SQL.
+-- - parentTaskId is immutable: no code moves a task between chains, and the
+--   members table depends on it. Changing it aborts.
+-- - Trigger bodies cannot use WITH, so deleteTask (the only task delete)
+--   drops the members rows of a deleted task's descendants itself, before the
+--   DELETE. The delete trigger then recomputes the chain.
+-- - session_summary_recompute_apply reads agent_tasks, task_steering_messages
+--   and approval_requests. A later migration that rebuilds one of those
+--   tables (create, copy, drop, rename) must drop that trigger before the
+--   rename and re-create it after, or the rename fails its schema check. The
+--   boot-time agent_tasks rebuild in src/be/db/runtime.ts already does.
+
+CREATE TABLE session_members (
+  taskId TEXT PRIMARY KEY,
+  rootId TEXT NOT NULL
+);
+CREATE INDEX idx_session_members_root ON session_members(rootId);
+
+CREATE TABLE session_summaries (
+  rootId TEXT PRIMARY KEY,
+  -- Root copies (filters, ordering, tree grouping).
+  createdAt TEXT NOT NULL,
+  source TEXT,
+  "key" TEXT NOT NULL,
+  requestedByUserId TEXT,
+  scheduleId TEXT,
+  taskType TEXT,
+  slackChannelId TEXT,
+  contextKey TEXT,
+  -- Chain aggregates.
+  chainCount INTEGER NOT NULL,
+  lastActivityAt TEXT NOT NULL,
+  latestStatus TEXT NOT NULL,
+  pendingApprovalCount INTEGER NOT NULL DEFAULT 0,
+  -- Newest event that reopens a Done session: a human message (a task a
+  -- person requested directly from a human channel), a person's live steering
+  -- message, or a pending approval. Done reopens when this is newer than the
+  -- Done mark, which is what the chain walk's per-row check asks.
+  lastHumanAt TEXT
+);
+CREATE INDEX idx_session_summaries_activity
+  ON session_summaries(lastActivityAt DESC, createdAt DESC, rootId DESC);
+CREATE INDEX idx_session_summaries_thread
+  ON session_summaries("key") WHERE requestedByUserId IS NOT NULL;
+
+-- INSERT INTO session_summary_recompute (rootId) VALUES (?) recomputes one
+-- summary from its members. A missing root is a no-op, including a root whose
+-- row is mid-delete: an FK cascade (steering messages) fires its trigger after
+-- the row is gone but before the delete trigger drops the summary.
+CREATE VIEW session_summary_recompute AS SELECT NULL AS rootId;
+
+CREATE TRIGGER session_summary_recompute_apply
+INSTEAD OF INSERT ON session_summary_recompute
+BEGIN
+  UPDATE session_summaries SET
+    chainCount = (SELECT COUNT(*) FROM session_members m WHERE m.rootId = NEW.rootId),
+    lastActivityAt = (SELECT MAX(t.lastUpdatedAt) FROM session_members m
+      JOIN agent_tasks t ON t.id = m.taskId WHERE m.rootId = NEW.rootId),
+    latestStatus = (SELECT t.status FROM session_members m
+      JOIN agent_tasks t ON t.id = m.taskId WHERE m.rootId = NEW.rootId
+      ORDER BY t.lastUpdatedAt DESC LIMIT 1),
+    pendingApprovalCount = (SELECT COUNT(*) FROM session_members m
+      JOIN approval_requests ar ON ar.sourceTaskId = m.taskId
+      WHERE m.rootId = NEW.rootId AND ar.status = 'pending'),
+    lastHumanAt = (SELECT MAX(at) FROM (
+      SELECT t.createdAt AS at FROM session_members m JOIN agent_tasks t ON t.id = m.taskId
+      WHERE m.rootId = NEW.rootId AND t.requestedByUserId IS NOT NULL
+        AND t.requestedByUserIdInherited = 0
+        AND COALESCE(t.source, '') NOT IN ('mcp', 'system', 'schedule', 'workflow')
+      UNION ALL
+      SELECT sm.created_at FROM session_members m
+      JOIN task_steering_messages sm ON sm.task_id = m.taskId
+      WHERE m.rootId = NEW.rootId AND sm.created_by_kind = 'user' AND sm.status != 'cancelled'
+      UNION ALL
+      SELECT ar.createdAt FROM session_members m
+      JOIN approval_requests ar ON ar.sourceTaskId = m.taskId
+      WHERE m.rootId = NEW.rootId AND ar.status = 'pending'))
+  WHERE rootId = NEW.rootId
+    AND EXISTS (SELECT 1 FROM agent_tasks WHERE id = NEW.rootId);
+END;
+
+-- A new root opens a session; a new child joins its parent's session. A child
+-- of a missing parent joins nothing (task ids are fresh UUIDs, so no later
+-- insert can adopt it).
+CREATE TRIGGER session_task_insert
+AFTER INSERT ON agent_tasks
+BEGIN
+  INSERT OR REPLACE INTO session_members (taskId, rootId)
+  SELECT NEW.id, NEW.id WHERE NEW.parentTaskId IS NULL
+  UNION ALL
+  SELECT NEW.id, m.rootId FROM session_members m WHERE m.taskId = NEW.parentTaskId;
+
+  INSERT OR REPLACE INTO session_summaries (rootId, createdAt, source, "key", requestedByUserId,
+    scheduleId, taskType, slackChannelId, contextKey, chainCount, lastActivityAt, latestStatus,
+    pendingApprovalCount, lastHumanAt)
+  SELECT NEW.id, NEW.createdAt, NEW.source, NEW."key", NEW.requestedByUserId, NEW.scheduleId,
+    NEW.taskType, NEW.slackChannelId, NEW.contextKey, 1, NEW.lastUpdatedAt, NEW.status, 0,
+    CASE WHEN NEW.requestedByUserId IS NOT NULL AND NEW.requestedByUserIdInherited = 0
+      AND COALESCE(NEW.source, '') NOT IN ('mcp', 'system', 'schedule', 'workflow')
+      THEN NEW.createdAt END
+  WHERE NEW.parentTaskId IS NULL;
+
+  UPDATE session_summaries SET
+    chainCount = chainCount + 1,
+    latestStatus = CASE WHEN NEW.lastUpdatedAt >= lastActivityAt THEN NEW.status ELSE latestStatus END,
+    lastActivityAt = MAX(lastActivityAt, NEW.lastUpdatedAt),
+    lastHumanAt = CASE WHEN NEW.requestedByUserId IS NOT NULL AND NEW.requestedByUserIdInherited = 0
+      AND COALESCE(NEW.source, '') NOT IN ('mcp', 'system', 'schedule', 'workflow')
+      AND (lastHumanAt IS NULL OR NEW.createdAt > lastHumanAt)
+      THEN NEW.createdAt ELSE lastHumanAt END
+  WHERE NEW.parentTaskId IS NOT NULL
+    AND rootId = (SELECT rootId FROM session_members WHERE taskId = NEW.id);
+END;
+
+-- Progress and status writes (the hot path): newest activity wins.
+CREATE TRIGGER session_task_activity
+AFTER UPDATE OF lastUpdatedAt, status ON agent_tasks
+WHEN NEW.lastUpdatedAt >= OLD.lastUpdatedAt
+BEGIN
+  UPDATE session_summaries SET
+    latestStatus = CASE WHEN NEW.lastUpdatedAt >= lastActivityAt THEN NEW.status ELSE latestStatus END,
+    lastActivityAt = MAX(lastActivityAt, NEW.lastUpdatedAt)
+  WHERE rootId = (SELECT rootId FROM session_members WHERE taskId = NEW.id);
+END;
+
+-- A timestamp moved back may have been the chain's newest one.
+CREATE TRIGGER session_task_activity_rewind
+AFTER UPDATE OF lastUpdatedAt ON agent_tasks
+WHEN NEW.lastUpdatedAt < OLD.lastUpdatedAt
+BEGIN
+  INSERT INTO session_summary_recompute (rootId)
+  SELECT rootId FROM session_members WHERE taskId = NEW.id;
+END;
+
+-- Requester or source edits change which tasks count as human messages.
+CREATE TRIGGER session_task_human
+AFTER UPDATE OF requestedByUserId, requestedByUserIdInherited, source, createdAt ON agent_tasks
+WHEN OLD.requestedByUserId IS NOT NEW.requestedByUserId
+  OR OLD.requestedByUserIdInherited IS NOT NEW.requestedByUserIdInherited
+  OR OLD.source IS NOT NEW.source
+  OR OLD.createdAt IS NOT NEW.createdAt
+BEGIN
+  INSERT INTO session_summary_recompute (rootId)
+  SELECT rootId FROM session_members WHERE taskId = NEW.id;
+END;
+
+-- Root column copies (session moves rewrite the root key).
+CREATE TRIGGER session_root_columns
+AFTER UPDATE OF createdAt, source, "key", requestedByUserId, scheduleId, taskType,
+  slackChannelId, contextKey ON agent_tasks
+WHEN NEW.parentTaskId IS NULL AND (
+  OLD.createdAt IS NOT NEW.createdAt OR OLD.source IS NOT NEW.source
+  OR OLD."key" IS NOT NEW."key" OR OLD.requestedByUserId IS NOT NEW.requestedByUserId
+  OR OLD.scheduleId IS NOT NEW.scheduleId OR OLD.taskType IS NOT NEW.taskType
+  OR OLD.slackChannelId IS NOT NEW.slackChannelId OR OLD.contextKey IS NOT NEW.contextKey)
+BEGIN
+  UPDATE session_summaries SET
+    createdAt = NEW.createdAt, source = NEW.source, "key" = NEW."key",
+    requestedByUserId = NEW.requestedByUserId, scheduleId = NEW.scheduleId,
+    taskType = NEW.taskType, slackChannelId = NEW.slackChannelId, contextKey = NEW.contextKey
+  WHERE rootId = NEW.id;
+END;
+
+CREATE TRIGGER session_task_parent_immutable
+BEFORE UPDATE OF parentTaskId ON agent_tasks
+WHEN OLD.parentTaskId IS NOT NEW.parentTaskId
+BEGIN
+  SELECT RAISE(ABORT, 'agent_tasks.parentTaskId is immutable (session_members depends on it)');
+END;
+
+-- A deleted root ends its session, and its chain tasks join nothing. A deleted
+-- chain task leaves its chain (deleteTask already dropped its descendants).
+CREATE TRIGGER session_task_delete
+AFTER DELETE ON agent_tasks
+BEGIN
+  DELETE FROM session_members WHERE taskId = OLD.id OR rootId = OLD.id;
+  DELETE FROM session_summaries WHERE rootId = OLD.id;
+  INSERT INTO session_summary_recompute (rootId)
+  SELECT rootId FROM session_members WHERE taskId = OLD.parentTaskId;
+END;
+
+-- Steering messages and approvals are rare: recompute on any change that
+-- can move lastHumanAt or pendingApprovalCount.
+CREATE TRIGGER session_steering_insert
+AFTER INSERT ON task_steering_messages
+WHEN NEW.created_by_kind = 'user' AND NEW.status != 'cancelled'
+BEGIN
+  INSERT INTO session_summary_recompute (rootId)
+  SELECT rootId FROM session_members WHERE taskId = NEW.task_id;
+END;
+
+CREATE TRIGGER session_steering_update
+AFTER UPDATE OF task_id, created_by_kind, status, created_at ON task_steering_messages
+WHEN OLD.task_id IS NOT NEW.task_id OR OLD.created_by_kind IS NOT NEW.created_by_kind
+  OR OLD.created_at IS NOT NEW.created_at
+  OR (OLD.status = 'cancelled') IS NOT (NEW.status = 'cancelled')
+BEGIN
+  INSERT INTO session_summary_recompute (rootId)
+  SELECT rootId FROM session_members WHERE taskId IN (OLD.task_id, NEW.task_id);
+END;
+
+CREATE TRIGGER session_steering_delete
+AFTER DELETE ON task_steering_messages
+WHEN OLD.created_by_kind = 'user' AND OLD.status != 'cancelled'
+BEGIN
+  INSERT INTO session_summary_recompute (rootId)
+  SELECT rootId FROM session_members WHERE taskId = OLD.task_id;
+END;
+
+CREATE TRIGGER session_approval_insert
+AFTER INSERT ON approval_requests
+WHEN NEW.sourceTaskId IS NOT NULL AND NEW.status = 'pending'
+BEGIN
+  INSERT INTO session_summary_recompute (rootId)
+  SELECT rootId FROM session_members WHERE taskId = NEW.sourceTaskId;
+END;
+
+CREATE TRIGGER session_approval_update
+AFTER UPDATE OF sourceTaskId, status, createdAt ON approval_requests
+WHEN OLD.sourceTaskId IS NOT NEW.sourceTaskId OR OLD.createdAt IS NOT NEW.createdAt
+  OR (OLD.status = 'pending') IS NOT (NEW.status = 'pending')
+BEGIN
+  INSERT INTO session_summary_recompute (rootId)
+  SELECT rootId FROM session_members WHERE taskId IN (OLD.sourceTaskId, NEW.sourceTaskId);
+END;
+
+CREATE TRIGGER session_approval_delete
+AFTER DELETE ON approval_requests
+WHEN OLD.sourceTaskId IS NOT NULL AND OLD.status = 'pending'
+BEGIN
+  INSERT INTO session_summary_recompute (rootId)
+  SELECT rootId FROM session_members WHERE taskId = OLD.sourceTaskId;
+END;
+
+-- Backfill: one chain walk for the members, then set-based aggregates (a
+-- recompute per root reads every chain task several times). The packed MAX
+-- takes the status of the newest task, as the bare column does in the walk.
+INSERT INTO session_members (taskId, rootId)
+WITH RECURSIVE chain(root_id, id) AS (
+  SELECT id, id FROM agent_tasks WHERE parentTaskId IS NULL
+  UNION ALL
+  SELECT c.root_id, t.id FROM chain c JOIN agent_tasks t ON t.parentTaskId = c.id
+)
+SELECT id, root_id FROM chain;
+
+INSERT INTO session_summaries (rootId, createdAt, source, "key", requestedByUserId, scheduleId,
+  taskType, slackChannelId, contextKey, chainCount, lastActivityAt, latestStatus, lastHumanAt)
+SELECT r.id, r.createdAt, r.source, r."key", r.requestedByUserId, r.scheduleId, r.taskType,
+  r.slackChannelId, r.contextKey, w.chainCount, w.lastActivityAt,
+  substr(w.newest, instr(w.newest, char(31)) + 1), w.humanAt
+FROM (
+  SELECT m.rootId, COUNT(*) AS chainCount, MAX(t.lastUpdatedAt) AS lastActivityAt,
+    MAX(t.lastUpdatedAt || char(31) || t.status) AS newest,
+    MAX(CASE WHEN t.requestedByUserId IS NOT NULL AND t.requestedByUserIdInherited = 0
+      AND COALESCE(t.source, '') NOT IN ('mcp', 'system', 'schedule', 'workflow')
+      THEN t.createdAt END) AS humanAt
+  FROM session_members m JOIN agent_tasks t ON t.id = m.taskId
+  GROUP BY m.rootId
+) w JOIN agent_tasks r ON r.id = w.rootId;
+
+UPDATE session_summaries SET
+  pendingApprovalCount = (SELECT COUNT(*) FROM session_members m
+    JOIN approval_requests ar ON ar.sourceTaskId = m.taskId
+    WHERE m.rootId = session_summaries.rootId AND ar.status = 'pending'),
+  lastHumanAt = (SELECT MAX(at) FROM (
+    SELECT session_summaries.lastHumanAt AS at
+    UNION ALL
+    SELECT sm.created_at FROM session_members m
+    JOIN task_steering_messages sm ON sm.task_id = m.taskId
+    WHERE m.rootId = session_summaries.rootId AND sm.created_by_kind = 'user'
+      AND sm.status != 'cancelled'
+    UNION ALL
+    SELECT ar.createdAt FROM session_members m
+    JOIN approval_requests ar ON ar.sourceTaskId = m.taskId
+    WHERE m.rootId = session_summaries.rootId AND ar.status = 'pending'))
+WHERE rootId IN (
+  SELECT m.rootId FROM session_members m JOIN task_steering_messages sm ON sm.task_id = m.taskId
+  WHERE sm.created_by_kind = 'user' AND sm.status != 'cancelled'
+  UNION
+  SELECT m.rootId FROM session_members m JOIN approval_requests ar ON ar.sourceTaskId = m.taskId
+  WHERE ar.status = 'pending');

package/src/be/migrations/254_query_audit_indexes.sql

@@ -0,0 +1,25 @@
+-- Indexes for hot lookups that scan agent_tasks or script_runs today.
+--
+-- agent_tasks rows carry large `task` text, so every scan of the table reads
+-- its overflow pages and costs hundreds of milliseconds, whatever column it
+-- filters. Production has no sqlite_stat1, so each index below is shaped so
+-- the planner picks it without statistics.
+
+-- getTaskByWorkflowRunStepId and getStuckWorkflowRuns look tasks up by step.
+-- Partial: only workflow-step tasks carry the column.
+CREATE INDEX IF NOT EXISTS idx_agent_tasks_workflowRunStepId
+  ON agent_tasks(workflowRunStepId) WHERE workflowRunStepId IS NOT NULL;
+
+-- getRecentCompletedCount: `status = ? AND finishedAt > ?` becomes a covering
+-- range instead of reading finishedAt from every completed row.
+CREATE INDEX IF NOT EXISTS idx_agent_tasks_status_finishedAt
+  ON agent_tasks(status, finishedAt);
+
+-- Session root counts: `parentTaskId IS NULL AND source IN (...)` becomes a
+-- covering range instead of reading source from every root.
+CREATE INDEX IF NOT EXISTS idx_agent_tasks_parentTaskId_source
+  ON agent_tasks(parentTaskId, source);
+
+-- countScriptRuns / listScriptRuns filtered by script name.
+CREATE INDEX IF NOT EXISTS idx_script_runs_scriptName_startedAt
+  ON script_runs(scriptName, startedAt DESC);

package/src/be/migrations/256_agent_slack_icon.sql

@@ -0,0 +1,2 @@
+-- JSON of AgentSlackIcon for the agent's Slack posts. NULL = default emoji.
+ALTER TABLE agents ADD COLUMN slack_icon TEXT;

package/src/be/migrations/257_agent_tasks_fts.sql

@@ -0,0 +1,55 @@
+-- Token index for task search (getAllTasks / getTasksCount `search`), which
+-- used to run `task LIKE '%q%'` over every task body. External content: the
+-- index stores no copy of the text, rows are keyed by agent_tasks.rowid, and
+-- the default unicode61 tokenizer (no porter: ids and numbers stay exact).
+CREATE VIRTUAL TABLE IF NOT EXISTS agent_tasks_fts USING fts5(
+  task,
+  title,
+  content='agent_tasks',
+  content_rowid='rowid'
+);
+
+-- Rows with rowid <= indexedThrough are in the index. A full backfill would
+-- block boot and hold the write lock, so the migration indexes nothing and
+-- the API backfills in rowid batches after boot (backfillTaskSearchIndex in
+-- src/be/db/tasks/search-index.ts), raising indexedThrough in the same
+-- transaction as each batch. Once it reaches 9007199254740991 every row is
+-- indexed and search switches from LIKE to the index. An empty table starts
+-- complete.
+CREATE TABLE IF NOT EXISTS agent_tasks_fts_state (
+  id INTEGER PRIMARY KEY CHECK (id = 1),
+  indexedThrough INTEGER NOT NULL
+);
+
+INSERT OR IGNORE INTO agent_tasks_fts_state (id, indexedThrough)
+  SELECT 1, CASE WHEN EXISTS (SELECT 1 FROM agent_tasks) THEN 0 ELSE 9007199254740991 END;
+
+-- Triggers keep the index in sync on every write path (the two INSERT sites,
+-- title updates, the draft append, the boot scrub sweep, deletes). They touch
+-- only rows the backfill has reached: an external-content 'delete' must name
+-- a row the index holds, or it corrupts the index. A rebuild of agent_tasks
+-- must keep rowids (the index is keyed by them) and recreate these triggers;
+-- src/tests/task-search-fts.test.ts covers the runtime.ts rebuild.
+CREATE TRIGGER IF NOT EXISTS agent_tasks_fts_insert
+AFTER INSERT ON agent_tasks
+WHEN NEW.rowid <= (SELECT indexedThrough FROM agent_tasks_fts_state WHERE id = 1)
+BEGIN
+  INSERT INTO agent_tasks_fts(rowid, task, title) VALUES (NEW.rowid, NEW.task, NEW.title);
+END;
+
+CREATE TRIGGER IF NOT EXISTS agent_tasks_fts_update
+AFTER UPDATE OF task, title ON agent_tasks
+WHEN OLD.rowid <= (SELECT indexedThrough FROM agent_tasks_fts_state WHERE id = 1)
+BEGIN
+  INSERT INTO agent_tasks_fts(agent_tasks_fts, rowid, task, title)
+    VALUES ('delete', OLD.rowid, OLD.task, OLD.title);
+  INSERT INTO agent_tasks_fts(rowid, task, title) VALUES (NEW.rowid, NEW.task, NEW.title);
+END;
+
+CREATE TRIGGER IF NOT EXISTS agent_tasks_fts_delete
+AFTER DELETE ON agent_tasks
+WHEN OLD.rowid <= (SELECT indexedThrough FROM agent_tasks_fts_state WHERE id = 1)
+BEGIN
+  INSERT INTO agent_tasks_fts(agent_tasks_fts, rowid, task, title)
+    VALUES ('delete', OLD.rowid, OLD.task, OLD.title);
+END;

package/src/comb/config.ts

@@ -2,14 +2,16 @@ import {
   getAgentFsDefaultDriveId,
   getAgentFsDefaultOrgId,
   getAgentFsLiveUrl,
+  getCombState,
   getPublicMcpBaseUrl,
   isAgentFsProxyEnabled,
-  isCombEnabled,
 } from "../utils/constants";
 
 /** The Comb block of `/status` (`agent_fs.comb`), before snake-casing. */
 export interface CombConfig {
   enabled: boolean;
+  /** Why Comb is off; null when on. */
+  reason: string | null;
   /** Browser-facing agent-fs URL. */
   apiUrl: string | null;
   liveUrl: string;
@@ -32,8 +34,10 @@ export function getCombConfig(): CombConfig {
   // With the proxy on, the browser reaches agent-fs through the API itself.
   const browserDefault =
     isAgentFsProxyEnabled() && internalUrl ? `${getPublicMcpBaseUrl()}/agentfs` : internalUrl;
+  const state = getCombState();
   return {
-    enabled: isCombEnabled(),
+    enabled: state.enabled,
+    reason: state.reason,
     apiUrl: trimUrl(process.env.AGENT_FS_PUBLIC_URL) ?? browserDefault,
     liveUrl: getAgentFsLiveUrl(),
     orgId: getAgentFsDefaultOrgId() ?? null,

package/src/comb/requester.ts

@@ -0,0 +1,69 @@
+/**
+ * Who sent a Comb batch, when the request names no user.
+ *
+ * The dashboard sends with the swarm API key, so the request carries no user.
+ * The comment authors do: an agent-fs author maps to a swarm user through a
+ * linked `agent-fs` identity, else through the email agent-fs has for that
+ * drive member. The browser's agent-fs key never reaches the swarm API, so no
+ * request proves which author pressed Send. With several mapped authors, the
+ * author of the newest comment wins: the person who commented last is the
+ * one most likely to have sent the batch.
+ */
+
+import { findUserByEmail, findUserByExternalId } from "../be/users";
+import type { AgentFsComment, AgentFsDrive, AgentFsProvider } from "../fs/agent-fs-provider";
+import { scrubSecrets } from "../utils/secret-scrubber";
+
+/** `user_external_ids.kind` of an agent-fs user id. */
+export const AGENT_FS_IDENTITY_KIND = "agent-fs";
+
+/**
+ * agent-fs user id -> swarm user id, for each author that maps. The swarm
+ * service account is never a requester. Reads the drive members from
+ * agent-fs only when an author has no linked identity.
+ */
+export async function commentAuthorUsers(
+  agentFs: AgentFsProvider,
+  drive: AgentFsDrive,
+  comments: AgentFsComment[],
+  serviceUserId: string,
+): Promise<Map<string, string>> {
+  const authors = [...new Set(comments.map((comment) => comment.author))].filter(
+    (author) => author && author !== serviceUserId,
+  );
+  const users = new Map<string, string>();
+  const unlinked: string[] = [];
+  for (const author of authors) {
+    const user = await findUserByExternalId(AGENT_FS_IDENTITY_KIND, author);
+    if (user) users.set(author, user.id);
+    else unlinked.push(author);
+  }
+  if (unlinked.length === 0) return users;
+
+  const members = await agentFs.getDriveMembers(drive).catch((error: unknown) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(scrubSecrets(`[comb] could not read the drive members: ${message}`));
+    return [];
+  });
+  for (const author of unlinked) {
+    const email = members.find((member) => member.userId === author)?.email;
+    const user = email ? await findUserByEmail(email) : null;
+    if (user) users.set(author, user.id);
+  }
+  return users;
+}
+
+/** The author of the newest comment that maps to a swarm user, else null. */
+export function batchRequester(
+  comments: AgentFsComment[],
+  users: Map<string, string>,
+): string | null {
+  let newest: AgentFsComment | null = null;
+  for (const comment of comments) {
+    if (!users.has(comment.author)) continue;
+    if (!newest || Date.parse(comment.createdAt) > Date.parse(newest.createdAt)) {
+      newest = comment;
+    }
+  }
+  return newest ? (users.get(newest.author) ?? null) : null;
+}

package/src/comb/review-batch.ts

@@ -27,6 +27,7 @@ import { scrubSecrets } from "../utils/secret-scrubber";
 import { combAgentFs } from "./agent-fs";
 import { getCombConfig } from "./config";
 import { sentMarker, sentTaskId } from "./markers";
+import { batchRequester, commentAuthorUsers } from "./requester";
 // Side-effect import: registers the comb.review.* templates.
 import "./templates";
 
@@ -67,6 +68,7 @@ export interface ReviewBatchInput {
   scopePath: string;
   /** The sender's note for the lead about the whole batch. Blank means none. */
   note?: string;
+  /** The authenticated sender. Null: the author of the newest mapped comment (`./requester`). */
   requestedByUserId: string | null;
 }
 
@@ -153,6 +155,18 @@ export async function sendReviewBatch(
     if (skip) skipped.push(skip);
     else candidates.push(read);
   }
+  // Without an authenticated sender, map the comment authors to swarm users
+  // now: it may read the drive members from agent-fs. Without the service
+  // identity, a swarm-authored comment could pass for a person: no requester.
+  // The caller picks the comments, so an author requester is caller-chosen
+  // attribution: TRUST_BODY_REQUESTED_BY_USER_ID=false turns it off, like a
+  // body `requestedByUserId` on POST /api/tasks.
+  const authorUsers =
+    input.requestedByUserId ||
+    !serviceUserId ||
+    process.env.TRUST_BODY_REQUESTED_BY_USER_ID === "false"
+      ? null
+      : await commentAuthorUsers(agentFs, drive, candidates.map(commentOf), serviceUserId);
 
   // 2. Claim in one transaction, so two sends never split one set of comments.
   const claim = crypto.randomUUID();
@@ -175,8 +189,11 @@ export async function sendReviewBatch(
   let taskId: string | null = null;
   let leadState: ReviewBatchLead = "none";
   if (won.length > 0) {
+    const requestedByUserId =
+      input.requestedByUserId ??
+      (authorUsers ? batchRequester(won.map(commentOf), authorUsers) : null);
     try {
-      const text = await renderTaskText(input, won);
+      const text = await renderTaskText({ ...input, requestedByUserId }, won);
       if (text === null) {
         throw new ReviewBatchError(503, "The Comb review template is disabled", [
           ...skipped,
@@ -194,7 +211,7 @@ export async function sendReviewBatch(
           source: "comb",
           taskType: "comb-review",
           tags: ["comb"],
-          requestedByUserId: input.requestedByUserId ?? undefined,
+          requestedByUserId: requestedByUserId ?? undefined,
         },
         { origin: "rest" },
       );
@@ -279,6 +296,11 @@ async function readComment(
   return { id, thread, version };
 }
 
+/** The root comment of a read that `skipOf` kept. */
+function commentOf(read: CommentRead): AgentFsComment {
+  return (read.thread as AgentFsCommentThread).comment;
+}
+
 function skipOf({ id, thread }: CommentRead, serviceUserId: string | null): SkippedComment | null {
   if (!thread) return { id, reason: "not-found" };
   if (thread.comment.parentId) return { id, reason: "reply" };

package/src/commands/onboard/agent-fs-version.ts

@@ -2,4 +2,4 @@
  * agent-fs image tag bundled by `agent-swarm onboard --yes`.
  * `bun run bump:agent-fs` rewrites it together with the other pins.
  */
-export const AGENT_FS_VERSION = "0.18.11";
+export const AGENT_FS_VERSION = "0.18.12";

package/src/commands/onboard/compose-generator.ts

@@ -14,6 +14,11 @@ const DEFAULT_WORKER_MAX_CONCURRENT_TASKS = 1;
 // which moves on every commit to main; operators pin a release in .env.
 // biome-ignore lint/suspicious/noTemplateCurlyInString: Docker Compose env var syntax
 const IMAGE_TAG_EXPRESSION = "${AGENT_SWARM_VERSION:-latest}";
+// Host address for published ports, from AGENT_SWARM_BIND_ADDRESS in .env. Blank
+// publishes on every interface, as before. 127.0.0.1 keeps the ports behind a host
+// reverse proxy: Docker-published ports bypass host firewalls such as ufw.
+// biome-ignore lint/suspicious/noTemplateCurlyInString: Docker Compose env var syntax
+const BIND_ADDRESS_PREFIX = "${AGENT_SWARM_BIND_ADDRESS:+${AGENT_SWARM_BIND_ADDRESS:-}:}";
 // biome-ignore lint/suspicious/noTemplateCurlyInString: Docker Compose env var syntax
 const ENV_API_KEY = "      - API_KEY=${API_KEY}";
 // biome-ignore lint/suspicious/noTemplateCurlyInString: Docker Compose env var syntax
@@ -275,7 +280,7 @@ export function generateCompose(state: OnboardState): string {
 
   lines.push("");
   lines.push("    ports:");
-  lines.push(`      - "${port}:3013"`);
+  lines.push(`      - "${BIND_ADDRESS_PREFIX}${port}:3013"`);
   lines.push("");
   lines.push("    volumes:");
   lines.push("      - swarm_data:/app/data");
@@ -353,7 +358,7 @@ export function generateCompose(state: OnboardState): string {
 
     lines.push("");
     lines.push("    ports:");
-    lines.push(`      - "${port}:3000"`);
+    lines.push(`      - "${BIND_ADDRESS_PREFIX}${port}:3000"`);
     lines.push("");
     lines.push("    volumes:");
     // Same targets as docker-compose.example.yml: the worker logs to /logs and

package/src/commands/onboard/env-generator.ts

@@ -35,9 +35,14 @@ export function generateEnv(state: OnboardState, env: NodeJS.ProcessEnv = proces
     lines.push(`INSTALL_PRESET=${state.presetId}`);
   }
 
-  // Telemetry knobs from the installer's environment, so the first boot already
-  // honours them (`ANONYMIZED_TELEMETRY=false`, `DESPLEGA_TELEMETRY_ENV=<cohort>`).
-  for (const key of ["ANONYMIZED_TELEMETRY", "DESPLEGA_TELEMETRY_ENV"]) {
+  // Knobs from the installer's environment, so the first boot already honours
+  // them: telemetry (`ANONYMIZED_TELEMETRY=false`, `DESPLEGA_TELEMETRY_ENV=<cohort>`)
+  // and the host address for published ports (`AGENT_SWARM_BIND_ADDRESS=127.0.0.1`).
+  for (const key of [
+    "ANONYMIZED_TELEMETRY",
+    "DESPLEGA_TELEMETRY_ENV",
+    "AGENT_SWARM_BIND_ADDRESS",
+  ]) {
     const value = env[key]?.trim();
     if (value) lines.push(`${key}=${value}`);
   }