@usine/engine 0.3.0 → 0.5.0

package/dist/store/queries.js

@@ -1,22 +1,25 @@
-import { Attempt, AttemptId, AttemptContext } from "@usine/core/attempt";
+import { RepositoryName } from "@usine/core/repository";
+import { WorkerName } from "@usine/core/worker";
+import { Attempt, AttemptId, AttemptContext, AttemptNumber, totalOutOfMemoryKills, } from "@usine/core/attempt";
 import { AttemptOutcome } from "@usine/core/attempt/outcome";
+import { AttemptSalvage, salvageRefFor } from "@usine/core/attempt/salvage";
 import { Event, DedupKey, EventId } from "@usine/core/event";
 import { ItemKey } from "@usine/core/item";
-import { LoopName } from "@usine/core/loop";
+import { LoopName, LoopPermissions } from "@usine/core/loop";
 import { RunId } from "@usine/core/run";
 import { StepName } from "@usine/core/step";
 import * as RunState from "@usine/core/run/state";
 import { StepResult } from "@usine/core/step/result";
-import { and, asc, desc, eq, inArray, isNull, ne, notInArray, sql } from "drizzle-orm";
+import { and, asc, desc, eq, gte, inArray, isNull, ne, notInArray, sql, } from "drizzle-orm";
 import { alias } from "drizzle-orm/sqlite-core";
 import { Array as EffectArray, DateTime, Effect, Option, Schema } from "effect";
-import { approvals, attempts, events, ignoredEvents, projectionRevision, runs, steps, triggerEvents, workflowCommands, } from "../database/schema.js";
+import { approvals, attempts, events, ignoredEvents, itemCycleBudgets, loopItems, projectionRevision, runAgainEvents, runs, steps, triggerEvents, } from "../database/schema.js";
 import { RunNotFoundError } from "../engine/error.js";
 import { RunSnapshot, RunSummary } from "../run-reader/model.js";
 import { Submission } from "../engine/submission.js";
-import { WORKFLOW_COMMAND_PRIORITY } from "../workflow/command.js";
 import { cycleQueries } from "../cycle-budget/queries.js";
-import { attemptFromRow, decodeAttemptRows, decodeDiscards, decodeEventRoutes, decodeRecoverableRuns, decodeProjectionRevision, decodeRunIds, decodeRunRows, decodeWorkflowCommands, encodeAgent, encodeBrainSpec, encodeDateTime, encodeOutcome, encodePayload, encodeRunState, encodeStepResult, eventFromRow, runFromRow, runSummaryFromRow, stepFromRow, submissionFromRow, } from "./codec.js";
+import { approvalFromRow, attemptFromRow, decodeAttemptRows, decodeDiscards, decodeNextStarts, decodeOutOfMemory, decodeEventRoutes, decodeProjectionRevision, decodeReopenedEvents, decodeReopenings, decodeRunEventRows, decodeRunIds, decodeRunRows, encodeAgent, encodeAttemptStart, encodeFailureResolution, encodeBrainSpec, encodeDateTime, encodeOutcome, encodeComments, encodeOutOfMemory, encodeSalvage, encodePayload, encodeRunState, encodeStepResult, eventFromRow, runAgainFromRow, runEventFromRow, runFromRow, runSummaryFromRow, stepFromRow, submissionFromRow, } from "./codec.js";
+import { loopItemQueries } from "./loop-items.js";
 import { transcriptQueries } from "./transcript.js";
 const newestRunFirst = (left, right) => DateTime.toEpochMillis(right.openedAt) - DateTime.toEpochMillis(left.openedAt) ||
     right.runId.localeCompare(left.runId);
