@otto-code/server 0.5.0

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

@@ -0,0 +1,882 @@
+import { randomUUID } from "node:crypto";
+import { stat } from "node:fs/promises";
+import { join } from "node:path";
+import { resolvePersonality, } from "../agent/agent-personalities.js";
+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 { formatProviderModel } from "../agent/create-agent/create.js";
+import { ScheduleStore } from "./store.js";
+import { computeNextRunAt, validateScheduleCadence } from "./cron.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";
+    }
+}
+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;
+        }
+    }
+    if (patch.thinkingOptionId !== undefined) {
+        const trimmed = patch.thinkingOptionId?.trim();
+        if (trimmed) {
+            config.thinkingOptionId = trimmed;
+        }
+        else {
+            delete config.thinkingOptionId;
+        }
+    }
+    if (patch.archiveOnFinish !== undefined) {
+        config.archiveOnFinish = patch.archiveOnFinish;
+    }
+    if (patch.isolation !== undefined) {
+        config.isolation = patch.isolation;
+    }
+    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 shouldArchiveScheduleRunWorkspace(input) {
+    return input.agentId === null || (input.archiveOnFinish ?? true);
+}
+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;
+}
+function requireSchedule(schedule, id) {
+    if (!schedule) {
+        throw new Error(`Schedule not found: ${id}`);
+    }
+    return schedule;
+}
+function completeSchedule(schedule, now) {
+    return {
+        ...schedule,
+        status: "completed",
+        nextRunAt: null,
+        pausedAt: null,
+        updatedAt: now.toISOString(),
+    };
+}
+function mergeScheduleCadenceTimezone(current, next) {
+    if (current.type === "cron" &&
+        next.type === "cron" &&
+        next.timezone === undefined &&
+        current.timezone !== undefined) {
+        return {
+            ...next,
+            timezone: current.timezone,
+        };
+    }
+    return next;
+}
+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;
+}
+export class ScheduleService {
+    constructor(options) {
+        this.runningScheduleIds = new Set();
+        this.tickTimer = null;
+        this.store = new ScheduleStore(join(options.ottoHome, "schedules"));
+        this.logger = options.logger.child({ module: "schedule-service" });
+        this.agentManager = options.agentManager;
+        this.agentStorage = options.agentStorage;
+        this.createAgent = options.createAgent;
+        this.createLocalCheckoutWorkspace = options.createLocalCheckoutWorkspace;
+        this.createOttoWorktreeWorkspace = options.createOttoWorktreeWorkspace;
+        this.archiveWorkspace = options.archiveWorkspace;
+        this.providerSnapshotManager = options.providerSnapshotManager ?? null;
+        this.readAgentPersonalities = options.readAgentPersonalities ?? null;
+        this.now = options.now ?? (() => new Date());
+        this.runner = options.runner ?? ((schedule, runId) => this.executeSchedule(schedule, runId));
+    }
+    async start() {
+        await this.recoverInterruptedRuns();
+        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 prompt = normalizePrompt(input.prompt);
+        validateScheduleCadence(input.cadence);
+        return this.createScheduleRecord(input, {
+            name: trimOptionalName(input.name),
+            prompt,
+            target: input.target,
+        });
+    }
+    async createScheduleRecord(input, fields) {
+        return this.store.create(this.buildScheduleRecord(input, fields));
+    }
+    buildScheduleRecord(input, fields) {
+        const now = this.now();
+        const runOnCreate = input.runOnCreate ?? input.cadence.type === "every";
+        const nextRunAt = runOnCreate ? now : computeNextRunAt(input.cadence, now);
+        return {
+            name: fields.name,
+            prompt: fields.prompt,
+            cadence: input.cadence,
+            target: fields.target,
+            status: "active",
+            createdAt: now.toISOString(),
+            updatedAt: now.toISOString(),
+            nextRunAt: nextRunAt.toISOString(),
+            lastRunAt: null,
+            lastRunStatus: null,
+            lastRunError: null,
+            pausedAt: null,
+            expiresAt: input.expiresAt ?? null,
+            maxRuns: normalizeMaxRuns(input.maxRuns),
+            runs: [],
+        };
+    }
+    // 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);
+        const prompt = normalizePrompt(input.prompt);
+        validateScheduleCadence(input.cadence);
+        if (name === null) {
+            return this.createScheduleRecord(input, { name, prompt, target: input.target });
+        }
+        const inputTarget = input.target;
+        return this.store.upsertByNameAndTarget(name, inputTarget, {
+            create: async () => {
+                return this.buildScheduleRecord(input, { name, prompt, target: inputTarget });
+            },
+            update: async (current) => {
+                const now = this.now();
+                const cadence = mergeScheduleCadenceTimezone(current.cadence, input.cadence);
+                const runOnCreate = input.runOnCreate ?? cadence.type === "every";
+                const nextRunAt = runOnCreate ? now : computeNextRunAt(cadence, now);
+                return {
+                    ...current,
+                    name,
+                    prompt,
+                    cadence,
+                    target: inputTarget,
+                    status: "active",
+                    pausedAt: null,
+                    nextRunAt: nextRunAt.toISOString(),
+                    expiresAt: input.expiresAt ?? null,
+                    maxRuns: normalizeMaxRuns(input.maxRuns),
+                    updatedAt: now.toISOString(),
+                };
+            },
+        });
+    }
+    async list() {
+        return this.store.list();
+    }
+    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 paused = await this.store.update(id, (schedule) => {
+            if (schedule.status === "completed") {
+                throw new Error(`Schedule ${id} is already completed`);
+            }
+            if (schedule.status === "paused") {
+                return schedule;
+            }
+            const now = this.now();
+            return {
+                ...schedule,
+                status: "paused",
+                nextRunAt: null,
+                pausedAt: now.toISOString(),
+                updatedAt: now.toISOString(),
+            };
+        });
+        return requireSchedule(paused, id);
+    }
+    async resume(id) {
+        const resumed = await this.store.update(id, (schedule) => {
+            if (schedule.status === "completed") {
+                throw new Error(`Schedule ${id} is already completed`);
+            }
+            if (schedule.status === "active") {
+                return schedule;
+            }
+            const now = this.now();
+            return {
+                ...schedule,
+                status: "active",
+                pausedAt: null,
+                nextRunAt: computeNextRunAt(schedule.cadence, now).toISOString(),
+                updatedAt: now.toISOString(),
+            };
+        });
+        return requireSchedule(resumed, id);
+    }
+    async update(input) {
+        const next = await this.store.update(input.id, async (schedule) => {
+            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) {
+                const cadence = mergeScheduleCadenceTimezone(updated.cadence, input.cadence);
+                validateScheduleCadence(cadence);
+                const nextRunAt = updated.status === "active" ? computeNextRunAt(cadence, now).toISOString() : null;
+                updated = { ...updated, 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");
+                }
+                const patchedTarget = applyNewAgentConfig(updated.target, input.newAgentConfig);
+                updated = {
+                    ...updated,
+                    target: patchedTarget,
+                };
+            }
+            if (input.maxRuns !== undefined) {
+                updated = { ...updated, maxRuns: normalizeMaxRuns(input.maxRuns) };
+            }
+            if (input.expiresAt !== undefined) {
+                updated = { ...updated, expiresAt: input.expiresAt };
+            }
+            return { ...updated, updatedAt: now.toISOString() };
+        });
+        return requireSchedule(next, input.id);
+    }
+    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.completeScheduleForAgent(schedule.id, agentId, now)));
+        let completed = 0;
+        for (const [index, result] of results.entries()) {
+            if (result.status === "fulfilled" && result.value) {
+                completed += 1;
+            }
+            else if (result.status === "rejected") {
+                this.logger.warn({
+                    err: result.reason,
+                    scheduleId: matches[index].id,
+                    agentId,
+                }, "Failed to complete schedule for archived agent; continuing");
+            }
+        }
+        return completed;
+    }
+    async completeScheduleForAgent(scheduleId, agentId, now) {
+        let completed = false;
+        const updated = await this.store.update(scheduleId, (schedule) => {
+            if (schedule.target.type !== "agent" ||
+                schedule.target.agentId !== agentId ||
+                schedule.status === "completed") {
+                return schedule;
+            }
+            completed = true;
+            return completeSchedule(schedule, now);
+        });
+        requireSchedule(updated, scheduleId);
+        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();
+        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.completeScheduleIfDue(schedule.id, now);
+                continue;
+            }
+            if (new Date(schedule.nextRunAt).getTime() > now.getTime()) {
+                continue;
+            }
+            await this.runSchedule(schedule, now);
+        }
+    }
+    async completeScheduleIfDue(scheduleId, now) {
+        const updated = await this.store.update(scheduleId, (schedule) => {
+            if (schedule.status !== "active" ||
+                !schedule.nextRunAt ||
+                !shouldCompleteSchedule(schedule, now)) {
+                return schedule;
+            }
+            return completeSchedule(schedule, now);
+        });
+        requireSchedule(updated, scheduleId);
+    }
+    async recoverInterruptedRuns() {
+        const schedules = await this.store.list();
+        const now = this.now();
+        await Promise.all(schedules.map((schedule) => this.recoverInterruptedSchedule(schedule.id, now)));
+    }
+    async recoverInterruptedSchedule(scheduleId, now) {
+        const interruptedWorkspaces = [];
+        await this.store.update(scheduleId, (current) => {
+            let updated = { ...current };
+            let dirty = false;
+            const runningIndex = updated.runs.findIndex((run) => run.status === "running");
+            if (runningIndex !== -1) {
+                const runs = [...updated.runs];
+                const runningRun = runs[runningIndex];
+                if (updated.target.type === "new-agent" &&
+                    runningRun.workspaceId &&
+                    shouldArchiveScheduleRunWorkspace({
+                        agentId: runningRun.agentId,
+                        archiveOnFinish: updated.target.config.archiveOnFinish,
+                    })) {
+                    interruptedWorkspaces.push({
+                        workspaceId: runningRun.workspaceId,
+                        repoRoot: updated.target.config.cwd,
+                        agentId: runningRun.agentId,
+                        runId: runningRun.id,
+                    });
+                }
+                runs[runningIndex] = {
+                    ...runningRun,
+                    status: "failed",
+                    endedAt: now.toISOString(),
+                    error: "Daemon restarted before the scheduled run completed",
+                };
+                updated = { ...updated, runs };
+                dirty = true;
+            }
+            if (updated.status === "active" &&
+                updated.nextRunAt &&
+                new Date(updated.nextRunAt).getTime() <= now.getTime()) {
+                let nextRunAt = computeNextRunAt(updated.cadence, new Date(updated.nextRunAt));
+                while (nextRunAt.getTime() <= now.getTime()) {
+                    nextRunAt = computeNextRunAt(updated.cadence, nextRunAt);
+                }
+                updated = { ...updated, nextRunAt: nextRunAt.toISOString() };
+                dirty = true;
+            }
+            if (dirty) {
+                return { ...updated, updatedAt: now.toISOString() };
+            }
+            return current;
+        });
+        const interruptedWorkspace = interruptedWorkspaces[0];
+        if (!interruptedWorkspace) {
+            return;
+        }
+        try {
+            await this.archiveWorkspace(interruptedWorkspace.workspaceId, interruptedWorkspace.repoRoot);
+        }
+        catch (error) {
+            this.logger.warn({
+                err: error,
+                agentId: interruptedWorkspace.agentId,
+                workspaceId: interruptedWorkspace.workspaceId,
+                scheduleId,
+                runId: interruptedWorkspace.runId,
+            }, "Failed to archive interrupted scheduled workspace after daemon restart");
+        }
+    }
+    // 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((schedule) => this.sweepOrphanedSchedule(schedule.id, now)));
+    }
+    async sweepOrphanedSchedule(scheduleId, now) {
+        await this.store.update(scheduleId, async (schedule) => {
+            if (schedule.target.type !== "agent" || schedule.status === "completed") {
+                return schedule;
+            }
+            const record = await this.agentStorage.get(schedule.target.agentId);
+            if (record && !record.archivedAt) {
+                return schedule;
+            }
+            return 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 = await this.appendRunningRun(schedule.id, runningRun);
+        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 appendRunningRun(scheduleId, runningRun) {
+        const updated = await this.store.update(scheduleId, (schedule) => ({
+            ...schedule,
+            updatedAt: runningRun.startedAt,
+            runs: [...schedule.runs, runningRun],
+        }));
+        return requireSchedule(updated, scheduleId);
+    }
+    async finishRun(params) {
+        const updatedSchedule = await this.store.update(params.scheduleId, (schedule) => {
+            const now = this.now();
+            const completedRuns = schedule.runs.map((run) => run.id === params.runId
+                ? {
+                    ...run,
+                    status: params.status,
+                    endedAt: now.toISOString(),
+                    agentId: params.agentId ?? run.agentId,
+                    output: params.output,
+                    error: params.error,
+                }
+                : run);
+            let updated = {
+                ...schedule,
+                runs: completedRuns,
+                lastRunAt: now.toISOString(),
+                lastRunStatus: params.status,
+                lastRunError: params.error,
+                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.getTime() <= now.getTime()) {
+                    nextRunAt = computeNextRunAt(updated.cadence, nextRunAt);
+                }
+                updated = {
+                    ...updated,
+                    nextRunAt: nextRunAt.toISOString(),
+                };
+            }
+            return updated;
+        });
+        requireSchedule(updatedSchedule, params.scheduleId);
+    }
+    async recordRunWorkspace(params) {
+        const updatedSchedule = await this.store.update(params.scheduleId, (schedule) => ({
+            ...schedule,
+            updatedAt: this.now().toISOString(),
+            runs: schedule.runs.map((run) => run.id === params.runId && run.status === "running"
+                ? {
+                    ...run,
+                    workspaceId: params.workspaceId,
+                    agentId: params.agentId,
+                }
+                : run),
+        }));
+        requireSchedule(updatedSchedule, params.scheduleId);
+    }
+    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 config = schedule.target.type === "new-agent" ? schedule.target.config : null;
+        if (!config) {
+            throw new Error(`Schedule ${schedule.id} target changed during execution`);
+        }
+        await this.assertNewAgentCwdDirectory(config.cwd);
+        let workspace = null;
+        let agentId = null;
+        try {
+            workspace = await this.createScheduleRunWorkspace(config, schedule.prompt);
+            await this.recordRunWorkspace({
+                scheduleId: schedule.id,
+                runId,
+                workspaceId: workspace.workspaceId,
+                agentId: null,
+            });
+            const runConfig = { ...config, cwd: workspace.cwd };
+            // A personality-bound schedule re-resolves its personality against THIS
+            // run's cwd and hard-fails the run if it's unavailable (surfaced via the
+            // run's failure path) — no silent fallback.
+            const brain = await this.resolveSchedulePersonalityBrain(runConfig);
+            const spawn = applyScheduleBrain({
+                brain,
+                baseAgentConfig: buildScheduleAgentConfig(runConfig),
+                fallbackProviderModel: formatScheduleProviderModel(runConfig),
+                configModeId: config.modeId,
+                configThinkingOptionId: config.thinkingOptionId,
+            });
+            const created = await this.createAgent({
+                kind: "mcp",
+                provider: spawn.provider,
+                config: spawn.config,
+                cwd: workspace.cwd,
+                workspaceId: workspace.workspaceId,
+                title: resolveScheduleAgentTitle(config, schedule.prompt),
+                labels: {
+                    "otto.schedule-id": schedule.id,
+                    "otto.schedule-run": runId,
+                },
+                mode: spawn.mode,
+                thinking: spawn.thinking,
+                features: config.featureValues,
+                unattended: true,
+                promptFailure: "return-error",
+                background: true,
+                notifyOnFinish: false,
+            });
+            const agent = created.snapshot;
+            agentId = agent.id;
+            await this.recordRunWorkspace({
+                scheduleId: schedule.id,
+                runId,
+                workspaceId: workspace.workspaceId,
+                agentId,
+            });
+            if (created.initialPromptError) {
+                throw created.initialPromptError;
+            }
+            const result = await this.agentManager.runAgent(agent.id, schedule.prompt);
+            const waitResult = await this.agentManager.waitForAgentEvent(agent.id, {
+                waitForActive: true,
+            });
+            if (result.canceled) {
+                throw new Error(`Scheduled agent ${agent.id} was canceled`);
+            }
+            if (waitResult.permission) {
+                throw new Error(`Scheduled agent ${agent.id} is waiting for permission`);
+            }
+            if (waitResult.status === "error") {
+                throw new Error(waitResult.lastMessage ?? `Scheduled agent ${agent.id} failed`);
+            }
+            const timelineText = curateAgentActivity(result.timeline);
+            return {
+                agentId: agent.id,
+                output: buildRunOutput({
+                    output: waitResult.lastMessage ?? null,
+                    timelineText,
+                    finalText: result.finalText,
+                }),
+            };
+        }
+        finally {
+            if (workspace &&
+                shouldArchiveScheduleRunWorkspace({ agentId, archiveOnFinish: config.archiveOnFinish })) {
+                try {
+                    await this.archiveWorkspace(workspace.workspaceId, config.cwd);
+                }
+                catch (error) {
+                    this.logger.warn({
+                        err: error,
+                        agentId,
+                        workspaceId: workspace.workspaceId,
+                        scheduleId: schedule.id,
+                        runId,
+                    }, "Failed to archive scheduled workspace after run");
+                }
+            }
+        }
+    }
+    async createScheduleRunWorkspace(config, prompt) {
+        const firstAgentContext = { prompt };
+        switch (config.isolation ?? "local") {
+            case "local":
+                return this.createLocalCheckoutWorkspace({ cwd: config.cwd, firstAgentContext });
+            case "worktree":
+                return (await this.createOttoWorktreeWorkspace({ cwd: config.cwd, firstAgentContext }))
+                    .workspace;
+        }
+    }
+    async assertNewAgentCwdDirectory(cwd) {
+        try {
+            const stats = await stat(cwd);
+            if (!stats.isDirectory()) {
+                throw new ScheduleTargetGoneError(`Working directory ${cwd} is not a directory`);
+            }
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                throw new ScheduleTargetGoneError(`Working directory ${cwd} no longer exists`);
+            }
+            throw error;
+        }
+    }
+    // Resolve a schedule's optional personality binding against the run cwd, or
+    // undefined when unbound. Throws (failing the run) when the personality is
+    // named but missing/unavailable, or when personality resolution isn't wired.
+    async resolveSchedulePersonalityBrain(config) {
+        const name = config.personality?.trim();
+        if (!name) {
+            return undefined;
+        }
+        if (!this.providerSnapshotManager || !this.readAgentPersonalities) {
+            throw new Error(`Schedule binds personality "${name}", but personality resolution is not configured on this host.`);
+        }
+        const roster = this.readAgentPersonalities();
+        const personality = roster.find((entry) => entry.name === name) ??
+            roster.find((entry) => entry.name.toLowerCase() === name.toLowerCase());
+        if (!personality) {
+            throw new Error(`Personality "${name}" not found; the scheduled run cannot proceed.`);
+        }
+        const entries = await this.providerSnapshotManager.listProviders({
+            cwd: config.cwd,
+            wait: true,
+        });
+        const resolution = resolvePersonality(personality, entries);
+        if (resolution.status === "unavailable") {
+            throw new Error(`Personality "${personality.name}" is unavailable: ${resolution.reason}`);
+        }
+        const snapshot = resolution.snapshot;
+        return {
+            providerModel: snapshot.model ? `${snapshot.provider}/${snapshot.model}` : snapshot.provider,
+            ...(snapshot.modeId !== undefined ? { modeId: snapshot.modeId } : {}),
+            ...(snapshot.thinkingOptionId !== undefined
+                ? { thinkingOptionId: snapshot.thinkingOptionId }
+                : {}),
+            ...(snapshot.systemPrompt !== undefined ? { systemPrompt: snapshot.systemPrompt } : {}),
+            snapshot,
+        };
+    }
+}
+// Fold a resolved personality brain (or its absence) into the createAgent
+// provider/config/mode/thinking. Extracted so executeSchedule stays under the
+// complexity budget.
+function applyScheduleBrain(input) {
+    const { brain, baseAgentConfig, fallbackProviderModel, configModeId, configThinkingOptionId } = input;
+    if (!brain) {
+        return {
+            provider: fallbackProviderModel,
+            config: baseAgentConfig,
+            mode: configModeId,
+            thinking: configThinkingOptionId,
+        };
+    }
+    const config = { ...baseAgentConfig, personalitySnapshot: brain.snapshot };
+    if (brain.systemPrompt !== undefined) {
+        config.systemPrompt = brain.systemPrompt;
+    }
+    return {
+        provider: brain.providerModel,
+        config,
+        mode: brain.modeId ?? configModeId,
+        thinking: brain.thinkingOptionId ?? configThinkingOptionId,
+    };
+}
+function buildScheduleAgentConfig(config) {
+    return {
+        provider: config.provider,
+        cwd: config.cwd,
+        modeId: config.modeId,
+        model: config.model,
+        thinkingOptionId: config.thinkingOptionId,
+        title: config.title,
+        approvalPolicy: config.approvalPolicy,
+        sandboxMode: config.sandboxMode,
+        networkAccess: config.networkAccess,
+        webSearch: config.webSearch,
+        featureValues: config.featureValues,
+        extra: config.extra,
+        systemPrompt: config.systemPrompt,
+        mcpServers: config.mcpServers,
+    };
+}
+function resolveScheduleAgentTitle(config, prompt) {
+    return (resolveCreateAgentTitles({
+        configTitle: config.title,
+        initialPrompt: prompt,
+    }).provisionalTitle ?? "");
+}
+function formatScheduleProviderModel(config) {
+    return formatProviderModel(config.provider, config.model);
+}
+//# sourceMappingURL=service.js.map