@hyperdrive.bot/paseo-server 0.3.40 → 0.3.42

package/dist/server/server/agent/providers/opencode-agent.js

@@ -1925,6 +1925,29 @@ function appendOpenCodeSessionError(event, state, events) {
         });
     }
 }
+/**
+ * Some opencode "retry" errors are DETERMINISTIC: the exact request that failed
+ * will fail identically on every retry, so opencode's retry-forever policy turns
+ * them into a permanent wedge (endless "Provider retry" lines, spinner never ends,
+ * the turn never reaches a terminal state). We only match the failure whose
+ * unrecoverability is provable from the request itself.
+ *
+ * Deliberately NARROW. Notably EXCLUDED (kept retryable on purpose):
+ *  - "model does not exist" / "not found": ollama and other backends lazy-load a
+ *    model on first use, so this can resolve mid-retry once the model finishes
+ *    loading. A unit test pins this as non-terminal.
+ *  - auth failures (401 / invalid api key): a token can be refreshed out of band
+ *    between retries in some provider setups.
+ *
+ * Currently the sole member is the model server rejecting a request that has no
+ * user-role message (e.g. ollama 0.32.x "no user query found in messages"). The
+ * message array cannot gain a user turn on retry, so it never recovers. Add a new
+ * pattern here only when its unrecoverability is likewise provable.
+ */
+const TERMINAL_PROVIDER_RETRY_PATTERNS = [/no user query found in messages/i];
+function isTerminalProviderRetryMessage(message) {
+    return message.length > 0 && TERMINAL_PROVIDER_RETRY_PATTERNS.some((re) => re.test(message));
+}
 function appendOpenCodeSessionStatus(event, state, events) {
     if (event.properties.sessionID !== state.sessionId) {
         return;
@@ -1936,12 +1959,32 @@ function appendOpenCodeSessionStatus(event, state, events) {
         return;
     }
     if (status.type === "retry") {
+        const message = typeof status.message === "string" ? status.message.trim() : "";
+        // A deterministic provider error fails identically on every retry, and
+        // opencode never gives up on its own. Fail the turn cleanly and ask the agent
+        // to abort the opencode session so it stops backing off forever.
+        if (isTerminalProviderRetryMessage(message)) {
+            events.push({
+                type: "timeline",
+                provider: "opencode",
+                item: {
+                    type: "error",
+                    message: `Provider gave up (non-retryable after attempt ${status.attempt}): ${message}`,
+                },
+            });
+            state.onTerminalProviderRetry?.(message);
+            events.push({
+                type: "turn_failed",
+                provider: "opencode",
+                error: message,
+            });
+            return;
+        }
         // Mirror what opencode's TUI shows: retry attempts are visible activity, not
         // terminal. opencode itself never gives up — it backs off and tries again
         // forever. If we silently swallow these the user sees a spinner with no
         // explanation. Forwarding as a timeline error item is a no-op for old
         // clients (the schema already supports it).
-        const message = typeof status.message === "string" ? status.message.trim() : "";
         const text = message
             ? `Provider retry (attempt ${status.attempt}): ${message}`
             : `Provider retry (attempt ${status.attempt})`;
@@ -2801,6 +2844,13 @@ class OpenCodeAgentSession {
                     this.selectedModelContextWindowMaxTokens = contextWindowMaxTokens;
                 }
             },
+            onTerminalProviderRetry: () => {
+                // The translated turn_failed already ends the turn for our clients; this
+                // aborts opencode's session so its own retry-forever loop stops hammering
+                // the provider in the background. Best-effort: an abort failure must not
+                // mask the terminal turn_failed.
+                void this.beginSessionAbort(this.activeForegroundTurnId, "provider_error").catch(() => { });
+            },
         });
         const events = [];
         if (typeof this.accumulatedUsage.totalCostUsd === "number") {

package/dist/server/server/agent/tools/paseo-tools.d.ts

@@ -8,6 +8,7 @@ import type { TerminalManager } from "../../../terminal/terminal-manager.js";
 import type { CreatePaseoWorktreeWorkflowFn } from "../../worktree-session.js";
 import type { JudgeRelayGate } from "../judge-relay-gate.js";
 import type { ScheduleService } from "../../schedule/service.js";
+import { type ScheduleCadence } from "@hyperdrive.bot/paseo-protocol/schedule/types";
 import type { ProviderSnapshotManager } from "../provider-snapshot-manager.js";
 import type { GitHubService } from "../../../services/github-service.js";
 import type { WorkspaceGitService } from "../../workspace-git-service.js";
@@ -62,5 +63,23 @@ export interface PaseoToolHostDependencies {
     judgeRelayGate?: JudgeRelayGate;
     logger: Logger;
 }
+export interface ScheduleCreateCadenceArgs {
+    at?: string;
+    every?: string;
+    cron?: string;
+    timezone?: string;
+}
+export interface ResolvedScheduleCreateCadence {
+    cadence: ScheduleCadence;
+    /**
+     * `at` is a one-off. It lowers to an `every` cadence whose interval is the
+     * distance to the instant, pinned to a single run. An `every` schedule stores
+     * the computed `nextRunAt`, so a daemon that was down at that moment fires it
+     * late on the next tick, which is what a reminder wants. A pinned cron would
+     * instead skip silently to the next calendar match a year away.
+     */
+    oneOff: boolean;
+}
+export declare function resolveScheduleCreateCadence(input: ScheduleCreateCadenceArgs, now: Date): ResolvedScheduleCreateCadence;
 export declare function createPaseoToolCatalog(options: PaseoToolHostDependencies): PaseoToolCatalog;
 //# sourceMappingURL=paseo-tools.d.ts.map

package/dist/server/server/agent/tools/paseo-tools.js

@@ -141,6 +141,51 @@ function resolveScheduleUpdateCadence(input) {
     }
     return undefined;
 }
