@cursor/july 0.1.105 → 0.1.108

package/dist/internal/reminder-runner.js

@@ -1,7 +1,7 @@
 /**
  * Per-session reminder runner: durable wake subscriptions with
- * prompt XOR run, every/cron/delay/at schedules, and until as
- * function XOR prompt.
+ * prompt XOR named handler XOR run, every/cron/delay/at schedules, and
+ * until as function XOR prompt.
  */
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
@@ -13,11 +13,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { randomBytes } from "node:crypto";
+import { channelContinuationIdentity, httpContinuationIdentity, } from "./continuation-channel.js";
+import { continuationSource } from "./continuation-identity.js";
+import { NAME_PATTERN } from "./discovery/names.js";
 import { parseDuration } from "./duration.js";
+import { REMINDER_CP_PROTOCOL_VERSION, scheduleSpecFromCreateInput, toWireReschedule, } from "./reminder-control-plane-protocol.js";
 import { defaultBusyPolicy, MAX_TIMER_MS, nextCronFireMs, ReminderValidationError, resolveSchedule, } from "./reminder-schedule.js";
 import { APP_AUTH } from "./schedule-runner.js";
-import { SessionBusyError } from "./session-engine.js";
+import { HTTP_CHANNEL_ID, SessionBusyError, } from "./session-engine.js";
 export { ReminderValidationError } from "./reminder-schedule.js";
