cloving 1.3.0 → 1.4.0

package/dist/src/authority/instants.js

@@ -36,3 +36,24 @@ export function notBefore(value, bound) {
 export function isAfter(value, bound) {
     return notBefore(value, bound) && !notBefore(bound, value);
 }
+function leapDaysBefore(year) {
+    const previous = year - 1;
+    return (Math.floor(previous / 4) -
+        Math.floor(previous / 100) +
+        Math.floor(previous / 400));
+}
+export function instantMilliseconds(value) {
+    if (!isInstant(value))
+        throw new Error("invalid-instant");
+    const year = Number(value.slice(0, 4));
+    const month = Number(value.slice(5, 7));
+    let days = Number(value.slice(8, 10)) - 1;
+    for (let preceding = 1; preceding < month; preceding += 1)
+        days += daysIn(year, preceding);
+    days += 365 * (year - 1970) + leapDaysBefore(year) - leapDaysBefore(1970);
+    return (days * 86_400_000 +
+        Number(value.slice(11, 13)) * 3_600_000 +
+        Number(value.slice(14, 16)) * 60_000 +
+        Number(value.slice(17, 19)) * 1000 +
+        Number(value.slice(20, 23)));
+}

package/dist/src/authority/reduction-state.d.ts

@@ -1,3 +1,4 @@
+import { type CommandWaitsState } from "./command-waits.ts";
 import { type RunDetails } from "./details.ts";
 import { type GateState } from "./gates.ts";
 import { type Disposition, type EffectState } from "./operations.ts";
@@ -20,6 +21,7 @@ export interface Recorded {
 }
 export interface Change extends Recorded {
     readonly moved?: RunState;
+    readonly commandWaits?: CommandWaitsState;
     readonly gates?: readonly GateState[];
     readonly added?: readonly EffectIntent[];
     readonly questions?: number;

package/dist/src/authority/reduction-state.js

@@ -1,3 +1,4 @@
+import { closedCommandWaits } from "./command-waits.js";
 import { operationIdentity } from "../operation-identity.js";
 import { continued } from "./details.js";
 import { gateKey } from "./gates.js";
@@ -40,12 +41,16 @@ function nextDetails(change) {
 }
 export function applied(state, change) {
     const { event } = change;
+    const waits = change.commandWaits ?? state.commandWaits;
     return {
         kind: "applied",
         ...(change.disposition === undefined
             ? {}
             : { disposition: change.disposition }),
         state: {
+            ...(waits === undefined
+                ? {}
+                : { commandWaits: closedCommandWaits(waits, event) }),
             sequence: event.sequence,
             runs: change.moved
                 ? { ...state.runs, [event.runId]: change.moved }

package/dist/src/authority/reduction.js

@@ -1,3 +1,6 @@
+import { checkedCommandWait } from "./command-wait-checks.js";
+import { waitEffectTime, waitEffectChange } from "./command-wait-results.js";
+import { commandWaitKey, commandWaitsAfter, validCommandWaitTime, } from "./command-waits.js";
 import { admittedDetails, observed } from "./details.js";
 import { settled } from "./gates.js";
 import { admittedBudgets } from "./budgets.js";
@@ -57,6 +60,8 @@ function dispatched(state, recorded) {
 function effect(rule) {
     return (state, recorded) => {
         const { event, run } = recorded;
+        if (!waitEffectTime(state.commandWaits ?? {}, event))
+            return invalid("invalid-recorded-time");
         const result = rule(state.effects, { event, runStatus: run.status });
         if (result.kind === "invalid")
             return result;
@@ -64,6 +69,7 @@ function effect(rule) {
         return applied(state, {
             ...recorded,
             effects: result.effects,
+            ...waitEffectChange(state, { event, result }),
             ...(result.released === undefined ? {} : { released: result.released }),
             ...(result.disposition === undefined
                 ? {}
@@ -78,8 +84,24 @@ function effect(rule) {
         });
     };
 }
+const changeCommandWait = (state, recorded) => {
+    const { event, run } = recorded;
+    const waits = state.commandWaits ?? {};
+    const key = commandWaitKey(event.runId, event.payload["waitName"] ?? "");
+    if (event.type === "command-wait.opened" &&
+        waits[key] === undefined &&
+        run.status !== "running")
+        return invalid("command-wait-run-not-running");
+    const result = commandWaitsAfter(waits, event);
+    return result.kind === "invalid"
+        ? result
+        : applied(state, { ...recorded, commandWaits: result.waits });
+};
 const handlers = {
     "schedule.skipped": applied,
+    "command-wait.opened": changeCommandWait,
+    "command-wait.checked": checkedCommandWait,
+    "command-wait.expired": changeCommandWait,
     "effect.requested": effect(requested),
     "lease.granted": effect(granted),
     "lease.expired": effect(leaseExpired),
@@ -146,6 +168,8 @@ function created(state, recorded) {
     };
 }
 export function reduce(state, event) {
+    if (!validCommandWaitTime(state.commandWaits ?? {}, event))
+        return invalid("invalid-command-wait-time");
     if (event.sequence !== state.sequence + 1)
         return invalid("sequence-gap");
     if (state.commands[event.commandId])

package/dist/src/authority/status-input.d.ts

@@ -1,3 +1,4 @@
+import type { CommandWaitView } from "./command-wait-view.ts";
 import type { RunDetails } from "./details.ts";
 import type { GateState } from "./gates.ts";
 import type { RunClosure } from "./stop-sequence.ts";
@@ -21,6 +22,7 @@ export interface BudgetSummary {
     readonly spent: number;
 }
 export interface StatusInput {
+    readonly commandWaits: readonly CommandWaitView[];
     readonly run: RunState;
     readonly details: RunDetails | undefined;
     readonly gates: readonly GateState[];

package/dist/src/authority/status.d.ts

@@ -1,3 +1,4 @@
+import type { CommandWaitView } from "./command-wait-view.ts";
 import { type EffectView, type Recovery } from "./status-effects.ts";
 import { type BudgetSummary, type StatusInput } from "./status-input.ts";
 import type { RunStatus } from "./transitions.ts";
@@ -5,6 +6,7 @@ export { unresolved, unresolvedEffects } from "./status-closure.ts";
 export type { EffectView } from "./status-effects.ts";
 export type { Assessment, BudgetSummary, EffectSummary, OperationSummary, StatusInput, } from "./status-input.ts";
 export interface RunView {
+    readonly commandWaits: readonly CommandWaitView[];
     readonly runId: string;
     readonly workflow: string;
     readonly state: RunStatus;

package/dist/src/authority/status.js

@@ -266,6 +266,7 @@ export function runView(input) {
             attempts: observation?.attempt ?? 0,
             limit: observation?.limit ?? null,
         },
+        commandWaits: input.commandWaits,
         budget: input.budget,
         effects: effectViews(input.effects),
         nextAction: assessment.nextAction,

package/dist/src/authority/stop-sequence.d.ts

@@ -5,6 +5,7 @@ export interface AttemptSummary {
     readonly stagedSequence: number;
 }
 export interface StopSubject {
+    readonly stopSequence?: number;
     readonly operationId: string;
     readonly kind: string;
     readonly attempts: readonly AttemptSummary[];

package/dist/src/authority/stop-sequence.js

@@ -39,7 +39,8 @@ const stopPurposes = ["stop", "reconcile"];
 export function stopCount(subject, cancelledSequence) {
     return subject.attempts.filter((attempt) => attempt.outcome !== null &&
         stopPurposes.includes(attempt.purpose) &&
-        attempt.stagedSequence >= cancelledSequence).length;
+        attempt.stagedSequence >=
+            Math.max(cancelledSequence, subject.stopSequence ?? 0)).length;
 }
 const uncertainStatuses = ["recovering", "blocked"];
 function uncertain(subject) {

package/dist/src/authority/transitions.d.ts

@@ -1,3 +1,4 @@
+import type { CommandWaitsState } from "./command-waits.ts";
 import type { RunDetails } from "./details.ts";
 import type { GateState } from "./gates.ts";
 import type { EffectState } from "./operations.ts";
@@ -26,9 +27,10 @@ export interface AuthorityState {
     readonly gates: Readonly<Record<string, GateState>>;
     readonly details: Readonly<Record<string, RunDetails>>;
     readonly questions: number;
+    readonly commandWaits?: CommandWaitsState;
     readonly effects: EffectState;
 }
-export declare const eventTypes: readonly ["run.created", "run.started", "gate.opened", "gate.wait-registered", "gate.decided", "gate.expired", "run.paused", "run.resumed", "run.completed", "run.failed", "run.cancelled", "run.observed", "step.dispatched", "effect.requested", "lease.granted", "lease.expired", "effect.reported", "operation.reconciled", "schedule.skipped"];
+export declare const eventTypes: readonly ["run.created", "run.started", "gate.opened", "gate.wait-registered", "gate.decided", "gate.expired", "run.paused", "run.resumed", "run.completed", "run.failed", "run.cancelled", "run.observed", "step.dispatched", "effect.requested", "lease.granted", "lease.expired", "effect.reported", "operation.reconciled", "schedule.skipped", "command-wait.opened", "command-wait.checked", "command-wait.expired"];
 export type EventType = (typeof eventTypes)[number];
 export interface AuthorityEvent {
     readonly sequence: number;
@@ -39,8 +41,8 @@ export interface AuthorityEvent {
     readonly request: string;
     readonly payload: Readonly<Record<string, string>>;
 }
-export declare const numberFields: readonly ["expectedRevision", "expectedObservation", "generation", "attempt", "limit", "effectLimit", "units", "recoveryLimit", "leaseGeneration", "sourceGeneration", "capacity", "slot"];
-export declare const textFields: readonly ["parentRunId", "chainId", "workflow", "workflowId", "submission", "input", "resolver", "gateId", "gateKind", "waitMode", "subject", "prompt", "expiresAt", "decision", "answer", "condition", "reason", "evidence", "retryAt", "operationId", "receipt", "capabilities", "capability", "method", "target", "payload", "inputDigest", "resource", "transport", "source", "worker", "outcome", "outcomeReason", "promotionId", "ticketStatus", "issueUpdate", "result", "actor"];
+export declare const numberFields: readonly ["expectedRevision", "expectedObservation", "generation", "attempt", "limit", "effectLimit", "units", "recoveryLimit", "leaseGeneration", "sourceGeneration", "capacity", "slot", "maximumWaitSeconds", "pollEverySeconds"];
+export declare const textFields: readonly ["parentRunId", "chainId", "workflow", "workflowId", "submission", "input", "resolver", "gateId", "gateKind", "waitMode", "subject", "prompt", "expiresAt", "decision", "answer", "condition", "reason", "evidence", "retryAt", "operationId", "receipt", "capabilities", "capability", "method", "target", "payload", "inputDigest", "resource", "transport", "source", "worker", "outcome", "outcomeReason", "promotionId", "ticketStatus", "issueUpdate", "result", "actor", "waitName", "commandOutput"];
 export type NumberField = (typeof numberFields)[number];
 export type TextField = (typeof textFields)[number];
 export type AuthorityCommand = {
@@ -48,7 +50,7 @@ export type AuthorityCommand = {
     readonly commandId: string;
     readonly runId: string;
 } & Readonly<Partial<Record<NumberField, number>>> & Readonly<Partial<Record<TextField, string>>>;
-export type Move = Exclude<EventType, "run.created" | "step.dispatched" | "gate.wait-registered" | "run.observed" | "effect.requested" | "lease.granted" | "lease.expired" | "effect.reported" | "operation.reconciled" | "schedule.skipped">;
+export type Move = Exclude<EventType, "run.created" | "step.dispatched" | "gate.wait-registered" | "run.observed" | "effect.requested" | "lease.granted" | "lease.expired" | "effect.reported" | "operation.reconciled" | "schedule.skipped" | "command-wait.opened" | "command-wait.checked" | "command-wait.expired">;
 export declare const terminal: readonly RunStatus[];
 export type Transition = {
     readonly kind: "moved";

package/dist/src/authority/transitions.js

@@ -18,6 +18,9 @@ export const eventTypes = [
     "effect.reported",
     "operation.reconciled",
     "schedule.skipped",
+    "command-wait.opened",
+    "command-wait.checked",
+    "command-wait.expired",
 ];
 export const numberFields = [
     "expectedRevision",
@@ -32,6 +35,8 @@ export const numberFields = [
     "sourceGeneration",
     "capacity",
     "slot",
+    "maximumWaitSeconds",
+    "pollEverySeconds",
 ];
 export const textFields = [
     "parentRunId",
@@ -72,6 +77,8 @@ export const textFields = [
     "issueUpdate",
     "result",
     "actor",
+    "waitName",
+    "commandOutput",
 ];
 export const terminal = [
     "completed",

package/dist/src/broker/actor/authority-queries.d.ts

@@ -33,6 +33,7 @@ export interface CompletionCursor {
     readonly terminal?: boolean;
 }
 export interface RunRecord extends RunState {
+    readonly admissionCommandId: string | null;
     readonly sequence: number;
 }
 export interface AuthorityQueries {
@@ -43,7 +44,7 @@ export interface AuthorityQueries {
     readonly eventsAfter: (cursor: EventCursor) => Promise<EventPage>;
     readonly latestCompletion: (cursor: CompletionCursor) => Promise<PublishedEvent | undefined>;
     readonly sequences: () => Promise<Sequences>;
-    readonly workflowIds: () => Promise<Readonly<Record<string, string>>>;
+    readonly workflowIds: (runIds?: readonly string[]) => Promise<Readonly<Record<string, string>>>;
     readonly runOrigins: () => Promise<RunOrigins>;
     readonly runLinks: () => Promise<Readonly<Record<string, RunLinks>>>;
 }

package/dist/src/broker/actor/authority-queries.js

@@ -6,11 +6,15 @@ import { storedEvents, storedRun } from "../authority-restore.js";
 import { documentDigest } from "../decision-restore.js";
 import { runLinks, } from "../../authority/handoff-chain.js";
 async function run(connection, runId) {
-    const row = await connection.get("SELECT run_id, status, revision, workflow, paused_from, gates, sequence FROM runs WHERE run_id = ?", [runId]);
+    const row = await connection.get("SELECT r.run_id, r.status, r.revision, r.workflow, r.paused_from, r.gates, r.sequence, c.command_id AS admission_command_id FROM runs r LEFT JOIN events c ON c.run_id = r.run_id AND c.type = 'run.created' WHERE r.run_id = ? ORDER BY c.sequence LIMIT 1", [runId]);
     if (row === undefined)
         return undefined;
     const record = runRow(row);
-    return { ...storedRun(record), sequence: record.sequence };
+    return {
+        ...storedRun(record),
+        sequence: record.sequence,
+        admissionCommandId: optionalText(row, "admission_command_id"),
+    };
 }
 async function runOrigins(connection, cursor) {
     const rows = await connection.all("SELECT run_id, json_extract(payload, '$.parentRunId') AS parent_run_id, coalesce(json_extract(payload, '$.chainId'), run_id) AS chain_id FROM events WHERE type = 'run.created' AND sequence > ? AND sequence <= ? ORDER BY sequence", [cursor.after, cursor.through]);
@@ -84,8 +88,13 @@ async function sequences(connection) {
         times: Object.fromEntries(rows.map((row) => [text(row, "run_id"), text(row, "recorded_at")])),
     };
 }
-async function workflowIds(connection) {
-    const rows = await connection.all("SELECT d.run_id, json_extract(s.body, '$.workflowId') AS workflow_id FROM run_details d JOIN documents s ON s.digest = d.submission WHERE json_valid(s.body) AND json_type(s.body, '$.workflowId') = 'text'");
+async function workflowIds(connection, runIds) {
+    if (runIds?.length === 0)
+        return {};
+    const scoped = runIds === undefined
+        ? ""
+        : ` AND d.run_id IN (${runIds.map(() => "?").join(", ")})`;
+    const rows = await connection.all(`SELECT d.run_id, json_extract(s.body, '$.workflowId') AS workflow_id FROM run_details d JOIN documents s ON s.digest = d.submission WHERE json_valid(s.body) AND json_type(s.body, '$.workflowId') = 'text'${scoped}`, runIds);
     return Object.fromEntries(rows.map((row) => [text(row, "run_id"), text(row, "workflow_id")]));
 }
 function cachedOrigins(read) {
@@ -142,7 +151,7 @@ export function authorityQueries(read) {
         eventsAfter: (cursor) => read((connection) => eventsAfter(connection, cursor)),
         latestCompletion: (cursor) => read((connection) => latestCompletion(connection, cursor)),
         sequences: () => read(sequences),
-        workflowIds: () => read(workflowIds),
+        workflowIds: (runIds) => read((connection) => workflowIds(connection, runIds)),
         runOrigins: origins,
         runLinks: currentLinks,
     };

package/dist/src/broker/actor/authority-receipts.js

@@ -24,7 +24,7 @@ export function oversized(request) {
         command["kind"] === "report-effect" &&
         command["worker"] === "command";
     const limit = report
-        ? maximumRequestBytes + commandLimits.stdoutBytes * 6
+        ? maximumRequestBytes + commandLimits.stdoutBytes * 12
         : maximumRequestBytes;
     return Buffer.byteLength(JSON.stringify(request)) > limit;
 }

package/dist/src/broker/actor/authority-settings.js

@@ -52,8 +52,8 @@ export function librarySettings(timing, log) {
         tableNamePrefix: "solid_",
         maxAttempts: 1,
         maxActivationDurationMilliseconds: 50,
-        maxPayloadBytes: 900_000 + commandLimits.stdoutBytes * 6,
-        maxResultBytes: 900_000 + commandLimits.stdoutBytes * 6,
+        maxPayloadBytes: 900_000 + commandLimits.stdoutBytes * 12,
+        maxResultBytes: 900_000 + commandLimits.stdoutBytes * 12,
         logger: lineLogger(log ?? standardError),
         leaseDurationMilliseconds: timing.leaseMilliseconds,
         leaseRenewalIntervalMilliseconds: timing.renewalMilliseconds,

package/dist/src/broker/actor/authority-upgrades.d.ts

@@ -1,7 +1,8 @@
-import { loadDecided } from "../../storage/decision-snapshots.ts";
+import { upgradeCommandWaits, upgradeCommandWaitChecks } from "../command-wait-restore.ts";
+import { loadDecided, loadEffected, loadWaiting, loadCurrent } from "../../storage/decision-snapshots.ts";
 import { loadSnapshot } from "../../storage/domain-rows.ts";
 import { upgradeDecisions } from "../decision-upgrade.ts";
-import { upgradeEffects } from "../effect-upgrade.ts";
+import { upgradeEffects, upgradeEventIndexes, upgradeSpendingIndexes } from "../effect-upgrade.ts";
 declare const upgrades: readonly [{
     readonly from: "adopted";
     readonly load: typeof loadSnapshot;
@@ -10,6 +11,22 @@ declare const upgrades: readonly [{
     readonly from: "decided";
     readonly load: typeof loadDecided;
     readonly apply: typeof upgradeEffects;
+}, {
+    readonly from: "effected";
+    readonly load: typeof loadEffected;
+    readonly apply: typeof upgradeCommandWaits;
+}, {
+    readonly from: "waiting";
+    readonly load: typeof loadWaiting;
+    readonly apply: typeof upgradeCommandWaitChecks;
+}, {
+    readonly from: "checked";
+    readonly load: typeof loadCurrent;
+    readonly apply: typeof upgradeSpendingIndexes;
+}, {
+    readonly from: "indexed";
+    readonly load: typeof loadCurrent;
+    readonly apply: typeof upgradeEventIndexes;
 }];
 export type UpgradeStep = (typeof upgrades)[number];
 export declare function upgradeSteps(kind: string): readonly UpgradeStep[];

package/dist/src/broker/actor/authority-upgrades.js

@@ -1,10 +1,15 @@
-import { loadDecided } from "../../storage/decision-snapshots.js";
+import { upgradeCommandWaits, upgradeCommandWaitChecks, } from "../command-wait-restore.js";
+import { loadDecided, loadEffected, loadWaiting, loadCurrent, } from "../../storage/decision-snapshots.js";
 import { loadSnapshot } from "../../storage/domain-rows.js";
 import { upgradeDecisions } from "../decision-upgrade.js";
-import { upgradeEffects } from "../effect-upgrade.js";
+import { upgradeEffects, upgradeEventIndexes, upgradeSpendingIndexes, } from "../effect-upgrade.js";
 const upgrades = [
     { from: "adopted", load: loadSnapshot, apply: upgradeDecisions },
     { from: "decided", load: loadDecided, apply: upgradeEffects },
+    { from: "effected", load: loadEffected, apply: upgradeCommandWaits },
+    { from: "waiting", load: loadWaiting, apply: upgradeCommandWaitChecks },
+    { from: "checked", load: loadCurrent, apply: upgradeSpendingIndexes },
+    { from: "indexed", load: loadCurrent, apply: upgradeEventIndexes },
 ];
 export function upgradeSteps(kind) {
     const first = upgrades.findIndex((step) => step.from === kind);

package/dist/src/broker/actor/delivery-intents.js

@@ -1,3 +1,4 @@
+import { commandWaitDeadline } from "../command-wait-restore.js";
 import { createHash } from "node:crypto";
 import { delivers, isSettled } from "../../authority/gates.js";
 import { eligibleIntents, } from "../../authority/reducer.js";
@@ -26,6 +27,7 @@ export function protectedIntent(state, attempt) {
         .filter((lease) => lease.resourceKey === operation.leaseKey)
         .map((lease) => ({
         ...intent,
+        ...commandWaitDeadline(state.commandWaits ?? {}, operation.operationId),
         workflow,
         purpose,
         inputDigest: operation.inputDigest,

package/dist/src/broker/actor/effect-delivery.d.ts

@@ -16,4 +16,4 @@ export interface Attempt {
     readonly effectId: string;
 }
 export declare function deliverEffect(parts: EffectDelivery, attempt: Attempt): Promise<JsonObject>;
-export declare function protectedArguments(value: JsonObject): EffectArguments;
+export declare function protectedArguments(value: JsonObject): EffectArguments & Pick<ProtectedIntent, "commandDeadline">;

package/dist/src/broker/actor/effect-delivery.js

@@ -1,3 +1,4 @@
+import { dispatchCommandWait, readCommandWaitDeadline, } from "../command-wait-restore.js";
 import { dispatchDecision, } from "../../authority/dispatch-decision.js";
 import { integer, optionalInteger, optionalText, text, } from "../../storage/domain-rows.js";
 import { budgetRow } from "../../storage/effect-rows.js";
@@ -16,11 +17,16 @@ const absent = {
     budget: undefined,
 };
 async function dispatchRead(connection, attempt) {
-    const row = await connection.get("SELECT d.outcome, d.input_digest, a.lease_generation, o.released_sequence, r.status, r.workflow, p.status AS operation_status, p.capability, p.units, l.operation_id AS lease_owner, l.generation, l.expires_at, l.state AS lease_state, b.run_id, b.effect_limit, b.spent, b.capabilities, b.exhausted_sequence FROM deliveries d JOIN outbox o ON o.operation_id = d.operation_id JOIN runs r ON r.run_id = o.run_id JOIN dispatch_attempts a ON a.effect_id = d.effect_id JOIN operations p ON p.operation_id = d.operation_id JOIN leases l ON l.resource_key = p.lease_key JOIN run_budgets b ON b.run_id = o.run_id WHERE d.effect_id = ? AND d.operation_id = ?", [attempt.effectId, attempt.intent.operationId]);
+    const row = await connection.get("SELECT d.outcome, d.input_digest, a.lease_generation, o.released_sequence, r.status, r.workflow, p.status AS operation_status, p.capability, p.units, p.method, p.target, p.payload, l.operation_id AS lease_owner, l.generation, l.expires_at, l.state AS lease_state, b.run_id, b.effect_limit, b.spent, b.capabilities, b.exhausted_sequence FROM deliveries d JOIN outbox o ON o.operation_id = d.operation_id JOIN runs r ON r.run_id = o.run_id JOIN dispatch_attempts a ON a.effect_id = d.effect_id JOIN operations p ON p.operation_id = d.operation_id JOIN leases l ON l.resource_key = p.lease_key JOIN run_budgets b ON b.run_id = o.run_id WHERE d.effect_id = ? AND d.operation_id = ?", [attempt.effectId, attempt.intent.operationId]);
     if (row === undefined)
         return absent;
     const workflow = text(row, "workflow");
     return {
+        ...(await dispatchCommandWait(connection, {
+            runId: attempt.intent.runId,
+            workflow,
+            operationId: attempt.intent.operationId,
+        })),
         attempt: {
             outcome: optionalText(row, "outcome"),
             inputDigest: text(row, "input_digest"),
@@ -37,6 +43,9 @@ async function dispatchRead(connection, attempt) {
             status: text(row, "operation_status"),
             capability: text(row, "capability"),
             units: integer(row, "units"),
+            method: text(row, "method"),
+            target: text(row, "target"),
+            payload: text(row, "payload"),
         },
         budget: storedBudget(budgetRow(row)),
         lease: {
@@ -52,7 +61,8 @@ async function called(parts, call) {
     const adapterCall = parts.delivery[name]?.bind(parts.delivery);
     if (adapterCall === undefined)
         return { kind: "unknown", reason: "stop-not-supported" };
-    return settlement(await parts.calls.call(intent.operationId, (signal) => adapterCall(intent, signal)), intent.capability === "command"
+    const deadline = await parts.reader.connection((connection) => readCommandWaitDeadline(connection, intent));
+    return settlement(await parts.calls.call(intent.operationId, (signal) => adapterCall({ ...intent, ...deadline }, signal)), intent.capability === "command"
         ? commandLimits.resultBytes
         : parts.effects.resultBytes);
 }
@@ -126,5 +136,8 @@ export function protectedArguments(value) {
         method: text(value, "method"),
         target: text(value, "target"),
         payload: text(value, "payload"),
+        ...(typeof value["commandDeadline"] === "string"
+            ? { commandDeadline: value["commandDeadline"] }
+            : {}),
     };
 }

package/dist/src/broker/actor/effect-plan.js

@@ -1,3 +1,5 @@
+import { operationPhase } from "../../operation-identity.js";
+import { endedCommandWaitCheck } from "../../authority/command-waits.js";
 import { isInstant } from "../../authority/instants.js";
 import { promotions } from "../../authority/leases.js";
 import { execute } from "../../authority/reducer.js";
@@ -45,7 +47,9 @@ function closure(state, operation) {
         return ["run-ended"];
     const exhausted = (state.effects.budgets[operation.runId]?.exhaustedSequence ?? null) !==
         null;
-    return exhausted ? ["budget-exhausted"] : [];
+    return exhausted && operationPhase(operation.operationId) !== "command-wait"
+        ? ["budget-exhausted"]
+        : [];
 }
 function unblocked(state, followUp) {
     const steps = [];
@@ -95,6 +99,9 @@ const outcomes = {
     }),
     completed: (attempt) => stated({
         outcome: "completed",
+        ...(attempt.worker === "command"
+            ? { commandOutput: attempt.result }
+            : {}),
         result: attempt.result === null ? null : documentDigest(attempt.result),
         reason: attempt.reason,
         ...identified(attempt),
@@ -155,7 +162,9 @@ function acceptedNow(reconciling) {
 export function reconciliations(state, reconciling) {
     const accepted = acceptedNow(reconciling);
     const rejected = rejectedReports(reconciling.results);
-    const due = (operation) => state.runs[operation.runId]?.status !== "cancelled" && live(operation);
+    const due = (operation) => state.runs[operation.runId]?.status !== "cancelled" &&
+        !endedCommandWaitCheck(state.commandWaits ?? {}, operation.operationId) &&
+        live(operation);
     const live = (operation) => (operation.status === "recovering" &&
         !accepted.has(operation.operationId)) ||
         (operation.status === "blocked" && rejected.has(operation.operationId));

package/dist/src/broker/actor/effect-queries.d.ts

@@ -8,6 +8,10 @@ export interface OperationView extends OperationRow {
 }
 export type StoredDisposition = Omit<Evidence, "sequence">;
 export interface EffectQueries {
+    readonly workerTurns: (window: {
+        readonly after: string;
+        readonly through: string;
+    }) => Promise<readonly OperationView[]>;
     readonly operation: (operationId: string) => Promise<OperationView | undefined>;
     readonly operations: (runId: string) => Promise<readonly OperationView[]>;
     readonly evidence: (runId: string) => Promise<readonly number[]>;

package/dist/src/broker/actor/effect-queries.js

@@ -34,7 +34,9 @@ const viewColumns = operationColumns
     .map((name) => `o.${name}`)
     .join(", ");
 const waitCause = "CASE WHEN o.status != 'waiting' THEN NULL WHEN r.status != 'running' THEN 'run-not-running' WHEN EXISTS (SELECT 1 FROM leases h WHERE h.resource_key = o.lease_key AND h.state != 'released') THEN 'resource' ELSE 'ready' END";
-const viewed = `SELECT ${viewColumns}, l.generation AS lease_generation, ${waitCause} AS wait_cause FROM operations o JOIN runs r ON r.run_id = o.run_id LEFT JOIN leases l ON l.resource_key = o.lease_key AND l.operation_id = o.operation_id AND l.state != 'released'`;
+const viewSelection = `SELECT ${viewColumns}, l.generation AS lease_generation, ${waitCause} AS wait_cause`;
+const viewJoins = "JOIN runs r ON r.run_id = o.run_id LEFT JOIN leases l ON l.resource_key = o.lease_key AND l.operation_id = o.operation_id AND l.state != 'released'";
+const viewed = `${viewSelection} FROM operations o ${viewJoins}`;
 function operationView(row) {
     return {
         ...operationRow(row),
@@ -52,6 +54,11 @@ async function operations(connection, runId) {
     const rows = await connection.all(`${viewed} WHERE o.run_id = ? ORDER BY o.requested_sequence`, [runId]);
     return rows.map(operationView);
 }
+async function workerTurns(connection, window) {
+    const settled = await connection.all(`${viewSelection} FROM events e CROSS JOIN operations o ${viewJoins} WHERE o.settled_sequence = e.sequence AND o.capability = 'claude' AND julianday(e.recorded_at) > julianday(?) AND julianday(e.recorded_at) <= julianday(?)`, [window.after, window.through]);
+    const open = await connection.all(`${viewSelection} FROM operations o INDEXED BY operations_worker_open ${viewJoins} WHERE o.capability = 'claude' AND o.settled_sequence IS NULL AND o.status NOT IN ('refused', 'completed', 'failed', 'stopped', 'cancelled')`);
+    return [...settled, ...open].map(operationView);
+}
 async function evidence(connection, runId) {
     const rows = await connection.all("SELECT e.sequence FROM effect_evidence e JOIN events v ON v.sequence = e.sequence WHERE e.run_id = ? AND (e.disposition IN ('rejected', 'denied', 'refused') OR (v.type = 'operation.reconciled' AND json_extract(v.payload, '$.outcome') = 'unknown')) ORDER BY e.sequence", [runId]);
     return rows.map((row) => integer(row, "sequence"));
@@ -74,6 +81,7 @@ async function budget(connection, runId) {
 }
 export function effectQueries(read, settings) {
     return {
+        workerTurns: (window) => read((connection) => workerTurns(connection, window)),
         stops: (runId) => read((connection) => stops(connection, runId)),
         closure: (runId) => read((connection) => storedClosure(connection, { runId, stopLimit: settings.stopLimit })),
         settledAt: (runId) => read((connection) => settledAt(connection, runId)),

package/dist/src/broker/actor/effect-turn.js

@@ -1,3 +1,4 @@
+import { readCommandWaitDeadline } from "../command-wait-restore.js";
 import { detailColumns, detailRow } from "../../storage/decision-rows.js";
 import { integer, runRow, text, } from "../../storage/domain-rows.js";
 import { storedRun } from "../authority-restore.js";
@@ -57,6 +58,7 @@ export async function pendingEffect(connection, attempt) {
     return {
         ...intent,
         purpose,
+        ...(await readCommandWaitDeadline(connection, intent)),
         inputDigest: text(row, "input_digest"),
         leaseGeneration: integer(row, "generation"),
         capability: text(row, "capability"),

package/dist/src/broker/actor/stop-plan.js

@@ -1,3 +1,4 @@
+import { endedCommandWaitCheck } from "../../authority/command-waits.js";
 import { stopAttempts, } from "../../authority/stop-sequence.js";
 import { observingIntent, protectedIntent, } from "./delivery-intents.js";
 function present(state, planning) {
@@ -33,9 +34,14 @@ export function presentSubjects(state, planning) {
 }
 export function stopIntents(state, planning) {
     const { runId, stopping } = planning;
-    if (state.runs[runId]?.status !== "cancelled")
-        return [];
-    const subjects = presentSubjects(state, planning);
+    const cancelled = state.runs[runId]?.status === "cancelled";
+    const subjects = presentSubjects(state, planning).flatMap((subject) => {
+        if (endedCommandWaitCheck(state.commandWaits ?? {}, subject.operationId))
+            return [
+                { ...subject, stopSequence: subject.stopSequence ?? state.sequence },
+            ];
+        return cancelled ? [subject] : [];
+    });
     return stopAttempts(subjects, {
         cancelledSequence: planning.cancelledNow[0] ?? stopping.cancelledSequence ?? 0,
         stopLimit: planning.stopLimit,

package/dist/src/broker/actor/stop-turn.d.ts

@@ -1,4 +1,5 @@
 import type { StopSubject } from "../../authority/stop-sequence.ts";
+import type { CommandWaitsState } from "../../authority/command-waits.ts";
 import { type SqlConnection } from "../../storage/domain-rows.ts";
 export interface Stopping {
     readonly subjects: readonly StopSubject[];
@@ -10,6 +11,7 @@ export declare function turnStopping(connection: SqlConnection, scope: {
     readonly runId: string;
     readonly status: string | undefined;
     readonly kind: string;
+    readonly commandWaits?: CommandWaitsState;
 }): Promise<Stopping>;
 export declare function droppedRuns(connection: SqlConnection, rule: {
     readonly limit: number;