@cursor/july 0.1.105 → 0.1.108

package/dist/internal/legacy-command-guard.js

@@ -0,0 +1,51 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { DeployApiError, } from "./deploy-client.js";
+/**
+ * Classify a hosted slug by probing the v2 control plane.
+ *
+ * Only HTTP 404 means “not v2.” Auth, 5xx, and transport errors fail closed
+ * so a v2 slug cannot fall through to `/internal/agent-serve`. That probe
+ * shares the factory microlith path used by secrets; a factory outage will
+ * also block legacy `--prod` until it recovers.
+ */
+export function deploymentArchitecture(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield args.client.getAgentkitDeploy({
+                teamId: args.teamId,
+                slug: args.slug,
+            });
+            return "v2";
+        }
+        catch (error) {
+            if (error instanceof DeployApiError && error.status === 404) {
+                return "v1";
+            }
+            throw error;
+        }
+    });
+}
+export function unsupportedV2LegacyCommandError(slug) {
+    return new DeployApiError(`This command is not supported for architecture v2 deployment "${slug}". The command stopped before calling the legacy v1 deployment API.`, 409);
+}
+export function isUnsupportedV2LegacyCommandError(error) {
+    return (error instanceof DeployApiError &&
+        error.status === 409 &&
+        error.message.includes("not supported for architecture v2"));
+}
+export function rejectV2ForLegacyCommand(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const architecture = yield deploymentArchitecture(args);
+        if (architecture === "v2") {
+            throw unsupportedV2LegacyCommandError(args.slug);
+        }
+    });
+}

package/dist/internal/local-control-plane.d.ts

@@ -3,6 +3,12 @@
  * and reminder documents + clocks, then fires into the kit the same way the
  * Cursor backend does over HTTP when `--no-control-plane` is set.
  *
+ * Reminder lifecycle (protocol v1): CP assigns id, arms timers, claims a due
+ * fire once, invokes a guest executor with an immutable descriptor, and
+ * applies the outcome with generation/fireCount CAS. Cancel/rekey racing an
+ * in-flight execution bumps generation so a stale outcome cannot resurrect
+ * the reminder. Legacy `fireReminder(id, fireCount)` remains for v1 runners.
+ *
  * v2 ingest lives here: `routeContinuation` stamps the mailbox (July twin
  * of hosted `routeVerifiedIngressContinuation`), and `attachScmEvents`
  * owns the `/v0/scm-events` long poll. v1 keeps engine-side scm-events.
@@ -10,7 +16,8 @@
  */
 import { type LocalIngressContinuation, type RouteLocalIngressContinuationInput } from "./local-ingress.js";
 import type { PlatformTimers } from "./platform-timers.js";
