@desplega.ai/agent-swarm 1.161.0 → 1.162.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@desplega.ai/agent-swarm",
-  "version": "1.161.0",
+  "version": "1.162.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",
@@ -82,6 +82,13 @@
     "check:ai-toolbox-skills": "bun scripts/sync-ai-toolbox-skills.ts --check",
     "check:skill-sources": "bun scripts/check-skill-sources.ts",
     "check:operator-skill": "bun scripts/check-operator-skill.ts",
+    "sync:telemetry-contract": "bun scripts/sync-telemetry-contract.ts",
+    "check:telemetry-contract": "bun scripts/sync-telemetry-contract.ts --check",
+    "build:telemetry-docs": "bun scripts/gen-telemetry-docs.ts",
+    "check:telemetry-docs": "bun scripts/gen-telemetry-docs.ts --check",
+    "build:claude-mod": "bun scripts/build-claude-mod.ts",
+    "check:claude-mod": "bun scripts/build-claude-mod.ts --check",
+    "test:claude-mod": "bash scripts/test-claude-mod.sh",
     "build:script-types": "bun scripts/bundle-script-types.ts",
     "build:extension-types": "bun scripts/bundle-extension-types.ts",
     "build:extension-schema": "bun scripts/build-extension-manifest-schema.ts",
