@opengeni/api-router 3.0.1 → 3.1.2

package/src/routes/scheduled-tasks.ts

@@ -1,19 +1,46 @@
+import {
+  clearsLegacyVariableSet,
+  rejectLegacyVariableSetFields,
+} from "../http/variable-sets-removed";
 import { z } from "zod";
 import {
   CreateScheduledTaskRequest,
+  ListPrivateScheduledTaskSummariesResponse,
+  PrivateScheduledTaskSummary,
+  RefreshScheduledTaskAccessRequest,
+  ScheduledTaskSlackChannelId,
+  ScheduledTaskSlackChannelListResponse,
   TriggerScheduledTaskRequest,
   UpdateScheduledTaskRequest,
+  type AccessGrant,
 } from "@opengeni/contracts";
-import { listScheduledTaskRuns, listScheduledTasks } from "@opengeni/db";
+import {
+  getScheduledTaskBlockers,
+  getScheduledTaskIncludingDeleted,
+  getScheduledTaskRevisionAuthoritySubject,
+  listPrivateScheduledTaskSummaries,
+  listScheduledTaskRuns,
+  listScheduledTasks,
+} from "@opengeni/db";
 import type { Hono } from "hono";
+import type { ScheduledTask } from "@opengeni/contracts";
 import { HTTPException } from "hono/http-exception";
 import {
+  isAuthenticatedPersonAuthorization,
   requireAccessGrant,
   requireAccessGrantAuthorization,
+  requirePermission,
   resolveWorkspaceCatalogSettings,
+  validateOpenGeniSlackBotConnectionSelection,
+  type ScheduledTaskSlackChannelVerifier,
+} from "@opengeni/core";
+import {
+  recordWorkspaceUsage,
+  requireLimit,
+  resolveScheduledTaskPreflightModel,
 } from "@opengeni/core";
-import { recordWorkspaceUsage, requireLimit } from "@opengeni/core";
 import type { ApiRouteDeps } from "@opengeni/core";
