@hasna/loops 0.4.0 → 0.4.2

package/dist/lib/storage/postgres.js

@@ -0,0 +1,423 @@
+// @bun
+// src/lib/storage/postgres-schema.ts
+import { createHash } from "crypto";
+var POSTGRES_MIGRATION_LEDGER_TABLE = "open_loops_schema_migrations";
+function checksumStorageSql(sql) {
+  const normalized = sql.trim().replace(/\r\n/g, `
+`);
+  return `sha256:${createHash("sha256").update(normalized).digest("hex")}`;
+}
+function migration(id, sql) {
+  return Object.freeze({ id, sql: sql.trim(), checksum: checksumStorageSql(sql) });
+}
+var POSTGRES_STORAGE_MIGRATIONS = Object.freeze([
+  migration("0001_core_runtime", `
+CREATE TABLE IF NOT EXISTS loops (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  description TEXT,
+  status TEXT NOT NULL,
+  archived_at TIMESTAMPTZ,
+  archived_from_status TEXT,
+  schedule_json JSONB NOT NULL,
+  target_json JSONB NOT NULL,
+  goal_json JSONB,
+  machine_json JSONB,
+  next_run_at TIMESTAMPTZ,
+  retry_scheduled_for TIMESTAMPTZ,
+  catch_up TEXT NOT NULL,
+  catch_up_limit INTEGER NOT NULL,
+  overlap TEXT NOT NULL,
+  max_attempts INTEGER NOT NULL,
+  retry_delay_ms INTEGER NOT NULL,
+  lease_ms INTEGER NOT NULL,
+  expires_at TIMESTAMPTZ,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_loops_status_next ON loops(status, next_run_at);
+CREATE INDEX IF NOT EXISTS idx_loops_name ON loops(name);
+
+CREATE TABLE IF NOT EXISTS loop_runs (
+  id TEXT PRIMARY KEY,
+  loop_id TEXT NOT NULL REFERENCES loops(id) ON DELETE CASCADE,
+  loop_name TEXT NOT NULL,
+  scheduled_for TIMESTAMPTZ NOT NULL,
+  attempt INTEGER NOT NULL,
+  status TEXT NOT NULL,
+  started_at TIMESTAMPTZ,
+  finished_at TIMESTAMPTZ,
+  claimed_by TEXT,
+  claim_token TEXT,
+  lease_expires_at TIMESTAMPTZ,
+  pid INTEGER,
+  pgid INTEGER,
+  process_started_at TIMESTAMPTZ,
+  exit_code INTEGER,
+  duration_ms INTEGER,
+  stdout TEXT,
+  stderr TEXT,
+  error TEXT,
+  goal_run_id TEXT,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL,
+  UNIQUE(loop_id, scheduled_for)
+);
+CREATE INDEX IF NOT EXISTS idx_runs_loop ON loop_runs(loop_id, created_at);
+CREATE INDEX IF NOT EXISTS idx_runs_status ON loop_runs(status);
+CREATE INDEX IF NOT EXISTS idx_runs_status_lease ON loop_runs(status, lease_expires_at);
+CREATE INDEX IF NOT EXISTS idx_runs_scheduled ON loop_runs(scheduled_for);
+CREATE INDEX IF NOT EXISTS idx_runs_claim_token ON loop_runs(claim_token) WHERE claim_token IS NOT NULL;
+
+CREATE TABLE IF NOT EXISTS daemon_lease (
+  id TEXT PRIMARY KEY,
+  pid INTEGER NOT NULL,
+  hostname TEXT NOT NULL,
+  heartbeat_at TIMESTAMPTZ NOT NULL,
+  expires_at TIMESTAMPTZ NOT NULL,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL
+);
+    `),
+  migration("0002_workflows_goals", `
+CREATE TABLE IF NOT EXISTS workflow_specs (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  description TEXT,
+  version INTEGER NOT NULL,
+  status TEXT NOT NULL,
+  goal_json JSONB,
+  steps_json JSONB NOT NULL,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_workflows_status_name ON workflow_specs(status, name);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_workflows_name_active ON workflow_specs(name) WHERE status = 'active';
+
+CREATE TABLE IF NOT EXISTS workflow_runs (
+  id TEXT PRIMARY KEY,
+  workflow_id TEXT NOT NULL REFERENCES workflow_specs(id) ON DELETE CASCADE,
+  workflow_name TEXT NOT NULL,
+  loop_id TEXT REFERENCES loops(id) ON DELETE SET NULL,
+  loop_run_id TEXT REFERENCES loop_runs(id) ON DELETE SET NULL,
+  invocation_id TEXT,
+  work_item_id TEXT,
+  scheduled_for TIMESTAMPTZ,
+  idempotency_key TEXT,
+  manifest_path TEXT,
+  status TEXT NOT NULL,
+  started_at TIMESTAMPTZ,
+  finished_at TIMESTAMPTZ,
+  duration_ms INTEGER,
+  error TEXT,
+  goal_run_id TEXT,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL
+);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_workflow_runs_idempotency ON workflow_runs(workflow_id, idempotency_key) WHERE idempotency_key IS NOT NULL;
+CREATE INDEX IF NOT EXISTS idx_workflow_runs_workflow_created ON workflow_runs(workflow_id, created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_workflow_runs_loop_run ON workflow_runs(loop_run_id);
+CREATE INDEX IF NOT EXISTS idx_workflow_runs_status ON workflow_runs(status);
+CREATE INDEX IF NOT EXISTS idx_workflow_runs_invocation ON workflow_runs(invocation_id);
+CREATE INDEX IF NOT EXISTS idx_workflow_runs_work_item ON workflow_runs(work_item_id);
+
+CREATE TABLE IF NOT EXISTS workflow_invocations (
+  id TEXT PRIMARY KEY,
+  workflow_id TEXT,
+  template_id TEXT,
+  source_kind TEXT NOT NULL,
+  source_id TEXT,
+  source_dedupe_key TEXT,
+  source_json JSONB NOT NULL,
+  subject_kind TEXT NOT NULL,
+  subject_id TEXT,
+  subject_path TEXT,
+  subject_url TEXT,
+  subject_json JSONB NOT NULL,
+  intent TEXT NOT NULL,
+  scope_json JSONB,
+  output_policy_json JSONB,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_workflow_invocations_source ON workflow_invocations(source_kind, source_id);
+CREATE INDEX IF NOT EXISTS idx_workflow_invocations_subject ON workflow_invocations(subject_kind, subject_id, subject_path);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_workflow_invocations_dedupe ON workflow_invocations(source_kind, source_dedupe_key) WHERE source_dedupe_key IS NOT NULL;
+
+CREATE TABLE IF NOT EXISTS workflow_work_items (
+  id TEXT PRIMARY KEY,
+  route_key TEXT NOT NULL,
+  idempotency_key TEXT NOT NULL,
+  invocation_id TEXT NOT NULL REFERENCES workflow_invocations(id) ON DELETE CASCADE,
+  source_type TEXT NOT NULL,
+  source_ref TEXT NOT NULL,
+  subject_ref TEXT NOT NULL,
+  project_key TEXT,
+  project_group TEXT,
+  priority INTEGER NOT NULL,
+  status TEXT NOT NULL,
+  attempts INTEGER NOT NULL,
+  next_attempt_at TIMESTAMPTZ,
+  lease_expires_at TIMESTAMPTZ,
+  workflow_id TEXT REFERENCES workflow_specs(id) ON DELETE SET NULL,
+  loop_id TEXT REFERENCES loops(id) ON DELETE SET NULL,
+  workflow_run_id TEXT REFERENCES workflow_runs(id) ON DELETE SET NULL,
+  last_reason TEXT,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL,
+  UNIQUE(route_key, idempotency_key)
+);
+CREATE INDEX IF NOT EXISTS idx_workflow_work_items_status_next ON workflow_work_items(status, next_attempt_at, priority DESC, created_at ASC);
+CREATE INDEX IF NOT EXISTS idx_workflow_work_items_project ON workflow_work_items(project_key, status);
+CREATE INDEX IF NOT EXISTS idx_workflow_work_items_group ON workflow_work_items(project_group, status);
+CREATE INDEX IF NOT EXISTS idx_workflow_work_items_invocation ON workflow_work_items(invocation_id);
+
+CREATE TABLE IF NOT EXISTS workflow_step_runs (
+  id TEXT PRIMARY KEY,
+  workflow_run_id TEXT NOT NULL REFERENCES workflow_runs(id) ON DELETE CASCADE,
+  step_id TEXT NOT NULL,
+  sequence INTEGER NOT NULL,
+  status TEXT NOT NULL,
+  started_at TIMESTAMPTZ,
+  finished_at TIMESTAMPTZ,
+  exit_code INTEGER,
+  pid INTEGER,
+  duration_ms INTEGER,
+  stdout TEXT,
+  stderr TEXT,
+  error TEXT,
+  account_profile TEXT,
+  account_tool TEXT,
+  goal_run_id TEXT,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL,
+  UNIQUE(workflow_run_id, step_id)
+);
+CREATE INDEX IF NOT EXISTS idx_workflow_step_runs_run_sequence ON workflow_step_runs(workflow_run_id, sequence);
+CREATE INDEX IF NOT EXISTS idx_workflow_step_runs_status ON workflow_step_runs(status);
+
+CREATE TABLE IF NOT EXISTS workflow_events (
+  id TEXT PRIMARY KEY,
+  workflow_run_id TEXT NOT NULL REFERENCES workflow_runs(id) ON DELETE CASCADE,
+  sequence INTEGER NOT NULL,
+  event_type TEXT NOT NULL,
+  step_id TEXT,
+  payload_json JSONB,
+  created_at TIMESTAMPTZ NOT NULL,
+  UNIQUE(workflow_run_id, sequence)
+);
+CREATE INDEX IF NOT EXISTS idx_workflow_events_run_sequence ON workflow_events(workflow_run_id, sequence);
+
+CREATE TABLE IF NOT EXISTS goals (
+  id TEXT PRIMARY KEY,
+  plan_id TEXT NOT NULL,
+  objective TEXT NOT NULL,
+  status TEXT NOT NULL,
+  token_budget INTEGER,
+  tokens_used INTEGER NOT NULL,
+  time_used_seconds INTEGER NOT NULL,
+  auto_execute TEXT NOT NULL,
+  max_tokens INTEGER,
+  source_type TEXT,
+  source_id TEXT,
+  loop_id TEXT,
+  loop_run_id TEXT,
+  workflow_id TEXT,
+  workflow_run_id TEXT,
+  workflow_step_id TEXT,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_goals_status_updated ON goals(status, updated_at DESC);
+CREATE INDEX IF NOT EXISTS idx_goals_loop_run ON goals(loop_run_id);
+CREATE INDEX IF NOT EXISTS idx_goals_workflow_run ON goals(workflow_run_id);
+CREATE INDEX IF NOT EXISTS idx_goals_source ON goals(source_type, source_id);
+
+CREATE TABLE IF NOT EXISTS goal_plan_nodes (
+  id TEXT PRIMARY KEY,
+  goal_id TEXT NOT NULL REFERENCES goals(id) ON DELETE CASCADE,
+  plan_id TEXT NOT NULL,
+  key TEXT NOT NULL,
+  sequence INTEGER NOT NULL,
+  priority INTEGER NOT NULL,
+  objective TEXT NOT NULL,
+  status TEXT NOT NULL,
+  ready BOOLEAN NOT NULL,
+  token_budget INTEGER,
+  tokens_used INTEGER NOT NULL,
+  time_used_seconds INTEGER NOT NULL,
+  depends_on_json JSONB NOT NULL,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL,
+  UNIQUE(plan_id, key)
+);
+CREATE INDEX IF NOT EXISTS idx_goal_plan_nodes_goal_sequence ON goal_plan_nodes(goal_id, sequence);
+CREATE INDEX IF NOT EXISTS idx_goal_plan_nodes_status ON goal_plan_nodes(status);
+
+CREATE TABLE IF NOT EXISTS goal_runs (
+  id TEXT PRIMARY KEY,
+  goal_id TEXT NOT NULL REFERENCES goals(id) ON DELETE CASCADE,
+  plan_id TEXT NOT NULL,
+  loop_id TEXT,
+  loop_run_id TEXT,
+  workflow_id TEXT,
+  workflow_run_id TEXT,
+  workflow_step_id TEXT,
+  turn INTEGER NOT NULL,
+  phase TEXT NOT NULL,
+  status TEXT NOT NULL,
+  node_key TEXT,
+  tokens_used INTEGER NOT NULL,
+  evidence_json JSONB,
+  raw_response_json JSONB,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_goal_runs_goal_created ON goal_runs(goal_id, created_at);
+CREATE INDEX IF NOT EXISTS idx_goal_runs_loop_run ON goal_runs(loop_run_id);
+CREATE INDEX IF NOT EXISTS idx_goal_runs_workflow_run ON goal_runs(workflow_run_id);
+    `),
+  migration("0003_remote_runners_and_audit", `
+CREATE TABLE IF NOT EXISTS runner_machines (
+  id TEXT PRIMARY KEY,
+  hostname TEXT NOT NULL,
+  labels_json JSONB NOT NULL DEFAULT '{}'::jsonb,
+  capabilities_json JSONB NOT NULL DEFAULT '{}'::jsonb,
+  status TEXT NOT NULL,
+  last_seen_at TIMESTAMPTZ NOT NULL,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_runner_machines_status_seen ON runner_machines(status, last_seen_at DESC);
+
+CREATE TABLE IF NOT EXISTS runner_leases (
+  id TEXT PRIMARY KEY,
+  runner_id TEXT NOT NULL REFERENCES runner_machines(id) ON DELETE CASCADE,
+  loop_run_id TEXT REFERENCES loop_runs(id) ON DELETE CASCADE,
+  workflow_run_id TEXT REFERENCES workflow_runs(id) ON DELETE CASCADE,
+  claim_token TEXT NOT NULL,
+  status TEXT NOT NULL,
+  heartbeat_at TIMESTAMPTZ NOT NULL,
+  expires_at TIMESTAMPTZ NOT NULL,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL,
+  CHECK (loop_run_id IS NOT NULL OR workflow_run_id IS NOT NULL)
+);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_runner_leases_active_loop_run ON runner_leases(loop_run_id) WHERE loop_run_id IS NOT NULL AND status = 'active';
+CREATE UNIQUE INDEX IF NOT EXISTS idx_runner_leases_active_workflow_run ON runner_leases(workflow_run_id) WHERE workflow_run_id IS NOT NULL AND status = 'active';
+CREATE INDEX IF NOT EXISTS idx_runner_leases_runner_status ON runner_leases(runner_id, status, expires_at);
+CREATE INDEX IF NOT EXISTS idx_runner_leases_claim_token ON runner_leases(claim_token);
+
+CREATE TABLE IF NOT EXISTS audit_events (
+  id TEXT PRIMARY KEY,
+  actor TEXT NOT NULL,
+  action TEXT NOT NULL,
+  subject_type TEXT NOT NULL,
+  subject_id TEXT NOT NULL,
+  metadata_json JSONB,
+  created_at TIMESTAMPTZ NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_audit_events_subject ON audit_events(subject_type, subject_id, created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_audit_events_action ON audit_events(action, created_at DESC);
+    `)
+]);
+
+// src/lib/storage/postgres.ts
+class PostgresStorage {
+  executor;
+  backend = "postgres";
+  migrations;
+  constructor(executor, migrations = POSTGRES_STORAGE_MIGRATIONS) {
+    this.executor = executor;
+    this.migrations = migrations;
+  }
+  async listAppliedMigrations() {
+    await this.ensureLedger();
+    return this.readAppliedMigrations();
+  }
+  async migrate(opts = {}) {
+    const dryRun = opts.dryRun === true;
+    if (!dryRun)
+      await this.ensureLedger();
+    const applied = dryRun ? await this.tryReadAppliedMigrations() : await this.readAppliedMigrations();
+    const knownMigrationIds = new Set(this.migrations.map((migration2) => migration2.id));
+    for (const row of applied) {
+      if (!knownMigrationIds.has(row.id)) {
+        throw new Error(`Postgres migration ${row.id} is not recognized by this binary`);
+      }
+    }
+    const appliedById = new Map(applied.map((row) => [row.id, row]));
+    const plan = this.migrations.map((migration2) => ({
+      migration: migration2,
+      state: appliedById.has(migration2.id) ? "already_applied" : "pending"
+    }));
+    for (const migration2 of this.migrations) {
+      const existing = appliedById.get(migration2.id);
+      if (existing && existing.checksum !== migration2.checksum) {
+        throw new Error(`Postgres migration checksum mismatch for ${migration2.id}`);
+      }
+    }
+    if (dryRun)
+      return { backend: this.backend, dryRun, applied, plan };
+    const run = async () => {
+      for (const item of plan) {
+        if (item.state === "already_applied")
+          continue;
+        await this.executor.execute(item.migration.sql);
+        await this.executor.execute(`INSERT INTO ${POSTGRES_MIGRATION_LEDGER_TABLE} (id, checksum, applied_at) VALUES ($1, $2, NOW())`, [item.migration.id, item.migration.checksum]);
+      }
+    };
+    if (this.executor.transaction)
+      await this.executor.transaction(run);
+    else
+      await run();
+    return {
+      backend: this.backend,
+      dryRun,
+      applied: await this.readAppliedMigrations(),
+      plan
+    };
+  }
+  async close() {
+    await this.executor.close?.();
+  }
+  async ensureLedger() {
+    await this.executor.execute(`
+CREATE TABLE IF NOT EXISTS ${POSTGRES_MIGRATION_LEDGER_TABLE} (
+  id TEXT PRIMARY KEY,
+  checksum TEXT NOT NULL,
+  applied_at TIMESTAMPTZ NOT NULL
+);
+    `);
+  }
+  async readAppliedMigrations() {
+    const rows = await this.executor.query(`SELECT id, checksum, applied_at FROM ${POSTGRES_MIGRATION_LEDGER_TABLE} ORDER BY id ASC`);
+    return rows.map((row) => ({
+      id: row.id,
+      checksum: row.checksum,
+      appliedAt: row.applied_at instanceof Date ? row.applied_at.toISOString() : row.applied_at
+    }));
+  }
+  async tryReadAppliedMigrations() {
+    try {
+      return await this.readAppliedMigrations();
+    } catch (error) {
+      if (isMissingLedgerError(error))
+        return [];
+      throw error;
+    }
+  }
+}
+function createPostgresStorage(executor) {
+  return new PostgresStorage(executor);
+}
+function isMissingLedgerError(error) {
+  if (!(error instanceof Error))
+    return false;
+  const message = error.message.toLowerCase();
+  return message.includes(POSTGRES_MIGRATION_LEDGER_TABLE.toLowerCase()) && (message.includes("does not exist") || message.includes("no such table") || message.includes("undefined_table"));
+}
+export {
+  createPostgresStorage,
+  PostgresStorage
+};