@@ -187,17 +194,17 @@
     "bun": ">=1.3.12"
   },
   "dependencies": {
-    "@agentclientprotocol/sdk": "1.6.0",
+    "@agentclientprotocol/sdk": "1.7.0",
     "@ai-sdk/openai": "^3.0.41",
-    "@anthropic-ai/claude-agent-sdk": "0.3.287",
+    "@anthropic-ai/claude-agent-sdk": "0.3.289",
     "@anthropic-ai/sdk": "^0.131.0",
     "@asteasolutions/zod-to-openapi": "^8.0.0",
     "@aws-sdk/client-bedrock": "3.1048.0",
     "@desplega.ai/business-use": "^0.4.2",
     "@desplega.ai/localtunnel": "^2.2.0",
-    "@earendil-works/pi-agent-core": "^1.0.0",
-    "@earendil-works/pi-ai": "^1.0.0",
-    "@earendil-works/pi-coding-agent": "^1.0.0",
+    "@earendil-works/pi-agent-core": "^1.0.2",
+    "@earendil-works/pi-ai": "^1.0.2",
+    "@earendil-works/pi-coding-agent": "^1.0.2",
     "@inkjs/ui": "^2.0.0",
     "@linear/sdk": "^77.0.0",
     "@modelcontextprotocol/sdk": "1.29.0",

package/src/be/api-drain.ts

@@ -0,0 +1,184 @@
+/**
+ * API drain: what the API does between SIGTERM and closing its HTTP server.
+ *
+ * On a deploy the orchestrator stops the API and the workers together, and the
+ * workers' own SIGTERM handoff (`POST /api/tasks/:id/supersede`) lands after the
+ * API is gone, so every in-flight task falls through to the heartbeat sweep.
+ * Draining flips that order: the API keeps serving, dispatches no new work,
+ * marks every response with `X-Swarm-Draining: 1` (see `src/utils/api-drain.ts`),
+ * and waits, bounded, until the tasks it saw in flight have been handed off.
+ *
+ * The state is process-local. A new API process starts not draining.
+ */
+
+import { API_DRAIN_MAX_MS_LIMIT } from "../utils/api-drain";
+import { scrubSecrets } from "../utils/secret-scrubber";
+import { getDbClient } from "./db";
+
+/**
+ * Default cap on the wait for worker handoffs: `0`, the drain is off. It is
+ * opt-in because it makes every live worker supersede its in-flight tasks on
+ * any API SIGTERM, including an API-only restart where those tasks would
+ * otherwise keep running. A deploy that stops the API and the workers together
+ * sets `API_DRAIN_MAX_MS` (e.g. `30000`) to turn it on.
+ */
+export const DEFAULT_API_DRAIN_MAX_MS = 0;
+const DRAIN_CHECK_INTERVAL_MS = 500;
+/**
+ * A worker pings every few seconds. One silent for longer than this is not
+ * expected to hand anything off; the heartbeat sweep owns its tasks.
+ */
+const LIVE_WORKER_WINDOW_MS = 30_000;
+
+let drainStartedAt: number | null = null;
+
+export function isApiDraining(): boolean {
+  return drainStartedAt !== null;
+}
+
+/** Enter the draining state. Returns false when already draining. */
+export function beginApiDrain(now: number = Date.now()): boolean {
+  if (drainStartedAt !== null) return false;
+  drainStartedAt = now;
+  return true;
+}
+
+/** Test seam: the state is module-level, so tests reset it between cases. */
+export function resetApiDrainForTesting(): void {
+  drainStartedAt = null;
+}
+
+/**
+ * `API_DRAIN_MAX_MS`, capped at `API_DRAIN_MAX_MS_LIMIT`. Unset, empty, or
+ * invalid means `DEFAULT_API_DRAIN_MAX_MS` (`0`, the drain is off).
+ */
+export function resolveApiDrainMaxMs(
+  env: Record<string, string | undefined> = process.env,
+): number {
+  const raw = env.API_DRAIN_MAX_MS;
+  if (raw === undefined || raw.trim() === "") return DEFAULT_API_DRAIN_MAX_MS;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed < 0) return DEFAULT_API_DRAIN_MAX_MS;
+  return Math.min(Math.floor(parsed), API_DRAIN_MAX_MS_LIMIT);
+}
+
+/** `in_progress` tasks held by an agent that pinged recently, i.e. one that can still hand off. */
+export async function listLiveInFlightTaskIds(now: number = Date.now()): Promise<string[]> {
+  const cutoff = new Date(now - LIVE_WORKER_WINDOW_MS).toISOString();
+  const rows = await getDbClient().query<{ id: string }>(
+    `SELECT t.id AS id
+       FROM agent_tasks t
+       JOIN agents a ON a.id = t.agentId
+      WHERE t.status = 'in_progress' AND a.status != 'offline' AND a.lastUpdatedAt >= ?`,
+    [cutoff],
+  );
+  return rows.map((row) => row.id);
+}
+
+/** How many of `taskIds` are still `in_progress`. */
+export async function countStillInProgress(taskIds: string[]): Promise<number> {
+  if (taskIds.length === 0) return 0;
+  const row = await getDbClient().get<{ n: number }>(
+    `SELECT count(*) AS n FROM agent_tasks
+      WHERE status = 'in_progress' AND id IN (SELECT value FROM json_each(?))`,
+    [JSON.stringify(taskIds)],
+  );
+  return row?.n ?? 0;
+}
+
+export interface ApiDrainDeps {
+  env?: Record<string, string | undefined>;
+  now?: () => number;
+  sleep?: (ms: number) => Promise<void>;
+  listInFlight?: () => Promise<string[]>;
+  countRemaining?: (taskIds: string[]) => Promise<number>;
+  log?: (message: string) => void;
+}
+
+export interface ApiDrainOutcome {
+  /** False when the cap is `0` (the default): the API did not enter the draining state. */
+  enabled: boolean;
+  /** Live in-flight tasks seen when the drain began. */
+  inFlight: number;
+  /** Of those, still `in_progress` when the wait ended. */
+  remaining: number;
+  waitedMs: number;
+  timedOut: boolean;
+}
+
+/**
+ * Enter the draining state, then wait until the live in-flight tasks are handed
+ * off or the cap passes. Never throws: a failed read ends the wait, because a
+ * shutdown that cannot finish is worse than one that skips the drain.
+ */
+export async function drainApi(deps: ApiDrainDeps = {}): Promise<ApiDrainOutcome> {
+  const now = deps.now ?? Date.now;
+  const sleep = deps.sleep ?? ((ms: number) => Bun.sleep(ms));
+  const log = deps.log ?? ((message: string) => console.log(message));
+  const listInFlight = deps.listInFlight ?? (() => listLiveInFlightTaskIds(now()));
+  const countRemaining = deps.countRemaining ?? countStillInProgress;
+  const maxMs = resolveApiDrainMaxMs(deps.env);
+  const startedAt = now();
+
+  if (maxMs === 0) {
+    log("[drain] off (API_DRAIN_MAX_MS is 0 or unset): closing without waiting for handoffs");
+    return { enabled: false, inFlight: 0, remaining: 0, waitedMs: 0, timedOut: false };
+  }
+
+  beginApiDrain(startedAt);
+
+  let taskIds: string[];
+  try {
+    taskIds = await listInFlight();
+  } catch (err) {
+    log(`[drain] could not read in-flight tasks, closing without waiting: ${describe(err)}`);
+    return {
+      enabled: true,
+      inFlight: 0,
+      remaining: 0,
+      waitedMs: now() - startedAt,
+      timedOut: false,
+    };
+  }
+
+  if (taskIds.length === 0) {
+    log("[drain] draining: no in-flight tasks on live workers");
+    return {
+      enabled: true,
+      inFlight: 0,
+      remaining: 0,
+      waitedMs: now() - startedAt,
+      timedOut: false,
+    };
+  }
+
+  log(
+    `[drain] draining: waiting up to ${maxMs}ms for ${taskIds.length} in-flight task(s) to be handed off`,
+  );
+
+  const deadline = startedAt + maxMs;
+  let remaining = taskIds.length;
+  while (true) {
+    try {
+      remaining = await countRemaining(taskIds);
+    } catch (err) {
+      log(`[drain] could not re-read in-flight tasks, closing now: ${describe(err)}`);
+      break;
+    }
+    if (remaining === 0 || now() >= deadline) break;
+    await sleep(Math.min(DRAIN_CHECK_INTERVAL_MS, Math.max(0, deadline - now())));
+  }
+
+  const waitedMs = now() - startedAt;
+  const timedOut = remaining > 0;
+  log(
+    timedOut
+      ? `[drain] timed out after ${waitedMs}ms with ${remaining} of ${taskIds.length} task(s) still in_progress`
+      : `[drain] all ${taskIds.length} in-flight task(s) handed off after ${waitedMs}ms`,
+  );
+  return { enabled: true, inFlight: taskIds.length, remaining, waitedMs, timedOut };
+}
+
+function describe(err: unknown): string {
+  return scrubSecrets(err instanceof Error ? err.message : String(err));
+}

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