+/** Max UTF-8 byte length of `JSON.stringify(args)` on named-handler create. */
+export const REMINDER_ARGS_MAX_BYTES = 32 * 1024;
 export class UnknownReminderError extends Error {
     constructor(reminderId, availableReminderIds) {
         super(`Unknown reminder "${reminderId}"`);
@@ -25,9 +31,46 @@ export class UnknownReminderError extends Error {
         this.name = "UnknownReminderError";
     }
 }
+/**
+ * Server wiring for {@link ReminderRunnerOptions.rejectAnonymousHandlers}:
+ * architecture v2 always rejects anonymous run/until (local or hosted).
+ */
+export function rejectAnonymousReminderHandlers(options) {
+    return options.architecture === "v2";
+}
 function newReminderId() {
     return `rem_${randomBytes(8).toString("hex")}`;
 }
+function isJsonObject(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        Object.values(value).every(isJsonValue));
+}
+function isJsonValue(value) {
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "boolean") {
+        return true;
+    }
+    if (typeof value === "number") {
+        return Number.isFinite(value);
+    }
+    if (Array.isArray(value)) {
+        return value.every(isJsonValue);
+    }
+    return isJsonObject(value);
+}
+/** Same stem rules as `agent/reminders/<name>.ts` discovery. */
+function isValidReminderHandlerName(name) {
+    return NAME_PATTERN.test(name) && !name.includes("__");
+}
+function assertReminderArgsSize(args) {
+    const bytes = Buffer.byteLength(JSON.stringify(args), "utf8");
+    if (bytes > REMINDER_ARGS_MAX_BYTES) {
+        throw new ReminderValidationError(`reminders.create args exceed ${REMINDER_ARGS_MAX_BYTES} bytes (got ${bytes})`);
+    }
+}
 function toInfo(record) {
     return {
         id: record.id,
@@ -38,9 +81,11 @@ function toInfo(record) {
         scheduleKind: record.scheduleKind,
         scheduleValue: record.scheduleValue,
         prompt: record.prompt,
+        handler: record.handler,
+        args: record.args,
         untilPrompt: record.untilPrompt,
         busyPolicy: record.busyPolicy,
-        status: record.status,
+        status: record.status === "firing" ? "armed" : record.status,
         disarmReason: record.disarmReason,
         fireCount: record.fireCount,
         nextFireAt: new Date(record.nextFireAtMs).toISOString(),
@@ -69,17 +114,31 @@ function buildFirePrompt(record) {
     return lines.join("\n");
 }
 export class ReminderRunner {
-    constructor(engine, logger = () => { }, platformTimers) {
+    constructor(engine, logger = () => { }, platformTimers, options = {}) {
+        var _a;
         this.engine = engine;
         this.logger = logger;
         this.platformTimers = platformTimers;
         this.records = new Map();
         this.handlers = new Map();
+        this.namedHandlers = new Map();
+        this.namedHandlerNames = new Map();
         this.timers = new Map();
         this.firing = new Set();
         /** Single-flight idle gates keyed by `channelId:continuationToken`. */
         this.idleGates = new Map();
         this.started = false;
+        this.rejectAnonymousHandlers = options.rejectAnonymousHandlers === true;
+        this.controlPlane = options.controlPlane;
+        this.architecture = options.architecture;
+        for (const reminder of (_a = options.namedHandlers) !== null && _a !== void 0 ? _a : []) {
+            this.namedHandlers.set(reminder.name, reminder.definition);
+            this.namedHandlerNames.set(reminder.definition, reminder.name);
+        }
+    }
+    /** True when create/cancel/rekey/fire go through the CP protocol. */
+    get usesControlPlaneProtocol() {
+        return this.controlPlane !== undefined && this.architecture === "v2";
     }
     /**
      * Load reminder documents from the control plane into memory. Does not
@@ -107,6 +166,13 @@ export class ReminderRunner {
                 if (record.status !== "armed") {
                     continue;
                 }
+                if (record.handler !== undefined) {
+                    if (this.namedHandlers.get(record.handler) === undefined) {
+                        yield this.disarm(record, "handler_missing");
+                        disarmedOrphan += 1;
+                    }
+                    continue;
+                }
                 if ((record.hasRunHandler === true || record.hasUntilFn === true) &&
                     this.handlers.get(record.id) === undefined) {
                     yield this.disarm(record, "handler_lost_on_restart");
@@ -135,6 +201,16 @@ export class ReminderRunner {
             let restored = 0;
             let disarmedOrphan = 0;
             for (const record of armed) {
+                if (record.handler !== undefined) {
+                    if (this.namedHandlers.get(record.handler) === undefined) {
+                        yield this.disarm(record, "handler_missing");
+                        disarmedOrphan += 1;
+                        continue;
+                    }
+                    this.armTimer(record);
+                    restored += 1;
+                    continue;
+                }
                 if ((record.hasRunHandler === true || record.hasUntilFn === true) &&
                     this.handlers.get(record.id) === undefined) {
                     yield this.disarm(record, "handler_lost_on_restart");
@@ -207,11 +283,13 @@ export class ReminderRunner {
     }
     create(input) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            var _a, _b;
             const hasPrompt = input.prompt !== undefined;
             const hasRun = input.run !== undefined;
-            if (hasPrompt === hasRun) {
-                throw new ReminderValidationError("reminders.create requires exactly one of prompt or run");
+            const hasHandler = input.handler !== undefined;
+            const formCount = [hasPrompt, hasRun, hasHandler].filter(Boolean).length;
+            if (formCount !== 1) {
+                throw new ReminderValidationError("reminders.create requires exactly one of prompt, handler, or run");
             }
             if (input.continuationToken.trim() === "") {
                 throw new ReminderValidationError("continuationToken is required");
@@ -222,41 +300,111 @@ export class ReminderRunner {
             if (input.purpose.trim() === "") {
                 throw new ReminderValidationError("purpose is required");
             }
-            const schedule = resolveSchedule(input);
-            const busyPolicy = (_a = input.busyPolicy) !== null && _a !== void 0 ? _a : defaultBusyPolicy(schedule.kind);
-            const now = new Date().toISOString();
-            const id = newReminderId();
             const untilPrompt = typeof input.until === "string" ? input.until : undefined;
             const untilFn = typeof input.until === "function" ? input.until : undefined;
+            if (hasHandler && input.until !== undefined) {
+                throw new ReminderValidationError("reminders.create: until is not valid with handler; encode the stop condition in args and the handler body");
+            }
+            if (this.rejectAnonymousHandlers) {
+                if (hasRun) {
+                    throw new ReminderValidationError("reminders.create: anonymous run handlers are not durable on architecture v2; author agent/reminders/<name>.ts and pass handler + args");
+                }
+                if (untilFn !== undefined) {
+                    throw new ReminderValidationError("reminders.create: function until is not durable on architecture v2; use a string until prompt");
+                }
+            }
+            let handlerName;
+            let handlerArgs;
+            if (hasHandler) {
+                const handler = input.handler;
+                const name = typeof handler === "string"
+                    ? handler.trim()
+                    : this.namedHandlerNames.get(handler);
+                if (name === undefined) {
+                    throw new ReminderValidationError("Unknown reminder handler definition (expected a default export discovered under agent/reminders/)");
+                }
+                if (name === "") {
+                    throw new ReminderValidationError("handler name is required");
+                }
+                if (!isValidReminderHandlerName(name)) {
+                    throw new ReminderValidationError(name.includes("__")
+                        ? `Invalid reminder handler name "${name}": may not contain "__"`
+                        : `Invalid reminder handler name "${name}": must match ${NAME_PATTERN}`);
+                }
+                if (this.namedHandlers.get(name) === undefined) {
+                    throw new ReminderValidationError(`Unknown reminder handler "${name}" (expected agent/reminders/${name}.ts)`);
+                }
+                if (input.args !== undefined && !isJsonObject(input.args)) {
+                    throw new ReminderValidationError("reminders.create args must be a JSON object");
+                }
+                handlerName = name;
+                handlerArgs = (_a = input.args) !== null && _a !== void 0 ? _a : {};
+                assertReminderArgsSize(handlerArgs);
+            }
+            else if (input.args !== undefined) {
+                throw new ReminderValidationError("reminders.create args is only valid with handler");
+            }
+            const schedule = resolveSchedule(input);
+            const busyPolicy = (_b = input.busyPolicy) !== null && _b !== void 0 ? _b : defaultBusyPolicy(schedule.kind);
             const hasRunHandler = input.run !== undefined;
             const hasUntilFn = untilFn !== undefined;
-            const record = {
-                version: 1,
-                id,
-                purpose: input.purpose,
-                channelId: input.channelId,
-                continuationToken: input.continuationToken,
-                target: input.target,
-                scheduleKind: schedule.kind,
-                scheduleValue: schedule.value,
-                intervalMs: schedule.intervalMs,
-                prompt: input.prompt,
-                hasRunHandler,
-                hasUntilFn,
-                untilPrompt,
-                busyPolicy,
-                status: "armed",
-                fireCount: 0,
-                nextFireAtMs: schedule.nextFireAtMs,
-                createdAt: now,
-                updatedAt: now,
-            };
-            yield this.persist(record);
-            this.handlers.set(id, {
+            let record;
+            if (this.usesControlPlaneProtocol) {
+                const intent = {
+                    protocolVersion: REMINDER_CP_PROTOCOL_VERSION,
+                    purpose: input.purpose,
+                    channelId: input.channelId,
+                    continuationToken: input.continuationToken,
+                    target: input.target,
+                    // CP recalculates nextFireAtMs / intervalMs from the raw schedule.
+                    schedule: scheduleSpecFromCreateInput(input),
+                    prompt: input.prompt,
+                    handler: handlerName,
+                    args: handlerArgs,
+                    hasRunHandler,
+                    hasUntilFn,
+                    untilPrompt,
+                    busyPolicy,
+                };
+                record = yield this.controlPlane.createReminder(intent);
+                this.records.set(record.id, record);
+            }
+            else {
+                const now = new Date().toISOString();
+                const id = newReminderId();
+                record = {
+                    version: 1,
+                    id,
+                    purpose: input.purpose,
+                    channelId: input.channelId,
+                    continuationToken: input.continuationToken,
+                    target: input.target,
+                    scheduleKind: schedule.kind,
+                    scheduleValue: schedule.value,
+                    intervalMs: schedule.intervalMs,
+                    prompt: input.prompt,
+                    handler: handlerName,
+                    args: handlerArgs,
+                    hasRunHandler,
+                    hasUntilFn,
+                    untilPrompt,
+                    busyPolicy,
+                    status: "armed",
+                    fireCount: 0,
+                    nextFireAtMs: schedule.nextFireAtMs,
+                    generation: 0,
+                    createdAt: now,
+                    updatedAt: now,
+                };
+                yield this.persist(record);
+            }
+            this.handlers.set(record.id, {
                 run: input.run,
                 untilFn,
             });
-            if (this.started && this.platformTimers === undefined) {
+            if (this.started &&
+                this.platformTimers === undefined &&
+                !this.usesControlPlaneProtocol) {
                 this.armTimer(record);
             }
             return toInfo(record);
@@ -267,8 +415,11 @@ export class ReminderRunner {
             const all = yield this.allRecords();
             return all
                 .filter((r) => {
-                if ((filter === null || filter === void 0 ? void 0 : filter.status) !== undefined && r.status !== filter.status) {
-                    return false;
+                if ((filter === null || filter === void 0 ? void 0 : filter.status) !== undefined) {
+                    const publicStatus = r.status === "firing" ? "armed" : r.status;
+                    if (publicStatus !== filter.status) {
+                        return false;
+                    }
                 }
                 if ((filter === null || filter === void 0 ? void 0 : filter.purpose) !== undefined && r.purpose !== filter.purpose) {
                     return false;
@@ -290,15 +441,27 @@ export class ReminderRunner {
     }
     cancel(id_1) {
         return __awaiter(this, arguments, void 0, function* (id, reason = "explicit_cancel") {
+            var _a;
+            if (this.usesControlPlaneProtocol) {
+                const updated = yield this.controlPlane.cancelReminder(id, reason);
+                if (updated === undefined) {
+                    this.records.delete(id);
+                    this.handlers.delete(id);
+                    return undefined;
+                }
+                this.records.set(id, updated);
+                this.handlers.delete(id);
+                return toInfo(updated);
+            }
             const record = yield this.getRecord(id);
             if (record === undefined) {
                 return undefined;
             }
-            if (record.status !== "armed") {
+            if (record.status !== "armed" && record.status !== "firing") {
                 return toInfo(record);
             }
             this.clearTimer(id);
-            const updated = Object.assign(Object.assign({}, record), { status: "cancelled", disarmReason: reason, updatedAt: new Date().toISOString() });
+            const updated = Object.assign(Object.assign({}, record), { status: "cancelled", disarmReason: reason, generation: ((_a = record.generation) !== null && _a !== void 0 ? _a : 0) + 1, updatedAt: new Date().toISOString() });
             yield this.persist(updated);
             this.handlers.delete(id);
             return toInfo(updated);
@@ -326,14 +489,18 @@ export class ReminderRunner {
      */
     rekeyContinuation(channelId, oldToken, newToken) {
         return __awaiter(this, void 0, void 0, function* () {
-            const armed = (yield this.allRecords()).filter((r) => r.status === "armed");
+            var _a;
+            if (this.usesControlPlaneProtocol) {
+                return this.controlPlane.rekeyReminders(channelId, oldToken, newToken);
+            }
+            const armed = (yield this.allRecords()).filter((r) => r.status === "armed" || r.status === "firing");
             let n = 0;
             for (const record of armed) {
                 if (record.channelId !== channelId ||
                     record.continuationToken !== oldToken) {
                     continue;
                 }
-                yield this.persist(Object.assign(Object.assign({}, record), { continuationToken: newToken, updatedAt: new Date().toISOString() }));
+                yield this.persist(Object.assign(Object.assign({}, record), { continuationToken: newToken, generation: ((_a = record.generation) !== null && _a !== void 0 ? _a : 0) + 1, updatedAt: new Date().toISOString() }));
                 n += 1;
             }
             return n;
@@ -359,6 +526,108 @@ export class ReminderRunner {
             return Object.assign({ reminderId }, result);
         });
     }
+    /**
+     * Architecture v2 / CP protocol guest entrypoint: execute an immutable fire
+     * descriptor and return an outcome. Does not mint ids or mutate
+     * authoritative status/fireCount — the control plane applies the outcome.
+     */
+    executeFire(descriptor) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const record = this.recordFromDescriptor(descriptor);
+            this.records.set(record.id, record);
+            const live = (_a = this.handlers.get(record.id)) !== null && _a !== void 0 ? _a : {};
+            if (record.handler !== undefined) {
+                if (this.resolveNamedHandler(record.handler) === undefined) {
+                    return { kind: "stop", reason: "handler_missing" };
+                }
+            }
+            else if ((record.hasRunHandler === true || record.hasUntilFn === true) &&
+                live.run === undefined &&
+                live.untilFn === undefined) {
+                return { kind: "stop", reason: "handler_lost_on_restart" };
+            }
+            if (live.untilFn !== undefined) {
+                try {
+                    const done = yield live.untilFn(this.buildUntilContext(record));
+                    if (done) {
+                        return { kind: "stop", reason: "until_fn" };
+                    }
+                }
+                catch (error) {
+                    this.logger(`[agent-sdk] reminder "${record.id}" until() failed: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            if (yield this.isSessionBusy(record.channelId, record.continuationToken)) {
+                if (record.busyPolicy === "skipIfBusy") {
+                    this.logger(`[agent-sdk] reminder "${record.id}" (${record.purpose}) skipped: session busy`);
+                    return { kind: "skipped" };
+                }
+                yield this.whenSessionIdle(record.channelId, record.continuationToken);
+            }
+            let result;
+            if (record.handler !== undefined) {
+                const named = this.resolveNamedHandler(record.handler);
+                if (named === undefined) {
+                    return { kind: "stop", reason: "handler_missing" };
+                }
+                result = yield named.run(this.buildFireContext(record));
+            }
+            else if (live.run !== undefined) {
+                result = yield live.run(this.buildFireContext(record));
+            }
+            else if (record.prompt !== undefined) {
+                result = yield this.deliverPrompt(record);
+            }
+            else {
+                return { kind: "stop", reason: "missing_handler" };
+            }
+            if (result.action === "stop") {
+                return { kind: "stop", reason: "run_stop" };
+            }
+            if (result.action === "skip") {
+                return {
+                    kind: "skipped",
+                    reschedule: result.reschedule !== undefined
+                        ? toWireReschedule(result.reschedule)
+                        : undefined,
+                };
+            }
+            return {
+                kind: "delivered",
+                reschedule: result.reschedule !== undefined
+                    ? toWireReschedule(result.reschedule)
+                    : undefined,
+            };
+        });
+    }
+    recordFromDescriptor(descriptor) {
+        const now = new Date().toISOString();
+        return {
+            version: 1,
+            id: descriptor.id,
+            purpose: descriptor.purpose,
+            channelId: descriptor.channelId,
+            continuationToken: descriptor.continuationToken,
+            target: descriptor.target,
+            scheduleKind: descriptor.scheduleKind,
+            scheduleValue: descriptor.scheduleValue,
+            intervalMs: descriptor.intervalMs,
+            prompt: descriptor.prompt,
+            handler: descriptor.handler,
+            args: descriptor.args,
+            hasRunHandler: descriptor.hasRunHandler,
+            hasUntilFn: descriptor.hasUntilFn,
+            untilPrompt: descriptor.untilPrompt,
+            busyPolicy: descriptor.busyPolicy,
+            status: "firing",
+            fireCount: descriptor.fireCount,
+            nextFireAtMs: descriptor.nextFireAtMs,
+            generation: descriptor.generation,
+            createdAt: now,
+            updatedAt: now,
+        };
+    }
     armTimer(record) {
         var _a;
         this.clearTimer(record.id);
@@ -401,6 +670,9 @@ export class ReminderRunner {
             this.timers.delete(id);
         }
     }
+    resolveNamedHandler(name) {
+        return this.namedHandlers.get(name);
+    }
     fire(id_1) {
         return __awaiter(this, arguments, void 0, function* (id, opts = {}) {
             var _a, _b;
@@ -420,7 +692,13 @@ export class ReminderRunner {
                     return { outcome: "noop", reason: "not_due" };
                 }
                 const live = (_a = this.handlers.get(id)) !== null && _a !== void 0 ? _a : {};
-                if ((record.hasRunHandler === true || record.hasUntilFn === true) &&
+                if (record.handler !== undefined) {
+                    if (this.resolveNamedHandler(record.handler) === undefined) {
+                        yield this.disarm(record, "handler_missing");
+                        return { outcome: "noop", reason: "handler_missing" };
+                    }
+                }
+                else if ((record.hasRunHandler === true || record.hasUntilFn === true) &&
                     live.run === undefined &&
                     live.untilFn === undefined) {
                     yield this.disarm(record, "handler_lost_on_restart");
@@ -452,9 +730,16 @@ export class ReminderRunner {
                     }
                 }
                 let result;
-                if (live.run !== undefined) {
-                    const fireCtx = this.buildFireContext(record);
-                    result = yield live.run(fireCtx);
+                if (record.handler !== undefined) {
+                    const named = this.resolveNamedHandler(record.handler);
+                    if (named === undefined) {
+                        yield this.disarm(record, "handler_missing");
+                        return { outcome: "noop", reason: "handler_missing" };
+                    }
+                    result = yield named.run(this.buildFireContext(record));
+                }
+                else if (live.run !== undefined) {
+                    result = yield live.run(this.buildFireContext(record));
                 }
                 else if (record.prompt !== undefined) {
                     result = yield this.deliverPrompt(record);
@@ -485,7 +770,7 @@ export class ReminderRunner {
                     return { outcome: "fired", reason: "skipped" };
                 }
                 yield this.afterFire(latest, "delivered", result.reschedule);
-                this.logger(`[agent-sdk] reminder "${id}" (${record.purpose}) delivered`);
+                this.logger(`[agent-sdk] reminder "${id}" (${record.purpose}) fired`);
                 return { outcome: "fired", reason: "delivered" };
             }
             finally {
@@ -534,19 +819,51 @@ export class ReminderRunner {
         return __awaiter(this, void 0, void 0, function* () {
             const auth = yield this.resolveFollowupAuth(record.channelId, record.continuationToken);
             if (auth === undefined) {
-                yield this.disarm(record, "session_gone");
+                // Under CP protocol, return stop and let the CP apply/CAS; do not
+                // mutate authoritative status from the guest mid-fire.
+                if (!this.usesControlPlaneProtocol) {
+                    yield this.disarm(record, "session_gone");
+                }
                 return { action: "stop" };
             }
             return this.sendFollowup(record, buildFirePrompt(record), auth);
         });
     }
+    /**
+     * Join the reminder's existing session. Control-plane (`/v2`) channels
+     * refuse authored `continuationToken`; pass the stored key as
+     * {@link EngineSendOptions.mailboxContinuation} so the engine reuses the
+     * CP-selected identity without channel admission.
+     */
+    followupSendOptions(record, auth) {
+        if (this.channelUsesControlPlaneContinuation(record.channelId)) {
+            return {
+                auth,
+                mailboxContinuation: { key: record.continuationToken },
+            };
+        }
+        return {
+            auth,
+            continuationToken: record.continuationToken,
+        };
+    }
+    channelUsesControlPlaneContinuation(channelId) {
+        var _a;
+        const project = this.engine.project;
+        // Test doubles may omit `project`; keep the legacy continuationToken path.
+        if (project === undefined) {
+            return false;
+        }
+        const identity = channelId === HTTP_CHANNEL_ID
+            ? httpContinuationIdentity(project.httpChannel)
+            : channelContinuationIdentity((_a = project.channels.find((channel) => channel.id === channelId)) === null || _a === void 0 ? void 0 : _a.definition);
+        return continuationSource(identity) === "control-plane";
+    }
     sendFollowup(record, message, auth) {
         return __awaiter(this, void 0, void 0, function* () {
+            const sendOptions = this.followupSendOptions(record, auth);
             try {
-                const session = yield this.engine.send(record.channelId, message, {
-                    auth,
-                    continuationToken: record.continuationToken,
-                });
+                const session = yield this.engine.send(record.channelId, message, sendOptions);
                 this.engine.trackBackground(this.engine.waitForCompletion(session.id));
                 return { action: "delivered" };
             }
@@ -557,10 +874,7 @@ export class ReminderRunner {
                     }
                     yield this.whenSessionIdle(record.channelId, record.continuationToken);
                     try {
-                        const session = yield this.engine.send(record.channelId, message, {
-                            auth,
-                            continuationToken: record.continuationToken,
-                        });
+                        const session = yield this.engine.send(record.channelId, message, sendOptions);
                         this.engine.trackBackground(this.engine.waitForCompletion(session.id));
                         return { action: "delivered" };
                     }
@@ -576,13 +890,14 @@ export class ReminderRunner {
         });
     }
     buildFireContext(record) {
-        var _a;
+        var _a, _b;
         const self = this;
         return {
             id: record.id,
             purpose: record.purpose,
             fireCount: record.fireCount,
             target: Object.assign({ channelId: record.channelId, continuationToken: record.continuationToken }, ((_a = record.target) !== null && _a !== void 0 ? _a : {})),
+            args: (_b = record.args) !== null && _b !== void 0 ? _b : {},
             host: this.engine.host,
             mcp: this.engine.host.mcp,
             appAuth: APP_AUTH,

package/dist/internal/reminder-schedule.d.ts

@@ -13,8 +13,11 @@ export interface ResolvedSchedule {
     intervalMs?: number;
     nextFireAtMs: number;
 }
-/** Resolve create-input schedule fields into a concrete next-fire plan. */
-export declare function resolveSchedule(input: ReminderCreateInput): ResolvedSchedule;
+/**
+ * Resolve create-input schedule fields into a concrete next-fire plan.
+ * Pass `nowMs` for deterministic CP / test resolution; CP owns this call.
+ */
+export declare function resolveSchedule(input: Pick<ReminderCreateInput, "every" | "cron" | "delay" | "at">, nowMs?: number): ResolvedSchedule;
 /** Next UTC fire strictly after `afterMs` for a 5-field cron. */
 export declare function nextCronFireMs(cronSource: string, afterMs: number): number;
 /** Default busy policy: recurring may skip; one-shots queue behind the turn. */

package/dist/internal/reminder-schedule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reminder-schedule.d.ts","sourceRoot":"","sources":["../../src/internal/reminder-schedule.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAI7E,qBAAa,uBAAwB,SAAQ,KAAK;IAChD,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAED,4EAA4E;AAC5E,eAAO,MAAM,YAAY,aAAgB,CAAC;AAE1C,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,oBAAoB,CAAC;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,2EAA2E;AAC3E,wBAAgB,eAAe,CAAC,KAAK,EAAE,mBAAmB,GAAG,gBAAgB,CA2D5E;AAED,iEAAiE;AACjE,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAU1E;AAED,gFAAgF;AAChF,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,oBAAoB,GACzB,YAAY,GAAG,iBAAiB,CAElC"}
+{"version":3,"file":"reminder-schedule.d.ts","sourceRoot":"","sources":["../../src/internal/reminder-schedule.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAI7E,qBAAa,uBAAwB,SAAQ,KAAK;IAChD,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAED,4EAA4E;AAC5E,eAAO,MAAM,YAAY,aAAgB,CAAC;AAE1C,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,oBAAoB,CAAC;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,IAAI,CAAC,mBAAmB,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC,EACnE,KAAK,GAAE,MAAmB,GACzB,gBAAgB,CA0DlB;AAED,iEAAiE;AACjE,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAU1E;AAED,gFAAgF;AAChF,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,oBAAoB,GACzB,YAAY,GAAG,iBAAiB,CAElC"}