cloving 1.3.0 → 1.4.0

package/dist/src/storage/command-wait-rows.js

@@ -0,0 +1,96 @@
+import { integer, optionalInteger, optionalText, text, } from "./domain-rows.js";
+import { upsert } from "./statements.js";
+export const commandWaitSchema = `
+CREATE TABLE command_waits (
+  run_id TEXT NOT NULL REFERENCES runs (run_id) DEFERRABLE INITIALLY DEFERRED,
+  name TEXT NOT NULL,
+  command TEXT NOT NULL,
+  input_digest TEXT NOT NULL REFERENCES documents (digest) DEFERRABLE INITIALLY DEFERRED,
+  maximum_wait_seconds INTEGER NOT NULL,
+  poll_every_seconds INTEGER NOT NULL,
+  started_at INTEGER NOT NULL,
+  deadline INTEGER NOT NULL,
+  next_check_at INTEGER,
+  state TEXT NOT NULL,
+  settled_at INTEGER,
+  reason TEXT,
+  PRIMARY KEY (run_id, name)
+) STRICT;
+`;
+export const commandWaitCheckSchema = `
+ALTER TABLE command_waits ADD COLUMN check_count INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE command_waits ADD COLUMN check_operation TEXT;
+ALTER TABLE command_waits ADD COLUMN last_check_settled_at INTEGER;
+ALTER TABLE command_waits ADD COLUMN result TEXT;
+`;
+const openingColumns = "run_id, name, command, input_digest, maximum_wait_seconds, poll_every_seconds, started_at, deadline, next_check_at, state, settled_at, reason";
+const checkColumns = "check_count, check_operation, last_check_settled_at, result";
+const columns = `${openingColumns}, ${checkColumns}`;
+const save = upsert({
+    table: "command_waits",
+    names: columns.split(", "),
+    key: 2,
+});
+export function commandWaitRow(value) {
+    return {
+        runId: text(value, "run_id"),
+        name: text(value, "name"),
+        command: text(value, "command"),
+        inputDigest: text(value, "input_digest"),
+        maximumWaitSeconds: integer(value, "maximum_wait_seconds"),
+        pollEverySeconds: integer(value, "poll_every_seconds"),
+        startedAt: integer(value, "started_at"),
+        deadline: integer(value, "deadline"),
+        nextCheckAt: optionalInteger(value, "next_check_at"),
+        state: text(value, "state"),
+        checkCount: integer(value, "check_count"),
+        checkOperation: optionalText(value, "check_operation"),
+        lastCheckSettledAt: optionalInteger(value, "last_check_settled_at"),
+        result: optionalText(value, "result"),
+        settledAt: optionalInteger(value, "settled_at"),
+        reason: optionalText(value, "reason"),
+    };
+}
+export async function loadCommandWaits(connection, scope = {}) {
+    const { runId } = scope;
+    const selected = scope.version === "opened"
+        ? `${openingColumns}, 0 AS check_count, NULL AS check_operation, NULL AS last_check_settled_at, NULL AS result`
+        : columns;
+    const rows = await connection.all(`SELECT ${selected} FROM command_waits` +
+        (runId === undefined ? "" : " WHERE run_id = ?") +
+        " ORDER BY run_id, name", runId === undefined ? [] : [runId]);
+    return rows.map(commandWaitRow);
+}
+export function commandWaitStatements(rows, scope = {}) {
+    return rows.map((row) => ({
+        sql: scope.version === "opened"
+            ? upsert({
+                table: "command_waits",
+                names: openingColumns.split(", "),
+                key: 2,
+            })
+            : save,
+        parameters: [
+            row.runId,
+            row.name,
+            row.command,
+            row.inputDigest,
+            row.maximumWaitSeconds,
+            row.pollEverySeconds,
+            row.startedAt,
+            row.deadline,
+            row.nextCheckAt,
+            row.state,
+            row.settledAt,
+            row.reason,
+            ...(scope.version === "opened"
+                ? []
+                : [
+                    row.checkCount,
+                    row.checkOperation,
+                    row.lastCheckSettledAt,
+                    row.result,
+                ]),
+        ],
+    }));
+}

package/dist/src/storage/decision-snapshots.d.ts