+// A duration ("90m", "2h30m", "45" seconds) rather than a timestamp. Checked
+// first so `at` can accept both without Date parsing guessing at bare numbers.
+const SCHEDULE_DURATION_ONLY_PATTERN = /^(?:\d+|(?:\d+[smhd])+)$/;
+function resolveScheduleAtInstant(at, now) {
+    if (SCHEDULE_DURATION_ONLY_PATTERN.test(at)) {
+        return new Date(now.getTime() + parseDurationString(at));
+    }
+    const parsed = new Date(at);
+    if (Number.isNaN(parsed.getTime())) {
+        throw new Error(`Invalid at value: ${at}. Use an ISO 8601 instant (2026-08-21T21:30:00-03:00) or a duration from now (90m).`);
+    }
+    return parsed;
+}
+export function resolveScheduleCreateCadence(input, now) {
+    const at = normalizeScheduleCadenceArg(input.at);
+    const every = normalizeScheduleCadenceArg(input.every);
+    const cron = normalizeScheduleCadenceArg(input.cron);
+    const timeZone = normalizeScheduleTimeZoneArg(input.timezone);
+    const provided = [at, every, cron].filter((value) => value !== undefined);
+    if (provided.length !== 1) {
+        throw new Error("Specify exactly one of at, every, or cron");
+    }
+    if (timeZone !== undefined && cron === undefined) {
+        throw new Error("timezone can only be used with cron");
+    }
+    if (at !== undefined) {
+        const instant = resolveScheduleAtInstant(at, now);
+        const everyMs = instant.getTime() - now.getTime();
+        if (everyMs <= 0) {
+            throw new Error(`at must be in the future: ${instant.toISOString()} is not after ${now.toISOString()}`);
+        }
+        return { cadence: { type: "every", everyMs }, oneOff: true };
+    }
+    if (every !== undefined) {
+        return { cadence: { type: "every", everyMs: parseDurationString(every) }, oneOff: false };
+    }
+    return {
+        cadence: {
+            type: "cron",
+            expression: cron,
+            ...(timeZone !== undefined ? { timezone: timeZone } : {}),
+        },
+        oneOff: false,
+    };
+}
 function resolveScheduleUpdateExpiresAt(input) {
     if (input.expiresIn !== undefined && input.clearExpires) {
         throw new Error("Specify at most one of expiresIn or clearExpires");
@@ -277,18 +322,6 @@ export function createPaseoToolCatalog(options) {
             return tool.handler(await parseToolInput(tool, input), context);
         },
     });
-    const buildCronScheduleCadence = (input) => {
-        const expression = input.cron?.trim() ?? "";
-        if (!expression) {
-            throw new Error("cron is required");
-        }
-        const timezone = normalizeScheduleTimeZoneArg(input.timezone);
-        return {
-            type: "cron",
-            expression,
-            ...(timezone !== undefined ? { timezone } : {}),
-        };
-    };
     const buildScheduleExpiry = (expiresIn) => {
         return expiresIn === undefined
             ? undefined
@@ -427,6 +460,59 @@ export function createPaseoToolCatalog(options) {
             },
         };
     };