@@ -1161,7 +1161,9 @@ export type ExistingTrackerContextWork = {
 
 const LINEAR_TRACKER_CONTEXT_KEY_PREFIX = "task:trackers:linear:";
 
-function isLinearTrackerContextKey(contextKey: string | null | undefined): contextKey is string {
+export function isLinearTrackerContextKey(
+  contextKey: string | null | undefined,
+): contextKey is string {
   return !!contextKey && contextKey.startsWith(LINEAR_TRACKER_CONTEXT_KEY_PREFIX);
 }
 
@@ -1170,28 +1172,51 @@ function isLinearTrackerContextKey(contextKey: string | null | undefined): conte
  *
  * Active means any non-terminal task. A completed task with persisted VCS PR/MR
  * metadata is also treated as existing work because the task can be complete
- * while the PR is still awaiting review/merge.
+ * while the PR is still awaiting review/merge. Delegation excludes the tracker
+ * root and all its descendants from both lookups.
  */
 export async function findExistingLinearTrackerContextWork(
   contextKey: string | null | undefined,
+  delegatingParentTaskId?: string,
 ): Promise<ExistingTrackerContextWork | null> {
   if (!isLinearTrackerContextKey(contextKey)) return null;
 
+  const lineageCte = `WITH RECURSIVE
+    ancestors(id, parentTaskId) AS (
+      SELECT id, parentTaskId FROM agent_tasks WHERE id = ? AND contextKey = ?
+      UNION
+      SELECT parent.id, parent.parentTaskId FROM agent_tasks parent
+      JOIN ancestors child ON parent.id = child.parentTaskId
+      WHERE parent.contextKey = ?
+    ),
+    lineage(id) AS (
+      SELECT id FROM ancestors
+      WHERE parentTaskId IS NULL OR parentTaskId NOT IN (SELECT id FROM ancestors)
+      UNION
+      SELECT child.id FROM agent_tasks child
+      JOIN lineage parent ON child.parentTaskId = parent.id
+    )`;
+  const lineageParams = [delegatingParentTaskId ?? null, contextKey, contextKey];
+
   const activeRow = await getDbClient().get<AgentTaskRow>(
-    `SELECT * FROM agent_tasks
+    `${lineageCte}
+     SELECT * FROM agent_tasks
        WHERE contextKey = ?
+       AND id NOT IN (SELECT id FROM lineage)
        AND status NOT IN ('completed', 'failed', 'cancelled', 'superseded')
        ORDER BY lastUpdatedAt DESC
        LIMIT 1`,
-    [contextKey],
+    [...lineageParams, contextKey],
   );
   if (activeRow) {
     return { task: rowToAgentTask(activeRow), reason: "active_task" };
   }
 
   const linkedPrRow = await getDbClient().get<AgentTaskRow>(
-    `SELECT * FROM agent_tasks
+    `${lineageCte}
+     SELECT * FROM agent_tasks
        WHERE contextKey = ?
+       AND id NOT IN (SELECT id FROM lineage)
        AND status = 'completed'
        AND vcsProvider IS NOT NULL
        AND vcsRepo IS NOT NULL
@@ -1199,7 +1224,7 @@ export async function findExistingLinearTrackerContextWork(
        AND vcsUrl IS NOT NULL
        ORDER BY lastUpdatedAt DESC
        LIMIT 1`,
-    [contextKey],
+    [...lineageParams, contextKey],
   );
   if (linkedPrRow) {
     return { task: rowToAgentTask(linkedPrRow), reason: "linked_open_pr" };

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

@@ -1,6 +1,6 @@
 import pkg from "../../../../package.json";
 import { defaultAssetKey } from "../../../assets/key";
-import type { telemetry } from "../../../telemetry";
+import type { TaskTelemetryEvent, TaskTelemetryInput } from "../../../telemetry-trigger";
 import type {
   Agent,
   AgentLog,
@@ -42,10 +42,11 @@ type TaskWriteDependencies = {
     agentId: string | null,
     sourceTexts: Array<string | null | undefined>,
   ) => Promise<TaskAttachment[]>;
-  emitTaskLifecycleTelemetryAfterCommit: (
-    event: string,
-    props: Parameters<typeof telemetry.taskEvent>[1],
+  emitTaskLifecycleTelemetryAfterCommit: <S extends TaskTelemetryEvent>(
+    event: S,
+    props: TaskTelemetryInput<S>,
     verify?: (task: AgentTask | null) => boolean,
+    actorUserId?: string | null,
   ) => void;
   taskContextForTelemetry: (task: AgentTask) => {
     provider?: ProviderName;

package/src/be/db.ts

@@ -10,6 +10,12 @@ import {
 import { realtimeBus } from "../realtime/bus";
 import { slackChannelFromContextKey } from "../tasks/slack-routing";
 import { _resolveIntegrationType, emitIntegrationConnected, telemetry } from "../telemetry";
+import { scheduleOrgDomainRecompute } from "../telemetry-identity";
+import {
+  emitTaskTelemetry,
+  type TaskTelemetryEvent,
+  type TaskTelemetryInput,
+} from "../telemetry-trigger";
 import type {
   ActiveSession,
   Agent,
@@ -281,6 +287,7 @@ export {
   getTasksCount,
   hasNonTerminalRerouteDecisionChild,
   hasNonTerminalResumeChild,
+  isLinearTrackerContextKey,
   markFinalizedSlackRelaysDelivered,
   markSlackRelayAttempted,
   markSlackRelayDelivered,
@@ -331,7 +338,6 @@ configureTaskReadDependencies({
   previewText: (text, maxChars) => previewText(text, maxChars),
 });
 
-type TaskTelemetryProps = Parameters<typeof telemetry.taskEvent>[1];
 type TaskTelemetryContext = {
   provider?: ProviderName;
   harnessVariant?: string;
@@ -347,23 +353,27 @@ function assetKeyPrefixPattern(input: string): string {
   return literalPrefixPattern(normalizeAssetKey(input));
 }
 
-function emitTaskLifecycleTelemetryAfterCommit(
-  event: string,
-  props: TaskTelemetryProps,
+function emitTaskLifecycleTelemetryAfterCommit<S extends TaskTelemetryEvent>(
+  event: S,
+  props: TaskTelemetryInput<S>,
   verify?: (task: AgentTask | null) => boolean,
+  actorUserId?: string | null,
 ): void {
   // afterCommit (not queueMicrotask): under an async client transaction,
   // microtasks drain before COMMIT, so the verify read could observe
   // uncommitted state. afterCommit runs strictly post-COMMIT/ROLLBACK.
   getDbClient().afterCommit(() => {
+    // `trigger_surface` is resolved (one read up the parent chain) and
+    // `source` renamed to `task_source` inside emitTaskTelemetry, so every
+    // lifecycle event of a task reports the same root surface.
     if (!verify) {
-      telemetry.taskEvent(event, props);
+      void emitTaskTelemetry(event, props, actorUserId);
       return;
     }
-    getTaskById(props.taskId)
+    getTaskById((props as { taskId: string }).taskId)
       .then((task) => {
         if (!verify(task)) return;
-        telemetry.taskEvent(event, props);
+        return emitTaskTelemetry(event, props, actorUserId);
       })
       .catch((err) =>
         console.error(
@@ -2896,6 +2906,8 @@ export async function createTaskExtended(
       priority: row.priority,
     },
     (task) => task !== null,
+    // The human who asked (a pseudonymous user_ref), null for system tasks.
+    row.requestedByUserId,
   );
 
   getDbClient().afterCommit(() => {
@@ -7352,12 +7364,17 @@ export async function createWorkflow(
   if (!row) throw new Error("Failed to create workflow");
   const workflow = rowToWorkflow(row);
   // afterCommit: a caller's transaction that rolls back must not report the workflow.
+  const requestUserId = getCurrentRequestUserId();
   getDbClient().afterCommit(() =>
-    telemetry.workflow("created", {
-      workflowId: workflow.id,
-      nodeCount: workflow.definition.nodes.length,
-      ...(source ? { source } : {}),
-    }),
+    telemetry.workflow(
+      "created",
+      {
+        workflowId: workflow.id,
+        nodeCount: workflow.definition.nodes.length,
+        ...(source ? { via: source } : {}),
+      },
+      { userId: requestUserId ?? null },
+    ),
   );
   return workflow;
 }
@@ -7578,11 +7595,13 @@ async function deleteWorkflowRows(id: string, source?: "api" | "mcp"): Promise<b
   const deleted = result.changes > 0;
   if (deleted) {
     // afterCommit: a caller's transaction that rolls back must not report the delete.
+    const requestUserId = getCurrentRequestUserId();
     getDbClient().afterCommit(() =>
-      telemetry.workflow("deleted", {
-        workflowId: id,
-        ...(source ? { source } : {}),
-      }),
+      telemetry.workflow(
+        "deleted",
+        { workflowId: id, ...(source ? { via: source } : {}) },
+        { userId: requestUserId ?? null },
+      ),
     );
   }
   return deleted;
@@ -7669,6 +7688,7 @@ export async function getWorkflowRun(id: string): Promise<WorkflowRun | null> {
 
 function emitWorkflowTerminalTelemetry(run: WorkflowRun): void {
   if (run.status !== "completed" && run.status !== "failed") return;
+  const status = run.status;
 
   // afterCommit (not queueMicrotask): under an async client transaction,
   // microtasks drain before COMMIT, so the verify read below could observe
@@ -7678,9 +7698,9 @@ function emitWorkflowTerminalTelemetry(run: WorkflowRun): void {
   // crashing the process as an unhandled rejection.
   getDbClient().afterCommit(async () => {
     const latest = await getWorkflowRun(run.id);
-    if (!latest || latest.status !== run.status) return;
+    if (!latest || latest.status !== status) return;
     const steps = await getWorkflowRunStepsByRunId(run.id);
-    telemetry.workflow(run.status, {
+    telemetry.workflow(status, {
       workflowId: run.workflowId,
       durationMs: run.startedAt ? Date.now() - new Date(run.startedAt).getTime() : undefined,
       stepsCompleted: steps.filter((step) => step.status === "completed").length,
@@ -12046,6 +12066,8 @@ export async function createUser(data: {
     ],
   );
   if (!row) throw new Error("Failed to create user");
+  // The org's email domain may come from this user (debounced, post-commit).
+  getDbClient().afterCommit(scheduleOrgDomainRecompute);
   return rowToUser(row);
 }
 
@@ -12118,6 +12140,7 @@ export async function updateUser(
     `UPDATE users SET ${sets.join(", ")} WHERE id = ? RETURNING *`,
     params,
   );
+  if (row) getDbClient().afterCommit(scheduleOrgDomainRecompute);
   return row ? rowToUser(row) : null;
 }
 
@@ -12227,6 +12250,7 @@ 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);
     return result.changes > 0;
   });
 }

package/src/be/memory/link-resolver.ts

@@ -6,6 +6,7 @@
  * Phase 1: capture layer only — no traversal tools, no reranker integration.
  */
 import { getDbClient } from "@/be/db";
+import { getConfiguredAppUrls } from "@/utils/constants";
 
 export type LinkType =
   | "wikilink"
@@ -41,8 +42,8 @@ const WIKILINK_RE = /\[\[([^\]]+)\]\]/g;
 const PR_HASH_RE = /(?:^|[\s(])#(\d{1,5})(?=[\s,.)!?]|$)/gm;
 const PR_PREFIX_RE = /\bPR\s*#(\d{1,5})\b/gi;
 const GITHUB_PR_URL_RE = /https?:\/\/github\.com\/([\w.-]+)\/([\w.-]+)\/pull\/(\d+)/g;
-const AGENT_FS_PATH_RE =
-  /(?:agent-fs|live\.agent-fs\.dev)\/file\/~\/([a-f0-9-]+)\/([a-f0-9-]+)\/([\w/.%-]+)/g;
+const AGENT_FS_LIVE_HOSTS = String.raw`agent-fs|live\.agent-fs\.dev`;
+const AGENT_FS_FILE_ROUTE = String.raw`\/file\/~\/([a-f0-9-]+)\/([a-f0-9-]+)\/([\w/.%-]+)`;
 const AGENT_UI_PAGE_RE = /(?:app\.[^/]+|localhost:\d+)\/pages\/([a-f0-9-]+)/g;
 const AGENT_UI_TASK_RE = /(?:app\.[^/]+|localhost:\d+)\/tasks\/([a-f0-9-]+)/g;
 
@@ -111,9 +112,34 @@ const prMatcher: Matcher = (content) => {
   return results;
 };
 
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
+}
+
+/**
+ * agent-fs file links: the live UI, and the dashboard (Comb) at a configured
+ * `APP_URL` / `DASHBOARD_URL` or `localhost:<port>`. Both use the same
+ * `/file/~/<org>/<drive>/<path>` route and path encoding, so they resolve to
+ * the same target. Built per call: a config reload can change the app URLs.
+ * A host must start the host name (`evil-swarm.example.com` does not match
+ * `swarm.example.com`). Hosts are case-insensitive.
+ */
+function agentFsPathRegex(): RegExp {
+  const appHosts = getConfiguredAppUrls().flatMap((value) => {
+    try {
+      const url = new URL(value);
+      return [escapeRegExp(`${url.host}${url.pathname.replace(/\/+$/, "")}`)];
+    } catch {
+      return [];
+    }
+  });
+  const hosts = [AGENT_FS_LIVE_HOSTS, ...appHosts, String.raw`localhost:\d+`].join("|");
+  return new RegExp(`(?<![\\w.-])(?:${hosts})${AGENT_FS_FILE_ROUTE}`, "gi");
+}
+
 const agentFsMatcher: Matcher = (content) => {
   const results: MatcherResult[] = [];
-  for (const match of content.matchAll(AGENT_FS_PATH_RE)) {
+  for (const match of content.matchAll(agentFsPathRegex())) {
     const orgId = match[1]!;
     const driveId = match[2]!;
     const path = match[3]!;

package/src/be/migrations/192_favorites_agent_fs_path.sql

@@ -0,0 +1,36 @@
+-- Comb pins: an agent-fs file or folder can be a favorite. The item id is
+-- `<orgId>/<driveId>/<path>` (a folder path ends with "/"). SQLite cannot
+-- change a CHECK in place, so rebuild the table with the 116 shape plus the
+-- new item type. Every row is copied unchanged.
+
+CREATE TABLE user_favorites_new (
+  id            TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(16)))),
+  favoriteScope TEXT NOT NULL,
+  userId        TEXT REFERENCES users(id) ON DELETE CASCADE,
+  itemType      TEXT NOT NULL CHECK (itemType IN ('page','workflow','schedule','agent-fs-path')),
+  itemId        TEXT NOT NULL,
+  createdAt     TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  lastUpdatedAt TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  created_by    TEXT,
+  updated_by    TEXT,
+  UNIQUE (favoriteScope, itemType, itemId)
+);
+
+INSERT INTO user_favorites_new (
+  id, favoriteScope, userId, itemType, itemId,
+  createdAt, lastUpdatedAt, created_by, updated_by
+)
+SELECT
+  id, favoriteScope, userId, itemType, itemId,
+  createdAt, lastUpdatedAt, created_by, updated_by
+FROM user_favorites;
+
+DROP TABLE user_favorites;
+ALTER TABLE user_favorites_new RENAME TO user_favorites;
+
+CREATE INDEX idx_user_favorites_scope_type
+  ON user_favorites(favoriteScope, itemType);
+CREATE INDEX idx_user_favorites_user_type
+  ON user_favorites(userId, itemType);
+CREATE INDEX idx_user_favorites_item
+  ON user_favorites(itemType, itemId);

package/src/be/onboarding.ts

@@ -1,5 +1,6 @@
 import { telemetry } from "../telemetry";
 import { ProviderNameSchema } from "../types";
+import { getCurrentRequestUserId } from "../utils/request-auth-context";
 import { z } from "../utils/zod-openapi";
 import { getDbClient, getSwarmConfigs, getTaskById, upsertSwarmConfig } from "./db";
 import { validateConfigValue } from "./swarm-config-guard";
@@ -23,6 +24,7 @@ export const OnboardingErrorClassSchema = z.enum([
   "timeout",
   "dimension",
   "model",
+  "endpoint",
   "not_enabled",
   "expired",
   "unknown",
@@ -48,6 +50,7 @@ export const OnboardingMemoryPresetSchema = z.enum([
   "openai",
   "openrouter",
   "vercel",
+  "azure",
   "custom",
   "existing",
 ]);
@@ -359,8 +362,11 @@ function addTelemetry<Event extends OnboardingTelemetryEvent>(
 }
 
 function queueTelemetry(events: PendingTelemetry[]): void {
+  // Captured now: the request's user is ambient state, and the post-commit hook
+  // may run after it has moved on. Null for an operator (API key) request.
+  const actor = { userId: getCurrentRequestUserId() ?? null };
   for (const item of events) {
-    getDbClient().afterCommit(() => telemetry.onboarding(item.event, item.properties));
+    getDbClient().afterCommit(() => telemetry.onboarding(item.event, item.properties, actor));
   }
 }
 

package/src/be/seed-prompt-templates.ts

@@ -15,6 +15,7 @@ import { getPromptTemplates, resetPromptTemplateToDefault, upsertPromptTemplate
 // handler imports, but runner/session templates are only loaded by the worker. Importing them
 // here ensures all templates are available for the render endpoint and seeded to the DB.
 import "../prompts/session-templates";
+import "../comb/templates";
 import "../commands/templates";
 import "../tools/templates";