@raybase/core 0.0.2 → 0.3.4

package/dist/agent-follow-up-store.js

@@ -0,0 +1,703 @@
+import { stableJson } from "./internal.js";
+import { id, integer, longText, raybaseSystemTable, text } from "./schema.js";
+import { nowIso, q, randomId } from "./sql.js";
+export const followUpStaleRunningMs = 10 * 60_000;
+export const followUpMaxDispatchAttempts = 5;
+export const followUpDispatchRecencyMs = 24 * 60 * 60_000;
+export const followUpDispatchClaimLeaseMs = 60_000;
+export const raybaseAgentFollowUpSystemTables = [
+    raybaseSystemTable("_agent_follow_ups", {
+        id: id(),
+        agentName: text({ required: true }),
+        key: text({ required: true }),
+        ownerKey: text(),
+        body: longText({ required: true }),
+        contextJson: longText(),
+        conversationJson: longText(),
+        dueAt: text({ required: true }),
+        idleAfterMs: integer(),
+        notLaterThan: text(),
+        wakeOnEvent: text(),
+        wakeOnMatchJson: longText(),
+        wokeBy: text(),
+        wokeEvent: text(),
+        wokeEventId: text(),
+        wokePayloadJson: longText(),
+        wokeAt: text(),
+        onDue: text({ required: true }),
+        fallbackEveryMs: integer(),
+        maxRuns: integer(),
+        status: text({ required: true }),
+        reason: longText(),
+        dispatchGeneration: integer({ required: true }),
+        dispatchAttempts: integer({ required: true }),
+        dispatchStartedAt: text(),
+        dispatchClaimToken: text(),
+        claimAcquiredAt: text(),
+        lastRunGeneration: integer(),
+        continuedGeneration: integer(),
+        runCount: integer({ required: true }),
+        lastRunAt: text(),
+        continuedAt: text(),
+        driftCount: integer({ required: true }),
+        lastDriftAt: text(),
+        settledAt: text(),
+        lapseHandledAt: text(),
+        lapseAttempts: integer({ required: true }),
+        createdBy: text({ required: true }),
+        requestedByConversationId: text(),
+        requestedByRunId: text(),
+        triggerEventId: text(),
+        createdAt: text({ required: true }),
+        updatedAt: text({ required: true })
+    }, {
+        label: "Agent follow-ups",
+        indexes: [
+            { columns: ["agentName", "key"], unique: true, where: "\"status\" = 'pending'" },
+            ["status", "dueAt"],
+            ["agentName", "status", "dueAt"],
+            ["agentName", "ownerKey"],
+            ["agentName", "createdAt"],
+            ["agentName", "status", "wakeOnEvent"]
+        ]
+    })
+];
+/** Reads one of this table's JSON columns without letting bad JSON break a dispatch. */
+export function parsedFollowUpJson(value) {
+    if (!value)
+        return null;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}
+export async function getAgentFollowUp(control, id) {
+    return (await control.first(`SELECT * FROM ${q("_agent_follow_ups")} WHERE "id" = ? LIMIT 1`, [id])) ?? null;
+}
+export async function listDueAgentFollowUps(control, input = {}) {
+    return control.all(`SELECT * FROM ${q("_agent_follow_ups")} WHERE "status" = 'pending' AND "dueAt" <= ? ORDER BY "dueAt" ASC LIMIT ?`, [input.now ?? nowIso(), Math.max(1, Math.min(500, input.limit ?? 100))]);
+}
+export async function listUnhandledLapsedAgentFollowUps(control, input = {}) {
+    return control.all(`SELECT * FROM ${q("_agent_follow_ups")}
+     WHERE "status" = 'lapsed' AND "lapseHandledAt" IS NULL AND "lapseAttempts" < 10
+     ORDER BY "updatedAt" ASC LIMIT ?`, [Math.max(1, Math.min(500, input.limit ?? 100))]);
+}
+export async function agentFollowUpAlarmWork(control) {
+    const pending = await control.first(`SELECT MIN("dueAt") AS "nextDueAt" FROM ${q("_agent_follow_ups")} WHERE "status" = 'pending'`);
+    const lapsed = await control.first(`SELECT 1 AS "present" FROM ${q("_agent_follow_ups")}
+     WHERE "status" = 'lapsed' AND "lapseHandledAt" IS NULL AND "lapseAttempts" < 10
+     LIMIT 1`);
+    const outstanding = await control.first(`SELECT 1 AS "present"
+     FROM ${q("_agent_follow_ups")} f
+     JOIN ${q("_agent_trigger_events")} e ON e."id" = f."triggerEventId"
+     WHERE e."triggerType" = 'follow-up'
+       AND e."status" IN ('queued','failed','running')
+       AND f."status" IN ('pending','fired')
+     LIMIT 1`);
+    return {
+        nextDueAt: pending?.nextDueAt ?? null,
+        hasUnhandledLapse: Boolean(lapsed?.present),
+        hasOutstandingDispatch: Boolean(outstanding?.present)
+    };
+}
+export async function settleDueLapse(control, input) {
+    const now = input.now ?? nowIso();
+    const wallNow = input.wallNow ?? now;
+    const claimToken = randomId("follow_up_lapse");
+    await control.run(`UPDATE ${q("_agent_follow_ups")}
+     SET "status" = 'lapsed', "settledAt" = ?, "dispatchClaimToken" = ?, "claimAcquiredAt" = ?, "updatedAt" = ?
+     WHERE "id" = ? AND "status" = 'pending' AND "dueAt" <= ?`, [now, claimToken, wallNow, now, input.id, now]);
+    const row = await getAgentFollowUp(control, input.id);
+    return row?.status === "lapsed" && row.dispatchClaimToken === claimToken ? row : null;
+}
+export async function claimRunOnceAgentFollowUp(control, input) {
+    const now = input.now ?? nowIso();
+    const wallNow = input.wallNow ?? now;
+    const claimToken = randomId("follow_up_generation");
+    await control.run(`UPDATE ${q("_agent_follow_ups")}
+     SET "status" = 'fired', "settledAt" = ?, "dispatchGeneration" = 1,
+         "dispatchAttempts" = 0, "dispatchStartedAt" = ?, "dispatchClaimToken" = ?, "claimAcquiredAt" = ?,
+         "triggerEventId" = ?, "updatedAt" = ?
+     WHERE "id" = ? AND "status" = 'pending' AND "onDue" = 'run' AND "fallbackEveryMs" IS NULL AND "dueAt" <= ?`, [now, wallNow, claimToken, wallNow, input.eventId, now, input.id, now]);
+    const row = await getAgentFollowUp(control, input.id);
+    return row?.status === "fired"
+        && row.triggerEventId === input.eventId
+        && row.dispatchClaimToken === claimToken
+        ? row
+        : null;
+}
+export async function claimContinuingAgentFollowUp(control, input) {
+    const now = input.now ?? nowIso();
+    const wallNow = input.wallNow ?? now;
+    const claimToken = randomId("follow_up_generation");
+    await control.run(
+    // A continuing chain starts a fresh wait with each generation, so the
+    // wake marks of the generation being dispatched are cleared here — the
+    // trigger envelope was already built from the row that carried them.
+    `UPDATE ${q("_agent_follow_ups")}
+     SET "dispatchGeneration" = ?, "dispatchAttempts" = 0, "dispatchStartedAt" = ?,
+         "dispatchClaimToken" = ?, "claimAcquiredAt" = ?, "triggerEventId" = ?, "dueAt" = ?, "updatedAt" = ?,
+         "wokeBy" = NULL, "wokeEvent" = NULL, "wokeEventId" = NULL, "wokePayloadJson" = NULL, "wokeAt" = NULL
+     WHERE "id" = ? AND "status" = 'pending' AND "fallbackEveryMs" IS NOT NULL
+       AND "dispatchGeneration" = ? AND "dueAt" <= ?`, [input.generation, wallNow, claimToken, wallNow, input.eventId, input.dueAt, now, input.id, input.expectedGeneration, now]);
+    const row = await getAgentFollowUp(control, input.id);
+    return row?.status === "pending"
+        && row.dispatchGeneration === input.generation
+        && row.triggerEventId === input.eventId
+        && row.dispatchClaimToken === claimToken
+        ? row
+        : null;
+}
+export async function claimAgentFollowUpDispatchAttempt(control, input) {
+    const now = input.now ?? nowIso();
+    const wallNow = input.wallNow ?? now;
+    const maxAttempts = Math.max(1, input.maxAttempts ?? followUpMaxDispatchAttempts);
+    const notBefore = new Date(Date.parse(wallNow) - (input.recencyMs ?? followUpDispatchRecencyMs)).toISOString();
+    const before = await getAgentFollowUp(control, input.id);
+    if (!before || before.triggerEventId !== input.eventId)
+        return null;
+    if (before.dispatchClaimToken?.startsWith("follow_up_dispatch_")
+        && Date.parse(before.claimAcquiredAt ?? "") > Date.parse(wallNow) - followUpDispatchClaimLeaseMs) {
+        return null;
+    }
+    const claimToken = randomId("follow_up_dispatch");
+    await control.run(`UPDATE ${q("_agent_follow_ups")}
+     SET "dispatchAttempts" = "dispatchAttempts" + 1, "dispatchClaimToken" = ?, "claimAcquiredAt" = ?, "updatedAt" = ?
+     WHERE "id" = ? AND "triggerEventId" = ? AND "status" IN ('pending','fired')
+       AND "dispatchAttempts" = ? AND "updatedAt" = ?
+       AND (("dispatchClaimToken" IS NULL AND ? IS NULL) OR "dispatchClaimToken" = ?)
+       AND "dispatchAttempts" < ? AND "dispatchStartedAt" >= ?`, [
+        claimToken,
+        wallNow,
+        now,
+        input.id,
+        input.eventId,
+        before.dispatchAttempts,
+        before.updatedAt,
+        before.dispatchClaimToken,
+        before.dispatchClaimToken,
+        maxAttempts,
+        notBefore
+    ]);
+    const row = await getAgentFollowUp(control, input.id);
+    return row?.triggerEventId === input.eventId && row.dispatchClaimToken === claimToken ? row : null;
+}
+export async function abandonAgentFollowUpDispatch(control, input) {
+    const now = input.now ?? nowIso();
+    const wallNow = input.wallNow ?? now;
+    const reason = input.reason ?? "dispatch-attempts-exhausted";
+    const claimToken = randomId("follow_up_abandon");
+    await control.run(`UPDATE ${q("_agent_follow_ups")}
+     SET "status" = 'closed', "reason" = ?, "settledAt" = ?, "dispatchClaimToken" = ?, "claimAcquiredAt" = ?, "updatedAt" = ?
+     WHERE "id" = ? AND "triggerEventId" = ? AND "status" IN ('pending','fired')`, [reason, now, claimToken, wallNow, now, input.id, input.eventId]);
+    const row = await getAgentFollowUp(control, input.id);
+    return row?.status === "closed"
+        && row.triggerEventId === input.eventId
+        && row.dispatchClaimToken === claimToken
+        ? row
+        : null;
+}
+export async function parkContinuingAgentFollowUp(control, input) {
+    const now = input.now ?? nowIso();
+    await control.run(`UPDATE ${q("_agent_follow_ups")} SET "dueAt" = ?, "updatedAt" = ?
+     WHERE "id" = ? AND "status" = 'pending' AND "dispatchGeneration" = ?`, [input.dueAt, now, input.id, input.generation]);
+    const row = await getAgentFollowUp(control, input.id);
+    return row?.status === "pending" && row.dispatchGeneration === input.generation && row.dueAt === input.dueAt;
+}
+export async function getAgentFollowUpTriggerEvent(control, eventId) {
+    return control.first(`SELECT * FROM ${q("_agent_trigger_events")} WHERE "id" = ? AND "triggerType" = 'follow-up' LIMIT 1`, [eventId]);
+}
+export async function findAgentFollowUpTriggerEvent(control, idempotencyKey) {
+    return control.first(`SELECT * FROM ${q("_agent_trigger_events")}
+     WHERE "idempotencyKey" = ? AND "triggerType" = 'follow-up' LIMIT 1`, [idempotencyKey]);
+}
+async function findOrCreateAgentFollowUpTriggerEvent(control, input) {
+    const idempotencyKey = `follow_up:${input.row.id}:${input.generation}`;
+    const existing = await findAgentFollowUpTriggerEvent(control, idempotencyKey);
+    if (existing)
+        return existing;
+    const event = {
+        id: randomId("agent_evt"),
+        agentName: input.row.agentName,
+        triggerType: "follow-up",
+        triggerKey: `follow-up:${input.row.agentName}:${input.row.key}`,
+        sourceTable: null,
+        sourceOp: null,
+        rowId: null,
+        inputJson: stableJson({
+            trigger: {
+                type: "follow-up",
+                key: input.row.key,
+                ownerKey: input.row.ownerKey,
+                body: input.row.body,
+                context: input.row.contextJson ? JSON.parse(input.row.contextJson) : null,
+                conversation: input.row.conversationJson ? JSON.parse(input.row.conversationJson) : { mode: "new" },
+                mode: input.row.fallbackEveryMs === null ? "once" : "continuing",
+                runCount: input.row.runCount,
+                generation: input.generation,
+                maxRuns: input.row.maxRuns,
+                fallbackEveryMs: input.row.fallbackEveryMs,
+                createdBy: input.row.createdBy,
+                createdAt: input.row.createdAt,
+                drifted: input.row.driftCount > 0,
+                wakeOn: input.row.wakeOnEvent
+                    ? { event: input.row.wakeOnEvent, match: parsedFollowUpJson(input.row.wakeOnMatchJson) }
+                    : null,
+                wokeBy: input.row.wokeBy === "event" ? "event" : "deadline",
+                wokeEvent: input.row.wokeEvent,
+                wokeEventId: input.row.wokeEventId,
+                wokePayload: parsedFollowUpJson(input.row.wokePayloadJson),
+                wokeAt: input.row.wokeAt
+            },
+            followUpId: input.row.id,
+            scheduledAt: input.now
+        }),
+        idempotencyKey,
+        status: "queued",
+        runId: null,
+        error: null,
+        createdAt: input.wallNow,
+        updatedAt: input.wallNow
+    };
+    await control.run(`INSERT OR IGNORE INTO ${q("_agent_trigger_events")}
+      ("id", "agentName", "triggerType", "triggerKey", "sourceTable", "sourceOp", "rowId", "inputJson",
+       "idempotencyKey", "status", "runId", "error", "createdAt", "updatedAt")
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+        event.id,
+        event.agentName,
+        event.triggerType,
+        event.triggerKey,
+        event.sourceTable,
+        event.sourceOp,
+        event.rowId,
+        event.inputJson,
+        event.idempotencyKey,
+        event.status,
+        event.runId,
+        event.error,
+        event.createdAt,
+        event.updatedAt
+    ]);
+    const stored = await findAgentFollowUpTriggerEvent(control, idempotencyKey);
+    if (!stored)
+        throw new Error(`Failed to create Agent follow-up trigger event ${idempotencyKey}`);
+    return stored;
+}
+async function markAgentFollowUpTriggerEvent(control, eventId, input) {
+    await control.run(`UPDATE ${q("_agent_trigger_events")}
+     SET "status" = ?, "error" = ?, "updatedAt" = ?
+     WHERE "id" = ? AND "triggerType" = 'follow-up'`, [input.status, input.error ?? null, input.wallNow, eventId]);
+    return getAgentFollowUpTriggerEvent(control, eventId);
+}
+export async function releaseAgentFollowUpClaim(control, rowId, claimToken) {
+    await control.run(`UPDATE ${q("_agent_follow_ups")} SET "dispatchClaimToken" = NULL, "claimAcquiredAt" = NULL
+     WHERE "id" = ? AND "dispatchClaimToken" = ?`, [rowId, claimToken]);
+}
+export async function claimDueAgentFollowUps(control, input = {}) {
+    const now = input.now ?? nowIso();
+    const wallNow = input.wallNow ?? now;
+    const outcomes = [];
+    for (const candidate of await listDueAgentFollowUps(control, { now, limit: input.limit })) {
+        if (candidate.onDue === "lapse") {
+            const row = await settleDueLapse(control, { id: candidate.id, now, wallNow });
+            if (row)
+                outcomes.push({ type: "lapsed", row });
+            continue;
+        }
+        if (candidate.fallbackEveryMs !== null && candidate.triggerEventId) {
+            const currentEvent = await getAgentFollowUpTriggerEvent(control, candidate.triggerEventId);
+            if (currentEvent && currentEvent.status !== "completed" && currentEvent.status !== "skipped") {
+                const runningFresh = currentEvent.status === "running"
+                    && Date.parse(currentEvent.updatedAt) > Date.parse(wallNow) - followUpStaleRunningMs;
+                const attemptedRecently = Date.parse(currentEvent.updatedAt) > Date.parse(wallNow) - followUpDispatchClaimLeaseMs;
+                if (!runningFresh
+                    && !attemptedRecently
+                    && candidate.dispatchClaimToken?.startsWith("follow_up_dispatch_")) {
+                    await releaseAgentFollowUpClaim(control, candidate.id, candidate.dispatchClaimToken);
+                }
+                const dueAt = new Date(Date.parse(now) + candidate.fallbackEveryMs).toISOString();
+                const parked = await parkContinuingAgentFollowUp(control, {
+                    id: candidate.id,
+                    generation: candidate.dispatchGeneration,
+                    dueAt,
+                    now
+                });
+                if (!parked)
+                    continue;
+                if (!runningFresh && !attemptedRecently) {
+                    const row = await getAgentFollowUp(control, candidate.id);
+                    if (row) {
+                        outcomes.push({
+                            type: "dispatch",
+                            source: "outstanding",
+                            row,
+                            event: currentEvent,
+                            generation: candidate.dispatchGeneration
+                        });
+                    }
+                }
+                continue;
+            }
+        }
+        if (candidate.fallbackEveryMs !== null && candidate.maxRuns !== null && candidate.runCount >= candidate.maxRuns) {
+            const row = await closeAgentFollowUpForMaxRuns(control, { id: candidate.id, now, wallNow });
+            if (row)
+                outcomes.push({ type: "closed", reason: "max-runs", row, event: null });
+            continue;
+        }
+        const generation = candidate.fallbackEveryMs === null ? 1 : candidate.dispatchGeneration + 1;
+        const event = await findOrCreateAgentFollowUpTriggerEvent(control, { row: candidate, generation, now, wallNow });
+        const row = candidate.fallbackEveryMs === null
+            ? await claimRunOnceAgentFollowUp(control, { id: candidate.id, eventId: event.id, now, wallNow })
+            : await claimContinuingAgentFollowUp(control, {
+                id: candidate.id,
+                expectedGeneration: candidate.dispatchGeneration,
+                generation,
+                eventId: event.id,
+                dueAt: new Date(Date.parse(now) + candidate.fallbackEveryMs).toISOString(),
+                now,
+                wallNow
+            });
+        if (row)
+            outcomes.push({ type: "dispatch", source: "new", row, event, generation });
+    }
+    return outcomes;
+}
+export async function listOutstandingAgentFollowUpDispatches(control, input) {
+    const rows = await control.all(`SELECT f.*,
+            e."id" AS "eventId", e."agentName" AS "eventAgentName", e."triggerKey" AS "eventTriggerKey",
+            e."inputJson" AS "eventInputJson", e."idempotencyKey" AS "eventIdempotencyKey",
+            e."status" AS "eventStatus", e."runId" AS "eventRunId", e."error" AS "eventError",
+            e."createdAt" AS "eventCreatedAt", e."updatedAt" AS "eventUpdatedAt"
+     FROM ${q("_agent_follow_ups")} f
+     JOIN ${q("_agent_trigger_events")} e ON e."id" = f."triggerEventId"
+     WHERE e."triggerType" = 'follow-up'
+       AND e."idempotencyKey" LIKE 'follow_up:%'
+       AND e."status" IN ('queued','failed','running')
+       AND f."status" IN ('pending','fired')
+     ORDER BY e."updatedAt" ASC
+     LIMIT ?`, [Math.max(1, Math.min(500, input.limit ?? 100))]);
+    return rows.map((joined) => {
+        const { eventId, eventAgentName, eventTriggerKey, eventInputJson, eventIdempotencyKey, eventStatus, eventRunId, eventError, eventCreatedAt, eventUpdatedAt, ...row } = joined;
+        return {
+            row,
+            event: {
+                id: eventId,
+                agentName: eventAgentName,
+                triggerType: "follow-up",
+                triggerKey: eventTriggerKey,
+                sourceTable: null,
+                sourceOp: null,
+                rowId: null,
+                inputJson: eventInputJson,
+                idempotencyKey: eventIdempotencyKey,
+                status: eventStatus,
+                runId: eventRunId,
+                error: eventError,
+                createdAt: eventCreatedAt,
+                updatedAt: eventUpdatedAt
+            }
+        };
+    });
+}
+function agentFollowUpDispatchOrigin(event) {
+    if (!event.inputJson)
+        return null;
+    try {
+        const envelope = JSON.parse(event.inputJson);
+        if (!envelope || typeof envelope !== "object" || Array.isArray(envelope))
+            return null;
+        const origin = envelope.dispatchOrigin;
+        if (!origin || typeof origin !== "object" || Array.isArray(origin))
+            return null;
+        const claimedBy = origin.claimedBy;
+        const claimedAt = origin.claimedAt;
+        if ((claimedBy !== "sweep" && claimedBy !== "alarm") || typeof claimedAt !== "string")
+            return null;
+        return { claimedBy, claimedAt };
+    }
+    catch {
+        return null;
+    }
+}
+async function preserveAgentFollowUpDispatchOrigin(control, event, claimedBy) {
+    const existing = agentFollowUpDispatchOrigin(event);
+    if (existing || !claimedBy || !event.inputJson)
+        return { event, origin: existing };
+    let envelope;
+    try {
+        const parsed = JSON.parse(event.inputJson);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return { event, origin: null };
+        envelope = parsed;
+    }
+    catch {
+        return { event, origin: null };
+    }
+    const claimedAt = event.createdAt;
+    const inputJson = stableJson({
+        ...envelope,
+        dispatchOrigin: { claimedBy, claimedAt }
+    });
+    await control.run(`UPDATE ${q("_agent_trigger_events")}
+     SET "inputJson" = ?
+     WHERE "id" = ? AND "triggerType" = 'follow-up' AND "inputJson" = ?`, [inputJson, event.id, event.inputJson]);
+    const stored = (await getAgentFollowUpTriggerEvent(control, event.id)) ?? event;
+    return {
+        event: stored,
+        origin: agentFollowUpDispatchOrigin(stored)
+    };
+}
+async function dispatchAgentFollowUpRun(input) {
+    const claimed = await claimAgentFollowUpDispatchAttempt(input.control, {
+        id: input.claim.row.id,
+        eventId: input.claim.event.id,
+        now: input.now,
+        wallNow: input.wallNow
+    });
+    if (!claimed) {
+        const current = await getAgentFollowUp(input.control, input.claim.row.id);
+        const dispatchExpired = current
+            && current.triggerEventId === input.claim.event.id
+            && (current.dispatchAttempts >= followUpMaxDispatchAttempts
+                || Date.parse(current.dispatchStartedAt ?? "") < Date.parse(input.wallNow) - followUpDispatchRecencyMs);
+        if (!dispatchExpired)
+            return null;
+        const row = await abandonAgentFollowUpDispatch(input.control, {
+            id: input.claim.row.id,
+            eventId: input.claim.event.id,
+            now: input.now,
+            wallNow: input.wallNow
+        });
+        if (!row)
+            return null;
+        const event = await markAgentFollowUpTriggerEvent(input.control, input.claim.event.id, {
+            status: "skipped",
+            error: "Follow-up dispatch retry budget or recency window was exhausted",
+            wallNow: input.wallNow
+        });
+        return {
+            type: "closed",
+            reason: "dispatch-attempts-exhausted",
+            row,
+            event
+        };
+    }
+    const claimToken = claimed.dispatchClaimToken;
+    let persisted;
+    try {
+        persisted = await preserveAgentFollowUpDispatchOrigin(input.control, input.claim.event, input.claimedBy);
+    }
+    catch (error) {
+        await releaseAgentFollowUpClaim(input.control, claimed.id, claimToken);
+        throw error;
+    }
+    const dispatchOrigin = persisted.origin;
+    let delivery;
+    let event;
+    let retainSuccessfulClaim = false;
+    try {
+        await input.send({
+            kind: "raybase.agent.run",
+            version: 1,
+            eventId: persisted.event.id,
+            agentName: claimed.agentName,
+            triggerType: "follow-up",
+            ...(input.organizationId ? { organizationId: input.organizationId } : {}),
+            ...(dispatchOrigin ? {
+                claimedBy: dispatchOrigin.claimedBy,
+                claimedAt: dispatchOrigin.claimedAt
+            } : {})
+        });
+        event = await markAgentFollowUpTriggerEvent(input.control, persisted.event.id, {
+            status: "queued",
+            wallNow: input.wallNow
+        });
+        retainSuccessfulClaim = true;
+        delivery = { ok: true };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        event = await markAgentFollowUpTriggerEvent(input.control, persisted.event.id, {
+            status: "failed",
+            error: message,
+            wallNow: input.wallNow
+        });
+        delivery = { ok: false, error: message };
+    }
+    finally {
+        if (!retainSuccessfulClaim) {
+            await releaseAgentFollowUpClaim(input.control, claimed.id, claimToken);
+        }
+    }
+    return {
+        type: "dispatched",
+        source: input.claim.source,
+        row: (await getAgentFollowUp(input.control, claimed.id)) ?? claimed,
+        event: event ?? persisted.event,
+        generation: input.claim.generation,
+        delivery
+    };
+}
+export async function dispatchDueAgentFollowUps(input) {
+    const now = input.now ?? nowIso();
+    const wallNow = input.wallNow ?? now;
+    const limit = Math.max(1, Math.min(500, input.limit ?? 100));
+    const outcomes = [];
+    const attemptedEventIds = new Set();
+    const claims = await claimDueAgentFollowUps(input.control, { now, wallNow, limit });
+    for (const claim of claims) {
+        if (claim.type === "closed") {
+            outcomes.push(claim);
+            continue;
+        }
+        if (claim.type === "lapsed") {
+            try {
+                await input.send({
+                    kind: "raybase.agent.follow_up.lapse",
+                    version: 1,
+                    followUpId: claim.row.id,
+                    agentName: claim.row.agentName,
+                    ...(input.organizationId ? { organizationId: input.organizationId } : {}),
+                    ...(input.claimedBy ? { claimedBy: input.claimedBy, lapsedAt: claim.row.settledAt ?? claim.row.updatedAt } : {})
+                });
+                outcomes.push({ ...claim, delivery: { ok: true } });
+            }
+            catch (error) {
+                outcomes.push({
+                    ...claim,
+                    delivery: { ok: false, error: error instanceof Error ? error.message : String(error) }
+                });
+            }
+            continue;
+        }
+        attemptedEventIds.add(claim.event.id);
+        const outcome = await dispatchAgentFollowUpRun({
+            organizationId: input.organizationId,
+            control: input.control,
+            send: input.send,
+            now,
+            wallNow,
+            claimedBy: input.claimedBy,
+            claim
+        });
+        if (outcome)
+            outcomes.push(outcome);
+    }
+    for (const outstanding of await listOutstandingAgentFollowUpDispatches(input.control, { now, limit })) {
+        if (attemptedEventIds.has(outstanding.event.id))
+            continue;
+        const runningFresh = outstanding.event.status === "running"
+            && Date.parse(outstanding.event.updatedAt) > Date.parse(wallNow) - followUpStaleRunningMs;
+        const attemptedRecently = Date.parse(outstanding.event.updatedAt) > Date.parse(wallNow) - followUpDispatchClaimLeaseMs;
+        if (runningFresh || attemptedRecently)
+            continue;
+        if (outstanding.row.dispatchClaimToken?.startsWith("follow_up_dispatch_")) {
+            await releaseAgentFollowUpClaim(input.control, outstanding.row.id, outstanding.row.dispatchClaimToken);
+        }
+        const outcome = await dispatchAgentFollowUpRun({
+            organizationId: input.organizationId,
+            control: input.control,
+            send: input.send,
+            now,
+            wallNow,
+            claimedBy: input.claimedBy,
+            claim: {
+                type: "dispatch",
+                source: "outstanding",
+                row: outstanding.row,
+                event: outstanding.event,
+                generation: outstanding.row.dispatchGeneration
+            }
+        });
+        if (outcome)
+            outcomes.push(outcome);
+    }
+    return outcomes;
+}
+export async function beginAgentFollowUpRun(control, input) {
+    const now = input.now ?? nowIso();
+    const wallNow = input.wallNow ?? now;
+    const claimToken = randomId("follow_up_run");
+    await control.run(`UPDATE ${q("_agent_follow_ups")}
+     SET "lastRunGeneration" = ?, "runCount" = "runCount" + 1, "lastRunAt" = ?,
+         "dispatchClaimToken" = ?, "claimAcquiredAt" = ?, "updatedAt" = ?
+     WHERE "id" = ? AND ("lastRunGeneration" IS NULL OR "lastRunGeneration" < ?)`, [input.generation, now, claimToken, wallNow, now, input.id, input.generation]);
+    let row = await getAgentFollowUp(control, input.id);
+    const began = row?.lastRunGeneration === input.generation && row.dispatchClaimToken === claimToken;
+    if (began) {
+        await releaseAgentFollowUpClaim(control, input.id, claimToken);
+        row = await getAgentFollowUp(control, input.id);
+    }
+    return { began, row };
+}
+export async function continueAgentFollowUpStore(control, input) {
+    const now = input.now ?? nowIso();
+    await control.run(`UPDATE ${q("_agent_follow_ups")}
+     SET "dueAt" = ?, "contextJson" = COALESCE(?, "contextJson"), "body" = COALESCE(?, "body"),
+         "continuedGeneration" = ?, "continuedAt" = ?, "updatedAt" = ?
+     WHERE "id" = ? AND "status" = 'pending' AND "dispatchGeneration" = ?`, [input.dueAt, input.contextJson ?? null, input.body ?? null, input.generation, now, now, input.id, input.generation]);
+    const row = await getAgentFollowUp(control, input.id);
+    return row?.continuedGeneration === input.generation && row.continuedAt === now ? row : null;
+}
+export async function markAgentFollowUpDrifted(control, input) {
+    const now = input.now ?? nowIso();
+    await control.run(`UPDATE ${q("_agent_follow_ups")}
+     SET "driftCount" = "driftCount" + 1, "lastDriftAt" = ?, "dueAt" = ?, "updatedAt" = ?
+     WHERE "id" = ? AND "status" = 'pending' AND "dispatchGeneration" = ?`, [now, input.dueAt, now, input.id, input.generation]);
+    const row = await getAgentFollowUp(control, input.id);
+    return row?.lastDriftAt === now && row.dispatchGeneration === input.generation ? row : null;
+}
+export async function closeAgentFollowUpForMaxRuns(control, input) {
+    const now = input.now ?? nowIso();
+    const wallNow = input.wallNow ?? now;
+    const claimToken = randomId("follow_up_max_runs");
+    await control.run(`UPDATE ${q("_agent_follow_ups")}
+     SET "status" = 'closed', "reason" = 'max-runs', "settledAt" = ?,
+         "dispatchClaimToken" = ?, "claimAcquiredAt" = ?, "updatedAt" = ?
+     WHERE "id" = ? AND "status" = 'pending'`, [now, claimToken, wallNow, now, input.id]);
+    const row = await getAgentFollowUp(control, input.id);
+    return row?.status === "closed"
+        && row.reason === "max-runs"
+        && row.dispatchClaimToken === claimToken
+        ? row
+        : null;
+}
+export async function claimAgentFollowUpLapseAttempt(control, input) {
+    const now = input.now ?? nowIso();
+    const wallNow = input.wallNow ?? now;
+    const before = await getAgentFollowUp(control, input.id);
+    if (!before || before.status !== "lapsed" || before.lapseHandledAt || before.lapseAttempts >= 10)
+        return null;
+    if (before.dispatchClaimToken?.startsWith("follow_up_lapse_attempt_")
+        && Date.parse(before.claimAcquiredAt ?? "") > Date.parse(wallNow) - followUpDispatchClaimLeaseMs) {
+        return null;
+    }
+    const claimToken = randomId("follow_up_lapse_attempt");
+    await control.run(`UPDATE ${q("_agent_follow_ups")}
+     SET "lapseAttempts" = "lapseAttempts" + 1, "dispatchClaimToken" = ?, "claimAcquiredAt" = ?, "updatedAt" = ?
+     WHERE "id" = ? AND "status" = 'lapsed' AND "lapseHandledAt" IS NULL
+       AND "lapseAttempts" = ? AND "updatedAt" = ?
+       AND (("dispatchClaimToken" IS NULL AND ? IS NULL) OR "dispatchClaimToken" = ?)
+       AND "lapseAttempts" < 10`, [
+        claimToken,
+        wallNow,
+        now,
+        input.id,
+        before.lapseAttempts,
+        before.updatedAt,
+        before.dispatchClaimToken,
+        before.dispatchClaimToken
+    ]);
+    const row = await getAgentFollowUp(control, input.id);
+    return row?.dispatchClaimToken === claimToken ? row : null;
+}
+export async function finishAgentFollowUpLapse(control, input) {
+    const now = input.now ?? nowIso();
+    await control.run(`UPDATE ${q("_agent_follow_ups")} SET "lapseHandledAt" = ?, "updatedAt" = ?
+     WHERE "id" = ? AND "status" = 'lapsed' AND "lapseHandledAt" IS NULL`, [now, now, input.id]);
+    return (await getAgentFollowUp(control, input.id))?.lapseHandledAt === now;
+}
+//# sourceMappingURL=agent-follow-up-store.js.map