@@ -1,3 +1,4 @@
+import { type CommandWaitRow } from "./command-wait-rows.ts";
 import { type DecisionRows, type DocumentRow } from "./decision-rows.ts";
 import { type AttemptRow, type DomainSnapshot, type ProjectionRows, type SqlConnection } from "./domain-rows.ts";
 import { type EffectRows } from "./effect-rows.ts";
@@ -5,14 +6,20 @@ export interface ProjectionSnapshot extends ProjectionRows, DecisionRows {
     readonly deliveries: readonly AttemptRow[];
     readonly pending: readonly string[];
     readonly sequence: number;
+    readonly waits?: readonly CommandWaitRow[];
 }
 export interface DecidedSnapshot extends DomainSnapshot, DecisionRows {
     readonly documents: readonly DocumentRow[];
 }
-export interface CurrentSnapshot extends DecidedSnapshot {
+export interface EffectedSnapshot extends DecidedSnapshot {
     readonly effects: EffectRows;
 }
+export interface CurrentSnapshot extends EffectedSnapshot {
+    readonly waits: readonly CommandWaitRow[];
+}
 export declare function loadOperationSnapshot(connection: SqlConnection): Promise<Pick<ProjectionSnapshot, "outbox" | "deliveries">>;
 export declare function loadProjections(connection: SqlConnection): Promise<ProjectionSnapshot>;
 export declare function loadDecided(connection: SqlConnection): Promise<DecidedSnapshot>;
+export declare function loadEffected(connection: SqlConnection): Promise<EffectedSnapshot>;
 export declare function loadCurrent(connection: SqlConnection): Promise<CurrentSnapshot>;
+export declare function loadWaiting(connection: SqlConnection): Promise<CurrentSnapshot>;

package/dist/src/storage/decision-snapshots.js

@@ -1,3 +1,4 @@
+import { loadCommandWaits } from "./command-wait-rows.js";
 import { loadDecisions, loadDocuments, } from "./decision-rows.js";
 import { latestSequence, loadAttempts, loadSnapshot, outboxRow, projectionRows, text, } from "./domain-rows.js";
 import { loadEffects } from "./effect-rows.js";
@@ -9,6 +10,7 @@ export async function loadOperationSnapshot(connection) {
 }
 export async function loadProjections(connection) {
     return {
+        waits: await loadCommandWaits(connection),
         ...(await projectionRows(connection)),
         ...(await loadDecisions(connection)),
         deliveries: await loadAttempts(connection),
@@ -23,9 +25,21 @@ export async function loadDecided(connection) {
         documents: await loadDocuments(connection),
     };
 }
-export async function loadCurrent(connection) {
+export async function loadEffected(connection) {
     return {
         ...(await loadDecided(connection)),
         effects: await loadEffects(connection),
     };
 }
+export async function loadCurrent(connection) {
+    return {
+        ...(await loadEffected(connection)),
+        waits: await loadCommandWaits(connection),
+    };
+}
+export async function loadWaiting(connection) {
+    return {
+        ...(await loadEffected(connection)),
+        waits: await loadCommandWaits(connection, { version: "opened" }),
+    };
+}

package/dist/src/storage/domain-changes.d.ts

@@ -1,3 +1,4 @@
+import { type CommandWaitRow } from "./command-wait-rows.ts";
 import { type DetailRow, type DocumentRow, type GateRow } from "./decision-rows.ts";
 import { type CommandRow, type DefinitionRow, type EventRow, type RunRow, type SqlConnection } from "./domain-rows.ts";
 import { type EffectRows } from "./effect-rows.ts";
@@ -37,6 +38,7 @@ export interface DomainChange extends EffectRows {
     readonly staged: readonly StagedDelivery[];
     readonly closed: readonly ClosedDelivery[];
     readonly gates: readonly GateRow[];
+    readonly waits: readonly CommandWaitRow[];
     readonly details: readonly DetailRow[];
     readonly documents: readonly DocumentRow[];
     readonly completesAdoption: boolean;

package/dist/src/storage/domain-changes.js

@@ -1,3 +1,4 @@
+import { commandWaitRow, commandWaitStatements, } from "./command-wait-rows.js";
 import { detailColumns, detailRow, documentRow, gateColumns, gateRow, } from "./decision-rows.js";
 import { commandRow, definitionRow, eventRow, integer, latestSequence, optionalInteger, optionalText, runRow, text, } from "./domain-rows.js";
 import { effectStatements } from "./effect-changes.js";
@@ -48,6 +49,7 @@ function statements(change) {
         ...deliveryStatements(change),
         ...decisionStatements(change),
         ...effectStatements(change),
+        ...commandWaitStatements(change.waits),
         ...(change.completesAdoption
             ? [
                 {
@@ -195,6 +197,7 @@ function parseChange(value) {
             receipt: optionalText(row, "receipt"),
         })),
         gates: list(value, "gates").map(gateRow),
+        waits: list(value, "waits").map(commandWaitRow),
         details: list(value, "details").map(detailRow),
         documents: list(value, "documents").map(documentRow),
         budgets: list(value, "budgets").map(budgetRow),

package/dist/src/storage/domain-schema.d.ts

@@ -2,7 +2,11 @@ import { type SqlConnection } from "./domain-rows.ts";
 export declare const baselineVersion = 1;
 export declare const adoptedVersion = 2;
 export declare const decidedVersion = 3;
-export declare const currentVersion = 4;
+export declare const effectedVersion = 4;
+export declare const waitingVersion = 5;
+export declare const checkedVersion = 6;
+export declare const spendingVersion = 7;
+export declare const currentVersion = 8;
 export declare const baselineSchema = "\nCREATE TABLE schema_migrations (\n  version INTEGER PRIMARY KEY,\n  checksum TEXT NOT NULL\n) STRICT;\nCREATE TABLE events (\n  sequence INTEGER PRIMARY KEY,\n  type TEXT NOT NULL,\n  run_id TEXT NOT NULL,\n  command_id TEXT NOT NULL UNIQUE,\n  recorded_at TEXT NOT NULL,\n  request TEXT NOT NULL,\n  payload TEXT NOT NULL\n) STRICT;\nCREATE TABLE definitions (\n  pin TEXT PRIMARY KEY,\n  manifest TEXT NOT NULL\n) STRICT;\nCREATE TABLE runs (\n  run_id TEXT PRIMARY KEY,\n  status TEXT NOT NULL,\n  revision INTEGER NOT NULL,\n  workflow TEXT NOT NULL REFERENCES definitions (pin) DEFERRABLE INITIALLY DEFERRED,\n  paused_from TEXT,\n  gates TEXT NOT NULL,\n  sequence INTEGER NOT NULL REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED\n) STRICT;\nCREATE TABLE commands (\n  command_id TEXT PRIMARY KEY,\n  request TEXT NOT NULL,\n  sequence INTEGER NOT NULL UNIQUE REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED\n) STRICT;\nCREATE TABLE outbox (\n  operation_id TEXT PRIMARY KEY,\n  kind TEXT NOT NULL,\n  run_id TEXT NOT NULL REFERENCES runs (run_id) DEFERRABLE INITIALLY DEFERRED,\n  created_sequence INTEGER NOT NULL REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED,\n  released_sequence INTEGER REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED\n) STRICT;\n";
 export type SchemaRefusal = {
     readonly kind: "refused";
@@ -17,6 +21,14 @@ export type SchemaState = {
     readonly kind: "adopted";
 } | {
     readonly kind: "decided";
+} | {
+    readonly kind: "effected";
+} | {
+    readonly kind: "waiting";
+} | {
+    readonly kind: "checked";
+} | {
+    readonly kind: "indexed";
 } | {
     readonly kind: "current";
 } | SchemaRefusal;

package/dist/src/storage/domain-schema.js

@@ -1,11 +1,16 @@
 import { createHash, randomUUID } from "node:crypto";
 import { DatabaseSync } from "node:sqlite";
 import { integer, optionalInteger, optionalText, text, } from "./domain-rows.js";
-import { effectSchema } from "./effect-schema.js";
+import { commandWaitSchema, commandWaitCheckSchema, } from "./command-wait-rows.js";
+import { effectSchema, spendingIndexes } from "./effect-schema.js";
 export const baselineVersion = 1;
 export const adoptedVersion = 2;
 export const decidedVersion = 3;
-export const currentVersion = 4;
+export const effectedVersion = 4;
+export const waitingVersion = 5;
+export const checkedVersion = 6;
+export const spendingVersion = 7;
+export const currentVersion = 8;
 export const baselineSchema = `
 CREATE TABLE schema_migrations (
   version INTEGER PRIMARY KEY,
@@ -102,9 +107,27 @@ CREATE TABLE documents (
   body TEXT NOT NULL
 ) STRICT;
 `;
-const schemas = [baselineSchema, adoption, decisions, effectSchema];
+const schemas = [
+    baselineSchema,
+    adoption,
+    decisions,
+    effectSchema,
+    commandWaitSchema,
+    commandWaitCheckSchema,
+    spendingIndexes,
+    "CREATE INDEX events_run_type_sequence ON events (run_id, type, sequence);",
+];
 const checksums = schemas.map((schema) => createHash("sha256").update(schema).digest("hex"));
-const versionKinds = ["baseline", "adopted", "decided", "current"];
+const versionKinds = [
+    "baseline",
+    "adopted",
+    "decided",
+    "effected",
+    "waiting",
+    "checked",
+    "indexed",
+    "current",
+];
 export async function inspectSchema(connection) {
     const version = integer(await connection.get("PRAGMA user_version"), "user_version");
     const detail = String(version);
@@ -132,6 +155,10 @@ export async function createSchema(connection) {
     await recordVersion(connection, baselineVersion);
     await adoptSchema(connection, null);
     await upgradeSchema(connection, decidedVersion);
+    await upgradeSchema(connection, effectedVersion);
+    await upgradeSchema(connection, waitingVersion);
+    await upgradeSchema(connection, checkedVersion);
+    await upgradeSchema(connection, spendingVersion);
     await upgradeSchema(connection, currentVersion);
 }
 export async function upgradeSchema(connection, version) {

package/dist/src/storage/effect-schema.d.ts

@@ -1 +1,2 @@
 export declare const effectSchema = "\nCREATE TABLE run_budgets (\n  run_id TEXT PRIMARY KEY REFERENCES runs (run_id) DEFERRABLE INITIALLY DEFERRED,\n  effect_limit INTEGER NOT NULL,\n  spent INTEGER NOT NULL CHECK (spent <= effect_limit),\n  capabilities TEXT NOT NULL,\n  exhausted_sequence INTEGER REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED\n) STRICT;\nCREATE TABLE operations (\n  operation_id TEXT PRIMARY KEY,\n  run_id TEXT NOT NULL REFERENCES runs (run_id) DEFERRABLE INITIALLY DEFERRED,\n  capability TEXT NOT NULL,\n  method TEXT NOT NULL,\n  target TEXT NOT NULL,\n  payload TEXT NOT NULL,\n  input_digest TEXT NOT NULL,\n  units INTEGER NOT NULL,\n  lease_key TEXT NOT NULL,\n  recovery_limit INTEGER NOT NULL,\n  status TEXT NOT NULL,\n  reason TEXT,\n  attempts INTEGER NOT NULL,\n  receipt TEXT,\n  worker TEXT,\n  result TEXT,\n  requested_sequence INTEGER NOT NULL REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED,\n  wait_sequence INTEGER REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED,\n  settled_sequence INTEGER REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED\n) STRICT;\nCREATE INDEX operations_run ON operations (run_id);\nCREATE INDEX operations_waiting ON operations (wait_sequence) WHERE status = 'waiting';\nCREATE TABLE leases (\n  resource_key TEXT PRIMARY KEY,\n  operation_id TEXT NOT NULL REFERENCES operations (operation_id) DEFERRABLE INITIALLY DEFERRED,\n  generation INTEGER NOT NULL CHECK (generation > 0),\n  expires_at TEXT NOT NULL,\n  state TEXT NOT NULL CHECK (state IN ('held', 'expired', 'released')),\n  granted_sequence INTEGER NOT NULL REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED\n) STRICT;\nCREATE INDEX leases_due ON leases (expires_at) WHERE state = 'held';\nCREATE TABLE effect_evidence (\n  sequence INTEGER PRIMARY KEY REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED,\n  run_id TEXT NOT NULL,\n  operation_id TEXT NOT NULL,\n  disposition TEXT NOT NULL,\n  reason TEXT\n) STRICT;\nCREATE TABLE stopped_operations (\n  operation_id TEXT PRIMARY KEY,\n  run_id TEXT NOT NULL REFERENCES runs (run_id) DEFERRABLE INITIALLY DEFERRED,\n  sequence INTEGER NOT NULL REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED\n) STRICT;\nCREATE TABLE dispatch_attempts (\n  effect_id TEXT PRIMARY KEY REFERENCES deliveries (effect_id) DEFERRABLE INITIALLY DEFERRED,\n  purpose TEXT NOT NULL,\n  lease_generation INTEGER,\n  authority_epoch INTEGER NOT NULL\n) STRICT;\n";
+export declare const spendingIndexes = "\nCREATE INDEX events_spend_window ON events (julianday(recorded_at));\nCREATE INDEX operations_worker_settled ON operations (settled_sequence) WHERE capability = 'claude';\nCREATE INDEX operations_worker_open ON operations (requested_sequence) WHERE capability = 'claude' AND settled_sequence IS NULL AND status NOT IN ('refused', 'completed', 'failed', 'stopped', 'cancelled');\n";

package/dist/src/storage/effect-schema.js

@@ -57,3 +57,8 @@ CREATE TABLE dispatch_attempts (
   authority_epoch INTEGER NOT NULL
 ) STRICT;
 `;
+export const spendingIndexes = `
+CREATE INDEX events_spend_window ON events (julianday(recorded_at));
+CREATE INDEX operations_worker_settled ON operations (settled_sequence) WHERE capability = 'claude';
+CREATE INDEX operations_worker_open ON operations (requested_sequence) WHERE capability = 'claude' AND settled_sequence IS NULL AND status NOT IN ('refused', 'completed', 'failed', 'stopped', 'cancelled');
+`;

package/dist/src/testing-requests.d.ts

@@ -0,0 +1,15 @@
+import type { ProtectedRequest, GateRequest, HandoffRequest, RunWaitRequest, CommandWaitRequest } from "./step-bridge.ts";
+export type ScenarioRequest = readonly ["effect", ProtectedRequest] | readonly ["gate", GateRequest] | readonly ["waitForDecision", GateRequest] | readonly ["handoff", HandoffRequest] | readonly ["waitForRun", RunWaitRequest] | readonly ["waitForCommand", CommandWaitRequest] | readonly [
+    "sleep",
+    {
+        readonly seconds: number;
+    } | {
+        readonly until: string;
+    }
+];
+export interface ScenarioResult {
+    readonly spent?: number;
+    readonly outcome: unknown;
+    readonly requests: readonly ScenarioRequest[];
+}
+export declare function scenarioResult(value: unknown): value is ScenarioResult;

package/dist/src/testing-requests.js

@@ -0,0 +1,93 @@
+import { isInstant } from "./authority/instants.js";
+import { isCommandWaitRequest } from "./command-wait.js";
+import { record } from "./protocol.js";
+export function scenarioResult(value) {
+    const result = record(value);
+    return (result !== undefined &&
+        Object.hasOwn(result, "outcome") &&
+        Array.isArray(result["requests"]) &&
+        result["requests"].every(scenarioRequest) &&
+        (result["spent"] === undefined || typeof result["spent"] === "number"));
+}
+function scenarioRequest(value) {
+    if (!requestPair(value))
+        return false;
+    const request = record(value[1]);
+    if (request === undefined)
+        return false;
+    switch (value[0]) {
+        case "effect":
+            return protectedRequest(request);
+        case "gate":
+        case "waitForDecision":
+            return gateRequest(request);
+        case "handoff":
+            return handoffRequest(request);
+        case "waitForRun":
+            return runWaitRequest(request);
+        case "waitForCommand":
+            return isCommandWaitRequest(request);
+        case "sleep":
+            return sleepRequest(request);
+        default:
+            return false;
+    }
+}
+function requestPair(value) {
+    return Array.isArray(value) && value.length === 2;
+}
+function runWaitRequest(request) {
+    return (typeof request["runId"] === "string" &&
+        typeof request["maximumWaitSeconds"] === "number");
+}
+function sleepRequest(request) {
+    if (typeof request["until"] === "string")
+        return isInstant(request["until"]);
+    const seconds = request["seconds"];
+    return (typeof seconds === "number" &&
+        Number.isInteger(seconds) &&
+        seconds >= 1 &&
+        seconds <= 86400);
+}
+function gateRequest(request) {
+    return (typeof request["gateId"] === "string" &&
+        (request["kind"] === "question" || request["kind"] === "approval") &&
+        typeof request["prompt"] === "string" &&
+        optionalText(request["expiresAt"]));
+}
+function handoffRequest(request) {
+    const input = record(request["input"]);
+    return (typeof request["workflowId"] === "string" &&
+        input !== undefined &&
+        Object.values(input).every(handoffValue));
+}
+function protectedRequest(request) {
+    return (protectedScope(request["scope"]) &&
+        ["capability", "method", "target", "payload"].every((key) => typeof request[key] === "string") &&
+        typeof request["units"] === "number" &&
+        optionalText(request["resource"]));
+}
+function protectedScope(value) {
+    const scope = record(value);
+    if (scope === undefined)
+        return false;
+    const stage = record(scope["stage"]);
+    return (typeof scope["phase"] === "string" &&
+        typeof scope["operation"] === "string" &&
+        typeof scope["round"] === "number" &&
+        optionalText(scope["key"]) &&
+        (scope["stage"] === undefined ||
+            (stage !== undefined &&
+                ["id", "visit", "branch"].every((key) => typeof stage[key] === "string"))));
+}
+function optionalText(value) {
+    return value === undefined || typeof value === "string";
+}
+function handoffValue(value) {
+    if (value === null || ["string", "boolean", "number"].includes(typeof value))
+        return true;
+    if (Array.isArray(value))
+        return value.every(handoffValue);
+    const fields = record(value);
+    return fields !== undefined && Object.values(fields).every(handoffValue);
+}

package/dist/src/testing.d.ts

@@ -1,5 +1,7 @@
-import { type HandoffValue, type ProtectedResult, type GateResult, type DecisionResult, type RunWaitOutcome, type ProtectedRequest, type GateRequest, type HandoffRequest, type RunWaitRequest } from "./step-bridge.ts";
+import { type ScenarioRequest, type ScenarioResult } from "./testing-requests.ts";
+import { type HandoffValue, type ProtectedResult, type GateResult, type DecisionResult, type RunWaitOutcome, type CommandWaitProgress } from "./step-bridge.ts";
 export interface StepScenario {
+    readonly commandWaits?: Readonly<Record<string, readonly CommandWaitProgress[]>>;
     readonly turn?: ProtectedResult;
     readonly effects?: Readonly<Record<string, readonly ProtectedResult[]>>;
     readonly gate?: GateResult;
@@ -11,16 +13,8 @@ export interface WorkflowScenario extends StepScenario {
     readonly workflow: string;
     readonly exportName: string;
     readonly input: HandoffValue;
-    readonly decision?: HandoffValue;
-}
-export type ScenarioRequest = readonly ["effect", ProtectedRequest] | readonly ["gate", GateRequest] | readonly ["waitForDecision", GateRequest] | readonly ["handoff", HandoffRequest] | readonly ["waitForRun", RunWaitRequest] | readonly ["sleep", {
-    readonly seconds: number;
-}];
-export interface ScenarioResult {
-    readonly spent?: number;
-    readonly outcome: unknown;
-    readonly requests: readonly ScenarioRequest[];
 }
+export type { ScenarioRequest, ScenarioResult } from "./testing-requests.ts";
 export declare function fakeStepBridge(scenario: StepScenario): {
     requests: ScenarioRequest[];
     readonly spent: number;

package/dist/src/testing.js

@@ -5,7 +5,7 @@ import { join, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { workflowTestLoader } from "../tools/workflow-test-loader.js";
 import { authorizeEffect } from "./effect-authorization.js";
-import { record } from "./protocol.js";
+import { scenarioResult, } from "./testing-requests.js";
 import { stepBridgeKey, } from "./step-bridge.js";
 export function fakeStepBridge(scenario) {
     const { bridge, requests, budget } = scenarioBridge(scenario);
@@ -22,7 +22,12 @@ export function fakeStepBridge(scenario) {
     Object.defineProperty(globalThis, sleepKey, {
         configurable: true,
         value: (milliseconds) => {
-            requests.push(["sleep", { seconds: milliseconds / 1000 }]);
+            requests.push([
+                "sleep",
+                milliseconds instanceof Date
+                    ? { until: milliseconds.toISOString() }
+                    : { seconds: milliseconds / 1000 },
+            ]);
             return Promise.resolve();
         },
     });
@@ -50,6 +55,7 @@ function scenarioBridge(scenario) {
     const budget = { spent: 0 };
     const bridge = {
         ...scenarioEffects(scenario, { requests, budget }),
+        ...scenarioCommandWaits(scenario, requests),
         gate: (request) => {
             requests.push(["gate", request]);
             return Promise.resolve(scenario.gate ?? {
@@ -75,6 +81,30 @@ function scenarioBridge(scenario) {
     };
     return { bridge, requests, budget };
 }
+function scenarioCommandWaits(scenario, requests) {
+    const waits = new Map(Object.entries(scenario.commandWaits ?? {}).map(([name, values]) => [
+        name,
+        [...values],
+    ]));
+    return {
+        openCommandWait: (request) => {
+            requests.push(["waitForCommand", request]);
+            if (!waits.get(request.name)?.length)
+                return Promise.reject(new Error("no-scenario-result"));
+            return Promise.resolve({
+                kind: "pending",
+                deadline: 0,
+                nextCheckAt: 0,
+            });
+        },
+        checkCommandWait: (request) => {
+            const result = waits.get(request.name)?.shift();
+            if (result === undefined)
+                return Promise.reject(new Error("no-scenario-result"));
+            return Promise.resolve(result);
+        },
+    };
+}
 function scenarioEffects(scenario, state) {
     const { requests, budget } = state;
     const effects = new Map(Object.entries(scenario.effects ?? {}).map(([key, values]) => [
@@ -133,93 +163,10 @@ const given = ${JSON.stringify(scenario)};
 const workflow = workflows[given.exportName];
 if (typeof workflow !== "function") throw new Error("workflow-test-export-missing");
 using bridge = fakeStepBridge(given);
-const outcome = await workflow(given.input, given.decision);
+const outcome = await workflow(given.input);
 await writeFile(process.argv[2], JSON.stringify({ outcome, requests: bridge.requests,
   ...(given.effectLimit === undefined ? {} : { spent: bridge.spent }) }));`;
 }
-function scenarioResult(value) {
-    const result = record(value);
-    return (result !== undefined &&
-        Object.hasOwn(result, "outcome") &&
-        Array.isArray(result["requests"]) &&
-        result["requests"].every(scenarioRequest) &&
-        (result["spent"] === undefined || typeof result["spent"] === "number"));
-}
-function scenarioRequest(value) {
-    if (!Array.isArray(value) || value.length !== 2)
-        return false;
-    const request = record(value[1]);
-    if (request === undefined)
-        return false;
-    switch (value[0]) {
-        case "effect":
-            return protectedRequest(request);
-        case "gate":
-        case "waitForDecision":
-            return gateRequest(request);
-        case "handoff":
-            return handoffRequest(request);
-        case "waitForRun":
-            return runWaitRequest(request);
-        case "sleep":
-            return sleepRequest(request);
-        default:
-            return false;
-    }
-}
-function runWaitRequest(request) {
-    return (typeof request["runId"] === "string" &&
-        typeof request["maximumWaitSeconds"] === "number");
-}
-function sleepRequest(request) {
-    const seconds = request["seconds"];
-    return (typeof seconds === "number" &&
-        Number.isInteger(seconds) &&
-        seconds >= 1 &&
-        seconds <= 86400);
-}
-function gateRequest(request) {
-    return (typeof request["gateId"] === "string" &&
-        (request["kind"] === "question" || request["kind"] === "approval") &&
-        typeof request["prompt"] === "string" &&
-        optionalText(request["expiresAt"]));
-}
-function handoffRequest(request) {
-    const input = record(request["input"]);
-    return (typeof request["workflowId"] === "string" &&
-        input !== undefined &&
-        Object.values(input).every(handoffValue));
-}
-function protectedRequest(request) {
-    return (protectedScope(request["scope"]) &&
-        ["capability", "method", "target", "payload"].every((key) => typeof request[key] === "string") &&
-        typeof request["units"] === "number" &&
-        optionalText(request["resource"]));
-}
-function protectedScope(value) {
-    const scope = record(value);
-    if (scope === undefined)
-        return false;
-    const stage = record(scope["stage"]);
-    return (typeof scope["phase"] === "string" &&
-        typeof scope["operation"] === "string" &&
-        typeof scope["round"] === "number" &&
-        optionalText(scope["key"]) &&
-        (scope["stage"] === undefined ||
-            (stage !== undefined &&
-                ["id", "visit", "branch"].every((key) => typeof stage[key] === "string"))));
-}
-function optionalText(value) {
-    return value === undefined || typeof value === "string";
-}
-function handoffValue(value) {
-    if (value === null || ["string", "boolean", "number"].includes(typeof value))
-        return true;
-    if (Array.isArray(value))
-        return value.every(handoffValue);
-    const fields = record(value);
-    return fields !== undefined && Object.values(fields).every(handoffValue);
-}
 export async function runScenario(scenario) {
     const temporary = await mkdtemp(join(tmpdir(), "cloving-scenario-"));
     try {

package/dist/src/worker-usage.d.ts

@@ -16,6 +16,7 @@ export interface WorkerTurnUsage {
     readonly costUsd: number | null;
 }
 export interface WorkerAttemptUsage {
+    readonly resumedAfter?: "daemon-restart";
     readonly models?: readonly WorkerModelUsage[];
     readonly retryKind?: RetryKind | null;
     readonly attempt: number;

package/dist/src/worker-usage.js

@@ -85,6 +85,9 @@ export function attemptsOf(value) {
         return [
             {
                 ...retryKindField(field("retryKind")),
+                ...(field("resumedAfter") === "daemon-restart"
+                    ? { resumedAfter: "daemon-restart" }
+                    : {}),
                 attempt,
                 model,
                 ...(models === undefined ? {} : { models }),

package/dist/src/workflow-candidate.d.ts

@@ -13,6 +13,7 @@ export interface CandidateEffect {
     readonly method: string | null;
 }
 export interface CandidateAnalysis {
+    readonly commandWaits?: readonly (string | null)[];
     readonly localSources?: readonly string[];
     readonly imports: readonly CandidateImport[];
     readonly effects: readonly CandidateEffect[];

package/dist/src/workflow-candidate.js

@@ -15,6 +15,7 @@ const workflowModules = [
     "cloving/workflows/steps/wait-for-run",
     "cloving/workflows/steps/run-command",
     "cloving/workflows/steps/sleep",
+    "cloving/workflows/steps/wait-for-command",
 ];
 export function workflowHelperPath(source, imported) {
     if (!imported.startsWith("./"))
@@ -66,7 +67,7 @@ export function checkWorkflowCandidate(input) {
     if (!isCandidateDeclaration(input.declaration))
         return candidateDeclarationRefusals(input.declaration);
     const { analysis, declaration, installedExports } = input;
-    const codes = [];
+    const codes = commandWaitRefusals(analysis, declaration);
     if (analysis.imports.some((entry) => !allowedImport(entry, analysis)))
         codes.push("forbidden-import");
     if (analysis.imports.some((entry) => {
@@ -100,3 +101,13 @@ export function candidateDeclarationRefusals(value) {
     const codes = workflowQueueRefusals(record(value)?.["workflow"]);
     return codes.length > 0 ? codes : ["invalid-declaration"];
 }
+function commandWaitRefusals(analysis, declaration) {
+    const waits = analysis.commandWaits ?? [];
+    const codes = [];
+    if (waits.includes(null))
+        codes.push("dynamic-effect");
+    if (waits.some((name) => name !== null &&
+        !Object.hasOwn(declaration.workflow.commandWaits ?? {}, name)))
+        codes.push("undeclared-effect");
+    return codes;
+}

package/dist/src/workflow-contracts.d.ts

@@ -17,6 +17,7 @@ export type CycleOutcome = {
     readonly ticketStatus?: "complete" | "partial";
     readonly issueUpdate?: "failed";
     readonly reason?: string;
+    readonly report?: string;
 };
 export type Validation<Value> = {
     readonly kind: "valid";