@inflexa-ai/harness 0.45.1 → 0.46.2

package/dist/state/runs.js

@@ -11,6 +11,10 @@
  */
 import { stripNulCharacters } from "../input-sanitization.js";
 import { tryMutation, tryQuery } from "../lib/db-result.js";
+import { parseJsonAs } from "../lib/parse-json.js";
+import { UnknownArraySchema } from "../lib/unknown-containers.js";
+import { z } from "zod";
+import { CortexRunRowSchema } from "./schema.js";
 export class RunIdentityCollisionError extends Error {
     runId;
     constructor(runId) {
@@ -50,8 +54,8 @@ export function insertRun(pool, input) {
         await pool.query({
             text: `INSERT INTO cortex_runs
             (run_id, analysis_id, thread_id, workflow_name,
-             status, started_at, plan_id, mandate_jti, mandate_expires_at) -- oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
-            VALUES ($1, $2, $3, $4, 'running', $5, $6, $7, $8)`,
+             status, started_at, plan_id, mandate_id) -- oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
+            VALUES ($1, $2, $3, $4, 'running', $5, $6, $7)`,
             values: [
                 input.runId,
                 input.analysisId,
@@ -59,8 +63,7 @@ export function insertRun(pool, input) {
                 input.workflowName,
                 now,
                 input.planId ?? null,
-                input.mandateJti ?? null, // oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
-                input.mandateExpiresAt ?? null, // oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
+                input.mandateId ?? null, // oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
             ],
         });
     }).mapErr((e) => {
@@ -81,27 +84,18 @@ export function reserveRunById(pool, input) {
         const result = await pool.query({
             text: `INSERT INTO cortex_runs
             (run_id, analysis_id, thread_id, workflow_name,
-             status, started_at, plan_id, mandate_jti, mandate_expires_at)
-            VALUES ($1, $2, $3, $4, 'running', $5, $6, $7, $8)
+             status, started_at, plan_id, mandate_id)
+            VALUES ($1, $2, $3, $4, 'running', $5, $6, $7)
             ON CONFLICT (run_id) DO NOTHING
             RETURNING run_id`,
-            values: [
-                input.runId,
-                input.analysisId,
-                input.threadId ?? null,
-                input.workflowName,
-                now,
-                input.planId ?? null,
-                input.mandateJti ?? null,
-                input.mandateExpiresAt ?? null,
-            ],
+            values: [input.runId, input.analysisId, input.threadId ?? null, input.workflowName, now, input.planId ?? null, input.mandateId ?? null],
         });
         return (result.rowCount ?? 0) > 0;
     }).andThen((inserted) => tryQuery("runs.reserveRunById.reload", async () => {
         const result = await pool.query({
             text: `SELECT run_id, analysis_id, thread_id, workflow_name,
                        status, started_at, completed_at, error, synthesis_status, synthesis_reason, parts,
-                       mandate_jti, mandate_expires_at, plan_id
+                       mandate_id, plan_id
                 FROM cortex_runs
                 WHERE run_id = $1`,
             values: [input.runId],
@@ -113,11 +107,11 @@ export function reserveRunById(pool, input) {
         return { row: mapRunRow(row), inserted };
     }));
 }
+/** The two pg error fields a dedup collision is read from; a driver error is an `Error` carrying them as own fields. */
+const PgErrorIdentitySchema = z.object({ code: z.string(), constraint: z.string() });
 function isPartialUniqueViolation(err) {
-    if (err === null || typeof err !== "object")
-        return false;
-    const e = err;
-    return e.code === "23505" && e.constraint === "idx_cortex_runs_active_plan";
+    const parsed = PgErrorIdentitySchema.safeParse(err);
+    return parsed.success && parsed.data.code === "23505" && parsed.data.constraint === "idx_cortex_runs_active_plan";
 }
 /**
  * Recover the active run row for `(analysisId, planId)` after `insertRun`
@@ -129,7 +123,7 @@ export function queryActiveRun(pool, analysisId, planId) {
         const result = await pool.query({
             text: `SELECT run_id, analysis_id, thread_id, workflow_name,
                    status, started_at, completed_at, error, synthesis_status, synthesis_reason, parts,
-                   mandate_jti, mandate_expires_at, plan_id -- oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
+                   mandate_id, plan_id -- oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
             FROM cortex_runs
             WHERE analysis_id = $1
               AND plan_id IS NOT DISTINCT FROM $2
@@ -180,7 +174,7 @@ export function queryActiveRunsByAnalysis(pool, analysisId, { q } = {}) {
         const result = await pool.query({
             text: `SELECT run_id, analysis_id, thread_id, workflow_name,
                    status, started_at, completed_at, error, synthesis_status, synthesis_reason, parts,
-                   mandate_jti, mandate_expires_at, plan_id -- oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
+                   mandate_id, plan_id -- oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
             FROM cortex_runs
             WHERE analysis_id = $1
               AND status = 'running'
@@ -234,7 +228,7 @@ export function reconcileOrphanedRuns(pool, opts = {}) {
  */
 export function updateRunStatus(pool, runId, status, error) {
     const now = new Date().toISOString();
-    const isTerminal = status === "completed" || status === "partial" || status === "failed" || status === "canceled" || status === "suspended_insufficient_funds";
+    const isTerminal = status === "completed" || status === "partial" || status === "failed" || status === "canceled";
     return tryMutation("runs.updateRunStatus", async () => {
         const result = await pool.query({
             text: `UPDATE cortex_runs
@@ -280,7 +274,7 @@ export function queryRun(pool, runId) {
         const result = await pool.query({
             text: `SELECT run_id, analysis_id, thread_id, workflow_name,
                    status, started_at, completed_at, error, synthesis_status, synthesis_reason, parts,
-                   mandate_jti, mandate_expires_at, plan_id -- oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
+                   mandate_id, plan_id -- oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
             FROM cortex_runs
             WHERE run_id = $1`,
             values: [runId],
@@ -300,7 +294,7 @@ export function queryRunsByAnalysis(pool, analysisId, { limit = 50, offset = 0,
         const result = await pool.query({
             text: `SELECT run_id, analysis_id, thread_id, workflow_name,
                    status, started_at, completed_at, error, synthesis_status, synthesis_reason, parts,
-                   mandate_jti, mandate_expires_at, plan_id -- oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
+                   mandate_id, plan_id -- oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
             FROM cortex_runs
             WHERE analysis_id = $1
               ${text}
@@ -325,7 +319,7 @@ export function countRunsByAnalysis(pool, analysisId, { q } = {}) {
               ${text}`,
             values,
         });
-        return Number(result.rows[0]?.total ?? 0);
+        return result.rows[0]?.total ?? 0;
     });
 }
 /**
@@ -379,7 +373,7 @@ export function queryNonTerminalRunsByAnalysis(pool, analysisId, limit = 20) {
         const rowsResult = await pool.query({
             text: `SELECT run_id, analysis_id, thread_id, workflow_name,
                    status, started_at, completed_at, error, synthesis_status, synthesis_reason, parts,
-                   mandate_jti, mandate_expires_at, plan_id
+                   mandate_id, plan_id
             FROM cortex_runs
             WHERE analysis_id = $1
               AND status = 'running'
@@ -408,7 +402,7 @@ export function queryRunsForInspection(pool, analysisId, { limit = 50, offset =
         const rowsResult = await pool.query({
             text: `SELECT run_id, analysis_id, thread_id, workflow_name,
                    status, started_at, completed_at, error, synthesis_status, synthesis_reason, parts,
-                   mandate_jti, mandate_expires_at, plan_id
+                   mandate_id, plan_id
             FROM cortex_runs
             WHERE analysis_id = $1
             ORDER BY CASE status
@@ -434,7 +428,7 @@ export function queryRunsByThread(pool, analysisId, threadId, { limit = 50, offs
         const result = await pool.query({
             text: `SELECT run_id, analysis_id, thread_id, workflow_name,
                    status, started_at, completed_at, error, synthesis_status, synthesis_reason, parts,
-                   mandate_jti, mandate_expires_at, plan_id -- oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
+                   mandate_id, plan_id -- oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
             FROM cortex_runs
             WHERE analysis_id = $1 AND thread_id = $2
               ${text}
@@ -445,20 +439,20 @@ export function queryRunsByThread(pool, analysisId, threadId, { limit = 50, offs
     });
 }
 /**
- * Persist the run mandate jti + expiry for a run. oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
- * Called by `authorizeForRun` after a successful mint so the cancel
- * handler can revoke the mandate by `runId → jti` lookup. oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
- * The JWT itself is NOT persisted — it rides in DBOS workflow input.
+ * Persist the run mandate reference for a run. oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
+ * Called by the host authorizer after it authorizes the run, so the cancel
+ * handler can revoke the mandate by `runId → mandate id` lookup. oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
+ * The reference has no expiry here: the run does not depend on a clock.
  */
-export function setRunMandate(pool, runId, jti, expiresAt) {
+export function setRunMandate(pool, runId, mandateId) {
     // oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
     return tryMutation("runs.setRunMandate", async () => {
         // oss-core-managed-ok: run-mandate ledger op label
         await pool.query({
             text: `UPDATE cortex_runs
-            SET mandate_jti = $1, mandate_expires_at = $2 -- oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
-            WHERE run_id = $3`,
-            values: [jti, expiresAt, runId],
+            SET mandate_id = $1 -- oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
+            WHERE run_id = $2`,
+            values: [mandateId, runId],
         });
     });
 }
@@ -479,20 +473,19 @@ export function setRunSynthesisOutcome(pool, runId, synthesisStatus, synthesisRe
 }
 function mapRunRow(row) {
     // JSONB is parsed by `pg` into native arrays/objects. Treat legacy TEXT
-    // rows (if anything slipped through) as strings and parse them.
-    let parts = null;
-    if (Array.isArray(row.parts)) {
-        parts = row.parts;
-    }
-    else if (typeof row.parts === "string") {
+    // rows (if anything slipped through) as strings and parse them. A parts
+    // value that survives neither shape reads as null, like a row with no parts.
+    let parts = row.parts;
+    if (typeof parts === "string") {
         try {
-            parts = JSON.parse(row.parts);
+            parts = parseJsonAs(parts, z.json());
         }
         catch {
-            /* malformed — treat as null */
+            parts = null;
         }
     }
-    return {
+    const parsedParts = UnknownArraySchema.safeParse(parts);
+    return CortexRunRowSchema.parse({
         runId: row.run_id,
         analysisId: row.analysis_id,
         threadId: row.thread_id ?? null,
@@ -503,9 +496,8 @@ function mapRunRow(row) {
         error: row.error ?? null,
         synthesisStatus: row.synthesis_status ?? null,
         synthesisReason: row.synthesis_reason ?? null,
-        parts,
-        mandateJti: row.mandate_jti ?? null, // oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
-        mandateExpiresAt: row.mandate_expires_at ?? null, // oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
+        parts: parsedParts.success ? parsedParts.data : null,
+        mandateId: row.mandate_id ?? null, // oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
         planId: row.plan_id ?? null,
-    };
+    });
 }

package/dist/state/schema.d.ts

@@ -10,10 +10,10 @@ export declare const AnalysisStateRowSchema: z.ZodObject<{
     status: z.ZodString;
     context: z.ZodNullable<z.ZodString>;
     dataProfileStatus: z.ZodEnum<{
+        completed: "completed";
         failed: "failed";
         pending: "pending";
         running: "running";
-        completed: "completed";
     }>;
     dataProfileError: z.ZodNullable<z.ZodString>;
     dataProfileStartedAt: z.ZodNullable<z.ZodString>;
@@ -46,31 +46,30 @@ export declare const ArtifactRowSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type ArtifactRow = z.infer<typeof ArtifactRowSchema>;
 export declare const RunStatus: z.ZodEnum<{
-    failed: "failed";
-    running: "running";
+    canceled: "canceled";
     completed: "completed";
+    failed: "failed";
     partial: "partial";
-    canceled: "canceled";
-    suspended_insufficient_funds: "suspended_insufficient_funds";
+    running: "running";
 }>;
 export type RunStatus = z.infer<typeof RunStatus>;
 /** A status that a run keeps once it ended: every status but `running`. */
 export type TerminalRunStatus = Exclude<RunStatus, "running">;
 export declare const StepExecutionStatus: z.ZodEnum<{
+    blocked: "blocked";
+    canceled: "canceled";
+    completed: "completed";
     failed: "failed";
     pending: "pending";
     running: "running";
-    completed: "completed";
-    canceled: "canceled";
     skipped: "skipped";
-    blocked: "blocked";
 }>;
 export type StepExecutionStatus = z.infer<typeof StepExecutionStatus>;
 export declare const SynthesisStatus: z.ZodEnum<{
     failed: "failed";
     produced: "produced";
-    skipped_no_summaries: "skipped_no_summaries";
     skipped_blocker: "skipped_blocker";
+    skipped_no_summaries: "skipped_no_summaries";
 }>;
 export type SynthesisStatus = z.infer<typeof SynthesisStatus>;
 export declare const CortexRunRowSchema: z.ZodObject<{
@@ -79,12 +78,11 @@ export declare const CortexRunRowSchema: z.ZodObject<{
     threadId: z.ZodNullable<z.ZodString>;
     workflowName: z.ZodString;
     status: z.ZodEnum<{
-        failed: "failed";
-        running: "running";
+        canceled: "canceled";
         completed: "completed";
+        failed: "failed";
         partial: "partial";
-        canceled: "canceled";
-        suspended_insufficient_funds: "suspended_insufficient_funds";
+        running: "running";
     }>;
     startedAt: z.ZodString;
     completedAt: z.ZodNullable<z.ZodString>;
@@ -92,13 +90,12 @@ export declare const CortexRunRowSchema: z.ZodObject<{
     synthesisStatus: z.ZodNullable<z.ZodEnum<{
         failed: "failed";
         produced: "produced";
-        skipped_no_summaries: "skipped_no_summaries";
         skipped_blocker: "skipped_blocker";
+        skipped_no_summaries: "skipped_no_summaries";
     }>>;
     synthesisReason: z.ZodNullable<z.ZodString>;
-    parts: z.ZodNullable<z.ZodArray<z.ZodAny>>;
-    mandateJti: z.ZodNullable<z.ZodString>;
-    mandateExpiresAt: z.ZodNullable<z.ZodString>;
+    parts: z.ZodNullable<z.ZodArray<z.ZodJSONSchema>>;
+    mandateId: z.ZodNullable<z.ZodString>;
     planId: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;
 export type CortexRunRow = z.infer<typeof CortexRunRowSchema>;
@@ -123,13 +120,13 @@ export declare const StepExecutionRowSchema: z.ZodObject<{
     wave: z.ZodNumber;
     agentId: z.ZodString;
     status: z.ZodEnum<{
+        blocked: "blocked";
+        canceled: "canceled";
+        completed: "completed";
         failed: "failed";
         pending: "pending";
         running: "running";
-        completed: "completed";
-        canceled: "canceled";
         skipped: "skipped";
-        blocked: "blocked";
     }>;
     startedAt: z.ZodNullable<z.ZodString>;
     completedAt: z.ZodNullable<z.ZodString>;
@@ -155,7 +152,7 @@ export type StepExecutionRow = z.infer<typeof StepExecutionRowSchema>;
 export declare const CortexPlanRowSchema: z.ZodObject<{
     planId: z.ZodString;
     analysisId: z.ZodString;
-    plan: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    plan: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
     parentPlanId: z.ZodNullable<z.ZodString>;
     createdAt: z.ZodString;
 }, z.core.$strip>;

package/dist/state/schema.js

@@ -33,7 +33,7 @@ export const ArtifactRowSchema = z.object({
     fileType: z.string().nullable(),
 });
 // ── Run & Step Execution Schemas ─────────────────────────────────────
-export const RunStatus = z.enum(["running", "completed", "partial", "failed", "canceled", "suspended_insufficient_funds"]);
+export const RunStatus = z.enum(["running", "completed", "partial", "failed", "canceled"]);
 export const StepExecutionStatus = z.enum(["pending", "running", "completed", "failed", "skipped", "canceled", "blocked"]);
 // Run-level synthesis outcome, distinct from RunStatus: a run can reach
 // status="completed" while synthesis produced nothing. "produced" is the only
@@ -53,9 +53,8 @@ export const CortexRunRowSchema = z.object({
     // synthesis never recorded an outcome.
     synthesisStatus: SynthesisStatus.nullable(),
     synthesisReason: z.string().nullable(),
-    parts: z.array(z.any()).nullable(),
-    mandateJti: z.string().nullable(), // oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
-    mandateExpiresAt: z.string().nullable(), // oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
+    parts: z.array(z.json()).nullable(),
+    mandateId: z.string().nullable(), // oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
     planId: z.string().nullable(),
 });
 /**
@@ -98,7 +97,7 @@ export const StepExecutionRowSchema = z.object({
 export const CortexPlanRowSchema = z.object({
     planId: z.string(),
     analysisId: z.string(),
-    plan: z.record(z.string(), z.unknown()),
+    plan: z.record(z.string(), z.json()),
     parentPlanId: z.string().nullable(),
     createdAt: z.string(),
 });

package/dist/state/snapshot-parse.d.ts

@@ -14,10 +14,10 @@ import { type Result } from "neverthrow";
 import { z } from "zod";
 import type { ReportSnapshot } from "../report-model/reference-resolver.js";
 /** One reduced schema issue -- the dotted path and the message, without the rest. */
-export interface SchemaIssue {
+export type SchemaIssue = {
     readonly path: string;
     readonly message: string;
-}
+};
 /** Reduce a zod error to the dotted path and the message of each issue. */
 export declare function reduceIssues(error: z.ZodError): SchemaIssue[];
 /**

package/dist/state/snapshot-parse.js

@@ -11,6 +11,7 @@
  * value on its own, thus the two stores agree on the key set.
  */
 import { err, ok } from "neverthrow";
+import { nullProtoRecord } from "../lib/null-proto.js";
 import { z } from "zod";
 /**
  * One pinned artifact of a stored snapshot. The value carries the content hash, an
@@ -42,7 +43,13 @@ function prefixIssues(prefix, issues) {
         message: issue.message,
     }));
 }
-/** A stored map is a plain object. An array and a null carry no own key that a map read can use. */
+/**
+ * A stored map is a plain object. An array and a null carry no own key that a map read can use.
+ *
+ * The check stays a hand predicate because the walk below must address the ORIGINAL object: a
+ * zod record parse rebuilds the value through string-keyed assignment, and a `__proto__` own key
+ * does not survive that rebuild — the pin contract this module keeps.
+ */
 function isPlainRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -72,9 +79,7 @@ export function parseSnapshot(stored) {
     if (!citationRecords.success) {
         return err(prefixIssues("citationRecords", reduceIssues(citationRecords.error)));
     }
-    // The map takes a null prototype, the same as the pin, thus a path such as
-    // `__proto__` stays an ordinary entry and never reaches a prototype slot.
-    const artifacts = Object.create(null);
+    const artifacts = nullProtoRecord();
     const issues = [];
     for (const [path, value] of Object.entries(stored.artifacts)) {
         const parsed = ArtifactSnapshotSchema.safeParse(value);
@@ -87,11 +92,12 @@ export function parseSnapshot(stored) {
     if (issues.length > 0) {
         return err(issues);
     }
-    // An absent part stays absent in the parsed value. Thus a reload gives the same shape that the pin
-    // wrote, and an equality test over a stored snapshot holds across the round trip.
+    // An absent part comes back as an own key that holds `undefined`, because the literal below always
+    // sets the three keys. An equality that ignores `undefined` members holds across the round trip; a
+    // check that counts the own keys does not.
     return ok({
         artifacts,
-        ...(citations.data === undefined ? {} : { citations: citations.data }),
-        ...(citationRecords.data === undefined ? {} : { citationRecords: citationRecords.data }),
+        citations: citations.data,
+        citationRecords: citationRecords.data,
     });
 }

package/dist/state/step-executions.d.ts

@@ -4,16 +4,28 @@
  * module.
  */
 import type { ResultAsync } from "neverthrow";
+import type { QueryConfig } from "pg";
 import { type DbError } from "../lib/db-result.js";
 import type { Querier } from "./db.js";
-import type { StepExecutionRow } from "./schema.js";
-export interface SeedStepExecutionRow {
+import { type StepExecutionRow } from "./schema.js";
+/**
+ * The row-reading surface of this module: one query over the text or config form, whose rows the
+ * mapStepExecutionRow parser types. A computed test fake satisfies this shape directly, where the
+ * row-generic of `Querier` cannot be implemented by a fake that computes its rows.
+ */
+export type StepRowQuerier = {
+    query(queryTextOrConfig: string | QueryConfig, values?: unknown[]): Promise<{
+        rows: Record<string, unknown>[];
+        rowCount: number | null;
+    }>;
+};
+export type SeedStepExecutionRow = {
     runId: string;
     stepId: string;
     analysisId: string;
     wave: number;
     agentId: string;
-}
+};
 /**
  * Seed one `pending` row per plan step at run start (`started_at` NULL — no
  * attempt has happened yet; `attempts`/`hit_max_steps` lean on their column
@@ -25,7 +37,7 @@ export interface SeedStepExecutionRow {
  * honest done/total progress including not-yet-started steps.
  */
 export declare function seedStepExecutions(pool: Querier, rows: readonly SeedStepExecutionRow[]): ResultAsync<void, DbError>;
-export interface InsertStepExecutionInput {
+export type InsertStepExecutionInput = {
     runId: string;
     stepId: string;
     analysisId: string;
@@ -33,14 +45,14 @@ export interface InsertStepExecutionInput {
     agentId: string;
     /** DBOS child workflow id (`"${parent}-${N}"`). Optional for legacy callers. */
     childWorkflowId?: string | null;
-}
+};
 export declare function insertStepExecution(pool: Querier, input: InsertStepExecutionInput): ResultAsync<void, DbError>;
 /**
  * Look up a step execution by its DBOS child workflow id. The parent
  * scheduler uses this to find the step row corresponding to a CANCELLED
  * child without holding the runId/stepId map in memory across recovery.
  */
-export interface UpdateStepExecutionInput {
+export type UpdateStepExecutionInput = {
     /** Step status — `running` is allowed for mid-flight telemetry updates (retries). */
     status: "running" | "completed" | "failed" | "skipped" | "canceled" | "blocked";
     durationMs?: number | null;
@@ -55,7 +67,7 @@ export interface UpdateStepExecutionInput {
     finishReason?: string | null;
     /** True when `stepsUsed === maxSteps`. Stored as 0/1 in SQLite. */
     hitMaxSteps?: boolean | null;
-}
+};
 /**
  * Update a step execution row. Columns are written conditionally so callers
  * can bump `attempts` / `lastErrorClass` on retry without clobbering timing
@@ -83,4 +95,4 @@ export declare function sweepPendingStepExecutions(pool: Querier, runId: string)
  * the duration casts both; it is NULL when `started_at` is NULL.
  */
 export declare function cancelRunningStepExecutions(pool: Querier, runId: string, reason: string): ResultAsync<void, DbError>;
-export declare function queryStepsByRun(pool: Querier, runId: string): ResultAsync<StepExecutionRow[], DbError>;
+export declare function queryStepsByRun(pool: StepRowQuerier, runId: string): ResultAsync<StepExecutionRow[], DbError>;

package/dist/state/step-executions.js

@@ -4,6 +4,7 @@
  * module.
  */
 import { tryMutation, tryQuery } from "../lib/db-result.js";
+import { StepExecutionRowSchema } from "./schema.js";
 /**
  * Seed one `pending` row per plan step at run start (`started_at` NULL — no
  * attempt has happened yet; `attempts`/`hit_max_steps` lean on their column
@@ -174,7 +175,7 @@ export function queryStepsByRun(pool, runId) {
     });
 }
 function mapStepExecutionRow(row) {
-    return {
+    return StepExecutionRowSchema.parse({
         runId: row.run_id,
         stepId: row.step_id,
         analysisId: row.analysis_id,
@@ -183,14 +184,15 @@ function mapStepExecutionRow(row) {
         status: row.status,
         startedAt: row.started_at ?? null,
         completedAt: row.completed_at ?? null,
-        durationMs: row.duration_ms === null || row.duration_ms === undefined ? null : Number(row.duration_ms),
+        // `duration_ms` is bigint, which `pg` delivers as a string; the schema wants the number.
+        durationMs: row.duration_ms === undefined || row.duration_ms === null ? null : Number(row.duration_ms),
         error: row.error ?? null,
-        attempts: row.attempts ?? 1,
+        attempts: row.attempts === undefined || row.attempts === null ? undefined : Number(row.attempts),
         lastErrorClass: row.last_error_class ?? null,
         finishReason: row.finish_reason ?? null,
         hitMaxSteps: row.hit_max_steps === 1 || row.hit_max_steps === true,
         blockedReason: row.blocked_reason ?? null,
         sandboxRef: row.sandbox_ref ?? null,
         childWorkflowId: row.child_workflow_id ?? null,
-    };
+    });
 }

package/dist/state/tool-outputs.d.ts

@@ -1,4 +1,4 @@
 /** The Postgres realization of the tool output store of the loop, over `cortex_tool_outputs`. */
-import type { Pool } from "pg";
+import type { Querier } from "./db.js";
 import type { ToolOutputStore } from "../loop/tool-output.js";
-export declare function createToolOutputStore(pool: Pool): ToolOutputStore;
+export declare function createToolOutputStore(pool: Querier): ToolOutputStore;

package/dist/state/tool-outputs.js

@@ -1,14 +1,15 @@
 /** The Postgres realization of the tool output store of the loop, over `cortex_tool_outputs`. */
 import { tryMutation, tryQuery } from "../lib/db-result.js";
 function toKeptToolOutput(row) {
+    const threadIdField = row.thread_id === null ? undefined : { threadId: row.thread_id };
     return {
         analysisId: row.analysis_id,
         ref: row.ref,
         toolName: row.tool_name,
         toolCallId: row.tool_call_id,
-        ...(row.thread_id === null ? {} : { threadId: row.thread_id }),
         content: row.content,
         totalLength: row.total_length,
+        ...threadIdField,
     };
 }
 export function createToolOutputStore(pool) {

package/dist/state/vector-store.d.ts

@@ -13,7 +13,7 @@
  * `search_{snake}` shape we ever produce.
  */
 import { ResultAsync } from "neverthrow";
-import type { Pool } from "pg";
+import type { Querier } from "./db.js";
 import { type DbError } from "../lib/db-result.js";
 /**
  * Whether `name` may be interpolated into a statement as an identifier. Shared
@@ -21,24 +21,24 @@ import { type DbError } from "../lib/db-result.js";
  * shape — one invariant, one place to read it.
  */
 export declare function isSqlIdentifier(name: string): boolean;
-export interface CreateIndexInput {
+export type CreateIndexInput = {
     readonly indexName: string;
     readonly dimension: number;
     readonly metric?: "cosine" | "l2" | "ip";
-}
-export interface BuildIndexInput {
+};
+export type BuildIndexInput = {
     readonly indexName: string;
     readonly metric?: "cosine" | "l2" | "ip";
     readonly indexConfig: {
         readonly type: "hnsw";
     };
-}
-export interface UpsertInput {
+};
+export type UpsertInput = {
     readonly indexName: string;
     readonly vectors: readonly number[][];
     readonly metadata?: readonly Record<string, unknown>[];
     readonly ids?: readonly string[];
-}
+};
 /**
  * A narrow delete surface: every entry of one index whose metadata `type` is named.
  *
@@ -47,26 +47,26 @@ export interface UpsertInput {
  * has to be unable to reach another's — a general predicate would make that a review
  * question rather than a type error.
  */
-export interface DeleteByTypeInput {
+export type DeleteByTypeInput = {
     readonly indexName: string;
     readonly types: readonly string[];
-}
-export interface QueryInput {
+};
+export type QueryInput = {
     readonly indexName: string;
     readonly queryVector: readonly number[];
     readonly topK: number;
     readonly filter?: Record<string, unknown>;
-}
-export interface QueryResult {
+};
+export type QueryResult = {
     readonly id: string;
     readonly score: number;
     readonly metadata: Record<string, unknown>;
-}
-export interface VectorStore {
+};
+export type VectorStore = {
     createIndex(input: CreateIndexInput): ResultAsync<void, DbError>;
     buildIndex(input: BuildIndexInput): ResultAsync<void, DbError>;
     upsert(input: UpsertInput): ResultAsync<void, DbError>;
     deleteByType(input: DeleteByTypeInput): ResultAsync<void, DbError>;
     query(input: QueryInput): ResultAsync<QueryResult[], DbError>;
-}
-export declare function createVectorStore(pool: Pool): VectorStore;
+};
+export declare function createVectorStore(pool: Querier): VectorStore;