+    // A schedule bound to an agent that is gone can never fire: the startup sweep
+    // completes it on sight. Fail loudly at create time instead of handing back a
+    // schedule that reads active and is already dead.
+    const assertScheduleTargetAgentExists = async (agentId) => {
+        if (agentManager.getAgent(agentId)) {
+            return;
+        }
+        const record = await agentStorage.get(agentId);
+        if (!record || record.internal) {
+            throw new Error(`Agent ${agentId} not found`);
+        }
+        if (record.archivedAt) {
+            throw new Error(`Agent ${agentId} is archived and cannot be a schedule target`);
+        }
+    };
+    const resolveScheduleCreateTarget = async (params) => {
+        const target = params.target?.trim();
+        // Default stays new-agent so callers written against the narrower schema
+        // keep the behaviour they had before target existed.
+        if (!target || target === "new-agent") {
+            return resolveNewAgentScheduleTarget({
+                ...(params.provider !== undefined ? { provider: params.provider } : {}),
+                ...(params.cwd !== undefined ? { cwd: params.cwd } : {}),
+            });
+        }
+        if (params.provider !== undefined || params.cwd !== undefined) {
+            throw new Error("provider and cwd can only be used with target new-agent");
+        }
+        if (target === "self") {
+            if (!callerAgentId) {
+                throw new Error('target "self" requires an agent-scoped session');
+            }
+            resolveCallerAgent();
+            return { type: "agent", agentId: callerAgentId };
+        }
+        await assertScheduleTargetAgentExists(target);
+        return { type: "agent", agentId: target };
+    };
+    // Recurring creates go through createOrReplace so an agent re-registering the
+    // same standing schedule refreshes it instead of minting a twin. A one-off must
+    // NOT: createOrReplace carries the existing schedule's `runs` forward, and
+    // shouldCompleteSchedule counts them against the incoming maxRuns before tick
+    // looks at nextRunAt, so replacing a schedule that has already run with
+    // maxRuns 1 completes it on the next tick without ever firing. There is also
+    // nothing to make idempotent about a one-off: two calls mean two reminders.
+    // Covered by schedule/service.test.ts "replacing a schedule that has run with
+    // maxRuns 1 buries it without firing".
+    const persistNewSchedule = async (input, oneOff) => {
+        if (!scheduleService) {
+            throw new Error("Schedule service is not configured");
+        }
+        return oneOff ? scheduleService.create(input) : scheduleService.createOrReplace(input);
+    };
     const ProviderModelInputSchema = AgentProviderEnum.trim()
         .refine((value) => value.includes("/"), {
         message: "provider must be provider/model, for example codex/gpt-5.4",
@@ -1609,39 +1695,80 @@ export function createPaseoToolCatalog(options) {
     });
     registerTool("create_schedule", {
         title: "Create schedule",
-        description: "Create a recurring schedule that starts a new agent on a cron cadence.",
+        description: "Schedule a prompt for later: once at a specific time (at), on a repeating interval (every), or on a cron cadence (cron). The prompt can start a fresh agent, come back to you (target self), or go to another agent by id. Prefer this over an in-session loop whenever the work must survive this session ending, since schedules are owned by the daemon.",
         inputSchema: {
             prompt: z.string().trim().min(1, "prompt is required"),
-            cron: z.string().trim().min(1, "cron is required"),
+            at: z
+                .string()
+                .trim()
+                .min(1)
+                .optional()
+                .describe('One-off delivery time. An ISO 8601 instant ("2026-08-21T21:30:00-03:00") or a duration from now ("90m", "2h30m"). Runs exactly once. Mutually exclusive with every and cron.'),
+            every: z
+                .string()
+                .trim()
+                .min(1)
+                .optional()
+                .describe('Repeating interval, for example "5m", "1h", "2h30m", "1d". Mutually exclusive with at and cron.'),
+            cron: z
+                .string()
+                .trim()
+                .min(1)
+                .optional()
+                .describe('Repeating cron expression, for example "0 9 * * 1-5". Mutually exclusive with at and every.'),
             timezone: z
                 .string()
                 .trim()
                 .min(1)
                 .optional()
-                .describe("IANA time zone for the cron cadence. For example: America/New_York."),
-            name: z.string().optional(),
-            provider: AgentProviderEnum.optional().describe("Provider, or provider/model (for example: codex or codex/gpt-5.4)."),
-            cwd: z.string().optional(),
+                .describe("IANA time zone for the cron cadence. Requires cron. For example: America/New_York."),
+            name: z
+                .string()
+                .optional()
+                .describe("Reusing a name with the same target refreshes that schedule in place instead of creating a second one."),
+            target: z
+                .string()
+                .trim()
+                .min(1)
+                .optional()
+                .describe('Who receives the prompt: "new-agent" (default) starts a fresh agent each run, "self" delivers to you, or an agent id delivers to that agent.'),
+            provider: AgentProviderEnum.optional().describe("Provider, or provider/model (for example: codex or codex/gpt-5.4). Only valid with target new-agent."),
+            cwd: z.string().optional().describe("Working directory. Only valid with target new-agent."),
             maxRuns: z.number().int().positive().optional(),
             expiresIn: z.string().optional(),
+            runNow: z
+                .boolean()
+                .optional()
+                .describe("Also fire once immediately on create. Defaults to true for every, false for cron. Not allowed with at."),
         },
         outputSchema: ScheduleSummarySchema.shape,
-    }, async ({ prompt, cron, timezone, name, provider, cwd, maxRuns, expiresIn }) => {
+    }, async ({ prompt, at, every, cron, timezone, name, target, provider, cwd, maxRuns, expiresIn, runNow, }) => {
         if (!scheduleService) {
             throw new Error("Schedule service is not configured");
         }
+        const { cadence, oneOff } = resolveScheduleCreateCadence({ at, every, cron, timezone }, new Date());
+        if (oneOff && maxRuns !== undefined && maxRuns !== 1) {
+            throw new Error("maxRuns cannot be combined with at: an at schedule runs exactly once");
+        }
+        if (oneOff && runNow === true) {
+            throw new Error("runNow cannot be combined with at: an at schedule runs only at its time");
+        }
+        const resolvedTarget = await resolveScheduleCreateTarget({ target, provider, cwd });
         const expiresAt = buildScheduleExpiry(expiresIn);
-        const schedule = await scheduleService.createOrReplace({
+        const scheduleInput = {
             prompt: prompt.trim(),
-            cadence: buildCronScheduleCadence({
-                cron,
-                ...(timezone !== undefined ? { timezone } : {}),
-            }),
-            target: resolveNewAgentScheduleTarget({ provider, cwd }),
+            cadence,
+            target: resolvedTarget,
             ...(name?.trim() ? { name: name.trim() } : {}),
-            ...(maxRuns === undefined ? {} : { maxRuns }),
+            ...(oneOff
+                ? { maxRuns: 1, runOnCreate: false }
+                : {
+                    ...(maxRuns === undefined ? {} : { maxRuns }),
+                    ...(runNow === undefined ? {} : { runOnCreate: runNow }),
+                }),
             ...(expiresAt === undefined ? {} : { expiresAt }),
-        });
+        };
+        const schedule = await persistNewSchedule(scheduleInput, oneOff);
         return {
             content: [],
             structuredContent: ensureValidJson(toScheduleSummary(schedule)),
@@ -1649,22 +1776,43 @@ export function createPaseoToolCatalog(options) {
     });
     registerTool("create_heartbeat", {
         title: "Create heartbeat",
-        description: "Create a recurring heartbeat that sends you a prompt on a cron cadence.",
+        description: "Schedule a prompt back to yourself: once at a specific time (at), on a repeating interval (every), or on a cron cadence (cron). Equivalent to create_schedule with target self.",
         inputSchema: {
             prompt: z.string().trim().min(1, "prompt is required"),
-            cron: z.string().trim().min(1, "cron is required"),
+            at: z
+                .string()
+                .trim()
+                .min(1)
+                .optional()
+                .describe('One-off delivery time. An ISO 8601 instant ("2026-08-21T21:30:00-03:00") or a duration from now ("90m"). Runs exactly once. Mutually exclusive with every and cron.'),
+            every: z
+                .string()
+                .trim()
+                .min(1)
+                .optional()
+                .describe('Repeating interval, for example "5m", "1h", "2h30m". Mutually exclusive with at and cron.'),
+            cron: z
+                .string()
+                .trim()
+                .min(1)
+                .optional()
+                .describe('Repeating cron expression, for example "0 9 * * 1-5". Mutually exclusive with at and every.'),
             timezone: z
                 .string()
                 .trim()
                 .min(1)
                 .optional()
-                .describe("IANA time zone for the cron cadence. For example: America/New_York."),
+                .describe("IANA time zone for the cron cadence. Requires cron. For example: America/New_York."),
             name: z.string().optional(),
             maxRuns: z.number().int().positive().optional(),
             expiresIn: z.string().optional(),
+            runNow: z
+                .boolean()
+                .optional()
+                .describe("Also fire once immediately on create. Defaults to true for every, false for cron. Not allowed with at."),
         },
         outputSchema: ScheduleSummarySchema.shape,
-    }, async ({ prompt, cron, timezone, name, maxRuns, expiresIn }) => {
+    }, async ({ prompt, at, every, cron, timezone, name, maxRuns, expiresIn, runNow }) => {
         if (!scheduleService) {
             throw new Error("Schedule service is not configured");
         }
@@ -1672,23 +1820,50 @@ export function createPaseoToolCatalog(options) {
             throw new Error("create_heartbeat requires an agent-scoped session");
         }
         resolveCallerAgent();
+        const { cadence, oneOff } = resolveScheduleCreateCadence({ at, every, cron, timezone }, new Date());
+        if (oneOff && maxRuns !== undefined && maxRuns !== 1) {
+            throw new Error("maxRuns cannot be combined with at: an at schedule runs exactly once");
+        }
+        if (oneOff && runNow === true) {
+            throw new Error("runNow cannot be combined with at: an at schedule runs only at its time");
+        }
         const expiresAt = buildScheduleExpiry(expiresIn);
-        const schedule = await scheduleService.createOrReplace({
+        const scheduleInput = {
             prompt: prompt.trim(),
-            cadence: buildCronScheduleCadence({
-                cron,
-                ...(timezone !== undefined ? { timezone } : {}),
-            }),
+            cadence,
             target: { type: "agent", agentId: callerAgentId },
             ...(name?.trim() ? { name: name.trim() } : {}),
-            ...(maxRuns === undefined ? {} : { maxRuns }),
+            ...(oneOff
+                ? { maxRuns: 1, runOnCreate: false }
+                : {
+                    ...(maxRuns === undefined ? {} : { maxRuns }),
+                    ...(runNow === undefined ? {} : { runOnCreate: runNow }),
+                }),
             ...(expiresAt === undefined ? {} : { expiresAt }),
-        });
+        };
+        const schedule = await persistNewSchedule(scheduleInput, oneOff);
         return {
             content: [],
             structuredContent: ensureValidJson(toScheduleSummary(schedule)),
         };
     });
+    registerTool("run_schedule_once", {
+        title: "Run schedule once",
+        description: "Fire a schedule immediately, out of band. The cadence and the next scheduled run are left untouched, but the run is recorded and counts toward maxRuns.",
+        inputSchema: {
+            id: z.string(),
+        },
+        outputSchema: StoredScheduleSchema.shape,
+    }, async ({ id }) => {
+        if (!scheduleService) {
+            throw new Error("Schedule service is not configured");
+        }
+        const schedule = await scheduleService.runOnce(id);
+        return {
+            content: [],
+            structuredContent: ensureValidJson(schedule),
+        };
+    });
     registerTool("list_schedules", {
         title: "List schedules",
         description: "List all schedules managed by the daemon.",

package/dist/server/server/agent/tools/read-only-surface.d.ts

@@ -42,6 +42,7 @@
  * - `create_terminal`, `kill_terminal`, `send_terminal_keys`       arbitrary command execution.
  * - `create_schedule`, `update_schedule`, `delete_schedule`,
  *   `pause_schedule`, `resume_schedule`, `create_heartbeat`        persistent side effects.
+ * - `run_schedule_once`      fires a schedule now, which starts or prompts an agent.
  * - `rename_workspace`       mutates.
  * - `speak`                  an outward side effect, and voice is out of v1 scope.
  * - `wait_for_agent`         not mutating, but it BLOCKS. An event-woken judge

package/dist/server/server/agent/tools/read-only-surface.js

@@ -42,6 +42,7 @@
  * - `create_terminal`, `kill_terminal`, `send_terminal_keys`       arbitrary command execution.
  * - `create_schedule`, `update_schedule`, `delete_schedule`,
  *   `pause_schedule`, `resume_schedule`, `create_heartbeat`        persistent side effects.
+ * - `run_schedule_once`      fires a schedule now, which starts or prompts an agent.
  * - `rename_workspace`       mutates.
  * - `speak`                  an outward side effect, and voice is out of v1 scope.
  * - `wait_for_agent`         not mutating, but it BLOCKS. An event-woken judge

package/dist/server/server/persistence-hooks.js

@@ -41,6 +41,7 @@ export function buildConfigOverrides(record) {
         extra: record.config?.extra ?? undefined,
         systemPrompt: record.config?.systemPrompt ?? undefined,
         mcpServers: record.config?.mcpServers ?? undefined,
+        allowedTools: record.config?.allowedTools ?? undefined,
     });
 }
 export function buildSessionConfig(record, options) {
@@ -58,6 +59,7 @@ export function buildSessionConfig(record, options) {
         extra: overrides.extra,
         systemPrompt: overrides.systemPrompt,
         mcpServers: overrides.mcpServers,
+        allowedTools: overrides.allowedTools,
     });
 }
 export function isStoredAgentProviderAvailable(record, validProviders) {

package/dist/server/server/workspace-directory.js

@@ -44,6 +44,28 @@ export function workspaceIdsOnCheckout(workspaces, cwd) {
         .filter((workspace) => !workspace.archivedAt && resolve(workspace.cwd) === resolvedCwd)
         .map((workspace) => workspace.workspaceId);
 }
+/**
+ * Build the bucket-derivation input for one agent snapshot.
+ *
+ * Exists so every call site in this file feeds `deriveAgentStateBucket` the
+ * SAME shape. It previously did not: two call sites hand-built the object and
+ * both omitted `activeChildCount`, so server-derived workspace buckets could
+ * never see armed background work while the app-side derivation could. The same
+ * agent then bucketed as "done" in the workspace list and "running" on its
+ * kanban card. One helper, one shape, no drift.
+ */
+function toBucketInput(agent) {
+    return {
+        status: agent.status,
+        pendingPermissionCount: agent.pendingPermissions?.length ?? 0,
+        requiresAttention: agent.requiresAttention,
+        attentionReason: agent.attentionReason ?? null,
+        // Monitors, crons and backgrounded shells still alive on this agent. Live
+        // SUBAGENTS are not counted here — they arrive as their own snapshots and
+        // are attributed to the delegation root in applyAgentBucketContributions.
+        activeChildCount: agent.activeBackgroundTaskCount ?? 0,
+    };
+}
 export class WorkspaceDirectory {
     constructor(deps) {
         this.deps = deps;
@@ -166,15 +188,13 @@ export class WorkspaceDirectory {
                     continue;
                 }
                 workspaceAgent = parentAgent;
-                bucket = "running";
+                // A live subagent means the ROOT's own turn is not in flight — it is
+                // waiting on delegated work that will hand control back by itself.
+                // That is "pending", not "running"; see agent-state-bucket.ts.
+                bucket = "pending";
             }
             else {
-                bucket = deriveAgentStateBucket({
-                    status: agent.status,
-                    pendingPermissionCount: agent.pendingPermissions?.length ?? 0,
-                    requiresAttention: agent.requiresAttention,
-                    attentionReason: agent.attentionReason ?? null,
-                });
+                bucket = deriveAgentStateBucket(toBucketInput(agent));
             }
             const workspaceId = workspaceAgent.workspaceId;
             if (!workspaceId) {
@@ -210,7 +230,10 @@ export class WorkspaceDirectory {
                 existing.status = bucket;
             }
             const entries = terminalEntriesByWorkspaceId.get(workspaceId) ?? [];
-            entries.push({ bucket, changedAtIso: new Date(activity.changedAt).toISOString() });
+            entries.push({
+                bucket,
+                changedAtIso: new Date(activity.changedAt).toISOString(),
+            });
             terminalEntriesByWorkspaceId.set(workspaceId, entries);
         }
         return terminalEntriesByWorkspaceId;
@@ -271,12 +294,7 @@ export class WorkspaceDirectory {
     findNewestTimestampInBucket(contributingAgents, terminalEntries, winningBucket) {
         const agentTimestamps = contributingAgents
             .filter((agent) => {
-            const derived = deriveAgentStateBucket({
-                status: agent.status,
-                pendingPermissionCount: agent.pendingPermissions?.length ?? 0,
-                requiresAttention: agent.requiresAttention,
-                attentionReason: agent.attentionReason ?? null,
-            });
+            const derived = deriveAgentStateBucket(toBucketInput(agent));
             return derived === winningBucket;
         })
             .map((agent) => {