@axiom-lattice/pg-stores 2.0.4 → 2.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiom-lattice/pg-stores",
-  "version": "2.0.4",
+  "version": "2.0.6",
   "description": "PG stores implementation for Axiom Lattice framework",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -25,7 +25,7 @@
     "@langchain/core": "1.1.30",
     "pg": "^8.16.3",
     "uuid": "^9.0.1",
-    "@axiom-lattice/core": "3.0.4",
+    "@axiom-lattice/core": "3.0.6",
     "@axiom-lattice/protocols": "3.0.2"
   },
   "devDependencies": {
@@ -33,6 +33,9 @@
     "@types/node": "^20.11.24",
     "@types/pg": "^8.11.10",
     "@types/uuid": "^9.0.8",
+    "@typescript-eslint/eslint-plugin": "^7.2.0",
+    "@typescript-eslint/parser": "^7.2.0",
+    "eslint": "^8.57.0",
     "jest": "^29.7.0",
     "rimraf": "^5.0.5",
     "ts-jest": "^29.4.0",

package/src/__tests__/PostgreSQLEvalStore.test.ts

@@ -0,0 +1,60 @@
+/**
+ * PostgreSQLEvalStore tests — regression lock for HITL interruptPolicy
+ * round-trip. A case's interruptPolicy must survive store writes AND reads;
+ * the SELECT queries must include the interrupt_policy column.
+ */
+
+import { PostgreSQLEvalStore } from "../stores/PostgreSQLEvalStore";
+
+const mockQuery = jest.fn();
+
+const mockPool = {
+  query: mockQuery,
+  connect: jest.fn().mockResolvedValue({ query: mockQuery, release: jest.fn() }),
+  end: jest.fn(),
+};
+
+describe("PostgreSQLEvalStore interruptPolicy round-trip", () => {
+  let store: PostgreSQLEvalStore;
+
+  const caseRow = {
+    id: "case-1",
+    tenant_id: "t1",
+    suite_id: "s1",
+    input_message: "approve the payment",
+    input_files: "{}",
+    steps: JSON.stringify([{ agent_id: "executor-1" }]),
+    output_type: "message_content",
+    content_assertion: "payment executed",
+    rubrics: "[]",
+    interrupt_policy: JSON.stringify({ mode: "auto-approve" }),
+    created_at: new Date(),
+    updated_at: new Date(),
+  };
+
+  beforeEach(() => {
+    // External pool → constructor sets initialized=true, no migrations run.
+    store = new PostgreSQLEvalStore({ pool: mockPool as never });
+    jest.clearAllMocks();
+  });
+
+  it("getCasesBySuite SELECT includes the interrupt_policy column", async () => {
+    mockQuery.mockResolvedValueOnce({ rows: [] });
+    await store.getCasesBySuite("t1", "s1");
+    const sql = mockQuery.mock.calls[0][0] as string;
+    expect(sql).toContain("interrupt_policy");
+  });
+
+  it("parses interruptPolicy from a case row", async () => {
+    mockQuery.mockResolvedValueOnce({ rows: [caseRow] });
+    const cases = await store.getCasesBySuite("t1", "s1");
+    expect(cases[0].interruptPolicy).toEqual({ mode: "auto-approve" });
+  });
+
+  it("getCaseById SELECT includes the interrupt_policy column", async () => {
+    mockQuery.mockResolvedValueOnce({ rows: [] });
+    await store.getCaseById("t1", "case-1");
+    const sql = mockQuery.mock.calls[0][0] as string;
+    expect(sql).toContain("interrupt_policy");
+  });
+});

package/src/__tests__/eval-migrations.test.ts

@@ -0,0 +1,48 @@
+/**
+ * Eval migration tests
+ *
+ * Verifies the unique-project-name migration executes the deduplication
+ * and constraint SQL in order.
+ */
+
+import { describe, expect, it, jest } from "@jest/globals";
+import { enforceUniqueEvalProjectName } from "../migrations/eval_migrations";
+
+describe("enforceUniqueEvalProjectName migration", () => {
+  it("repoints children, deduplicates, then adds the unique constraint", async () => {
+    const queries: string[] = [];
+    const client = {
+      query: jest.fn(async (sql: string) => {
+        queries.push(sql.replace(/\s+/g, " ").trim());
+      }),
+    } as any;
+
+    await enforceUniqueEvalProjectName.up(client);
+
+    expect(queries).toHaveLength(4);
+    // 1. suites repointed to the kept project (history preserved)
+    expect(queries[0]).toContain("UPDATE lattice_eval_suites");
+    expect(queries[0]).toContain("ORDER BY p2.created_at DESC, p2.id DESC");
+    // 2. runs repointed
+    expect(queries[1]).toContain("UPDATE lattice_eval_runs");
+    // 3. duplicate projects deleted
+    expect(queries[2]).toContain("DELETE FROM lattice_eval_projects");
+    expect(queries[2]).toContain("p.created_at < p2.created_at");
+    // 4. unique constraint added
+    expect(queries[3]).toContain("ADD CONSTRAINT lattice_eval_projects_tenant_name_unique UNIQUE (tenant_id, name)");
+  });
+
+  it("drops the constraint on down", async () => {
+    const queries: string[] = [];
+    const client = {
+      query: jest.fn(async (sql: string) => {
+        queries.push(sql.replace(/\s+/g, " ").trim());
+      }),
+    } as any;
+
+    await enforceUniqueEvalProjectName.down(client);
+
+    expect(queries).toHaveLength(1);
+    expect(queries[0]).toContain("DROP CONSTRAINT IF EXISTS lattice_eval_projects_tenant_name_unique");
+  });
+});

package/src/migrations/eval_migrations.ts

@@ -248,6 +248,117 @@ export const addEnvToEvalRuns: Migration = {
   },
 };
 