-export interface LocalControlPlane extends PlatformTimers {
+import { type ReminderControlPlane, type ReminderGuestExecutor } from "./reminder-control-plane-protocol.js";
+export interface LocalControlPlane extends PlatformTimers, ReminderControlPlane {
     /**
      * Stamp a v2 mailbox from the channel selector + live payload. Same
      * contract as hosted verified ingress. `/v1` is a no-op.
@@ -30,7 +37,16 @@ export interface LocalControlPlane extends PlatformTimers {
 }
 export declare function createLocalControlPlane(opts: {
     fireSchedule: (name: string) => Promise<unknown>;
-    fireReminder: (id: string, fireCount: number) => Promise<unknown>;
+    /**
+     * Legacy v1 path: CP calls this with (id, fireCount) and the runner mutates
+     * authoritative state. Prefer {@link executeReminder} for architecture v2.
+     */
+    fireReminder?: (id: string, fireCount: number) => Promise<unknown>;
+    /**
+     * Protocol guest executor. When set, due timers claim once, invoke this
+     * with an immutable descriptor, and apply the returned outcome via CAS.
+     */
+    executeReminder?: ReminderGuestExecutor;
     /**
      * Persist reminder documents under `<stateDir>/reminders`. Local serve
      * passes `<stateRoot>/control-plane`.

package/dist/internal/local-control-plane.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"local-control-plane.d.ts","sourceRoot":"","sources":["../../src/internal/local-control-plane.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,kCAAkC,EAExC,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAI3D,MAAM,WAAW,iBAAkB,SAAQ,cAAc;IACvD;;;OAGG;IACH,iBAAiB,CACf,KAAK,EAAE,kCAAkC,GACxC,wBAAwB,CAAC;IAC5B;;;OAGG;IACH,eAAe,CAAC,KAAK,EAAE;QAAE,KAAK,IAAI,IAAI,CAAC;QAAC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;KAAE,GAAG,IAAI,CAAC;IACvE,yEAAyE;IACzE,WAAW,IAAI,IAAI,CAAC;IACpB,IAAI,IAAI,IAAI,CAAC;CACd;AAED,wBAAsB,uBAAuB,CAAC,IAAI,EAAE;IAClD,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACjD,YAAY,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAClE;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6DAA6D;IAC7D,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAsJ7B"}
+{"version":3,"file":"local-control-plane.d.ts","sourceRoot":"","sources":["../../src/internal/local-control-plane.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,kCAAkC,EAExC,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EAKL,KAAK,oBAAoB,EAIzB,KAAK,qBAAqB,EAI3B,MAAM,sCAAsC,CAAC;AAI9C,MAAM,WAAW,iBACf,SAAQ,cAAc,EACpB,oBAAoB;IACtB;;;OAGG;IACH,iBAAiB,CACf,KAAK,EAAE,kCAAkC,GACxC,wBAAwB,CAAC;IAC5B;;;OAGG;IACH,eAAe,CAAC,KAAK,EAAE;QAAE,KAAK,IAAI,IAAI,CAAC;QAAC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;KAAE,GAAG,IAAI,CAAC;IACvE,yEAAyE;IACzE,WAAW,IAAI,IAAI,CAAC;IACpB,IAAI,IAAI,IAAI,CAAC;CACd;AAED,wBAAsB,uBAAuB,CAAC,IAAI,EAAE;IAClD,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACjD;;;OAGG;IACH,YAAY,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACnE;;;OAGG;IACH,eAAe,CAAC,EAAE,qBAAqB,CAAC;IACxC;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6DAA6D;IAC7D,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC,GAAG,OAAO,CAAC,iBAAiB,CAAC,CA0X7B"}

package/dist/internal/local-control-plane.js

@@ -3,6 +3,12 @@
  * and reminder documents + clocks, then fires into the kit the same way the
  * Cursor backend does over HTTP when `--no-control-plane` is set.
  *
+ * Reminder lifecycle (protocol v1): CP assigns id, arms timers, claims a due
+ * fire once, invokes a guest executor with an immutable descriptor, and
+ * applies the outcome with generation/fireCount CAS. Cancel/rekey racing an
+ * in-flight execution bumps generation so a stale outcome cannot resurrect
+ * the reminder. Legacy `fireReminder(id, fireCount)` remains for v1 runners.
+ *
  * v2 ingest lives here: `routeContinuation` stamps the mailbox (July twin
  * of hosted `routeVerifiedIngressContinuation`), and `attachScmEvents`
  * owns the `/v0/scm-events` long poll. v1 keeps engine-side scm-events.
@@ -20,11 +26,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { join } from "node:path";
 import { parseCron } from "./cron.js";
 import { routeLocalIngressContinuation, } from "./local-ingress.js";
+import { applyOutcomeToRecord, claimFromDescriptor, intentToNewRecord, REMINDER_CP_PROTOCOL_VERSION, recordGeneration, toFireDescriptor, } from "./reminder-control-plane-protocol.js";
 import { MAX_TIMER_MS } from "./reminder-schedule.js";
 import { ReminderStore } from "./reminder-store.js";
 export function createLocalControlPlane(opts) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a, _b;
+        if (opts.fireReminder === undefined && opts.executeReminder === undefined) {
+            throw new Error("createLocalControlPlane requires fireReminder and/or executeReminder");
+        }
         const logger = (_a = opts.logger) !== null && _a !== void 0 ? _a : (() => { });
         const armReminderClocks = opts.armReminderClocks !== false;
         const store = opts.stateDir === undefined
@@ -32,10 +42,21 @@ export function createLocalControlPlane(opts) {
             : new ReminderStore(join(opts.stateDir, "reminders"));
         const schedules = new Map();
         const reminderTimers = new Map();
-        const reminders = new Map(((_b = (yield store === null || store === void 0 ? void 0 : store.list())) !== null && _b !== void 0 ? _b : []).map((record) => [record.id, record]));
+        const reminders = new Map(((_b = (yield store === null || store === void 0 ? void 0 : store.list())) !== null && _b !== void 0 ? _b : []).map((record) => { var _a; return [
+            record.id,
+            Object.assign(Object.assign({}, record), { generation: (_a = record.generation) !== null && _a !== void 0 ? _a : 0 }),
+        ]; }));
+        /** In-flight claims keyed by reminder id (single-flight per id). */
+        const inflight = new Map();
         let scheduleTimer;
         let lastFiredMinute = -1;
         let scmRelay;
+        function persist(record) {
+            return __awaiter(this, void 0, void 0, function* () {
+                reminders.set(record.id, record);
+                yield store === null || store === void 0 ? void 0 : store.save(record);
+            });
+        }
         function armScheduleTicker() {
             var _a;
             if (scheduleTimer !== undefined || schedules.size === 0) {
@@ -80,10 +101,96 @@ export function createLocalControlPlane(opts) {
         function armReminder(record) {
             var _a;
             clearReminderTimer(record.id);
+            if (record.status !== "armed") {
+                return;
+            }
             const delay = Math.min(MAX_TIMER_MS, Math.max(0, record.nextFireAtMs - Date.now()));
             const timer = setTimeout(() => {
                 reminderTimers.delete(record.id);
-                const current = reminders.get(record.id);
+                void onReminderDue(record.id).catch((error) => {
+                    logger(`[agent-sdk] reminder "${record.id}" dispatch failed: ${error instanceof Error ? error.message : String(error)}`);
+                });
+            }, delay);
+            (_a = timer.unref) === null || _a === void 0 ? void 0 : _a.call(timer);
+            reminderTimers.set(record.id, timer);
+        }
+        function claimDue(id) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const current = reminders.get(id);
+                if (current === undefined || current.status !== "armed") {
+                    return undefined;
+                }
+                if (current.nextFireAtMs > Date.now() + 50) {
+                    armReminder(current);
+                    return undefined;
+                }
+                if (inflight.has(id)) {
+                    return undefined;
+                }
+                const claimed = Object.assign(Object.assign({}, current), { status: "firing", generation: recordGeneration(current), updatedAt: new Date().toISOString() });
+                yield persist(claimed);
+                inflight.set(id, {
+                    id: claimed.id,
+                    fireCount: claimed.fireCount,
+                    generation: recordGeneration(claimed),
+                });
+                return claimed;
+            });
+        }
+        function applyReminderOutcome(claim, outcome) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const current = reminders.get(claim.id);
+                if (current === undefined) {
+                    inflight.delete(claim.id);
+                    return { applied: false, reason: "missing" };
+                }
+                const result = applyOutcomeToRecord(current, claim, outcome);
+                inflight.delete(claim.id);
+                if (!result.applied) {
+                    if (current.status === "armed" && armReminderClocks) {
+                        armReminder(current);
+                    }
+                    return result;
+                }
+                yield persist(result.record);
+                if (armReminderClocks && result.record.status === "armed") {
+                    armReminder(result.record);
+                }
+                else {
+                    clearReminderTimer(result.record.id);
+                }
+                return result;
+            });
+        }
+        function onReminderDue(id) {
+            return __awaiter(this, void 0, void 0, function* () {
+                // Protocol path: claim → guest execute → CAS apply.
+                if (opts.executeReminder !== undefined) {
+                    const claimed = yield claimDue(id);
+                    if (claimed === undefined) {
+                        return;
+                    }
+                    const descriptor = toFireDescriptor(claimed, Date.now());
+                    let outcome;
+                    try {
+                        outcome = yield opts.executeReminder(descriptor);
+                    }
+                    catch (error) {
+                        logger(`[agent-sdk] reminder "${id}" guest execution failed: ${error instanceof Error ? error.message : String(error)}`);
+                        outcome = {
+                            kind: "retry",
+                            delayMs: 1000,
+                            reason: "guest_error",
+                        };
+                    }
+                    const result = yield applyReminderOutcome(claimFromDescriptor(descriptor), outcome);
+                    if (!result.applied) {
+                        logger(`[agent-sdk] reminder "${id}" outcome not applied: ${result.reason}`);
+                    }
+                    return;
+                }
+                // Legacy v1: do not claim/firing — runner mutates via putReminder after fire.
+                const current = reminders.get(id);
                 if (current === undefined || current.status !== "armed") {
                     return;
                 }
@@ -91,14 +198,16 @@ export function createLocalControlPlane(opts) {
                     armReminder(current);
                     return;
                 }
-                void opts.fireReminder(current.id, current.fireCount).catch((error) => {
-                    logger(`[agent-sdk] reminder "${current.id}" dispatch failed: ${error instanceof Error ? error.message : String(error)}`);
-                });
-            }, delay);
-            (_a = timer.unref) === null || _a === void 0 ? void 0 : _a.call(timer);
-            reminderTimers.set(record.id, timer);
+                try {
+                    yield opts.fireReminder(current.id, current.fireCount);
+                }
+                catch (error) {
+                    logger(`[agent-sdk] reminder "${id}" dispatch failed: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            });
         }
         return {
+            protocolVersion: REMINDER_CP_PROTOCOL_VERSION,
             routeContinuation: routeLocalIngressContinuation,
             attachScmEvents(relay) {
                 scmRelay = relay;
@@ -121,13 +230,17 @@ export function createLocalControlPlane(opts) {
             },
             putReminder(record) {
                 return __awaiter(this, void 0, void 0, function* () {
-                    reminders.set(record.id, record);
-                    yield store === null || store === void 0 ? void 0 : store.save(record);
-                    if (armReminderClocks && record.status === "armed") {
-                        armReminder(record);
+                    var _a;
+                    const normalized = Object.assign(Object.assign({}, record), { generation: (_a = record.generation) !== null && _a !== void 0 ? _a : 0 });
+                    yield persist(normalized);
+                    if (armReminderClocks && normalized.status === "armed") {
+                        armReminder(normalized);
                         return;
                     }
-                    clearReminderTimer(record.id);
+                    clearReminderTimer(normalized.id);
+                    if (normalized.status !== "firing") {
+                        inflight.delete(normalized.id);
+                    }
                 });
             },
             getReminder(id) {
@@ -143,16 +256,84 @@ export function createLocalControlPlane(opts) {
             deleteReminder(id) {
                 return __awaiter(this, void 0, void 0, function* () {
                     clearReminderTimer(id);
+                    inflight.delete(id);
                     reminders.delete(id);
                     yield store === null || store === void 0 ? void 0 : store.delete(id);
                 });
             },
+            createReminder(intent) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    if (intent.protocolVersion !== REMINDER_CP_PROTOCOL_VERSION) {
+                        throw new Error(`Unsupported reminder CP protocol version ${String(intent.protocolVersion)}`);
+                    }
+                    const record = intentToNewRecord(intent);
+                    yield persist(record);
+                    if (armReminderClocks && record.status === "armed") {
+                        armReminder(record);
+                    }
+                    return record;
+                });
+            },
+            cancelReminder(id_1) {
+                return __awaiter(this, arguments, void 0, function* (id, reason = "explicit_cancel") {
+                    const current = reminders.get(id);
+                    if (current === undefined) {
+                        return undefined;
+                    }
+                    if (current.status === "completed" ||
+                        current.status === "cancelled" ||
+                        current.status === "disarmed") {
+                        return current;
+                    }
+                    clearReminderTimer(id);
+                    inflight.delete(id);
+                    const updated = Object.assign(Object.assign({}, current), { status: "cancelled", disarmReason: reason, generation: recordGeneration(current) + 1, updatedAt: new Date().toISOString() });
+                    yield persist(updated);
+                    return updated;
+                });
+            },
+            rekeyReminders(channelId, oldToken, newToken) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    let n = 0;
+                    for (const record of [...reminders.values()]) {
+                        if (record.channelId !== channelId ||
+                            record.continuationToken !== oldToken) {
+                            continue;
+                        }
+                        if (record.status !== "armed" && record.status !== "firing") {
+                            continue;
+                        }
+                        const wasInflight = inflight.has(record.id);
+                        inflight.delete(record.id);
+                        let updated = Object.assign(Object.assign({}, record), { continuationToken: newToken, status: "armed", generation: recordGeneration(record) + 1, updatedAt: new Date().toISOString() });
+                        // Interrupted in-flight fire: retry the same fireCount soon.
+                        if (wasInflight) {
+                            updated = Object.assign(Object.assign({}, updated), { nextFireAtMs: Math.min(updated.nextFireAtMs, Date.now()) });
+                        }
+                        yield persist(updated);
+                        if (armReminderClocks) {
+                            armReminder(updated);
+                        }
+                        n += 1;
+                    }
+                    return n;
+                });
+            },
+            applyReminderOutcome,
             startClocks() {
-                if (!armReminderClocks) {
-                    return;
-                }
                 for (const record of reminders.values()) {
-                    if (record.status === "armed") {
+                    if (record.status === "firing") {
+                        // Restart hydration: treat interrupted fires as armed for retry
+                        // even when clocks are not armed (status must still recover).
+                        const restored = Object.assign(Object.assign({}, record), { status: "armed", updatedAt: new Date().toISOString() });
+                        void persist(restored).then(() => {
+                            if (armReminderClocks) {
+                                armReminder(restored);
+                            }
+                        });
+                        continue;
+                    }
+                    if (armReminderClocks && record.status === "armed") {
                         armReminder(record);
                     }
                 }
@@ -162,6 +343,7 @@ export function createLocalControlPlane(opts) {
                 for (const id of [...reminderTimers.keys()]) {
                     clearReminderTimer(id);
                 }
+                inflight.clear();
                 if (scmRelay !== undefined) {
                     void scmRelay.stop();
                     scmRelay = undefined;

package/dist/internal/platform-timers.d.ts

@@ -7,6 +7,7 @@
  * The control plane owns reminder *documents* and clocks. The kit only
  * executes fires.
  */
+import { type ReminderControlPlane } from "./reminder-control-plane-protocol.js";
 import { type ReminderRecord } from "./reminder-store.js";
 export interface PlatformTimers {
     upsertSchedule(input: {
@@ -25,4 +26,10 @@ export interface CursorHostedPlatformTimersOptions {
     fetch?: typeof fetch;
 }
 export declare function createCursorHostedPlatformTimers(options?: CursorHostedPlatformTimersOptions): PlatformTimers;
+/**
+ * Cursor-hosted HTTP ReminderControlPlane for architecture v2.
+ * Speaks factory `/internal/agentsdk/reminders` (ELB → factory ECS).
+ * CP owns ids and time. v1 PUT/DELETE reminders stay on timed-work.
+ */
+export declare function createCursorHostedReminderControlPlane(options?: CursorHostedPlatformTimersOptions): ReminderControlPlane;
 //# sourceMappingURL=platform-timers.d.ts.map

package/dist/internal/platform-timers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"platform-timers.d.ts","sourceRoot":"","sources":["../../src/internal/platform-timers.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAoB,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAI5E,MAAM,WAAW,cAAc;IAC7B,cAAc,CAAC,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrE,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C,WAAW,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnD,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC,CAAC;IAC7D,aAAa,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC,CAAC;IAC3C,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3C;AAED,MAAM,WAAW,iCAAiC;IAChD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;CACtB;AAqED,wBAAgB,gCAAgC,CAC9C,OAAO,GAAE,iCAAsC,GAC9C,cAAc,CA0EhB"}
+{"version":3,"file":"platform-timers.d.ts","sourceRoot":"","sources":["../../src/internal/platform-timers.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAEL,KAAK,oBAAoB,EAK1B,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAoB,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAI5E,MAAM,WAAW,cAAc;IAC7B,cAAc,CAAC,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrE,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C,WAAW,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnD,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC,CAAC;IAC7D,aAAa,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC,CAAC;IAC3C,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3C;AAED,MAAM,WAAW,iCAAiC;IAChD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;CACtB;AAqED,wBAAgB,gCAAgC,CAC9C,OAAO,GAAE,iCAAsC,GAC9C,cAAc,CA0EhB;AA0DD;;;;GAIG;AACH,wBAAgB,sCAAsC,CACpD,OAAO,GAAE,iCAAsC,GAC9C,oBAAoB,CAsHtB"}

package/dist/internal/platform-timers.js

@@ -16,6 +16,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+import { REMINDER_CP_PROTOCOL_VERSION, } from "./reminder-control-plane-protocol.js";
 import { isReminderRecord } from "./reminder-store.js";
 const DEFAULT_CURSOR_EXTERNAL_API_URL = "https://api.cursor.com";
 function resolveApiKey(options) {
@@ -118,3 +119,141 @@ export function createCursorHostedPlatformTimers(options = {}) {
         },
     };
 }
+/** v2 reminder CP is factory ECS (`/internal/agentsdk/*`), not timed-work. */
+const AGENTSDK_REMINDERS_PREFIX = "/internal/agentsdk";
+/**
+ * Bounded retries for idempotent CP outcome writes after the guest handler
+ * has already run. Delivery is at-least-once: a transient apply failure may
+ * re-enter the handler on the next Temporal admission. Do not claim
+ * exactly-once handler execution.
+ */
+const APPLY_REMINDER_OUTCOME_MAX_ATTEMPTS = 3;
+const APPLY_REMINDER_OUTCOME_RETRY_DELAY_MS = 50;
+function sleepMs(ms) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield new Promise((resolve) => setTimeout(resolve, ms));
+    });
+}
+function withBoundedApplyRetries(run) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let lastError;
+        for (let attempt = 1; attempt <= APPLY_REMINDER_OUTCOME_MAX_ATTEMPTS; attempt++) {
+            try {
+                return yield run();
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt >= APPLY_REMINDER_OUTCOME_MAX_ATTEMPTS) {
+                    break;
+                }
+                yield sleepMs(APPLY_REMINDER_OUTCOME_RETRY_DELAY_MS * attempt);
+            }
+        }
+        throw lastError;
+    });
+}
+function timedWorkJsonFetch(options, method, path, body) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const fetchImpl = (_a = options.fetch) !== null && _a !== void 0 ? _a : globalThis.fetch;
+        if (typeof fetchImpl !== "function") {
+            throw new Error("reminder control plane requires fetch");
+        }
+        return fetchImpl(`${resolveBaseUrl(options)}${path}`, Object.assign({ method, headers: Object.assign({ Authorization: `Bearer ${resolveApiKey(options)}` }, (body === undefined ? {} : { "Content-Type": "application/json" })) }, (body === undefined ? {} : { body: JSON.stringify(body) })));
+    });
+}
+/**
+ * Cursor-hosted HTTP ReminderControlPlane for architecture v2.
+ * Speaks factory `/internal/agentsdk/reminders` (ELB → factory ECS).
+ * CP owns ids and time. v1 PUT/DELETE reminders stay on timed-work.
+ */
+export function createCursorHostedReminderControlPlane(options = {}) {
+    return {
+        protocolVersion: REMINDER_CP_PROTOCOL_VERSION,
+        createReminder(intent) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const response = yield timedWorkJsonFetch(options, "POST", `${AGENTSDK_REMINDERS_PREFIX}/reminders`, intent);
+                if (!response.ok) {
+                    const text = yield response.text();
+                    throw new Error(`reminder CP create failed: HTTP ${response.status} ${text}`);
+                }
+                const parsed = yield response.json();
+                if (!isReminderRecord(parsed)) {
+                    throw new Error("reminder CP create returned invalid record");
+                }
+                return parsed;
+            });
+        },
+        getReminder(id) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const response = yield timedWorkJsonFetch(options, "GET", `${AGENTSDK_REMINDERS_PREFIX}/reminders/${encodeURIComponent(id)}`);
+                if (response.status === 404) {
+                    return undefined;
+                }
+                if (!response.ok) {
+                    throw new Error(`reminder CP get failed: HTTP ${response.status}`);
+                }
+                const parsed = yield response.json();
+                return isReminderRecord(parsed) ? parsed : undefined;
+            });
+        },
+        listReminders() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const response = yield timedWorkJsonFetch(options, "GET", `${AGENTSDK_REMINDERS_PREFIX}/reminders`);
+                if (!response.ok) {
+                    throw new Error(`reminder CP list failed: HTTP ${response.status}`);
+                }
+                const parsed = yield response.json();
+                if (parsed === null ||
+                    typeof parsed !== "object" ||
+                    !("reminders" in parsed) ||
+                    !Array.isArray(parsed.reminders)) {
+                    return [];
+                }
+                return parsed.reminders.filter(isReminderRecord);
+            });
+        },
+        cancelReminder(id, reason) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const response = yield timedWorkJsonFetch(options, "POST", `${AGENTSDK_REMINDERS_PREFIX}/reminders/${encodeURIComponent(id)}/cancel`, reason === undefined ? {} : { reason });
+                if (response.status === 404) {
+                    return undefined;
+                }
+                if (!response.ok) {
+                    throw new Error(`reminder CP cancel failed: HTTP ${response.status}`);
+                }
+                const parsed = yield response.json();
+                return isReminderRecord(parsed) ? parsed : undefined;
+            });
+        },
+        rekeyReminders(channelId, oldToken, newToken) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const response = yield timedWorkJsonFetch(options, "POST", `${AGENTSDK_REMINDERS_PREFIX}/reminders/rekey`, { channelId, oldToken, newToken });
+                if (!response.ok) {
+                    throw new Error(`reminder CP rekey failed: HTTP ${response.status}`);
+                }
+                const parsed = yield response.json();
+                if (parsed === null ||
+                    typeof parsed !== "object" ||
+                    typeof parsed.count !== "number") {
+                    throw new Error("reminder CP rekey returned invalid body");
+                }
+                return parsed.count;
+            });
+        },
+        applyReminderOutcome(claim, outcome) {
+            return __awaiter(this, void 0, void 0, function* () {
+                // Handler side effects may already have run; retry only the idempotent
+                // CP write. Exhausted failures stay thrown so Temporal can re-admit
+                // (at-least-once — not exactly-once).
+                return yield withBoundedApplyRetries(() => __awaiter(this, void 0, void 0, function* () {
+                    const response = yield timedWorkJsonFetch(options, "POST", `${AGENTSDK_REMINDERS_PREFIX}/reminders/outcome`, { claim, outcome });
+                    if (!response.ok) {
+                        throw new Error(`reminder CP outcome apply failed: HTTP ${response.status}`);
+                    }
+                    return (yield response.json());
+                }));
+            });
+        },
+    };
+}