@desplega.ai/agent-swarm 1.131.0 → 1.133.1

package/src/commands/provider-credentials.ts

@@ -444,35 +444,62 @@ export async function buildCredStatusReport(
 }
 
 /**
- * Fire-and-forget POST of a `cred_status` snapshot to the API. Used by the
- * worker boot path (`runner.ts` after `awaitCredentials`) and the post-task
- * cache-miss path (also in `runner.ts`). Failures are logged, not thrown —
- * a stale dashboard is acceptable; blocking the worker is not.
+ * Strict PUT of credential readiness to the API: propagates network errors
+ * and non-2xx responses. The post-credential-wait boot path uses this — after
+ * a stale-runtime revival this write is the only transition out of
+ * `waiting_for_credentials`, so the caller must be able to observe (and
+ * retry) a failure instead of proceeding as though it landed.
  *
  * Posts to the existing `PUT /api/agents/:id/credential-status` endpoint
- * which (per migration 055) now accepts an optional `cred_status` field.
- * `ready` and `missing` are also included so legacy `agents.credentialMissing`
- * and `agents.status='waiting_for_credentials'` keep tracking.
+ * which (per migration 055) accepts an optional `cred_status` field. `ready`
+ * and `missing` are always included so legacy `agents.credentialMissing` and
+ * `agents.status='waiting_for_credentials'` keep tracking; the snapshot is
+ * optional so a hiccup while building it cannot lose the transition.
+ */
+export async function sendCredStatusReport(
+  apiUrl: string,
+  apiKey: string,
+  agentId: string,
+  runtimeInstanceId: string | undefined,
+  report: { ready: boolean; missing: string[]; credStatus?: AgentCredStatus },
+): Promise<void> {
+  const res = await fetch(`${apiUrl}/api/agents/${encodeURIComponent(agentId)}/credential-status`, {
+    method: "PUT",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "X-Agent-ID": agentId,
+      ...(runtimeInstanceId ? { "X-Runtime-Instance-ID": runtimeInstanceId } : {}),
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      ready: report.ready,
+      missing: report.missing,
+      ...(report.credStatus ? { cred_status: report.credStatus } : {}),
+    }),
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`credential-status report failed: ${res.status} ${body}`.trim());
+  }
+}
+
+/**
+ * Fire-and-forget wrapper around {@link sendCredStatusReport}. Used by the
+ * post-task cache-miss path (`runner.ts`), where a stale dashboard is
+ * acceptable and blocking the worker is not.
  */
 export async function reportCredStatus(
   apiUrl: string,
   apiKey: string,
   agentId: string,
+  runtimeInstanceId: string | undefined,
   credStatus: AgentCredStatus,
 ): Promise<void> {
   try {
-    await fetch(`${apiUrl}/api/agents/${encodeURIComponent(agentId)}/credential-status`, {
-      method: "PUT",
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-        "X-Agent-ID": agentId,
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({
-        ready: credStatus.ready,
-        missing: credStatus.missing,
-        cred_status: credStatus,
-      }),
+    await sendCredStatusReport(apiUrl, apiKey, agentId, runtimeInstanceId, {
+      ready: credStatus.ready,
+      missing: credStatus.missing,
+      credStatus,
     });
   } catch (err) {
     console.warn(`[cred-status] POST failed (non-fatal): ${err}`);

package/src/commands/runner.ts

@@ -65,9 +65,15 @@ import { interpolate } from "../utils/template.ts";
 import { detectVcsProvider } from "../vcs/index.ts";
 import { validateJsonSchema } from "../workflows/json-schema-validator.ts";
 import { buildContextPreamble, buildResumeContextPreamble } from "./context-preamble.ts";
-import { awaitCredentials, BootMaxWaitExceededError, EX_CONFIG } from "./credential-wait.ts";
+import {
+  awaitCredentials,
+  BootMaxWaitExceededError,
+  EX_CONFIG,
+  retryBootStep,
+} from "./credential-wait.ts";
 import {
   contentSha256,
+  prependProfileSyncRejectionBanner,
   resolveClaudeMdPath,
   syncProfileFilesToServer,
   writeIdentityBaselines,
@@ -80,6 +86,7 @@ import {
   isCredCheckDisabled,
   reportCredStatus,
   reportLatestModel,
+  sendCredStatusReport,
 } from "./provider-credentials.ts";
 import {
   type ResumeSessionCandidate,
@@ -481,6 +488,13 @@ export interface ApiConfig {
   apiUrl: string;
   apiKey: string;
   agentId: string;
+  /**
+   * Per-boot identity for this worker PROCESS, as opposed to `agentId` (the
+   * logical agent). Sent as the X-Runtime-Instance-ID header on ping/close so
+   * a server can track this process's liveness and retire only this runtime.
+   * Servers ignore it unless MULTI_RUNTIME_ENABLED.
+   */
+  runtimeInstanceId?: string;
 }
 
 export interface SteeringDispatchState {
@@ -589,6 +603,9 @@ async function pingServer(config: ApiConfig, _role: string): Promise<void> {
   if (config.apiKey) {
     headers.Authorization = `Bearer ${config.apiKey}`;
   }
+  if (config.runtimeInstanceId) {
+    headers["X-Runtime-Instance-ID"] = config.runtimeInstanceId;
+  }
 
   try {
     await fetch(`${config.apiUrl}/ping`, {
@@ -608,6 +625,9 @@ async function closeAgent(config: ApiConfig, role: string): Promise<void> {
   if (config.apiKey) {
     headers.Authorization = `Bearer ${config.apiKey}`;
   }
+  if (config.runtimeInstanceId) {
+    headers["X-Runtime-Instance-ID"] = config.runtimeInstanceId;
+  }
 
   try {
     console.log(`[${role}] Marking agent as offline...`);
@@ -2448,6 +2468,7 @@ async function registerActiveSession(
         triggerType: session.triggerType,
         taskDescription: session.taskDescription,
         runnerSessionId: session.runnerSessionId,
+        runtimeInstanceId: config.runtimeInstanceId,
       }),
     });
   } catch {
@@ -2563,7 +2584,14 @@ interface Trigger {
     text?: string;
   }>;
   cursorUpdates?: Array<{ channelId: string; ts: string }>; // Deferred cursor commits for channel_activity
-  requestedBy?: { name: string; email?: string; role?: string; notes?: string };
+  requestedBy?: {
+    name: string;
+    email?: string;
+    role?: string;
+    notes?: string;
+    /** Structured communication preferences from `users.metadata.comms`. */
+    comms?: { tone?: string; language?: string; verbosity?: string };
+  };
   // Phase 4 — budget_refused fields. The server emits this envelope from
   // /api/poll and MCP task-action accept when an admission gate refuses to
   // let the agent claim a task. Worker reads cause + reset/spend/budget for
@@ -2581,6 +2609,8 @@ interface PollOptions {
   apiUrl: string;
   apiKey: string;
   agentId: string;
+  /** Identifies the polling process so a retired runtime is not given work. */
+  runtimeInstanceId?: string;
   pollInterval: number;
   pollTimeout: number;
   since?: string; // Optional: for filtering finished tasks
@@ -2591,15 +2621,24 @@ type RequesterProfile = NonNullable<Trigger["requestedBy"]>;
 export async function buildRequesterProfilePrompt(
   requestedBy: RequesterProfile | undefined,
 ): Promise<string> {
-  if (!requestedBy?.role && !requestedBy?.notes) return "";
-
-  const notes = requestedBy.notes?.trim();
+  const comms = requestedBy?.comms;
+  const commsParts = [
+    comms?.tone ? `tone: ${comms.tone}` : undefined,
+    comms?.language ? `language: ${comms.language}` : undefined,
+    comms?.verbosity ? `verbosity: ${comms.verbosity}` : undefined,
+  ].filter((part): part is string => Boolean(part));
+  if (!requestedBy?.role && !requestedBy?.notes && commsParts.length === 0) return "";
+
+  const commsSection =
+    commsParts.length > 0 ? `\nTheir communication preferences: ${commsParts.join(", ")}.` : "";
+  const notes = requestedBy?.notes?.trim();
   const notesSection = notes
     ? `\nTheir stated notes for how you should respond and act:\n${notes}`
     : "";
   const result = await resolveTemplateAsync("task.requester.profile", {
-    requester_name: requestedBy.name,
-    requester_role_suffix: requestedBy.role ? ` (${requestedBy.role})` : "",
+    requester_name: requestedBy?.name ?? "",
+    requester_role_suffix: requestedBy?.role ? ` (${requestedBy.role})` : "",
+    requester_comms_section: commsSection,
     requester_notes_section: notesSection,
   });
 
@@ -2623,6 +2662,7 @@ async function registerAgent(opts: {
    * haven't migrated to passing it explicitly.
    */
   harnessProvider?: ProviderName;
+  runtimeInstanceId?: string;
 }): Promise<{ serverCapabilities?: string[] }> {
   const headers: Record<string, string> = {
     "Content-Type": "application/json",
@@ -2654,6 +2694,7 @@ async function registerAgent(opts: {
       maxTasks: opts.maxTasks,
       provider,
       harness_provider: harnessProvider,
+      runtimeInstanceId: opts.runtimeInstanceId,
     }),
   });
 
@@ -2702,6 +2743,9 @@ async function pollForTriggerOnce(opts: PollOptions): Promise<Trigger | null> {
   const headers: Record<string, string> = {
     "X-Agent-ID": opts.agentId,
   };
+  if (opts.runtimeInstanceId) {
+    headers["X-Runtime-Instance-ID"] = opts.runtimeInstanceId;
+  }
   if (opts.apiKey) {
     headers.Authorization = `Bearer ${opts.apiKey}`;
   }
@@ -3395,7 +3439,12 @@ async function spawnProviderProcess(
   function bufferEvent(evt: BufferedEvent) {
     eventBuffer.push(evt);
     if (eventBuffer.length >= EVENT_BUFFER_MAX) {
-      flushEvents();
+      flushEvents().catch((err) =>
+        console.error(
+          "[runner] event flush failed:",
+          scrubSecrets(err instanceof Error ? err.message : String(err)),
+        ),
+      );
     }
   }
 
@@ -4086,7 +4135,12 @@ async function checkCompletedProcesses(
     cancelledSignaled?.delete(taskId);
 
     if (apiConfig) {
-      removeActiveSession(apiConfig, taskId);
+      removeActiveSession(apiConfig, taskId).catch((err) =>
+        console.error(
+          "[runner] active-session removal failed:",
+          scrubSecrets(err instanceof Error ? err.message : String(err)),
+        ),
+      );
     }
 
     // Detect VCS before finishing — last chance to link a PR
@@ -4699,8 +4753,16 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
   let lastBedrockRefreshAt = 0;
   const BEDROCK_REFRESH_INTERVAL_MS = 5 * 60 * 1000;
 
+  // Fresh per boot and shared by registration, ping, and close: a restarted
+  // process is a new runtime, but one process presents one identity.
+  const runtimeInstanceId = crypto.randomUUID();
+
+  // Session MCP configs are built in provider adapters, which read this to
+  // stamp the runtime identity onto worker tool calls.
+  process.env.SWARM_RUNTIME_INSTANCE_ID = runtimeInstanceId;
+
   // Create API config for ping/close
-  const apiConfig: ApiConfig = { apiUrl, apiKey, agentId };
+  const apiConfig: ApiConfig = { apiUrl, apiKey, agentId, runtimeInstanceId };
 
   // Setup graceful shutdown handlers with API config and runner state access
   setupShutdownHandlers(role, apiConfig, () => state);
@@ -4821,22 +4883,32 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
     }
   };
 
-  /** Push the current live state back to the API so the dashboard reflects it. */
+  /** Register this boot's runtime with the current live state; propagates failure. */
+  const registerCurrentRuntime = async () => {
+    const reg = await registerAgent({
+      apiUrl,
+      apiKey,
+      agentId,
+      name: agentName,
+      role,
+      isLead,
+      capabilities,
+      maxTasks: state.maxConcurrent,
+      harnessProvider: state.harnessProvider,
+      runtimeInstanceId,
+    });
+    lastServerCapsRefreshAt = Date.now();
+    await applyServerCapabilities(reg.serverCapabilities);
+  };
+
+  /**
+   * Best-effort wrapper for the periodic/fire-and-forget callers: the
+   * dashboard tolerates a missed refresh. Recovery paths that must observe
+   * failure use registerCurrentRuntime directly.
+   */
   const reregisterAgent = async () => {
     try {
-      const reg = await registerAgent({
-        apiUrl,
-        apiKey,
-        agentId,
-        name: agentName,
-        role,
-        isLead,
-        capabilities,
-        maxTasks: state.maxConcurrent,
-        harnessProvider: state.harnessProvider,
-      });
-      lastServerCapsRefreshAt = Date.now();
-      await applyServerCapabilities(reg.serverCapabilities);
+      await registerCurrentRuntime();
     } catch (err) {
       console.warn(`[${role}] [config] Re-register failed (non-fatal): ${err}`);
     }
@@ -4852,6 +4924,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
       capabilities,
       maxTasks: maxConcurrent,
       harnessProvider: bootProvider,
+      runtimeInstanceId,
     });
     lastServerCapsRefreshAt = Date.now();
     // Rebuilds the prompt immediately: the initial build above ran before
@@ -4918,6 +4991,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
             headers: {
               Authorization: `Bearer ${apiKey}`,
               "X-Agent-ID": agentId,
+              "X-Runtime-Instance-ID": runtimeInstanceId,
               "Content-Type": "application/json",
             },
             body: JSON.stringify({ ready: status.ready, missing: status.missing }),
@@ -4934,16 +5008,71 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
       throw err;
     }
 
+    // Re-register before reporting readiness or doing any work. A worker
+    // blocked on credentials is not usable execution capacity, so its runtime
+    // is allowed to expire during the wait rather than being kept alive
+    // artificially — but once it can work again the server has to know, or
+    // its pings and polls would reference a runtime that no longer exists
+    // until the periodic refresh (up to 5 min later) happened to fix it.
+    // Same per-boot runtime id, so this refreshes the original row instead of
+    // creating a second one. Ordering matters: a readiness report sent while
+    // the row is still stale is dropped (only a live runtime may report), and
+    // the revival preserves credential_ready — reporting first would leave
+    // the agent parked on waiting_for_credentials forever. Best-effort is not
+    // enough here for the same reason: a swallowed transient failure would
+    // still let the report target the stale row, so recovery retries and
+    // treats exhaustion like boot-registration failure.
+    try {
+      await retryBootStep(registerCurrentRuntime, {
+        label: "runtime re-registration",
+        log: (line) => console.warn(`[${role}] ${line}`),
+      });
+    } catch (error) {
+      console.error(`[${role}] Failed to re-register after credential wait: ${error}`);
+      process.exit(1);
+    }
+
     // Migration 055: build the full snapshot (presence + live test) once
     // creds are ready and POST it to the agent row. Status endpoint reads
     // this instead of running predicates server-side. Always uses the
     // *current* state.harnessProvider in case it flipped during the wait.
+    // The snapshot build stays best-effort — its live test can hiccup, and
+    // that must not lose the readiness transition below.
+    let bootCredSnapshot: Awaited<ReturnType<typeof buildCredStatusReport>> | undefined;
     try {
-      const snapshot = await buildCredStatusReport(state.harnessProvider, process.env, {}, "boot");
-      await reportCredStatus(apiUrl, apiKey, agentId, snapshot);
+      bootCredSnapshot = await buildCredStatusReport(
+        state.harnessProvider,
+        process.env,
+        {},
+        "boot",
+      );
     } catch (err) {
-      // Non-fatal — worker proceeds even if reporting fails.
-      console.warn(`[${role}] cred_status boot report failed (non-fatal): ${err}`);
+      console.warn(`[${role}] cred_status boot snapshot failed (non-fatal): ${err}`);
+    }
+
+    // The readiness write is the only transition out of
+    // waiting_for_credentials after a stale-runtime revival (the wait's final
+    // tick targeted the pre-registration row, and revival preserves the old
+    // credential_ready) — so like the registration above, it retries and
+    // treats exhaustion as a failed boot rather than proceeding parked.
+    try {
+      await retryBootStep(
+        () =>
+          sendCredStatusReport(apiUrl, apiKey, agentId, runtimeInstanceId, {
+            // The snapshot's verdict when it built; otherwise the wait's own
+            // conclusion (it only returns once credentials are ready).
+            ready: bootCredSnapshot?.ready ?? true,
+            missing: bootCredSnapshot?.missing ?? [],
+            credStatus: bootCredSnapshot,
+          }),
+        {
+          label: "credential readiness report",
+          log: (line) => console.warn(`[${role}] ${line}`),
+        },
+      );
+    } catch (error) {
+      console.error(`[${role}] Failed to report credential readiness after recovery: ${error}`);
+      process.exit(1);
     }
   }
 
@@ -5291,6 +5420,15 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
           }
         }
 
+        const resumeWithSyncWarning = await prependProfileSyncRejectionBanner(resumePrompt, {
+          ...apiConfig,
+          claudeMdPath: resolveClaudeMdPath([state.harnessProvider]),
+        });
+        resumePrompt = resumeWithSyncWarning.prompt;
+        if (resumeWithSyncWarning.injected) {
+          console.warn(`[${role}] Injected persisted profile sync rejection warning`);
+        }
+
         // Resolve provider-aware resume: prefer own session, then parent.
         const resumeCandidates: ResumeSessionCandidate[] = [
           {
@@ -5428,7 +5566,12 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
           triggerType: "task_resumed",
           taskDescription: task.task?.slice(0, 200),
           runnerSessionId: resumeRunnerSessionId,
-        });
+        }).catch((err) =>
+          console.error(
+            "[runner] active-session registration failed:",
+            scrubSecrets(err instanceof Error ? err.message : String(err)),
+          ),
+        );
         console.log(
           `[${role}] Resumed task ${task.id.slice(0, 8)} (${state.activeTasks.size}/${state.maxConcurrent} active)`,
         );
@@ -5522,7 +5665,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
       if (currentHarness !== cachedCredHarnessProvider) {
         cachedCredHarnessProvider = currentHarness;
         buildCredStatusReport(currentHarness, process.env, {}, "post_task")
-          .then((snap) => reportCredStatus(apiUrl, apiKey, agentId, snap))
+          .then((snap) => reportCredStatus(apiUrl, apiKey, agentId, runtimeInstanceId, snap))
           .catch((err) =>
             console.warn(`[${role}] cred_status post_task report failed (non-fatal): ${err}`),
           );
@@ -5538,7 +5681,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
         // account state. One bounded AWS round-trip per tick.
         lastBedrockRefreshAt = Date.now();
         buildCredStatusReport(currentHarness, process.env, {}, "post_task")
-          .then((snap) => reportCredStatus(apiUrl, apiKey, agentId, snap))
+          .then((snap) => reportCredStatus(apiUrl, apiKey, agentId, runtimeInstanceId, snap))
           .catch((err) =>
             console.warn(`[${role}] bedrock enumeration refresh failed (non-fatal): ${err}`),
           );
@@ -5554,7 +5697,12 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
       if (!task.workingDir) continue;
 
       vcsCheckTimestamps.set(taskId, now);
-      detectVcsForTask(apiUrl, apiKey, taskId, task.workingDir);
+      detectVcsForTask(apiUrl, apiKey, taskId, task.workingDir).catch((err) =>
+        console.error(
+          "[runner] VCS detection failed:",
+          scrubSecrets(err instanceof Error ? err.message : String(err)),
+        ),
+      );
     }
 
     // Check for cancelled tasks and signal their subprocesses. Deliberately
@@ -5631,6 +5779,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
         apiKey,
         agentId,
         pollInterval: PollIntervalMs,
+        runtimeInstanceId,
         pollTimeout: effectiveTimeout,
       });
 
@@ -5739,6 +5888,15 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
           }
         }
 
+        const triggerWithSyncWarning = await prependProfileSyncRejectionBanner(triggerPrompt, {
+          ...apiConfig,
+          claudeMdPath: resolveClaudeMdPath([state.harnessProvider]),
+        });
+        triggerPrompt = triggerWithSyncWarning.prompt;
+        if (triggerWithSyncWarning.injected) {
+          console.warn(`[${role}] Injected persisted profile sync rejection warning`);
+        }
+
         // Resolve provider-aware resume for child tasks with parentTaskId.
         let resumeSessionId: string | undefined;
         if (taskObj?.parentTaskId) {
@@ -5990,7 +6148,12 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
           triggerType: trigger.type,
           taskDescription: taskDesc,
           runnerSessionId: taskRunnerSessionId,
-        });
+        }).catch((err) =>
+          console.error(
+            "[runner] active-session registration failed:",
+            scrubSecrets(err instanceof Error ? err.message : String(err)),
+          ),
+        );
 
         console.log(
           `[${role}] Started task ${runningTask.taskId.slice(0, 8)} (${state.activeTasks.size}/${state.maxConcurrent} active, trigger: ${trigger.type})`,

package/src/commands/templates.ts

@@ -50,6 +50,28 @@ Accept if you have capacity and skills. Reject with a reason if you cannot handl
   category: "task_lifecycle",
 });
 
