@hyperdrive.bot/fleet-server 0.3.99

package/dist/server/server/schedule/service.js

@@ -0,0 +1,867 @@
+import { randomUUID } from "node:crypto";
+import { stat } from "node:fs/promises";
+import { join } from "node:path";
+import { curateAgentActivity } from "../agent/activity-curator.js";
+import { ensureAgentLoaded } from "../agent/agent-loading.js";
+import { formatSystemNotificationPrompt } from "../agent/agent-prompt.js";
+import { resolveCreateAgentTitles } from "../agent/create-agent-title.js";
+import { ScheduleStore } from "./store.js";
+import { computeNextRunAt, validateScheduleCadence } from "./cron.js";
+import { buildSourceRunPrompt } from "./source-prompt.js";
+import { FILTER_ID_LABEL, ITEM_GROUP_LABEL, ITEM_KEYS_LABEL, } from "@hyperdrive.bot/fleet-protocol/agent-labels";
+import { groupMatchedItems } from "../ingestion/grouping.js";
+const SCHEDULE_TICK_INTERVAL_MS = 1000;
+// A run failed because its target no longer exists: the agent was deleted or
+// archived, or a new-agent cwd was removed. These are permanent, so the schedule
+// is completed instead of retried until it burns down to its expiry.
+export class ScheduleTargetGoneError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ScheduleTargetGoneError";
+    }
+}
+// Arming a source filter must never replay the history that already sits behind
+// the source. An explicit runOnCreate: true is therefore refused rather than
+// quietly downgraded, so the caller is pointed at backfill instead.
+export class ScheduleRunOnCreateUnsupportedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ScheduleRunOnCreateUnsupportedError";
+    }
+}
+const RUN_ON_CREATE_UNSUPPORTED_MESSAGE = "Source cadences cannot run on create; arm the filter and use backfill to process history.";
+function assertRunOnCreateSupported(input) {
+    if (input.cadence.type === "source" && input.runOnCreate === true) {
+        throw new ScheduleRunOnCreateUnsupportedError(RUN_ON_CREATE_UNSUPPORTED_MESSAGE);
+    }
+}
+function trimOptionalName(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function buildScheduleFireBody(schedule, runId) {
+    const heading = schedule.name
+        ? `Schedule "${schedule.name}" fired (id=${schedule.id}, run=${runId}).`
+        : `Schedule fired (id=${schedule.id}, run=${runId}).`;
+    return `${heading}\n${schedule.prompt}`;
+}
+function normalizePrompt(prompt) {
+    const trimmed = prompt.trim();
+    if (!trimmed) {
+        throw new Error("Schedule prompt is required");
+    }
+    return trimmed;
+}
+function applyNewAgentConfig(target, patch) {
+    const config = { ...target.config };
+    if (patch.provider !== undefined) {
+        const trimmed = patch.provider.trim();
+        if (!trimmed) {
+            throw new Error("provider cannot be empty");
+        }
+        config.provider = trimmed;
+    }
+    if (patch.cwd !== undefined) {
+        const trimmed = patch.cwd.trim();
+        if (!trimmed) {
+            throw new Error("cwd cannot be empty");
+        }
+        config.cwd = trimmed;
+    }
+    if (patch.model !== undefined) {
+        const trimmed = patch.model?.trim();
+        if (trimmed) {
+            config.model = trimmed;
+        }
+        else {
+            delete config.model;
+        }
+    }
+    if (patch.modeId !== undefined) {
+        const trimmed = patch.modeId?.trim();
+        if (trimmed) {
+            config.modeId = trimmed;
+        }
+        else {
+            delete config.modeId;
+        }
+    }
+    return { ...target, config };
+}
+function normalizeMaxRuns(value) {
+    if (value == null) {
+        return null;
+    }
+    if (!Number.isInteger(value) || value <= 0) {
+        throw new Error("maxRuns must be a positive integer");
+    }
+    return value;
+}
+function countCompletedRuns(schedule) {
+    return schedule.runs.filter((run) => run.status !== "running").length;
+}
+function shouldCompleteSchedule(schedule, now) {
+    if (schedule.expiresAt && new Date(schedule.expiresAt).getTime() <= now.getTime()) {
+        return true;
+    }
+    if (schedule.maxRuns == null) {
+        return false;
+    }
+    return countCompletedRuns(schedule) >= schedule.maxRuns;
+}
+// Sort object keys recursively so two structurally-equal configs serialize
+// identically regardless of key order. Stored configs come back from disk in Zod
+// schema order while incoming configs keep their construction order, so a plain
+// JSON.stringify comparison would wrongly treat identical targets as different.
+function canonicalize(value) {
+    if (Array.isArray(value)) {
+        return value.map(canonicalize);
+    }
+    if (value && typeof value === "object") {
+        const source = value;
+        return Object.fromEntries(Object.keys(source)
+            .sort()
+            .map((key) => [key, canonicalize(source[key])]));
+    }
+    return value;
+}
+function scheduleTargetsEqual(a, b) {
+    if (a.type === "agent" && b.type === "agent") {
+        return a.agentId === b.agentId;
+    }
+    if (a.type === "new-agent" && b.type === "new-agent") {
+        return JSON.stringify(canonicalize(a.config)) === JSON.stringify(canonicalize(b.config));
+    }
+    return false;
+}
+function completeSchedule(schedule, now) {
+    return {
+        ...schedule,
+        status: "completed",
+        nextRunAt: null,
+        pausedAt: null,
+        updatedAt: now.toISOString(),
+    };
+}
+function buildRunOutput(params) {
+    if (params.output && params.output.trim().length > 0) {
+        return params.output;
+    }
+    if (params.finalText.trim().length > 0) {
+        return params.finalText.trim();
+    }
+    if (params.timelineText.trim().length > 0) {
+        return params.timelineText.trim();
+    }
+    return null;
+}
+/**
+ * Both schedule facts per TARGETED agent id, in ONE pass over the store listing.
+ *
+ * Only `target.type === "agent"` counts, for both facts. A `new-agent` schedule
+ * mints a throwaway agent per firing and archives it, so it targets no durable
+ * agent and must neither make one look scheduled nor make one look durable.
+ *
+ * `nextFireAtByAgent` takes ACTIVE schedules only: the value is "when does this
+ * next fire", and a paused schedule never does. `routineAgentIds` takes active
+ * AND paused: a paused routine is benched, not absent. `completed` is in neither,
+ * because a one-shot that already fired is finished rather than benched.
+ */
+function indexAgentScheduleFacts(schedules) {
+    const nextFireAtByAgent = new Map();
+    const routineAgentIds = new Set();
+    for (const schedule of schedules) {
+        if (schedule.target.type !== "agent")
+            continue;
+        if (schedule.status !== "active" && schedule.status !== "paused")
+            continue;
+        routineAgentIds.add(schedule.target.agentId);
+        if (schedule.status !== "active")
+            continue;
+        const nextRunAt = schedule.nextRunAt;
+        if (!nextRunAt)
+            continue;
+        const parsed = Date.parse(nextRunAt);
+        if (Number.isNaN(parsed))
+            continue;
+        const current = nextFireAtByAgent.get(schedule.target.agentId);
+        if (current === undefined || parsed < Date.parse(current)) {
+            nextFireAtByAgent.set(schedule.target.agentId, nextRunAt);
+        }
+    }
+    return { nextFireAtByAgent, routineAgentIds };
+}
+export class ScheduleService {
+    constructor(options) {
+        this.runningScheduleIds = new Set();
+        this.tickTimer = null;
+        /**
+         * Last computed schedule facts per agent, refreshed on every tick (1s) and on
+         * demand. `null` until the first read, which is what lets `peekNextFireAt` and
+         * `peekHasRoutine` tell "no schedule targets this agent" apart from "nobody has
+         * looked yet" - the agent predicate treats those the same, but only one of them
+         * is a claim about the agent.
+         *
+         * ONE cache for BOTH facts on purpose: they are built in a single pass, so
+         * neither can be fresh while the other is stale.
+         */
+        this.agentScheduleFacts = null;
+        this.store = new ScheduleStore(join(options.paseoHome, "schedules"));
+        this.logger = options.logger.child({ module: "schedule-service" });
+        this.agentManager = options.agentManager;
+        this.agentStorage = options.agentStorage;
+        this.createConfigResolver = options.providerSnapshotManager;
+        this.now = options.now ?? (() => new Date());
+        this.ledger = options.ledger;
+        this.capLimiter = options.capLimiter;
+        this.cohortResumer = options.cohortResumer;
+        this.runner = options.runner ?? ((schedule, runId) => this.executeSchedule(schedule, runId));
+        this.filterResolver =
+            options.filterResolver ??
+                (() => {
+                    throw new Error("Source cadence requires a filterResolver");
+                });
+        this.matchedItems = options.matchedItems ?? (async () => []);
+    }
+    /**
+     * The daemon's one runs/day limiter, or undefined when the ledger is.
+     *
+     * The accessor exists so Epic 2's dispatch loop and Epic 5's confirmation
+     * screen reach the SAME instance through plumbing that already exists, instead
+     * of constructing their own.
+     */
+    getCapLimiter() {
+        return this.capLimiter;
+    }
+    async start() {
+        await this.recoverInterruptedRuns();
+        // Ingestion ledger maintenance. Order matters: release first, so a claim stranded by a
+        // crash records its failure and refreshes last_fail_at, then prune, so a row released
+        // one line earlier is never dropped by the same boot. Best-effort on purpose: a ledger
+        // that cannot open must not stop clock schedules from ticking. Fail-loud for ingestion
+        // happens where a { type: "source" } cadence arms, not here (epic D1).
+        if (this.ledger) {
+            try {
+                const released = this.ledger.releaseStaleClaims();
+                const pruned = this.ledger.prune();
+                if (released > 0 || pruned > 0) {
+                    this.logger.info({ released, pruned }, "Ingestion ledger maintenance complete");
+                }
+            }
+            catch (error) {
+                this.logger.warn({ err: error }, "Ingestion ledger maintenance failed; source-triggered filters will not arm");
+            }
+        }
+        // AFTER the ledger maintenance above, never before. A resumed group claims
+        // ledger rows, and a claim stranded by the crash is only released one block
+        // up - resuming first would find every item still claimed and dispatch a
+        // cohort that covers nothing.
+        //
+        // Best-effort for the same reason the maintenance above is: a cohort that
+        // cannot be resumed must not stop clock schedules from ticking.
+        if (this.cohortResumer) {
+            try {
+                await this.cohortResumer();
+            }
+            catch (error) {
+                this.logger.warn({ err: error }, "Cohort resume failed; pending cohort groups stay pending until the next boot");
+            }
+        }
+        await this.sweepOrphanedSchedules();
+        if (this.tickTimer) {
+            return;
+        }
+        const timer = setInterval(() => {
+            void this.tick().catch((error) => {
+                this.logger.error({ err: error }, "Failed to process schedule tick");
+            });
+        }, SCHEDULE_TICK_INTERVAL_MS);
+        timer.unref?.();
+        this.tickTimer = timer;
+    }
+    async stop() {
+        if (this.tickTimer) {
+            clearInterval(this.tickTimer);
+            this.tickTimer = null;
+        }
+    }
+    async create(input) {
+        const now = this.now();
+        const prompt = normalizePrompt(input.prompt);
+        validateScheduleCadence(input.cadence);
+        assertRunOnCreateSupported(input);
+        const runOnCreate = input.runOnCreate ?? input.cadence.type === "every";
+        const nextRunAt = runOnCreate ? now : computeNextRunAt(input.cadence, now);
+        const schedule = await this.store.create({
+            name: trimOptionalName(input.name),
+            prompt,
+            cadence: input.cadence,
+            target: input.target,
+            status: "active",
+            createdAt: now.toISOString(),
+            updatedAt: now.toISOString(),
+            nextRunAt: nextRunAt?.toISOString() ?? null,
+            lastRunAt: null,
+            pausedAt: null,
+            expiresAt: input.expiresAt ?? null,
+            maxRuns: normalizeMaxRuns(input.maxRuns),
+            runs: [],
+        });
+        return schedule;
+    }
+    // Idempotent create for the MCP write path: repeating a create with the same
+    // name and target (e.g. babysit-pr re-registering its heartbeat) refreshes the
+    // existing non-completed schedule in place instead of minting a duplicate.
+    async createOrReplace(input) {
+        const name = trimOptionalName(input.name);
+        if (name !== null) {
+            const existing = (await this.store.list()).find((schedule) => schedule.status !== "completed" &&
+                trimOptionalName(schedule.name) === name &&
+                scheduleTargetsEqual(schedule.target, input.target));
+            if (existing) {
+                const now = this.now();
+                const prompt = normalizePrompt(input.prompt);
+                validateScheduleCadence(input.cadence);
+                assertRunOnCreateSupported(input);
+                const runOnCreate = input.runOnCreate ?? input.cadence.type === "every";
+                const nextRunAt = runOnCreate ? now : computeNextRunAt(input.cadence, now);
+                const replaced = {
+                    ...existing,
+                    name,
+                    prompt,
+                    cadence: input.cadence,
+                    target: input.target,
+                    status: "active",
+                    pausedAt: null,
+                    nextRunAt: nextRunAt?.toISOString() ?? null,
+                    expiresAt: input.expiresAt ?? null,
+                    maxRuns: normalizeMaxRuns(input.maxRuns),
+                    updatedAt: now.toISOString(),
+                };
+                await this.store.put(replaced);
+                return replaced;
+            }
+        }
+        return this.create(input);
+    }
+    async list() {
+        return this.store.list();
+    }
+    /**
+     * Read the schedule store and return BOTH schedule facts per targeted agent id,
+     * refreshing the cache `peekNextFireAt` and `peekHasRoutine` serve.
+     *
+     * This is the seam the agent projections use for `nextFireAt` and `hasRoutine`.
+     * Those projections are pure and synchronous while this store is async and
+     * file-backed, so the caller that already awaits does the join ONCE per batch
+     * and passes each agent its own answer down. Both facts come off the same
+     * listing, so a caller can never get one refreshed and the other stale.
+     */
+    async listAgentScheduleFacts() {
+        const facts = indexAgentScheduleFacts(await this.store.list());
+        this.agentScheduleFacts = facts;
+        return facts;
+    }
+    /**
+     * Synchronous read of the cached next-fire index, for the projection paths that
+     * are not async and cannot await a store read.
+     *
+     * Returns `undefined` when the index has never been built (no tick yet, no
+     * explicit refresh), which the wire schema defines as "not computed". Returns
+     * `null` only when the index HAS been built and holds no active schedule for
+     * this agent. Staleness is bounded by the tick interval once `start()` has run.
+     */
+    peekNextFireAt(agentId) {
+        if (this.agentScheduleFacts === null) {
+            return undefined;
+        }
+        return this.agentScheduleFacts.nextFireAtByAgent.get(agentId) ?? null;
+    }
+    /**
+     * Synchronous read of the cached routine set: does any active OR paused
+     * schedule target this agent.
+     *
+     * Same `undefined` = "never computed" contract as `peekNextFireAt`, and served
+     * off the same cache entry so the two answers always describe the same listing.
+     */
+    peekHasRoutine(agentId) {
+        if (this.agentScheduleFacts === null) {
+            return undefined;
+        }
+        return this.agentScheduleFacts.routineAgentIds.has(agentId);
+    }
+    async inspect(id) {
+        const schedule = await this.store.get(id);
+        if (!schedule) {
+            throw new Error(`Schedule not found: ${id}`);
+        }
+        return schedule;
+    }
+    async logs(id) {
+        const schedule = await this.inspect(id);
+        return [...schedule.runs].sort((left, right) => left.startedAt.localeCompare(right.startedAt));
+    }
+    async pause(id) {
+        const schedule = await this.inspect(id);
+        if (schedule.status === "completed") {
+            throw new Error(`Schedule ${id} is already completed`);
+        }
+        if (schedule.status === "paused") {
+            return schedule;
+        }
+        const now = this.now();
+        const paused = {
+            ...schedule,
+            status: "paused",
+            nextRunAt: null,
+            pausedAt: now.toISOString(),
+            updatedAt: now.toISOString(),
+        };
+        await this.store.put(paused);
+        return paused;
+    }
+    async resume(id) {
+        const schedule = await this.inspect(id);
+        if (schedule.status === "completed") {
+            throw new Error(`Schedule ${id} is already completed`);
+        }
+        if (schedule.status === "active") {
+            return schedule;
+        }
+        const now = this.now();
+        const resumed = {
+            ...schedule,
+            status: "active",
+            pausedAt: null,
+            nextRunAt: computeNextRunAt(schedule.cadence, now)?.toISOString() ?? null,
+            updatedAt: now.toISOString(),
+        };
+        await this.store.put(resumed);
+        return resumed;
+    }
+    async update(input) {
+        const schedule = await this.inspect(input.id);
+        const now = this.now();
+        let updated = schedule;
+        if (input.prompt !== undefined) {
+            updated = { ...updated, prompt: normalizePrompt(input.prompt) };
+        }
+        if (input.name !== undefined) {
+            updated = { ...updated, name: trimOptionalName(input.name) };
+        }
+        if (input.cadence !== undefined) {
+            validateScheduleCadence(input.cadence);
+            const nextRunAt = updated.status === "active"
+                ? (computeNextRunAt(input.cadence, now)?.toISOString() ?? null)
+                : null;
+            updated = { ...updated, cadence: input.cadence, nextRunAt };
+        }
+        if (input.newAgentConfig !== undefined) {
+            if (updated.target.type !== "new-agent") {
+                throw new Error("new-agent config updates are only valid for new-agent target schedules");
+            }
+            updated = { ...updated, target: applyNewAgentConfig(updated.target, input.newAgentConfig) };
+        }
+        if (input.maxRuns !== undefined) {
+            updated = { ...updated, maxRuns: normalizeMaxRuns(input.maxRuns) };
+        }
+        if (input.expiresAt !== undefined) {
+            updated = { ...updated, expiresAt: input.expiresAt };
+        }
+        updated = { ...updated, updatedAt: now.toISOString() };
+        await this.store.put(updated);
+        return updated;
+    }
+    async delete(id) {
+        await this.store.delete(id);
+    }
+    async completeForAgent(agentId) {
+        const now = this.now();
+        const schedules = await this.store.list();
+        const matches = schedules.filter((schedule) => schedule.target.type === "agent" &&
+            schedule.target.agentId === agentId &&
+            schedule.status !== "completed");
+        const results = await Promise.allSettled(matches.map((schedule) => this.store.put(completeSchedule(schedule, now))));
+        let completed = 0;
+        for (const [index, result] of results.entries()) {
+            if (result.status === "fulfilled") {
+                completed += 1;
+            }
+            else {
+                this.logger.warn({ err: result.reason, scheduleId: matches[index].id, agentId }, "Failed to complete schedule for archived agent; continuing");
+            }
+        }
+        return completed;
+    }
+    async runOnce(id) {
+        const schedule = await this.inspect(id);
+        if (schedule.status === "completed") {
+            throw new Error(`Schedule ${id} is already completed`);
+        }
+        if (this.runningScheduleIds.has(id)) {
+            throw new Error(`Schedule ${id} is already running`);
+        }
+        await this.runSchedule(schedule, this.now(), { manual: true });
+        return this.inspect(id);
+    }
+    async tick() {
+        const now = this.now();
+        const schedules = await this.store.list();
+        // The tick already paid for the store read, so keep the projection cache warm
+        // off the same list rather than re-reading disk on every agent-list build.
+        this.agentScheduleFacts = indexAgentScheduleFacts(schedules);
+        for (const schedule of schedules) {
+            if (schedule.status !== "active" || !schedule.nextRunAt) {
+                continue;
+            }
+            if (this.runningScheduleIds.has(schedule.id)) {
+                continue;
+            }
+            if (shouldCompleteSchedule(schedule, now)) {
+                await this.store.put(completeSchedule(schedule, now));
+                continue;
+            }
+            if (new Date(schedule.nextRunAt).getTime() > now.getTime()) {
+                continue;
+            }
+            await this.runSchedule(schedule, now);
+        }
+    }
+    async recoverInterruptedRuns() {
+        const schedules = await this.store.list();
+        const now = this.now();
+        await Promise.all(schedules.map(async (schedule) => {
+            let updated = { ...schedule };
+            let dirty = false;
+            // Mark any in-flight runs as failed
+            const runningIndex = updated.runs.findIndex((run) => run.status === "running");
+            if (runningIndex !== -1) {
+                const runs = [...updated.runs];
+                runs[runningIndex] = {
+                    ...runs[runningIndex],
+                    status: "failed",
+                    endedAt: now.toISOString(),
+                    error: "Daemon restarted before the scheduled run completed",
+                };
+                updated = { ...updated, runs };
+                dirty = true;
+            }
+            // Advance stale nextRunAt for active schedules
+            if (updated.status === "active" &&
+                updated.nextRunAt &&
+                new Date(updated.nextRunAt).getTime() <= now.getTime()) {
+                let nextRunAt = computeNextRunAt(updated.cadence, new Date(updated.nextRunAt));
+                while (nextRunAt !== null && nextRunAt.getTime() <= now.getTime()) {
+                    nextRunAt = computeNextRunAt(updated.cadence, nextRunAt);
+                }
+                updated = { ...updated, nextRunAt: nextRunAt?.toISOString() ?? null };
+                dirty = true;
+            }
+            if (dirty) {
+                updated = { ...updated, updatedAt: now.toISOString() };
+                await this.store.put(updated);
+            }
+        }));
+    }
+    // Orphaned agent-target schedules (agent deleted while the daemon was down, or
+    // archived before completeForAgent existed) can never fire successfully. Complete
+    // them on startup so they stop ticking and surface as ended in the UI.
+    async sweepOrphanedSchedules() {
+        const now = this.now();
+        const schedules = await this.store.list();
+        await Promise.all(schedules.map(async (schedule) => {
+            if (schedule.target.type !== "agent" || schedule.status === "completed") {
+                return;
+            }
+            const record = await this.agentStorage.get(schedule.target.agentId);
+            if (record && !record.archivedAt) {
+                return;
+            }
+            await this.store.put(completeSchedule(schedule, now));
+        }));
+    }
+    async runSchedule(schedule, now, options) {
+        const manual = options?.manual === true;
+        this.runningScheduleIds.add(schedule.id);
+        const runId = randomUUID();
+        const runningRun = {
+            id: runId,
+            scheduledFor: manual ? now.toISOString() : (schedule.nextRunAt ?? now.toISOString()),
+            startedAt: now.toISOString(),
+            endedAt: null,
+            status: "running",
+            agentId: null,
+            output: null,
+            error: null,
+        };
+        const scheduleWithRun = {
+            ...schedule,
+            updatedAt: now.toISOString(),
+            runs: [...schedule.runs, runningRun],
+        };
+        await this.store.put(scheduleWithRun);
+        try {
+            const result = await this.runner(scheduleWithRun, runId);
+            await this.finishRun({
+                scheduleId: schedule.id,
+                runId,
+                status: "succeeded",
+                agentId: result.agentId,
+                output: result.output,
+                error: null,
+                targetGone: false,
+                manual,
+            });
+        }
+        catch (error) {
+            await this.finishRun({
+                scheduleId: schedule.id,
+                runId,
+                status: "failed",
+                agentId: null,
+                output: null,
+                error: error instanceof Error ? error.message : String(error),
+                targetGone: error instanceof ScheduleTargetGoneError,
+                manual,
+            });
+        }
+        finally {
+            this.runningScheduleIds.delete(schedule.id);
+        }
+    }
+    async finishRun(params) {
+        const schedule = await this.inspect(params.scheduleId);
+        const now = this.now();
+        const completedRuns = schedule.runs.map((run) => run.id === params.runId
+            ? {
+                ...run,
+                status: params.status,
+                endedAt: now.toISOString(),
+                agentId: params.agentId,
+                output: params.output,
+                error: params.error,
+            }
+            : run);
+        let updated = {
+            ...schedule,
+            runs: completedRuns,
+            lastRunAt: now.toISOString(),
+            updatedAt: now.toISOString(),
+        };
+        if (params.targetGone) {
+            // The target is permanently gone; retrying only burns the schedule down to
+            // its expiry, so complete it now regardless of manual/scheduled origin.
+            updated = completeSchedule(updated, now);
+        }
+        else if (updated.status === "completed") {
+            // Completed concurrently (e.g. the target agent was archived mid-run);
+            // record the run outcome but leave the schedule terminal — don't advance.
+        }
+        else if (params.manual) {
+            // Manual one-shot runs do not advance the cadence or recompute completion.
+        }
+        else if (shouldCompleteSchedule(updated, now)) {
+            updated = completeSchedule(updated, now);
+        }
+        else if (updated.status === "paused") {
+            updated = {
+                ...updated,
+                nextRunAt: null,
+            };
+        }
+        else {
+            const after = new Date(schedule.nextRunAt ?? now.toISOString());
+            let nextRunAt = computeNextRunAt(updated.cadence, after);
+            while (nextRunAt !== null && nextRunAt.getTime() <= now.getTime()) {
+                nextRunAt = computeNextRunAt(updated.cadence, nextRunAt);
+            }
+            updated = {
+                ...updated,
+                nextRunAt: nextRunAt?.toISOString() ?? null,
+            };
+        }
+        await this.store.put(updated);
+    }
+    async executeSchedule(schedule, runId) {
+        if (schedule.target.type === "agent") {
+            const wrappedPrompt = formatSystemNotificationPrompt(buildScheduleFireBody(schedule, runId));
+            const record = await this.agentStorage.get(schedule.target.agentId);
+            if (!record) {
+                throw new ScheduleTargetGoneError(`Agent ${schedule.target.agentId} no longer exists`);
+            }
+            if (record.archivedAt) {
+                throw new ScheduleTargetGoneError(`Agent ${schedule.target.agentId} is archived`);
+            }
+            const agent = await ensureAgentLoaded(schedule.target.agentId, {
+                agentManager: this.agentManager,
+                agentStorage: this.agentStorage,
+                logger: this.logger,
+            });
+            if (this.agentManager.hasInFlightRun(agent.id)) {
+                throw new Error(`Agent ${agent.id} already has an active run`);
+            }
+            const result = await this.agentManager.runAgent(agent.id, wrappedPrompt);
+            const timelineText = curateAgentActivity(result.timeline);
+            return {
+                agentId: agent.id,
+                output: buildRunOutput({
+                    output: null,
+                    timelineText,
+                    finalText: result.finalText,
+                }),
+            };
+        }
+        const targetConfig = schedule.target.config;
+        // The cwd guard fires BEFORE any filter resolution, and a test pins that
+        // ordering (`fires the missing-cwd guard ahead of any filter resolution`): a
+        // dead working directory is permanent, so polling a source and resolving a
+        // filter against it is outward work that can never pay off.
+        // `runUnattendedSession` runs the same guard again, because it is the entry
+        // point for the dry-run path too and must not depend on a caller remembering.
+        // `stat` is read-only and idempotent; the source path pays one extra syscall.
+        await this.assertTargetCwdExists(targetConfig.cwd);
+        const labels = {
+            "paseo.schedule-id": schedule.id,
+            "paseo.schedule-run": runId,
+        };
+        // Non-source cadences keep sending the stored prompt untouched. The source path
+        // ignores `schedule.prompt` entirely and briefs the session from the filter.
+        let runPrompt = schedule.prompt;
+        if (schedule.cadence.type === "source") {
+            const filter = await this.filterResolver(schedule.cadence.filterId);
+            if (!filter) {
+                // A deleted filter is the exact analogue of a deleted cwd: permanent, so it
+                // reuses the error that completes the schedule instead of retrying forever.
+                throw new ScheduleTargetGoneError(`Filter ${schedule.cadence.filterId} no longer exists`);
+            }
+            // Collapse INSIDE the run single-flight already admitted, never around it.
+            // The single-flight set stays keyed on the bare schedule id: the moment that key
+            // became a (schedule, group) pair, nine group keys would become nine concurrent
+            // sessions in one working directory, the exact thing a group key exists to stop.
+            // So this run dispatches the first group and the remainder waits for the next
+            // tick. The remainder is deliberately not queued or persisted; the provider is
+            // the memory in this epic, and Epic 3's ledger is the memory after it.
+            const groups = groupMatchedItems(await this.matchedItems(schedule, filter), filter.groupKey);
+            if (groups.length === 0) {
+                // Matching nothing is the common case for a poll, not a failure. Mint no
+                // session, brief no agent, and let the cadence advance normally.
+                return { agentId: null, output: null };
+            }
+            const group = groups[0];
+            runPrompt = buildSourceRunPrompt({ filter, items: group.items, runId });
+            labels[FILTER_ID_LABEL] = filter.id;
+            labels[ITEM_GROUP_LABEL] = group.key;
+            labels[ITEM_KEYS_LABEL] = group.items.map((item) => item.key).join(",");
+        }
+        // No `mcpServersOverride`: the tick path keeps `targetConfig.mcpServers`
+        // exactly as stored, so this branch is byte-identical to what it was before
+        // the extraction.
+        return this.runUnattendedSession({ targetConfig, prompt: runPrompt, labels });
+    }
+    /**
+     * A dead `cwd` is a permanently gone target, not a transient failure.
+     *
+     * Split out so `executeSchedule` can fire it ahead of source-filter resolution
+     * while `runUnattendedSession` still owns it for every other caller.
+     */
+    async assertTargetCwdExists(cwd) {
+        try {
+            await stat(cwd);
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                throw new ScheduleTargetGoneError(`Working directory ${cwd} no longer exists`);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Mint one unattended session against a `new-agent` target, run it, archive it,
+     * and hand back the curated output.
+     *
+     * This is the ONE new-agent minting path in the daemon. The overnight tick
+     * reaches it through `executeSchedule`; Epic 5's manual dry run reaches it
+     * directly as a `DryRunDispatcher`, which `ScheduleService` satisfies
+     * structurally with no adapter class. A second copy of this block is how the
+     * two paths would drift on `unattended`, on archival, or on title derivation.
+     *
+     * The caller owns the prompt and the labels. This method owns everything that
+     * touches the provider.
+     */
+    async runUnattendedSession(input) {
+        const { targetConfig, prompt, labels } = input;
+        await this.assertTargetCwdExists(targetConfig.cwd);
+        const resolvedUnattendedConfig = targetConfig.modeId
+            ? { modeId: targetConfig.modeId, featureValues: targetConfig.featureValues }
+            : await this.resolveProviderCreateConfig({
+                provider: targetConfig.provider,
+                cwd: targetConfig.cwd,
+                requestedMode: undefined,
+                featureValues: targetConfig.featureValues,
+                parent: null,
+                unattended: true,
+            });
+        const config = {
+            provider: targetConfig.provider,
+            cwd: targetConfig.cwd,
+            modeId: resolvedUnattendedConfig.modeId,
+            model: targetConfig.model,
+            thinkingOptionId: targetConfig.thinkingOptionId,
+            title: targetConfig.title,
+            approvalPolicy: targetConfig.approvalPolicy,
+            sandboxMode: targetConfig.sandboxMode,
+            networkAccess: targetConfig.networkAccess,
+            webSearch: targetConfig.webSearch,
+            featureValues: resolvedUnattendedConfig.featureValues,
+            extra: targetConfig.extra,
+            // An explicit `{}` is a DECISION ("this session gets zero MCP servers from
+            // paseo"), not an absence, and it must survive the trip. So the branch is on
+            // `!== undefined` rather than on truthiness or on `??`: an override of `{}`
+            // replaces the stored record entirely, while omitting the override leaves the
+            // tick path's behaviour exactly as it was.
+            systemPrompt: targetConfig.systemPrompt,
+            mcpServers: input.mcpServersOverride !== undefined
+                ? input.mcpServersOverride
+                : targetConfig.mcpServers,
+        };
+        const { provisionalTitle } = resolveCreateAgentTitles({
+            configTitle: config.title,
+            initialPrompt: prompt,
+        });
+        const agent = await this.agentManager.createAgent(config, undefined, {
+            labels,
+            initialPrompt: prompt,
+            initialTitle: provisionalTitle,
+        });
+        let result;
+        try {
+            result = await this.agentManager.runAgent(agent.id, prompt);
+        }
+        catch (error) {
+            try {
+                await this.agentManager.archiveAgent(agent.id);
+            }
+            catch (archiveError) {
+                this.logger.warn({ err: archiveError, agentId: agent.id, labels }, "Failed to archive scheduled agent after failed run");
+            }
+            throw error;
+        }
+        await this.agentManager.archiveAgent(agent.id);
+        const timelineText = curateAgentActivity(result.timeline);
+        return {
+            agentId: agent.id,
+            output: buildRunOutput({
+                output: null,
+                timelineText,
+                finalText: result.finalText,
+            }),
+        };
+    }
+    async resolveProviderCreateConfig(input) {
+        return this.createConfigResolver.resolveCreateConfig(input);
+    }
+}
+//# sourceMappingURL=service.js.map