@@ -29,6 +32,7 @@ const eventRouteSelection = {
     loop: triggerEvents.loopName,
     step: triggerEvents.stepName,
     approval: triggerEvents.approval,
+    permissions: triggerEvents.permissions,
     cycleLimit: triggerEvents.cycleLimit,
     cycleGeneration: triggerEvents.cycleGeneration,
     repository: triggerEvents.repository,
@@ -37,13 +41,16 @@ const eventRouteSelection = {
     agent: triggerEvents.agentJson,
     parentModel: triggerEvents.parentModel,
 };
+const approvalEvents = alias(events, "approval_event");
 const runSelection = {
     itemKey: triggerEvents.itemKey,
     runId: runs.runId,
     eventId: runs.eventId,
     loop: runs.loopName,
     state: runs.stateJson,
+    resolvedFailureAttemptId: runs.resolvedFailureAttemptId,
     openedAt: runs.openedAt,
+    closedAt: runs.closedAt,
     repository: runs.repository,
     revision: runs.revision,
     task: runs.task,
@@ -51,8 +58,13 @@ const runSelection = {
     parentModel: runs.parentModel,
     stepName: steps.stepName,
     result: steps.result,
+    approvedAt: approvalEvents.receivedAt,
+    approvalChannel: approvals.channel,
+    approver: approvals.approver,
+    againFrom: runAgainEvents.fromRunId,
+    againRequestedBy: runAgainEvents.requestedBy,
 };
-const attemptSelection = {
+export const attemptSelection = {
     attemptId: attempts.attemptId,
     runId: attempts.runId,
     stepName: attempts.stepName,
@@ -65,8 +77,14 @@ const attemptSelection = {
     parentModel: attempts.parentModel,
     startedAt: attempts.startedAt,
     outcome: attempts.outcomeJson,
+    endedAt: attempts.endedAt,
+    salvage: attempts.salvageJson,
+    start: attempts.startJson,
+    failureResolution: attempts.failureResolutionJson,
+    reattachedAt: attempts.reattachedAt,
+    comments: attempts.commentsJson,
+    outOfMemory: attempts.outOfMemoryJson,
 };
-// The state partitions are owned by @usine/core; these predicates only borrow their tags.
 const storedStateTag = sql `json_extract(${runs.stateJson}, '$._tag')`;
 const openState = inArray(storedStateTag, [...RunState.OPEN_STATE_TAGS]);
 const unstartedState = inArray(storedStateTag, [...RunState.UNSTARTED_STATE_TAGS]);
@@ -74,8 +92,7 @@ const unstartedState = inArray(storedStateTag, [...RunState.UNSTARTED_STATE_TAGS
 // cannot emit the declaration (TS2883).
 const storedAgent = (agent) => Schema.decodeUnknownSync(Schema.Json)(encodeAgent(agent));
 export const queriesFor = (database) => {
-    // Keep `.execute()` explicit: the yieldable wrapper can cross an Effect
-    // Workflow suspension before its final mutation is observable (ADR 0020).
+    // `.execute()` stays explicit (ADR 0020).
     const eventRouteByDedup = Effect.fn("RunStoreQueries.eventRouteByDedup")(function* (dedupKey) {
         const rows = yield* database
             .select(eventRouteSelection)
@@ -95,15 +112,64 @@ export const queriesFor = (database) => {
             .execute();
         return yield* decodeEventRoutes(rows);
     });
+    const selectRuns = () => database
+        .select(runSelection)
+        .from(runs)
+        .innerJoin(triggerEvents, eq(triggerEvents.eventId, runs.eventId))
+        .innerJoin(steps, eq(steps.runId, runs.runId))
+        .leftJoin(approvals, eq(approvals.runId, runs.runId))
+        .leftJoin(approvalEvents, eq(approvalEvents.eventId, approvals.eventId))
+        .leftJoin(runAgainEvents, eq(runAgainEvents.eventId, runs.eventId));
     const runRows = Effect.fn("RunStoreQueries.runRows")(function* (runId) {
+        const rows = yield* selectRuns().where(eq(runs.runId, runId)).execute();
+        return yield* decodeRunRows(rows);
+    });
+    /** Returns the Attempts that match `filters` and whose leftovers weren't discarded. */
+    const recoveries = (...filters) => Effect.gen(function* () {
         const rows = yield* database
-            .select(runSelection)
-            .from(runs)
+            .select({
+            attemptId: attempts.attemptId,
+            worker: attempts.workerName,
+            repository: runs.repository,
+            runId: attempts.runId,
+            loop: triggerEvents.loopName,
+            itemKey: triggerEvents.itemKey,
+            number: attempts.attemptNumber,
+            permissions: triggerEvents.permissions,
+            outcome: sql `coalesce(json_extract(${attempts.outcomeJson}, '$._tag'), '')`,
+            salvage: attempts.salvageJson,
+        })
+            .from(attempts)
+            .innerJoin(runs, eq(runs.runId, attempts.runId))
             .innerJoin(triggerEvents, eq(triggerEvents.eventId, runs.eventId))
-            .innerJoin(steps, eq(steps.runId, runs.runId))
-            .where(eq(runs.runId, runId))
+            .where(and(isNull(attempts.leftoversDiscardedAt), ...filters))
             .execute();
-        return yield* decodeRunRows(rows);
+        const decoded = yield* Schema.decodeUnknownEffect(Schema.Array(Schema.Struct({
+            attemptId: AttemptId,
+            worker: WorkerName,
+            repository: RepositoryName,
+            runId: RunId,
+            loop: LoopName,
+            itemKey: ItemKey,
+            number: AttemptNumber,
+            permissions: LoopPermissions,
+            outcome: Schema.String,
+            salvage: Schema.NullOr(AttemptSalvage),
+        })))(rows);
+        return decoded.map(({ number, outcome, salvage, ...attempt }) => ({
+            ...attempt,
+            ref: salvageRefFor(attempt.runId, number),
+            succeeded: outcome === "Succeeded",
+            open: outcome === "",
+            rejected: salvage?._tag === "Rejected" ? Option.some(salvage) : Option.none(),
+        }));
+    });
+    const salvageCandidates = Effect.fn("RunStoreQueries.salvageCandidates")(function* () {
+        return yield* recoveries();
+    });
+    const salvageCandidate = Effect.fn("RunStoreQueries.salvageCandidate")(function* (attemptId) {
+        yield* Effect.annotateCurrentSpan({ attemptId });
+        return EffectArray.head(yield* recoveries(eq(attempts.attemptId, attemptId)));
     });
     const attemptRows = Effect.fn("RunStoreQueries.attemptRows")(function* (runId) {
         const rows = yield* database
@@ -131,17 +197,21 @@ export const queriesFor = (database) => {
             run: runFromRow(storedRun),
             step: stepFromRow(storedRun),
             attempts: storedAttempts.map(attemptFromRow),
+            resolvedFailureAttemptId: Option.fromNullishOr(storedRun.resolvedFailureAttemptId),
+            closedAt: Option.fromNullishOr(storedRun.closedAt),
+            approval: approvalFromRow(storedRun),
+            runAgain: runAgainFromRow(storedRun),
             repository: storedRun.repository,
             revision: storedRun.revision,
             task: storedRun.task,
             agent: storedRun.agent,
             parentModel: Option.fromNullishOr(storedRun.parentModel),
+            permissions: route.permissions,
         });
     });
     const summariesWithAttempts = Effect.fn("RunStoreQueries.summariesWithAttempts")(function* (storedRuns) {
         const runIds = storedRuns.map(({ runId }) => runId);
-        // Keep history queries below adapter bind-parameter limits, even for a
-        // long-lived Task with many Runs.
+        // Chunks keep each read below the driver's bind-parameter limit.
         const storedAttempts = (yield* Effect.forEach(EffectArray.chunksOf(runIds, 100), (ids) => database
             .select(attemptSelection)
             .from(attempts)
@@ -155,11 +225,7 @@ export const queriesFor = (database) => {
     const itemRunSummaries = Effect.fn("RunStoreQueries.itemRunSummaries")(function* (itemKeys) {
         if (itemKeys.length === 0)
             return [];
-        const storedRuns = (yield* Effect.forEach(EffectArray.chunksOf([...new Set(itemKeys)], 100), (keys) => database
-            .select(runSelection)
-            .from(runs)
-            .innerJoin(triggerEvents, eq(triggerEvents.eventId, runs.eventId))
-            .innerJoin(steps, eq(steps.runId, runs.runId))
+        const storedRuns = (yield* Effect.forEach(EffectArray.chunksOf([...new Set(itemKeys)], 100), (keys) => selectRuns()
             .where(inArray(triggerEvents.itemKey, keys))
             .execute()
             .pipe(Effect.flatMap(decodeRunRows))))
@@ -167,24 +233,15 @@ export const queriesFor = (database) => {
             .sort(newestRunFirst);
         return yield* summariesWithAttempts(storedRuns);
     });
-    // Every open Run plus the newest `closedLimit` settled ones, so an old
-    // Waiting run never falls out of the operator's view while history stays bounded.
+    // Every open Run plus the newest `closedLimit` closed ones, so an old waiting Run stays listed.
     const runSummaries = Effect.fn("RunStoreQueries.runSummaries")(function* (closedLimit) {
         const [openRuns, closedRuns] = yield* Effect.all([
-            database
-                .select(runSelection)
-                .from(runs)
-                .innerJoin(triggerEvents, eq(triggerEvents.eventId, runs.eventId))
-                .innerJoin(steps, eq(steps.runId, runs.runId))
+            selectRuns()
                 .where(openState)
                 .orderBy(desc(runs.openedAt), desc(runs.runId))
                 .execute()
                 .pipe(Effect.flatMap(decodeRunRows)),
-            database
-                .select(runSelection)
-                .from(runs)
-                .innerJoin(triggerEvents, eq(triggerEvents.eventId, runs.eventId))
-                .innerJoin(steps, eq(steps.runId, runs.runId))
+            selectRuns()
                 .where(notInArray(storedStateTag, [...RunState.OPEN_STATE_TAGS]))
                 .orderBy(desc(runs.openedAt), desc(runs.runId))
                 .limit(closedLimit)
@@ -194,6 +251,45 @@ export const queriesFor = (database) => {
         const storedRuns = [...openRuns, ...closedRuns].sort(newestRunFirst);
         return yield* summariesWithAttempts(storedRuns);
     });
+    const runEvents = Effect.fn("RunStoreQueries.runEvents")(function* (runIds) {
+        // Chunks keep each read below the driver's bind-parameter limit.
+        const rows = yield* Effect.forEach(EffectArray.chunksOf([...new Set(runIds)], 100), (ids) => database
+            .select({
+            runId: runs.runId,
+            eventId: events.eventId,
+            dedupKey: events.dedupKey,
+            payload: events.payloadJson,
+            receivedAt: events.receivedAt,
+        })
+            .from(runs)
+            .innerJoin(events, eq(events.eventId, runs.eventId))
+            .where(inArray(runs.runId, ids))
+            .execute()
+            .pipe(Effect.flatMap(decodeRunEventRows)));
+        return rows.flat().map(runEventFromRow);
+    });
+    const closedRunSummaries = Effect.fn("RunStoreQueries.closedRunSummaries")(function* (limit) {
+        const closedRuns = yield* selectRuns()
+            .where(notInArray(storedStateTag, [...RunState.OPEN_STATE_TAGS]))
+            .orderBy(desc(runs.closedAt), desc(runs.runId))
+            .limit(limit)
+            .execute()
+            .pipe(Effect.flatMap(decodeRunRows));
+        return yield* summariesWithAttempts(closedRuns);
+    });
+    // Every closed Run with `closedAt` at or after `since`, or every closed Run for `None`.
+    const closedRunSummariesSince = Effect.fn("RunStoreQueries.closedRunSummariesSince")(function* (since) {
+        const closed = notInArray(storedStateTag, [...RunState.OPEN_STATE_TAGS]);
+        const closedRuns = yield* selectRuns()
+            .where(Option.match(since, {
+            onNone: () => closed,
+            onSome: (from) => and(closed, gte(runs.closedAt, encodeDateTime(from))),
+        }))
+            .orderBy(desc(runs.closedAt), desc(runs.runId))
+            .execute()
+            .pipe(Effect.flatMap(decodeRunRows));
+        return yield* summariesWithAttempts(closedRuns);
+    });
     const revision = Effect.fn("RunStoreQueries.projectionRevision")(function* () {
         const rows = yield* decodeProjectionRevision(yield* database
             .select({ revision: projectionRevision.revision })
@@ -203,10 +299,12 @@ export const queriesFor = (database) => {
             .execute());
         return Option.fromNullishOr(rows[0]?.revision);
     });
-    const updateState = Effect.fn("RunStoreQueries.updateState")(function* (runId, state) {
+    // A closed state sets `closedAt` to `at` or now; an open state clears it.
+    const updateState = Effect.fn("RunStoreQueries.updateState")(function* (runId, state, at) {
+        const closedAt = RunState.isOpen(state) ? null : encodeDateTime(at ?? (yield* DateTime.now));
         const updated = yield* database
             .update(runs)
-            .set({ stateJson: encodeRunState(state) })
+            .set({ stateJson: encodeRunState(state), closedAt })
             .where(eq(runs.runId, runId))
             .returning({ runId: runs.runId })
             .execute();
@@ -214,6 +312,19 @@ export const queriesFor = (database) => {
             return yield* new RunNotFoundError({ runId });
         }
     });
+    const resolveFailure = Effect.fn("RunStoreQueries.resolveFailure")(function* (runId, attemptId, resolution) {
+        yield* Effect.annotateCurrentSpan({ runId, attemptId });
+        yield* database
+            .update(attempts)
+            .set({ failureResolutionJson: encodeFailureResolution(resolution) })
+            .where(eq(attempts.attemptId, attemptId))
+            .execute();
+        yield* database
+            .update(runs)
+            .set({ resolvedFailureAttemptId: attemptId })
+            .where(eq(runs.runId, runId))
+            .execute();
+    });
     const addAttempt = Effect.fn("RunStoreQueries.addAttempt")(function* (attempt) {
         yield* database
             .insert(attempts)
@@ -230,13 +341,82 @@ export const queriesFor = (database) => {
             parentModel: Option.getOrNull(attempt.parentModel),
             startedAt: encodeDateTime(attempt.startedAt),
             outcomeJson: null,
+            endedAt: null,
+            salvageJson: null,
+            startJson: Option.match(attempt.start, { onNone: () => null, onSome: encodeAttemptStart }),
         })
             .execute();
     });
-    const closeAttempt = Effect.fn("RunStoreQueries.closeAttempt")(function* (attemptId, outcome) {
+    const recordReattach = Effect.fn("RunStoreQueries.recordReattach")(function* (attemptId, reattachedAt) {
+        yield* Effect.annotateCurrentSpan({ attemptId });
         yield* database
             .update(attempts)
-            .set({ outcomeJson: encodeOutcome(outcome) })
+            .set({ reattachedAt: encodeDateTime(reattachedAt) })
+            .where(eq(attempts.attemptId, attemptId))
+            .execute();
+    });
+    /** Returns the operator retry for the Run's next Attempt, or `None`. */
+    const nextStart = Effect.fn("RunStoreQueries.nextStart")(function* (runId) {
+        const rows = yield* database
+            .select({ nextStart: runs.nextStartJson })
+            .from(runs)
+            .where(eq(runs.runId, runId))
+            .execute();
+        return Option.fromNullishOr((yield* decodeNextStarts(rows))[0]?.nextStart);
+    });
+    const setNextStart = Effect.fn("RunStoreQueries.setNextStart")(function* (runId, start) {
+        yield* database
+            .update(runs)
+            .set({
+            nextStartJson: Option.match(start, { onNone: () => null, onSome: encodeAttemptStart }),
+        })
+            .where(eq(runs.runId, runId))
+            .execute();
+    });
+    const recordSalvage = Effect.fn("RunStoreQueries.recordSalvage")(function* (attemptId, salvage) {
+        yield* Effect.annotateCurrentSpan({ attemptId, salvage: salvage._tag });
+        yield* database
+            .update(attempts)
+            .set({ salvageJson: encodeSalvage(salvage) })
+            .where(eq(attempts.attemptId, attemptId))
+            .execute();
+    });
+    const recordComments = Effect.fn("RunStoreQueries.recordComments")(function* (attemptId, comments) {
+        yield* Effect.annotateCurrentSpan({ attemptId, comments: comments.length });
+        yield* database
+            .update(attempts)
+            .set({ commentsJson: encodeComments(comments) })
+            .where(eq(attempts.attemptId, attemptId))
+            .execute();
+    });
+    /**
+     * Records the kills of one of the Attempt's containers, replacing an earlier record of the same
+     * container, and returns the kills of all its containers.
+     */
+    const recordOutOfMemory = Effect.fn("RunStoreQueries.recordOutOfMemory")(function* (attemptId, kills) {
+        yield* Effect.annotateCurrentSpan({
+            attemptId,
+            container: kills.container,
+            kills: kills.kills,
+        });
+        const rows = yield* database
+            .select({ outOfMemory: attempts.outOfMemoryJson })
+            .from(attempts)
+            .where(eq(attempts.attemptId, attemptId))
+            .execute();
+        const recorded = (yield* decodeOutOfMemory(rows))[0]?.outOfMemory ?? [];
+        const containers = EffectArray.append(recorded.filter(({ container }) => container !== kills.container), kills);
+        yield* database
+            .update(attempts)
+            .set({ outOfMemoryJson: encodeOutOfMemory(containers) })
+            .where(eq(attempts.attemptId, attemptId))
+            .execute();
+        return totalOutOfMemoryKills(containers);
+    });
+    const closeAttempt = Effect.fn("RunStoreQueries.closeAttempt")(function* (attemptId, outcome, endedAt) {
+        yield* database
+            .update(attempts)
+            .set({ outcomeJson: encodeOutcome(outcome), endedAt: encodeDateTime(endedAt) })
             .where(and(eq(attempts.attemptId, attemptId), isNull(attempts.outcomeJson)))
             .execute();
     });
@@ -277,7 +457,7 @@ export const queriesFor = (database) => {
     const approvalExists = Effect.fn("RunStoreQueries.approvalExists")(function* (runId) {
         return (yield* database.$count(approvals, eq(approvals.runId, runId)).execute()) > 0;
     });
-    const recordApproval = Effect.fn("RunStoreQueries.recordApproval")(function* (runId, approval) {
+    const recordApproval = Effect.fn("RunStoreQueries.recordApproval")(function* (runId, approval, source) {
         yield* database
             .insert(events)
             .values({
@@ -288,30 +468,15 @@ export const queriesFor = (database) => {
         })
             .onConflictDoNothing()
             .execute();
-        yield* database.insert(approvals).values({ runId, eventId: approval.id }).execute();
-    });
-    const requestWorkflowCommand = Effect.fn("RunStoreQueries.requestWorkflowCommand")(function* (runId, command) {
-        yield* database
-            .insert(workflowCommands)
-            .values({ runId, command })
-            .onConflictDoNothing()
-            .execute();
-    });
-    const requestInterrupt = Effect.fn("RunStoreQueries.requestInterrupt")(function* (runId) {
         yield* database
-            .delete(workflowCommands)
-            .where(and(eq(workflowCommands.runId, runId), inArray(workflowCommands.command, ["Approve", "Resume"])))
-            .execute();
-        yield* requestWorkflowCommand(runId, "Interrupt");
-    });
-    const workflowCommandsFor = Effect.fn("RunStoreQueries.workflowCommandsFor")(function* (runId) {
-        yield* Effect.annotateCurrentSpan({ runId });
-        const rows = yield* database
-            .select({ runId: workflowCommands.runId, command: workflowCommands.command })
-            .from(workflowCommands)
-            .where(eq(workflowCommands.runId, runId))
+            .insert(approvals)
+            .values({
+            runId,
+            eventId: approval.id,
+            channel: source.channel,
+            approver: Option.getOrNull(source.approver),
+        })
             .execute();
-        return (yield* decodeWorkflowCommands(rows)).map(({ command }) => command);
     });
     const createRun = Effect.fn("RunStoreQueries.createRun")(function* (submission, eventId, runId) {
         const candidate = alias(triggerEvents, "candidate");
@@ -376,7 +541,48 @@ export const queriesFor = (database) => {
             .limit(1)
             .execute());
     });
-    const recordTriggerEvent = Effect.fn("RunStoreQueries.recordTriggerEvent")(function* (submission) {
+    /** Returns the newest reopening of `eventId` (#267), with its reopening number. */
+    const newestReopening = Effect.fn("RunStoreQueries.newestReopening")(function* (eventId) {
+        const rows = yield* decodeReopenings(yield* database
+            .select({ ...eventRouteSelection, reopening: triggerEvents.reopening })
+            .from(events)
+            .innerJoin(triggerEvents, eq(triggerEvents.eventId, events.eventId))
+            .where(eq(triggerEvents.reopensEventId, eventId))
+            .orderBy(desc(triggerEvents.reopening))
+            .limit(1)
+            .execute());
+        return Option.map(Option.fromNullishOr(rows[0]), (row) => ({
+            submission: submissionFromRow(row),
+            reopening: row.reopening,
+        }));
+    });
+    /** Returns the trigger Event that `eventId` reopens or runs again, or `None` for a trigger's own Event. */
+    const reopenedEvent = Effect.fn("RunStoreQueries.reopenedEvent")(function* (eventId) {
+        const reopened = alias(events, "reopened_event");
+        const rows = yield* decodeReopenedEvents(yield* database
+            .select({ eventId: reopened.eventId, dedupKey: reopened.dedupKey })
+            .from(triggerEvents)
+            .innerJoin(reopened, eq(reopened.eventId, triggerEvents.reopensEventId))
+            .where(eq(triggerEvents.eventId, eventId))
+            .execute());
+        return Option.fromNullishOr(rows[0]);
+    });
+    /** Records that `eventId` came from running a closed Run again, and the requesting login. */
+    const recordRunAgain = Effect.fn("RunStoreQueries.recordRunAgain")(function* (eventId, again) {
+        yield* database
+            .insert(runAgainEvents)
+            .values({
+            eventId,
+            fromRunId: again.from,
+            requestedBy: Option.getOrNull(again.requestedBy),
+        })
+            .execute();
+    });
+    /**
+     * Records a trigger Event and its route once, and returns the route as first recorded.
+     * `reopens` is the earlier Event that this one reopens.
+     */
+    const recordTriggerEvent = Effect.fn("RunStoreQueries.recordTriggerEvent")(function* (submission, reopens = Option.none()) {
         yield* database
             .insert(events)
             .values({
@@ -398,6 +604,7 @@ export const queriesFor = (database) => {
                 loopName: submission.loop,
                 stepName: submission.step,
                 approval: submission.approval,
+                permissions: submission.permissions,
                 cycleLimit: Option.getOrNull(submission.cycleLimit),
                 cycleGeneration: submission.cycleGeneration,
                 repository: submission.repository,
@@ -405,6 +612,11 @@ export const queriesFor = (database) => {
                 task: submission.task,
                 agentJson: storedAgent(submission.agent),
                 parentModel: Option.getOrNull(submission.parentModel),
+                reopensEventId: Option.getOrNull(Option.map(reopens, ({ eventId }) => eventId)),
+                reopening: Option.match(reopens, {
+                    onNone: () => 0,
+                    onSome: ({ reopening }) => reopening,
+                }),
             })
                 .execute();
             return submission;
@@ -416,6 +628,16 @@ export const queriesFor = (database) => {
         const current = routes[0];
         if (current === undefined)
             return Option.none();
+        const suppression = yield* loopItemQueries(database).suppression(current.loop, current.itemKey);
+        if (Option.isSome(suppression)) {
+            yield* Effect.logInfo("Queued Events wait while a suppression keeps the Item", {
+                runId,
+                suppressedBy: suppression.value.runId,
+                loop: current.loop,
+                itemKey: current.itemKey,
+            });
+            return Option.none();
+        }
         const queuedRows = yield* database
             .select(eventRouteSelection)
             .from(events)
@@ -424,55 +646,53 @@ export const queriesFor = (database) => {
             .leftJoin(ignoredEvents, eq(ignoredEvents.eventId, events.eventId))
             .where(and(eq(triggerEvents.loopName, current.loop), eq(triggerEvents.itemKey, current.itemKey), cycleQueries(database).currentEvent, isNull(runs.runId), isNull(ignoredEvents.eventId)))
             .orderBy(desc(events.receivedAt))
-            .limit(1)
             .execute();
         const queued = yield* decodeEventRoutes(queuedRows);
-        return Option.fromNullishOr(queued[0]).pipe(Option.map(submissionFromRow));
+        return Option.fromNullishOr(queued[0]).pipe(Option.map((newest) => ({
+            submission: submissionFromRow(newest),
+            eventIds: queued.map((row) => row.eventId),
+        })));
     });
-    const recoverable = Effect.fn("RunStoreQueries.recoverable")(function* () {
+    const runIdsToDrive = Effect.fn("RunStoreQueries.runIdsToDrive")(function* () {
+        const waiting = "Waiting";
         const rows = yield* database
-            .select({
-            ...eventRouteSelection,
-            runId: runs.runId,
-            state: runs.stateJson,
-        })
+            .select({ runId: runs.runId })
             .from(runs)
-            .innerJoin(events, eq(events.eventId, runs.eventId))
-            .innerJoin(triggerEvents, eq(triggerEvents.eventId, events.eventId))
-            .where(openState)
+            .where(and(openState, ne(storedStateTag, waiting)))
             .execute();
-        return yield* decodeRecoverableRuns(rows);
+        return (yield* decodeRunIds(rows)).map(({ runId }) => runId);
     });
-    const pendingWorkflowCommands = Effect.fn("RunStoreQueries.pendingWorkflowCommands")(function* () {
-        const rows = yield* database
-            .select({ runId: workflowCommands.runId, command: workflowCommands.command })
-            .from(workflowCommands)
-            .execute();
-        const decoded = yield* decodeWorkflowCommands(rows);
-        // Delivery order per run is a replay invariant; WORKFLOW_COMMAND_PRIORITY names it.
-        const priority = (command) => WORKFLOW_COMMAND_PRIORITY.indexOf(command);
-        return [...decoded].sort((left, right) => left.runId === right.runId
-            ? priority(left.command) - priority(right.command)
-            : left.runId < right.runId
-                ? -1
-                : 1);
-    });
-    const completeWorkflowCommand = Effect.fn("RunStoreQueries.completeWorkflowCommand")(function* (runId, command) {
-        yield* database
-            .delete(workflowCommands)
-            .where(and(eq(workflowCommands.runId, runId), eq(workflowCommands.command, command)))
+    // The newest closed Run of each Item that has a current queued Event and no open Run, excluding
+    // Items waiting for a cycle-budget reset or under a suppression.
+    const pendingContinuations = Effect.fn("RunStoreQueries.pendingContinuations")(function* () {
+        const items = yield* database
+            .selectDistinct({ loop: triggerEvents.loopName, itemKey: triggerEvents.itemKey })
+            .from(triggerEvents)
+            .leftJoin(runs, eq(runs.eventId, triggerEvents.eventId))
+            .leftJoin(ignoredEvents, eq(ignoredEvents.eventId, triggerEvents.eventId))
+            .leftJoin(itemCycleBudgets, eq(itemCycleBudgets.itemKey, triggerEvents.itemKey))
+            .leftJoin(loopItems, and(eq(loopItems.loopName, triggerEvents.loopName), eq(loopItems.itemKey, triggerEvents.itemKey)))
+            .where(and(isNull(runs.runId), isNull(ignoredEvents.eventId), isNull(itemCycleBudgets.askJson), isNull(loopItems.suppressedByRunId), cycleQueries(database).currentEvent))
             .execute();
+        const decoded = yield* Schema.decodeUnknownEffect(Schema.Array(Schema.Struct({ loop: LoopName, itemKey: ItemKey })))(items);
+        const closed = yield* Effect.forEach(decoded, ({ loop, itemKey }) => Effect.gen(function* () {
+            if ((yield* blockingRun(loop, itemKey)).length > 0)
+                return [];
+            return yield* decodeRunIds(yield* database
+                .select({ runId: runs.runId })
+                .from(runs)
+                .innerJoin(triggerEvents, eq(triggerEvents.eventId, runs.eventId))
+                .where(and(eq(triggerEvents.loopName, loop), eq(triggerEvents.itemKey, itemKey)))
+                .orderBy(desc(runs.openedAt), desc(runs.runId))
+                .limit(1)
+                .execute());
+        }));
+        return closed.flat().map(({ runId }) => runId);
     });
-    const revokeUnstarted = Effect.fn("RunStoreQueries.revokeUnstarted")(function* (loop, itemKey) {
-        const rows = yield* decodeRunIds(yield* database
-            .select({ runId: runs.runId })
-            .from(runs)
-            .innerJoin(triggerEvents, eq(triggerEvents.eventId, runs.eventId))
-            .where(and(eq(triggerEvents.loopName, loop), eq(triggerEvents.itemKey, itemKey), unstartedState))
-            .execute());
+    const revokeQueued = Effect.fn("RunStoreQueries.revokeQueued")(function* (loop, itemKey, eventIds) {
         const candidate = alias(triggerEvents, "candidate");
         const candidateRun = alias(runs, "candidate_run");
-        yield* database
+        const ignored = yield* database
             .insert(ignoredEvents)
             .select(database
             .select({
@@ -481,41 +701,69 @@ export const queriesFor = (database) => {
         })
             .from(candidate)
             .leftJoin(candidateRun, eq(candidateRun.eventId, candidate.eventId))
-            .where(and(eq(candidate.loopName, loop), eq(candidate.itemKey, itemKey), isNull(candidateRun.runId))))
+            .where(and(eq(candidate.loopName, loop), eq(candidate.itemKey, itemKey), inArray(candidate.eventId, eventIds), isNull(candidateRun.runId))))
             .onConflictDoNothing()
+            .returning({ eventId: ignoredEvents.eventId })
             .execute();
+        return ignored.length;
+    });
+    const revokeUnstarted = Effect.fn("RunStoreQueries.revokeUnstarted")(function* (loop, itemKey) {
+        const rows = yield* decodeRunIds(yield* database
+            .select({ runId: runs.runId })
+            .from(runs)
+            .innerJoin(triggerEvents, eq(triggerEvents.eventId, runs.eventId))
+            .where(and(eq(triggerEvents.loopName, loop), eq(triggerEvents.itemKey, itemKey), unstartedState))
+            .execute());
+        const queued = database
+            .select({ eventId: triggerEvents.eventId })
+            .from(triggerEvents)
+            .where(and(eq(triggerEvents.loopName, loop), eq(triggerEvents.itemKey, itemKey)));
+        yield* revokeQueued(loop, itemKey, queued);
         return rows;
     });
     return {
+        salvageCandidates,
+        salvageCandidate,
         cycles: cycleQueries(database),
+        loopItems: loopItemQueries(database),
         ...transcriptQueries(database),
         addAttempt,
+        recordReattach,
+        nextStart,
+        setNextStart,
+        recordSalvage,
+        recordComments,
+        recordOutOfMemory,
         amend,
         markIntervened,
         approvalExists,
         blockingRun,
         closeAttempt,
-        completeWorkflowCommand,
         createRun,
         eventRouteByRun,
-        workflowCommandsFor,
         ignoredEvent,
+        newestReopening,
         nextQueued,
-        pendingWorkflowCommands,
+        reopenedEvent,
+        recordRunAgain,
+        pendingContinuations,
         recordTriggerEvent,
-        recoverable,
+        runIdsToDrive,
         recordApproval,
-        requestInterrupt,
-        requestWorkflowCommand,
         revision,
+        revokeQueued,
         revokeUnstarted,
         runSummaries,
+        closedRunSummaries,
+        closedRunSummariesSince,
         itemRunSummaries,
+        runEvents,
         runForEvent,
         snapshot,
         updateStepResult,
         updateAttemptParentModel,
         updateState,
+        resolveFailure,
     };
 };
 //# sourceMappingURL=queries.js.map