+import { assertNotSiteClampedAgent } from "@opengeni/core";
 import {
   captureScheduledTaskRestoreState,
   createValidatedScheduledTask,
@@ -23,19 +50,173 @@ import {
   scheduledTaskForGrant,
   scheduledTaskRunForGrant,
   scheduledTaskTriggerToken,
-  requireScheduledTaskForApi,
+  pauseScheduledTaskAsAdmin,
+  pausePrivateScheduledTaskAsAdmin,
+  requirePausableScheduledTask,
+  requireVisibleScheduledTask,
+  scheduledTaskAccess,
+  scheduledTaskViewerForGrant,
   syncCreatedScheduledTask,
   syncUpdatedScheduledTask,
   updateScheduledTaskForApi,
+  triggerScheduledTaskForGrant,
   validateScheduledTaskMachineTarget,
   validateScheduledTaskTarget,
   validatedScheduledTaskUpdate,
+  listScheduledTaskAccessAttention,
+  refreshScheduledTaskAccess,
+  scheduledTaskAccessSource,
+  withScheduledTaskPolicyDrift,
+  withScheduledTaskRunAccessFailures,
 } from "@opengeni/core";
+import type { AccessGrantAuthorization } from "@opengeni/core";
 import { boundedLimit } from "../http/common";
+import { permissionsRequiredByFirstPartyTools } from "../mcp/first-party-tool-permissions";
+import {
+  createOpenGeniSlackBotInteractionClient,
+  verifyScheduledTaskSlackChannel,
+} from "../integrations/slack-bot";
 import { deleteScheduledTaskWithDurableCleanup } from "../scheduled-task-deletion";
+import { parseRequestBody, readRequestJson } from "../http/request-body";
 
 export function registerScheduledTaskRoutes(app: Hono, deps: ApiRouteDeps): void {
   const { db, workflowClient, objectStorage } = deps;
+  const slackChannelVerifier =
+    (grant: AccessGrant): ScheduledTaskSlackChannelVerifier =>
+    async ({ connectionId, channelId }) =>
+      await verifyScheduledTaskSlackChannel(deps, {
+        accountId: grant.accountId,
+        workspaceId: grant.workspaceId,
+        subjectId: grant.subjectId,
+        connectionId,
+        channelId,
+      });
+
+  // Channels a person may choose as a task's fixed Slack destination: active,
+  // non-shared channels the selected Opengeni bot already belongs to.
+  app.get("/v1/workspaces/:workspaceId/scheduled-task-slack-channels", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    const authorization = await requireAccessGrantAuthorization(
+      c,
+      deps,
+      workspaceId,
+      "scheduled_tasks:manage",
+    );
+    const grant = authorization.grant;
+    requirePermission(grant, "connections:write");
+    if (!isAuthenticatedPersonAuthorization(authorization)) {
+      throw new HTTPException(403, {
+        message: "Only a person can choose the Slack channel a scheduled task posts to",
+      });
+    }
+    const connectionId = c.req.query("connectionId");
+    if (!connectionId || !z.string().uuid().safeParse(connectionId).success) {
+      throw new HTTPException(400, { message: "connectionId is required" });
+    }
+    const cursor = c.req.query("cursor");
+    if (cursor !== undefined && cursor.length > 1_024) {
+      throw new HTTPException(400, { message: "invalid cursor" });
+    }
+    await validateOpenGeniSlackBotConnectionSelection(db, grant, workspaceId, connectionId);
+    const client = await createOpenGeniSlackBotInteractionClient(deps, {
+      accountId: grant.accountId,
+      workspaceId,
+      connectionId,
+      subjectId: grant.subjectId,
+    });
+    const result = await client.listChannels({ limit: 200, ...(cursor ? { cursor } : {}) });
+    c.header("cache-control", "private, no-store");
+    return c.json(
+      ScheduledTaskSlackChannelListResponse.parse({
+        channels: result.channels
+          .filter(
+            (channel) =>
+              channel.isMember &&
+              !channel.isArchived &&
+              !channel.isShared &&
+              !channel.isExternallyShared &&
+              !channel.isOrgShared &&
+              ScheduledTaskSlackChannelId.safeParse(channel.id).success,
+          )
+          .map((channel) => ({ id: channel.id, name: channel.name, isPrivate: channel.isPrivate })),
+        nextCursor: result.nextCursor || null,
+      }),
+    );
+  });
+
+  // Drift is advisory: it is attached for viewers who can act on a task and
+  // never fails the read it decorates.
+  async function withPolicyDrift(
+    authorization: AccessGrantAuthorization,
+    tasks: ScheduledTask[],
+  ): Promise<ScheduledTask[]> {
+    if (!tasks.some((task) => scheduledTaskAccessSource(task, authorization.grant))) {
+      return tasks;
+    }
+    const catalogSettings = (
+      await resolveWorkspaceCatalogSettings(db, deps.settings, {
+        accountId: authorization.grant.accountId,
+        workspaceId: authorization.grant.workspaceId,
+      })
+    ).settings;
+    return await withScheduledTaskPolicyDrift({
+      db,
+      settings: catalogSettings,
+      authorization,
+      tasks,
+      permissionsRequiredByTools: permissionsRequiredByFirstPartyTools,
+      onError: (error) => {
+        deps.observability?.warn("Scheduled task access drift could not be computed", {
+          errorClass: error instanceof Error ? error.name : "ScheduledTaskPolicyDriftError",
+          origin: "api",
+        });
+      },
+    });
+  }
+
+  // Why a schedule paused itself or why its owner was told about it. Like
+  // drift, this decorates a read and never fails it.
+  async function withBlockers(tasks: ScheduledTask[]): Promise<ScheduledTask[]> {
+    const workspaceId = tasks[0]?.workspaceId;
+    if (!workspaceId) return tasks;
+    try {
+      const blockers = await getScheduledTaskBlockers(
+        db,
+        workspaceId,
+        tasks.map((task) => task.id),
+      );
+      return tasks.map((task) => {
+        const blocker = blockers.get(task.id);
+        return blocker ? { ...task, blocker } : task;
+      });
+    } catch (error) {
+      deps.observability?.warn("Scheduled task blockers could not be read", {
+        errorClass: error instanceof Error ? error.name : "ScheduledTaskBlockerReadError",
+        origin: "api",
+      });
+      return tasks;
+    }
+  }
+
+  // Registered before `/:taskId` so the literal segment is never read as an id.
+  app.get("/v1/workspaces/:workspaceId/scheduled-tasks/attention", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    const grant = await requireAccessGrant(c, deps, workspaceId, "scheduled_tasks:run");
+    // The account plan reads only the MCP registry and tool defaults, which the
+    // model catalog does not change, so the deployment settings suffice here.
+    const tasks = await listScheduledTaskAccessAttention({
+      db,
+      settings: deps.settings,
+      grant,
+      onError: (error) => {
+        deps.observability?.warn("Scheduled task account availability could not be computed", {
+          errorClass: error instanceof Error ? error.name : "ScheduledTaskAccessAttentionError",
+          origin: "api",
+        });
+      },
+    });
+    return c.json({ tasks });
+  });
 
   app.post("/v1/workspaces/:workspaceId/scheduled-tasks", async (c) => {
     const workspaceId = c.req.param("workspaceId");
@@ -46,7 +227,9 @@ export function registerScheduledTaskRoutes(app: Hono, deps: ApiRouteDeps): void
       "scheduled_tasks:manage",
     );
     const grant = authorization.grant;
-    const rawPayload = await c.req.json();
+    const legacy = rejectLegacyVariableSetFields(c, await readRequestJson(c));
+    if ("response" in legacy) return legacy.response;
+    const rawPayload = legacy.payload;
     const parsedPayload = CreateScheduledTaskRequest.safeParse(rawPayload);
     if (!parsedPayload.success) {
       throw new HTTPException(400, {
@@ -76,6 +259,7 @@ export function registerScheduledTaskRoutes(app: Hono, deps: ApiRouteDeps): void
       toolsProvided: scheduledTaskToolsProvided(rawPayload),
       sessionAuthorization: deps.sessionAuthorization,
       authorizationSurface: "http",
+      verifySlackChannel: slackChannelVerifier(grant),
     });
     await syncCreatedScheduledTask({ db, workflowClient, task });
     return c.json(scheduledTaskForGrant(task, grant), 201);
@@ -83,7 +267,13 @@ export function registerScheduledTaskRoutes(app: Hono, deps: ApiRouteDeps): void
 
   app.get("/v1/workspaces/:workspaceId/scheduled-tasks", async (c) => {
     const workspaceId = c.req.param("workspaceId");
-    const grant = await requireAccessGrant(c, deps, workspaceId, "scheduled_tasks:run");
+    const authorization = await requireAccessGrantAuthorization(
+      c,
+      deps,
+      workspaceId,
+      "scheduled_tasks:run",
+    );
+    const grant = authorization.grant;
     const sessionId = c.req.query("sessionId");
     const offset = Number(c.req.query("offset") ?? 0);
     if (!Number.isSafeInteger(offset) || offset < 0) {
@@ -95,21 +285,109 @@ export function registerScheduledTaskRoutes(app: Hono, deps: ApiRouteDeps): void
       }
       await requireAccessGrant(c, deps, workspaceId, "sessions:control");
     }
+    const viewer = await scheduledTaskViewerForGrant(db, grant, deps.settings);
     const tasks = await listScheduledTasks(
       db,
       workspaceId,
       boundedLimit(c.req.query("limit")),
       offset,
       sessionId,
+      viewer.subjectId,
+    );
+    return c.json(
+      (await withBlockers(await withPolicyDrift(authorization, tasks))).map((task) =>
+        scheduledTaskForGrant(task, grant),
+      ),
     );
-    return c.json(tasks.map((task) => scheduledTaskForGrant(task, grant)));
   });
 
+  // Registered before `/:taskId`. Admins see that other people's Only me
+  // schedules exist: owner, how often, last run and cost. Never their name,
+  // prompt, settings or runs.
+  app.get("/v1/workspaces/:workspaceId/scheduled-tasks/private-summaries", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    const grant = await requireAccessGrant(c, deps, workspaceId, "workspace:admin");
+    const viewer = await scheduledTaskViewerForGrant(db, grant, deps.settings);
+    // The organization can choose that admins don't see these at all.
+    const schedules = viewer.seesPrivateSummaries
+      ? await listPrivateScheduledTaskSummaries(db, {
+          workspaceId,
+          excludeOwnerSubjectId: viewer.subjectId,
+        })
+      : [];
+    return c.json(ListPrivateScheduledTaskSummariesResponse.parse({ schedules }));
+  });
+
+  // An admin pauses someone else's Only me schedule from its summary. Only its
+  // owner can change, run or resume it.
+  app.post(
+    "/v1/workspaces/:workspaceId/scheduled-tasks/private-summaries/:taskId/pause",
+    async (c) => {
+      const workspaceId = c.req.param("workspaceId");
+      const grant = await requireAccessGrant(c, deps, workspaceId, "workspace:admin");
+      const viewer = await scheduledTaskViewerForGrant(db, grant, deps.settings);
+      const pausable = await requirePausableScheduledTask(db, grant, c.req.param("taskId"), viewer);
+      if (pausable.access !== "summary")
+        throw new HTTPException(404, { message: "scheduled task not found" });
+      const summary =
+        pausable.summary.status === "paused"
+          ? pausable.summary
+          : await pausePrivateScheduledTaskAsAdmin(db, grant, pausable.summary.id, viewer);
+      return c.json(PrivateScheduledTaskSummary.parse(summary));
+    },
+  );
+
   app.get("/v1/workspaces/:workspaceId/scheduled-tasks/:taskId", async (c) => {
     const workspaceId = c.req.param("workspaceId");
-    const grant = await requireAccessGrant(c, deps, workspaceId, "scheduled_tasks:run");
-    const task = await requireScheduledTaskForApi(db, workspaceId, c.req.param("taskId"));
-    return c.json(scheduledTaskForGrant(task, grant));
+    const authorization = await requireAccessGrantAuthorization(
+      c,
+      deps,
+      workspaceId,
+      "scheduled_tasks:run",
+    );
+    const grant = authorization.grant;
+    const task = await requireVisibleScheduledTask(db, grant, c.req.param("taskId"));
+    const [decorated] = await withBlockers(await withPolicyDrift(authorization, [task]));
+    return c.json(scheduledTaskForGrant(decorated ?? task, grant));
+  });
+
+  // The owner's explicit access refresh: re-freeze connectors, connector
+  // accounts and an agent-created task's Opengeni tools with the calling
+  // person's current authority. It changes neither the schedule nor its
+  // status, so the Temporal schedule is untouched.
+  app.post("/v1/workspaces/:workspaceId/scheduled-tasks/:taskId/refresh-access", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    const authorization = await requireAccessGrantAuthorization(
+      c,
+      deps,
+      workspaceId,
+      "scheduled_tasks:manage",
+    );
+    const parsed = RefreshScheduledTaskAccessRequest.safeParse(
+      await c.req.json().catch(() => null),
+    );
+    if (!parsed.success) {
+      throw new HTTPException(400, { message: "invalid scheduled task access refresh request" });
+    }
+    const catalogSettings = (
+      await resolveWorkspaceCatalogSettings(db, deps.settings, {
+        accountId: authorization.grant.accountId,
+        workspaceId,
+      })
+    ).settings;
+    const task = await refreshScheduledTaskAccess({
+      settings: catalogSettings,
+      db,
+      objectStorage,
+      authorization,
+      taskId: c.req.param("taskId"),
+      request: parsed.data,
+      permissionsRequiredByTools: permissionsRequiredByFirstPartyTools,
+      sessionAuthorization: deps.sessionAuthorization,
+      authorizationSurface: "http",
+    });
+    const [withDrift] = await withPolicyDrift(authorization, [task]);
+    return c.json(scheduledTaskForGrant(withDrift ?? task, authorization.grant));
   });
 
   app.patch("/v1/workspaces/:workspaceId/scheduled-tasks/:taskId", async (c) => {
@@ -122,16 +400,23 @@ export function registerScheduledTaskRoutes(app: Hono, deps: ApiRouteDeps): void
     );
     const grant = authorization.grant;
     const taskId = c.req.param("taskId");
-    const existing = await requireScheduledTaskForApi(db, workspaceId, taskId);
+    const existing = await requireVisibleScheduledTask(db, grant, taskId);
     const previous = await captureScheduledTaskRestoreState(db, existing);
-    const rawPayload = await c.req.json();
+    const body = await readRequestJson(c);
+    const legacy = rejectLegacyVariableSetFields(c, body);
+    if ("response" in legacy) return legacy.response;
+    const rawPayload = legacy.payload;
     const parsedPayload = UpdateScheduledTaskRequest.safeParse(rawPayload);
     if (!parsedPayload.success) {
       throw new HTTPException(400, {
         message: "invalid scheduled task update request",
       });
     }
-    const payload = parsedPayload.data;
+    // `variableSetId: null` / `variableSetIds: []` still clear an old link, so a
+    // task tied to a set that is gone can be fixed without recreating it.
+    const payload = clearsLegacyVariableSet(body)
+      ? { ...parsedPayload.data, variableSetId: null }
+      : parsedPayload.data;
     const catalogSettings = (
       await resolveWorkspaceCatalogSettings(db, deps.settings, {
         accountId: grant.accountId,
@@ -149,10 +434,11 @@ export function registerScheduledTaskRoutes(app: Hono, deps: ApiRouteDeps): void
       toolsProvided: scheduledTaskToolsProvided(rawPayload),
       sessionAuthorization: deps.sessionAuthorization,
       authorizationSurface: "http",
+      verifySlackChannel: slackChannelVerifier(grant),
     });
     const task = await updateScheduledTaskForApi(
       db,
-      workspaceId,
+      grant,
       taskId,
       update,
       payload.agentLearning
@@ -166,11 +452,15 @@ export function registerScheduledTaskRoutes(app: Hono, deps: ApiRouteDeps): void
   app.post("/v1/workspaces/:workspaceId/scheduled-tasks/:taskId/pause", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     const grant = await requireAccessGrant(c, deps, workspaceId, "scheduled_tasks:manage");
-    const existing = await requireScheduledTaskForApi(db, workspaceId, c.req.param("taskId"));
+    const viewer = await scheduledTaskViewerForGrant(db, grant, deps.settings);
+    const existing = await requireVisibleScheduledTask(db, grant, c.req.param("taskId"), viewer);
     const previous = await captureScheduledTaskRestoreState(db, existing);
-    const task = await updateScheduledTaskForApi(db, workspaceId, existing.id, {
-      status: "paused",
-    });
+    const ownerPause = viewer.subjectId !== null && existing.ownerSubjectId === viewer.subjectId;
+    const adminPause = viewer.admin && !ownerPause;
+    if (adminPause) await assertNotSiteClampedAgent(db, grant, "schedules");
+    const task = adminPause
+      ? await pauseScheduledTaskAsAdmin(db, workspaceId, existing.id)
+      : await updateScheduledTaskForApi(db, grant, existing.id, { status: "paused" });
     await syncUpdatedScheduledTask({ db, workflowClient, previous, task });
     return c.json(scheduledTaskForGrant(task, grant));
   });
@@ -184,7 +474,7 @@ export function registerScheduledTaskRoutes(app: Hono, deps: ApiRouteDeps): void
       "scheduled_tasks:manage",
     );
     const grant = authorization.grant;
-    const existing = await requireScheduledTaskForApi(db, workspaceId, c.req.param("taskId"));
+    const existing = await requireVisibleScheduledTask(db, grant, c.req.param("taskId"));
     const previous = await captureScheduledTaskRestoreState(db, existing);
     const catalogSettings = (
       await resolveWorkspaceCatalogSettings(db, deps.settings, {
@@ -203,7 +493,7 @@ export function registerScheduledTaskRoutes(app: Hono, deps: ApiRouteDeps): void
       sessionAuthorization: deps.sessionAuthorization,
       authorizationSurface: "http",
     });
-    const task = await updateScheduledTaskForApi(db, workspaceId, existing.id, update);
+    const task = await updateScheduledTaskForApi(db, grant, existing.id, update);
     await syncUpdatedScheduledTask({ db, workflowClient, previous, task });
     return c.json(scheduledTaskForGrant(task, grant));
   });