package/dist/lib/storage/sqlite.d.ts

@@ -0,0 +1,84 @@
+import { Store } from "../store.js";
+import type { LoopStorageContract, LoopStorageMethodName } from "./contract.js";
+type StoreMethod<K extends LoopStorageMethodName> = Store[K] extends (...args: infer Args) => infer Result ? {
+    args: Args;
+    result: Result;
+} : never;
+export declare class SqliteLoopStorage implements LoopStorageContract {
+    readonly store: Store;
+    readonly backend = "sqlite";
+    readonly supportsRemoteRunners = false;
+    constructor(store?: Store);
+    close(): Promise<void>;
+    private call;
+    createLoop(...args: StoreMethod<"createLoop">["args"]): Promise<import("../../types.js").Loop>;
+    getLoop(...args: StoreMethod<"getLoop">["args"]): Promise<import("../../types.js").Loop | undefined>;
+    findLoopByName(...args: StoreMethod<"findLoopByName">["args"]): Promise<import("../../types.js").Loop | undefined>;
+    requireLoop(...args: StoreMethod<"requireLoop">["args"]): Promise<import("../../types.js").Loop>;
+    listLoops(...args: StoreMethod<"listLoops">["args"]): Promise<import("../../types.js").Loop[]>;
+    dueLoops(...args: StoreMethod<"dueLoops">["args"]): Promise<import("../../types.js").Loop[]>;
+    updateLoop(...args: StoreMethod<"updateLoop">["args"]): Promise<import("../../types.js").Loop>;
+    renameLoop(...args: StoreMethod<"renameLoop">["args"]): Promise<import("../../types.js").Loop>;
+    archiveLoop(...args: StoreMethod<"archiveLoop">["args"]): Promise<import("../../types.js").Loop>;
+    unarchiveLoop(...args: StoreMethod<"unarchiveLoop">["args"]): Promise<import("../../types.js").Loop>;
+    deleteLoop(...args: StoreMethod<"deleteLoop">["args"]): Promise<boolean>;
+    createWorkflow(...args: StoreMethod<"createWorkflow">["args"]): Promise<import("../../types.js").WorkflowSpec>;
+    getWorkflow(...args: StoreMethod<"getWorkflow">["args"]): Promise<import("../../types.js").WorkflowSpec | undefined>;
+    listWorkflows(...args: StoreMethod<"listWorkflows">["args"]): Promise<import("../../types.js").WorkflowSpec[]>;
+    countWorkflows(...args: StoreMethod<"countWorkflows">["args"]): Promise<number>;
+    archiveWorkflow(...args: StoreMethod<"archiveWorkflow">["args"]): Promise<import("../../types.js").WorkflowSpec>;
+    createWorkflowInvocation(...args: StoreMethod<"createWorkflowInvocation">["args"]): Promise<import("../../types.js").WorkflowInvocation>;
+    getWorkflowInvocation(...args: StoreMethod<"getWorkflowInvocation">["args"]): Promise<import("../../types.js").WorkflowInvocation | undefined>;
+    listWorkflowInvocations(...args: StoreMethod<"listWorkflowInvocations">["args"]): Promise<import("../../types.js").WorkflowInvocation[]>;
+    upsertWorkflowWorkItem(...args: StoreMethod<"upsertWorkflowWorkItem">["args"]): Promise<import("../../types.js").WorkflowWorkItem>;
+    getWorkflowWorkItem(...args: StoreMethod<"getWorkflowWorkItem">["args"]): Promise<import("../../types.js").WorkflowWorkItem | undefined>;
+    listWorkflowWorkItems(...args: StoreMethod<"listWorkflowWorkItems">["args"]): Promise<import("../../types.js").WorkflowWorkItem[]>;
+    countActiveWorkflowWorkItems(...args: StoreMethod<"countActiveWorkflowWorkItems">["args"]): Promise<{
+        global: number;
+        project: number;
+        projectGroup?: number;
+    }>;
+    admitWorkflowWorkItem(...args: StoreMethod<"admitWorkflowWorkItem">["args"]): Promise<import("../../types.js").WorkflowWorkItem>;
+    createGoal(...args: StoreMethod<"createGoal">["args"]): Promise<import("../goal/types.js").Goal>;
+    getGoal(...args: StoreMethod<"getGoal">["args"]): Promise<import("../goal/types.js").Goal | undefined>;
+    listGoals(...args: StoreMethod<"listGoals">["args"]): Promise<import("../goal/types.js").Goal[]>;
+    createGoalPlanNodes(...args: StoreMethod<"createGoalPlanNodes">["args"]): Promise<import("../goal/types.js").GoalPlanNode[]>;
+    listGoalPlanNodes(...args: StoreMethod<"listGoalPlanNodes">["args"]): Promise<import("../goal/types.js").GoalPlanNode[]>;
+    updateGoalStatus(...args: StoreMethod<"updateGoalStatus">["args"]): Promise<import("../goal/types.js").Goal>;
+    updateGoalPlanNode(...args: StoreMethod<"updateGoalPlanNode">["args"]): Promise<import("../goal/types.js").GoalPlanNode>;
+    recordGoalEvent(...args: StoreMethod<"recordGoalEvent">["args"]): Promise<import("../goal/types.js").GoalRun>;
+    listGoalRuns(...args: StoreMethod<"listGoalRuns">["args"]): Promise<import("../goal/types.js").GoalRun[]>;
+    createWorkflowRun(...args: StoreMethod<"createWorkflowRun">["args"]): Promise<import("../../types.js").WorkflowRun>;
+    getWorkflowRun(...args: StoreMethod<"getWorkflowRun">["args"]): Promise<import("../../types.js").WorkflowRun | undefined>;
+    listWorkflowRuns(...args: StoreMethod<"listWorkflowRuns">["args"]): Promise<import("../../types.js").WorkflowRun[]>;
+    listWorkflowStepRuns(...args: StoreMethod<"listWorkflowStepRuns">["args"]): Promise<import("../../types.js").WorkflowStepRun[]>;
+    getWorkflowStepRun(...args: StoreMethod<"getWorkflowStepRun">["args"]): Promise<import("../../types.js").WorkflowStepRun | undefined>;
+    startWorkflowStepRun(...args: StoreMethod<"startWorkflowStepRun">["args"]): Promise<import("../../types.js").WorkflowStepRun>;
+    recoverWorkflowRun(...args: StoreMethod<"recoverWorkflowRun">["args"]): Promise<{
+        run: import("../../types.js").WorkflowRun;
+        recoveredSteps: import("../../types.js").WorkflowStepRun[];
+    }>;
+    finalizeWorkflowStepRun(...args: StoreMethod<"finalizeWorkflowStepRun">["args"]): Promise<import("../../types.js").WorkflowStepRun>;
+    finalizeWorkflowRun(...args: StoreMethod<"finalizeWorkflowRun">["args"]): Promise<import("../../types.js").WorkflowRun>;
+    appendWorkflowEvent(...args: StoreMethod<"appendWorkflowEvent">["args"]): Promise<import("../../types.js").WorkflowEvent>;
+    listWorkflowEvents(...args: StoreMethod<"listWorkflowEvents">["args"]): Promise<import("../../types.js").WorkflowEvent[]>;
+    recordRunProcess(...args: StoreMethod<"recordRunProcess">["args"]): Promise<import("../../types.js").LoopRun | undefined>;
+    createSkippedRun(...args: StoreMethod<"createSkippedRun">["args"]): Promise<import("../../types.js").LoopRun>;
+    getRun(...args: StoreMethod<"getRun">["args"]): Promise<import("../../types.js").LoopRun | undefined>;
+    getRunBySlot(...args: StoreMethod<"getRunBySlot">["args"]): Promise<import("../../types.js").LoopRun | undefined>;
+    claimRun(...args: StoreMethod<"claimRun">["args"]): Promise<import("../store.js").ClaimRunResult | undefined>;
+    finalizeRun(...args: StoreMethod<"finalizeRun">["args"]): Promise<import("../../types.js").LoopRun>;
+    heartbeatRunLease(...args: StoreMethod<"heartbeatRunLease">["args"]): Promise<import("../../types.js").LoopRun | undefined>;
+    listRuns(...args: StoreMethod<"listRuns">["args"]): Promise<import("../../types.js").LoopRun[]>;
+    recoverExpiredRunLeases(...args: StoreMethod<"recoverExpiredRunLeases">["args"]): Promise<import("../../types.js").LoopRun[]>;
+    recoverExpiredRunLeasesDetailed(...args: StoreMethod<"recoverExpiredRunLeasesDetailed">["args"]): Promise<import("../store.js").RecoverExpiredRunLeasesResult>;
+    countLoops(...args: StoreMethod<"countLoops">["args"]): Promise<number>;
+    countRuns(...args: StoreMethod<"countRuns">["args"]): Promise<number>;
+    pruneHistory(...args: StoreMethod<"pruneHistory">["args"]): Promise<import("../store.js").PruneHistorySummary>;
+    acquireDaemonLease(...args: StoreMethod<"acquireDaemonLease">["args"]): Promise<import("../store.js").DaemonLease | undefined>;
+    heartbeatDaemonLease(...args: StoreMethod<"heartbeatDaemonLease">["args"]): Promise<import("../store.js").DaemonLease | undefined>;
+    releaseDaemonLease(...args: StoreMethod<"releaseDaemonLease">["args"]): Promise<void>;
+    getDaemonLease(...args: StoreMethod<"getDaemonLease">["args"]): Promise<import("../store.js").DaemonLease | undefined>;
+}
+export declare function createSqliteLoopStorage(path?: string): SqliteLoopStorage;
+export {};