@axiom-lattice/pg-stores 3.3.13 → 3.4.0

package/dist/index.mjs

@@ -1,8 +1,8 @@
 // src/index.ts
-import { Pool as Pool33 } from "pg";
+import { Pool as Pool35 } from "pg";
 
 // src/createPgStoreConfig.ts
-import { Pool as Pool30 } from "pg";
+import { Pool as Pool32 } from "pg";
 
 // src/migrations/migration.ts
 var MigrationManager = class {
@@ -215,6 +215,25 @@ var createThreadsTable = {
     await client.query("DROP TABLE IF EXISTS lattice_threads");
   }
 };
+var addThreadExpiresAt = {
+  version: 194,
+  name: "add_thread_expires_at",
+  up: async (client) => {
+    await client.query(`
+      ALTER TABLE lattice_threads
+      ADD COLUMN IF NOT EXISTS expires_at TIMESTAMPTZ
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_threads_expires_at
+      ON lattice_threads(expires_at)
+      WHERE expires_at IS NOT NULL
+    `);
+  },
+  down: async (client) => {
+    await client.query("DROP INDEX IF EXISTS idx_lattice_threads_expires_at");
+    await client.query("ALTER TABLE lattice_threads DROP COLUMN IF EXISTS expires_at");
+  }
+};
 
 // src/migrations/thread_tenant_migration.ts
 var addThreadTenantId = {
@@ -342,6 +361,7 @@ var PostgreSQLThreadStore = class {
     this.migrationManager.register(createThreadsTable);
     this.migrationManager.register(addThreadTenantId);
     this.migrationManager.register(changeThreadPrimaryKey);
+    this.migrationManager.register(addThreadExpiresAt);
     if (options.autoMigrate !== false) {
       this.initialize().catch((error) => {
         console.error("Failed to initialize PostgreSQLThreadStore:", error);
@@ -386,7 +406,7 @@ var PostgreSQLThreadStore = class {
     await this.ensureInitialized();
     const result = await this.pool.query(
       `
-      SELECT id, tenant_id, assistant_id, metadata, created_at, updated_at
+      SELECT id, tenant_id, assistant_id, metadata, created_at, updated_at, expires_at
       FROM lattice_threads
       WHERE tenant_id = $1 AND assistant_id = $2
       ORDER BY created_at DESC
@@ -410,7 +430,7 @@ var PostgreSQLThreadStore = class {
     await this.ensureInitialized();
     const result = await this.pool.query(
       `
-      SELECT id, tenant_id, assistant_id, metadata, created_at, updated_at
+      SELECT id, tenant_id, assistant_id, metadata, created_at, updated_at, expires_at
       FROM lattice_threads
       WHERE tenant_id = $1 AND id = $2
     `,
@@ -430,14 +450,15 @@ var PostgreSQLThreadStore = class {
     const metadata = data.metadata || {};
     await this.pool.query(
       `
-      INSERT INTO lattice_threads (id, tenant_id, assistant_id, metadata, created_at, updated_at)
-      VALUES ($1, $2, $3, $4, $5, $6)
+      INSERT INTO lattice_threads (id, tenant_id, assistant_id, metadata, created_at, updated_at, expires_at)
+      VALUES ($1, $2, $3, $4, $5, $6, $7)
       ON CONFLICT (id, tenant_id) DO UPDATE SET
         assistant_id = EXCLUDED.assistant_id,
         metadata = EXCLUDED.metadata,
-        updated_at = EXCLUDED.updated_at
+        updated_at = EXCLUDED.updated_at,
+        expires_at = EXCLUDED.expires_at
     `,
-      [threadId, tenantId, assistantId, JSON.stringify(metadata), now, now]
+      [threadId, tenantId, assistantId, JSON.stringify(metadata), now, now, data.expiresAt ?? null]
     );
     return {
       id: threadId,
@@ -445,7 +466,8 @@ var PostgreSQLThreadStore = class {
       assistantId,
       metadata,
       createdAt: now,
-      updatedAt: now
+      updatedAt: now,
+      expiresAt: data.expiresAt
     };
   }
   /**
@@ -462,18 +484,20 @@ var PostgreSQLThreadStore = class {
       ...updates.metadata || {}
     };
     const now = /* @__PURE__ */ new Date();
+    const expiresAt = updates.expiresAt !== void 0 ? updates.expiresAt : existing.expiresAt ?? null;
     await this.pool.query(
       `
       UPDATE lattice_threads
-      SET metadata = $1, updated_at = $2
-      WHERE tenant_id = $3 AND id = $4
+      SET metadata = $1, updated_at = $2, expires_at = $3
+      WHERE tenant_id = $4 AND id = $5
     `,
-      [JSON.stringify(updatedMetadata), now, tenantId, threadId]
+      [JSON.stringify(updatedMetadata), now, expiresAt, tenantId, threadId]
     );
     return {
       ...existing,
       metadata: updatedMetadata,
-      updatedAt: now
+      updatedAt: now,
+      expiresAt: expiresAt ?? void 0
     };
   }
   /**
@@ -505,6 +529,23 @@ var PostgreSQLThreadStore = class {
     );
     return result.rows.length > 0;
   }
+  /**
+   * List expired threads across all tenants, oldest expiry first.
+   */
+  async listExpiredThreads(now, limit) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      SELECT id, tenant_id, assistant_id, metadata, created_at, updated_at, expires_at
+      FROM lattice_threads
+      WHERE expires_at IS NOT NULL AND expires_at <= $1
+      ORDER BY expires_at ASC
+      LIMIT $2
+    `,
+      [now, Math.max(0, limit)]
+    );
+    return result.rows.map(this.mapRowToThread);
+  }
   /**
    * Ensure store is initialized
    */
@@ -523,7 +564,8 @@ var PostgreSQLThreadStore = class {
       assistantId: row.assistant_id,
       metadata: typeof row.metadata === "string" ? JSON.parse(row.metadata) : row.metadata || {},
       createdAt: row.created_at,
-      updatedAt: row.updated_at
+      updatedAt: row.updated_at,
+      expiresAt: row.expires_at ?? void 0
     };
   }
 };
@@ -5443,20 +5485,25 @@ var ThreadMessageQueueStore = class {
   }
   /**
    * Get all threads with pending or processing messages
+   *
+   * @returns One entry per full scope, with `hasPending` distinguishing
+   * processing-only threads (no pending row) from threads with work to drain.
    */
   async getThreadsWithPendingMessages() {
     const result = await this.pool.query(
-      `SELECT DISTINCT ON (tenant_id, assistant_id, workspace_id, project_id, thread_id) tenant_id, assistant_id, thread_id, workspace_id, project_id
-       FROM lattice_thread_message_queue 
-       WHERE status IN ('pending', 'processing')
-        ORDER BY tenant_id, assistant_id, workspace_id, project_id, thread_id`
+      `SELECT tenant_id, assistant_id, thread_id, workspace_id, project_id,
+              bool_or(status = 'pending') AS has_pending
+         FROM lattice_thread_message_queue
+        WHERE status IN ('pending', 'processing')
+        GROUP BY tenant_id, assistant_id, thread_id, workspace_id, project_id`
     );
     return result.rows.map((row) => ({
       tenantId: row.tenant_id,
       assistantId: row.assistant_id,
       threadId: row.thread_id,
       workspaceId: row.workspace_id,
-      projectId: row.project_id
+      projectId: row.project_id,
+      hasPending: row.has_pending
     }));
   }
   /**
@@ -9890,6 +9937,299 @@ var createCollectionsTable = {
   }
 };
 
+// src/migrations/agent_run_ledger_migration.ts
+var createAgentRunLedgerTable = {
+  version: 193,
+  name: "create_lattice_agent_runs_table",
+  up: async (client) => {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS lattice_agent_runs (
+        run_id UUID PRIMARY KEY,
+        tenant_id VARCHAR(255) NOT NULL,
+        workspace_id VARCHAR(255),
+        project_id VARCHAR(255),
+        assistant_id VARCHAR(255) NOT NULL,
+        thread_id VARCHAR(255) NOT NULL,
+        status VARCHAR(32) NOT NULL,
+        owner VARCHAR(255) NOT NULL,
+        lease_expires_at TIMESTAMPTZ NOT NULL,
+        input_message_ids TEXT[] NOT NULL DEFAULT '{}',
+        attempts INTEGER NOT NULL DEFAULT 1,
+        error TEXT,
+        cancel_requested BOOLEAN NOT NULL DEFAULT FALSE,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        started_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        finished_at TIMESTAMPTZ
+      )
+    `);
+    await client.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS uq_lattice_agent_runs_one_running
+        ON lattice_agent_runs (tenant_id, thread_id) WHERE status = 'running'
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_agent_runs_history
+        ON lattice_agent_runs (tenant_id, thread_id, created_at DESC)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_agent_runs_reap
+        ON lattice_agent_runs (status, lease_expires_at)
+    `);
+  },
+  down: async (client) => {
+    await client.query("DROP TABLE IF EXISTS lattice_agent_runs");
+  }
+};
+
+// src/migrations/channel_reply_job_migration.ts
+var DB_CLOCK_MS = "FLOOR(EXTRACT(EPOCH FROM clock_timestamp()) * 1000)::bigint";
+var createChannelReplyJobsTable = {
+  version: 200,
+  name: "create_lattice_channel_reply_jobs",
+  up: async (client) => {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS lattice_channel_reply_jobs (
+        run_id TEXT PRIMARY KEY,
+        tenant_id VARCHAR(255) NOT NULL,
+        assistant_id TEXT NOT NULL,
+        thread_id TEXT NOT NULL,
+        adapter_channel TEXT NOT NULL,
+        channel_installation_id TEXT NOT NULL,
+        reply_target JSONB NOT NULL,
+        input_message_id TEXT NOT NULL,
+        stream_cursor TEXT NULL,
+        status TEXT NOT NULL,
+        attempts INT NOT NULL DEFAULT 0,
+        available_at BIGINT NOT NULL,
+        lease_owner TEXT NULL,
+        lease_expires_at BIGINT NULL,
+        last_error TEXT NULL,
+        output_message_id TEXT NULL,
+        created_at BIGINT NOT NULL DEFAULT (${DB_CLOCK_MS}),
+        updated_at BIGINT NOT NULL DEFAULT (${DB_CLOCK_MS}),
+        delivered_at BIGINT NULL
+      )
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_channel_reply_jobs_due
+      ON lattice_channel_reply_jobs (status, available_at)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_channel_reply_jobs_tenant_thread
+      ON lattice_channel_reply_jobs (tenant_id, thread_id)
+    `);
+  },
+  down: async (client) => {
+    await client.query("DROP INDEX IF EXISTS idx_lattice_channel_reply_jobs_tenant_thread");
+    await client.query("DROP INDEX IF EXISTS idx_lattice_channel_reply_jobs_due");
+    await client.query("DROP TABLE IF EXISTS lattice_channel_reply_jobs");
+  }
+};
+
+// src/migrations/agent_run_task_queue_migration.ts
+var createAgentRunTaskQueueMigration = {
+  version: 196,
+  name: "expand_lattice_agent_runs_task_queue",
+  up: async (client) => {
+    await client.query(`
+      ALTER TABLE lattice_agent_runs
+        ALTER COLUMN owner DROP NOT NULL,
+        ALTER COLUMN lease_expires_at DROP NOT NULL,
+        ALTER COLUMN started_at DROP NOT NULL,
+        ALTER COLUMN started_at DROP DEFAULT
+    `);
+    await client.query(`
+      ALTER TABLE lattice_agent_runs
+        ADD COLUMN IF NOT EXISTS source VARCHAR(32) NOT NULL DEFAULT 'legacy',
+        ADD COLUMN IF NOT EXISTS input JSONB,
+        ADD COLUMN IF NOT EXISTS command JSONB,
+        ADD COLUMN IF NOT EXISTS config JSONB,
+        ADD COLUMN IF NOT EXISTS metadata JSONB,
+        ADD COLUMN IF NOT EXISTS base_checkpoint_id TEXT,
+        ADD COLUMN IF NOT EXISTS available_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        ADD COLUMN IF NOT EXISTS rollback_requested BOOLEAN NOT NULL DEFAULT FALSE
+    `);
+    await client.query(`
+      ALTER TABLE lattice_agent_runs
+        ALTER COLUMN source SET DEFAULT 'legacy'
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_agent_runs_run_queue
+        ON lattice_agent_runs (source, status, available_at, created_at)
+    `);
+  },
+  down: async (client) => {
+    await client.query(`
+      DROP INDEX IF EXISTS idx_lattice_agent_runs_run_queue
+    `);
+    await client.query(`
+      ALTER TABLE lattice_agent_runs
+        DROP COLUMN IF EXISTS rollback_requested,
+        DROP COLUMN IF EXISTS available_at,
+        DROP COLUMN IF EXISTS base_checkpoint_id,
+        DROP COLUMN IF EXISTS metadata,
+        DROP COLUMN IF EXISTS config,
+        DROP COLUMN IF EXISTS command,
+        DROP COLUMN IF EXISTS input,
+        DROP COLUMN IF EXISTS source
+    `);
+    await client.query(`
+      ALTER TABLE lattice_agent_runs
+        ALTER COLUMN started_at SET DEFAULT now()
+    `);
+  }
+};
+
+// src/migrations/agent_run_capability_revision_migration.ts
+var createAgentRunCapabilityRevisionMigration = {
+  version: 197,
+  name: "add_agent_run_capability_revision",
+  up: async (client) => {
+    await client.query(`
+      ALTER TABLE lattice_agent_runs
+        ADD COLUMN IF NOT EXISTS capability_runtime_revision TEXT
+    `);
+  },
+  down: async (client) => {
+    await client.query(`
+      ALTER TABLE lattice_agent_runs
+        DROP COLUMN IF EXISTS capability_runtime_revision
+    `);
+  }
+};
+
+// src/migrations/agent_run_base_checkpoint_captured_migration.ts
+var createAgentRunBaseCheckpointCapturedMigration = {
+  version: 198,
+  name: "add_agent_run_base_checkpoint_captured",
+  up: async (client) => {
+    await client.query(`
+      ALTER TABLE lattice_agent_runs
+        ADD COLUMN IF NOT EXISTS base_checkpoint_captured BOOLEAN NOT NULL DEFAULT FALSE
+    `);
+    await client.query(`
+      UPDATE lattice_agent_runs
+         SET base_checkpoint_captured = TRUE
+       WHERE base_checkpoint_id IS NOT NULL
+    `);
+  },
+  down: async (client) => {
+    await client.query(`
+      ALTER TABLE lattice_agent_runs
+        DROP COLUMN IF EXISTS base_checkpoint_captured
+    `);
+  }
+};
+
+// src/migrations/agent_run_rollback_failure_migration.ts
+var createAgentRunRollbackFailureMigration = {
+  version: 199,
+  name: "add_agent_run_rollback_failure",
+  up: async (client) => {
+    await client.query(`
+      ALTER TABLE lattice_agent_runs
+        ADD COLUMN IF NOT EXISTS rollback_attempts INTEGER NOT NULL DEFAULT 0,
+        ADD COLUMN IF NOT EXISTS rollback_error TEXT
+    `);
+  },
+  down: async (client) => {
+    await client.query(`
+      ALTER TABLE lattice_agent_runs
+        DROP COLUMN IF EXISTS rollback_error,
+        DROP COLUMN IF EXISTS rollback_attempts
+    `);
+  }
+};
+
+// src/migrations/agent_run_running_index_source_migration.ts
+var agentRunRunningIndexSourceMigration = {
+  version: 202,
+  name: "scope_agent_run_running_index_to_run_api",
+  up: async (client) => {
+    await client.query("DROP INDEX IF EXISTS uq_lattice_agent_runs_one_running");
+    await client.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS uq_lattice_agent_runs_one_running
+        ON lattice_agent_runs (tenant_id, thread_id)
+        WHERE status = 'running' AND source = 'run_api'
+    `);
+  },
+  down: async (client) => {
+    await client.query("DROP INDEX IF EXISTS uq_lattice_agent_runs_one_running");
+    await client.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS uq_lattice_agent_runs_one_running
+        ON lattice_agent_runs (tenant_id, thread_id)
+        WHERE status = 'running'
+    `);
+  }
+};
+
+// src/migrations/agent_run_retention_migration.ts
+var createAgentRunRetentionMigration = {
+  version: 201,
+  name: "add_agent_run_retention_index",
+  up: async (client) => {
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_agent_runs_terminal_finished_at
+        ON lattice_agent_runs (finished_at)
+        WHERE status IN ('success', 'error', 'interrupted', 'cancelled', 'timeout')
+    `);
+  },
+  down: async (client) => {
+    await client.query(`
+      DROP INDEX IF EXISTS idx_lattice_agent_runs_terminal_finished_at
+    `);
+  }
+};
+
+// src/migrations/agent_run_project_task_migration.ts
+var createAgentRunProjectTaskMigration = {
+  version: 203,
+  name: "add_agent_run_project_task",
+  up: async (client) => {
+    await client.query(`
+      ALTER TABLE lattice_agent_runs
+        ADD COLUMN IF NOT EXISTS task_id TEXT NULL
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_agent_runs_project_task
+        ON lattice_agent_runs (tenant_id, task_id, status, created_at DESC)
+        WHERE task_id IS NOT NULL
+    `);
+  },
+  down: async (client) => {
+    await client.query(`
+      DROP INDEX IF EXISTS idx_lattice_agent_runs_project_task
+    `);
+    await client.query(`
+      ALTER TABLE lattice_agent_runs
+        DROP COLUMN IF EXISTS task_id
+    `);
+  }
+};
+
+// src/migrations/agent_run_project_task_running_index_migration.ts
+var agentRunProjectTaskRunningIndexMigration = {
+  version: 204,
+  name: "scope_agent_run_running_index_to_queue_sources",
+  up: async (client) => {
+    await client.query("DROP INDEX IF EXISTS uq_lattice_agent_runs_one_running");
+    await client.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS uq_lattice_agent_runs_one_running
+        ON lattice_agent_runs (tenant_id, thread_id)
+        WHERE status = 'running'
+          AND source IN ('run_api', 'project_task')
+    `);
+  },
+  down: async (client) => {
+    await client.query("DROP INDEX IF EXISTS uq_lattice_agent_runs_one_running");
+    await client.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS uq_lattice_agent_runs_one_running
+        ON lattice_agent_runs (tenant_id, thread_id)
+        WHERE status = 'running' AND source = 'run_api'
+    `);
+  }
+};
+
 // src/migrations/capability_bundle_migration.ts
 var createCapabilityBundlesTable = {
   version: 170,
@@ -12231,64 +12571,1910 @@ var PostgreSQLPluginDeploymentStore = class {
   }
 };
 
-// src/createPgStoreConfig.ts
-async function createPgStoreConfig(connectionString) {
-  const pool = new Pool30({ connectionString });
-  const mm = new MigrationManager(pool);
-  mm.register(createThreadsTable);
-  mm.register(createScheduledTasksTable);
-  mm.register(createAssistantsTable);
-  mm.register(createSkillsTable);
-  mm.register(createWorkspacesTable);
-  mm.register(createProjectsTable);
-  mm.register(createUsersTable);
-  mm.register(createTenantsTable);
-  mm.register(addUserStatusColumn);
-  mm.register(createUserTenantLinkTable);
-  mm.register(migrateRemoveTenantIdFromUsers);
-  mm.register(createMetricsConfigsTable);
-  mm.register(createMcpServerConfigsTable);
-  mm.register(addAssistantTenantId);
-  mm.register(addSkillTenantId);
-  mm.register(changeSkillPrimaryKey);
-  mm.register(addScheduleTenantId);
-  mm.register(changeThreadPrimaryKey);
-  mm.register(createChannelIdentityMappingTables);
-  mm.register(createChannelInstallationsTable);
-  mm.register(addThreadTenantId);
-  mm.register(addProjectConfigColumn);
-  registerThreadMessageQueueMigrations(mm);
-  mm.register(createWorkflowTrackingTables);
-  for (const m of evalMigrations) {
-    mm.register(m);
+// src/stores/PostgreSQLAgentRunLedger.ts
+import { Pool as Pool30 } from "pg";
+import {
+  AgentRunAlreadyActiveError,
+  AgentRunDuplicateMessageIdError,
+  AgentRunInputCommandConflictError,
+  AgentRunInvalidTaskIdError,
+  AgentRunTenantQuotaExceededError,
+  assertQueueSources,
+  extractAgentRunInputMessageIds,
+  normalizeAgentRunMessageIds
+} from "@axiom-lattice/core";
+var DEFAULT_LIST_LIMIT = 50;
+var MAX_LIST_LIMIT = 200;
+var CLAIM_RUN_SQL = `UPDATE lattice_agent_runs AS r
+    SET status = 'running',
+        owner = $2,
+        lease_expires_at = now() + ($3::bigint || ' milliseconds')::interval,
+        started_at = now(),
+        attempts = r.attempts + 1,
+        input_message_ids = COALESCE($4::text[], r.input_message_ids),
+        updated_at = now()
+  WHERE r.run_id = $1
+    AND r.source = ANY($5::text[])
+    AND r.status = 'pending'
+    AND r.available_at <= now()
+    AND NOT EXISTS (
+      SELECT 1 FROM lattice_agent_runs AS o
+       WHERE o.tenant_id = r.tenant_id
+         AND o.thread_id = r.thread_id
+         AND o.source IN ('run_api', 'project_task')
+         AND o.status = 'running'
+    )
+    AND NOT EXISTS (
+      SELECT 1 FROM lattice_agent_runs AS b
+       WHERE b.tenant_id = r.tenant_id
+         AND b.thread_id = r.thread_id
+         AND b.source = 'run_api'
+         AND b.rollback_requested = TRUE
+    )
+  RETURNING r.*`;
+var PostgreSQLAgentRunLedger = class {
+  /**
+   * @param options An externally managed pool, or a pool config/connection URL.
+   */
+  constructor(options) {
+    this.ownsPool = true;
+    this.initialized = false;
+    this.initPromise = null;
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
+    if (typeof options.poolConfig === "string") {
+      this.pool = new Pool30({ connectionString: options.poolConfig });
+    } else if (options.poolConfig) {
+      this.pool = new Pool30(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
+    }
+    this.migrationManager = new MigrationManager(this.pool);
+    this.migrationManager.register(createAgentRunLedgerTable);
+    this.migrationManager.register(createAgentRunTaskQueueMigration);
+    this.migrationManager.register(createAgentRunCapabilityRevisionMigration);
+    this.migrationManager.register(createAgentRunBaseCheckpointCapturedMigration);
+    this.migrationManager.register(createAgentRunRollbackFailureMigration);
+    this.migrationManager.register(createAgentRunRetentionMigration);
+    this.migrationManager.register(agentRunRunningIndexSourceMigration);
+    this.migrationManager.register(createAgentRunProjectTaskMigration);
+    this.migrationManager.register(agentRunProjectTaskRunningIndexMigration);
+    if (options.autoMigrate !== false) {
+      this.initialize().catch((error) => {
+        console.error("Failed to initialize PostgreSQLAgentRunLedger:", error);
+        throw error;
+      });
+    }
   }
-  mm.register(alterChannelInstallationsTable);
-  mm.register(createChannelBindingsTable);
-  mm.register(createDatabaseConfigsTable);
-  mm.register(changeAssistantPrimaryKey);
-  mm.register(addStepThreadId);
-  mm.register(createA2AApiKeysTable);
-  mm.register(addAssistantOwnerUserId);
-  for (const m of taskMigrations) {
-    mm.register(m);
+  /** Runs pending migrations once. */
+  async initialize() {
+    if (this.initialized) return;
+    if (this.initPromise) return this.initPromise;
+    this.initPromise = (async () => {
+      try {
+        await this.migrationManager.migrate();
+        this.initialized = true;
+      } finally {
+        this.initPromise = null;
+      }
+    })();
+    return this.initPromise;
   }
-  mm.register(createMenuItemsTable);
-  mm.register(createSharedResourcesTable);
-  mm.register(addFileContentType);
-  mm.register(addMcpAppContentType);
-  mm.register(createCollectionsTable);
-  mm.register(createTaskWorkItemsMigration);
-  mm.register(addWorkItemProjectFieldsMigration);
-  mm.register(createConnectionConfigsTable);
-  mm.register(addWorkflowRunsTenantStatusUpdatedIndex);
-  mm.register(addProjectKindColumn);
-  mm.register(addA2AKeyAssistantIds);
-  mm.register(addApiKeyGrants);
-  mm.register(createOpenAuditTable);
-  mm.register(addShareOpenGrants);
-  mm.register(addTaskWorkItemEventKeyMigration);
-  mm.register(createAgentWebAppsTable);
-  mm.register(createCapabilityBundlesTable);
+  /** Ends the pool when this store owns it. */
+  async dispose() {
+    if (this.ownsPool && this.pool) {
+      await this.pool.end();
+    }
+  }
+  /**
+   * Creates a running legacy run, reconciling any existing running row first.
+   *
+   * @remarks The caller holds the `thread-run` lease, so a surviving `running`
+   * row is stale (its owner can no longer hold the lease) even when its ledger
+   * lease has not expired yet.
+   */
+  async beginRun(input) {
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      await client.query(
+        `UPDATE lattice_agent_runs
+            SET status = 'interrupted',
+                error = COALESCE(error, 'superseded by a new run on the same thread'),
+                finished_at = now(),
+                updated_at = now()
+          WHERE tenant_id = $1 AND thread_id = $2
+            AND status = 'running'`,
+        [input.tenantId, input.threadId]
+      );
+      const result = await client.query(
+        `INSERT INTO lattice_agent_runs
+           (run_id, tenant_id, workspace_id, project_id, assistant_id, thread_id,
+            status, source, owner, lease_expires_at, input_message_ids, attempts,
+            started_at)
+         VALUES ($1, $2, $3, $4, $5, $6, 'running', 'legacy', $7,
+                 now() + ($8::bigint || ' milliseconds')::interval, $9, 1, now())
+         RETURNING *`,
+        [
+          input.runId,
+          input.tenantId,
+          input.workspaceId ?? null,
+          input.projectId ?? null,
+          input.assistantId,
+          input.threadId,
+          input.owner,
+          input.leaseMs,
+          input.inputMessageIds
+        ]
+      );
+      await client.query("COMMIT");
+      return rowToRecord(result.rows[0]);
+    } catch (error) {
+      await client.query("ROLLBACK");
+      if (isActiveRunViolation(error)) {
+        throw new AgentRunAlreadyActiveError();
+      }
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  /** Creates an unowned pending run-queue row. */
+  async createPendingRun(input) {
+    const source = input.source ?? "run_api";
+    if (source === "project_task") {
+      if (input.taskId === void 0 || input.taskId.trim().length === 0) {
+        throw new AgentRunInvalidTaskIdError(
+          "A project_task run requires a non-empty taskId"
+        );
+      }
+    } else if (input.taskId !== void 0) {
+      throw new AgentRunInvalidTaskIdError(
+        `A ${source} run cannot carry a taskId`
+      );
+    }
+    if (input.input != null && input.command != null) {
+      throw new AgentRunInputCommandConflictError();
+    }
+    const inputMessageIds = input.inputMessageIds ? normalizeAgentRunMessageIds(input.inputMessageIds) : extractAgentRunInputMessageIds(input.input);
+    const availableAt = input.availableAt ?? Date.now();
+    const limit = input.maxActiveRunsForTenant;
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      if (limit !== void 0 && limit > 0) {
+        await client.query("SELECT pg_advisory_xact_lock(hashtext($1))", [
+          input.tenantId
+        ]);
+      }
+      await client.query("SELECT pg_advisory_xact_lock(hashtext($1))", [
+        `agent-run:${input.tenantId}:${input.threadId}`
+      ]);
+      if (inputMessageIds.length > 0) {
+        const duplicate = await client.query(
+          `SELECT input_message_ids
+             FROM lattice_agent_runs
+            WHERE tenant_id = $1 AND thread_id = $2
+              AND status IN ('pending', 'running')
+              AND input_message_ids && $3::text[]
+            LIMIT 1`,
+          [input.tenantId, input.threadId, inputMessageIds]
+        );
+        if ((duplicate.rowCount ?? 0) > 0) {
+          const existing = duplicate.rows[0].input_message_ids;
+          const messageId = existing.find((id) => inputMessageIds.includes(id)) ?? inputMessageIds[0];
+          throw new AgentRunDuplicateMessageIdError(messageId);
+        }
+      }
+      if (limit !== void 0 && limit > 0) {
+        const active = await client.query(
+          `SELECT count(*)::text AS count
+             FROM lattice_agent_runs
+            WHERE tenant_id = $1
+              AND source = 'run_api'
+              AND status IN ('pending', 'running')`,
+          [input.tenantId]
+        );
+        if (Number(active.rows[0].count) >= limit) {
+          throw new AgentRunTenantQuotaExceededError(input.tenantId, limit);
+        }
+      }
+      const result = await client.query(
+        `INSERT INTO lattice_agent_runs
+           (run_id, tenant_id, workspace_id, project_id, assistant_id, thread_id,
+            status, source, owner, lease_expires_at, input_message_ids, attempts,
+            input, command, config, metadata, capability_runtime_revision,
+            available_at, created_at, updated_at, task_id)
+         VALUES ($1, $2, $3, $4, $5, $6, 'pending', $7, NULL, NULL, $8, 0,
+                 $9::jsonb, $10::jsonb, $11::jsonb, $12::jsonb, $13,
+                 to_timestamp($14::double precision / 1000.0),
+                 date_trunc('milliseconds', now()),
+                 date_trunc('milliseconds', now()), $15)
+         RETURNING *`,
+        [
+          input.runId,
+          input.tenantId,
+          input.workspaceId ?? null,
+          input.projectId ?? null,
+          input.assistantId,
+          input.threadId,
+          source,
+          inputMessageIds,
+          jsonParam(input.input),
+          jsonParam(input.command),
+          jsonParam(input.config),
+          jsonParam(input.metadata),
+          input.capabilityRuntimeRevision ?? null,
+          availableAt,
+          input.taskId ?? null
+        ]
+      );
+      await client.query("COMMIT");
+      return rowToRecord(result.rows[0]);
+    } catch (error) {
+      await client.query("ROLLBACK");
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  /** Lists claimable run-queue rows, oldest available first. */
+  async listPendingRuns(options) {
+    const limit = clampLimit(options?.limit);
+    const after = options?.after;
+    const fairTenants = options?.fairTenants === true;
+    if (fairTenants && after !== void 0) {
+      throw new RangeError(
+        "listPendingRuns fairTenants does not support the after cursor"
+      );
+    }
+    const maxRunning = positiveLimit(options?.maxRunningPerTenant);
+    const sources = options?.sources === void 0 ? ["run_api"] : [...options.sources];
+    assertQueueSources(sources);
+    const params = [limit];
+    let cursorClause = "";
+    if (after) {
+      params.push(
+        new Date(after.availableAt),
+        new Date(after.createdAt),
+        after.runId
+      );
+      cursorClause = `
+          AND (r.available_at, r.created_at, r.run_id)
+              > ($2::timestamptz, $3::timestamptz, $4::uuid)`;
+    }
+    params.push(maxRunning ?? null);
+    const capIndex = params.length;
+    params.push(sources);
+    const sourcesIndex = params.length;
+    const capClause = `
+          AND ($${capIndex}::bigint IS NULL OR (
+            SELECT count(*) FROM lattice_agent_runs AS c
+             WHERE c.tenant_id = r.tenant_id
+               AND c.source = ANY($${sourcesIndex}::text[])
+               AND c.status = 'running'
+          ) < $${capIndex}::bigint)`;
+    const filterClause = `WHERE r.source = ANY($${sourcesIndex}::text[]) AND r.status = 'pending'
+          AND r.available_at <= now()
+          AND NOT EXISTS (
+            SELECT 1 FROM lattice_agent_runs AS o
+             WHERE o.tenant_id = r.tenant_id
+               AND o.thread_id = r.thread_id
+               AND o.source IN ('run_api', 'project_task')
+               AND o.status = 'running'
+          )
+          AND NOT EXISTS (
+            SELECT 1 FROM lattice_agent_runs AS b
+             WHERE b.tenant_id = r.tenant_id
+               AND b.thread_id = r.thread_id
+               AND b.source = 'run_api'
+               AND b.rollback_requested = TRUE
+          )${capClause}${cursorClause}`;
+    if (fairTenants) {
+      const ranked = await this.pool.query(
+        `WITH ranked AS (
+          SELECT r.*,
+                 row_number() OVER (
+                   PARTITION BY r.tenant_id
+                   ORDER BY r.available_at ASC, r.created_at ASC, r.run_id ASC
+                 ) AS tenant_rank
+            FROM lattice_agent_runs AS r
+            ${filterClause}
+        )
+        SELECT * FROM ranked
+        ORDER BY tenant_rank ASC, available_at ASC, created_at ASC,
+                 run_id ASC, tenant_id ASC
+        LIMIT $1`,
+        params
+      );
+      return ranked.rows.map(rowToRecord);
+    }
+    const result = await this.pool.query(
+      `SELECT r.* FROM lattice_agent_runs AS r
+        ${filterClause}
+        ORDER BY r.available_at ASC, r.created_at ASC, r.run_id ASC
+        LIMIT $1`,
+      params
+    );
+    return result.rows.map(rowToRecord);
+  }
+  /** Atomically claims a pending run-queue row. */
+  async claimRun(input) {
+    const maxRunning = positiveLimit(input.maxRunningPerTenant);
+    const sources = input.sources === void 0 ? ["run_api"] : [...input.sources];
+    assertQueueSources(sources);
+    if (maxRunning !== void 0) {
+      return this.claimRunWithTenantCap(input, maxRunning, sources);
+    }
+    try {
+      const result = await this.pool.query(
+        CLAIM_RUN_SQL,
+        [
+          input.runId,
+          input.owner,
+          input.leaseMs,
+          input.inputMessageIds ?? null,
+          sources
+        ]
+      );
+      return result.rowCount === 0 ? void 0 : rowToRecord(result.rows[0]);
+    } catch (error) {
+      if (isActiveRunViolation(error)) return void 0;
+      throw error;
+    }
+  }
+  /**
+   * Claims under a per-tenant running cap.
+   *
+   * @remarks Serializes claims for one tenant with a transaction-scoped
+   * advisory lock, counts running rows, then runs the same claim statement.
+   * The lock is shared with admission creates so cap checks cannot race.
+   */
+  async claimRunWithTenantCap(input, maxRunning, sources) {
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      const candidate = await client.query(
+        `SELECT tenant_id FROM lattice_agent_runs
+          WHERE run_id = $1 AND source = ANY($2::text[]) AND status = 'pending'`,
+        [input.runId, sources]
+      );
+      if (candidate.rowCount === 0) {
+        await client.query("COMMIT");
+        return void 0;
+      }
+      const tenantId = candidate.rows[0].tenant_id;
+      await client.query("SELECT pg_advisory_xact_lock(hashtext($1))", [
+        tenantId
+      ]);
+      const running = await client.query(
+        `SELECT count(*)::text AS count
+           FROM lattice_agent_runs
+          WHERE tenant_id = $1
+            AND source = ANY($2::text[])
+            AND status = 'running'`,
+        [tenantId, sources]
+      );
+      if (Number(running.rows[0].count) >= maxRunning) {
+        await client.query("COMMIT");
+        return void 0;
+      }
+      const result = await client.query(
+        CLAIM_RUN_SQL,
+        [
+          input.runId,
+          input.owner,
+          input.leaseMs,
+          input.inputMessageIds ?? null,
+          sources
+        ]
+      );
+      await client.query("COMMIT");
+      return result.rowCount === 0 ? void 0 : rowToRecord(result.rows[0]);
+    } catch (error) {
+      await client.query("ROLLBACK");
+      if (isActiveRunViolation(error)) return void 0;
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  /** Captures the checkpoint a running run-queue row started from. */
+  async setBaseCheckpoint(tenantId, runId, owner, baseCheckpointId) {
+    const result = await this.pool.query(
+      `UPDATE lattice_agent_runs
+          SET base_checkpoint_id = $4,
+              base_checkpoint_captured = TRUE,
+              updated_at = now()
+        WHERE tenant_id = $1 AND run_id = $2 AND owner = $3
+          AND status = 'running'
+          AND source IN ('run_api', 'project_task')
+        RETURNING run_id`,
+      [tenantId, runId, owner, baseCheckpointId]
+    );
+    return (result.rowCount ?? 0) > 0;
+  }
+  /** Records the resolved capability runtime revision for a running run. */
+  async setCapabilityRevision(tenantId, runId, owner, revision) {
+    const result = await this.pool.query(
+      `UPDATE lattice_agent_runs
+          SET capability_runtime_revision = $4, updated_at = now()
+        WHERE tenant_id = $1 AND run_id = $2 AND owner = $3
+          AND status = 'running'
+          AND source IN ('run_api', 'project_task')
+        RETURNING run_id`,
+      [tenantId, runId, owner, revision]
+    );
+    return (result.rowCount ?? 0) > 0;
+  }
+  /** Deletes a run row immediately, optionally guarded by status/owner. */
+  async deleteRun(tenantId, runId, expected) {
+    const params = [tenantId, runId];
+    let predicate = "tenant_id = $1 AND run_id = $2";
+    if (expected?.status !== void 0) {
+      params.push(expected.status);
+      predicate += ` AND status = $${params.length}`;
+    }
+    if (expected?.owner !== void 0) {
+      params.push(expected.owner);
+      predicate += ` AND owner = $${params.length}`;
+    }
+    const result = await this.pool.query(
+      `DELETE FROM lattice_agent_runs WHERE ${predicate}`,
+      params
+    );
+    return (result.rowCount ?? 0) > 0;
+  }
+  /** Deletes terminal rows finished before `cutoffMs`, oldest first. */
+  async deleteTerminalBefore(cutoffMs, limit) {
+    if (!Number.isFinite(cutoffMs)) return 0;
+    const max = Number.isFinite(limit) ? Math.floor(limit) : 0;
+    if (max <= 0) return 0;
+    const result = await this.pool.query(
+      `DELETE FROM lattice_agent_runs
+        WHERE run_id IN (
+          SELECT run_id FROM lattice_agent_runs
+           WHERE status IN ('success', 'error', 'interrupted', 'cancelled', 'timeout')
+             AND finished_at < to_timestamp($1::double precision / 1000.0)
+           ORDER BY finished_at ASC
+           LIMIT $2
+        )`,
+      [cutoffMs, max]
+    );
+    return result.rowCount ?? 0;
+  }
+  /** Extends a running run's lease when `owner` still holds it. */
+  async heartbeatRun(runId, owner, leaseMs) {
+    const result = await this.pool.query(
+      `UPDATE lattice_agent_runs
+          SET lease_expires_at = now() + ($3::bigint || ' milliseconds')::interval,
+              updated_at = now()
+        WHERE run_id = $1 AND owner = $2 AND status = 'running'
+        RETURNING run_id`,
+      [runId, owner, leaseMs]
+    );
+    return (result.rowCount ?? 0) > 0;
+  }
+  /** Settles a running run when `owner` still holds it. */
+  async settleRun(runId, owner, status, error) {
+    const result = await this.pool.query(
+      `UPDATE lattice_agent_runs
+          SET status = $3, error = $4, finished_at = now(), updated_at = now()
+        WHERE run_id = $1 AND owner = $2 AND status = 'running'
+        RETURNING run_id`,
+      [runId, owner, status, error ?? null]
+    );
+    return (result.rowCount ?? 0) > 0;
+  }
+  /** Settles a running run only when no rollback is pending. */
+  async settleRunUnlessRollbackRequested(runId, owner, status, error) {
+    const result = await this.pool.query(
+      `UPDATE lattice_agent_runs
+          SET status = $3, error = $4, finished_at = now(), updated_at = now()
+        WHERE run_id = $1 AND owner = $2 AND status = 'running'
+          AND rollback_requested = FALSE
+        RETURNING run_id`,
+      [runId, owner, status, error ?? null]
+    );
+    return (result.rowCount ?? 0) > 0;
+  }
+  /** Terminates an uncaptured rollback run with a repair signal. */
+  async settleRollbackFailure(tenantId, runId, error) {
+    const result = await this.pool.query(
+      `UPDATE lattice_agent_runs
+          SET status = 'error',
+              error = $3,
+              rollback_requested = FALSE,
+              rollback_error = $3,
+              finished_at = now(),
+              updated_at = now()
+        WHERE tenant_id = $1 AND run_id = $2
+          AND source = 'run_api'
+          AND rollback_requested = TRUE
+          AND base_checkpoint_captured = FALSE
+          AND status IN ('running', 'interrupted')
+        RETURNING run_id`,
+      [tenantId, runId, error]
+    );
+    return (result.rowCount ?? 0) > 0;
+  }
+  /** Records one bounded rollback failure and optionally converges. */
+  async recordRollbackFailure(tenantId, runId, error, maxAttempts) {
+    const result = await this.pool.query(
+      `UPDATE lattice_agent_runs
+          SET rollback_attempts = rollback_attempts + 1,
+              rollback_error = $3,
+              status = CASE
+                WHEN rollback_attempts + 1 >= $4 THEN 'error'
+                ELSE status
+              END,
+              error = CASE
+                WHEN rollback_attempts + 1 >= $4 THEN $3
+                ELSE error
+              END,
+              rollback_requested = CASE
+                WHEN rollback_attempts + 1 >= $4 THEN FALSE
+                ELSE rollback_requested
+              END,
+              finished_at = CASE
+                WHEN rollback_attempts + 1 >= $4 THEN now()
+                ELSE finished_at
+              END,
+              updated_at = now()
+        WHERE tenant_id = $1
+          AND run_id = $2
+          AND source = 'run_api'
+          AND rollback_requested = TRUE
+          AND status IN ('running', 'interrupted')
+        RETURNING rollback_attempts, status`,
+      [tenantId, runId, error, maxAttempts]
+    );
+    if (result.rowCount === 0) return void 0;
+    const row = result.rows[0];
+    return {
+      attempts: row.rollback_attempts,
+      terminal: row.status === "error"
+    };
+  }
+  /** Reads a run within a tenant. */
+  async getRun(tenantId, runId) {
+    const result = await this.pool.query(
+      `SELECT * FROM lattice_agent_runs WHERE tenant_id = $1 AND run_id = $2`,
+      [tenantId, runId]
+    );
+    return result.rowCount === 0 ? void 0 : rowToRecord(result.rows[0]);
+  }
+  /** Finds the active (pending/running) run for a ProjectTask. */
+  async getActiveRunForTask(tenantId, taskId) {
+    const result = await this.pool.query(
+      `SELECT * FROM lattice_agent_runs
+        WHERE tenant_id = $1 AND task_id = $2
+          AND status IN ('pending', 'running')
+        ORDER BY created_at DESC, run_id DESC
+        LIMIT 1`,
+      [tenantId, taskId]
+    );
+    return result.rowCount === 0 ? void 0 : rowToRecord(result.rows[0]);
+  }
+  /** Lists a thread's runs, newest first (including pending rows). */
+  async listRuns(tenantId, threadId, options) {
+    const limit = clampLimit(options?.limit);
+    const offset = Math.max(0, Math.floor(options?.offset ?? 0));
+    const result = await this.pool.query(
+      `SELECT * FROM lattice_agent_runs
+        WHERE tenant_id = $1 AND thread_id = $2
+        ORDER BY created_at DESC
+        LIMIT $3 OFFSET $4`,
+      [tenantId, threadId, limit, offset]
+    );
+    return result.rows.map(rowToRecord);
+  }
+  /** Finds the thread's running run, if any. */
+  async findRunning(tenantId, threadId) {
+    const result = await this.pool.query(
+      `SELECT * FROM lattice_agent_runs
+        WHERE tenant_id = $1 AND thread_id = $2 AND status = 'running'
+        LIMIT 1`,
+      [tenantId, threadId]
+    );
+    return result.rowCount === 0 ? void 0 : rowToRecord(result.rows[0]);
+  }
+  /** Requests cancellation, settling pending/expired rows interrupted. */
+  async requestCancel(tenantId, runId) {
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      const current = await client.query(
+        `SELECT status,
+                COALESCE(lease_expires_at < now(), TRUE) AS expired
+           FROM lattice_agent_runs
+          WHERE tenant_id = $1 AND run_id = $2
+          FOR UPDATE`,
+        [tenantId, runId]
+      );
+      if (current.rowCount === 0) {
+        await client.query("COMMIT");
+        return "not_found";
+      }
+      const row = current.rows[0];
+      if (row.status === "pending") {
+        await client.query(
+          `UPDATE lattice_agent_runs
+              SET status = 'interrupted', cancel_requested = TRUE,
+                  finished_at = now(), updated_at = now()
+            WHERE tenant_id = $1 AND run_id = $2`,
+          [tenantId, runId]
+        );
+        await client.query("COMMIT");
+        return "cancelled";
+      }
+      if (row.status !== "running") {
+        await client.query("COMMIT");
+        return "terminal";
+      }
+      if (row.expired) {
+        await client.query(
+          `UPDATE lattice_agent_runs
+              SET status = 'interrupted', cancel_requested = TRUE,
+                  finished_at = now(), updated_at = now()
+            WHERE tenant_id = $1 AND run_id = $2`,
+          [tenantId, runId]
+        );
+        await client.query("COMMIT");
+        return "cancelled";
+      }
+      await client.query(
+        `UPDATE lattice_agent_runs
+            SET cancel_requested = TRUE, updated_at = now()
+          WHERE tenant_id = $1 AND run_id = $2`,
+        [tenantId, runId]
+      );
+      await client.query("COMMIT");
+      return "requested";
+    } catch (error) {
+      await client.query("ROLLBACK");
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  /** Deletes a pending run or flags a running run for rollback. */
+  async requestRollback(tenantId, runId) {
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      const current = await client.query(
+        `SELECT status, source FROM lattice_agent_runs
+          WHERE tenant_id = $1 AND run_id = $2
+          FOR UPDATE`,
+        [tenantId, runId]
+      );
+      if (current.rowCount === 0) {
+        await client.query("COMMIT");
+        return "not_found";
+      }
+      const { status, source } = current.rows[0];
+      if (source !== "run_api") {
+        await client.query("COMMIT");
+        return "terminal";
+      }
+      if (status === "pending") {
+        await client.query(
+          `DELETE FROM lattice_agent_runs WHERE tenant_id = $1 AND run_id = $2`,
+          [tenantId, runId]
+        );
+        await client.query("COMMIT");
+        return "deleted";
+      }
+      if (status !== "running") {
+        await client.query("COMMIT");
+        return "terminal";
+      }
+      await client.query(
+        `UPDATE lattice_agent_runs
+            SET rollback_requested = TRUE, cancel_requested = TRUE,
+                updated_at = now()
+          WHERE tenant_id = $1 AND run_id = $2`,
+        [tenantId, runId]
+      );
+      await client.query("COMMIT");
+      return "requested";
+    } catch (error) {
+      await client.query("ROLLBACK");
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  /** Atomically reclaims an expired running row without requeueing it. */
+  async recoverExpiredRun(runId, owner, leaseMs) {
+    const result = await this.pool.query(
+      `UPDATE lattice_agent_runs
+          SET owner = $2,
+              lease_expires_at = now() + ($3::bigint || ' milliseconds')::interval,
+              attempts = attempts + 1,
+              updated_at = now()
+        WHERE run_id = $1
+          AND source IN ('run_api', 'project_task')
+          AND status = 'running'
+          AND lease_expires_at < now()
+        RETURNING *`,
+      [runId, owner, leaseMs]
+    );
+    return result.rowCount === 0 ? void 0 : rowToRecord(result.rows[0]);
+  }
+  /** Atomically requeues or interrupts an expired run-queue row. */
+  async settleExpiredRun(runId, outcome, options) {
+    if (outcome === "pending") {
+      const availableAt = options?.availableAt ?? Date.now();
+      const result2 = await this.pool.query(
+        `UPDATE lattice_agent_runs
+            SET status = 'pending',
+                owner = NULL,
+                lease_expires_at = NULL,
+                started_at = NULL,
+                available_at = to_timestamp($2::double precision / 1000.0),
+                finished_at = NULL,
+                updated_at = now()
+          WHERE run_id = $1
+            AND source IN ('run_api', 'project_task')
+            AND status = 'running'
+            AND lease_expires_at < now()
+          RETURNING run_id`,
+        [runId, availableAt]
+      );
+      return (result2.rowCount ?? 0) > 0;
+    }
+    const result = await this.pool.query(
+      `UPDATE lattice_agent_runs
+          SET status = $3,
+              error = COALESCE($2, error),
+              finished_at = now(),
+              updated_at = now()
+        WHERE run_id = $1
+          AND source IN ('run_api', 'project_task')
+          AND status = 'running'
+          AND lease_expires_at < now()
+        RETURNING run_id`,
+      [
+        runId,
+        options?.error ?? null,
+        outcome === "timeout" ? "timeout" : "interrupted"
+      ]
+    );
+    return (result.rowCount ?? 0) > 0;
+  }
+  /** Counts runs grouped by lifecycle status. */
+  async counts() {
+    const counts = {
+      pending: 0,
+      running: 0,
+      success: 0,
+      error: 0,
+      interrupted: 0,
+      cancelled: 0,
+      timeout: 0
+    };
+    const result = await this.pool.query(
+      `SELECT status, count(*)::int AS count
+         FROM lattice_agent_runs
+        GROUP BY status`
+    );
+    for (const row of result.rows) {
+      const status = parseStatus(row.status);
+      if (status) counts[status] = row.count;
+    }
+    return counts;
+  }
+  /** Reports expired run-queue rows for the requested sources. */
+  async reapExpired(sources = ["run_api"]) {
+    assertQueueSources(sources);
+    const result = await this.pool.query(
+      `SELECT * FROM lattice_agent_runs
+        WHERE source = ANY($1::text[]) AND status = 'running'
+          AND lease_expires_at < now()
+        ORDER BY lease_expires_at ASC`,
+      [[...sources]]
+    );
+    return result.rows.map(reapedFromRow);
+  }
+  /** Lists rollback work that still needs a checkpoint rewind. */
+  async listRollbackRuns() {
+    const result = await this.pool.query(
+      `SELECT * FROM lattice_agent_runs
+        WHERE source = 'run_api'
+          AND rollback_requested = TRUE
+          AND (
+            status = 'interrupted'
+            OR (status = 'running' AND lease_expires_at < now())
+          )
+        ORDER BY updated_at ASC`
+    );
+    return result.rows.map(reapedFromRow);
+  }
+  /** Settles expired legacy rows, preserving the historical supervisor behavior. */
+  async reapLegacyExpired() {
+    const result = await this.pool.query(
+      `UPDATE lattice_agent_runs
+          SET status = 'interrupted',
+              error = COALESCE(error, 'run owner lost'),
+              finished_at = now(),
+              updated_at = now()
+        WHERE source = 'legacy' AND status = 'running'
+          AND lease_expires_at < now()
+        RETURNING run_id, tenant_id, assistant_id, thread_id, workspace_id, project_id`
+    );
+    return result.rows.map((row) => ({
+      runId: row.run_id,
+      tenantId: row.tenant_id,
+      assistantId: row.assistant_id,
+      threadId: row.thread_id,
+      workspaceId: row.workspace_id ?? void 0,
+      projectId: row.project_id ?? void 0
+    }));
+  }
+};
+function positiveLimit(limit) {
+  return limit !== void 0 && Number.isSafeInteger(limit) && limit > 0 ? limit : void 0;
+}
+function clampLimit(limit) {
+  if (limit === void 0) return DEFAULT_LIST_LIMIT;
+  const floored = Math.floor(limit);
+  if (!Number.isFinite(floored)) return DEFAULT_LIST_LIMIT;
+  return Math.min(MAX_LIST_LIMIT, Math.max(1, floored));
+}
+function jsonParam(value) {
+  return value === void 0 || value === null ? null : JSON.stringify(value);
+}
+function parseStatus(value) {
+  switch (value) {
+    case "pending":
+    case "running":
+    case "success":
+    case "error":
+    case "interrupted":
+    case "cancelled":
+    case "timeout":
+      return value;
+    default:
+      return void 0;
+  }
+}
+function parseSource(value) {
+  switch (value) {
+    case "run_api":
+      return "run_api";
+    case "project_task":
+      return "project_task";
+    default:
+      return "legacy";
+  }
+}
+function toJsonObject(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value !== "object" || Array.isArray(value)) return null;
+  return value;
+}
+function rowToRecord(row) {
+  return {
+    runId: row.run_id,
+    tenantId: row.tenant_id,
+    workspaceId: row.workspace_id ?? void 0,
+    projectId: row.project_id ?? void 0,
+    assistantId: row.assistant_id,
+    threadId: row.thread_id,
+    status: parseStatus(row.status) ?? "error",
+    source: parseSource(row.source),
+    taskId: row.task_id ?? void 0,
+    owner: row.owner,
+    leaseExpiresAt: row.lease_expires_at === null ? null : row.lease_expires_at.getTime(),
+    inputMessageIds: row.input_message_ids,
+    attempts: row.attempts,
+    error: row.error,
+    cancelRequested: row.cancel_requested,
+    rollbackRequested: row.rollback_requested,
+    rollbackAttempts: row.rollback_attempts,
+    rollbackError: row.rollback_error,
+    input: toJsonObject(row.input),
+    command: toJsonObject(row.command),
+    config: toJsonObject(row.config),
+    metadata: toJsonObject(row.metadata),
+    baseCheckpointId: row.base_checkpoint_id,
+    baseCheckpointCaptured: row.base_checkpoint_captured,
+    capabilityRuntimeRevision: row.capability_runtime_revision,
+    availableAt: row.available_at.getTime(),
+    createdAt: row.created_at.getTime(),
+    updatedAt: row.updated_at.getTime(),
+    startedAt: row.started_at === null ? null : row.started_at.getTime(),
+    finishedAt: row.finished_at === null ? null : row.finished_at.getTime()
+  };
+}
+function reapedFromRow(row) {
+  return {
+    runId: row.run_id,
+    tenantId: row.tenant_id,
+    assistantId: row.assistant_id,
+    threadId: row.thread_id,
+    workspaceId: row.workspace_id ?? void 0,
+    projectId: row.project_id ?? void 0,
+    source: parseSource(row.source),
+    taskId: row.task_id ?? void 0,
+    attempts: row.attempts,
+    cancelRequested: row.cancel_requested,
+    rollbackRequested: row.rollback_requested,
+    baseCheckpointId: row.base_checkpoint_id,
+    createdAt: row.created_at.getTime(),
+    startedAt: row.started_at === null ? null : row.started_at.getTime(),
+    leaseExpiresAt: row.lease_expires_at === null ? null : row.lease_expires_at.getTime()
+  };
+}
+function isActiveRunViolation(error) {
+  if (typeof error !== "object" || error === null) return false;
+  const { code, constraint } = error;
+  return code === "23505" && constraint === "uq_lattice_agent_runs_one_running";
+}
+
+// src/stores/PostgreSQLChannelReplyJobStore.ts
+import { Pool as Pool31 } from "pg";
+import {
+  assertValidCreateChannelReplyJobInput,
+  normalizeChannelReplyJobListLimit
+} from "@axiom-lattice/protocols";
+var DB_CLOCK_MS2 = "FLOOR(EXTRACT(EPOCH FROM clock_timestamp()) * 1000)::bigint";
+var COLUMNS = `run_id, tenant_id, assistant_id, thread_id, adapter_channel,
+  channel_installation_id, reply_target, input_message_id, stream_cursor, status,
+  attempts, available_at, lease_owner, lease_expires_at, last_error,
+  output_message_id, created_at, updated_at, delivered_at`;
+function toNumber(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "string") return Number(value);
+  throw new Error("Invalid channel reply job numeric column");
+}
+function toNullableNumber(value) {
+  return value === null ? null : toNumber(value);
+}
+function toStatus(value) {
+  if (value === "pending" || value === "delivered" || value === "failed") {
+    return value;
+  }
+  throw new Error(`Invalid channel reply job status: ${value}`);
+}
+function mapRow9(row) {
+  return {
+    runId: row.run_id,
+    tenantId: row.tenant_id,
+    assistantId: row.assistant_id,
+    threadId: row.thread_id,
+    adapterChannel: row.adapter_channel,
+    channelInstallationId: row.channel_installation_id,
+    replyTarget: row.reply_target,
+    inputMessageId: row.input_message_id,
+    streamCursor: row.stream_cursor,
+    status: toStatus(row.status),
+    attempts: toNumber(row.attempts),
+    availableAt: toNumber(row.available_at),
+    leaseOwner: row.lease_owner,
+    leaseExpiresAt: toNullableNumber(row.lease_expires_at),
+    lastError: row.last_error,
+    outputMessageId: row.output_message_id,
+    createdAt: toNumber(row.created_at),
+    updatedAt: toNumber(row.updated_at),
+    deliveredAt: toNullableNumber(row.delivered_at)
+  };
+}
+var PostgreSQLChannelReplyJobStore = class {
+  /** @param options An externally managed pool, or a pool config/connection URL. */
+  constructor(options) {
+    this.ownsPool = true;
+    this.initialized = false;
+    this.initPromise = null;
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
+    if (typeof options.poolConfig === "string") {
+      this.pool = new Pool31({ connectionString: options.poolConfig });
+    } else if (options.poolConfig) {
+      this.pool = new Pool31(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
+    }
+    this.migrationManager = new MigrationManager(this.pool);
+    this.migrationManager.register(createChannelReplyJobsTable);
+    if (options.autoMigrate !== false) {
+      this.initialize().catch((error) => {
+        console.error("Failed to initialize PostgreSQLChannelReplyJobStore:", error);
+        throw error;
+      });
+    }
+  }
+  /** Runs pending migrations once. */
+  async initialize() {
+    if (this.initialized) return;
+    if (this.initPromise) return this.initPromise;
+    this.initPromise = (async () => {
+      try {
+        await this.migrationManager.migrate();
+        this.initialized = true;
+      } finally {
+        this.initPromise = null;
+      }
+    })();
+    return this.initPromise;
+  }
+  /** Ends the pool when this store owns it. */
+  async dispose() {
+    if (this.ownsPool) await this.pool.end();
+  }
+  /** Creates a pending job with database-clock created/updated timestamps. */
+  async create(input) {
+    assertValidCreateChannelReplyJobInput(input);
+    const result = await this.pool.query(
+      `WITH clock AS (SELECT ${DB_CLOCK_MS2} AS now_ms)
+       INSERT INTO lattice_channel_reply_jobs (
+         run_id, tenant_id, assistant_id, thread_id, adapter_channel,
+         channel_installation_id, reply_target, input_message_id, stream_cursor,
+         status, attempts, available_at, lease_owner, lease_expires_at,
+         last_error, output_message_id, created_at, updated_at, delivered_at
+       )
+       SELECT
+         $1, $2, $3, $4, $5,
+         $6, $7::jsonb, $8, $9,
+         'pending', 0, $10, NULL, NULL,
+         NULL, NULL, clock.now_ms, clock.now_ms, NULL
+       FROM clock
+       RETURNING ${COLUMNS}`,
+      [
+        input.runId,
+        input.tenantId,
+        input.assistantId,
+        input.threadId,
+        input.adapterChannel,
+        input.channelInstallationId,
+        JSON.stringify(input.replyTarget),
+        input.inputMessageId,
+        input.streamCursor ?? null,
+        input.availableAt
+      ]
+    );
+    return mapRow9(result.rows[0]);
+  }
+  /** Reads one job within a tenant scope. */
+  async get(tenantId, runId) {
+    const result = await this.pool.query(
+      `SELECT ${COLUMNS}
+         FROM lattice_channel_reply_jobs
+        WHERE tenant_id = $1 AND run_id = $2`,
+      [tenantId, runId]
+    );
+    return result.rowCount === 0 ? null : mapRow9(result.rows[0]);
+  }
+  /** Lists claimable pending jobs that are due at `now`, oldest first. */
+  async listPending(now, limit) {
+    const result = await this.pool.query(
+      `SELECT ${COLUMNS}
+         FROM lattice_channel_reply_jobs
+        WHERE status = 'pending'
+          AND available_at <= $1
+          AND (lease_owner IS NULL OR lease_expires_at IS NULL OR lease_expires_at <= $1)
+        ORDER BY available_at ASC, created_at ASC, run_id ASC
+        LIMIT $2`,
+      [now, normalizeChannelReplyJobListLimit(limit)]
+    );
+    return result.rows.map(mapRow9);
+  }
+  /**
+   * Atomically leases a claimable job.
+   *
+   * @param now Accepted for interface symmetry; PostgreSQL uses the database clock.
+   */
+  async claim(tenantId, runId, owner, leaseMs, now) {
+    void now;
+    const result = await this.pool.query(
+      `WITH clock AS (SELECT ${DB_CLOCK_MS2} AS now_ms)
+       UPDATE lattice_channel_reply_jobs AS j
+          SET lease_owner = $3,
+              lease_expires_at = clock.now_ms + $4,
+              updated_at = clock.now_ms
+         FROM clock
+        WHERE j.tenant_id = $1
+          AND j.run_id = $2
+          AND j.status = 'pending'
+          AND j.available_at <= clock.now_ms
+          AND (j.lease_owner IS NULL OR j.lease_expires_at IS NULL OR j.lease_expires_at <= clock.now_ms)
+        RETURNING ${COLUMNS}`,
+      [tenantId, runId, owner, leaseMs]
+    );
+    return result.rowCount === 0 ? null : mapRow9(result.rows[0]);
+  }
+  /**
+   * Marks a job delivered when `owner` still holds the lease.
+   *
+   * @param now Accepted for interface symmetry; PostgreSQL uses the database clock.
+   */
+  async markDelivered(tenantId, runId, owner, outputMessageId = null, now) {
+    void now;
+    const result = await this.pool.query(
+      `WITH clock AS (SELECT ${DB_CLOCK_MS2} AS now_ms)
+       UPDATE lattice_channel_reply_jobs AS j
+          SET status = 'delivered',
+              output_message_id = $4,
+              lease_owner = NULL,
+              lease_expires_at = NULL,
+              delivered_at = clock.now_ms,
+              updated_at = clock.now_ms
+         FROM clock
+        WHERE j.tenant_id = $1
+          AND j.run_id = $2
+          AND j.lease_owner = $3
+          AND j.status = 'pending'
+        RETURNING ${COLUMNS}`,
+      [tenantId, runId, owner, outputMessageId]
+    );
+    return result.rowCount === 0 ? null : mapRow9(result.rows[0]);
+  }
+  /**
+   * Returns a job to pending with an incremented attempt count.
+   *
+   * @param now Accepted for interface symmetry; PostgreSQL uses the database clock.
+   */
+  async reschedule(tenantId, runId, owner, error, availableAt, now) {
+    void now;
+    const result = await this.pool.query(
+      `WITH clock AS (SELECT ${DB_CLOCK_MS2} AS now_ms)
+       UPDATE lattice_channel_reply_jobs AS j
+          SET status = 'pending',
+              attempts = attempts + 1,
+              lease_owner = NULL,
+              lease_expires_at = NULL,
+              last_error = $4,
+              available_at = $5,
+              updated_at = clock.now_ms
+         FROM clock
+        WHERE j.tenant_id = $1
+          AND j.run_id = $2
+          AND j.lease_owner = $3
+          AND j.status = 'pending'
+        RETURNING ${COLUMNS}`,
+      [tenantId, runId, owner, error, availableAt]
+    );
+    return result.rowCount === 0 ? null : mapRow9(result.rows[0]);
+  }
+  /**
+   * Marks a job terminally failed when `owner` still holds the lease.
+   *
+   * @param now Accepted for interface symmetry; PostgreSQL uses the database clock.
+   */
+  async markFailed(tenantId, runId, owner, error, now) {
+    void now;
+    const result = await this.pool.query(
+      `WITH clock AS (SELECT ${DB_CLOCK_MS2} AS now_ms)
+       UPDATE lattice_channel_reply_jobs AS j
+          SET status = 'failed',
+              last_error = $4,
+              lease_owner = NULL,
+              lease_expires_at = NULL,
+              updated_at = clock.now_ms
+         FROM clock
+        WHERE j.tenant_id = $1
+          AND j.run_id = $2
+          AND j.lease_owner = $3
+          AND j.status = 'pending'
+        RETURNING ${COLUMNS}`,
+      [tenantId, runId, owner, error]
+    );
+    return result.rowCount === 0 ? null : mapRow9(result.rows[0]);
+  }
+  /** Deletes one job. Returns whether a row was removed. */
+  async delete(tenantId, runId) {
+    const result = await this.pool.query(
+      `DELETE FROM lattice_channel_reply_jobs WHERE tenant_id = $1 AND run_id = $2`,
+      [tenantId, runId]
+    );
+    return (result.rowCount ?? 0) > 0;
+  }
+  /** Deletes terminal jobs whose last update is older than `before`. */
+  async deleteTerminalBefore(before, limit) {
+    const result = await this.pool.query(
+      `DELETE FROM lattice_channel_reply_jobs
+        WHERE run_id IN (
+          SELECT run_id
+            FROM lattice_channel_reply_jobs
+           WHERE status IN ('delivered', 'failed')
+             AND updated_at < $1
+           ORDER BY updated_at ASC, run_id ASC
+           LIMIT $2
+        )`,
+      [before, normalizeChannelReplyJobListLimit(limit)]
+    );
+    return result.rowCount ?? 0;
+  }
+};
+
+// src/stores/PostgreSQLCheckpointStorage.ts
+var CheckpointTargetNotEmptyError = class extends Error {
+  /**
+   * @param threadId - Non-empty target thread id.
+   */
+  constructor(threadId) {
+    super(`Checkpoint target thread ${threadId} is not empty`);
+    /** Machine-readable conflict code. */
+    this.code = "CHECKPOINT_TARGET_NOT_EMPTY";
+    this.name = "CheckpointTargetNotEmptyError";
+  }
+};
+var CheckpointBaseNotFoundError = class extends Error {
+  /**
+   * @param threadId - Thread owning the missing base checkpoint.
+   * @param baseCheckpointId - Base checkpoint id that was not found.
+   */
+  constructor(threadId, baseCheckpointId) {
+    super(`Checkpoint ${baseCheckpointId} does not exist on thread ${threadId}`);
+    /** Machine-readable failure code. */
+    this.code = "CHECKPOINT_BASE_NOT_FOUND";
+    this.name = "CheckpointBaseNotFoundError";
+    this.threadId = threadId;
+    this.baseCheckpointId = baseCheckpointId;
+  }
+};
+async function rollbackQuietly(client) {
+  try {
+    await client.query("ROLLBACK");
+  } catch {
+  }
+}
+function isUniqueViolation3(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "23505";
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function checkpointKey(checkpointNs, checkpointId) {
+  return `${checkpointNs}\0${checkpointId}`;
+}
+function blobKey(checkpointNs, channel, version) {
+  return `${checkpointNs}\0${channel}\0${version}`;
+}
+function checkpointRecord(value) {
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value);
+      return isRecord4(parsed) ? parsed : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  return isRecord4(value) ? value : void 0;
+}
+function channelVersions(value) {
+  const checkpoint = checkpointRecord(value);
+  const versions = checkpoint?.channel_versions;
+  return isRecord4(versions) ? versions : void 0;
+}
+var DELETE_CHUNK_SIZE = 100;
+function chunk(items, size) {
+  const chunks = [];
+  for (let index = 0; index < items.length; index += size) {
+    chunks.push(items.slice(index, index + size));
+  }
+  return chunks;
+}
+function toCount(value) {
+  const parsed = Number(value ?? 0);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+var PostgreSQLCheckpointStorage = class {
+  /**
+   * @param pool - PostgreSQL pool shared with the rest of the store config.
+   */
+  constructor(pool) {
+    this.pool = pool;
+  }
+  /**
+   * Measure the checkpoint storage used by one thread.
+   *
+   * @param threadId - Thread id whose checkpoint rows should be measured.
+   * @returns Counts and byte sizes grouped by checkpoint storage category.
+   */
+  async get(threadId) {
+    const result = await this.pool.query(
+      `SELECT
+        (SELECT count(*)::bigint FROM checkpoints WHERE thread_id=$1) AS checkpoint_count,
+        (SELECT coalesce(sum(pg_column_size(checkpoint) + pg_column_size(metadata)),0)::bigint FROM checkpoints WHERE thread_id=$1) AS checkpoint_bytes,
+        (SELECT count(*)::bigint FROM checkpoint_blobs WHERE thread_id=$1) AS blob_count,
+        (SELECT coalesce(sum(coalesce(octet_length(blob),0)),0)::bigint FROM checkpoint_blobs WHERE thread_id=$1) AS blob_bytes,
+        (SELECT count(*)::bigint FROM checkpoint_writes WHERE thread_id=$1) AS write_count,
+        (SELECT coalesce(sum(octet_length(blob)),0)::bigint FROM checkpoint_writes WHERE thread_id=$1) AS write_bytes`,
+      [threadId]
+    );
+    const row = result.rows[0];
+    const checkpointCount = toCount(row?.checkpoint_count);
+    const checkpointBytes = toCount(row?.checkpoint_bytes);
+    const blobCount = toCount(row?.blob_count);
+    const blobBytes = toCount(row?.blob_bytes);
+    const writeCount = toCount(row?.write_count);
+    const writeBytes = toCount(row?.write_bytes);
+    return {
+      threadId,
+      totalBytes: checkpointBytes + blobBytes + writeBytes,
+      checkpoints: { count: checkpointCount, bytes: checkpointBytes },
+      channelValues: { count: blobCount, bytes: blobBytes },
+      pendingWrites: { count: writeCount, bytes: writeBytes }
+    };
+  }
+  /**
+   * Copy every checkpoint row from a source thread to an empty target thread.
+   *
+   * @param sourceThreadId - Thread whose rows are copied.
+   * @param targetThreadId - Empty thread that receives the rows.
+   * @returns Resolves when the copy commits; an empty source is a no-op.
+   * @throws {CheckpointTargetNotEmptyError} When the target already owns rows.
+   */
+  async copyThread(sourceThreadId, targetThreadId) {
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      const target = await client.query(
+        `SELECT (
+          EXISTS (SELECT 1 FROM checkpoints WHERE thread_id=$1)
+          OR EXISTS (SELECT 1 FROM checkpoint_blobs WHERE thread_id=$1)
+          OR EXISTS (SELECT 1 FROM checkpoint_writes WHERE thread_id=$1)
+        ) AS not_empty`,
+        [targetThreadId]
+      );
+      if (target.rows[0]?.not_empty) {
+        throw new CheckpointTargetNotEmptyError(targetThreadId);
+      }
+      await client.query(
+        `INSERT INTO checkpoints (
+          thread_id, checkpoint_ns, checkpoint_id, parent_checkpoint_id, type, checkpoint, metadata
+        )
+        SELECT $2, checkpoint_ns, checkpoint_id, parent_checkpoint_id, type, checkpoint,
+          jsonb_set(coalesce(metadata, '{}'::jsonb), '{thread_id}', to_jsonb($2::text), true)
+        FROM checkpoints WHERE thread_id=$1`,
+        [sourceThreadId, targetThreadId]
+      );
+      await client.query(
+        `INSERT INTO checkpoint_blobs (thread_id, checkpoint_ns, channel, version, type, blob)
+        SELECT $2, checkpoint_ns, channel, version, type, blob
+        FROM checkpoint_blobs WHERE thread_id=$1`,
+        [sourceThreadId, targetThreadId]
+      );
+      await client.query(
+        `INSERT INTO checkpoint_writes (
+          thread_id, checkpoint_ns, checkpoint_id, task_id, idx, channel, type, blob
+        )
+        SELECT $2, checkpoint_ns, checkpoint_id, task_id, idx, channel, type, blob
+        FROM checkpoint_writes WHERE thread_id=$1`,
+        [sourceThreadId, targetThreadId]
+      );
+      await client.query("COMMIT");
+    } catch (error) {
+      await rollbackQuietly(client);
+      if (isUniqueViolation3(error)) {
+        throw new CheckpointTargetNotEmptyError(targetThreadId);
+      }
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  /**
+   * Retain only the latest N checkpoints per checkpoint namespace.
+   *
+   * @param threadId - Thread whose checkpoint history is pruned.
+   * @param options - Retention options.
+   * @param options.keepLatest - Number of latest checkpoints to retain per namespace.
+   * @returns Counts of deleted checkpoint, blob, and write rows.
+   */
+  async pruneThread(threadId, options) {
+    if (!Number.isSafeInteger(options.keepLatest) || options.keepLatest < 1) {
+      throw new RangeError("keepLatest must be an integer >= 1");
+    }
+    const keepLatest = options.keepLatest;
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      const retainedResult = await client.query(
+        `SELECT checkpoint_ns, checkpoint_id, checkpoint FROM (
+          SELECT checkpoint_ns, checkpoint_id, checkpoint,
+            row_number() OVER (
+              PARTITION BY checkpoint_ns ORDER BY checkpoint_id DESC
+            ) AS rn
+          FROM checkpoints WHERE thread_id=$1
+        ) t WHERE rn <= $2`,
+        [threadId, keepLatest]
+      );
+      const retained = retainedResult.rows;
+      const retainedCheckpoints = new Set(
+        retained.map((row) => checkpointKey(row.checkpoint_ns, row.checkpoint_id))
+      );
+      const fallbackNamespaces = /* @__PURE__ */ new Set();
+      const retainedBlobs = /* @__PURE__ */ new Set();
+      for (const row of retained) {
+        const versions = channelVersions(row.checkpoint);
+        if (!versions) {
+          fallbackNamespaces.add(row.checkpoint_ns);
+          continue;
+        }
+        for (const [channel, version] of Object.entries(versions)) {
+          retainedBlobs.add(blobKey(row.checkpoint_ns, channel, String(version)));
+        }
+      }
+      const writeRows = await client.query(
+        `SELECT checkpoint_ns, checkpoint_id, task_id, idx
+         FROM checkpoint_writes WHERE thread_id=$1`,
+        [threadId]
+      );
+      const staleWrites = writeRows.rows.filter(
+        (row) => !retainedCheckpoints.has(checkpointKey(row.checkpoint_ns, row.checkpoint_id))
+      );
+      let writes = 0;
+      for (const batch of chunk(staleWrites, DELETE_CHUNK_SIZE)) {
+        const params = [threadId];
+        const tuples = batch.map((row) => {
+          params.push(row.checkpoint_ns, row.checkpoint_id, row.task_id, row.idx);
+          return `($${params.length - 3}, $${params.length - 2}, $${params.length - 1}, $${params.length})`;
+        });
+        const deleted = await client.query(
+          `DELETE FROM checkpoint_writes
+           WHERE thread_id=$1
+             AND (checkpoint_ns, checkpoint_id, task_id, idx) IN (${tuples.join(", ")})`,
+          params
+        );
+        writes += deleted.rowCount ?? 0;
+      }
+      const checkpointRows = await client.query(
+        `SELECT checkpoint_ns, checkpoint_id FROM checkpoints WHERE thread_id=$1`,
+        [threadId]
+      );
+      const staleCheckpoints = checkpointRows.rows.filter(
+        (row) => !retainedCheckpoints.has(checkpointKey(row.checkpoint_ns, row.checkpoint_id))
+      );
+      let checkpoints = 0;
+      for (const batch of chunk(staleCheckpoints, DELETE_CHUNK_SIZE)) {
+        const params = [threadId];
+        const tuples = batch.map((row) => {
+          params.push(row.checkpoint_ns, row.checkpoint_id);
+          return `($${params.length - 1}, $${params.length})`;
+        });
+        const deleted = await client.query(
+          `DELETE FROM checkpoints
+           WHERE thread_id=$1
+             AND (checkpoint_ns, checkpoint_id) IN (${tuples.join(", ")})`,
+          params
+        );
+        checkpoints += deleted.rowCount ?? 0;
+      }
+      const blobRows = await client.query(
+        `SELECT checkpoint_ns, channel, version FROM checkpoint_blobs WHERE thread_id=$1`,
+        [threadId]
+      );
+      const staleBlobs = blobRows.rows.filter(
+        (row) => !fallbackNamespaces.has(row.checkpoint_ns) && !retainedBlobs.has(blobKey(row.checkpoint_ns, row.channel, row.version))
+      );
+      let blobs = 0;
+      for (const batch of chunk(staleBlobs, DELETE_CHUNK_SIZE)) {
+        const params = [threadId];
+        const tuples = batch.map((row) => {
+          params.push(row.checkpoint_ns, row.channel, row.version);
+          return `($${params.length - 2}, $${params.length - 1}, $${params.length})`;
+        });
+        const deleted = await client.query(
+          `DELETE FROM checkpoint_blobs
+           WHERE thread_id=$1
+             AND (checkpoint_ns, channel, version) IN (${tuples.join(", ")})`,
+          params
+        );
+        blobs += deleted.rowCount ?? 0;
+      }
+      await client.query("COMMIT");
+      return { checkpoints, blobs, writes };
+    } catch (error) {
+      await rollbackQuietly(client);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  /**
+   * Delete the checkpoints that descend from a base checkpoint.
+   *
+   * Descendants are discovered by following both same-namespace
+   * `parent_checkpoint_id` edges and cross-namespace `metadata.parents` edges
+   * (LangGraph's `{ "<parent checkpoint_ns>": "<parent checkpoint id>" }` map on
+   * subgraph checkpoints), recursively across every namespace. Out-of-order or
+   * clock-skewed ids do not affect the result. Writes keyed to the base
+   * checkpoint belong to the rolled-back run's first superstep and are deleted
+   * too. Blobs referenced only by deleted checkpoints are removed.
+   *
+   * @param threadId - Thread whose later checkpoint history is deleted.
+   * @param baseCheckpointId - Checkpoint to retain as the new tip, or `null` to
+   * delete every checkpoint for the thread.
+   * @returns Resolves when the deletion commits; no descendants is a no-op.
+   * @throws {RangeError} When `baseCheckpointId` is an empty string.
+   * @throws {CheckpointBaseNotFoundError} When the base checkpoint does not
+   * exist on the thread.
+   */
+  async deleteAfter(threadId, baseCheckpointId) {
+    if (baseCheckpointId !== null && baseCheckpointId.length === 0) {
+      throw new RangeError("baseCheckpointId must be null or a non-empty checkpoint id");
+    }
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      if (baseCheckpointId === null) {
+        await client.query("DELETE FROM checkpoint_writes WHERE thread_id=$1", [threadId]);
+        await client.query("DELETE FROM checkpoint_blobs WHERE thread_id=$1", [threadId]);
+        await client.query("DELETE FROM checkpoints WHERE thread_id=$1", [threadId]);
+        await client.query("COMMIT");
+        return;
+      }
+      const base = await client.query(
+        `SELECT checkpoint_ns
+         FROM checkpoints
+         WHERE thread_id=$1 AND checkpoint_id=$2`,
+        [threadId, baseCheckpointId]
+      );
+      if (base.rows.length === 0) {
+        throw new CheckpointBaseNotFoundError(threadId, baseCheckpointId);
+      }
+      const baseCheckpointNs = base.rows[0].checkpoint_ns;
+      const descendantResult = await client.query(
+        `WITH RECURSIVE lineage(checkpoint_ns, checkpoint_id) AS (
+           SELECT $2::text, $3::text
+           UNION
+           SELECT c.checkpoint_ns, c.checkpoint_id
+           FROM checkpoints c
+           JOIN lineage l ON (
+             (c.checkpoint_ns = l.checkpoint_ns
+               AND c.parent_checkpoint_id = l.checkpoint_id)
+             OR (c.metadata->'parents'->>l.checkpoint_ns = l.checkpoint_id)
+           )
+           WHERE c.thread_id=$1
+         ),
+         roots AS (
+           SELECT $2::text AS checkpoint_ns, $3::text AS checkpoint_id
+         )
+         SELECT l.checkpoint_ns, l.checkpoint_id
+         FROM lineage l
+         WHERE NOT EXISTS (
+           SELECT 1 FROM roots r
+           WHERE r.checkpoint_ns = l.checkpoint_ns
+             AND r.checkpoint_id = l.checkpoint_id
+         )`,
+        [threadId, baseCheckpointNs, baseCheckpointId]
+      );
+      const descendants = descendantResult.rows;
+      await client.query(
+        `DELETE FROM checkpoint_writes
+         WHERE thread_id=$1 AND checkpoint_ns=$2 AND checkpoint_id=$3`,
+        [threadId, baseCheckpointNs, baseCheckpointId]
+      );
+      for (const batch of chunk(descendants, DELETE_CHUNK_SIZE)) {
+        const params = [threadId];
+        const tuples = batch.map((row) => {
+          params.push(row.checkpoint_ns, row.checkpoint_id);
+          return `($${params.length - 1}, $${params.length})`;
+        });
+        await client.query(
+          `DELETE FROM checkpoint_writes
+           WHERE thread_id=$1
+             AND (checkpoint_ns, checkpoint_id) IN (${tuples.join(", ")})`,
+          params
+        );
+        await client.query(
+          `DELETE FROM checkpoints
+           WHERE thread_id=$1
+             AND (checkpoint_ns, checkpoint_id) IN (${tuples.join(", ")})`,
+          params
+        );
+      }
+      const retainedResult = await client.query(
+        `SELECT checkpoint_ns, checkpoint_id, checkpoint
+         FROM checkpoints WHERE thread_id=$1`,
+        [threadId]
+      );
+      const fallbackNamespaces = /* @__PURE__ */ new Set();
+      const retainedBlobs = /* @__PURE__ */ new Set();
+      for (const row of retainedResult.rows) {
+        const versions = channelVersions(row.checkpoint);
+        if (!versions) {
+          fallbackNamespaces.add(row.checkpoint_ns);
+          continue;
+        }
+        for (const [channel, version] of Object.entries(versions)) {
+          retainedBlobs.add(blobKey(row.checkpoint_ns, channel, String(version)));
+        }
+      }
+      const blobRows = await client.query(
+        `SELECT checkpoint_ns, channel, version FROM checkpoint_blobs WHERE thread_id=$1`,
+        [threadId]
+      );
+      const staleBlobs = blobRows.rows.filter(
+        (row) => !fallbackNamespaces.has(row.checkpoint_ns) && !retainedBlobs.has(blobKey(row.checkpoint_ns, row.channel, row.version))
+      );
+      for (const batch of chunk(staleBlobs, DELETE_CHUNK_SIZE)) {
+        const params = [threadId];
+        const tuples = batch.map((row) => {
+          params.push(row.checkpoint_ns, row.channel, row.version);
+          return `($${params.length - 2}, $${params.length - 1}, $${params.length})`;
+        });
+        await client.query(
+          `DELETE FROM checkpoint_blobs
+           WHERE thread_id=$1
+             AND (checkpoint_ns, channel, version) IN (${tuples.join(", ")})`,
+          params
+        );
+      }
+      await client.query("COMMIT");
+    } catch (error) {
+      await rollbackQuietly(client);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  /**
+   * Delete every checkpoint row for a thread.
+   *
+   * @param threadId - Thread whose checkpoint rows are deleted.
+   * @returns Resolves when the deletion commits.
+   */
+  async deleteThread(threadId) {
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      await client.query("DELETE FROM checkpoint_writes WHERE thread_id=$1", [threadId]);
+      await client.query("DELETE FROM checkpoint_blobs WHERE thread_id=$1", [threadId]);
+      await client.query("DELETE FROM checkpoints WHERE thread_id=$1", [threadId]);
+      await client.query("COMMIT");
+    } catch (error) {
+      await rollbackQuietly(client);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+};
+
+// src/stores/PostgreSQLStore.ts
+import {
+  assertStoreIdentity,
+  assertStoreNamespacePrefix,
+  storeExpiresAt,
+  storePaginationValue
+} from "@axiom-lattice/protocols";
+function mapRow10(row) {
+  return {
+    namespace: row.namespace,
+    key: row.key,
+    value: row.value ?? {},
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    expiresAt: row.expires_at ?? void 0
+  };
+}
+var PostgreSQLStore = class {
+  /**
+   * @param pool - Pool shared with the rest of the store config.
+   */
+  constructor(pool) {
+    this.pool = pool;
+  }
+  async put(tenantId, input) {
+    assertStoreIdentity(input.namespace, input.key);
+    const now = /* @__PURE__ */ new Date();
+    const expiresAt = storeExpiresAt(input.ttlMinutes, now) ?? null;
+    const result = await this.pool.query(
+      `INSERT INTO lattice_store_items
+        (tenant_id, namespace, key, value, created_at, updated_at, expires_at)
+       VALUES ($1, $2, $3, $4::jsonb, $5, $5, $6)
+       ON CONFLICT (tenant_id, namespace, key) DO UPDATE SET
+         value = EXCLUDED.value,
+         updated_at = EXCLUDED.updated_at,
+         expires_at = EXCLUDED.expires_at
+       RETURNING tenant_id, namespace, key, value, created_at, updated_at, expires_at`,
+      [tenantId, input.namespace, input.key, JSON.stringify(input.value), now, expiresAt]
+    );
+    return mapRow10(result.rows[0]);
+  }
+  async get(tenantId, namespace, key) {
+    assertStoreIdentity(namespace, key);
+    const result = await this.pool.query(
+      `SELECT tenant_id, namespace, key, value, created_at, updated_at, expires_at
+       FROM lattice_store_items
+       WHERE tenant_id = $1 AND namespace = $2 AND key = $3
+         AND (expires_at IS NULL OR expires_at > $4)`,
+      [tenantId, namespace, key, /* @__PURE__ */ new Date()]
+    );
+    return result.rows[0] ? mapRow10(result.rows[0]) : null;
+  }
+  async delete(tenantId, namespace, key) {
+    assertStoreIdentity(namespace, key);
+    const result = await this.pool.query(
+      `DELETE FROM lattice_store_items
+       WHERE tenant_id = $1 AND namespace = $2 AND key = $3`,
+      [tenantId, namespace, key]
+    );
+    return (result.rowCount ?? 0) > 0;
+  }
+  async search(tenantId, input) {
+    const conditions = [
+      "tenant_id = $1",
+      "(expires_at IS NULL OR expires_at > $2)"
+    ];
+    const params = [tenantId, /* @__PURE__ */ new Date()];
+    if (input.namespacePrefix) {
+      assertStoreNamespacePrefix(input.namespacePrefix);
+    }
+    if (input.namespacePrefix && input.namespacePrefix.length > 0) {
+      params.push(input.namespacePrefix);
+      conditions.push(`namespace[1:array_length($${params.length}::text[], 1)] = $${params.length}`);
+    }
+    if (input.filter !== void 0) {
+      params.push(JSON.stringify(input.filter));
+      conditions.push(`value @> $${params.length}::jsonb`);
+    }
+    if (input.query !== void 0 && input.query !== "") {
+      params.push(input.query.replace(/[\\%_]/g, "\\$&"));
+      conditions.push(`value::text ILIKE '%' || $${params.length} || '%' ESCAPE '\\'`);
+    }
+    params.push(storePaginationValue(input.limit, 10));
+    const limitParam = params.length;
+    params.push(storePaginationValue(input.offset, 0));
+    const offsetParam = params.length;
+    const result = await this.pool.query(
+      `SELECT tenant_id, namespace, key, value, created_at, updated_at, expires_at
+       FROM lattice_store_items
+       WHERE ${conditions.join(" AND ")}
+       ORDER BY updated_at DESC, namespace, key
+       LIMIT $${limitParam} OFFSET $${offsetParam}`,
+      params
+    );
+    return result.rows.map(mapRow10);
+  }
+  async listNamespaces(tenantId, prefix = [], limit = 100) {
+    assertStoreNamespacePrefix(prefix);
+    const conditions = [
+      "tenant_id = $1",
+      "(expires_at IS NULL OR expires_at > $2)"
+    ];
+    const params = [tenantId, /* @__PURE__ */ new Date()];
+    if (prefix.length > 0) {
+      params.push(prefix);
+      conditions.push(`namespace[1:array_length($${params.length}::text[], 1)] = $${params.length}`);
+    }
+    params.push(storePaginationValue(limit, 100));
+    const result = await this.pool.query(
+      `SELECT DISTINCT namespace
+       FROM lattice_store_items
+       WHERE ${conditions.join(" AND ")}
+       ORDER BY namespace
+       LIMIT $${params.length}`,
+      params
+    );
+    return result.rows.map((row) => row.namespace);
+  }
+  async deleteExpired(now, limit) {
+    const bounded = storePaginationValue(limit, 0);
+    const result = await this.pool.query(
+      `WITH expired AS (
+         SELECT ctid FROM lattice_store_items
+         WHERE expires_at IS NOT NULL AND expires_at <= $1
+         ORDER BY expires_at
+         LIMIT $2
+       )
+       DELETE FROM lattice_store_items WHERE ctid IN (SELECT ctid FROM expired)`,
+      [now, bounded]
+    );
+    return result.rowCount ?? 0;
+  }
+};
+
+// src/migrations/store_migrations.ts
+var createStoreItemsTable = {
+  version: 195,
+  name: "create_lattice_store_items_table",
+  up: async (client) => {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS lattice_store_items (
+        tenant_id TEXT NOT NULL,
+        namespace TEXT[] NOT NULL,
+        key TEXT NOT NULL,
+        value JSONB NOT NULL,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        expires_at TIMESTAMPTZ,
+        PRIMARY KEY (tenant_id, namespace, key)
+      )
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_store_items_namespace
+      ON lattice_store_items USING GIN (namespace)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_store_items_value
+      ON lattice_store_items USING GIN (value)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_store_items_expires_at
+      ON lattice_store_items(expires_at)
+      WHERE expires_at IS NOT NULL
+    `);
+  },
+  down: async (client) => {
+    await client.query("DROP INDEX IF EXISTS idx_lattice_store_items_expires_at");
+    await client.query("DROP INDEX IF EXISTS idx_lattice_store_items_value");
+    await client.query("DROP INDEX IF EXISTS idx_lattice_store_items_namespace");
+    await client.query("DROP TABLE IF EXISTS lattice_store_items");
+  }
+};
+
+// src/createPgStoreConfig.ts
+async function createPgStoreConfig(connectionString) {
+  const pool = new Pool32({ connectionString });
+  const mm = new MigrationManager(pool);
+  mm.register(createThreadsTable);
+  mm.register(createScheduledTasksTable);
+  mm.register(createAssistantsTable);
+  mm.register(createSkillsTable);
+  mm.register(createWorkspacesTable);
+  mm.register(createProjectsTable);
+  mm.register(createUsersTable);
+  mm.register(createTenantsTable);
+  mm.register(addUserStatusColumn);
+  mm.register(createUserTenantLinkTable);
+  mm.register(migrateRemoveTenantIdFromUsers);
+  mm.register(createMetricsConfigsTable);
+  mm.register(createMcpServerConfigsTable);
+  mm.register(addAssistantTenantId);
+  mm.register(addSkillTenantId);
+  mm.register(changeSkillPrimaryKey);
+  mm.register(addScheduleTenantId);
+  mm.register(changeThreadPrimaryKey);
+  mm.register(createChannelIdentityMappingTables);
+  mm.register(createChannelInstallationsTable);
+  mm.register(addThreadTenantId);
+  mm.register(addProjectConfigColumn);
+  registerThreadMessageQueueMigrations(mm);
+  mm.register(createWorkflowTrackingTables);
+  for (const m of evalMigrations) {
+    mm.register(m);
+  }
+  mm.register(alterChannelInstallationsTable);
+  mm.register(createChannelBindingsTable);
+  mm.register(createDatabaseConfigsTable);
+  mm.register(changeAssistantPrimaryKey);
+  mm.register(addStepThreadId);
+  mm.register(createA2AApiKeysTable);
+  mm.register(addAssistantOwnerUserId);
+  for (const m of taskMigrations) {
+    mm.register(m);
+  }
+  mm.register(createMenuItemsTable);
+  mm.register(createSharedResourcesTable);
+  mm.register(addFileContentType);
+  mm.register(addMcpAppContentType);
+  mm.register(createCollectionsTable);
+  mm.register(createTaskWorkItemsMigration);
+  mm.register(addWorkItemProjectFieldsMigration);
+  mm.register(createConnectionConfigsTable);
+  mm.register(addWorkflowRunsTenantStatusUpdatedIndex);
+  mm.register(addProjectKindColumn);
+  mm.register(addA2AKeyAssistantIds);
+  mm.register(addApiKeyGrants);
+  mm.register(createOpenAuditTable);
+  mm.register(addShareOpenGrants);
+  mm.register(addTaskWorkItemEventKeyMigration);
+  mm.register(createAgentWebAppsTable);
+  mm.register(createCapabilityBundlesTable);
   mm.register(addTaskWorkItemPendingIndexesMigration);
   mm.register(createProjectRoomTables);
   mm.register(addProjectLifecycleEventIndex);
@@ -12309,6 +14495,18 @@ async function createPgStoreConfig(connectionString) {
   mm.register(addModelProviderModelExtra);
   mm.register(addModelProviderModelDefault);
   mm.register(addModelProviderModelKind);
+  mm.register(createAgentRunLedgerTable);
+  mm.register(createAgentRunTaskQueueMigration);
+  mm.register(createAgentRunCapabilityRevisionMigration);
+  mm.register(createAgentRunBaseCheckpointCapturedMigration);
+  mm.register(createAgentRunRollbackFailureMigration);
+  mm.register(agentRunRunningIndexSourceMigration);
+  mm.register(addThreadExpiresAt);
+  mm.register(createStoreItemsTable);
+  mm.register(createChannelReplyJobsTable);
+  mm.register(createAgentRunRetentionMigration);
+  mm.register(createAgentRunProjectTaskMigration);
+  mm.register(agentRunProjectTaskRunningIndexMigration);
   await mm.migrate();
   const checkpoint = PostgresSaver.fromConnString(connectionString);
   checkpoint.setup().catch((err) => {
@@ -12353,13 +14551,17 @@ async function createPgStoreConfig(connectionString) {
     lease: new PostgreSQLLeaseStore(opts),
     outbox: new PostgreSQLOutboxStore(opts),
     pluginDeployment: new PostgreSQLPluginDeploymentStore(opts),
+    agentRun: new PostgreSQLAgentRunLedger(opts),
+    channelReplyJob: new PostgreSQLChannelReplyJobStore(opts),
     vectorStoreProvider: new PGVectorStoreProvider(pool, connectionString),
-    checkpoint
+    checkpoint,
+    checkpointStorage: new PostgreSQLCheckpointStorage(pool),
+    store: new PostgreSQLStore(pool)
   };
 }
 
 // src/stores/PostgreSQLSkillStore.ts
-import { Pool as Pool31 } from "pg";
+import { Pool as Pool33 } from "pg";
 var PostgreSQLSkillStore = class {
   constructor(options) {
     this.initialized = false;
@@ -12372,9 +14574,9 @@ var PostgreSQLSkillStore = class {
       return;
     }
     if (typeof options.poolConfig === "string") {
-      this.pool = new Pool31({ connectionString: options.poolConfig });
+      this.pool = new Pool33({ connectionString: options.poolConfig });
     } else if (options.poolConfig) {
-      this.pool = new Pool31(options.poolConfig);
+      this.pool = new Pool33(options.poolConfig);
     } else {
       throw new Error("Either pool or poolConfig must be provided");
     }
@@ -12675,7 +14877,7 @@ var PostgreSQLSkillStore = class {
 };
 
 // src/stores/ChannelIdentityMappingStore.ts
-import { Pool as Pool32 } from "pg";
+import { Pool as Pool34 } from "pg";
 var ChannelIdentityMappingStore = class {
   constructor(options) {
     this.initialized = false;
@@ -12687,7 +14889,7 @@ var ChannelIdentityMappingStore = class {
       this.initialized = true;
       return;
     }
-    this.pool = typeof options.poolConfig === "string" ? new Pool32({ connectionString: options.poolConfig }) : options.poolConfig ? new Pool32(options.poolConfig) : (() => {
+    this.pool = typeof options.poolConfig === "string" ? new Pool34({ connectionString: options.poolConfig }) : options.poolConfig ? new Pool34(options.poolConfig) : (() => {
       throw new Error("Either pool or poolConfig must be provided");
     })();
     this.migrationManager = new MigrationManager(this.pool);
@@ -12908,17 +15110,22 @@ function mapRowToChannelIdentityMapping(row) {
 export {
   ChannelBindingStore,
   ChannelIdentityMappingStore,
+  CheckpointBaseNotFoundError,
+  CheckpointTargetNotEmptyError,
   DuplicateProjectMembershipError,
   DuplicateProjectRoomMessageIdempotencyKeyError,
   MenuStore,
   MigrationManager,
   PGVectorStoreProvider,
-  Pool33 as Pool,
+  Pool35 as Pool,
   PostgreSQLA2AApiKeyStore,
+  PostgreSQLAgentRunLedger,
   PostgreSQLAgentWebAppStore,
   PostgreSQLAssistantStore,
   PostgreSQLCapabilityBundleStore,
   PostgreSQLChannelInstallationStore,
+  PostgreSQLChannelReplyJobStore,
+  PostgreSQLCheckpointStorage,
   PostgreSQLCollectionStore,
   PostgreSQLConnectionStore,
   PostgreSQLDatabaseConfigStore,
@@ -12936,6 +15143,7 @@ export {
   PostgreSQLProjectStore,
   PostgreSQLScheduleStorage,
   PostgreSQLSkillStore,
+  PostgreSQLStore,
   PostgreSQLTaskWorkItemStore,
   PostgreSQLTenantStore,
   PostgreSQLThreadStore,
@@ -12960,6 +15168,7 @@ export {
   addSkillTenantId,
   addStepThreadId,
   addTaskIdToEvalRuns,
+  addThreadExpiresAt,
   addThreadTenantId,
   addWorkflowRunsTenantStatusUpdatedIndex,
   alterChannelInstallationsTable,
@@ -12967,12 +15176,14 @@ export {
   changeSkillPrimaryKey,
   changeThreadPrimaryKey,
   createA2AApiKeysTable,
+  createAgentRunLedgerTable,
   createAgentWebAppsTable,
   createAssistantsTable,
   createCapabilityBundlesTable,
   createChannelBindingsTable,
   createChannelIdentityMappingTables,
   createChannelInstallationsTable,
+  createChannelReplyJobsTable,
   createCollectionsTable,
   createDatabaseConfigsTable,
   createEvalCasesTable,
@@ -12992,6 +15203,7 @@ export {
   createScheduledTasksTable,
   createSharedResourcesTable,
   createSkillsTable,
+  createStoreItemsTable,
   createTenantsTable,
   createThreadMessageQueueTable,
   createThreadsTable,