@@ -213,7 +503,7 @@ export function registerScheduledTaskRoutes(app: Hono, deps: ApiRouteDeps): void
     const grant = await requireAccessGrant(c, deps, workspaceId, "scheduled_tasks:run");
     // Load the task before the gate so a codex-model scheduled task can be
     // recognised as codex-billed and skip the credit/cost gates at the edge.
-    const task = await requireScheduledTaskForApi(db, workspaceId, c.req.param("taskId"));
+    const task = await requireVisibleScheduledTask(db, grant, c.req.param("taskId"));
     if (task.action.kind === "agent_turn") {
       const catalogSettings = (
         await resolveWorkspaceCatalogSettings(db, deps.settings, {
@@ -239,30 +529,45 @@ export function registerScheduledTaskRoutes(app: Hono, deps: ApiRouteDeps): void
         grant,
         runMode: task.runMode,
         agentConfig: task.agentConfig,
+        audience: task.visibility === "private" ? "user_private" : "workspace_shared",
         requireOnline: true,
       });
+      const taskAuthoritySubjectId = await getScheduledTaskRevisionAuthoritySubject(db, {
+        accountId: task.accountId,
+        workspaceId: task.workspaceId,
+        taskId: task.id,
+        taskAuthorityRevision: task.authorityRevision,
+      });
       await requireLimit(
         { ...deps, settings: catalogSettings },
         {
           accountId: grant.accountId,
           workspaceId,
+          // A manual trigger does not transfer the task's frozen human to
+          // the triggering administrator. Unavailable authority is refused
+          // visibly by worker dispatch; this edge still checks the workspace.
+          initiatingHumanSubjectId:
+            taskAuthoritySubjectId === task.ownerSubjectId ? taskAuthoritySubjectId : null,
           action: "agent_run:create",
           quantity: 1,
-          model: task.agentConfig.model ?? catalogSettings.openaiModel,
+          // A model-less task is checked against the model its occurrence
+          // will run (a connected subscription, the credits default, or the
+          // deployment default), not always the deployment default.
+          model: await resolveScheduledTaskPreflightModel(db, catalogSettings, task),
         },
       );
     }
     // Body is optional (a bare POST is still a valid trigger); only a present,
     // non-empty body must parse against the contract.
     const body = await c.req.json().catch(() => ({}));
-    const { triggerId } = TriggerScheduledTaskRequest.parse(body ?? {});
+    const { triggerId } = parseRequestBody(TriggerScheduledTaskRequest, body ?? {});
     const triggerToken = scheduledTaskTriggerToken(triggerId);
     const agentRunUsageIdempotencyKey =
       task.action.kind === "agent_turn"
         ? manualScheduledTaskTriggerUsageKey(workspaceId, task.id, triggerToken)
         : `knowledge-source-sync:manual:${workspaceId}:${task.id}:${triggerToken}`;
     const triggerWorkflowId = manualScheduledTaskTriggerWorkflowId(task.id, triggerToken);
-    await workflowClient.triggerScheduledTask({
+    await triggerScheduledTaskForGrant(db, grant, workflowClient, {
       task,
       agentRunUsageIdempotencyKey,
       triggerWorkflowId,
@@ -287,10 +592,18 @@ export function registerScheduledTaskRoutes(app: Hono, deps: ApiRouteDeps): void
   app.delete("/v1/workspaces/:workspaceId/scheduled-tasks/:taskId", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     const grant = await requireAccessGrant(c, deps, workspaceId, "scheduled_tasks:manage");
+    // Deleting stays idempotent, but someone else's Only me schedule is
+    // indistinguishable from a missing one.
+    const target = await getScheduledTaskIncludingDeleted(db, workspaceId, c.req.param("taskId"));
+    if (
+      target &&
+      scheduledTaskAccess(await scheduledTaskViewerForGrant(db, grant, deps.settings), target) !==
+        "full"
+    )
+      throw new HTTPException(404, { message: "scheduled task not found" });
     await deleteScheduledTaskWithDurableCleanup(deps, {
-      workspaceId,
+      grant,
       taskId: c.req.param("taskId"),
-      subjectId: grant.subjectId,
     });
     return c.json({ ok: true });
   });
@@ -298,13 +611,20 @@ export function registerScheduledTaskRoutes(app: Hono, deps: ApiRouteDeps): void
   app.get("/v1/workspaces/:workspaceId/scheduled-tasks/:taskId/runs", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     const grant = await requireAccessGrant(c, deps, workspaceId, "scheduled_tasks:run");
-    const task = await requireScheduledTaskForApi(db, workspaceId, c.req.param("taskId"));
+    const task = await requireVisibleScheduledTask(db, grant, c.req.param("taskId"));
     const taskRuns = await listScheduledTaskRuns(
       db,
       workspaceId,
       task.id,
       boundedLimit(c.req.query("limit")),
     );
-    return c.json(taskRuns.map((run) => scheduledTaskRunForGrant(run, grant)));
+    const runs = await withScheduledTaskRunAccessFailures({
+      db,
+      settings: deps.settings,
+      grant,
+      task,
+      runs: taskRuns,
+    });
+    return c.json(runs.map((run) => scheduledTaskRunForGrant(run, grant)));
   });
 }