@sixb/sqlite 0.1.11 → 0.1.12

package/dist/index.js

@@ -3990,6 +3990,246 @@ CREATE INDEX idx_ontology_outbox_publication_order
   WHERE published_at IS NULL;
 `;
 
+// src/migrations/041-agent-thread-workspaces.sql
+var _041_agent_thread_workspaces_default = `ALTER TABLE agent_threads ADD COLUMN sandbox_params TEXT
+  CHECK (sandbox_params IS NULL OR (json_valid(sandbox_params) AND json_type(sandbox_params) = 'object'));
+`;
+
+// src/migrations/042-vector-profiles.sql
+var _042_vector_profiles_default = `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(trim(profile)) > 0),
+  configuration TEXT NOT NULL,
+  source TEXT NOT NULL CHECK (
+    json_valid(source) AND json_type(source) = 'array' AND json_array_length(source) > 0
+  ),
+  source_fingerprint TEXT NOT NULL,
+  embedding BLOB NOT NULL CHECK (
+    typeof(embedding) = 'blob' AND length(embedding) BETWEEN 4 AND 64000
+    AND length(embedding) % 4 = 0
+  ),
+  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
+);
+`;
+
+// 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 TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('pending', 'running', 'ready', 'failed')),
+  available_at TEXT NOT NULL,
+  dispatch_at TEXT NOT NULL,
+  values_json TEXT,
+  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';
+
+CREATE TABLE executions_v2 (
+  project_id TEXT NOT NULL CHECK (length(trim(project_id)) > 0),
+  id TEXT NOT NULL CHECK (length(trim(id)) > 0),
+  executor_kind TEXT NOT NULL CHECK (
+    executor_kind IN (
+      'request', 'action', 'pipeline', 'projection', 'rule', 'sync', 'webhook', 'workflow',
+      'agent', 'kernel'
+    )
+  ),
+  executor_id TEXT NOT NULL CHECK (length(trim(executor_id)) > 0),
+  source_kind TEXT NOT NULL CHECK (
+    source_kind IN ('http', 'webhook', 'schedule', 'event', 'datasetVersion', 'execution', 'ontologyCommit')
+  ),
+  source_id TEXT NOT NULL CHECK (length(trim(source_id)) > 0),
+  requested_by_user_id TEXT,
+  requested_by_service_account_id TEXT,
+  correlation_id TEXT NOT NULL CHECK (length(trim(correlation_id)) > 0),
+  parent_execution_id TEXT,
+  authority_kind TEXT NOT NULL CHECK (
+    authority_kind IN ('principal', 'trustedPrimitive', 'delegated', 'kernel', 'disabled')
+  ),
+  authority_user_id TEXT,
+  authority_service_account_id TEXT,
+  authority_session_id TEXT,
+  authority_access_token_id TEXT,
+  authority_primitive_kind TEXT CHECK (
+    authority_primitive_kind IS NULL
+      OR authority_primitive_kind IN (
+        'action', 'pipeline', 'projection', 'rule', 'sync', 'webhook', 'workflow'
+      )
+  ),
+  authority_primitive_id TEXT,
+  authority_kernel_operation TEXT CHECK (
+    authority_kernel_operation IS NULL OR authority_kernel_operation IN ('ontology.recover', 'ontology.indexVectors')
+  ),
+  authority_delegation_kind TEXT CHECK (
+    authority_delegation_kind IS NULL OR authority_delegation_kind = 'share'
+  ),
+  authority_delegation_id TEXT,
+  authority_delegation_session_id TEXT,
+  requester_group_ids TEXT NOT NULL DEFAULT '[]',
+  created_at TEXT NOT NULL,
+  PRIMARY KEY (project_id, id),
+  FOREIGN KEY (project_id, parent_execution_id) REFERENCES executions (project_id, id),
+  FOREIGN KEY (project_id, requested_by_user_id) REFERENCES auth_users (project_id, id),
+  FOREIGN KEY (project_id, requested_by_service_account_id)
+    REFERENCES auth_service_accounts (project_id, id),
+  FOREIGN KEY (project_id, authority_user_id) REFERENCES auth_users (project_id, id),
+  FOREIGN KEY (project_id, authority_service_account_id)
+    REFERENCES auth_service_accounts (project_id, id),
+  FOREIGN KEY (project_id, authority_session_id) REFERENCES auth_sessions (project_id, id),
+  FOREIGN KEY (project_id, authority_access_token_id)
+    REFERENCES auth_access_tokens (project_id, id),
+  FOREIGN KEY (
+    project_id, authority_delegation_session_id, authority_delegation_id
+  ) REFERENCES share_sessions (project_id, id, grant_id),
+  CHECK ((requested_by_user_id IS NOT NULL) + (requested_by_service_account_id IS NOT NULL) <= 1),
+  CHECK (
+    (source_kind = 'execution' AND parent_execution_id = source_id)
+      OR (source_kind <> 'execution' AND parent_execution_id IS NULL)
+  ),
+  CHECK (
+    (
+      authority_kind = 'principal'
+      AND (authority_user_id IS NOT NULL) + (authority_service_account_id IS NOT NULL) = 1
+      AND (authority_session_id IS NOT NULL) + (authority_access_token_id IS NOT NULL) <= 1
+      AND (authority_session_id IS NULL OR authority_user_id IS NOT NULL)
+      AND authority_primitive_kind IS NULL
+      AND authority_primitive_id IS NULL
+      AND authority_kernel_operation IS NULL
+      AND authority_delegation_kind IS NULL
+      AND authority_delegation_id IS NULL
+      AND authority_delegation_session_id IS NULL
+    )
+    OR (
+      authority_kind = 'trustedPrimitive'
+      AND authority_user_id IS NULL
+      AND authority_service_account_id IS NULL
+      AND authority_session_id IS NULL
+      AND authority_access_token_id IS NULL
+      AND authority_primitive_kind IS NOT NULL
+      AND authority_primitive_id IS NOT NULL
+      AND length(trim(authority_primitive_id)) > 0
+      AND authority_kernel_operation IS NULL
+      AND authority_delegation_kind IS NULL
+      AND authority_delegation_id IS NULL
+      AND authority_delegation_session_id IS NULL
+    )
+    OR (
+      authority_kind = 'delegated'
+      AND authority_user_id IS NULL
+      AND authority_service_account_id IS NULL
+      AND authority_session_id IS NULL
+      AND authority_access_token_id IS NULL
+      AND authority_primitive_kind IS NULL
+      AND authority_primitive_id IS NULL
+      AND authority_kernel_operation IS NULL
+      AND authority_delegation_kind IS NOT NULL
+      AND authority_delegation_kind = 'share'
+      AND authority_delegation_id IS NOT NULL
+      AND length(trim(authority_delegation_id)) > 0
+      AND authority_delegation_session_id IS NOT NULL
+      AND length(trim(authority_delegation_session_id)) > 0
+    )
+    OR (
+      authority_kind = 'kernel'
+      AND authority_user_id IS NULL
+      AND authority_service_account_id IS NULL
+      AND authority_session_id IS NULL
+      AND authority_access_token_id IS NULL
+      AND authority_primitive_kind IS NULL
+      AND authority_primitive_id IS NULL
+      AND authority_kernel_operation IS NOT NULL
+      AND authority_delegation_kind IS NULL
+      AND authority_delegation_id IS NULL
+      AND authority_delegation_session_id IS NULL
+    )
+    OR (
+      authority_kind = 'disabled'
+      AND authority_user_id IS NULL
+      AND authority_service_account_id IS NULL
+      AND authority_session_id IS NULL
+      AND authority_access_token_id IS NULL
+      AND authority_primitive_kind IS NULL
+      AND authority_primitive_id IS NULL
+      AND authority_kernel_operation IS NULL
+      AND authority_delegation_kind IS NULL
+      AND authority_delegation_id IS NULL
+      AND authority_delegation_session_id IS NULL
+    )
+  ),
+  CHECK (
+    (
+      executor_kind = 'request'
+      AND source_kind = 'http'
+      AND executor_id = source_id
+      AND (
+        (
+          authority_kind = 'principal'
+          AND requested_by_user_id IS authority_user_id
+          AND requested_by_service_account_id IS authority_service_account_id
+        )
+        OR (
+          authority_kind IN ('delegated', 'disabled')
+          AND requested_by_user_id IS NULL
+          AND requested_by_service_account_id IS NULL
+        )
+      )
+    )
+    OR (
+      executor_kind IN ('action', 'pipeline', 'projection', 'rule', 'sync', 'webhook', 'workflow')
+      AND authority_kind = 'trustedPrimitive'
+      AND executor_kind = authority_primitive_kind
+    )
+    OR (
+      executor_kind = 'agent'
+      AND source_kind = 'execution'
+      AND (
+        (
+          authority_kind = 'principal'
+          AND authority_service_account_id IS NOT NULL
+          AND authority_session_id IS NULL
+          AND authority_access_token_id IS NULL
+        )
+        OR (
+          authority_kind = 'principal'
+          AND authority_user_id IS NOT NULL
+          AND (authority_session_id IS NOT NULL) + (authority_access_token_id IS NOT NULL) = 1
+        )
+        OR authority_kind = 'disabled'
+      )
+    )
+    OR (executor_kind = 'kernel' AND authority_kind = 'kernel')
+  )
+);
+
+INSERT INTO executions_v2 (project_id, id, executor_kind, executor_id, source_kind, source_id, requested_by_user_id, requested_by_service_account_id, correlation_id, parent_execution_id, authority_kind, authority_user_id, authority_service_account_id, authority_session_id, authority_access_token_id, authority_primitive_kind, authority_primitive_id, authority_kernel_operation, authority_delegation_kind, authority_delegation_id, authority_delegation_session_id, requester_group_ids, created_at) SELECT project_id, id, executor_kind, executor_id, source_kind, source_id, requested_by_user_id, requested_by_service_account_id, correlation_id, parent_execution_id, authority_kind, authority_user_id, authority_service_account_id, authority_session_id, authority_access_token_id, authority_primitive_kind, authority_primitive_id, authority_kernel_operation, authority_delegation_kind, authority_delegation_id, authority_delegation_session_id, requester_group_ids, created_at FROM executions;
+DROP TABLE executions;
+ALTER TABLE executions_v2 RENAME TO executions;
+`;
+
+// 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 TEXT
+  CHECK (sandbox_state IS NULL OR (json_valid(sandbox_state) AND json_type(sandbox_state) = 'object'));
+`;
+
 // src/migrations/037-execution-requester-groups.sql
 var _037_execution_requester_groups_default = `ALTER TABLE executions ADD COLUMN requester_group_ids TEXT NOT NULL DEFAULT '[]';
 