+/** Add HITL interrupt tracking: interrupted flag on run results + interrupted count on runs */
+export const addInterruptColumnsToEval: Migration = {
+  version: 111,
+  name: "add_interrupt_columns_to_eval",
+  up: async (client: PoolClient) => {
+    await client.query(`
+      ALTER TABLE lattice_eval_run_results
+        ADD COLUMN IF NOT EXISTS interrupted BOOLEAN NOT NULL DEFAULT FALSE
+    `);
+    await client.query(`
+      ALTER TABLE lattice_eval_runs
+        ADD COLUMN IF NOT EXISTS interrupted_cases INTEGER NOT NULL DEFAULT 0
+    `);
+  },
+  down: async (client: PoolClient) => {
+    await client.query(`
+      ALTER TABLE lattice_eval_run_results DROP COLUMN IF EXISTS interrupted
+    `);
+    await client.query(`
+      ALTER TABLE lattice_eval_runs DROP COLUMN IF EXISTS interrupted_cases
+    `);
+  },
+};
+
+/** Add HITL auto-resolve policy to eval cases */
+export const addInterruptPolicyToEvalCases: Migration = {
+  version: 112,
+  name: "add_interrupt_policy_to_eval_cases",
+  up: async (client: PoolClient) => {
+    await client.query(`
+      ALTER TABLE lattice_eval_cases
+        ADD COLUMN IF NOT EXISTS interrupt_policy JSONB
+    `);
+  },
+  down: async (client: PoolClient) => {
+    await client.query(`
+      ALTER TABLE lattice_eval_cases DROP COLUMN IF EXISTS interrupt_policy
+    `);
+  },
+};
+
+/** Enforce unique eval project name per tenant (eval-{agent-id} convention) */
+export const enforceUniqueEvalProjectName: Migration = {
+  version: 163,
+  name: "enforce_unique_eval_project_name",
+  up: async (client: PoolClient) => {
+    // Keep the newest project (max created_at, tie-break max id) per
+    // (tenant_id, name). Repoint child rows (suites, runs) of duplicate
+    // projects onto the kept project BEFORE deleting, so no eval history
+    // is lost. Cases follow their suite; run results follow their run.
+    await client.query(`
+      UPDATE lattice_eval_suites s
+      SET project_id = (
+        SELECT p2.id FROM lattice_eval_projects p2
+        WHERE p2.tenant_id = p.tenant_id AND p2.name = p.name
+        ORDER BY p2.created_at DESC, p2.id DESC
+        LIMIT 1
+      )
+      FROM lattice_eval_projects p
+      WHERE s.project_id = p.id
+        AND s.project_id <> (
+          SELECT p2.id FROM lattice_eval_projects p2
+          WHERE p2.tenant_id = p.tenant_id AND p2.name = p.name
+          ORDER BY p2.created_at DESC, p2.id DESC
+          LIMIT 1
+        )
+    `);
+
+    await client.query(`
+      UPDATE lattice_eval_runs r
+      SET project_id = (
+        SELECT p2.id FROM lattice_eval_projects p2
+        WHERE p2.tenant_id = p.tenant_id AND p2.name = p.name
+        ORDER BY p2.created_at DESC, p2.id DESC
+        LIMIT 1
+      )
+      FROM lattice_eval_projects p
+      WHERE r.project_id = p.id
+        AND r.project_id <> (
+          SELECT p2.id FROM lattice_eval_projects p2
+          WHERE p2.tenant_id = p.tenant_id AND p2.name = p.name
+          ORDER BY p2.created_at DESC, p2.id DESC
+          LIMIT 1
+        )
+    `);
+
+    // Children are repointed; safe to delete the duplicate projects now.
+    await client.query(`
+      DELETE FROM lattice_eval_projects p
+      USING lattice_eval_projects p2
+      WHERE p.tenant_id = p2.tenant_id
+        AND p.name = p2.name
+        AND (
+          p.created_at < p2.created_at
+          OR (p.created_at = p2.created_at AND p.id < p2.id)
+        )
+    `);
+
+    await client.query(`
+      ALTER TABLE lattice_eval_projects
+        ADD CONSTRAINT lattice_eval_projects_tenant_name_unique UNIQUE (tenant_id, name)
+    `);
+  },
+  down: async (client: PoolClient) => {
+    await client.query(`
+      ALTER TABLE lattice_eval_projects
+        DROP CONSTRAINT IF EXISTS lattice_eval_projects_tenant_name_unique
+    `);
+  },
+};
+
 /** All eval migrations in version order */
 export const evalMigrations: Migration[] = [
   createEvalProjectsTable,
@@ -257,4 +368,7 @@ export const evalMigrations: Migration[] = [
   createEvalRunResultsTable,
   addHoldoutToEvalRuns,
   addEnvToEvalRuns,
+  addInterruptColumnsToEval,
+  addInterruptPolicyToEvalCases,
+  enforceUniqueEvalProjectName,
 ];

package/src/stores/PostgreSQLEvalStore.ts

@@ -16,6 +16,7 @@ import {
   CreateEvalRunRequest,
   EvalRunResult,
   EvalProjectReport,
+  InterruptPolicy,
 } from "@axiom-lattice/protocols";
 import { MigrationManager } from "../migrations/migration";
 import { evalMigrations } from "../migrations/eval_migrations";
@@ -160,6 +161,7 @@ export class PostgreSQLEvalStore implements EvalStore {
       outputType: (row.output_type as EvalCase["outputType"]) || "message_content",
       contentAssertion: (row.content_assertion as string) || "",
       rubrics: this.parseOptionalJson<Array<{ name: string; weight: number; description: string }>>(row.rubrics),
+      interruptPolicy: this.parseOptionalJson<InterruptPolicy>(row.interrupt_policy),
       createdAt: new Date(row.created_at as string),
       updatedAt: new Date(row.updated_at as string),
     };
@@ -175,6 +177,7 @@ export class PostgreSQLEvalStore implements EvalStore {
       totalCases: (row.total_cases as number) ?? 0,
       passedCases: (row.passed_cases as number) ?? 0,
       failedCases: (row.failed_cases as number) ?? 0,
+      interruptedCases: (row.interrupted_cases as number) ?? 0,
       avgScore: (row.avg_score as number) ?? 0,
       error: row.error as string | undefined,
       holdout: row.holdout as boolean | undefined,
@@ -200,6 +203,7 @@ export class PostgreSQLEvalStore implements EvalStore {
       messages: this.parseOptionalJson<Array<{ role: string; content: string; id?: string }>>(row.messages),
       logs: this.parseOptionalJson<Array<{ timestamp: string; level: string; message: string; data?: unknown }>>(row.logs),
       error: row.error as string | undefined,
+      interrupted: (row.interrupted as boolean) ?? false,
       createdAt: new Date(row.created_at as string),
     };
   }
@@ -457,11 +461,12 @@ export class PostgreSQLEvalStore implements EvalStore {
       id: string; tenant_id: string; suite_id: string;
       input_message: string; input_files: unknown; steps: unknown;
       output_type: string; content_assertion: string; rubrics: unknown;
+      interrupt_policy: unknown;
       created_at: string; updated_at: string;
     }>(
       `SELECT id, tenant_id, suite_id,
               input_message, input_files, steps,
-              output_type, content_assertion, rubrics,
+              output_type, content_assertion, rubrics, interrupt_policy,
               created_at, updated_at
        FROM lattice_eval_cases
        WHERE tenant_id = $1 AND suite_id = $2
@@ -478,11 +483,12 @@ export class PostgreSQLEvalStore implements EvalStore {
       id: string; tenant_id: string; suite_id: string;
       input_message: string; input_files: unknown; steps: unknown;
       output_type: string; content_assertion: string; rubrics: unknown;
+      interrupt_policy: unknown;
       created_at: string; updated_at: string;
     }>(
       `SELECT id, tenant_id, suite_id,
               input_message, input_files, steps,
-              output_type, content_assertion, rubrics,
+              output_type, content_assertion, rubrics, interrupt_policy,
               created_at, updated_at
        FROM lattice_eval_cases
        WHERE id = $1 AND tenant_id = $2`,
@@ -504,14 +510,15 @@ export class PostgreSQLEvalStore implements EvalStore {
       id: string; tenant_id: string; suite_id: string;
       input_message: string; input_files: unknown; steps: unknown;
       output_type: string; content_assertion: string; rubrics: unknown;
+      interrupt_policy: unknown;
       created_at: string; updated_at: string;
     }>(
       `INSERT INTO lattice_eval_cases
-        (id, tenant_id, suite_id, input_message, input_files, steps, output_type, content_assertion, rubrics)
-       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+        (id, tenant_id, suite_id, input_message, input_files, steps, output_type, content_assertion, rubrics, interrupt_policy)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
        RETURNING id, tenant_id, suite_id,
                  input_message, input_files, steps,
-                 output_type, content_assertion, rubrics,
+                 output_type, content_assertion, rubrics, interrupt_policy,
                  created_at, updated_at`,
       [
         actualId,
@@ -523,6 +530,7 @@ export class PostgreSQLEvalStore implements EvalStore {
         data.outputType,
         data.contentAssertion || null,
         JSON.stringify(data.rubrics || []),
+        data.interruptPolicy ? JSON.stringify(data.interruptPolicy) : null,
       ]
     );
     return this.mapRowToCase(rows[0] as unknown as Record<string, unknown>);
@@ -544,6 +552,7 @@ export class PostgreSQLEvalStore implements EvalStore {
     if (updates.outputType !== undefined) { set.push(`output_type = $${i++}`); vals.push(updates.outputType); }
     if (updates.contentAssertion !== undefined) { set.push(`content_assertion = $${i++}`); vals.push(updates.contentAssertion); }
     if (updates.rubrics !== undefined) { set.push(`rubrics = $${i++}`); vals.push(JSON.stringify(updates.rubrics)); }
+    if (updates.interruptPolicy !== undefined) { set.push(`interrupt_policy = $${i++}`); vals.push(updates.interruptPolicy ? JSON.stringify(updates.interruptPolicy) : null); }
     if (set.length === 0) return this.getCaseById(tenantId, id);
     set.push(`updated_at = NOW()`);
     vals.push(id, tenantId);
@@ -551,13 +560,14 @@ export class PostgreSQLEvalStore implements EvalStore {
       id: string; tenant_id: string; suite_id: string;
       input_message: string; input_files: unknown; steps: unknown;
       output_type: string; content_assertion: string; rubrics: unknown;
+      interrupt_policy: unknown;
       created_at: string; updated_at: string;
     }>(
       `UPDATE lattice_eval_cases SET ${set.join(", ")}
        WHERE id = $${i} AND tenant_id = $${i + 1}
        RETURNING id, tenant_id, suite_id,
                  input_message, input_files, steps,
-                 output_type, content_assertion, rubrics,
+                 output_type, content_assertion, rubrics, interrupt_policy,
                  created_at, updated_at`,
       vals
     );
@@ -592,13 +602,13 @@ export class PostgreSQLEvalStore implements EvalStore {
     const { rows } = await this.pool.query<{
       id: string; project_id: string; tenant_id: string;
       status: string; concurrency: number; total_cases: number;
-      passed_cases: number; failed_cases: number; avg_score: number;
-      error: string | null; created_at: string; started_at: string | null;
+      passed_cases: number; failed_cases: number; interrupted_cases: number; avg_score: number;
+      error: string | null; interrupted: boolean; created_at: string; started_at: string | null;
       completed_at: string | null;
     }>(
       `SELECT id, project_id, tenant_id,
               status, concurrency, total_cases,
-              passed_cases, failed_cases, avg_score,
+              passed_cases, failed_cases, interrupted_cases, avg_score,
               error, holdout, env_project_id, env_workspace_id, created_at, started_at, completed_at
        FROM lattice_eval_runs
        WHERE ${conditions.join(" AND ")}
@@ -614,13 +624,13 @@ export class PostgreSQLEvalStore implements EvalStore {
     const { rows } = await this.pool.query<{
       id: string; project_id: string; tenant_id: string;
       status: string; concurrency: number; total_cases: number;
-      passed_cases: number; failed_cases: number; avg_score: number;
-      error: string | null; created_at: string; started_at: string | null;
+      passed_cases: number; failed_cases: number; interrupted_cases: number; avg_score: number;
+      error: string | null; interrupted: boolean; created_at: string; started_at: string | null;
       completed_at: string | null;
     }>(
       `SELECT id, project_id, tenant_id,
               status, concurrency, total_cases,
-              passed_cases, failed_cases, avg_score,
+              passed_cases, failed_cases, interrupted_cases, avg_score,
               error, holdout, env_project_id, env_workspace_id, created_at, started_at, completed_at
        FROM lattice_eval_runs
        WHERE id = $1 AND tenant_id = $2`,
@@ -641,8 +651,8 @@ export class PostgreSQLEvalStore implements EvalStore {
     const { rows } = await this.pool.query<{
       id: string; project_id: string; tenant_id: string;
       status: string; concurrency: number; total_cases: number;
-      passed_cases: number; failed_cases: number; avg_score: number;
-      error: string | null; created_at: string; started_at: string | null;
+      passed_cases: number; failed_cases: number; interrupted_cases: number; avg_score: number;
+      error: string | null; interrupted: boolean; created_at: string; started_at: string | null;
       completed_at: string | null;
     }>(
       `INSERT INTO lattice_eval_runs
@@ -650,7 +660,7 @@ export class PostgreSQLEvalStore implements EvalStore {
        VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)
        RETURNING id, project_id, tenant_id,
                  status, concurrency, total_cases,
-                 passed_cases, failed_cases, avg_score,
+                 passed_cases, failed_cases, interrupted_cases, avg_score,
                  error, holdout, env_project_id, env_workspace_id, created_at, started_at, completed_at`,
       [
         actualId,
@@ -679,6 +689,7 @@ export class PostgreSQLEvalStore implements EvalStore {
       status?: EvalRun["status"];
       passedCases?: number;
       failedCases?: number;
+      interruptedCases?: number;
       avgScore?: number;
       error?: string;
       completedAt?: Date;
@@ -691,6 +702,7 @@ export class PostgreSQLEvalStore implements EvalStore {
     if (updates.status !== undefined) { set.push(`status = $${i++}`); vals.push(updates.status); }
     if (updates.passedCases !== undefined) { set.push(`passed_cases = $${i++}`); vals.push(updates.passedCases); }
     if (updates.failedCases !== undefined) { set.push(`failed_cases = $${i++}`); vals.push(updates.failedCases); }
+    if (updates.interruptedCases !== undefined) { set.push(`interrupted_cases = $${i++}`); vals.push(updates.interruptedCases); }
     if (updates.avgScore !== undefined) { set.push(`avg_score = $${i++}`); vals.push(updates.avgScore); }
     if (updates.completedAt !== undefined) { set.push(`completed_at = $${i++}`); vals.push(updates.completedAt); }
     if (updates.error !== undefined) { set.push(`error = $${i++}`); vals.push(updates.error); }
@@ -699,15 +711,15 @@ export class PostgreSQLEvalStore implements EvalStore {
     const { rows } = await this.pool.query<{
       id: string; project_id: string; tenant_id: string;
       status: string; concurrency: number; total_cases: number;
-      passed_cases: number; failed_cases: number; avg_score: number;
-      error: string | null; created_at: string; started_at: string | null;
+      passed_cases: number; failed_cases: number; interrupted_cases: number; avg_score: number;
+      error: string | null; interrupted: boolean; created_at: string; started_at: string | null;
       completed_at: string | null;
     }>(
       `UPDATE lattice_eval_runs SET ${set.join(", ")}
        WHERE id = $${i} AND tenant_id = $${i + 1}
        RETURNING id, project_id, tenant_id,
                  status, concurrency, total_cases,
-                 passed_cases, failed_cases, avg_score,
+                 passed_cases, failed_cases, interrupted_cases, avg_score,
                  error, holdout, env_project_id, env_workspace_id, created_at, started_at, completed_at`,
       vals
     );
@@ -737,11 +749,11 @@ export class PostgreSQLEvalStore implements EvalStore {
       case_id: string | null; pass: boolean; score: number;
       summary: string | null; dimension_results: unknown;
       duration_ms: number | null; messages: unknown; logs: unknown;
-      error: string | null; created_at: string;
+      error: string | null; interrupted: boolean; created_at: string;
     }>(
       `SELECT rr.id, rr.run_id, rr.suite_name, rr.case_id,
               rr.pass, rr.score, rr.summary, rr.dimension_results,
-              rr.duration_ms, rr.messages, rr.logs, rr.error, rr.created_at
+              rr.duration_ms, rr.messages, rr.logs, rr.error, rr.interrupted, rr.created_at
        FROM lattice_eval_run_results rr
        INNER JOIN lattice_eval_runs r ON r.id = rr.run_id
        WHERE r.tenant_id = $1 AND rr.run_id = $2
@@ -765,14 +777,14 @@ export class PostgreSQLEvalStore implements EvalStore {
       case_id: string | null; pass: boolean; score: number;
       summary: string | null; dimension_results: unknown;
       duration_ms: number | null; messages: unknown; logs: unknown;
-      error: string | null; created_at: string;
+      error: string | null; interrupted: boolean; created_at: string;
     }>(
       `INSERT INTO lattice_eval_run_results
-        (id, run_id, suite_name, case_id, pass, score, summary, dimension_results, duration_ms, messages, logs, error)
-       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
+        (id, run_id, suite_name, case_id, pass, score, summary, dimension_results, duration_ms, messages, logs, error, interrupted)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)
        RETURNING id, run_id, suite_name, case_id,
                  pass, score, summary, dimension_results,
-                 duration_ms, messages, logs, error, created_at`,
+                 duration_ms, messages, logs, error, interrupted, created_at`,
       [
         actualId,
         runId,
@@ -786,6 +798,7 @@ export class PostgreSQLEvalStore implements EvalStore {
         JSON.stringify(data.messages || []),
         JSON.stringify(data.logs || []),
         data.error || null,
+        data.interrupted ?? false,
       ]
     );
     return this.mapRowToRunResult(rows[0] as unknown as Record<string, unknown>);
@@ -814,6 +827,7 @@ export class PostgreSQLEvalStore implements EvalStore {
     if (updates.messages !== undefined) { set.push(`messages = $${i++}`); vals.push(JSON.stringify(updates.messages)); }
     if (updates.logs !== undefined) { set.push(`logs = $${i++}`); vals.push(JSON.stringify(updates.logs)); }
     if (updates.error !== undefined) { set.push(`error = $${i++}`); vals.push(updates.error); }
+    if (updates.interrupted !== undefined) { set.push(`interrupted = $${i++}`); vals.push(updates.interrupted); }
     if (set.length === 0) return this.getRunResultById(tenantId, id);
     vals.push(id, tenantId);
     const { rows } = await this.pool.query<{
@@ -821,7 +835,7 @@ export class PostgreSQLEvalStore implements EvalStore {
       case_id: string | null; pass: boolean; score: number;
       summary: string | null; dimension_results: unknown;
       duration_ms: number | null; messages: unknown; logs: unknown;
-      error: string | null; created_at: string;
+      error: string | null; interrupted: boolean; created_at: string;
     }>(
       `UPDATE lattice_eval_run_results SET ${set.join(", ")}
        WHERE id = $${i}
@@ -854,11 +868,11 @@ export class PostgreSQLEvalStore implements EvalStore {
       case_id: string | null; pass: boolean; score: number;
       summary: string | null; dimension_results: unknown;
       duration_ms: number | null; messages: unknown; logs: unknown;
-      error: string | null; created_at: string;
+      error: string | null; interrupted: boolean; created_at: string;
     }>(
       `SELECT rr.id, rr.run_id, rr.suite_name, rr.case_id,
               rr.pass, rr.score, rr.summary, rr.dimension_results,
-              rr.duration_ms, rr.messages, rr.logs, rr.error, rr.created_at
+              rr.duration_ms, rr.messages, rr.logs, rr.error, rr.interrupted, rr.created_at
        FROM lattice_eval_run_results rr
        INNER JOIN lattice_eval_runs r ON r.id = rr.run_id
        WHERE rr.id = $1 AND r.tenant_id = $2`,