@desplega.ai/agent-swarm 1.131.0 → 1.133.1

package/src/http/schedules.ts

@@ -40,7 +40,7 @@ const scheduleUpdateBodySchema = z.object({
   taskTemplate: z.string().optional(),
   taskType: z.string().optional(),
   tags: z.array(z.string()).optional(),
-  priority: z.number().int().optional(),
+  priority: z.number().int().min(0).max(100).optional(),
   targetAgentId: z.string().nullable().optional(),
   enabled: z.boolean().optional(),
   timezone: z.string().optional(),
@@ -96,7 +96,7 @@ const createSchedule = route({
     taskTemplate: z.string().min(1).optional(),
     taskType: z.string().optional(),
     tags: z.array(z.string()).optional(),
-    priority: z.number().int().optional(),
+    priority: z.number().int().min(0).max(100).optional(),
     targetAgentId: z.string().optional(),
     enabled: z.boolean().optional(),
     timezone: z.string().optional(),

package/src/http/scripts.ts

@@ -24,7 +24,9 @@ import {
   listScriptApisForScript,
   listScripts,
   listScriptVersions,
+  restoreScratchScriptLastUsedIfUnchanged,
   rotateScriptApiSecret,
+  touchScratchScriptLastUsed,
   updateScriptApi,
   upsertScriptByName,
 } from "../be/scripts/db";
@@ -51,7 +53,7 @@ import {
   ScriptVersionRecordSchema,
 } from "../types";
 import { scrubObject, scrubSecrets } from "../utils/secret-scrubber";
-import { route } from "./route-def";
+import { route, runtimeInstanceHeader } from "./route-def";
 import { json, jsonError } from "./utils";
 
 const scriptNameSchema = z.string().min(1).max(200);
@@ -242,6 +244,7 @@ const runRoute = route({
   description:
     "Inline source skips typecheck and is auto-saved as a scratch script only on success.",
   tags: ["Scripts"],
+  headers: runtimeInstanceHeader("acquire work through the script SDK"),
   body: runBodySchema,
   responses: {
     200: { description: "Script run completed", schema: scriptRunResponseSchema },
@@ -693,14 +696,23 @@ export async function handleScripts(
     const agent = requireAgent(res, agentId);
     if (!agent) return true;
 
+    // Per-boot identity of the invoking worker process. Carried into the
+    // script runtime as system context so SDK work-acquisition calls present
+    // the same runtime the worker itself would — never script input.
+    const runtimeInstanceId = ((h) => (Array.isArray(h) ? h[0] : h))(
+      req.headers["x-runtime-instance-id"],
+    );
+
     let source = parsed.body.source;
     let fsMode = parsed.body.fsMode;
+    let namedScript: ScriptRecord | null = null;
     if (parsed.body.name) {
       const script = resolveScript(parsed.body.name, agent.id, parsed.body.scope);
       if (!script) {
         jsonError(res, "Script not found", 404);
         return true;
       }
+      namedScript = script;
       source = script.source;
       fsMode = script.fsMode;
     }
@@ -711,21 +723,37 @@ export async function handleScripts(
     }
 
     const startedAt = new Date().toISOString();
+    // Touch before executing so an already-stale scratch script isn't reaped
+    // by the retention sweep while this run is still in flight.
+    const runStartTouch = namedScript?.isScratch
+      ? touchScratchScriptLastUsed(namedScript.id)
+      : null;
     const credentials = await buildScriptCredentialBindingsWithFailures({ agentId: agent.id });
     const output = await runScript({
       source: source as string,
       args: parsed.body.args,
       fsMode,
       agentId: agent.id,
+      runtimeInstanceId,
       egressSecrets: credentials.egressSecrets,
       failedBindings: credentials.failedBindings,
       apiConnections: getScriptApiConnectionDescriptors({ agentId: agent.id }),
       mcpConnections: getScriptMcpConnectionDescriptors({ agentId: agent.id }),
     });
+    const ok = output.exitCode === 0 && !output.error && !output.runtimeError;
+
+    if (namedScript?.isScratch && ok) {
+      touchScratchScriptLastUsed(namedScript.id);
+    } else if (namedScript?.isScratch && runStartTouch) {
+      // Failed run — restore the pre-run timestamp so it doesn't buy the
+      // script another retention window, unless a concurrent run already
+      // touched it since.
+      restoreScratchScriptLastUsedIfUnchanged(namedScript.id, namedScript.updatedAt, runStartTouch);
+    }
 
     // Persist output to KV when idempotencyKey is provided and run succeeded
     let kvSaved: { namespace: string; key: string } | undefined;
-    if (parsed.body.idempotencyKey && !output.error && output.exitCode === 0) {
+    if (parsed.body.idempotencyKey && ok) {
       const kvNamespace = `script:executions`;
       const kvKey = parsed.body.idempotencyKey;
       const kvValue = {
@@ -745,7 +773,7 @@ export async function handleScripts(
     }
 
     let autoSaved: { slug: string; reason: string } | undefined;
-    if (parsed.body.source && !output.error && output.exitCode === 0) {
+    if (parsed.body.source && ok) {
       const slug = scratchSlug(parsed.body.intent, parsed.body.source);
       await upsertScriptByName({
         name: slug,
@@ -767,7 +795,6 @@ export async function handleScripts(
     // Persist the inline run (no journal) so one-off executions show up alongside
     // durable workflow runs in the Script Runs dashboard. Best-effort: recording
     // must never fail the actual execution.
-    const ok = output.exitCode === 0 && !output.error && !output.runtimeError;
     const runError = ok
       ? undefined
       : scrubSecrets(

package/src/http/session-data.ts

@@ -5,6 +5,7 @@ import {
   createSessionLogs,
   getActivePricingRow,
   getAllSessionCosts,
+  getAttributionByPerson,
   getDashboardCostSummary,
   getSessionCostSummary,
   getSessionCostsByAgentId,
@@ -34,6 +35,9 @@ const SessionCostSummaryTotalsSchema = z.object({
   totalSessions: z.number().int(),
   avgCostPerSession: z.number(),
   attributedCostUsd: z.number(),
+  attributableCostUsd: z.number(),
+  excludedCostUsd: z.number(),
+  excludedTaskCount: z.number().int(),
 });
 
 /** Mirrors `SessionCostDailyRow` in src/be/db.ts. */
@@ -79,6 +83,17 @@ const DashboardCostSummarySchema = z.object({
   costMtd: z.number(),
 });
 
+/** Mirrors `AttributionByPersonRow` in src/be/db.ts. */
+const AttributionByPersonRowSchema = z.object({
+  userId: z.string(),
+  problemsInitiated: z.number().int(),
+  problemsShipped: z.number().int(),
+  agentsReached: z.number().int(),
+  reposReached: z.number().int(),
+  surfacesReached: z.number().int(),
+  firstPassYield: z.null(),
+});
+
 // ─── Route Definitions ───────────────────────────────────────────────────────
 
 const createSessionLogsRoute = route({
@@ -203,6 +218,24 @@ const getSessionCostSummaryRoute = route({
   },
 });
 
+const getAttributionByPersonRoute = route({
+  method: "get",
+  path: "/api/attribution/by-person",
+  pattern: ["api", "attribution", "by-person"],
+  summary: "Four-metric per-person attribution (problems initiated/shipped, reach)",
+  tags: ["Session Data"],
+  query: z.object({
+    startDate: z.string().optional(),
+    endDate: z.string().optional(),
+  }),
+  responses: {
+    200: {
+      description: "Per-person attribution rows",
+      schema: z.object({ rows: z.array(AttributionByPersonRowSchema) }),
+    },
+  },
+});
+
 const getDashboardCosts = route({
   method: "get",
   path: "/api/session-costs/dashboard",
@@ -403,6 +436,17 @@ export async function handleSessionData(
     return true;
   }
 
+  if (getAttributionByPersonRoute.match(req.method, pathSegments)) {
+    const parsed = await getAttributionByPersonRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+    const rows = getAttributionByPerson({
+      startDate: parsed.query.startDate || undefined,
+      endDate: parsed.query.endDate || undefined,
+    });
+    getAttributionByPersonRoute.respond(res, 200, { rows });
+    return true;
+  }
+
   if (listSessionCosts.match(req.method, pathSegments)) {
     const parsed = await listSessionCosts.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;

package/src/http/tasks.ts

@@ -220,7 +220,7 @@ const createTask = route({
     agentId: z.string().optional(),
     taskType: z.string().optional(),
     tags: z.array(z.string()).optional(),
-    priority: z.number().int().optional(),
+    priority: z.number().int().min(0).max(100).optional(),
     dependsOn: z.array(z.string()).optional(),
     offeredTo: z.string().optional(),
     dir: z.string().optional(),
@@ -760,7 +760,7 @@ export async function handleTasks(
         creatorAgentId: myAgentId || undefined,
         taskType: parsed.body.taskType || undefined,
         tags: parsed.body.tags || undefined,
-        priority: parsed.body.priority || 50,
+        priority: parsed.body.priority,
         dependsOn: parsed.body.dependsOn || undefined,
         offeredTo: parsed.body.offeredTo || undefined,
         dir: parsed.body.dir || undefined,

package/src/http/users.ts

@@ -32,6 +32,7 @@ import {
   deleteKv,
   deleteUser,
   getAllUsers,
+  getDb,
   getUserById,
   listKv,
   updateUser,
@@ -48,7 +49,7 @@ import {
   revokeToken,
   unlinkIdentity,
 } from "../be/users";
-import { UserSchema } from "../types";
+import { UserCommsPrefsSchema, UserSchema } from "../types";
 import { getRequestAuth } from "../utils/request-auth-context";
 import { getOperatorActor } from "./operator-actor";
 import { route } from "./route-def";
@@ -296,6 +297,11 @@ const updateUserRoute = route({
       preferredChannel: z.string().optional(),
       timezone: z.string().optional(),
       metadata: z.record(z.string(), z.unknown()).nullable().optional(),
+      comms: UserCommsPrefsSchema.nullable()
+        .optional()
+        .describe(
+          "Merges into metadata.comms without touching sibling metadata keys; null removes only the comms key. When metadata is also provided, it is applied first and replaces the whole blob.",
+        ),
       dailyBudgetUsd: z.number().nullable().optional(),
       status: z.enum(["invited", "active", "suspended"]).optional(),
       // Complete-list diff: passing this replaces the user's identity set,
@@ -776,60 +782,63 @@ export async function handleUsers(
     }
 
     try {
-      // Move every identity from source → target.
-      for (const ident of sourceBefore.identities) {
-        unlinkIdentity(sourceId, ident.kind, ident.externalId, actor);
-        linkIdentity(targetId, ident.kind, ident.externalId, actor);
-      }
+      const mergedUser = getDb().transaction(() => {
+        // Move every identity from source → target.
+        for (const ident of sourceBefore.identities) {
+          unlinkIdentity(sourceId, ident.kind, ident.externalId, actor);
+          linkIdentity(targetId, ident.kind, ident.externalId, actor);
+        }
 
-      // Merge email aliases — append source.email + source.emailAliases into
-      // target.emailAliases (de-duped). Emit `email_added` per added alias.
-      const targetAliases = new Set(targetBefore.emailAliases ?? []);
-      const targetPrimary = (targetBefore.email ?? "").toLowerCase();
-      const newAliases: string[] = [];
-      const candidates = [
-        ...(sourceBefore.email ? [sourceBefore.email] : []),
-        ...(sourceBefore.emailAliases ?? []),
-      ];
-      for (const candidate of candidates) {
-        const lower = candidate.toLowerCase();
-        if (!lower || lower === targetPrimary) continue;
-        if (
-          ![...targetAliases].some((a) => a.toLowerCase() === lower) &&
-          !newAliases.some((a) => a.toLowerCase() === lower)
-        ) {
-          newAliases.push(candidate);
+        // Merge email aliases — append source.email + source.emailAliases into
+        // target.emailAliases (de-duped). Emit `email_added` per added alias.
+        const targetAliases = new Set(targetBefore.emailAliases ?? []);
+        const targetPrimary = (targetBefore.email ?? "").toLowerCase();
+        const newAliases: string[] = [];
+        const candidates = [
+          ...(sourceBefore.email ? [sourceBefore.email] : []),
+          ...(sourceBefore.emailAliases ?? []),
+        ];
+        for (const candidate of candidates) {
+          const lower = candidate.toLowerCase();
+          if (!lower || lower === targetPrimary) continue;
+          if (
+            ![...targetAliases].some((a) => a.toLowerCase() === lower) &&
+            !newAliases.some((a) => a.toLowerCase() === lower)
+          ) {
+            newAliases.push(candidate);
+          }
         }
-      }
-      if (newAliases.length > 0) {
-        const merged = [...(targetBefore.emailAliases ?? []), ...newAliases];
-        updateUser(targetId, { emailAliases: merged });
-        for (const alias of newAliases) {
-          recordIdentityEvent(targetId, "email_added", actor, null, { email: alias });
+        if (newAliases.length > 0) {
+          const merged = [...(targetBefore.emailAliases ?? []), ...newAliases];
+          updateUser(targetId, { emailAliases: merged });
+          for (const alias of newAliases) {
+            recordIdentityEvent(targetId, "email_added", actor, null, { email: alias });
+          }
         }
-      }
 
-      // Delete source — CASCADE cleans up any leftover external_ids row that
-      // we may have missed (and clears tasks.requestedByUserId pointers).
-      deleteUser(sourceId);
-
-      // Single manual_merge event on target capturing the before/after rows.
-      // The source row is deleted above, so carry a minimal snapshot of the
-      // source user ({id, name, email}) inside the `after` payload under
-      // `source` — this lets the UI render "Merged manually from X → Y".
-      const targetAfter = composeUser(targetId);
-      recordIdentityEvent(targetId, "manual_merge", actor, targetBefore, {
-        ...targetAfter,
-        source: {
-          id: sourceBefore.id,
-          name: sourceBefore.name,
-          email: sourceBefore.email,
-        },
-      });
+        // Delete source — CASCADE cleans up any leftover external_ids row that
+        // we may have missed. Retained user references move to the target.
+        deleteUser(sourceId, targetId);
+
+        // Single manual_merge event on target capturing the before/after rows.
+        // The source row is deleted above, so carry a minimal snapshot of the
+        // source user ({id, name, email}) inside the `after` payload under
+        // `source` — this lets the UI render "Merged manually from X → Y".
+        const targetAfter = composeUser(targetId);
+        recordIdentityEvent(targetId, "manual_merge", actor, targetBefore, {
+          ...targetAfter,
+          source: {
+            id: sourceBefore.id,
+            name: sourceBefore.name,
+            email: sourceBefore.email,
+          },
+        });
 
-      // Re-compose AFTER the event so the response surfaces the merge event in
-      // recentEvents (otherwise the timeline is missing the event we just wrote).
-      mergeUsersRoute.respond(res, 200, { user: composeUser(targetId) });
+        // Re-compose AFTER the event so the response surfaces the merge event in
+        // recentEvents (otherwise the timeline is missing the event we just wrote).
+        return composeUser(targetId);
+      })();
+      mergeUsersRoute.respond(res, 200, { user: mergedUser });
     } catch (err) {
       jsonError(res, err instanceof Error ? err.message : "Failed to merge users", 500);
     }
@@ -863,10 +872,23 @@ export async function handleUsers(
     }
 
     try {
-      const { identities, metadata, ...rest } = parsed.body;
+      const { identities, metadata, comms, ...rest } = parsed.body;
       // updateUser doesn't accept `metadata: null` directly — passthrough via cast.
       const update: Parameters<typeof updateUser>[1] = { ...rest };
-      if (metadata !== undefined) {
+      if (comms !== undefined) {
+        // Merge-safe write: metadata (if provided) is applied first and
+        // replaces the whole blob, then comms is merged into it so sibling
+        // metadata keys survive.
+        const base: Record<string, unknown> = {
+          ...(metadata !== undefined ? (metadata ?? {}) : (before.metadata ?? {})),
+        };
+        if (comms === null) {
+          delete base.comms;
+        } else {
+          base.comms = comms;
+        }
+        update.metadata = Object.keys(base).length > 0 ? base : null;
+      } else if (metadata !== undefined) {
         update.metadata = metadata as Record<string, unknown> | null;
       }
       const updated = updateUser(parsed.params.id, update);

package/src/http/webhooks.ts

@@ -50,7 +50,7 @@ import {
 import type { KapsoConfig } from "../integrations/kapso/config";
 import { getKapsoConfig } from "../integrations/kapso/config";
 import type { KapsoWebhookPayload } from "../integrations/kapso/inbound";
-import { routeKapsoInbound } from "../integrations/kapso/inbound";
+import { resolveKapsoRequestedByUserId, routeKapsoInbound } from "../integrations/kapso/inbound";
 import { getExecutorRegistry } from "../workflows";
 import { workflowEventBus } from "../workflows/event-bus";
 import { handleWebhookTrigger, verifyHmacSignature, WebhookError } from "../workflows/triggers";
@@ -600,7 +600,10 @@ export async function handleWebhooks(
             rawBody,
             req.headers,
             getExecutorRegistry(),
-            { alreadyAuthenticated: true },
+            {
+              alreadyAuthenticated: true,
+              requestedByUserId: resolveKapsoRequestedByUserId(payload),
+            },
           );
           break;
         case "no_mapping":

package/src/http/workflows.ts

@@ -31,7 +31,6 @@ import {
   WorkflowSchema,
   WorkflowVersionSchema,
 } from "../types";
-import { getRequestAuth } from "../utils/request-auth-context";
 import { getExecutorRegistry, startWorkflowExecution } from "../workflows";
 import {
   applyDefinitionPatch,
@@ -827,13 +826,11 @@ export async function handleWorkflows(
       return true;
     }
     const body = await parseBody<Record<string, unknown>>(req);
-    const auth = getRequestAuth(req);
-
     let runId: string;
     try {
       runId = await startWorkflowExecution(workflow, body, getExecutorRegistry(), {
         triggerType: "api",
-        requestedByUserId: auth?.kind === "user" ? auth.userId : workflow.createdBy,
+        requestedByUserId: resolveHttpAuditUserId(req, myAgentId) ?? undefined,
       });
     } catch (err) {
       if (err instanceof TriggerSchemaError) {

package/src/http/x.ts

@@ -12,6 +12,8 @@ import {
   getScriptApiSecret,
   getScriptById,
   recordScriptApiUsage,
+  restoreScratchScriptLastUsedIfUnchanged,
+  touchScratchScriptLastUsed,
 } from "../be/scripts/db";
 import {
   MAX_SCRIPT_WALL_CLOCK_MS,
@@ -228,6 +230,10 @@ export async function handleX(
   const timeoutMs = resolveTimeoutMs(req);
   const startedAt = new Date().toISOString();
 
+  // Touch before executing so an already-stale scratch script isn't reaped by
+  // the retention sweep while this run is still in flight.
+  const runStartTouch = script.isScratch ? touchScratchScriptLastUsed(script.id) : null;
+
   const credentials = await buildScriptCredentialBindingsWithFailures({
     agentId: endpoint.agentId,
   });
@@ -250,6 +256,14 @@ export async function handleX(
 
   const ok = output.exitCode === 0 && !output.error && !output.runtimeError;
   const error = ok ? null : buildExecutionError(output);
+  if (ok) {
+    touchScratchScriptLastUsed(script.id);
+  } else if (script.isScratch && runStartTouch) {
+    // Failed run — restore the pre-run timestamp so it doesn't buy the
+    // script another retention window, unless a concurrent run already
+    // touched it since.
+    restoreScratchScriptLastUsedIfUnchanged(script.id, script.updatedAt, runStartTouch);
+  }
 
   // Usage + observability — best-effort, must never fail the response.
   try {

package/src/integrations/kapso/inbound.ts

@@ -80,7 +80,7 @@ function resolveKapsoIdentity(externalId: string): IdentityResolution {
   return kapsoResolution;
 }
 
-function resolveKapsoRequestedByUserId(payload: KapsoWebhookPayload): string | undefined {
+export function resolveKapsoRequestedByUserId(payload: KapsoWebhookPayload): string | undefined {
   const externalId = normalizeKapsoSender(payload);
   if (!externalId) return undefined;
 

package/src/jira/outbound.ts

@@ -1,4 +1,5 @@
 import { getTrackerSync, updateTrackerSync } from "../be/db-queries/tracker";
+import { scrubSecrets } from "../utils/secret-scrubber";
 import { workflowEventBus } from "../workflows/event-bus";
 import { jiraFetch } from "./client";
 
@@ -28,14 +29,44 @@ const OUTPUT_TRUNCATE_CHARS = 4000;
  * as a known v1 limitation; a per-issue debounce / bounded outbound queue
  * could be added in v2 if it becomes a real problem.
  */
+/**
+ * `EventEmitter.emit()` calls listeners synchronously and discards whatever
+ * they return, so a rejected async handler is never seen by the emitting side
+ * — it escapes to the process-level `unhandledRejection` handler with no
+ * subsystem context. These wrappers observe the *complete* handler body,
+ * including work that runs before any internal `try` (e.g. `getTrackerSync`).
+ *
+ * Each wrapper is created once at module scope so `off()` is passed the exact
+ * reference `on()` registered; building them inside `init` would leave the
+ * listeners attached after teardown.
+ */
+function observed(
+  eventName: string,
+  handler: (data: unknown) => Promise<void>,
+): (data: unknown) => void {
+  return (data: unknown): void => {
+    handler(data).catch((error) => {
+      console.error(
+        `[Jira Outbound] ${eventName} handler failed:`,
+        scrubSecrets(error instanceof Error ? error.message : String(error)),
+      );
+    });
+  };
+}
+
+const onTaskCreated = observed("task.created", handleTaskCreated);
+const onTaskCompleted = observed("task.completed", handleTaskCompleted);
+const onTaskFailed = observed("task.failed", handleTaskFailed);
+const onTaskCancelled = observed("task.cancelled", handleTaskCancelled);
+
 export function initJiraOutboundSync(): void {
   if (subscribed) return;
   subscribed = true;
 
-  workflowEventBus.on("task.created", handleTaskCreated);
-  workflowEventBus.on("task.completed", handleTaskCompleted);
-  workflowEventBus.on("task.failed", handleTaskFailed);
-  workflowEventBus.on("task.cancelled", handleTaskCancelled);
+  workflowEventBus.on("task.created", onTaskCreated);
+  workflowEventBus.on("task.completed", onTaskCompleted);
+  workflowEventBus.on("task.failed", onTaskFailed);
+  workflowEventBus.on("task.cancelled", onTaskCancelled);
   console.log("[Jira] Outbound sync subscribed to event bus");
 }
 
@@ -43,10 +74,10 @@ export function teardownJiraOutboundSync(): void {
   if (!subscribed) return;
   subscribed = false;
 
-  workflowEventBus.off("task.created", handleTaskCreated);
-  workflowEventBus.off("task.completed", handleTaskCompleted);
-  workflowEventBus.off("task.failed", handleTaskFailed);
-  workflowEventBus.off("task.cancelled", handleTaskCancelled);
+  workflowEventBus.off("task.created", onTaskCreated);
+  workflowEventBus.off("task.completed", onTaskCompleted);
+  workflowEventBus.off("task.failed", onTaskFailed);
+  workflowEventBus.off("task.cancelled", onTaskCancelled);
   console.log("[Jira] Outbound sync unsubscribed from event bus");
 }
 

package/src/jira/webhook-lifecycle.ts

@@ -1,4 +1,5 @@
 import { getPublicMcpBaseUrl } from "../utils/constants";
+import { scrubSecrets } from "../utils/secret-scrubber";
 import { jiraFetch } from "./client";
 import { getJiraMetadata, updateJiraMetadata } from "./metadata";
 
@@ -359,11 +360,21 @@ export function startJiraWebhookKeepalive(): void {
   // Immediate-on-boot check (after a short delay so server finishes startup
   // and OAuth tokens are loaded). Mirrors src/oauth/keepalive.ts pattern.
   setTimeout(() => {
-    runKeepalive();
+    runKeepalive().catch((err) =>
+      console.error(
+        "[Jira webhook keepalive] run failed:",
+        scrubSecrets(err instanceof Error ? err.message : String(err)),
+      ),
+    );
   }, 10_000);
 
   keepaliveInterval = setInterval(() => {
-    runKeepalive();
+    runKeepalive().catch((err) =>
+      console.error(
+        "[Jira webhook keepalive] run failed:",
+        scrubSecrets(err instanceof Error ? err.message : String(err)),
+      ),
+    );
   }, TWELVE_HOURS_MS);
 }
 

package/src/linear/outbound.ts

@@ -1,5 +1,6 @@
 import { getTrackerSync, updateTrackerSync } from "../be/db-queries/tracker";
 import { ensureToken } from "../oauth/ensure-token";
+import { scrubSecrets } from "../utils/secret-scrubber";
 import { workflowEventBus } from "../workflows/event-bus";
 import { getLinearClient, resetLinearClient } from "./client";
 import { endAgentSession, postAgentSessionAction, taskSessionMap } from "./sync";
@@ -8,15 +9,47 @@ let subscribed = false;
 
 const LOOP_PREVENTION_WINDOW_MS = 5_000;
 
+/**
+ * `EventEmitter.emit()` calls listeners synchronously and discards whatever
+ * they return, so a rejected async handler is never seen by the emitting side
+ * — it escapes to the process-level `unhandledRejection` handler with no
+ * subsystem context. These wrappers observe the *complete* handler body,
+ * including work that runs before any internal `try` (e.g. `getTrackerSync`)
+ * and the `updateTrackerSync` write that runs after it.
+ *
+ * Each wrapper is created once at module scope so `off()` is passed the exact
+ * reference `on()` registered; building them inside `init` would leave the
+ * listeners attached after teardown.
+ */
+function observed(
+  eventName: string,
+  handler: (data: unknown) => Promise<void>,
+): (data: unknown) => void {
+  return (data: unknown): void => {
+    handler(data).catch((error) => {
+      console.error(
+        `[Linear Outbound] ${eventName} handler failed:`,
+        scrubSecrets(error instanceof Error ? error.message : String(error)),
+      );
+    });
+  };
+}
+
+const onTaskCreated = observed("task.created", handleTaskCreated);
+const onTaskCompleted = observed("task.completed", handleTaskCompleted);
+const onTaskFailed = observed("task.failed", handleTaskFailed);
+const onTaskCancelled = observed("task.cancelled", handleTaskCancelled);
+const onTaskProgress = observed("task.progress", handleTaskProgress);
+
 export function initLinearOutboundSync(): void {
   if (subscribed) return;
   subscribed = true;
 
-  workflowEventBus.on("task.created", handleTaskCreated);
-  workflowEventBus.on("task.completed", handleTaskCompleted);
-  workflowEventBus.on("task.failed", handleTaskFailed);
-  workflowEventBus.on("task.cancelled", handleTaskCancelled);
-  workflowEventBus.on("task.progress", handleTaskProgress);
+  workflowEventBus.on("task.created", onTaskCreated);
+  workflowEventBus.on("task.completed", onTaskCompleted);
+  workflowEventBus.on("task.failed", onTaskFailed);
+  workflowEventBus.on("task.cancelled", onTaskCancelled);
+  workflowEventBus.on("task.progress", onTaskProgress);
   console.log("[Linear] Outbound sync subscribed to event bus");
 }
 
@@ -24,11 +57,11 @@ export function teardownLinearOutboundSync(): void {
   if (!subscribed) return;
   subscribed = false;
 
-  workflowEventBus.off("task.created", handleTaskCreated);
-  workflowEventBus.off("task.completed", handleTaskCompleted);
-  workflowEventBus.off("task.failed", handleTaskFailed);
-  workflowEventBus.off("task.cancelled", handleTaskCancelled);
-  workflowEventBus.off("task.progress", handleTaskProgress);
+  workflowEventBus.off("task.created", onTaskCreated);
+  workflowEventBus.off("task.completed", onTaskCompleted);
+  workflowEventBus.off("task.failed", onTaskFailed);
+  workflowEventBus.off("task.cancelled", onTaskCancelled);
+  workflowEventBus.off("task.progress", onTaskProgress);
   console.log("[Linear] Outbound sync unsubscribed from event bus");
 }