@hyperdrive.bot/paseo-server 0.3.39 → 0.3.41

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/session/workspace-provisioning/workspace-provisioning-service.d.ts

@@ -19,9 +19,21 @@ export interface ResolveOrCreateWorkspaceIdInput {
     cwd: string;
     initialTitle: string | null;
 }
+/**
+ * `createdWorkspace` is true ONLY when this call minted a brand new workspace
+ * record. Callers use it to decide whether post-create side effects that are
+ * only correct on a fresh workspace may run — notably workspace auto-naming,
+ * which would otherwise rename a workspace the user already had. Deriving that
+ * from the REQUEST (`!msg.workspaceId`) is wrong now that an omitted id can
+ * resolve to an existing workspace.
+ */
+export interface ResolveOrCreateWorkspaceIdResult {
+    workspaceId: string;
+    createdWorkspace: boolean;
+}
 export interface WorkspaceProvisioningService {
     findOrCreateWorkspaceForDirectory(cwd: string): Promise<PersistedWorkspaceRecord>;
-    resolveOrCreateWorkspaceIdForCreateAgent(input: ResolveOrCreateWorkspaceIdInput): Promise<string>;
+    resolveOrCreateWorkspaceIdForCreateAgent(input: ResolveOrCreateWorkspaceIdInput): Promise<ResolveOrCreateWorkspaceIdResult>;
     createWorkspaceForDirectory(cwd: string, title?: string | null): Promise<PersistedWorkspaceRecord>;
     findOrCreateProjectForDirectory(cwd: string): Promise<PersistedProjectRecord>;
     ensureWorkspaceRecordUnarchived(workspace: PersistedWorkspaceRecord): Promise<PersistedWorkspaceRecord>;

package/dist/server/server/session/workspace-provisioning/workspace-provisioning-service.js

@@ -119,12 +119,36 @@ export function createWorkspaceProvisioningService(deps) {
     }
     async function resolveOrCreateWorkspaceIdForCreateAgent(input) {
         if (input.createdWorktree) {
-            return input.createdWorktree.workspace.workspaceId;
+            return {
+                workspaceId: input.createdWorktree.workspace.workspaceId,
+                createdWorkspace: false,
+            };
         }
         if (input.requestedWorkspaceId) {
-            return input.requestedWorkspaceId;
+            return { workspaceId: input.requestedWorkspaceId, createdWorkspace: false };
         }
-        return (await createWorkspaceForDirectory(input.cwd, input.initialTitle)).workspaceId;
+        // Look before you mint. This branch used to call createWorkspaceForDirectory
+        // unconditionally, so every createAgent that omitted `workspaceId` produced a
+        // SECOND workspace for a directory that already had one — no lookup, not even
+        // against the identical cwd. On one daemon that turned 19 directories into 114
+        // workspace records, 48 of them on a single repo root, and the agent surfaced
+        // in the fresh workspace instead of the one on screen.
+        //
+        // 0.3.38 fixed the palette by making its caller pass the id. That closes one
+        // door and leaves the hole: any other caller (MCP create_agent, loops,
+        // schedules, whatever is written next) still mints. Fix it where ownership is
+        // actually decided.
+        const existing = await findExactWorkspaceByDirectory(input.cwd, { refreshGit: false });
+        if (existing) {
+            const reused = await reclassifyOrUnarchiveWorkspaceForDirectory({
+                workspace: existing,
+                project: await projectRegistry.get(existing.projectId),
+                cwd: await resolveWorkspaceDirectory(input.cwd, { refreshGit: false }),
+            });
+            return { workspaceId: reused.workspaceId, createdWorkspace: false };
+        }
+        const created = await createWorkspaceForDirectory(input.cwd, input.initialTitle);
+        return { workspaceId: created.workspaceId, createdWorkspace: true };
     }
     async function createWorkspaceForDirectory(cwd, title) {
         const checkout = await workspaceGitService.getCheckout(cwd);

package/dist/server/server/session.js

@@ -2693,13 +2693,17 @@ export class Session {
             let createAgentConfig = createdWorktree
                 ? { ...config, cwd: createdWorktree.worktree.worktreePath }
                 : config;
-            const workspaceId = await this.workspaceProvisioning.resolveOrCreateWorkspaceIdForCreateAgent({
+            const { workspaceId, createdWorkspace } = await this.workspaceProvisioning.resolveOrCreateWorkspaceIdForCreateAgent({
                 createdWorktree,
                 requestedWorkspaceId: msg.workspaceId,
                 cwd: createAgentConfig.cwd,
                 initialTitle: workspacePromptTitle,
             });
-            const createdDirectoryWorkspaceForAgent = !createdWorktree && !msg.workspaceId;
+            // Gate auto-naming on what actually happened, NOT on what was requested.
+            // An omitted workspaceId no longer implies a fresh workspace: provisioning
+            // now reuses the one that already owns this cwd, and auto-naming a reused
+            // workspace would rename one the user already had.
+            const createdDirectoryWorkspaceForAgent = !createdWorktree && createdWorkspace;
             // Resuming a past session: the recorded cwd may no longer exist on this
             // machine (different $HOME, deleted folder). The transcript is read from
             // ~/.claude/projects regardless, so fall back to an existing directory