@sixb/pg 0.1.11 → 0.1.12

package/dist/index.js

@@ -125,6 +125,7 @@ function canStartPgTransaction(sql) {
 }
 
 // src/agents/rows.ts
+import { snapshotAgentThreadSandboxParams } from "@sixb/core/internal/agent-run-storage-provider";
 import { parseSixbFailure } from "@sixb/core/internal/errors";
 import {
   AGENT_RUN_FAILURE_CODES,
@@ -136,6 +137,12 @@ function rowToThreadRecord(row) {
     projectId: row.project_id,
     ownerPrincipal: { type: row.owner_principal_type, id: row.owner_principal_id },
     title: row.title ?? undefined,
+    ...row.sandbox_state == null ? {} : {
+      sandboxState: typeof row.sandbox_state === "string" ? JSON.parse(row.sandbox_state) : row.sandbox_state
+    },
+    ...row.sandbox_params == null ? {} : {
+      sandboxParams: snapshotAgentThreadSandboxParams(typeof row.sandbox_params === "string" ? JSON.parse(row.sandbox_params) : row.sandbox_params)
+    },
     status: row.status,
     activeRunId: row.active_run_id,
     lastMessageAt: row.last_message_at ? new Date(row.last_message_at) : undefined,
@@ -974,6 +981,10 @@ class PgAgentRunStore {
 }
 
 // src/agents/threads.ts
+import {
+  snapshotAgentThreadSandboxParams as snapshotAgentThreadSandboxParams2,
+  transitionAgentThreadSandbox
+} from "@sixb/core/internal/agent-run-storage-provider";
 import {
   AgentStorageError as AgentStorageError4
 } from "@sixb/core/storage";
@@ -982,7 +993,24 @@ class PgAgentThreadStore {
   constructor(sql) {
     this.sql = sql;
   }
+  async transitionSandbox(input) {
+    return runPgTransaction(this.sql, async (tx) => {
+      const runs = input.action === "recreate" ? [] : await tx`
+        SELECT * FROM agent_runs WHERE project_id = ${input.projectId} AND id = ${input.runId}
+        FOR UPDATE
+      `;
+      const [thread] = await tx`
+        SELECT * FROM agent_threads WHERE project_id = ${input.projectId} AND id = ${input.id}
+        FOR UPDATE
+      `;
+      const state = transitionAgentThreadSandbox(thread ? rowToThreadRecord(thread) : null, runs[0] ? rowToRunRecord(runs[0]) : null, input);
+      await tx`UPDATE agent_threads SET sandbox_state = ${JSON.stringify(state)}::text::jsonb
+        WHERE project_id = ${input.projectId} AND id = ${input.id}`;
+      return state;
+    });
+  }
   async create(input) {
+    const sandboxParams = input.sandboxParams === undefined ? null : JSON.stringify(snapshotAgentThreadSandboxParams2(input.sandboxParams));
     const createdAt = input.createdAt ?? new Date;
     const updatedAt = input.updatedAt ?? createdAt;
     try {
@@ -993,6 +1021,7 @@ class PgAgentThreadStore {
           owner_principal_type,
           owner_principal_id,
           title,
+          sandbox_params,
           status,
           created_at,
           updated_at
@@ -1002,6 +1031,7 @@ class PgAgentThreadStore {
           ${input.ownerPrincipal.type},
           ${input.ownerPrincipal.id},
           ${input.title ?? null},
+          ${sandboxParams}::text::jsonb,
           ${input.status ?? "active"},
           ${createdAt},
           ${updatedAt}
@@ -7140,6 +7170,80 @@ ALTER TABLE projection_runs ADD COLUMN source_changes_read BIGINT
   CHECK (source_changes_read IS NULL OR source_changes_read >= 0);
 `;
 
+// src/migrations/041-agent-thread-workspaces.sql
+var _041_agent_thread_workspaces_default = `ALTER TABLE agent_threads ADD COLUMN sandbox_params JSONB
+  CHECK (sandbox_params IS NULL OR jsonb_typeof(sandbox_params) = 'object');
+`;
+
+// src/migrations/042-vector-profiles.sql
+var _042_vector_profiles_default = `-- Transactional derived state. Search extensions are not required for persistence.
+CREATE TABLE object_vectors (
+  project_id TEXT NOT NULL,
+  object_type_id TEXT NOT NULL,
+  primary_id TEXT NOT NULL,
+  profile TEXT NOT NULL CHECK (length(btrim(profile)) > 0),
+  configuration TEXT NOT NULL,
+  source TEXT[] NOT NULL,
+  source_fingerprint TEXT NOT NULL,
+  embedding REAL[] NOT NULL,
+  last_commit_id TEXT NOT NULL,
+  PRIMARY KEY (project_id, object_type_id, primary_id, profile),
+  FOREIGN KEY (project_id, object_type_id, primary_id)
+    REFERENCES objects (project_id, object_type_id, primary_id) ON DELETE CASCADE,
+  FOREIGN KEY (project_id, last_commit_id)
+    REFERENCES ontology_commits (project_id, id) DEFERRABLE INITIALLY DEFERRED,
+  CONSTRAINT object_vectors_sources CHECK (
+    cardinality(source) > 0 AND array_ndims(source) = 1 AND array_lower(source, 1) = 1
+    AND array_position(source, NULL) IS NULL
+  ),
+  CONSTRAINT object_vectors_values CHECK (
+    cardinality(embedding) BETWEEN 1 AND 16000
+    AND array_ndims(embedding) = 1 AND array_lower(embedding, 1) = 1
+    AND array_position(embedding, NULL) IS NULL
+    AND '-Infinity'::real < ALL(embedding) AND 'Infinity'::real > ALL(embedding)
+    AND 0::real <> ANY(embedding)
+  )
+);
+`;
+
+// src/migrations/043-vector-indexing.sql
+var _043_vector_indexing_default = `CREATE TABLE object_vector_indexing (
+  project_id TEXT NOT NULL,
+  id TEXT NOT NULL,
+  object_type_id TEXT NOT NULL,
+  primary_id TEXT NOT NULL,
+  profile TEXT NOT NULL,
+  request JSONB NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('pending', 'running', 'ready', 'failed')),
+  available_at TIMESTAMPTZ NOT NULL,
+  dispatch_at TIMESTAMPTZ NOT NULL,
+  values_json JSONB,
+  error TEXT,
+  PRIMARY KEY (project_id, id),
+  UNIQUE (project_id, object_type_id, primary_id, profile)
+);
+CREATE INDEX object_vector_indexing_due ON object_vector_indexing (project_id, dispatch_at, id)
+  WHERE status <> 'failed';
+
+ALTER TABLE executions DROP CONSTRAINT executions_authority_kernel_operation_check;
+ALTER TABLE executions ADD CONSTRAINT executions_authority_kernel_operation_check
+  CHECK (authority_kernel_operation IS NULL OR authority_kernel_operation IN ('ontology.recover', 'ontology.indexVectors'));
+ALTER TABLE executions DROP CONSTRAINT executions_source_kind_check;
+ALTER TABLE executions ADD CONSTRAINT executions_source_kind_check
+  CHECK (source_kind IN ('http', 'webhook', 'schedule', 'event', 'datasetVersion', 'execution', 'ontologyCommit'));
+`;
+
+// src/migrations/044-vector-batching.sql
+var _044_vector_batching_default = `ALTER TABLE object_vector_indexing ADD COLUMN batch_id TEXT;
+CREATE INDEX object_vector_indexing_batch ON object_vector_indexing (project_id, batch_id, id)
+  WHERE batch_id IS NOT NULL;
+`;
+
+// src/migrations/045-agent-thread-sandbox-state.sql
+var _045_agent_thread_sandbox_state_default = `ALTER TABLE agent_threads ADD COLUMN sandbox_state JSONB
+  CHECK (sandbox_state IS NULL OR jsonb_typeof(sandbox_state) = 'object');
+`;
+
 // src/migrations/037-execution-requester-groups.sql
 var _037_execution_requester_groups_default = `ALTER TABLE executions ADD COLUMN requester_group_ids JSONB NOT NULL DEFAULT '[]'::jsonb;
 
@@ -7392,17 +7496,34 @@ var postgresStorageMigrations = defineMigrations({
     pgSql("037-execution-requester-groups", _037_execution_requester_groups_default),
     pgSql("038-outbox-publication-order", _038_outbox_publication_order_default),
     pgSql("039-projection-source-roots", _039_projection_source_roots_default),
-    pgSql("040-connector-optional-pkce", _040_connector_optional_pkce_default)
+    pgSql("040-connector-optional-pkce", _040_connector_optional_pkce_default),
+    pgSql("041-agent-thread-workspaces", _041_agent_thread_workspaces_default),
+    pgSql("042-vector-profiles", _042_vector_profiles_default),
+    pgSql("043-vector-indexing", _043_vector_indexing_default),
+    pgSql("044-vector-batching", _044_vector_batching_default),
+    pgSql("045-agent-thread-sandbox-state", _045_agent_thread_sandbox_state_default)
   ]
 });
 
+// src/objects/storage.ts
+import { hasVectorProfile as hasVectorProfile3 } from "@sixb/core/internal/query";
+
 // src/objects/query-compiler.ts
 import {
   ObjectQueryExecutionError
 } from "@sixb/core";
+import {
+  hasVectorProfile,
+  isVectorProfileQuery,
+  normalizeVector,
+  vectorSearchCandidateLimit
+} from "@sixb/core/internal/query";
 var PAGE_TOKEN_PREFIX = "keyset:";
 var DEFAULT_EXPANSION_FANOUT = 1000;
 function compilePgObjectQuery(projectId, query, options = {}) {
+  if (hasVectorProfile(query) && !isVectorProfileQuery(query)) {
+    throw new ObjectQueryExecutionError("unsupported_vector_composition", "Vector search supports one profile with filters before ranking and limit/project after.");
+  }
   const source = options.source ?? DEFAULT_OBJECT_QUERY_SOURCE;
   const compiled = source.wrapQuery(compileObjectQueryInternal(projectId, query, {
     probeLimit: options.includeTotal === false,
@@ -7412,6 +7533,7 @@ function compilePgObjectQuery(projectId, query, options = {}) {
     ...compiled,
     sql: numberPlaceholders(compiled.sql),
     totalSql: numberPlaceholders(compiled.totalSql),
+    vectorProbe: compiled.vectorProbe ? { ...compiled.vectorProbe, sql: numberPlaceholders(compiled.vectorProbe.sql) } : undefined,
     hasMoreProbe: compiled.hasMoreProbe ? {
       ...compiled.hasMoreProbe,
       sql: numberPlaceholders(compiled.hasMoreProbe.sql)
@@ -7489,8 +7611,56 @@ function compileObjectQueryInternal(projectId, query, ctx) {
     case "expand":
       return compileExpand(projectId, query.input, query.expansions, ctx);
     case "vector":
-      throw new Error(`[SixbPg] PostgreSQL object storage does not support query node '${query.kind}'`);
-  }
+      return compileVector(projectId, query, ctx);
+  }
+}
+function compileVector(projectId, query, ctx) {
+  if (typeof query.vector === "string" || !isVectorProfileQuery(query) || !query.configuration || !Number.isSafeInteger(query.k) || query.k < 1 || query.k > 1000 || query.vector.length < 1 || query.vector.length > 16000) {
+    throw new ObjectQueryExecutionError("invalid_vector_query", "A validated named vector profile is required.");
+  }
+  const input = compileObjectQueryInternal(projectId, query.input, exactContext(ctx));
+  const permissions = ctx.source.objectPropertyPermissionsTable;
+  const permissionJoin = permissions ? `JOIN (
+      SELECT project_id, object_type_id, primary_id, array_agg(property_id) AS property_ids
+      FROM ${permissions}
+      GROUP BY project_id, object_type_id, primary_id
+    ) AS vector_permissions ON vector_permissions.project_id = vectors.project_id
+      AND vector_permissions.object_type_id = vectors.object_type_id
+      AND vector_permissions.primary_id = vectors.primary_id` : "";
+  const authorized = permissions ? `AND vectors.source <@ vector_permissions.property_ids` : "";
+  const candidates = `FROM (${input.sql}) AS input
+    JOIN object_vectors AS vectors ON vectors.project_id = input.project_id
+      AND vectors.object_type_id = input.object_type_id AND vectors.primary_id = input.primary_id
+    ${permissionJoin}
+    WHERE vectors.profile = ? AND vectors.configuration = ?
+      AND cardinality(vectors.embedding) = ? ${authorized}`;
+  const candidateArgs = [...input.args, query.profile, query.configuration, query.vector.length];
+  const limit = vectorSearchCandidateLimit(query.vector.length);
+  const values = normalizeVector(query.vector, query.vector.length);
+  const order = compileOrder([
+    { kind: "column", column: "_vector_score", direction: "desc" },
+    ...identityOrderFields().map((field) => ({ ...field, binary: true }))
+  ]);
+  const sql = `SELECT * FROM (SELECT input.*, 1 - (vectors.embedding::public.vector OPERATOR(public.<=>) ?::public.vector) AS _vector_score
+    ${candidates}) AS ranked ORDER BY ${order.sql} LIMIT ?`;
+  const args = [JSON.stringify(values), ...candidateArgs, query.k];
+  return {
+    sql,
+    args,
+    totalSql: `SELECT COUNT(*)::bigint AS total FROM (SELECT 1 ${candidates} LIMIT ?) AS eligible`,
+    totalArgs: [...candidateArgs, query.k],
+    order,
+    vectorProbe: {
+      sql: `SELECT COUNT(*)::bigint AS total FROM (SELECT 1 ${candidates} LIMIT ?) AS candidates`,
+      args: [...candidateArgs, limit + 1],
+      limit
+    },
+    hasMore: () => false,
+    trimRows: identityRows,
+    nextPageToken: () => {
+      return;
+    }
+  };
 }
 function compileStart(projectId, query, ctx) {
   if (query.includeSubtypes === true) {
@@ -7578,6 +7748,7 @@ function compileWhere(projectId, inputQuery, predicate, ctx) {
       WHERE ${predicate.sql}
     `,
     totalArgs: [...input.args, ...predicate.args],
+    vectorProbe: input.vectorProbe,
     order: input.order,
     hasMore: () => false,
     trimRows: identityRows,
@@ -7604,7 +7775,7 @@ function compileSort(projectId, inputQuery, fields, ctx) {
         input.created_at,
         input.updated_at,
         input.version,
-        input.last_commit_id
+        input.last_commit_id${input.vectorProbe ? ", input._vector_score" : ""}
       FROM (${input.sql}) AS input
       ORDER BY ${order.sql}
     `,
@@ -7635,6 +7806,7 @@ function compileLimit(projectId, inputQuery, rawLimit, ctx) {
       FROM (${input.sql}) AS input
     `,
     totalArgs: input.args,
+    vectorProbe: input.vectorProbe,
     order: input.order,
     hasMore: (rowCount, total) => total === undefined ? ctx.probeLimit && rowCount > limit : limit < total,
     trimRows: ctx.probeLimit ? (rows) => rows.slice(0, limit) : identityRows,
@@ -7663,6 +7835,7 @@ function compilePage(projectId, inputQuery, rawPageSize, pageToken, ctx) {
       FROM (${input.sql}) AS input
     `,
     totalArgs: input.args,
+    vectorProbe: input.vectorProbe,
     order: input.order,
     hasMore: (rowCount) => rowCount > pageSize,
     trimRows: (rows) => rows.slice(0, pageSize),
@@ -7739,6 +7912,7 @@ function compileExpand(projectId, inputQuery, expansions, ctx) {
     args: [...expand.args, ...input.args, ...inputOrder.args],
     totalSql: input.totalSql,
     totalArgs: input.totalArgs,
+    vectorProbe: input.vectorProbe,
     order: input.order,
     hasMoreProbe: input.hasMoreProbe,
     hasMore: input.hasMore,
@@ -7904,13 +8078,14 @@ function compileProject(projectId, inputQuery, properties, ctx) {
         input.created_at,
         input.updated_at,
         input.version,
-        input.last_commit_id
+        input.last_commit_id${input.vectorProbe ? ", input._vector_score" : ""}
       FROM (${input.sql}) AS input
       ORDER BY ${inputOrder.sql}
     `,
     args: [...projection.args, ...input.args, ...inputOrder.args],
     totalSql: input.totalSql,
     totalArgs: input.totalArgs,
+    vectorProbe: input.vectorProbe,
     order: outputOrder,
     hasMoreProbe: input.hasMoreProbe,
     hasMore: input.hasMore,
@@ -7941,7 +8116,7 @@ function compileAggregateSource(projectId, query, source) {
     case "page":
       return compileRowQueryAggregateSource(projectId, query, source);
     case "vector":
-      throw new Error(`[SixbPg] PostgreSQL object storage does not support query node '${query.kind}'`);
+      return compileRowQueryAggregateSource(projectId, query, source);
   }
 }
 function compileAggregateStart(projectId, query, source) {
@@ -8310,7 +8485,7 @@ function compileOrder(fields, qualifier, propertyColumn = "properties") {
   const args = [];
   for (const field of fields) {
     if (field.kind === "column") {
-      clauses.push(`${columnExpression(field.column, qualifier)} ${field.direction.toUpperCase()}`);
+      clauses.push(`${columnExpression(field.column, qualifier)}${field.binary ? ' COLLATE "C"' : ""} ${field.direction.toUpperCase()}`);
       continue;
     }
     const direction = field.direction === "desc" ? "DESC" : "ASC";
@@ -8519,6 +8694,8 @@ function isPlainObject(value) {
 }
 
 // src/objects/reader.ts
+import { ObjectQueryExecutionError as ObjectQueryExecutionError2 } from "@sixb/core";
+import { hasVectorProfile as hasVectorProfile2 } from "@sixb/core/internal/query";
 import { linkBatchKey, objectBatchKey } from "@sixb/core/storage";
 
 // src/objects/rows.ts
@@ -8535,7 +8712,10 @@ function rowToObject(row) {
   };
 }
 function queryRowToObject(row) {
-  const base = rowToObject(row);
+  const base = {
+    ...rowToObject(row),
+    ...row._vector_score === undefined ? {} : { score: row._vector_score }
+  };
   const links = reviveExpandedLinks(row._expand);
   return links ? { ...base, links } : base;
 }
@@ -8610,7 +8790,23 @@ class PgObjectReader {
     this.sql = sql;
     this.source = source;
   }
+  async assertVectorSearch(params) {
+    if (!hasVectorProfile2(params.query))
+      return;
+    const compiled = compilePgObjectQuery(params.projectId, params.query, { source: this.source });
+    if (!compiled.vectorProbe)
+      return;
+    const extensions = await this.sql.unsafe("SELECT EXISTS (SELECT 1 FROM pg_extension e JOIN pg_namespace n ON n.oid = e.extnamespace WHERE e.extname = 'vector' AND n.nspname = 'public') AS ready");
+    if (!extensions[0]?.ready)
+      throw new ObjectQueryExecutionError2("vector_extension_missing", "PostgreSQL vector search requires pgvector installed in schema public (CREATE EXTENSION vector WITH SCHEMA public).");
+    const probe = compiled.vectorProbe;
+    const [row] = await this.sql.unsafe(probe.sql, probe.args);
+    if (Number(row?.total ?? 0) > probe.limit) {
+      throw new ObjectQueryExecutionError2("vector_work_limit_exceeded", `Exact vector search supports at most ${probe.limit} eligible vectors at this dimension. Narrow the query filters.`);
+    }
+  }
   async queryObjects(params) {
+    await this.assertVectorSearch(params);
     const sql = this.sql;
     const source = this.source;
     const compiled = compilePgObjectQuery(params.projectId, params.query, {
@@ -8629,6 +8825,7 @@ class PgObjectReader {
     };
   }
   async countObjects(params) {
+    await this.assertVectorSearch(params);
     const sql = this.sql;
     const source = this.source;
     const compiled = compilePgObjectCountQuery(params.projectId, stripOuterRowShape(params.query), {
@@ -8638,6 +8835,7 @@ class PgObjectReader {
     return { count: Number(row?.count ?? 0) };
   }
   async existsObjects(params) {
+    await this.assertVectorSearch(params);
     const sql = this.sql;
     const source = this.source;
     const compiled = compilePgObjectExistsQuery(params.projectId, stripOuterRowShape(params.query), { source });
@@ -8645,6 +8843,7 @@ class PgObjectReader {
     return { exists: row !== undefined };
   }
   async facetObjects(params) {
+    await this.assertVectorSearch(params);
     const sql = this.sql;
     const source = this.source;
     const facets = [];
@@ -9032,6 +9231,7 @@ ${sql}`,
     wrapQuery: (query) => ({
       ...query,
       ...wrapStatement(query.sql, query.args),
+      vectorProbe: query.vectorProbe ? { ...query.vectorProbe, ...wrapStatement(query.vectorProbe.sql, query.vectorProbe.args) } : undefined,
       totalSql: `${compiled.sql}
 ${query.totalSql}`,
       totalArgs: [...compiled.args, ...query.totalArgs],
@@ -9153,32 +9353,29 @@ function compileSelectedReadScopeCte(scopeJson, projectId) {
         SELECT DISTINCT project_id, object_type_id, primary_id
         FROM _sixb_scope_reachable
       ),
+      _sixb_scope_object_grants AS (
+        SELECT reachable.project_id, reachable.object_type_id, reachable.primary_id,
+          array_agg(DISTINCT selected_property.value) FILTER (WHERE selected_property.value IS NOT NULL) AS property_ids
+        FROM _sixb_scope_reachable AS reachable
+        LEFT JOIN _sixb_scope_object_selections AS selection
+          ON selection.node_id = reachable.node_id
+         AND selection.object_type_id = reachable.object_type_id
+        LEFT JOIN LATERAL jsonb_array_elements_text(selection.property_ids) AS selected_property(value) ON true
+        GROUP BY reachable.project_id, reachable.object_type_id, reachable.primary_id
+      ),
       _sixb_scope_objects AS (
-        SELECT
-          stored.project_id,
-          stored.object_type_id,
-          stored.primary_id,
-          COALESCE(
-            (
-              SELECT jsonb_object_agg(property.key, property.value)
-              FROM jsonb_each(stored.properties) AS property(key, value)
-              JOIN _sixb_scope_object_permissions AS permission
-                ON permission.project_id = stored.project_id
-               AND permission.object_type_id = stored.object_type_id
-               AND permission.primary_id = stored.primary_id
-               AND permission.property_id = property.key
-            ),
-            '{}'::jsonb
-          ) AS properties,
-          stored.created_at,
-          stored.updated_at,
-          stored.version,
-          stored.last_commit_id
-        FROM objects AS stored
-        JOIN _sixb_scope_object_ids AS visible
-          ON visible.project_id = stored.project_id
-         AND visible.object_type_id = stored.object_type_id
-         AND visible.primary_id = stored.primary_id
+        SELECT stored.project_id, stored.object_type_id, stored.primary_id,
+          COALESCE((
+            SELECT jsonb_object_agg(property.key, property.value)
+            FROM jsonb_each(stored.properties) AS property(key, value)
+            WHERE property.key = ANY(grants.property_ids)
+          ), '{}'::jsonb) AS properties,
+          stored.created_at, stored.updated_at, stored.version, stored.last_commit_id
+        FROM _sixb_scope_object_grants AS grants
+        JOIN objects AS stored
+          ON stored.project_id = grants.project_id
+         AND stored.object_type_id = grants.object_type_id
+         AND stored.primary_id = grants.primary_id
       ),
       _sixb_scope_reached_links(
         project_id,
@@ -9385,6 +9582,7 @@ var PG_OBJECT_QUERY_CAPABILITIES = {
     refs: true,
     filter: true,
     text: true,
+    vector: true,
     sort: true,
     limit: true,
     page: true,
@@ -9437,7 +9635,7 @@ var PG_OBJECT_QUERY_CAPABILITIES = {
     "PostgreSQL object query pushdown supports start/refs/filter/text/sort/limit/page/traverse/set/project/expand over JSONB properties and object links.",
     "expand hydrates linked objects in-database (top-N per parent via LATERAL + jsonb_agg); core resolves each expansion's cardinality before pushdown, and a mixed/unresolved one stays on the fallback.",
     "Exact decimal predicates, ordering, and keyset pagination use PostgreSQL numeric casts.",
-    "Relevance sorting, vector search, and unresolved start.includeSubtypes remain planner fallback or rejection cases."
+    "Relevance sorting and unresolved start.includeSubtypes remain planner fallback or rejection cases."
   ]
 };
 
@@ -9455,15 +9653,23 @@ class PgObjectStorage {
     return createPgSelectedReader(this.sql, params, () => this.queryCapabilities());
   }
   async queryObjects(params) {
+    if (hasVectorProfile3(params.query))
+      return runPgRepeatableReadTransaction(this.sql, (tx) => new PgObjectReader(tx, DEFAULT_OBJECT_QUERY_SOURCE).queryObjects(params));
     return this.reader.queryObjects(params);
   }
   async countObjects(params) {
+    if (hasVectorProfile3(params.query))
+      return runPgRepeatableReadTransaction(this.sql, (tx) => new PgObjectReader(tx, DEFAULT_OBJECT_QUERY_SOURCE).countObjects(params));
     return this.reader.countObjects(params);
   }
   async existsObjects(params) {
+    if (hasVectorProfile3(params.query))
+      return runPgRepeatableReadTransaction(this.sql, (tx) => new PgObjectReader(tx, DEFAULT_OBJECT_QUERY_SOURCE).existsObjects(params));
     return this.reader.existsObjects(params);
   }
   async facetObjects(params) {
+    if (hasVectorProfile3(params.query))
+      return runPgRepeatableReadTransaction(this.sql, (tx) => new PgObjectReader(tx, DEFAULT_OBJECT_QUERY_SOURCE).facetObjects(params));
     return this.reader.facetObjects(params);
   }
   async getByPrimaryId(params) {
@@ -9766,6 +9972,7 @@ import {
   linkRefSortKey,
   linkScopeSortKey as linkScopeSortKey2,
   MaterializationConflictError as MaterializationConflictError6,
+  MaterializationValidationError as MaterializationValidationError2,
   objectRefKey as objectRefKey3,
   objectRefSortKey,
   telemetryPointKey as telemetryPointKey3,
@@ -11692,6 +11899,12 @@ class PgOntologyMaterializationStorage {
     this.sessions = new PgMaterializationSessions(sql, context);
     this.writer = new PgMaterializationWriter(sql);
   }
+  assertVectorSession(session, projectId, commitId) {
+    const active = this.sessions.require(session);
+    if (active.header.commit.projectId !== projectId || commitId !== undefined && active.header.commit.id !== commitId) {
+      throw new MaterializationValidationError2("Vector mutation does not belong to this materialization session.");
+    }
+  }
   async begin(input) {
     assertMaterializationHeader(input);
     const session = await this.sessions.create(input);
@@ -12299,7 +12512,7 @@ function databaseCount(value) {
 import { serializeSixbFailure as serializeSixbFailure2 } from "@sixb/core/internal/errors";
 import {
   MaterializationConflictError as MaterializationConflictError7,
-  MaterializationValidationError as MaterializationValidationError2
+  MaterializationValidationError as MaterializationValidationError3
 } from "@sixb/core/internal/materialization";
 import { ONTOLOGY_OUTBOX_FAILURE_CODES as ONTOLOGY_OUTBOX_FAILURE_CODES2 } from "@sixb/core/storage";
 class PgOntologyOutboxStorage {
@@ -12315,7 +12528,7 @@ class PgOntologyOutboxStorage {
       const leaseExpiry = assertTimestamp(input.leaseExpiresAt, "Ontology outbox lease expiry");
       assertNonblank(input.leaseId, "Ontology outbox lease id");
       if (leaseExpiry <= now) {
-        throw new MaterializationValidationError2("Ontology outbox lease expiry must be later than the claim time.");
+        throw new MaterializationValidationError3("Ontology outbox lease expiry must be later than the claim time.");
       }
       const rows = await sql`
         WITH candidates AS (
@@ -12466,7 +12679,7 @@ function validateLeaseIds(ids) {
   for (const id of ids) {
     assertNonblank(id, "Ontology outbox event id");
     if (seen.has(id)) {
-      throw new MaterializationValidationError2(`Ontology outbox lease batch repeats event '${id}'.`);
+      throw new MaterializationValidationError3(`Ontology outbox lease batch repeats event '${id}'.`);
     }
     seen.add(id);
   }
@@ -12481,7 +12694,7 @@ function leaseConflict() {
 }
 
 // src/ontology-storage/sources.ts
-import { MaterializationValidationError as MaterializationValidationError3 } from "@sixb/core/internal/materialization";
+import { MaterializationValidationError as MaterializationValidationError4 } from "@sixb/core/internal/materialization";
 import {
   assertSourceBeginInput as assertBeginInput,
   assertSourceExecutionIdentity as assertExecutionIdentity,
@@ -12641,7 +12854,7 @@ class PgOntologySourceStorage {
         throw sourceConflict(`Source materialization '${input.materializationId}' cannot transition from '${manifest.status}' to 'ready'.`);
       }
       if (input.readyAt < toIsoString2(manifest.created_at)) {
-        throw new MaterializationValidationError3("Source readyAt cannot precede source createdAt.");
+        throw new MaterializationValidationError4("Source readyAt cannot precede source createdAt.");
       }
       if (input.assertionCount >= 1000 || input.rootCount >= 1000) {
         await sql`ANALYZE ontology_source_rows, ontology_source_roots`;
@@ -12739,7 +12952,7 @@ class PgOntologySourceStorage {
   }
   async transitionToAbandoned(sql, manifest, abandonedAt) {
     if (abandonedAt < toIsoString2(manifest.created_at) || manifest.ready_at !== null && abandonedAt < toIsoString2(manifest.ready_at)) {
-      throw new MaterializationValidationError3("Source abandonedAt cannot precede source creation or readiness.");
+      throw new MaterializationValidationError4("Source abandonedAt cannot precede source creation or readiness.");
     }
     const rows = await sql`
       UPDATE ontology_sources
@@ -12777,7 +12990,7 @@ class PgOntologySourceStorage {
     const minimum = counts?.min_ordinal === null ? null : Number(counts?.min_ordinal);
     const maximum = counts?.max_ordinal === null ? null : Number(counts?.max_ordinal);
     if (assertions !== assertionCount || roots !== rootCount || ordinals !== rootCount || rootCount > 0 && (minimum !== 0 || maximum !== rootCount - 1)) {
-      throw new MaterializationValidationError3("Source ready counts do not match the staged roots and assertions.");
+      throw new MaterializationValidationError4("Source ready counts do not match the staged roots and assertions.");
     }
     await assertSourceRootCoverage(sql, manifest);
     const [invalid] = manifest.projection_kind === "link" ? await sql`
@@ -12813,7 +13026,7 @@ class PgOntologySourceStorage {
             LIMIT 1
           `;
     if (invalid) {
-      throw new MaterializationValidationError3(manifest.projection_kind === "link" ? "Link projection roots must contain exactly their matching link assertion." : "Object projection roots must contain exactly their matching object assertion plus links sourced from that root.");
+      throw new MaterializationValidationError4(manifest.projection_kind === "link" ? "Link projection roots must contain exactly their matching link assertion." : "Object projection roots must contain exactly their matching object assertion plus links sourced from that root.");
     }
   }
   async findStageRows(sql, input, rows) {
@@ -12945,17 +13158,300 @@ function numberOrNull(value) {
   return value === null ? null : Number(value);
 }
 
+// src/ontology-storage/vector-indexing.ts
+import { parseSixbFailure as parseSixbFailure3 } from "@sixb/core/internal/errors";
+import {
+  VECTOR_INDEXING_FAILURE_CODES
+} from "@sixb/core/storage";
+class PgVectorIndexingStorage {
+  sql;
+  run;
+  assertSession;
+  constructor(sql, run, assertSession) {
+    this.sql = sql;
+    this.run = run;
+    this.assertSession = assertSession;
+  }
+  async schedule(input) {
+    this.assertSession(input.session, input.projectId);
+    if (input.deleted.length)
+      await this.sql`
+      DELETE FROM object_vector_indexing AS work
+      USING jsonb_array_elements(${jsonParameter2(this.sql, input.deleted)}::jsonb) AS deleted(ref)
+      WHERE work.project_id = ${input.projectId}
+        AND work.object_type_id = deleted.ref->>'objectTypeId'
+        AND work.primary_id = deleted.ref->>'primaryId'
+    `;
+    if (input.requests.length)
+      await this.sql`
+      INSERT INTO object_vector_indexing (
+        project_id, id, object_type_id, primary_id, profile, batch_id, request, status, available_at, dispatch_at
+      )
+      SELECT ${input.projectId}, entry->>'id', entry#>>'{ref,objectTypeId}',
+        entry#>>'{ref,primaryId}', entry->>'profile', entry->>'batchId', entry - 'batchId', 'pending',
+        ${input.availableAt}::timestamptz, ${input.availableAt}::timestamptz
+      FROM jsonb_array_elements(${jsonParameter2(this.sql, input.requests)}::jsonb) AS pending(entry)
+      ON CONFLICT (project_id, object_type_id, primary_id, profile) DO UPDATE SET
+        id = EXCLUDED.id, batch_id = EXCLUDED.batch_id, request = EXCLUDED.request, status = 'pending',
+        available_at = EXCLUDED.available_at, dispatch_at = EXCLUDED.dispatch_at,
+        values_json = NULL, error = NULL
+    `;
+  }
+  async complete(input) {
+    this.assertSession(input.session, input.projectId);
+    if (!input.entries.length)
+      return;
+    await this.sql`
+      DELETE FROM object_vector_indexing AS work
+      USING jsonb_array_elements(${jsonParameter2(this.sql, input.entries)}::jsonb) AS completed(entry)
+      WHERE work.project_id = ${input.projectId}
+        AND work.object_type_id = entry#>>'{ref,objectTypeId}'
+        AND work.primary_id = entry#>>'{ref,primaryId}'
+        AND work.profile = entry->>'profile'
+        AND work.request->>'configuration' = entry->>'configuration'
+        AND work.request->>'sourceFingerprint' = entry->>'sourceFingerprint'
+    `;
+  }
+  async dispatched(input) {
+    if (!input.ids.length)
+      return;
+    await this.run(async (sql) => {
+      await sql`UPDATE object_vector_indexing SET dispatch_at = ${input.nextDispatchAt} WHERE project_id = ${input.projectId} AND id = ANY(${sql.array([...input.ids])}::text[])`;
+    });
+  }
+  async get(input) {
+    return this.run(async (sql) => {
+      const rows = await sql`SELECT batch_id, request, status, available_at, values_json, error FROM object_vector_indexing WHERE project_id = ${input.projectId} AND id = ${input.id}`;
+      return rows[0] ? decode(rows[0]) : null;
+    });
+  }
+  async getBatch(input) {
+    return this.run(async (sql) => (await sql`
+      SELECT batch_id, request, status, available_at, values_json, error
+      FROM object_vector_indexing WHERE project_id = ${input.projectId}
+      AND batch_id = ${input.batchId} ORDER BY id`).map(decode));
+  }
+  async getBatchMember(input) {
+    return this.run(async (sql) => {
+      const rows = await sql`
+        SELECT batch_id, request, status, available_at, values_json, error
+        FROM object_vector_indexing WHERE project_id = ${input.projectId}
+        AND object_type_id = ${input.ref.objectTypeId} AND primary_id = ${input.ref.primaryId}
+        AND profile = ${input.profile} AND batch_id = ${input.batchId}`;
+      return rows[0] ? decode(rows[0]) : null;
+    });
+  }
+  async updateBatch(input) {
+    if (!input.updates.length)
+      return true;
+    return this.run(async (sql) => {
+      const rows = await sql`
+        WITH changes AS MATERIALIZED (
+          SELECT item FROM jsonb_array_elements(${jsonParameter2(sql, input.updates)}::jsonb) AS entries(item)
+        ), locked AS MATERIALIZED (
+          SELECT work.id FROM object_vector_indexing AS work
+          JOIN changes ON work.id = item->>'id' AND work.status = item->>'expectedStatus'
+          WHERE work.project_id = ${input.projectId} ORDER BY work.id FOR UPDATE OF work
+        )
+        UPDATE object_vector_indexing AS work SET
+          status = changes.item->>'status', available_at = (changes.item->>'availableAt')::timestamptz,
+          values_json = COALESCE(changes.item->'values', work.values_json),
+          error = (changes.item->'error')::text
+        FROM changes, locked
+        WHERE work.project_id = ${input.projectId} AND work.id = locked.id
+          AND work.id = changes.item->>'id'
+          AND (${!input.requireAll} OR (SELECT count(*) FROM locked) = ${input.updates.length})
+        RETURNING work.id`;
+      return !input.requireAll || rows.length === input.updates.length;
+    });
+  }
+  async listDue(input) {
+    return this.run(async (sql) => (await sql`SELECT batch_id, request, status, available_at, NULL AS values_json, error FROM object_vector_indexing WHERE project_id = ${input.projectId} AND status <> 'failed' AND dispatch_at <= ${input.now} ORDER BY dispatch_at, id LIMIT ${input.limit}`).map(decode));
+  }
+  async update(input) {
+    return this.run(async (sql) => (await sql`
+      UPDATE object_vector_indexing SET status = ${input.status}, available_at = ${input.availableAt},
+      values_json = COALESCE(${input.values ? jsonParameter2(sql, input.values) : null}, values_json), error = ${input.error ? JSON.stringify(input.error) : null}
+      WHERE project_id = ${input.projectId} AND id = ${input.id} AND status = ${input.expectedStatus} RETURNING id
+    `).length === 1);
+  }
+  async remove(input) {
+    await this.run(async (sql) => {
+      await sql`DELETE FROM object_vector_indexing WHERE project_id = ${input.projectId} AND id = ${input.id}`;
+    });
+  }
+}
+function decode(row) {
+  return {
+    ...row.request,
+    ...row.batch_id ? { batchId: row.batch_id } : {},
+    status: row.status,
+    availableAt: new Date(row.available_at).toISOString(),
+    ...row.values_json ? { values: row.values_json } : {},
+    ...row.error ? {
+      error: parseSixbFailure3(row.error, VECTOR_INDEXING_FAILURE_CODES)
+    } : {}
+  };
+}
+
+// src/ontology-storage/vectors.ts
+import { MaterializationConflictError as MaterializationConflictError8 } from "@sixb/core/internal/materialization";
+class PgOntologyVectorStorage {
+  sql;
+  runRootOperation;
+  assertSession;
+  constructor(sql, runRootOperation, assertSession) {
+    this.sql = sql;
+    this.runRootOperation = runRootOperation;
+    this.assertSession = assertSession;
+  }
+  async list(input) {
+    return this.runRootOperation(async (sql) => {
+      const rows = await sql`
+        SELECT profile, configuration, source, source_fingerprint, last_commit_id
+        FROM object_vectors
+        WHERE project_id = ${input.projectId}
+          AND object_type_id = ${input.ref.objectTypeId} AND primary_id = ${input.ref.primaryId}
+        ORDER BY profile
+      `;
+      return rows.map((row) => ({
+        ref: { ...input.ref },
+        profile: row.profile,
+        configuration: row.configuration,
+        source: row.source,
+        sourceFingerprint: row.source_fingerprint,
+        lastCommitId: row.last_commit_id
+      }));
+    });
+  }
+  async listBatch(input) {
+    if (!input.refs.length)
+      return [];
+    return this.runRootOperation(async (sql) => {
+      const rows = await sql`
+        SELECT stored.object_type_id, stored.primary_id, stored.profile, stored.configuration,
+          stored.source, stored.source_fingerprint, stored.last_commit_id
+        FROM (SELECT DISTINCT ref->>'objectTypeId' AS object_type_id, ref->>'primaryId' AS primary_id
+          FROM jsonb_array_elements(${jsonParameter2(sql, input.refs)}::jsonb) AS requested(ref)) AS requested
+        JOIN object_vectors AS stored ON stored.project_id = ${input.projectId}
+          AND stored.object_type_id = requested.object_type_id AND stored.primary_id = requested.primary_id
+        ORDER BY stored.object_type_id, stored.primary_id, stored.profile
+      `;
+      return rows.map((row) => ({
+        ref: { objectTypeId: row.object_type_id, primaryId: row.primary_id },
+        profile: row.profile,
+        configuration: row.configuration,
+        source: row.source,
+        sourceFingerprint: row.source_fingerprint,
+        lastCommitId: row.last_commit_id
+      }));
+    });
+  }
+  async removeBatch(input) {
+    this.assertSession(input.session, input.projectId);
+    if (!input.entries.length)
+      return;
+    const removed = await this.sql`
+      DELETE FROM object_vectors AS stored
+      USING jsonb_array_elements(${jsonParameter2(this.sql, input.entries)}::jsonb) AS requested(entry)
+      WHERE stored.project_id = ${input.projectId}
+        AND stored.object_type_id = entry#>>'{ref,objectTypeId}'
+        AND stored.primary_id = entry#>>'{ref,primaryId}' AND stored.profile = entry->>'profile'
+        AND stored.last_commit_id = entry->>'expectedCommitId'
+      RETURNING stored.profile
+    `;
+    if (removed.length !== input.entries.length)
+      throw vectorConflict();
+  }
+  async write(input) {
+    await this.writeBatch({ session: input.session, projectId: input.projectId, entries: [input] });
+  }
+  async writeBatch(input) {
+    const entries = input.entries.map(({ value, expectedCommitId }) => {
+      this.assertSession(input.session, input.projectId, value.lastCommitId);
+      return {
+        object_type_id: value.ref.objectTypeId,
+        primary_id: value.ref.primaryId,
+        profile: value.profile,
+        configuration: value.configuration,
+        source: [...value.source],
+        source_fingerprint: value.sourceFingerprint,
+        embedding: [...value.values],
+        last_commit_id: value.lastCommitId,
+        expected_commit_id: expectedCommitId
+      };
+    });
+    const inserts = entries.filter((entry) => entry.expected_commit_id === null);
+    const updates = entries.filter((entry) => entry.expected_commit_id !== null);
+    if (inserts.length) {
+      const rows = await this.sql`
+        INSERT INTO object_vectors (
+          project_id, object_type_id, primary_id, profile, configuration,
+          source, source_fingerprint, embedding, last_commit_id
+        )
+        SELECT ${input.projectId}, object_type_id, primary_id, profile, configuration,
+          source, source_fingerprint, embedding, last_commit_id
+        FROM jsonb_to_recordset(${jsonParameter2(this.sql, inserts)}::jsonb) AS incoming(
+          object_type_id text, primary_id text, profile text, configuration text,
+          source text[], source_fingerprint text, embedding real[], last_commit_id text
+        )
+        ORDER BY object_type_id, primary_id, profile
+        ON CONFLICT (project_id, object_type_id, primary_id, profile) DO NOTHING
+        RETURNING profile`;
+      if (rows.length !== inserts.length)
+        throw vectorConflict();
+    }
+    if (updates.length) {
+      const rows = await this.sql`
+        UPDATE object_vectors AS stored SET
+          configuration = incoming.configuration, source = incoming.source,
+          source_fingerprint = incoming.source_fingerprint, embedding = incoming.embedding,
+          last_commit_id = incoming.last_commit_id
+        FROM jsonb_to_recordset(${jsonParameter2(this.sql, updates)}::jsonb) AS incoming(
+          object_type_id text, primary_id text, profile text, configuration text,
+          source text[], source_fingerprint text, embedding real[], last_commit_id text,
+          expected_commit_id text
+        )
+        WHERE stored.project_id = ${input.projectId}
+          AND stored.object_type_id = incoming.object_type_id AND stored.primary_id = incoming.primary_id
+          AND stored.profile = incoming.profile AND stored.last_commit_id = incoming.expected_commit_id
+        RETURNING stored.profile`;
+      if (rows.length !== updates.length)
+        throw vectorConflict();
+    }
+  }
+  async remove(input) {
+    this.assertSession(input.session, input.projectId);
+    const rows = await this.sql`
+      DELETE FROM object_vectors
+      WHERE project_id = ${input.projectId}
+        AND object_type_id = ${input.ref.objectTypeId} AND primary_id = ${input.ref.primaryId}
+        AND profile = ${input.profile} AND last_commit_id = ${input.expectedCommitId}
+      RETURNING profile
+    `;
+    if (rows.length !== 1)
+      throw vectorConflict();
+  }
+}
+function vectorConflict() {
+  return new MaterializationConflictError8("effective-state", "Vector changed since it was prepared.");
+}
+
 // src/ontology-storage/index.ts
 class PgOntologyStorage {
   commits;
   sources;
   materializations;
   outbox;
+  vectorIndexing;
+  vectors;
   constructor(input) {
     this.commits = new PgOntologyCommitStorage(input.runRootOperation);
     this.sources = new PgOntologySourceStorage(input.runRootOperation);
     this.materializations = new PgOntologyMaterializationStorage(input.sql, input.transactionContext);
     this.outbox = new PgOntologyOutboxStorage(input.runRootOperation);
+    this.vectorIndexing = new PgVectorIndexingStorage(input.sql, input.runRootOperation, (session, projectId) => this.materializations.assertVectorSession(session, projectId));
+    this.vectors = new PgOntologyVectorStorage(input.sql, input.runRootOperation, (session, projectId, commitId) => this.materializations.assertVectorSession(session, projectId, commitId));
   }
   deactivateSessions() {
     this.materializations.deactivateSessions();
@@ -13925,6 +14421,8 @@ class PgAiCostStorage {
         COUNT(*)::text AS model_call_count,
         COUNT(*) FILTER (WHERE reporting_status <> 'unavailable')::text
           AS reported_usage_call_count,
+        COUNT(*) FILTER (WHERE input_tokens IS NOT NULL AND output_tokens IS NOT NULL)::text
+          AS complete_usage_call_count,
         COUNT(input_tokens)::text AS input_tokens_count,
         SUM(input_tokens)::text AS input_tokens_sum,
         COUNT(output_tokens)::text AS output_tokens_count,
@@ -14066,6 +14564,7 @@ function aggregateFragmentFromRow(row) {
     modelCallCount: row.model_call_count,
     usage: {
       reportedCallCount: row.reported_usage_call_count,
+      completeCallCount: row.complete_usage_call_count,
       inputTokens: meterFragment(row.input_tokens_count, row.input_tokens_sum),
       outputTokens: meterFragment(row.output_tokens_count, row.output_tokens_sum),
       uncachedInputTokens: meterFragment(row.uncached_input_tokens_count, row.uncached_input_tokens_sum),
@@ -15049,7 +15548,7 @@ function toStorageRow(row) {
 }
 
 // src/pg-pipeline-run-storage.ts
-import { parseSixbFailure as parseSixbFailure3, serializeSixbFailure as serializeSixbFailure3 } from "@sixb/core/internal/errors";
+import { parseSixbFailure as parseSixbFailure4, serializeSixbFailure as serializeSixbFailure3 } from "@sixb/core/internal/errors";
 import { assertPipelineRunExecution } from "@sixb/core/internal/pipeline-run-storage-provider";
 import { canRequeuePipelineRunAfterEnqueueFailure } from "@sixb/core/internal/storage";
 import { PIPELINE_RUN_FAILURE_CODES, PipelineRunError } from "@sixb/core/storage";
@@ -15403,7 +15902,7 @@ function rowToPipelineRunRecord(row) {
       datasetId: row.output_dataset_id,
       versionId: row.output_version_id
     } : undefined,
-    error: row.error === null ? undefined : parseSixbFailure3(row.error, PIPELINE_RUN_FAILURE_CODES)
+    error: row.error === null ? undefined : parseSixbFailure4(row.error, PIPELINE_RUN_FAILURE_CODES)
   };
 }
 function rowToPipelineStepRunRecord(row) {
@@ -15424,7 +15923,7 @@ function rowToPipelineStepRunRecord(row) {
       versionId: row.output_version_id
     } : undefined,
     rowsWritten: row.rows_written != null ? Number(row.rows_written) : undefined,
-    error: row.error === null ? undefined : parseSixbFailure3(row.error, PIPELINE_RUN_FAILURE_CODES)
+    error: row.error === null ? undefined : parseSixbFailure4(row.error, PIPELINE_RUN_FAILURE_CODES)
   };
 }
 function parseDatasetVersionRefs(value) {
@@ -16150,7 +16649,7 @@ function toIsoString3(value) {
 }
 
 // src/pg-sync-run-storage.ts
-import { parseSixbFailure as parseSixbFailure4, serializeSixbFailure as serializeSixbFailure5 } from "@sixb/core/internal/errors";
+import { parseSixbFailure as parseSixbFailure5, serializeSixbFailure as serializeSixbFailure5 } from "@sixb/core/internal/errors";
 import { canRequeueSyncRunAfterEnqueueFailure } from "@sixb/core/internal/storage";
 import { assertSyncRunExecution } from "@sixb/core/internal/sync-run-storage-provider";
 import { SYNC_RUN_FAILURE_CODES, SyncRunError } from "@sixb/core/storage";
@@ -16376,7 +16875,7 @@ function rowToSyncRunRecord(row) {
     } : undefined,
     expectedLatestVersionId: row.expected_latest_version_id ?? undefined,
     commitMessage: row.commit_message ?? undefined,
-    error: row.error === null ? undefined : parseSixbFailure4(row.error, SYNC_RUN_FAILURE_CODES),
+    error: row.error === null ? undefined : parseSixbFailure5(row.error, SYNC_RUN_FAILURE_CODES),
     checkpoint: hasCheckpoint(row) ? row.checkpoint : undefined
   };
 }
@@ -16501,7 +17000,7 @@ function rowToPoint(row) {
 }
 
 // src/pg-webhook-run-storage.ts
-import { parseSixbFailure as parseSixbFailure5, serializeSixbFailure as serializeSixbFailure6 } from "@sixb/core/internal/errors";
+import { parseSixbFailure as parseSixbFailure6, serializeSixbFailure as serializeSixbFailure6 } from "@sixb/core/internal/errors";
 import { assertWebhookRunExecution } from "@sixb/core/internal/webhook-run-storage-provider";
 import { canRetryWebhookRun, WEBHOOK_RUN_FAILURE_CODES, WebhookRunError } from "@sixb/core/storage";
 class PgWebhookRunStorage {
@@ -16655,7 +17154,7 @@ function rowToWebhookRunRecord(row) {
     requestBodySha256: row.request_body_sha256,
     responseStatus: row.response_status != null ? Number(row.response_status) : undefined,
     idempotencyKey: row.idempotency_key ?? undefined,
-    error: row.error === null ? undefined : parseSixbFailure5(row.error, WEBHOOK_RUN_FAILURE_CODES)
+    error: row.error === null ? undefined : parseSixbFailure6(row.error, WEBHOOK_RUN_FAILURE_CODES)
   };
 }
 
@@ -16899,7 +17398,7 @@ function assertNonNegativeInteger(value, fieldName) {
 }
 
 // src/pg-workflow-run-storage.ts
-import { parseSixbFailure as parseSixbFailure6, serializeSixbFailure as serializeSixbFailure7 } from "@sixb/core/internal/errors";
+import { parseSixbFailure as parseSixbFailure7, serializeSixbFailure as serializeSixbFailure7 } from "@sixb/core/internal/errors";
 import {
   assertWorkflowAgentNodeRunExecution,
   assertWorkflowRunExecution
@@ -17541,7 +18040,7 @@ function rowToWorkflowRunRecord(row) {
     queuedAt: row.queued_at ? new Date(row.queued_at) : undefined,
     startedAt: new Date(row.started_at),
     finishedAt: row.finished_at ? new Date(row.finished_at) : undefined,
-    error: row.error === null ? undefined : parseSixbFailure6(row.error, WORKFLOW_RUN_FAILURE_CODES),
+    error: row.error === null ? undefined : parseSixbFailure7(row.error, WORKFLOW_RUN_FAILURE_CODES),
     attempt: Number(row.attempt),
     ...row.execution_token && row.execution_queue_lease_expires_at ? {
       execution: {
@@ -17566,7 +18065,7 @@ function rowToWorkflowNodeRunRecord(row) {
     startedAt: new Date(row.started_at),
     finishedAt: row.finished_at ? new Date(row.finished_at) : undefined,
     output: row.output ? parseRecord2(row.output) : undefined,
-    error: row.error === null ? undefined : parseSixbFailure6(row.error, WORKFLOW_RUN_FAILURE_CODES)
+    error: row.error === null ? undefined : parseSixbFailure7(row.error, WORKFLOW_RUN_FAILURE_CODES)
   };
 }
 function assertNonNegativeInteger2(value, fieldName) {
@@ -17608,7 +18107,7 @@ function rowToWorkflowAgentNodeRunRecord(row) {
     ...row.finish_reason ? { finishReason: row.finish_reason } : {},
     ...row.trace ? { trace: parseJson(row.trace) } : {},
     ...row.diagnostics ? { diagnostics: parseJson(row.diagnostics) } : {},
-    ...row.error ? { error: parseSixbFailure6(row.error, AGENT_RUN_FAILURE_CODES3) } : {},
+    ...row.error ? { error: parseSixbFailure7(row.error, AGENT_RUN_FAILURE_CODES3) } : {},
     attempt: Number(row.attempt),
     ...row.execution_token && row.execution_queue_lease_expires_at ? {
       execution: {
@@ -18120,4 +18619,4 @@ export {
   migratePostgresStorage
 };
 
-//# debugId=0CAAAAC02FB5CFD864756E2164756E21
+//# debugId=C35F49117A3070E564756E2164756E21