@@ -4146,7 +4386,12 @@ var sqliteStorageMigrations = defineMigrations({
     sqliteSql("037-execution-requester-groups", _037_execution_requester_groups_default),
     sqliteSql("038-projection-source-roots", _038_projection_source_roots_default),
     sqliteSql("039-connector-optional-pkce", _039_connector_optional_pkce_default),
-    sqliteSql("040-outbox-publication-order", _040_outbox_publication_order_default)
+    sqliteSql("040-outbox-publication-order", _040_outbox_publication_order_default),
+    sqliteSql("041-agent-thread-workspaces", _041_agent_thread_workspaces_default),
+    sqliteSql("042-vector-profiles", _042_vector_profiles_default),
+    sqliteSql("043-vector-indexing", _043_vector_indexing_default),
+    sqliteSql("044-vector-batching", _044_vector_batching_default),
+    sqliteSql("045-agent-thread-sandbox-state", _045_agent_thread_sandbox_state_default)
   ]
 });
 function sqliteStoragePath(basePath) {
@@ -4831,6 +5076,7 @@ import {
 } from "@sixb/core/storage";
 
 // 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,
@@ -4842,6 +5088,10 @@ 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: JSON.parse(row.sandbox_state)
+    },
+    ...row.sandbox_params == null ? {} : { sandboxParams: snapshotAgentThreadSandboxParams(JSON.parse(row.sandbox_params)) },
     status: row.status,
     activeRunId: row.active_run_id,
     lastMessageAt: row.last_message_at ? new Date(row.last_message_at) : undefined,
