@osolmaz/pi-workflows 0.12.1 → 0.13.0

package/dist/controllers/sqlite.d.ts

@@ -1,24 +1,23 @@
-import { type ControllerStore, type EffectReservation, type QueueItem, type QueueRequeueOptions, type WorkflowRecordUpdate, type WorkflowReservation } from "./store.js";
+import { StateDatabase } from "../state/database.js";
+import type { ControllerStore, EffectReservation, QueueItem, QueueRequeueOptions, WorkflowRecordUpdate, WorkflowReservation } from "./store.js";
 import type { ChildWorkflowRecord, ControllerEvent, ControllerQueueClaim, ControllerResource, ControllerResourceRef, ControllerResourceStatus, EffectRecord, JsonObject } from "./types.js";
 declare const TURN_INTENT_FACTS_SCHEMA = "pi-workflows.deferred-turn-facts.v1";
 export type WorkflowRunLaunchStatus = "queued" | "starting" | "running" | "parked" | "done" | "failed" | "cancelled";
-/** A user-started workflow run tracked by the durable run queue. */
 export type WorkflowRunQueueRecord = {
     runId: string;
-    /** Human-readable workflow name used in status and event output. */
     workflowName: string;
-    /** Canonical source reference used to reopen the run. */
     workflowSourceRef: string;
     workflowSource: unknown;
+    initialized: boolean;
     definitionDigest: string;
     input: unknown;
     launchOptions: unknown;
     status: WorkflowRunLaunchStatus;
     runnerId: string | null;
     claimToken: string | null;
+    claimGeneration: number | null;
     claimExpiresAt: string | null;
     affinityRunnerId: string | null;
-    /** Pi session that owns delivery and interactive execution, or null for detached runs. */
     originSessionId: string | null;
     parentRunId: string | null;
     errorCode: string | null;
@@ -71,7 +70,6 @@ export type WorkflowTurnIntentRecord = {
     resolutionMessageId: string | null;
     deliveryClaimExpiresAt: string | null;
 };
-/** One run lifecycle transition in the cross-session event feed. */
 export type RunEventRecord = {
     seq: number;
     recordedAt: string;
@@ -83,10 +81,14 @@ export type RunEventRecord = {
 };
 export declare class SqliteControllerStore implements ControllerStore {
     readonly filePath: string;
-    private readonly database;
+    readonly state: StateDatabase;
+    private readonly ownsState;
+    private readonly projectId;
     private closed;
     constructor(filePath?: string, options?: {
         readOnly?: boolean;
+        projectPath?: string;
+        state?: StateDatabase;
     });
     close(): void;
     putResource<TSpec, TStatus>(options: {
@@ -104,31 +106,34 @@ export declare class SqliteControllerStore implements ControllerStore {
     updateStatus<TStatus>(options: {
         ref: ControllerResourceRef;
         expectedResourceVersion: number;
+        claim: ControllerQueueClaim;
         status: ControllerResourceStatus<TStatus>;
         finalizers?: string[];
         now?: string;
     }): ControllerResource<unknown, TStatus>;
-    requestDeletion(ref: ControllerResourceRef, now?: string): ControllerResource;
+    requestDeletion(ref: ControllerResourceRef, nowValue?: string): ControllerResource;
     updateFinalizers(options: {
         ref: ControllerResourceRef;
         expectedResourceVersion: number;
         finalizers: string[];
         now?: string;
     }): ControllerResource;
-    deleteResource(ref: ControllerResourceRef, expectedResourceVersion: number): boolean;
+    deleteResource(ref: ControllerResourceRef, expectedResourceVersion: number, claim: ControllerQueueClaim): boolean;
     enqueue(ref: ControllerResourceRef, availableAt?: string): void;
     claimNext(options: {
         controllers: string[];
+        ownerId: string;
         leaseMs: number;
         now?: string;
     }): ControllerQueueClaim | undefined;
-    renewClaim(claim: ControllerQueueClaim, leaseMs: number, now?: string): boolean;
-    settleClaim(claim: ControllerQueueClaim, now?: string): boolean;
-    requeueClaim(claim: ControllerQueueClaim, options: QueueRequeueOptions, _now?: string): boolean;
+    renewClaim(claim: ControllerQueueClaim, leaseMs: number, nowValue?: string): boolean;
+    settleClaim(claim: ControllerQueueClaim, nowValue?: string): boolean;
+    requeueClaim(claim: ControllerQueueClaim, options: QueueRequeueOptions, nowValue?: string): boolean;
     listQueue(): QueueItem[];
     reserveEffect(options: {
         key: string;
         resourceUid: string;
+        claim: ControllerQueueClaim;
         generation: number;
         kind: string;
         requestFingerprint: string;
@@ -138,6 +143,7 @@ export declare class SqliteControllerStore implements ControllerStore {
     updateEffect(options: {
         resourceUid: string;
         key: string;
+        claim: ControllerQueueClaim;
         state: EffectRecord["state"];
         externalRef?: string;
         error?: string;
@@ -146,17 +152,20 @@ export declare class SqliteControllerStore implements ControllerStore {
     listEffects(resourceUid: string): EffectRecord[];
     reserveWorkflow(options: {
         resourceUid: string;
+        claim: ControllerQueueClaim;
         requestKey: string;
         workflow: string;
         inputFingerprint: string;
     }): WorkflowReservation;
     getWorkflow(resourceUid: string, requestKey: string): ChildWorkflowRecord | undefined;
     getWorkflowByRequestId(requestId: string): ChildWorkflowRecord | undefined;
-    updateWorkflow(requestId: string, update: WorkflowRecordUpdate): ChildWorkflowRecord;
+    updateWorkflow(requestId: string, update: WorkflowRecordUpdate, claim: ControllerQueueClaim): ChildWorkflowRecord;
+    completeWorkflow(requestId: string, update: WorkflowRecordUpdate): ChildWorkflowRecord;
     listWorkflows(resourceUid: string): ChildWorkflowRecord[];
     recordEvent(options: {
         controller: string;
         key: string;
+        claim?: ControllerQueueClaim;
         type: string;
         payload?: JsonObject;
         now?: string;
@@ -166,27 +175,13 @@ export declare class SqliteControllerStore implements ControllerStore {
         key?: string;
         limit?: number;
     }): ControllerEvent[];
-    private configure;
-    private initializeSchema;
-    private assertAlphaSchemaLayout;
-    private assertNoLegacyPendingLaunchNotifications;
-    private transaction;
-    private resourceRow;
-    private requireResource;
-    private throwMissingOrConflict;
-    private enqueueRow;
-    private claimedRow;
-    private effectRow;
-    private requireEffect;
-    private workflowRow;
-    private requireWorkflow;
-    /** Reserve a user-started run before the initiating agent turn settles. */
     reserveWorkflowRun(options: {
         runId: string;
         workflowName: string;
         workflowSourceRef: string;
         workflowSource: unknown;
         definitionDigest: string;
+        definitionSnapshot: unknown;
         input: unknown;
         launchOptions?: unknown;
         runnerId: string;
@@ -194,26 +189,27 @@ export declare class SqliteControllerStore implements ControllerStore {
         parentRunId?: string;
         now?: string;
     }): WorkflowRunQueueRecord;
-    /** Insert a run that will start immediately outside a live model turn. */
     enqueueWorkflowRun(options: {
         runId: string;
         workflowName: string;
         workflowSourceRef: string;
-        workflowSource?: unknown;
-        definitionDigest?: string;
+        workflowSource: unknown;
+        definitionDigest: string;
+        definitionSnapshot: unknown;
         input: unknown;
         launchOptions?: unknown;
         runnerId: string;
         claimToken: string;
         leaseMs: number;
-        affinityRunnerId?: string;
-        originSessionId?: string;
+        originSessionId: string;
         parentRunId?: string;
         now?: string;
     }): WorkflowRunQueueRecord;
     getWorkflowRun(runId: string): WorkflowRunQueueRecord | undefined;
     listWorkflowRuns(options?: {
-        status?: WorkflowRunQueueRecord["status"];
+        statuses?: WorkflowRunLaunchStatus[];
+        excludeRunIds?: string[];
+        limit?: number;
     }): WorkflowRunQueueRecord[];
     findSessionReservation(sessionId: string): WorkflowRunQueueRecord | undefined;
     claimWorkflowRun(options: {
@@ -228,35 +224,35 @@ export declare class SqliteControllerStore implements ControllerStore {
         claimToken: string;
         now?: string;
     }): boolean;
-    /**
-     * Claim the oldest claimable run, preferring runs with affinity to this
-     * runner. Parked rows are claimable immediately; claimed rows become
-     * claimable once their lease expires, so a dead or stalled runner never
-     * strands a run. Returns undefined when nothing is claimable.
-     */
     claimNextWorkflowRun(options: {
         runnerId: string;
+        sessionId?: string;
         claimToken: string;
         leaseMs: number;
-        excludeRunIds?: string[];
-        /** Interactive sessions provide their id; detached hosts omit it. */
-        sessionId?: string;
         now?: string;
+        excludeRunIds?: string[];
     }): WorkflowRunQueueRecord | undefined;
-    /** Extend a live claim. Rejects expired or foreign claims. */
     renewWorkflowRunClaim(options: {
         runId: string;
         claimToken: string;
         leaseMs: number;
         now?: string;
     }): boolean;
-    /** The fence check: true only while this exact claim is live. */
     verifyWorkflowRunClaim(options: {
         runId: string;
         claimToken: string;
         now?: string;
     }): boolean;
-    /** Release a claim and park the run so another runner can resume it. */
+    workflowRunAuthority(runId: string, claimToken: string): {
+        actor: {
+            type: "session" | "host";
+            id: string;
+        };
+        ownerType: "session" | "host";
+        ownerId: string;
+        token: string;
+        generation: number;
+    } | undefined;
     parkWorkflowRun(options: {
         runId: string;
         claimToken: string;
@@ -274,52 +270,25 @@ export declare class SqliteControllerStore implements ControllerStore {
         claimToken?: string;
         now?: string;
     }): boolean;
-    /**
-     * Delete a claimed row. Used when a continuation fails before its bundle
-     * exists, so the parent's one-continuation slot is not consumed by a run
-     * that never happened.
-     */
     deleteWorkflowRun(options: {
         runId: string;
         claimToken: string;
     }): boolean;
-    /** Release a claim and mark the run terminal in the queue. */
     completeWorkflowRun(options: {
         runId: string;
         claimToken: string;
         now?: string;
     }): boolean;
-    /** Repair a canonical bundle's queue source and claim it only when needed. */
-    repairCanonicalWorkflowSourceRun(options: {
-        runId: string;
-        workflowName: string;
-        workflowSourceRef: string;
-        runnerId: string;
-        claimToken: string;
-        leaseMs: number;
-        now?: string;
-    }): "unchanged" | "claimed" | false;
-    /** Claim and rewrite one proved legacy workflow source queue row atomically. */
-    claimLegacyWorkflowSourceRun(options: {
-        runId: string;
-        workflowName: string;
-        oldWorkflowPath: string;
-        workflowSourceRef: string;
-        runnerId: string;
-        claimToken: string;
-        leaseMs: number;
-        now?: string;
-    }): boolean;
-    /** Append a run lifecycle transition to the event feed. */
+    repairCanonicalWorkflowSourceRun(): never;
+    claimLegacyWorkflowSourceRun(): never;
     recordRunEvent(options: {
         runId: string;
         workflowRef: string;
         type: string;
-        runnerId?: string;
         payload?: JsonObject;
+        runnerId?: string;
         now?: string;
-    }): number;
-    /** List run events after a watermark, oldest first. */
+    }): RunEventRecord;
     listRunEventsAfter(seq: number, options?: {
         limit?: number;
     }): RunEventRecord[];
@@ -333,8 +302,8 @@ export declare class SqliteControllerStore implements ControllerStore {
         nodeId?: string | null;
         attemptId?: string | null;
         fallbackFacts: WorkflowTurnIntentFacts;
-        eligible?: boolean;
-        now?: string;
+        eligible: boolean;
+        requestedAt?: string;
     }): WorkflowTurnIntentRecord;
     getWorkflowTurnIntent(intentId: string): WorkflowTurnIntentRecord | undefined;
     findPendingWorkflowTurnIntent(options: {
@@ -352,12 +321,13 @@ export declare class SqliteControllerStore implements ControllerStore {
         targetSessionId: string;
         claimToken: string;
         leaseMs: number;
-        limit?: number;
         now?: string;
+        limit?: number;
     }): WorkflowTurnIntentRecord[];
     makeWorkflowTurnIntentEligible(options: {
         intentId: string;
         fallbackFacts: WorkflowTurnIntentFacts;
+        eligibleAt?: string;
         now?: string;
     }): boolean;
     resolveWorkflowTurnIntent(options: {
@@ -365,7 +335,7 @@ export declare class SqliteControllerStore implements ControllerStore {
         targetSessionId: string;
         claimToken: string;
         resolution: WorkflowTurnIntentResolution;
-        messageId: string;
+        messageId?: string;
         now?: string;
     }): boolean;
     releaseWorkflowTurnIntentClaim(options: {
@@ -374,8 +344,9 @@ export declare class SqliteControllerStore implements ControllerStore {
         claimToken: string;
     }): boolean;
     listWorkflowTurnIntents(options?: {
-        targetSessionId?: string;
         runId?: string;
+        targetSessionId?: string;
+        unresolvedOnly?: boolean;
         limit?: number;
     }): WorkflowTurnIntentRecord[];
     enqueueWorkflowNotification(options: {
@@ -386,15 +357,14 @@ export declare class SqliteControllerStore implements ControllerStore {
         targetSessionId: string;
         kind: "progress" | "final";
         content: string;
-        notificationId?: string;
         now?: string;
     }): WorkflowNotificationRecord;
     claimPendingWorkflowNotifications(options: {
         targetSessionId: string;
         claimToken: string;
         leaseMs: number;
-        limit?: number;
         now?: string;
+        limit?: number;
     }): WorkflowNotificationRecord[];
     markWorkflowNotificationDelivered(options: {
         notificationId: string;
@@ -402,8 +372,60 @@ export declare class SqliteControllerStore implements ControllerStore {
         claimToken: string;
         now?: string;
     }): boolean;
+    settleRunEffect(runId: string, effectType: "run.park_queue" | "run.settle_queue"): void;
     setWorkflowRunOriginSession(runId: string, originSessionId: string): boolean;
+    private ensureProject;
+    private findProject;
+    private requireProjectId;
+    private controllerRow;
+    private requireControllerRow;
+    private requireControllerRowByUid;
+    private requireResource;
+    private mapControllerResource;
+    private finalizers;
+    private replaceFinalizers;
+    private enqueueControllerRow;
+    private queueErrors;
+    private queueVersion;
+    private settleControllerClaim;
+    private assertControllerClaim;
+    private requireLease;
+    private releaseLease;
+    private resourceRevision;
+    private bumpResource;
+    private insertEvent;
+    private effectRow;
+    private requireEffectRow;
+    private mapEffect;
+    private effectKey;
+    private workflowRow;
+    private workflowRowById;
+    private requireWorkflowRow;
+    private mapWorkflow;
+    private workflowRunRow;
+    private requireWorkflowRunRow;
     private requireWorkflowRun;
-    private requireEvent;
+    private mapWorkflowRun;
+    private claimRun;
+    private updateClaimedRunStatus;
+    private releaseRunClaim;
+    private terminalRun;
+    private turnIntent;
+    private requireTurnIntent;
+    private turnIntentRow;
+    private turnIntentBySource;
+    private mapTurnIntent;
+    private claimEffectForTurn;
+    private claimEffect;
+    private verifyEffectToken;
+    private releaseEffectLease;
+    private completeEffect;
+    private insertEffectResource;
+    private notification;
+    private requireNotification;
+    private notificationRows;
+    private notificationRowById;
+    private mapNotification;
+    private assertWritable;
 }
 export {};