@sentry/junior-scheduler 0.66.3 → 0.67.0

package/dist/index.js

@@ -606,6 +606,43 @@ function canFinishRun(run, startedAtMs) {
   }
   return run.status === "running" && run.startedAtMs === startedAtMs;
 }
+async function getTaskFromState(state, taskId) {
+  return await state.get(taskKey(taskId)) ?? void 0;
+}
+async function listTasksFromState(state, indexKey) {
+  const ids = await getIndex(state, indexKey);
+  const tasks = await Promise.all(ids.map((id) => getTaskFromState(state, id)));
+  return tasks.filter((task) => Boolean(task)).filter((task) => task.status !== "deleted").sort((a, b) => a.createdAtMs - b.createdAtMs);
+}
+async function getRunFromState(state, runId) {
+  return await state.get(runKey(runId)) ?? void 0;
+}
+async function listIncompleteRunsForTasksFromState(state, tasks) {
+  const runs = [];
+  for (const task of tasks) {
+    const active = await state.get(activeRunKey(task.id));
+    if (typeof active?.runId !== "string") {
+      continue;
+    }
+    const run = await getRunFromState(state, active.runId);
+    if (run && !isFinishedRun(run)) {
+      runs.push(run);
+    }
+  }
+  return runs;
+}
+var PluginStateSchedulerOperationalStore = class {
+  state;
+  constructor(state) {
+    this.state = state;
+  }
+  async listTasks() {
+    return await listTasksFromState(this.state, globalTaskIndexKey());
+  }
+  async listIncompleteRunsForTasks(tasks) {
+    return await listIncompleteRunsForTasksFromState(this.state, tasks);
+  }
+};
 var PluginStateSchedulerStore = class {
   state;
   constructor(state) {
@@ -653,12 +690,13 @@ var PluginStateSchedulerStore = class {
     }
   }
   async getTask(taskId) {
-    return await this.state.get(taskKey(taskId)) ?? void 0;
+    return await getTaskFromState(this.state, taskId);
+  }
+  async listTasks() {
+    return await listTasksFromState(this.state, globalTaskIndexKey());
   }
   async listTasksForTeam(teamId) {
-    const ids = await getIndex(this.state, teamTaskIndexKey(teamId));
-    const tasks = await Promise.all(ids.map((id) => this.getTask(id)));
-    return tasks.filter((task) => Boolean(task)).filter((task) => task.status !== "deleted").sort((a, b) => a.createdAtMs - b.createdAtMs);
+    return await listTasksFromState(this.state, teamTaskIndexKey(teamId));
   }
   async claimDueRun(args) {
     const ids = await getIndex(this.state, globalTaskIndexKey());
@@ -772,24 +810,11 @@ var PluginStateSchedulerStore = class {
     ).sort((a, b) => a.createdAtMs - b.createdAtMs || a.id.localeCompare(b.id)).at(0);
   }
   async getRun(runId) {
-    return await this.state.get(runKey(runId)) ?? void 0;
+    return await getRunFromState(this.state, runId);
   }
   async listIncompleteRuns() {
-    const ids = await getIndex(this.state, globalTaskIndexKey());
-    const runs = [];
-    for (const taskId of ids) {
-      const active = await this.state.get(
-        activeRunKey(taskId)
-      );
-      if (typeof active?.runId !== "string") {
-        continue;
-      }
-      const run = await this.getRun(active.runId);
-      if (run && !isFinishedRun(run)) {
-        runs.push(run);
-      }
-    }
-    return runs;
+    const tasks = await this.listTasks();
+    return await listIncompleteRunsForTasksFromState(this.state, tasks);
   }
   async markRunDispatched(args) {
     return await this.updateRun(
@@ -938,6 +963,9 @@ var PluginStateSchedulerStore = class {
 function createSchedulerStore(state) {
   return new PluginStateSchedulerStore(state);
 }
+function createSchedulerOperationalStore(state) {
+  return new PluginStateSchedulerOperationalStore(state);
+}
 
 // src/schedule-tools.ts
 import { randomUUID } from "crypto";
@@ -1413,6 +1441,7 @@ function createSlackScheduleRunTaskNowTool(context) {
 
 // src/plugin.ts
 var SCHEDULER_HEARTBEAT_LIMIT = 10;
+var DASHBOARD_TABLE_LIMIT = 5;
 function shouldSkipRun(task, run) {
   if (task.status === "deleted") {
     return `Scheduled task ${task.id} was deleted before the run started.`;
@@ -1531,6 +1560,161 @@ async function failClaimedRun(args) {
     status: "failed"
   });
 }
+function formatCount(value) {
+  return String(value);
+}
+function formatTimestamp(timestampMs) {
+  return typeof timestampMs === "number" && Number.isFinite(timestampMs) ? new Date(timestampMs).toISOString() : "none";
+}
+function destinationLabel(destination) {
+  if (destination.channelId.startsWith("D")) {
+    return "Direct Message";
+  }
+  if (destination.channelId.startsWith("C")) {
+    return `Public Channel ${destination.channelId}`;
+  }
+  if (destination.channelId.startsWith("G")) {
+    return `Private Destination ${destination.channelId}`;
+  }
+  return destination.channelId;
+}
+function authorLabel(author) {
+  if (author.fullName && author.userName) {
+    return `${author.fullName} (@${author.userName})`;
+  }
+  if (author.fullName) {
+    return author.fullName;
+  }
+  if (author.userName) {
+    return `@${author.userName}`;
+  }
+  return `Slack User ${author.slackUserId}`;
+}
+function cadenceLabel(task) {
+  if (task.schedule.kind === "one_off") {
+    return "one-off";
+  }
+  return task.schedule.recurrence ? task.schedule.recurrence.frequency : "recurring";
+}
+function taskStatusCounts(tasks) {
+  return tasks.reduce(
+    (counts, task) => ({
+      active: counts.active + (task.status === "active" ? 1 : 0),
+      blocked: counts.blocked + (task.status === "blocked" ? 1 : 0),
+      paused: counts.paused + (task.status === "paused" ? 1 : 0)
+    }),
+    { active: 0, blocked: 0, paused: 0 }
+  );
+}
+function isDue(task, nowMs) {
+  return task.status === "active" && (typeof task.runNowAtMs === "number" && task.runNowAtMs <= nowMs || typeof task.nextRunAtMs === "number" && task.nextRunAtMs <= nowMs);
+}
+async function buildSchedulerOperationalReport(args) {
+  const tasks = await args.store.listTasks();
+  const incompleteRuns = await args.store.listIncompleteRunsForTasks(tasks);
+  const taskById = new Map(tasks.map((task) => [task.id, task]));
+  const counts = taskStatusCounts(tasks);
+  const dueCount = tasks.filter((task) => isDue(task, args.nowMs)).length;
+  const upcomingTasks = tasks.filter((task) => task.status === "active" && task.nextRunAtMs).sort((left, right) => left.nextRunAtMs - right.nextRunAtMs).slice(0, DASHBOARD_TABLE_LIMIT);
+  const blockedTasks = tasks.filter((task) => task.status === "blocked").sort((left, right) => right.updatedAtMs - left.updatedAtMs).slice(0, DASHBOARD_TABLE_LIMIT);
+  const runningCount = incompleteRuns.length;
+  const runningRuns = incompleteRuns.sort((left, right) => right.claimedAtMs - left.claimedAtMs).slice(0, DASHBOARD_TABLE_LIMIT);
+  return {
+    title: "Scheduler",
+    generatedAt: new Date(args.nowMs).toISOString(),
+    metrics: [
+      {
+        label: "active",
+        tone: counts.active > 0 ? "good" : "neutral",
+        value: formatCount(counts.active)
+      },
+      {
+        label: "blocked",
+        tone: counts.blocked > 0 ? "danger" : "neutral",
+        value: formatCount(counts.blocked)
+      },
+      { label: "paused", value: formatCount(counts.paused) },
+      {
+        label: "due now",
+        tone: dueCount > 0 ? "warning" : "neutral",
+        value: formatCount(dueCount)
+      },
+      {
+        label: "running",
+        tone: runningCount > 0 ? "warning" : "neutral",
+        value: formatCount(runningCount)
+      }
+    ],
+    recordSets: [
+      {
+        title: "Upcoming",
+        emptyText: "No active scheduled tasks.",
+        fields: [
+          { key: "task", label: "Task" },
+          { key: "author", label: "Author" },
+          { key: "destination", label: "Destination" },
+          { key: "nextRun", label: "Next Run" },
+          { key: "cadence", label: "Cadence" }
+        ],
+        records: upcomingTasks.map((task) => ({
+          id: task.id,
+          values: {
+            task: task.id,
+            author: authorLabel(task.createdBy),
+            destination: destinationLabel(task.destination),
+            nextRun: formatTimestamp(task.nextRunAtMs),
+            cadence: cadenceLabel(task)
+          }
+        }))
+      },
+      {
+        title: "Blocked",
+        emptyText: "No blocked scheduled tasks.",
+        fields: [
+          { key: "task", label: "Task" },
+          { key: "author", label: "Author" },
+          { key: "destination", label: "Destination" },
+          { key: "updated", label: "Updated" }
+        ],
+        records: blockedTasks.map((task) => ({
+          id: task.id,
+          tone: "danger",
+          values: {
+            task: task.id,
+            author: authorLabel(task.createdBy),
+            destination: destinationLabel(task.destination),
+            updated: formatTimestamp(task.updatedAtMs)
+          }
+        }))
+      },
+      {
+        title: "Running",
+        emptyText: "No scheduler runs in flight.",
+        fields: [
+          { key: "run", label: "Run" },
+          { key: "task", label: "Task" },
+          { key: "author", label: "Author" },
+          { key: "scheduledFor", label: "Scheduled For" },
+          { key: "status", label: "Status" }
+        ],
+        records: runningRuns.map((run) => {
+          const task = taskById.get(run.taskId);
+          return {
+            id: run.id,
+            tone: run.status === "pending" ? "warning" : "neutral",
+            values: {
+              run: run.id,
+              task: run.taskId,
+              author: task ? authorLabel(task.createdBy) : "unknown",
+              scheduledFor: formatTimestamp(run.scheduledForMs),
+              status: run.status
+            }
+          };
+        })
+      }
+    ]
+  };
+}
 function createSchedulerPlugin() {
   return defineJuniorPlugin({
     manifest: {
@@ -1650,6 +1834,12 @@ function createSchedulerPlugin() {
           dispatchCount += 1;
         }
         return { dispatchCount };
+      },
+      async operationalReport(ctx) {
+        return buildSchedulerOperationalReport({
+          nowMs: ctx.nowMs,
+          store: createSchedulerOperationalStore(ctx.state)
+        });
       }
     }
   });

package/dist/store.d.ts

@@ -1,4 +1,4 @@
-import type { AgentPluginState } from "@sentry/junior-plugin-api";
+import type { AgentPluginReadState, AgentPluginState } from "@sentry/junior-plugin-api";
 import type { ScheduledRun, ScheduledTask } from "./types";
 export interface SchedulerStore {
     claimDueRun(args: {
@@ -7,6 +7,7 @@ export interface SchedulerStore {
     getRun(runId: string): Promise<ScheduledRun | undefined>;
     getTask(taskId: string): Promise<ScheduledTask | undefined>;
     listIncompleteRuns(): Promise<ScheduledRun[]>;
+    listTasks(): Promise<ScheduledTask[]>;
     listTasksForTeam(teamId: string): Promise<ScheduledTask[]>;
     markRunBlocked(args: {
         completedAtMs: number;
@@ -45,5 +46,11 @@ export interface SchedulerStore {
         status: "blocked" | "completed" | "failed";
     }): Promise<void>;
 }
+export interface SchedulerOperationalStore {
+    listIncompleteRunsForTasks(tasks: ScheduledTask[]): Promise<ScheduledRun[]>;
+    listTasks(): Promise<ScheduledTask[]>;
+}
 /** Create a scheduler store backed by this plugin's durable state namespace. */
 export declare function createSchedulerStore(state: AgentPluginState): SchedulerStore;
+/** Create a read-only scheduler store for operational reporting. */
+export declare function createSchedulerOperationalStore(state: AgentPluginReadState): SchedulerOperationalStore;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior-scheduler",
-  "version": "0.66.3",
+  "version": "0.67.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -23,7 +23,7 @@
   ],
   "dependencies": {
     "@sinclair/typebox": "^0.34.49",
-    "@sentry/junior-plugin-api": "0.66.3"
+    "@sentry/junior-plugin-api": "0.67.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",

package/src/plugin.ts

@@ -2,10 +2,16 @@ import {
   defineJuniorPlugin,
   type Dispatch,
   type AgentPluginToolDefinition,
+  type PluginOperationalReportContent,
   type ToolRegistrationHookContext,
 } from "@sentry/junior-plugin-api";
 import { buildScheduledTaskRunPrompt } from "./prompt";
-import { createSchedulerStore, type SchedulerStore } from "./store";
+import {
+  createSchedulerOperationalStore,
+  createSchedulerStore,
+  type SchedulerOperationalStore,
+  type SchedulerStore,
+} from "./store";
 import type { ScheduledRun, ScheduledTask } from "./types";
 import {
   createSlackScheduleCreateTaskTool,
@@ -17,6 +23,7 @@ import {
 } from "./schedule-tools";
 
 const SCHEDULER_HEARTBEAT_LIMIT = 10;
+const DASHBOARD_TABLE_LIMIT = 5;
 
 function shouldSkipRun(
   task: ScheduledTask,
@@ -167,6 +174,189 @@ async function failClaimedRun(args: {
   });
 }
 
+function formatCount(value: number): string {
+  return String(value);
+}
+
+function formatTimestamp(timestampMs: number | undefined): string {
+  return typeof timestampMs === "number" && Number.isFinite(timestampMs)
+    ? new Date(timestampMs).toISOString()
+    : "none";
+}
+
+function destinationLabel(destination: ScheduledTask["destination"]): string {
+  if (destination.channelId.startsWith("D")) {
+    return "Direct Message";
+  }
+  if (destination.channelId.startsWith("C")) {
+    return `Public Channel ${destination.channelId}`;
+  }
+  if (destination.channelId.startsWith("G")) {
+    return `Private Destination ${destination.channelId}`;
+  }
+  return destination.channelId;
+}
+
+function authorLabel(author: ScheduledTask["createdBy"]): string {
+  if (author.fullName && author.userName) {
+    return `${author.fullName} (@${author.userName})`;
+  }
+  if (author.fullName) {
+    return author.fullName;
+  }
+  if (author.userName) {
+    return `@${author.userName}`;
+  }
+  return `Slack User ${author.slackUserId}`;
+}
+
+function cadenceLabel(task: ScheduledTask): string {
+  if (task.schedule.kind === "one_off") {
+    return "one-off";
+  }
+  return task.schedule.recurrence
+    ? task.schedule.recurrence.frequency
+    : "recurring";
+}
+
+function taskStatusCounts(tasks: ScheduledTask[]) {
+  return tasks.reduce(
+    (counts, task) => ({
+      active: counts.active + (task.status === "active" ? 1 : 0),
+      blocked: counts.blocked + (task.status === "blocked" ? 1 : 0),
+      paused: counts.paused + (task.status === "paused" ? 1 : 0),
+    }),
+    { active: 0, blocked: 0, paused: 0 },
+  );
+}
+
+function isDue(task: ScheduledTask, nowMs: number): boolean {
+  return (
+    task.status === "active" &&
+    ((typeof task.runNowAtMs === "number" && task.runNowAtMs <= nowMs) ||
+      (typeof task.nextRunAtMs === "number" && task.nextRunAtMs <= nowMs))
+  );
+}
+
+async function buildSchedulerOperationalReport(args: {
+  nowMs: number;
+  store: SchedulerOperationalStore;
+}): Promise<PluginOperationalReportContent> {
+  const tasks = await args.store.listTasks();
+  const incompleteRuns = await args.store.listIncompleteRunsForTasks(tasks);
+  const taskById = new Map(tasks.map((task) => [task.id, task]));
+  const counts = taskStatusCounts(tasks);
+  const dueCount = tasks.filter((task) => isDue(task, args.nowMs)).length;
+  const upcomingTasks = tasks
+    .filter((task) => task.status === "active" && task.nextRunAtMs)
+    .sort((left, right) => left.nextRunAtMs! - right.nextRunAtMs!)
+    .slice(0, DASHBOARD_TABLE_LIMIT);
+  const blockedTasks = tasks
+    .filter((task) => task.status === "blocked")
+    .sort((left, right) => right.updatedAtMs - left.updatedAtMs)
+    .slice(0, DASHBOARD_TABLE_LIMIT);
+  const runningCount = incompleteRuns.length;
+  const runningRuns = incompleteRuns
+    .sort((left, right) => right.claimedAtMs - left.claimedAtMs)
+    .slice(0, DASHBOARD_TABLE_LIMIT);
+
+  return {
+    title: "Scheduler",
+    generatedAt: new Date(args.nowMs).toISOString(),
+    metrics: [
+      {
+        label: "active",
+        tone: counts.active > 0 ? "good" : "neutral",
+        value: formatCount(counts.active),
+      },
+      {
+        label: "blocked",
+        tone: counts.blocked > 0 ? "danger" : "neutral",
+        value: formatCount(counts.blocked),
+      },
+      { label: "paused", value: formatCount(counts.paused) },
+      {
+        label: "due now",
+        tone: dueCount > 0 ? "warning" : "neutral",
+        value: formatCount(dueCount),
+      },
+      {
+        label: "running",
+        tone: runningCount > 0 ? "warning" : "neutral",
+        value: formatCount(runningCount),
+      },
+    ],
+    recordSets: [
+      {
+        title: "Upcoming",
+        emptyText: "No active scheduled tasks.",
+        fields: [
+          { key: "task", label: "Task" },
+          { key: "author", label: "Author" },
+          { key: "destination", label: "Destination" },
+          { key: "nextRun", label: "Next Run" },
+          { key: "cadence", label: "Cadence" },
+        ],
+        records: upcomingTasks.map((task) => ({
+          id: task.id,
+          values: {
+            task: task.id,
+            author: authorLabel(task.createdBy),
+            destination: destinationLabel(task.destination),
+            nextRun: formatTimestamp(task.nextRunAtMs),
+            cadence: cadenceLabel(task),
+          },
+        })),
+      },
+      {
+        title: "Blocked",
+        emptyText: "No blocked scheduled tasks.",
+        fields: [
+          { key: "task", label: "Task" },
+          { key: "author", label: "Author" },
+          { key: "destination", label: "Destination" },
+          { key: "updated", label: "Updated" },
+        ],
+        records: blockedTasks.map((task) => ({
+          id: task.id,
+          tone: "danger",
+          values: {
+            task: task.id,
+            author: authorLabel(task.createdBy),
+            destination: destinationLabel(task.destination),
+            updated: formatTimestamp(task.updatedAtMs),
+          },
+        })),
+      },
+      {
+        title: "Running",
+        emptyText: "No scheduler runs in flight.",
+        fields: [
+          { key: "run", label: "Run" },
+          { key: "task", label: "Task" },
+          { key: "author", label: "Author" },
+          { key: "scheduledFor", label: "Scheduled For" },
+          { key: "status", label: "Status" },
+        ],
+        records: runningRuns.map((run) => {
+          const task = taskById.get(run.taskId);
+          return {
+            id: run.id,
+            tone: run.status === "pending" ? "warning" : "neutral",
+            values: {
+              run: run.id,
+              task: run.taskId,
+              author: task ? authorLabel(task.createdBy) : "unknown",
+              scheduledFor: formatTimestamp(run.scheduledForMs),
+              status: run.status,
+            },
+          };
+        }),
+      },
+    ],
+  };
+}
+
 /** Create Junior's built-in trusted scheduler plugin. */
 export function createSchedulerPlugin() {
   return defineJuniorPlugin({
@@ -305,6 +495,12 @@ export function createSchedulerPlugin() {
 
         return { dispatchCount };
       },
+      async operationalReport(ctx) {
+        return buildSchedulerOperationalReport({
+          nowMs: ctx.nowMs,
+          store: createSchedulerOperationalStore(ctx.state),
+        });
+      },
     },
   });
 }

package/src/store.ts

@@ -1,4 +1,7 @@
-import type { AgentPluginState } from "@sentry/junior-plugin-api";
+import type {
+  AgentPluginReadState,
+  AgentPluginState,
+} from "@sentry/junior-plugin-api";
 import { getNextRunAtMs } from "./cadence";
 import type { ScheduledRun, ScheduledTask } from "./types";
 
@@ -15,6 +18,7 @@ export interface SchedulerStore {
   getRun(runId: string): Promise<ScheduledRun | undefined>;
   getTask(taskId: string): Promise<ScheduledTask | undefined>;
   listIncompleteRuns(): Promise<ScheduledRun[]>;
+  listTasks(): Promise<ScheduledTask[]>;
   listTasksForTeam(teamId: string): Promise<ScheduledTask[]>;
   markRunBlocked(args: {
     completedAtMs: number;
@@ -54,6 +58,11 @@ export interface SchedulerStore {
   }): Promise<void>;
 }
 
+export interface SchedulerOperationalStore {
+  listIncompleteRunsForTasks(tasks: ScheduledTask[]): Promise<ScheduledRun[]>;
+  listTasks(): Promise<ScheduledTask[]>;
+}
+
 function taskKey(taskId: string): string {
   return `${SCHEDULER_KEY_PREFIX}:task:${taskId}`;
 }
@@ -139,7 +148,7 @@ async function removeFromIndex(
 }
 
 async function getIndex(
-  state: AgentPluginState,
+  state: AgentPluginReadState,
   key: string,
 ): Promise<string[]> {
   const values = (await state.get<string[]>(key)) ?? [];
@@ -346,6 +355,68 @@ function canFinishRun(
   return run.status === "running" && run.startedAtMs === startedAtMs;
 }
 
+async function getTaskFromState(
+  state: AgentPluginReadState,
+  taskId: string,
+): Promise<ScheduledTask | undefined> {
+  return (await state.get<ScheduledTask>(taskKey(taskId))) ?? undefined;
+}
+
+async function listTasksFromState(
+  state: AgentPluginReadState,
+  indexKey: string,
+): Promise<ScheduledTask[]> {
+  const ids = await getIndex(state, indexKey);
+  const tasks = await Promise.all(ids.map((id) => getTaskFromState(state, id)));
+  return tasks
+    .filter((task): task is ScheduledTask => Boolean(task))
+    .filter((task) => task.status !== "deleted")
+    .sort((a, b) => a.createdAtMs - b.createdAtMs);
+}
+
+async function getRunFromState(
+  state: AgentPluginReadState,
+  runId: string,
+): Promise<ScheduledRun | undefined> {
+  return (await state.get<ScheduledRun>(runKey(runId))) ?? undefined;
+}
+
+async function listIncompleteRunsForTasksFromState(
+  state: AgentPluginReadState,
+  tasks: ScheduledTask[],
+): Promise<ScheduledRun[]> {
+  const runs: ScheduledRun[] = [];
+  for (const task of tasks) {
+    const active = await state.get<{ runId?: unknown }>(activeRunKey(task.id));
+    if (typeof active?.runId !== "string") {
+      continue;
+    }
+    const run = await getRunFromState(state, active.runId);
+    if (run && !isFinishedRun(run)) {
+      runs.push(run);
+    }
+  }
+  return runs;
+}
+
+class PluginStateSchedulerOperationalStore implements SchedulerOperationalStore {
+  private readonly state: AgentPluginReadState;
+
+  constructor(state: AgentPluginReadState) {
+    this.state = state;
+  }
+
+  async listTasks(): Promise<ScheduledTask[]> {
+    return await listTasksFromState(this.state, globalTaskIndexKey());
+  }
+
+  async listIncompleteRunsForTasks(
+    tasks: ScheduledTask[],
+  ): Promise<ScheduledRun[]> {
+    return await listIncompleteRunsForTasksFromState(this.state, tasks);
+  }
+}
+
 class PluginStateSchedulerStore implements SchedulerStore {
   private readonly state: AgentPluginState;
 
@@ -408,16 +479,15 @@ class PluginStateSchedulerStore implements SchedulerStore {
   }
 
   async getTask(taskId: string): Promise<ScheduledTask | undefined> {
-    return (await this.state.get<ScheduledTask>(taskKey(taskId))) ?? undefined;
+    return await getTaskFromState(this.state, taskId);
+  }
+
+  async listTasks(): Promise<ScheduledTask[]> {
+    return await listTasksFromState(this.state, globalTaskIndexKey());
   }
 
   async listTasksForTeam(teamId: string): Promise<ScheduledTask[]> {
-    const ids = await getIndex(this.state, teamTaskIndexKey(teamId));
-    const tasks = await Promise.all(ids.map((id) => this.getTask(id)));
-    return tasks
-      .filter((task): task is ScheduledTask => Boolean(task))
-      .filter((task) => task.status !== "deleted")
-      .sort((a, b) => a.createdAtMs - b.createdAtMs);
+    return await listTasksFromState(this.state, teamTaskIndexKey(teamId));
   }
 
   async claimDueRun(args: {
@@ -576,25 +646,12 @@ class PluginStateSchedulerStore implements SchedulerStore {
   }
 
   async getRun(runId: string): Promise<ScheduledRun | undefined> {
-    return (await this.state.get<ScheduledRun>(runKey(runId))) ?? undefined;
+    return await getRunFromState(this.state, runId);
   }
 
   async listIncompleteRuns(): Promise<ScheduledRun[]> {
-    const ids = await getIndex(this.state, globalTaskIndexKey());
-    const runs: ScheduledRun[] = [];
-    for (const taskId of ids) {
-      const active = await this.state.get<{ runId?: unknown }>(
-        activeRunKey(taskId),
-      );
-      if (typeof active?.runId !== "string") {
-        continue;
-      }
-      const run = await this.getRun(active.runId);
-      if (run && !isFinishedRun(run)) {
-        runs.push(run);
-      }
-    }
-    return runs;
+    const tasks = await this.listTasks();
+    return await listIncompleteRunsForTasksFromState(this.state, tasks);
   }
 
   async markRunDispatched(args: {
@@ -817,3 +874,10 @@ class PluginStateSchedulerStore implements SchedulerStore {
 export function createSchedulerStore(state: AgentPluginState): SchedulerStore {
   return new PluginStateSchedulerStore(state);
 }
+
+/** Create a read-only scheduler store for operational reporting. */
+export function createSchedulerOperationalStore(
+  state: AgentPluginReadState,
+): SchedulerOperationalStore {
+  return new PluginStateSchedulerOperationalStore(state);
+}