@agent-native/core 0.119.5 → 0.120.0

package/corpus/core/src/integrations/pending-tasks-store.ts

@@ -33,6 +33,10 @@ async function ensureTable(): Promise<void> {
   org_id TEXT,
   status TEXT NOT NULL,
   attempts ${intType()} NOT NULL DEFAULT 0,
+  dispatch_attempts ${intType()} NOT NULL DEFAULT 0,
+  last_dispatch_at ${intType()},
+  last_dispatch_outcome TEXT,
+  dispatch_scope TEXT,
   error_message TEXT,
   created_at ${intType()} NOT NULL,
   updated_at ${intType()} NOT NULL,
@@ -47,6 +51,26 @@ async function ensureTable(): Promise<void> {
           "external_event_key",
           `ALTER TABLE integration_pending_tasks ADD COLUMN IF NOT EXISTS external_event_key TEXT`,
         );
+        await ensureColumnExists(
+          "integration_pending_tasks",
+          "dispatch_attempts",
+          `ALTER TABLE integration_pending_tasks ADD COLUMN IF NOT EXISTS dispatch_attempts ${intType()} NOT NULL DEFAULT 0`,
+        );
+        await ensureColumnExists(
+          "integration_pending_tasks",
+          "last_dispatch_at",
+          `ALTER TABLE integration_pending_tasks ADD COLUMN IF NOT EXISTS last_dispatch_at ${intType()}`,
+        );
+        await ensureColumnExists(
+          "integration_pending_tasks",
+          "last_dispatch_outcome",
+          `ALTER TABLE integration_pending_tasks ADD COLUMN IF NOT EXISTS last_dispatch_outcome TEXT`,
+        );
+        await ensureColumnExists(
+          "integration_pending_tasks",
+          "dispatch_scope",
+          `ALTER TABLE integration_pending_tasks ADD COLUMN IF NOT EXISTS dispatch_scope TEXT`,
+        );
         await ensureIndexExists(
           "idx_pending_tasks_status_created",
           `CREATE INDEX IF NOT EXISTS idx_pending_tasks_status_created ON integration_pending_tasks(status, created_at)`,
@@ -55,6 +79,10 @@ async function ensureTable(): Promise<void> {
           "idx_pending_tasks_event_key",
           `CREATE UNIQUE INDEX IF NOT EXISTS idx_pending_tasks_event_key ON integration_pending_tasks(platform, external_event_key)`,
         );
+        await ensureIndexExists(
+          "idx_pending_tasks_dispatch_scope",
+          `CREATE INDEX IF NOT EXISTS idx_pending_tasks_dispatch_scope ON integration_pending_tasks(platform, dispatch_scope)`,
+        );
         return;
       }
 
@@ -69,6 +97,10 @@ async function ensureTable(): Promise<void> {
       // unique index ensures a duplicate INSERT raises an error we can
       // catch as "already-enqueued".
       await ensureExternalEventKey(client);
+      await ensureDispatchColumns(client);
+      await client.execute(
+        `CREATE INDEX IF NOT EXISTS idx_pending_tasks_dispatch_scope ON integration_pending_tasks(platform, dispatch_scope)`,
+      );
       await client.execute(
         `CREATE UNIQUE INDEX IF NOT EXISTS idx_pending_tasks_event_key ON integration_pending_tasks(platform, external_event_key)`,
       );
@@ -81,6 +113,10 @@ async function ensureTable(): Promise<void> {
   return _initPromise;
 }
 
+export async function ensurePendingTasksTable(): Promise<void> {
+  await ensureTable();
+}
+
 async function ensureExternalEventKey(
   client: ReturnType<typeof getDbExec>,
 ): Promise<void> {
@@ -107,6 +143,32 @@ async function ensureExternalEventKey(
   }
 }
 
+async function ensureDispatchColumns(
+  client: ReturnType<typeof getDbExec>,
+): Promise<void> {
+  const columns = [
+    `dispatch_attempts ${intType()} NOT NULL DEFAULT 0`,
+    `last_dispatch_at ${intType()}`,
+    "last_dispatch_outcome TEXT",
+    "dispatch_scope TEXT",
+  ];
+  for (const column of columns) {
+    try {
+      await client.execute(
+        `ALTER TABLE integration_pending_tasks ADD COLUMN ${column}`,
+      );
+    } catch (err: any) {
+      if (
+        !String(err?.message ?? err)
+          .toLowerCase()
+          .includes("duplicate")
+      ) {
+        throw err;
+      }
+    }
+  }
+}
+
 /** Status values for an integration pending task. */
 export type PendingTaskStatus =
   | "pending"
@@ -123,6 +185,10 @@ export interface PendingTask {
   orgId: string | null;
   status: PendingTaskStatus;
   attempts: number;
+  dispatchAttempts: number;
+  lastDispatchAt: number | null;
+  lastDispatchOutcome: string | null;
+  dispatchScope: string | null;
   errorMessage: string | null;
   createdAt: number;
   updatedAt: number;
@@ -164,6 +230,13 @@ function rowToTask(row: Record<string, unknown>): PendingTask {
     orgId: (row.org_id as string | null) ?? null,
     status: row.status as PendingTaskStatus,
     attempts: Number(row.attempts ?? 0),
+    dispatchAttempts: Number(row.dispatch_attempts ?? 0),
+    lastDispatchAt:
+      row.last_dispatch_at == null
+        ? null
+        : Number(row.last_dispatch_at as number),
+    lastDispatchOutcome: (row.last_dispatch_outcome as string | null) ?? null,
+    dispatchScope: (row.dispatch_scope as string | null) ?? null,
     errorMessage: (row.error_message as string | null) ?? null,
     createdAt: Number(row.created_at ?? 0),
     updatedAt: Number(row.updated_at ?? 0),
@@ -189,14 +262,15 @@ export async function insertPendingTask(input: {
   ownerEmail: string;
   orgId?: string | null;
   externalEventKey?: string | null;
+  dispatchScope?: string | null;
 }): Promise<void> {
   await ensureTable();
   const client = getDbExec();
   const now = Date.now();
   await client.execute({
     sql: `INSERT INTO integration_pending_tasks
-      (id, platform, external_thread_id, payload, owner_email, org_id, status, attempts, created_at, updated_at, external_event_key)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      (id, platform, external_thread_id, payload, owner_email, org_id, status, attempts, created_at, updated_at, external_event_key, dispatch_scope)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
     args: [
       input.id,
       input.platform,
@@ -209,6 +283,7 @@ export async function insertPendingTask(input: {
       now,
       now,
       input.externalEventKey ?? null,
+      input.dispatchScope ?? null,
     ],
   });
 }
@@ -238,7 +313,7 @@ export async function getPendingTask(id: string): Promise<PendingTask | null> {
   await ensureTable();
   const client = getDbExec();
   const { rows } = await client.execute({
-    sql: `SELECT id, platform, external_thread_id, payload, owner_email, org_id, status, attempts, error_message, created_at, updated_at, completed_at
+    sql: `SELECT id, platform, external_thread_id, payload, owner_email, org_id, status, attempts, dispatch_attempts, last_dispatch_at, last_dispatch_outcome, dispatch_scope, error_message, created_at, updated_at, completed_at
           FROM integration_pending_tasks WHERE id = ? LIMIT 1`,
     args: [id],
   });
@@ -342,6 +417,7 @@ export async function resolveIntegrationSourceContext(
  */
 export async function claimPendingTask(
   id: string,
+  options?: { dispatchOutcome?: string },
 ): Promise<PendingTask | null> {
   await ensureTable();
   const client = getDbExec();
@@ -352,7 +428,8 @@ export async function claimPendingTask(
   const result = await client.execute({
     sql: isPostgres()
       ? `UPDATE integration_pending_tasks
-         SET status = ?, attempts = attempts + 1, updated_at = ?
+         SET status = ?, attempts = attempts + 1, updated_at = ?,
+             last_dispatch_outcome = COALESCE(?, last_dispatch_outcome)
          WHERE id = ? AND status = 'pending'
            AND NOT EXISTS (
              SELECT 1 FROM integration_pending_tasks active
@@ -374,9 +451,10 @@ export async function claimPendingTask(
                  )
                )
            )
-         RETURNING id, platform, external_thread_id, payload, owner_email, org_id, status, attempts, error_message, created_at, updated_at, completed_at`
+         RETURNING id, platform, external_thread_id, payload, owner_email, org_id, status, attempts, dispatch_attempts, last_dispatch_at, last_dispatch_outcome, dispatch_scope, error_message, created_at, updated_at, completed_at`
       : `UPDATE integration_pending_tasks
-         SET status = ?, attempts = attempts + 1, updated_at = ?
+         SET status = ?, attempts = attempts + 1, updated_at = ?,
+             last_dispatch_outcome = COALESCE(?, last_dispatch_outcome)
          WHERE id = ? AND status = 'pending'
            AND NOT EXISTS (
              SELECT 1 FROM integration_pending_tasks active
@@ -398,7 +476,7 @@ export async function claimPendingTask(
                  )
                )
            )`,
-    args: ["processing", now, id],
+    args: ["processing", now, options?.dispatchOutcome ?? null, id],
   });
   const rows = result.rows ?? [];
 
@@ -418,19 +496,44 @@ export async function claimPendingTask(
   return fetched;
 }
 
+export async function recordPendingTaskDispatchAttempt(
+  id: string,
+  outcome: string,
+): Promise<void> {
+  await ensureTable();
+  await getDbExec().execute({
+    sql: `UPDATE integration_pending_tasks
+          SET dispatch_attempts = dispatch_attempts + 1,
+              last_dispatch_at = ?,
+              last_dispatch_outcome = CASE
+                WHEN status = 'processing'
+                  AND last_dispatch_outcome = 'background-acknowledged'
+                THEN last_dispatch_outcome
+                ELSE ?
+              END
+          WHERE id = ?`,
+    args: [Date.now(), outcome.slice(0, 80), id],
+  });
+}
+
 /** Next queued turn for a provider thread after its current task completes. */
-export async function getNextPendingTaskIdForThread(
+export async function getNextPendingTaskForThread(
   platform: string,
   externalThreadId: string,
-): Promise<string | null> {
+): Promise<{ id: string; dispatchScope: string | null } | null> {
   await ensureTable();
   const { rows } = await getDbExec().execute({
-    sql: `SELECT id FROM integration_pending_tasks
+    sql: `SELECT id, dispatch_scope FROM integration_pending_tasks
       WHERE platform = ? AND external_thread_id = ? AND status = 'pending'
       ORDER BY created_at ASC, id ASC LIMIT 1`,
     args: [platform, externalThreadId],
   });
-  return rows[0]?.id ? String(rows[0].id) : null;
+  return rows[0]?.id
+    ? {
+        id: String(rows[0].id),
+        dispatchScope: (rows[0].dispatch_scope as string | null) ?? null,
+      }
+    : null;
 }
 
 /** Mark a task as completed. */

package/corpus/core/src/integrations/plugin.ts

@@ -9,6 +9,10 @@ import {
 import { getRequestHeader } from "h3";
 import { createRemoteJWKSet, jwtVerify } from "jose";
 
+import {
+  AGENT_BACKGROUND_PROCESSOR_FIELD,
+  AGENT_BACKGROUND_PROCESSOR_INTEGRATION,
+} from "../agent/durable-background.js";
 import { abortRun } from "../agent/run-manager.js";
 import { getOrgContext, resolveOrgIdForEmail } from "../org/context.js";
 import { loadResourcesForPrompt } from "../server/agent-chat-plugin.js";
@@ -65,22 +69,27 @@ import {
   updateIntegrationInstallation,
   upsertIntegrationInstallation,
 } from "./installations-store.js";
+import {
+  dispatchPendingIntegrationTask,
+  INTEGRATION_RETRY_SWEEP_TOKEN_SUBJECT,
+  integrationDispatchScopeValue,
+  isIntegrationDurableDispatchConfigured,
+} from "./integration-durable-dispatch.js";
 import {
   forgetIntegrationMemory,
   integrationMemoryActions,
   listIntegrationMemory,
   rememberForIntegrationScope,
 } from "./integration-memory.js";
+import { extractBearerToken, verifyInternalToken } from "./internal-token.js";
 import {
-  extractBearerToken,
-  signInternalToken,
-  verifyInternalToken,
-} from "./internal-token.js";
-import { startPendingTasksRetryJob } from "./pending-tasks-retry-job.js";
+  retryStuckPendingTasks,
+  startPendingTasksRetryJob,
+} from "./pending-tasks-retry-job.js";
 import {
   claimPendingTask,
   failTaskDeliveryTransition,
-  getNextPendingTaskIdForThread,
+  getNextPendingTaskForThread,
   insertPendingTask,
   isDuplicateEventError,
   MAX_PENDING_TASK_ATTEMPTS,
@@ -725,40 +734,29 @@ export function createIntegrationsPlugin(
           externalEventKey: opts?.dedupeKey
             ? systemNoticeEventKey(opts.dedupeKey, dedupeTtlMs)
             : undefined,
+          dispatchScope: integrationDispatchScopeValue({
+            platform: incoming.platform,
+            externalThreadId: noticeThreadId,
+            platformContext: incoming.platformContext,
+          }),
         });
       } catch (err) {
         if (isDuplicateEventError(err)) return;
         throw err;
       }
 
-      // The SQL row is the durable source of truth. This best-effort self-call
-      // only reduces latency; the recurring pending-task sweep retries a row
-      // if the serverless host freezes this webhook execution immediately.
-      let token: string | undefined;
-      try {
-        token = signInternalToken(taskId);
-      } catch (err) {
-        if (process.env.NODE_ENV === "production") throw err;
-      }
-      void fetch(`${getBaseUrl(event)}${P}/process-task`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          ...(token ? { Authorization: `Bearer ${token}` } : {}),
+      await dispatchPendingIntegrationTask({
+        taskId,
+        task: {
+          platform: incoming.platform,
+          externalThreadId: noticeThreadId,
+          platformContext: incoming.platformContext,
         },
-        body: JSON.stringify({ taskId }),
-      }).catch((err) => {
-        console.warn("[integrations] System notice dispatch failed:", err);
+        event,
+        baseUrl: getBaseUrl(event),
       });
     }
 
-    async function requireSession(event: any): Promise<boolean> {
-      const session = await getSession(event).catch(() => null);
-      if (session?.email) return true;
-      setResponseStatus(event, 401);
-      return false;
-    }
-
     async function requireSessionContext(
       event: any,
     ): Promise<{ ownerEmail: string; orgId: string | null } | null> {
@@ -903,9 +901,10 @@ export function createIntegrationsPlugin(
           setResponseStatus(event, 405);
           return { error: "Method not allowed" };
         }
-        if (!(await requireSession(event))) return { error: "unauthorized" };
+        const scope = await requireSessionContext(event);
+        if (!scope) return { error: "unauthorized" };
         try {
-          return await getTaskQueueStats();
+          return await getTaskQueueStats(scope);
         } catch (err: any) {
           setResponseStatus(event, 500);
           return { error: err?.message ?? String(err) };
@@ -1595,10 +1594,53 @@ export function createIntegrationsPlugin(
       }),
     );
 
+    // ─── Durable pending-task recovery sweep ─────────────────────
+    h3.use(
+      `${P}/retry-stuck-tasks`,
+      defineEventHandler(async (event) => {
+        if (getMethod(event) !== "POST") {
+          setResponseStatus(event, 405);
+          return { error: "Method not allowed" };
+        }
+        const body = (await readBody(event)) as {
+          taskId?: string;
+          [AGENT_BACKGROUND_PROCESSOR_FIELD]?: string;
+        };
+        if (body?.taskId !== INTEGRATION_RETRY_SWEEP_TOKEN_SUBJECT) {
+          setResponseStatus(event, 400);
+          return { error: "invalid sweep subject" };
+        }
+        if (!process.env.A2A_SECRET) {
+          setResponseStatus(event, 503);
+          return { error: "durable integration recovery is not configured" };
+        }
+        const token = extractBearerToken(
+          getRequestHeader(event, "authorization"),
+        );
+        if (
+          !token ||
+          !verifyInternalToken(INTEGRATION_RETRY_SWEEP_TOKEN_SUBJECT, token)
+        ) {
+          setResponseStatus(event, 401);
+          return { error: "Invalid or expired internal token" };
+        }
+        if (!isIntegrationDurableDispatchConfigured()) {
+          return { ok: true, disabled: true };
+        }
+        const result = await retryStuckPendingTasks({
+          webhookBaseUrl: getBaseUrl(event),
+          limit: 20,
+          durableOnly: true,
+        });
+        return { ok: true, ...result };
+      }),
+    );
+
     // ─── Process pending task (cross-platform task queue) ────────
     // POST /_agent-native/integrations/process-task
-    // Internal endpoint invoked via fire-and-forget self-webhook from the
-    // public webhook handler. Auth: HMAC bearer signed with A2A_SECRET.
+    // Internal endpoint invoked from the public webhook handler through either
+    // the portable self-dispatch path or an acknowledged background handoff.
+    // Auth: HMAC bearer signed with A2A_SECRET.
     // Each invocation runs the agent loop in a fresh function execution.
     h3.use(
       `${P}/process-task`,
@@ -1608,7 +1650,10 @@ export function createIntegrationsPlugin(
           return { error: "Method not allowed" };
         }
 
-        const body = (await readBody(event)) as { taskId?: string };
+        const body = (await readBody(event)) as {
+          taskId?: string;
+          [AGENT_BACKGROUND_PROCESSOR_FIELD]?: string;
+        };
         const taskId = body?.taskId;
         if (!taskId) {
           setResponseStatus(event, 400);
@@ -1645,7 +1690,12 @@ export function createIntegrationsPlugin(
         }
 
         // Atomic claim: only one invocation gets to process this task
-        const task = await claimPendingTask(taskId);
+        const dispatchOutcome =
+          body[AGENT_BACKGROUND_PROCESSOR_FIELD] ===
+          AGENT_BACKGROUND_PROCESSOR_INTEGRATION
+            ? "background-acknowledged"
+            : "portable-unconfirmed";
+        const task = await claimPendingTask(taskId, { dispatchOutcome });
         if (!task) {
           setResponseStatus(event, 200);
           return { ok: true, skipped: "already-claimed-or-missing" };
@@ -1779,24 +1829,22 @@ export function createIntegrationsPlugin(
             return { ok: true, taskId, retrying: "response-delivery" };
           }
           await markTaskCompleted(taskId);
-          const nextTaskId = await getNextPendingTaskIdForThread(
+          const nextTask = await getNextPendingTaskForThread(
             task.platform,
             task.externalThreadId,
           );
-          if (nextTaskId) {
-            const nextToken = signInternalToken(nextTaskId);
-            void fetch(`${getBaseUrl(event)}${P}/process-task`, {
-              method: "POST",
-              headers: {
-                "Content-Type": "application/json",
-                ...(nextToken ? { Authorization: `Bearer ${nextToken}` } : {}),
+          if (nextTask) {
+            await dispatchPendingIntegrationTask({
+              taskId: nextTask.id,
+              task: {
+                platform: task.platform,
+                externalThreadId: task.externalThreadId,
+                platformContext: nextTask.dispatchScope
+                  ? { channelId: nextTask.dispatchScope }
+                  : undefined,
               },
-              body: JSON.stringify({ taskId: nextTaskId }),
-            }).catch((err) => {
-              console.error(
-                "[integrations] Failed to dispatch queued thread turn:",
-                err,
-              );
+              event,
+              baseUrl: getBaseUrl(event),
             });
           }
           await processDueA2AContinuations({
@@ -2018,18 +2066,21 @@ export function createIntegrationsPlugin(
             ownerEmail: control.ownerEmail,
             orgId: control.orgId,
             externalEventKey: `control:${control.id}`,
+            dispatchScope: integrationDispatchScopeValue({
+              platform: incoming.platform,
+              externalThreadId: incoming.externalThreadId,
+              platformContext: incoming.platformContext,
+            }),
           });
-          const processUrl = `${getBaseUrl(event)}${P}/process-task`;
-          const token = signInternalToken(taskId);
-          void fetch(processUrl, {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/json",
-              ...(token ? { Authorization: `Bearer ${token}` } : {}),
+          await dispatchPendingIntegrationTask({
+            taskId,
+            task: {
+              platform: incoming.platform,
+              externalThreadId: incoming.externalThreadId,
+              platformContext: incoming.platformContext,
             },
-            body: JSON.stringify({ taskId }),
-          }).catch((err) => {
-            console.error("[slack] Approval dispatch failed:", err);
+            event,
+            baseUrl: getBaseUrl(event),
           });
         } catch (err) {
           console.error("[slack] Interaction handling failed:", err);
@@ -2480,6 +2531,8 @@ export function createIntegrationsPlugin(
         if (parts[0] === "remote") return;
         // Already handled by the dedicated /process-task route above
         if (parts[0] === "process-task") return;
+        // Already handled by the signed durable recovery route above
+        if (parts[0] === "retry-stuck-tasks") return;
         // Already handled by the dedicated /process-a2a-continuation route above
         if (parts[0] === "process-a2a-continuation") return;
         // These are framework-owned control-plane routes, not integration

package/corpus/core/src/integrations/task-queue-stats.ts

@@ -3,11 +3,12 @@
  *
  * Lives in its own file so it stays out of `pending-tasks-store.ts`, which is
  * actively being edited by the agent that owns the queue itself. These
- * helpers only SELECT — they never write — and they degrade gracefully if
- * the `integration_pending_tasks` table doesn't exist yet (returning zeroed
- * stats instead of throwing).
+ * Queue reads never expose payloads or user text. The helper first runs the
+ * additive schema guard so older deployments gain the dispatch diagnostic
+ * columns before the SELECTs execute.
  */
 import { getDbExec } from "../db/client.js";
+import { ensurePendingTasksTable } from "./pending-tasks-store.js";
 
 export interface RecentFailure {
   id: string;
@@ -23,6 +24,20 @@ export interface TaskQueueStats {
   failed_last_hour: number;
   oldest_pending_age_seconds: number;
   recent_failures: RecentFailure[];
+  recent_tasks: Array<{
+    id: string;
+    platform: string;
+    status: string;
+    attempts: number;
+    dispatch_attempts: number;
+    last_dispatch_outcome: string | null;
+    age_seconds: number;
+  }>;
+}
+
+export interface TaskQueueStatsScope {
+  ownerEmail: string;
+  orgId: string | null;
 }
 
 const ZERO_STATS: TaskQueueStats = {
@@ -32,6 +47,7 @@ const ZERO_STATS: TaskQueueStats = {
   failed_last_hour: 0,
   oldest_pending_age_seconds: 0,
   recent_failures: [],
+  recent_tasks: [],
 };
 
 function isMissingTableError(err: unknown): boolean {
@@ -44,21 +60,27 @@ function isMissingTableError(err: unknown): boolean {
 /**
  * Get a snapshot of the integration task queue health.
  *
- * Returns zeros if the table doesn't exist yet — safe to call before the
- * pending-tasks store has initialised the schema.
+ * Safe to call before the pending-tasks store has initialized the schema.
  */
-export async function getTaskQueueStats(): Promise<TaskQueueStats> {
+export async function getTaskQueueStats(
+  scope: TaskQueueStatsScope,
+): Promise<TaskQueueStats> {
+  await ensurePendingTasksTable();
   const client = getDbExec();
   const now = Date.now();
   const oneHourAgo = now - 60 * 60 * 1000;
+  const scopeSql = `owner_email = ?
+              AND ((org_id IS NULL AND CAST(? AS TEXT) IS NULL) OR org_id = ?)`;
+  const scopeArgs = [scope.ownerEmail, scope.orgId, scope.orgId];
 
   try {
     // Status counts (pending, processing) — only need the live ones.
     const liveCounts = await client.execute({
       sql: `SELECT status, COUNT(*) AS c FROM integration_pending_tasks
-            WHERE status IN ('pending', 'processing')
+            WHERE ${scopeSql}
+              AND status IN ('pending', 'processing')
             GROUP BY status`,
-      args: [],
+      args: scopeArgs,
     });
 
     let pending = 0;
@@ -75,9 +97,10 @@ export async function getTaskQueueStats(): Promise<TaskQueueStats> {
     // miss tasks queued >1h ago that just finished now.
     const lastHourCounts = await client.execute({
       sql: `SELECT status, COUNT(*) AS c FROM integration_pending_tasks
-            WHERE status IN ('completed', 'failed') AND updated_at >= ?
+            WHERE ${scopeSql}
+              AND status IN ('completed', 'failed') AND updated_at >= ?
             GROUP BY status`,
-      args: [oneHourAgo],
+      args: [...scopeArgs, oneHourAgo],
     });
 
     let completedLastHour = 0;
@@ -94,10 +117,11 @@ export async function getTaskQueueStats(): Promise<TaskQueueStats> {
     if (pending > 0) {
       const oldest = await client.execute({
         sql: `SELECT created_at FROM integration_pending_tasks
-              WHERE status = 'pending'
+              WHERE ${scopeSql}
+                AND status = 'pending'
               ORDER BY created_at ASC
               LIMIT 1`,
-        args: [],
+        args: scopeArgs,
       });
       const oldestRow = oldest.rows[0] as Record<string, unknown> | undefined;
       if (oldestRow) {
@@ -113,10 +137,11 @@ export async function getTaskQueueStats(): Promise<TaskQueueStats> {
     // blowing up the response payload.
     const failures = await client.execute({
       sql: `SELECT id, platform, error_message, attempts FROM integration_pending_tasks
-            WHERE status = 'failed' AND updated_at >= ?
+            WHERE ${scopeSql}
+              AND status = 'failed' AND updated_at >= ?
             ORDER BY updated_at DESC
             LIMIT 5`,
-      args: [oneHourAgo],
+      args: [...scopeArgs, oneHourAgo],
     });
     const recentFailures: RecentFailure[] = (
       failures.rows as Array<Record<string, unknown>>
@@ -127,6 +152,33 @@ export async function getTaskQueueStats(): Promise<TaskQueueStats> {
       attempts: Number(row.attempts ?? 0),
     }));
 
+    const recent = await client.execute({
+      sql: `SELECT id, platform, status, attempts, dispatch_attempts,
+                   last_dispatch_outcome, created_at
+              FROM integration_pending_tasks
+             WHERE ${scopeSql}
+             ORDER BY created_at DESC
+             LIMIT 10`,
+      args: scopeArgs,
+    });
+    const recentTasks = (recent.rows as Array<Record<string, unknown>>).map(
+      (row) => ({
+        id: String(row.id ?? ""),
+        platform: String(row.platform ?? ""),
+        status: String(row.status ?? ""),
+        attempts: Number(row.attempts ?? 0),
+        dispatch_attempts: Number(row.dispatch_attempts ?? 0),
+        last_dispatch_outcome:
+          row.last_dispatch_outcome == null
+            ? null
+            : String(row.last_dispatch_outcome),
+        age_seconds: Math.max(
+          0,
+          Math.floor((now - Number(row.created_at ?? now)) / 1000),
+        ),
+      }),
+    );
+
     return {
       pending,
       processing,
@@ -134,10 +186,11 @@ export async function getTaskQueueStats(): Promise<TaskQueueStats> {
       failed_last_hour: failedLastHour,
       oldest_pending_age_seconds: oldestPendingAgeSeconds,
       recent_failures: recentFailures,
+      recent_tasks: recentTasks,
     };
   } catch (err) {
     if (isMissingTableError(err)) {
-      return { ...ZERO_STATS, recent_failures: [] };
+      return { ...ZERO_STATS, recent_failures: [], recent_tasks: [] };
     }
     throw err;
   }