+registerTemplate({
+  eventType: "task.profile_sync_rejection",
+  header: "",
+  defaultBody: `=== PERSISTED PROFILE SYNC REJECTION ===
+A {{timestamp}} sync of {{field_label}} did not reach the database. Disk size: {{disk_size}}; DB size: {{db_size}}; budget: {{budget}}; delta: {{delta}}.
+Audit event: {{event_id}}. {{recovery_guidance}}
+=== END PROFILE SYNC REJECTION ===
+
+`,
+  variables: [
+    { name: "timestamp", description: "UTC timestamp of the rejected sync" },
+    { name: "field_label", description: "Profile field and its harness-specific file path" },
+    { name: "disk_size", description: "Rejected local file size" },
+    { name: "db_size", description: "Stored database field size" },
+    { name: "budget", description: "Configured field budget" },
+    { name: "delta", description: "Signed size delta" },
+    { name: "event_id", description: "Persisted audit event ID" },
+    { name: "recovery_guidance", description: "Accurate field-specific recovery instructions" },
+  ],
+  category: "task_lifecycle",
+});
+
 registerTemplate({
   eventType: "task.trigger.unread_mentions",
   header: "",

package/src/github/handlers.ts

@@ -4,6 +4,7 @@ import { findUserByExternalId } from "../be/users";
 import { resolveTemplate } from "../prompts/resolver";
 import { githubContextKey } from "../tasks/context-key";
 import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
+import { scrubSecrets } from "../utils/secret-scrubber";
 import { getInstallationToken } from "./app";
 import {
   detectMention,
@@ -280,7 +281,12 @@ export async function handlePullRequest(
     }
 
     if (installation?.id) {
-      addIssueReaction(repository.full_name, pr.number, "eyes", installation.id);
+      addIssueReaction(repository.full_name, pr.number, "eyes", installation.id).catch((err) =>
+        console.error(
+          "[GitHub] failed to add issue reaction:",
+          scrubSecrets(err instanceof Error ? err.message : String(err)),
+        ),
+      );
     }
 
     return { created: true, taskId: task.id };
@@ -388,7 +394,12 @@ export async function handlePullRequest(
     }
 
     if (installation?.id) {
-      addIssueReaction(repository.full_name, pr.number, "eyes", installation.id);
+      addIssueReaction(repository.full_name, pr.number, "eyes", installation.id).catch((err) =>
+        console.error(
+          "[GitHub] failed to add issue reaction:",
+          scrubSecrets(err instanceof Error ? err.message : String(err)),
+        ),
+      );
     }
 
     return { created: true, taskId: task.id };
@@ -488,7 +499,12 @@ export async function handlePullRequest(
     }
 
     if (installation?.id) {
-      addIssueReaction(repository.full_name, pr.number, "eyes", installation.id);
+      addIssueReaction(repository.full_name, pr.number, "eyes", installation.id).catch((err) =>
+        console.error(
+          "[GitHub] failed to add issue reaction:",
+          scrubSecrets(err instanceof Error ? err.message : String(err)),
+        ),
+      );
     }
 
     return { created: true, taskId: task.id };
@@ -577,7 +593,12 @@ export async function handlePullRequest(
 
   // Add 👀 reaction to acknowledge the mention
   if (installation?.id) {
-    addIssueReaction(repository.full_name, pr.number, "eyes", installation.id);
+    addIssueReaction(repository.full_name, pr.number, "eyes", installation.id).catch((err) =>
+      console.error(
+        "[GitHub] failed to add issue reaction:",
+        scrubSecrets(err instanceof Error ? err.message : String(err)),
+      ),
+    );
   }
 
   return { created: true, taskId: task.id };
@@ -657,7 +678,12 @@ export async function handleIssue(
     }
 
     if (installation?.id) {
-      addIssueReaction(repository.full_name, issue.number, "eyes", installation.id);
+      addIssueReaction(repository.full_name, issue.number, "eyes", installation.id).catch((err) =>
+        console.error(
+          "[GitHub] failed to add issue reaction:",
+          scrubSecrets(err instanceof Error ? err.message : String(err)),
+        ),
+      );
     }
 
     return { created: true, taskId: task.id };
@@ -753,7 +779,12 @@ export async function handleIssue(
     }
 
     if (installation?.id) {
-      addIssueReaction(repository.full_name, issue.number, "eyes", installation.id);
+      addIssueReaction(repository.full_name, issue.number, "eyes", installation.id).catch((err) =>
+        console.error(
+          "[GitHub] failed to add issue reaction:",
+          scrubSecrets(err instanceof Error ? err.message : String(err)),
+        ),
+      );
     }
 
     return { created: true, taskId: task.id };
@@ -824,7 +855,12 @@ export async function handleIssue(
 
   // Add 👀 reaction to acknowledge the mention
   if (installation?.id) {
-    addIssueReaction(repository.full_name, issue.number, "eyes", installation.id);
+    addIssueReaction(repository.full_name, issue.number, "eyes", installation.id).catch((err) =>
+      console.error(
+        "[GitHub] failed to add issue reaction:",
+        scrubSecrets(err instanceof Error ? err.message : String(err)),
+      ),
+    );
   }
 
   return { created: true, taskId: task.id };
@@ -932,7 +968,12 @@ export async function handleComment(
 
   // Add 👀 reaction to the comment to acknowledge the mention
   if (installation?.id) {
-    addReaction(repository.full_name, comment.id, "eyes", installation.id);
+    addReaction(repository.full_name, comment.id, "eyes", installation.id).catch((err) =>
+      console.error(
+        "[GitHub] failed to add comment reaction:",
+        scrubSecrets(err instanceof Error ? err.message : String(err)),
+      ),
+    );
   }
 
   return { created: true, taskId: task.id };
@@ -1240,7 +1281,12 @@ export async function handlePullRequestReview(
 
   // Add reaction to acknowledge the review
   if (installation?.id) {
-    addIssueReaction(repository.full_name, pr.number, "eyes", installation.id);
+    addIssueReaction(repository.full_name, pr.number, "eyes", installation.id).catch((err) =>
+      console.error(
+        "[GitHub] failed to add issue reaction:",
+        scrubSecrets(err instanceof Error ? err.message : String(err)),
+      ),
+    );
   }
 
   return { created: true, taskId: task.id };