@@ -5541,6 +5791,10 @@ class SqliteAgentRunStore {
 }
 
 // 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";
@@ -5549,7 +5803,17 @@ class SqliteAgentThreadStore {
   constructor(db) {
     this.db = db;
   }
+  async transitionSandbox(input) {
+    return this.db.transaction(() => {
+      const run = input.action === "recreate" ? null : this.db.query("SELECT * FROM agent_runs WHERE project_id = ? AND id = ?").get(input.projectId, input.runId);
+      const thread = this.requireThread(input.projectId, input.id);
+      const state = transitionAgentThreadSandbox(thread, run ? rowToRunRecord(run) : null, input);
+      this.db.query("UPDATE agent_threads SET sandbox_state = ? WHERE project_id = ? AND id = ?").run(JSON.stringify(state), input.projectId, input.id);
+      return state;
+    }).immediate();
+  }
   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 {
@@ -5560,14 +5824,15 @@ class SqliteAgentThreadStore {
             owner_principal_type,
             owner_principal_id,
             title,
+            sandbox_params,
             status,
             active_run_id,
             last_message_at,
             message_count,
             created_at,
             updated_at
-          ) VALUES (?, ?, ?, ?, ?, ?, NULL, NULL, 0, ?, ?)
-        `).run(input.projectId, input.id, input.ownerPrincipal.type, input.ownerPrincipal.id, input.title ?? null, input.status ?? "active", createdAt.toISOString(), updatedAt.toISOString());
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, NULL, NULL, 0, ?, ?)
+        `).run(input.projectId, input.id, input.ownerPrincipal.type, input.ownerPrincipal.id, input.title ?? null, sandboxParams, input.status ?? "active", createdAt.toISOString(), updatedAt.toISOString());
     } catch (error) {
       if (isUniqueConstraintError2(error)) {
         throw new AgentStorageError4("duplicate_id", `[SixbSqlite] Agent thread '${input.id}' already exists for project '${input.projectId}'.`);
@@ -6188,6 +6453,8 @@ var SQLITE_ACCOUNTING_OVERVIEW_SQL = `
     CAST(COUNT(*) AS TEXT) AS model_call_count,
     CAST(SUM(CASE WHEN reporting_status <> 'unavailable' THEN 1 ELSE 0 END) AS TEXT)
       AS reported_usage_call_count,
+    CAST(SUM(CASE WHEN input_tokens IS NOT NULL AND output_tokens IS NOT NULL THEN 1 ELSE 0 END) AS TEXT)
+      AS complete_usage_call_count,
     CAST(COUNT(input_tokens) AS TEXT) AS input_tokens_count,
     CAST(SUM(input_tokens) AS TEXT) AS input_tokens_sum,
     CAST(COUNT(output_tokens) AS TEXT) AS output_tokens_count,
@@ -6240,6 +6507,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),
@@ -9652,13 +9920,37 @@ function isDuplicateExecutionError(error) {
   return error instanceof Error && error.message.includes("UNIQUE constraint failed: executions.project_id, executions.id");
 }
 
+// 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";
+
+// src/vector-encoding.ts
+function encodeSqliteVector(values) {
+  const bytes = new Uint8Array(values.length * 4);
+  const view = new DataView(bytes.buffer);
+  for (let index = 0;index < values.length; index++) {
+    view.setFloat32(index * 4, values[index], true);
+  }
+  return bytes;
+}
+
+// src/objects/query-compiler.ts
 var PAGE_TOKEN_PREFIX = "keyset:";
 var DEFAULT_EXPANSION_FANOUT = 1000;
 function compileObjectQuery(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 ctx = { probeLimit: options.includeTotal === false, source };
   return source.wrapQuery(compileObjectQueryInternal(projectId, query, ctx));
@@ -9697,8 +9989,59 @@ function compileObjectQueryInternal(projectId, query, ctx) {
     case "expand":
       return compileExpand(projectId, query.input, query.expansions, ctx);
     case "vector":
-      throw new Error(`[Sixb] SQLite 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 ? `CROSS JOIN (
+      SELECT project_id, object_type_id, primary_id, json_group_array(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 NOT EXISTS (
+    SELECT 1 FROM json_each(vectors.source) AS required
+    WHERE required.value NOT IN (SELECT value FROM json_each(vector_permissions.property_ids))
+  )` : "";
+  const candidates = `FROM (${input.sql}) AS input
+    CROSS 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 length(vectors.embedding) / 4 = ? ${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.*, max(-1, min(1, 1 - vec_distance_cosine(vectors.embedding, ?))) AS _vector_score
+    ${candidates}) AS ranked ORDER BY ${order.sql} LIMIT ?`;
+  const args = [encodeSqliteVector(values), ...candidateArgs, query.k];
+  return {
+    sql,
+    args,
+    totalSql: `SELECT COUNT(*) AS total FROM (SELECT 1 ${candidates} LIMIT ?) AS eligible`,
+    totalArgs: [...candidateArgs, query.k],
+    order,
+    vectorProbe: {
+      sql: `SELECT COUNT(*) 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) {
@@ -9788,6 +10131,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,
@@ -9818,7 +10162,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}
     `,
@@ -9849,6 +10193,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,
@@ -9877,6 +10222,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),
@@ -9953,6 +10299,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,
@@ -10123,13 +10470,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,
@@ -10324,7 +10672,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 BINARY" : ""} ${field.direction.toUpperCase()}`);
       continue;
     }
     const direction = field.direction === "desc" ? "DESC" : "ASC";
@@ -10510,6 +10858,8 @@ function isPlainObject(value) {
 }
 
 // src/objects/reader.ts
+import { ObjectQueryExecutionError as ObjectQueryExecutionError3 } from "@sixb/core";
+import { hasVectorProfile as hasVectorProfile2 } from "@sixb/core/internal/query";
 import { linkBatchKey, objectBatchKey } from "@sixb/core/storage";
 
 // src/objects/rows.ts
@@ -10526,7 +10876,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(parseExpandColumn(row._expand));
   return links ? { ...base, links } : base;
 }
@@ -10589,6 +10942,25 @@ function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// src/objects/vector-extension.ts
+import { ObjectQueryExecutionError as ObjectQueryExecutionError2 } from "@sixb/core";
+import { load } from "sqlite-vec";
+var loaded = new WeakSet;
+function ensureSqliteVectorSearch(db) {
+  if (loaded.has(db))
+    return;
+  const options = db.query("PRAGMA compile_options").all();
+  if (options.some((option) => option.compile_options === "OMIT_LOAD_EXTENSION")) {
+    throw new ObjectQueryExecutionError2("vector_extension_missing", "SQLite vector search requires extension support. On macOS install SQLite (brew install sqlite), then call Database.setCustomSQLite with its library path before opening any database.");
+  }
+  try {
+    load(db);
+    loaded.add(db);
+  } catch (cause) {
+    throw new Error("[SixbSqlite] Could not load sqlite-vec for vector search. Check that its native package supports your platform.", { cause });
+  }
+}
+
 // src/objects/reader.ts
 class SqliteObjectReader {
   db;
@@ -10597,7 +10969,21 @@ class SqliteObjectReader {
     this.db = db;
     this.source = source;
   }
+  assertVectorSearch(params) {
+    if (!hasVectorProfile2(params.query))
+      return;
+    const compiled = compileObjectQuery(params.projectId, params.query, { source: this.source });
+    if (!compiled.vectorProbe)
+      return;
+    ensureSqliteVectorSearch(this.db);
+    const probe = compiled.vectorProbe;
+    const row = this.db.query(probe.sql).get(...probe.args);
+    if (Number(row?.total ?? 0) > probe.limit) {
+      throw new ObjectQueryExecutionError3("vector_work_limit_exceeded", `Exact vector search supports at most ${probe.limit} eligible vectors at this dimension. Narrow the query filters.`);
+    }
+  }
   queryObjects(params) {
+    this.assertVectorSearch(params);
     const source = this.source;
     const compiled = compileObjectQuery(params.projectId, params.query, {
       includeTotal: params.includeTotal,
@@ -10615,6 +11001,7 @@ class SqliteObjectReader {
     };
   }
   countObjects(params) {
+    this.assertVectorSearch(params);
     const source = this.source;
     return {
       count: readTotal(this.db, compileObjectQuery(params.projectId, stripOuterRowShape(params.query), {
@@ -10623,6 +11010,7 @@ class SqliteObjectReader {
     };
   }
   existsObjects(params) {
+    this.assertVectorSearch(params);
     const source = this.source;
     const compiled = compileObjectQuery(params.projectId, existsProbeQuery(params.query), {
       source
@@ -10630,6 +11018,7 @@ class SqliteObjectReader {
     return { exists: this.db.query(compiled.sql).get(...compiled.args) !== null };
   }
   facetObjects(params) {
+    this.assertVectorSearch(params);
     const source = this.source;
     const compiled = compileObjectQuery(params.projectId, stripOuterRowShape(params.query), {
       source
@@ -10966,6 +11355,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],
@@ -11052,16 +11442,16 @@ function compileSelectedReadScopeCte(scopeJson, projectId) {
 
         SELECT edge.project_id, selection.node_id, edge.target_type_id, edge.target_id
         FROM _sixb_scope_reachable AS parent
-        JOIN _sixb_scope_link_selections AS selection
+        CROSS JOIN _sixb_scope_link_selections AS selection
           ON selection.parent_node_id = parent.node_id
          AND selection.source_object_type_id = parent.object_type_id
-        JOIN links AS edge
+        CROSS JOIN links AS edge
           ON edge.project_id = parent.project_id
          AND edge.source_type_id = parent.object_type_id
          AND edge.source_id = parent.primary_id
          AND edge.link_id = selection.link_id
          AND edge.target_type_id = selection.target_object_type_id
-        JOIN objects AS target
+        CROSS JOIN objects AS target
           ON target.project_id = edge.project_id
          AND target.object_type_id = edge.target_type_id
          AND target.primary_id = edge.target_id
@@ -11082,32 +11472,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,
+          json_group_array(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 json_each(selection.property_ids) AS selected_property 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 json_group_object(property.key, ${sqliteJsonEachValue("property")})
-              FROM json_each(stored.properties) AS property
-              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
-            ),
-            json('{}')
-          ) 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 json_group_object(property.key, ${sqliteJsonEachValue("property")})
+            FROM json_each(stored.properties) AS property
+            WHERE property.key IN (SELECT value FROM json_each(grants.property_ids))
+          ), json('{}')) AS properties,
+          stored.created_at, stored.updated_at, stored.version, stored.last_commit_id
+        FROM _sixb_scope_object_grants AS grants
+        CROSS 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,
@@ -11133,16 +11520,16 @@ function compileSelectedReadScopeCte(scopeJson, projectId) {
           edge.target_id,
           selection.property_ids
         FROM _sixb_scope_reachable AS parent
-        JOIN _sixb_scope_link_selections AS selection
+        CROSS JOIN _sixb_scope_link_selections AS selection
           ON selection.parent_node_id = parent.node_id
          AND selection.source_object_type_id = parent.object_type_id
-        JOIN links AS edge
+        CROSS JOIN links AS edge
           ON edge.project_id = parent.project_id
          AND edge.source_type_id = parent.object_type_id
          AND edge.source_id = parent.primary_id
          AND edge.link_id = selection.link_id
          AND edge.target_type_id = selection.target_object_type_id
-        JOIN objects AS target
+        CROSS JOIN objects AS target
           ON target.project_id = edge.project_id
          AND target.object_type_id = edge.target_type_id
          AND target.primary_id = edge.target_id
@@ -11314,6 +11701,7 @@ var SQLITE_OBJECT_QUERY_CAPABILITIES = {
     refs: true,
     filter: true,
     text: true,
+    vector: true,
     sort: true,
     limit: true,
     page: true,
@@ -11366,7 +11754,7 @@ var SQLITE_OBJECT_QUERY_CAPABILITIES = {
     "SQLite object query pushdown supports start/refs/filter/text/sort/limit/page/traverse/set/project/expand over JSON properties and object links.",
     "expand hydrates linked objects in-database (top-N per parent via row_number() + json_group_array); core resolves each expansion's cardinality before pushdown, and a mixed/unresolved one stays on the fallback.",
     "Ordered decimal predicates and sorting use the bounded core fallback because SQLite has no native exact decimal type; canonical decimal equality remains pushdown-safe.",
-    "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."
   ]
 };
 
@@ -11389,15 +11777,23 @@ class SqliteObjectStorage {
     return createSqliteSelectedReader(this.db, params, () => this.queryCapabilities());
   }
   async queryObjects(params) {
+    if (hasVectorProfile3(params.query))
+      return runDeferredReadTransaction(this.db, () => this.reader.queryObjects(params));
     return this.reader.queryObjects(params);
   }
   async countObjects(params) {
+    if (hasVectorProfile3(params.query))
+      return runDeferredReadTransaction(this.db, () => this.reader.countObjects(params));
     return this.reader.countObjects(params);
   }
   async existsObjects(params) {
+    if (hasVectorProfile3(params.query))
+      return runDeferredReadTransaction(this.db, () => this.reader.existsObjects(params));
     return this.reader.existsObjects(params);
   }
   async facetObjects(params) {
+    if (hasVectorProfile3(params.query))
+      return runDeferredReadTransaction(this.db, () => this.reader.facetObjects(params));
     return this.reader.facetObjects(params);
   }
   async getByPrimaryId(params) {
@@ -11689,6 +12085,7 @@ import {
   linkRefSortKey,
   linkScopeSortKey as linkScopeSortKey2,
   MaterializationConflictError as MaterializationConflictError6,
+  MaterializationValidationError as MaterializationValidationError2,
   objectRefKey as objectRefKey3,
   objectRefSortKey,
   telemetryPointKey as telemetryPointKey2,
@@ -13176,6 +13573,12 @@ class SqliteOntologyMaterializationStorage {
     this.sessions = new SqliteMaterializationSessions(db, context);
     this.writer = new SqliteMaterializationWriter(db);
   }
+  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 = this.sessions.create(input);
@@ -13613,7 +14016,7 @@ class SqliteOntologyMaterializationStorage {
 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 SqliteOntologyOutboxStorage {
@@ -13631,7 +14034,7 @@ class SqliteOntologyOutboxStorage {
       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 eligible = this.db.query(`SELECT CAST(rowid AS TEXT) AS rowId
            FROM ontology_outbox INDEXED BY idx_ontology_outbox_claim
@@ -13756,7 +14159,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);
   }
@@ -13771,7 +14174,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,
@@ -13911,7 +14314,7 @@ class SqliteOntologySourceStorage {
         throw sourceConflict(`Source materialization '${input.materializationId}' cannot transition from '${manifest.status}' to 'ready'.`);
       }
       if (input.readyAt < manifest.created_at) {
-        throw new MaterializationValidationError3("Source readyAt cannot precede source createdAt.");
+        throw new MaterializationValidationError4("Source readyAt cannot precede source createdAt.");
       }
       this.assertReadyState(manifest, input.rootCount, input.assertionCount);
       const result = this.db.query(`
@@ -13994,7 +14397,7 @@ class SqliteOntologySourceStorage {
   }
   transitionToAbandoned(manifest, abandonedAt) {
     if (abandonedAt < manifest.created_at || manifest.ready_at !== null && abandonedAt < 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 changed = this.db.query(`
           UPDATE ontology_sources
@@ -14019,7 +14422,7 @@ class SqliteOntologySourceStorage {
           WHERE project_id = ? AND source_id = ? AND materialization_id = ?
         `).get(manifest.project_id, manifest.source_id, manifest.materialization_id, manifest.project_id, manifest.source_id, manifest.materialization_id);
     if (counts.assertions !== assertionCount || counts.roots !== rootCount || counts.ordinals !== rootCount || rootCount > 0 && (counts.min_ordinal !== 0 || counts.max_ordinal !== 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.");
     }
     assertSourceRootCoverage(this.db, manifest);
     const invalid = this.db.query(manifest.projection_kind === "link" ? `
@@ -14047,7 +14450,7 @@ class SqliteOntologySourceStorage {
               LIMIT 1
             `).get(manifest.project_id, manifest.source_id, manifest.materialization_id);
     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.");
     }
   }
   findStageRows(input, rows) {
@@ -14153,16 +14556,228 @@ class SqliteOntologySourceStorage {
   }
 }
 
+// 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 SqliteVectorIndexingStorage {
+  db;
+  run;
+  assertSession;
+  constructor(db, run, assertSession) {
+    this.db = db;
+    this.run = run;
+    this.assertSession = assertSession;
+  }
+  async schedule(input) {
+    this.assertSession(input.session, input.projectId);
+    for (const ref of input.deleted)
+      this.db.query(`DELETE FROM object_vector_indexing WHERE project_id = ? AND object_type_id = ? AND primary_id = ?`).run(input.projectId, ref.objectTypeId, ref.primaryId);
+    const insert = this.db.query(`INSERT INTO object_vector_indexing (project_id, id, object_type_id, primary_id, profile, batch_id, request, status, available_at, dispatch_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, 'pending', ?, ?)
+      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`);
+    for (const { batchId, ...request } of input.requests)
+      insert.run(input.projectId, request.id, request.ref.objectTypeId, request.ref.primaryId, request.profile, batchId ?? null, JSON.stringify(request), input.availableAt, input.availableAt);
+  }
+  async complete(input) {
+    this.assertSession(input.session, input.projectId);
+    const remove = this.db.query(`DELETE FROM object_vector_indexing WHERE project_id = ? AND object_type_id = ? AND primary_id = ? AND profile = ? AND json_extract(request, '$.configuration') = ? AND json_extract(request, '$.sourceFingerprint') = ?`);
+    for (const entry of input.entries) {
+      remove.run(input.projectId, entry.ref.objectTypeId, entry.ref.primaryId, entry.profile, entry.configuration, entry.sourceFingerprint);
+    }
+  }
+  async dispatched(input) {
+    await this.run(() => {
+      const update = this.db.query(`UPDATE object_vector_indexing SET dispatch_at = ? WHERE project_id = ? AND id = ?`);
+      for (const id of input.ids)
+        update.run(input.nextDispatchAt, input.projectId, id);
+    });
+  }
+  async get(input) {
+    return this.run(() => {
+      const row = this.db.query(`SELECT batch_id, request, status, available_at, values_json, error FROM object_vector_indexing WHERE project_id = ? AND id = ?`).get(input.projectId, input.id);
+      return row ? decode(row) : null;
+    });
+  }
+  async getBatch(input) {
+    return this.run(() => this.db.query(`
+      SELECT batch_id, request, status, available_at, values_json, error FROM object_vector_indexing
+      WHERE project_id = ? AND batch_id = ? ORDER BY id`).all(input.projectId, input.batchId).map(decode));
+  }
+  async getBatchMember(input) {
+    return this.run(() => {
+      const row = this.db.query(`
+        SELECT batch_id, request, status, available_at, values_json, error
+        FROM object_vector_indexing WHERE project_id = ? AND object_type_id = ?
+        AND primary_id = ? AND profile = ? AND batch_id = ?`).get(input.projectId, input.ref.objectTypeId, input.ref.primaryId, input.profile, input.batchId);
+      return row ? decode(row) : null;
+    });
+  }
+  async updateBatch(input) {
+    return this.run(() => this.db.transaction(() => {
+      const status = this.db.query("SELECT status FROM object_vector_indexing WHERE project_id = ? AND id = ?");
+      if (input.requireAll && input.updates.some((update) => status.get(input.projectId, update.id)?.status !== update.expectedStatus))
+        return false;
+      const updateRow = this.db.query(`UPDATE object_vector_indexing
+        SET status = ?, available_at = ?, values_json = COALESCE(?, values_json), error = ?
+        WHERE project_id = ? AND id = ? AND status = ?`);
+      for (const update of input.updates)
+        updateRow.run(update.status, update.availableAt, update.values ? JSON.stringify(update.values) : null, update.error ? JSON.stringify(update.error) : null, input.projectId, update.id, update.expectedStatus);
+      return true;
+    })());
+  }
+  async listDue(input) {
+    return this.run(() => this.db.query(`SELECT batch_id, request, status, available_at, NULL AS values_json, error FROM object_vector_indexing WHERE project_id = ? AND status <> 'failed' AND dispatch_at <= ? ORDER BY dispatch_at, id LIMIT ?`).all(input.projectId, input.now, input.limit).map(decode));
+  }
+  async update(input) {
+    return this.run(() => this.db.query(`UPDATE object_vector_indexing SET status = ?, available_at = ?, values_json = COALESCE(?, values_json), error = ? WHERE project_id = ? AND id = ? AND status = ?`).run(input.status, input.availableAt, input.values ? JSON.stringify(input.values) : null, input.error ? JSON.stringify(input.error) : null, input.projectId, input.id, input.expectedStatus).changes === 1);
+  }
+  async remove(input) {
+    await this.run(() => {
+      this.db.query(`DELETE FROM object_vector_indexing WHERE project_id = ? AND id = ?`).run(input.projectId, input.id);
+    });
+  }
+}
+function decode(row) {
+  const request = JSON.parse(row.request);
+  return {
+    ...request,
+    ...row.batch_id ? { batchId: row.batch_id } : {},
+    status: row.status,
+    availableAt: row.available_at,
+    ...row.values_json ? { values: JSON.parse(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 SqliteOntologyVectorStorage {
+  db;
+  runRootOperation;
+  assertSession;
+  constructor(db, runRootOperation, assertSession) {
+    this.db = db;
+    this.runRootOperation = runRootOperation;
+    this.assertSession = assertSession;
+  }
+  async list(input) {
+    return this.runRootOperation(() => {
+      const rows = this.db.query(`
+        SELECT profile, configuration, source, source_fingerprint, last_commit_id
+        FROM object_vectors
+        WHERE project_id = ? AND object_type_id = ? AND primary_id = ?
+        ORDER BY profile
+      `).all(input.projectId, input.ref.objectTypeId, input.ref.primaryId);
+      return rows.map((row) => ({
+        ref: { ...input.ref },
+        profile: row.profile,
+        configuration: row.configuration,
+        source: JSON.parse(row.source),
+        sourceFingerprint: row.source_fingerprint,
+        lastCommitId: row.last_commit_id
+      }));
+    });
+  }
+  async listBatch(input) {
+    if (!input.refs.length)
+      return [];
+    return this.runRootOperation(() => {
+      const rows = this.db.query(`
+        WITH requested AS (
+          SELECT DISTINCT json_extract(value, '$.objectTypeId') AS object_type_id,
+            json_extract(value, '$.primaryId') AS primary_id FROM json_each(?)
+        )
+        SELECT stored.object_type_id, stored.primary_id, stored.profile, stored.configuration,
+          stored.source, stored.source_fingerprint, stored.last_commit_id
+        FROM requested CROSS JOIN object_vectors AS stored
+        WHERE stored.project_id = ? 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
+      `).all(JSON.stringify(input.refs), input.projectId);
+      return rows.map((row) => ({
+        ref: { objectTypeId: row.object_type_id, primaryId: row.primary_id },
+        profile: row.profile,
+        configuration: row.configuration,
+        source: JSON.parse(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 { changes } = this.db.query(`
+      DELETE FROM object_vectors WHERE rowid IN (
+        SELECT stored.rowid FROM json_each(?) AS requested CROSS JOIN object_vectors AS stored
+        WHERE stored.project_id = ? AND stored.object_type_id = json_extract(requested.value, '$.ref.objectTypeId')
+          AND stored.primary_id = json_extract(requested.value, '$.ref.primaryId')
+          AND stored.profile = json_extract(requested.value, '$.profile')
+          AND stored.last_commit_id = json_extract(requested.value, '$.expectedCommitId')
+      )
+    `).run(JSON.stringify(input.entries), input.projectId);
+    if (changes !== input.entries.length)
+      throw vectorConflict();
+  }
+  async write(input) {
+    const { value } = input;
+    this.assertSession(input.session, input.projectId, value.lastCommitId);
+    const embedding = encodeSqliteVector(value.values);
+    const changes = input.expectedCommitId === null ? this.db.query(`
+          INSERT INTO object_vectors (
+            project_id, object_type_id, primary_id, profile,
+            configuration, source, source_fingerprint, embedding, last_commit_id
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+          ON CONFLICT (project_id, object_type_id, primary_id, profile) DO NOTHING
+        `).run(input.projectId, value.ref.objectTypeId, value.ref.primaryId, value.profile, value.configuration, JSON.stringify(value.source), value.sourceFingerprint, embedding, value.lastCommitId).changes : this.db.query(`
+          UPDATE object_vectors
+          SET configuration = ?, source = ?, source_fingerprint = ?, embedding = ?, last_commit_id = ?
+          WHERE project_id = ? AND object_type_id = ? AND primary_id = ?
+            AND profile = ? AND last_commit_id = ?
+        `).run(value.configuration, JSON.stringify(value.source), value.sourceFingerprint, embedding, value.lastCommitId, input.projectId, value.ref.objectTypeId, value.ref.primaryId, value.profile, input.expectedCommitId).changes;
+    if (changes !== 1)
+      throw vectorConflict();
+  }
+  async writeBatch(input) {
+    for (const entry of input.entries) {
+      await this.write({ session: input.session, projectId: input.projectId, ...entry });
+    }
+  }
+  async remove(input) {
+    this.assertSession(input.session, input.projectId);
+    const { changes } = this.db.query(`
+      DELETE FROM object_vectors
+      WHERE project_id = ? AND object_type_id = ? AND primary_id = ?
+        AND profile = ? AND last_commit_id = ?
+    `).run(input.projectId, input.ref.objectTypeId, input.ref.primaryId, input.profile, input.expectedCommitId);
+    if (changes !== 1)
+      throw vectorConflict();
+  }
+}
+function vectorConflict() {
+  return new MaterializationConflictError8("effective-state", "Vector changed since it was prepared.");
+}
+
 // src/ontology-storage/index.ts
 class SqliteOntologyStorage {
   commits;
   sources;
   materializations;
+  vectorIndexing;
+  vectors;
   outbox;
   constructor(input) {
     this.commits = new SqliteOntologyCommitStorage(input.db, input.runRootOperation);
     this.sources = new SqliteOntologySourceStorage(input.db, input.runRootOperation);
     this.materializations = new SqliteOntologyMaterializationStorage(input.db, input.transactionContext);
+    this.vectorIndexing = new SqliteVectorIndexingStorage(input.db, input.runRootOperation, (session, projectId) => this.materializations.assertVectorSession(session, projectId));
+    this.vectors = new SqliteOntologyVectorStorage(input.db, input.runRootOperation, (session, projectId, commitId) => this.materializations.assertVectorSession(session, projectId, commitId));
     this.outbox = new SqliteOntologyOutboxStorage(input.db, input.runRootOperation);
   }
   deactivateSessions() {
@@ -14171,7 +14786,7 @@ class SqliteOntologyStorage {
 }
 
 // src/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";
@@ -14493,7 +15108,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) {
@@ -14514,7 +15129,7 @@ function rowToPipelineStepRunRecord(row) {
       versionId: row.output_version_id
     } : undefined,
     rowsWritten: 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 assertOptionalNonNegativeInteger(value, fieldName) {
@@ -15459,7 +16074,7 @@ function invalidRecord2(message) {
 }
 
 // src/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";
@@ -15662,7 +16277,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: parseCheckpoint(row.checkpoint)
   };
 }
@@ -15803,7 +16418,7 @@ class SqliteTimeseriesStorage {
 }
 
 // src/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 SqliteWebhookRunStorage {
@@ -15949,7 +16564,7 @@ function rowToWebhookRunRecord(row) {
     requestBodySha256: row.request_body_sha256,
     responseStatus: 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)
   };
 }
 
@@ -16178,7 +16793,7 @@ function assertNonNegativeInteger(value, fieldName) {
 }
 
 // src/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
@@ -16736,7 +17351,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: row.attempt,
     ...row.execution_token && row.execution_queue_lease_expires_at ? {
       execution: {
@@ -16761,7 +17376,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) {
@@ -16789,7 +17404,7 @@ function rowToWorkflowAgentNodeRunRecord(row) {
     ...row.finish_reason ? { finishReason: row.finish_reason } : {},
     ...row.trace ? { trace: JSON.parse(row.trace) } : {},
     ...row.diagnostics ? { diagnostics: JSON.parse(row.diagnostics) } : {},
-    ...row.error ? { error: parseSixbFailure6(row.error, AGENT_RUN_FAILURE_CODES3) } : {},
+    ...row.error ? { error: parseSixbFailure7(row.error, AGENT_RUN_FAILURE_CODES3) } : {},
     attempt: row.attempt,
     ...row.execution_token && row.execution_queue_lease_expires_at ? {
       execution: {
@@ -17012,4 +17627,4 @@ export {
   migrateSqliteStorage
 };
 
-//# debugId=6BCAC863183D761764756E2164756E21
+//# debugId=23F5EFFEE42C282464756E2164756E21