@sixb/sqlite 0.1.2 → 0.1.4

package/dist/index.js

@@ -2918,6 +2918,103 @@ CREATE INDEX idx_connector_connections_status
   ON connector_connections (project_id, connector_id, status, id);
 `;
 
+// src/migrations/026-ai-cost-accounting.sql
+var _026_ai_cost_accounting_default = `CREATE TABLE ai_model_call_valuations (
+  project_id TEXT NOT NULL CHECK (length(trim(project_id)) > 0),
+  usage_record_id TEXT NOT NULL CHECK (length(trim(usage_record_id)) > 0),
+  status TEXT NOT NULL CHECK (status IN ('rated', 'unpriceable')),
+  provider_id TEXT CHECK (provider_id IS NULL OR length(trim(provider_id)) > 0),
+  model_id TEXT CHECK (model_id IS NULL OR length(trim(model_id)) > 0),
+  currency TEXT CHECK (
+    currency IS NULL OR (length(currency) = 3 AND currency GLOB '[A-Z][A-Z][A-Z]')
+  ),
+  amount_nanos INTEGER CHECK (
+    amount_nanos IS NULL OR (typeof(amount_nanos) = 'integer' AND amount_nanos >= 0)
+  ),
+  reason TEXT CHECK (
+    reason IS NULL OR reason IN (
+      'missingBillingIdentity',
+      'missingCatalogEntry',
+      'missingUsageMeter',
+      'unsupportedPricingDimension',
+      'invalidUsageForFormula'
+    )
+  ),
+  details TEXT NOT NULL CHECK (json_valid(details) AND json_type(details) = 'object'),
+  rated_at TEXT NOT NULL CHECK (length(trim(rated_at)) > 0),
+  PRIMARY KEY (project_id, usage_record_id),
+  FOREIGN KEY (project_id, usage_record_id)
+    REFERENCES ai_model_call_usage(project_id, id)
+    ON DELETE RESTRICT,
+  CHECK (
+    (
+      status = 'rated'
+      AND provider_id IS NOT NULL
+      AND model_id IS NOT NULL
+      AND currency IS NOT NULL
+      AND amount_nanos IS NOT NULL
+      AND reason IS NULL
+    )
+    OR
+    (
+      status = 'unpriceable'
+      AND currency IS NULL
+      AND amount_nanos IS NULL
+      AND reason IS NOT NULL
+      AND (
+        (reason = 'missingBillingIdentity' AND provider_id IS NULL AND model_id IS NULL)
+        OR
+        (reason <> 'missingBillingIdentity' AND provider_id IS NOT NULL AND model_id IS NOT NULL)
+      )
+    )
+  )
+);
+
+CREATE INDEX idx_ai_model_call_usage_provider_model_time
+  ON ai_model_call_usage (project_id, provider_id, requested_model_id, occurred_at, id);
+CREATE INDEX idx_ai_model_call_usage_model_time
+  ON ai_model_call_usage (project_id, requested_model_id, occurred_at, id);
+CREATE INDEX idx_ai_model_call_valuations_summary
+  ON ai_model_call_valuations (project_id, status, currency, usage_record_id);
+`;
+
+// src/migrations/027-agent-context-checkpoints.sql
+var _027_agent_context_checkpoints_default = `CREATE TABLE agent_context_checkpoints (
+  project_id TEXT NOT NULL,
+  id TEXT NOT NULL,
+  thread_id TEXT NOT NULL,
+  created_by_run_id TEXT NOT NULL,
+  previous_checkpoint_id TEXT,
+  reason TEXT NOT NULL CHECK (reason IN ('threshold', 'overflow')),
+  summary TEXT NOT NULL CHECK (length(trim(summary)) > 0),
+  summary_format_version INTEGER NOT NULL CHECK (summary_format_version = 1),
+  summarized_through_seq INTEGER NOT NULL CHECK (summarized_through_seq >= 1),
+  observed_head_seq INTEGER NOT NULL,
+  estimated_input_tokens_before INTEGER NOT NULL CHECK (estimated_input_tokens_before >= 0),
+  estimated_input_tokens_after INTEGER NOT NULL CHECK (estimated_input_tokens_after >= 0),
+  summary_model_id TEXT NOT NULL CHECK (length(trim(summary_model_id)) > 0),
+  created_at TEXT NOT NULL,
+  PRIMARY KEY (project_id, id),
+  UNIQUE (project_id, created_by_run_id),
+  FOREIGN KEY (project_id, thread_id)
+    REFERENCES agent_threads(project_id, id) ON DELETE CASCADE,
+  FOREIGN KEY (project_id, created_by_run_id)
+    REFERENCES agent_runs(project_id, id) ON DELETE RESTRICT,
+  FOREIGN KEY (project_id, previous_checkpoint_id)
+    REFERENCES agent_context_checkpoints(project_id, id) ON DELETE RESTRICT,
+  CHECK (summarized_through_seq < observed_head_seq)
+);
+
+CREATE INDEX idx_agent_context_checkpoints_thread_latest
+  ON agent_context_checkpoints(project_id, thread_id, summarized_through_seq DESC, created_at DESC, id DESC);
+`;
+
+// src/migrations/028-object-override-edit-times.sql
+var _028_object_override_edit_times_default = `ALTER TABLE ontology_object_overrides
+ADD COLUMN edited_at TEXT NOT NULL DEFAULT '{}'
+CHECK (json_valid(edited_at) AND json_type(edited_at) = 'object');
+`;
+
 // src/migrations.ts
 var MIGRATIONS_TABLE_SQL = `
   CREATE TABLE IF NOT EXISTS sixb_migrations (
@@ -2977,7 +3074,10 @@ var sqliteStorageMigrations = defineMigrations({
       }
       db.run(_024_ontology_commit_executions_default);
     }, { checksum: checksum(_024_ontology_commit_executions_default) }),
-    sqliteSql("025-connector-connections", _025_connector_connections_default)
+    sqliteSql("025-connector-connections", _025_connector_connections_default),
+    sqliteSql("026-ai-cost-accounting", _026_ai_cost_accounting_default),
+    sqliteSql("027-agent-context-checkpoints", _027_agent_context_checkpoints_default),
+    sqliteSql("028-object-override-edit-times", _028_object_override_edit_times_default)
   ]
 });
 function sqliteStoragePath(basePath) {
@@ -3628,17 +3728,18 @@ function isUniqueConstraintError(error) {
   return error instanceof Error && error.message.includes("UNIQUE constraint failed");
 }
 
-// src/agents/messages.ts
-import { AGENT_MESSAGE_CONTENT_VERSION } from "@sixb/core/internal/agents";
+// src/agents/checkpoints.ts
+import {
+  agentContextCheckpointMatchesCreateInput,
+  assertAgentContextCheckpointAnchors,
+  assertAgentContextCheckpointAuthority,
+  assertAgentContextCheckpointReplayState,
+  assertCreateAgentContextCheckpointInput
+} from "@sixb/core/internal/agent-run-storage-provider";
 import {
   AgentStorageError
 } from "@sixb/core/storage";
 
-// src/storage-errors.ts
-function isUniqueConstraintError2(error) {
-  return error instanceof Error && error.message.includes("UNIQUE constraint failed");
-}
-
 // src/agents/rows.ts
 import { parseSixbFailure } from "@sixb/core/internal/errors";
 import {
@@ -3700,6 +3801,27 @@ function rowToMessageRecord(row) {
     completedAt: row.completed_at ? new Date(row.completed_at) : undefined
   };
 }
+function rowToContextCheckpointRecord(row) {
+  if (row.summary_format_version !== 1) {
+    throw new Error(`[SixbSqlite] Unsupported agent context checkpoint summary format version '${row.summary_format_version}'.`);
+  }
+  return {
+    id: row.id,
+    projectId: row.project_id,
+    threadId: row.thread_id,
+    createdByRunId: row.created_by_run_id,
+    previousCheckpointId: row.previous_checkpoint_id ?? undefined,
+    reason: row.reason,
+    summary: row.summary,
+    summaryFormatVersion: 1,
+    summarizedThroughSeq: row.summarized_through_seq,
+    observedHeadSeq: row.observed_head_seq,
+    estimatedInputTokensBefore: row.estimated_input_tokens_before,
+    estimatedInputTokensAfter: row.estimated_input_tokens_after,
+    summaryModelId: row.summary_model_id,
+    createdAt: new Date(row.created_at)
+  };
+}
 function principalFromColumns(type, id) {
   return type && id ? { type, id } : undefined;
 }
@@ -3721,6 +3843,124 @@ function queryAgentList(input) {
   return { rows, total, hasMore: offset + rows.length < total };
 }
 
+// src/agents/checkpoints.ts
+var SQLITE_CHECKPOINT_RUN_ID_BATCH_SIZE = 500;
+
+class SqliteAgentContextCheckpointStore {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async create(input) {
+    assertCreateAgentContextCheckpointInput(input, "SixbSqlite");
+    return this.db.transaction(() => {
+      const runRow = this.db.query("SELECT * FROM agent_runs WHERE project_id = ? AND id = ?").get(input.projectId, input.createdByRunId);
+      const threadRow = this.db.query("SELECT * FROM agent_threads WHERE project_id = ? AND id = ?").get(input.projectId, input.threadId);
+      assertAgentContextCheckpointAuthority({
+        create: input,
+        run: runRow ? rowToRunRecord(runRow) : null,
+        thread: threadRow ? rowToThreadRecord(threadRow) : null,
+        prefix: "SixbSqlite"
+      });
+      const latest = this.findLatest(input.projectId, input.threadId);
+      const headRow = this.db.query("SELECT COALESCE(MAX(seq), 0) AS seq FROM agent_messages WHERE project_id = ? AND thread_id = ?").get(input.projectId, input.threadId);
+      const existingForRun = this.db.query("SELECT * FROM agent_context_checkpoints WHERE project_id = ? AND created_by_run_id = ?").get(input.projectId, input.createdByRunId);
+      if (existingForRun) {
+        const record = rowToContextCheckpointRecord(existingForRun);
+        if (agentContextCheckpointMatchesCreateInput(record, input)) {
+          assertAgentContextCheckpointReplayState({
+            create: input,
+            existing: record,
+            latest,
+            headSeq: headRow.seq,
+            prefix: "SixbSqlite"
+          });
+          return record;
+        }
+        throw new AgentStorageError("invalid_state", `[SixbSqlite] Agent run '${input.createdByRunId}' already created a different context checkpoint.`);
+      }
+      const duplicateId = this.db.query("SELECT 1 FROM agent_context_checkpoints WHERE project_id = ? AND id = ?").get(input.projectId, input.id);
+      if (duplicateId) {
+        throw new AgentStorageError("duplicate_id", `[SixbSqlite] Agent context checkpoint '${input.id}' already exists for project '${input.projectId}'.`);
+      }
+      const firstRetainedRow = this.db.query("SELECT * FROM agent_messages WHERE project_id = ? AND thread_id = ? AND seq > ? ORDER BY seq ASC LIMIT 1").get(input.projectId, input.threadId, input.summarizedThroughSeq);
+      assertAgentContextCheckpointAnchors({
+        create: input,
+        latest,
+        headSeq: headRow.seq,
+        firstRetained: firstRetainedRow ? rowToMessageRecord(firstRetainedRow) : null,
+        prefix: "SixbSqlite"
+      });
+      const createdAt = input.createdAt ?? new Date;
+      this.db.query(`
+            INSERT INTO agent_context_checkpoints (
+              project_id,
+              id,
+              thread_id,
+              created_by_run_id,
+              previous_checkpoint_id,
+              reason,
+              summary,
+              summary_format_version,
+              summarized_through_seq,
+              observed_head_seq,
+              estimated_input_tokens_before,
+              estimated_input_tokens_after,
+              summary_model_id,
+              created_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          `).run(input.projectId, input.id, input.threadId, input.createdByRunId, input.expectedPreviousCheckpointId, input.reason, input.summary, input.summaryFormatVersion, input.summarizedThroughSeq, input.observedHeadSeq, input.estimatedInputTokensBefore, input.estimatedInputTokensAfter, input.summaryModelId, createdAt.toISOString());
+      return this.requireById(input.projectId, input.id);
+    })();
+  }
+  async getLatest(input) {
+    return this.findLatest(input.projectId, input.threadId);
+  }
+  async getByRunIds(input) {
+    const runIds = [...new Set(input.runIds)];
+    if (runIds.length === 0)
+      return [];
+    const rows = [];
+    for (let offset = 0;offset < runIds.length; offset += SQLITE_CHECKPOINT_RUN_ID_BATCH_SIZE) {
+      const batch = runIds.slice(offset, offset + SQLITE_CHECKPOINT_RUN_ID_BATCH_SIZE);
+      const placeholders = batch.map(() => "?").join(", ");
+      rows.push(...this.db.query(`SELECT * FROM agent_context_checkpoints WHERE project_id = ? AND created_by_run_id IN (${placeholders})`).all(input.projectId, ...batch));
+    }
+    const byRunId = new Map(rows.map((row) => [row.created_by_run_id, rowToContextCheckpointRecord(row)]));
+    return runIds.flatMap((runId) => {
+      const checkpoint = byRunId.get(runId);
+      return checkpoint ? [checkpoint] : [];
+    });
+  }
+  findLatest(projectId, threadId) {
+    const row = this.db.query(`
+          SELECT * FROM agent_context_checkpoints
+          WHERE project_id = ? AND thread_id = ?
+          ORDER BY summarized_through_seq DESC, created_at DESC, id DESC
+          LIMIT 1
+        `).get(projectId, threadId);
+    return row ? rowToContextCheckpointRecord(row) : null;
+  }
+  requireById(projectId, id) {
+    const row = this.db.query("SELECT * FROM agent_context_checkpoints WHERE project_id = ? AND id = ?").get(projectId, id);
+    if (!row) {
+      throw new AgentStorageError("invalid_state", `[SixbSqlite] Failed to load agent context checkpoint '${id}' for project '${projectId}'.`);
+    }
+    return rowToContextCheckpointRecord(row);
+  }
+}
+
+// src/agents/messages.ts
+import { AGENT_MESSAGE_CONTENT_VERSION } from "@sixb/core/internal/agents";
+import {
+  AgentStorageError as AgentStorageError2
+} from "@sixb/core/storage";
+
+// src/storage-errors.ts
+function isUniqueConstraintError2(error) {
+  return error instanceof Error && error.message.includes("UNIQUE constraint failed");
+}
+
 // src/agents/messages.ts
 class SqliteAgentMessageStore {
   db;
@@ -3732,12 +3972,12 @@ class SqliteAgentMessageStore {
     return this.db.transaction(() => {
       const thread = this.db.query("SELECT 1 AS present FROM agent_threads WHERE project_id = ? AND id = ?").get(input.projectId, input.threadId);
       if (!thread) {
-        throw new AgentStorageError("thread_not_found", `[SixbSqlite] Agent thread '${input.threadId}' not found for project '${input.projectId}'.`);
+        throw new AgentStorageError2("thread_not_found", `[SixbSqlite] Agent thread '${input.threadId}' not found for project '${input.projectId}'.`);
       }
       if (input.runId !== null) {
         const run = this.db.query("SELECT 1 AS present FROM agent_runs WHERE project_id = ? AND id = ?").get(input.projectId, input.runId);
         if (!run) {
-          throw new AgentStorageError("run_not_found", `[SixbSqlite] Agent run '${input.runId}' not found for project '${input.projectId}'.`);
+          throw new AgentStorageError2("run_not_found", `[SixbSqlite] Agent run '${input.runId}' not found for project '${input.projectId}'.`);
         }
       }
       const seqRow = this.db.query("SELECT COALESCE(MAX(seq), 0) + 1 AS next FROM agent_messages WHERE project_id = ? AND thread_id = ?").get(input.projectId, input.threadId);
@@ -3761,7 +4001,7 @@ class SqliteAgentMessageStore {
           `).run(input.projectId, input.id, input.threadId, input.runId, input.role, input.authorPrincipal?.type ?? null, input.authorPrincipal?.id ?? null, seqRow.next, JSON.stringify(input.parts), input.metadata === undefined ? null : JSON.stringify(input.metadata), AGENT_MESSAGE_CONTENT_VERSION, createdAt.toISOString(), input.completedAt ? input.completedAt.toISOString() : null);
       } catch (error) {
         if (isUniqueConstraintError2(error)) {
-          throw new AgentStorageError("duplicate_id", `[SixbSqlite] Agent message '${input.id}' already exists for project '${input.projectId}'.`);
+          throw new AgentStorageError2("duplicate_id", `[SixbSqlite] Agent message '${input.id}' already exists for project '${input.projectId}'.`);
         }
         throw error;
       }
@@ -3773,6 +4013,35 @@ class SqliteAgentMessageStore {
       return this.requireMessage(input.projectId, input.id);
     })();
   }
+  async deleteByRunId(input) {
+    return this.db.transaction(() => {
+      const thread = this.db.query("SELECT 1 AS present FROM agent_threads WHERE project_id = ? AND id = ?").get(input.projectId, input.threadId);
+      if (!thread) {
+        throw new AgentStorageError2("thread_not_found", `[SixbSqlite] Agent thread '${input.threadId}' not found for project '${input.projectId}'.`);
+      }
+      const deleted = this.db.query("DELETE FROM agent_messages WHERE project_id = ? AND thread_id = ? AND run_id = ?").run(input.projectId, input.threadId, input.runId);
+      if (deleted.changes === 0) {
+        return 0;
+      }
+      const updatedAt = new Date().toISOString();
+      this.db.query(`
+          UPDATE agent_threads
+          SET
+            message_count = (
+              SELECT COUNT(*) FROM agent_messages WHERE project_id = ? AND thread_id = ?
+            ),
+            last_message_at = (
+              SELECT created_at FROM agent_messages
+              WHERE project_id = ? AND thread_id = ?
+              ORDER BY seq DESC
+              LIMIT 1
+            ),
+            updated_at = ?
+          WHERE project_id = ? AND id = ?
+        `).run(input.projectId, input.threadId, input.projectId, input.threadId, updatedAt, input.projectId, input.threadId);
+      return deleted.changes;
+    })();
+  }
   async getById(params) {
     const row = this.db.query("SELECT * FROM agent_messages WHERE project_id = ? AND id = ?").get(params.projectId, params.id);
     return row ? rowToMessageRecord(row) : null;
@@ -3783,6 +4052,10 @@ class SqliteAgentMessageStore {
     }
     const whereClauses = ["project_id = ?", "thread_id = ?"];
     const args = [input.projectId, input.threadId];
+    if (input.afterSeq !== undefined) {
+      whereClauses.push("seq > ?");
+      args.push(input.afterSeq);
+    }
     if (input.roles) {
       whereClauses.push(`role IN (${input.roles.map(() => "?").join(", ")})`);
       args.push(...input.roles);
@@ -3802,7 +4075,7 @@ class SqliteAgentMessageStore {
   requireMessage(projectId, id) {
     const row = this.db.query("SELECT * FROM agent_messages WHERE project_id = ? AND id = ?").get(projectId, id);
     if (!row) {
-      throw new AgentStorageError("invalid_state", `[SixbSqlite] Failed to load agent message '${id}' for project '${projectId}'.`);
+      throw new AgentStorageError2("invalid_state", `[SixbSqlite] Failed to load agent message '${id}' for project '${projectId}'.`);
     }
     return rowToMessageRecord(row);
   }
@@ -3814,7 +4087,7 @@ import { normalizeRequesterGroupIds } from "@sixb/core/internal/auth";
 import { serializeSixbFailure } from "@sixb/core/internal/errors";
 import {
   AGENT_RUN_FAILURE_CODES as AGENT_RUN_FAILURE_CODES2,
-  AgentStorageError as AgentStorageError2
+  AgentStorageError as AgentStorageError3
 } from "@sixb/core/storage";
 
 // src/run-list-query.ts
@@ -3890,10 +4163,10 @@ class SqliteAgentRunStore {
     return this.db.transaction(() => {
       const thread = this.db.query("SELECT active_run_id FROM agent_threads WHERE project_id = ? AND id = ?").get(input.projectId, input.threadId);
       if (!thread) {
-        throw new AgentStorageError2("thread_not_found", `[SixbSqlite] Agent thread '${input.threadId}' not found for project '${input.projectId}'.`);
+        throw new AgentStorageError3("thread_not_found", `[SixbSqlite] Agent thread '${input.threadId}' not found for project '${input.projectId}'.`);
       }
       if (thread.active_run_id !== null) {
-        throw new AgentStorageError2("active_run_exists", `[SixbSqlite] Agent thread '${input.threadId}' already has an active run '${thread.active_run_id}'.`);
+        throw new AgentStorageError3("active_run_exists", `[SixbSqlite] Agent thread '${input.threadId}' already has an active run '${thread.active_run_id}'.`);
       }
       try {
         this.db.query(`
@@ -3912,7 +4185,7 @@ class SqliteAgentRunStore {
           `).run(input.projectId, input.id, input.executionId, input.threadId, input.agentId, input.triggerMessageId, JSON.stringify(normalizeRequesterGroupIds(input.requesterGroupIds)), createdAt.toISOString());
       } catch (error) {
         if (isUniqueConstraintError2(error)) {
-          throw new AgentStorageError2("duplicate_id", `[SixbSqlite] Agent run '${input.id}' already exists for project '${input.projectId}'.`);
+          throw new AgentStorageError3("duplicate_id", `[SixbSqlite] Agent run '${input.id}' already exists for project '${input.projectId}'.`);
         }
         throw error;
       }
@@ -3969,7 +4242,7 @@ class SqliteAgentRunStore {
     return this.db.transaction(() => {
       const run = this.requireRunning(input.projectId, input.id);
       if (run.execution_token !== input.executionToken) {
-        throw new AgentStorageError2("execution_lost", `[SixbSqlite] Execution token is no longer current on agent run '${input.id}'.`);
+        throw new AgentStorageError3("execution_lost", `[SixbSqlite] Execution token is no longer current on agent run '${input.id}'.`);
       }
       this.db.query(`
           UPDATE agent_runs
@@ -3985,7 +4258,7 @@ class SqliteAgentRunStore {
     return this.db.transaction(() => {
       const run = this.requireRunning(input.projectId, input.id);
       if (run.execution_token !== input.executionToken) {
-        throw new AgentStorageError2("execution_lost", `[SixbSqlite] Execution token is no longer current on agent run '${input.id}'.`);
+        throw new AgentStorageError3("execution_lost", `[SixbSqlite] Execution token is no longer current on agent run '${input.id}'.`);
       }
       this.db.query(`
           UPDATE agent_runs
@@ -4057,10 +4330,10 @@ class SqliteAgentRunStore {
   requireStatus(projectId, id, status) {
     const row = this.db.query("SELECT * FROM agent_runs WHERE project_id = ? AND id = ?").get(projectId, id);
     if (!row) {
-      throw new AgentStorageError2("run_not_found", `[SixbSqlite] Agent run '${id}' not found for project '${projectId}'.`);
+      throw new AgentStorageError3("run_not_found", `[SixbSqlite] Agent run '${id}' not found for project '${projectId}'.`);
     }
     if (row.status !== status) {
-      throw new AgentStorageError2("invalid_state", `[SixbSqlite] Agent run '${id}' is not ${status} (status '${row.status}').`);
+      throw new AgentStorageError3("invalid_state", `[SixbSqlite] Agent run '${id}' is not ${status} (status '${row.status}').`);
     }
     return row;
   }
@@ -4074,7 +4347,7 @@ class SqliteAgentRunStore {
   requireRun(projectId, id) {
     const row = this.db.query("SELECT * FROM agent_runs WHERE project_id = ? AND id = ?").get(projectId, id);
     if (!row) {
-      throw new AgentStorageError2("run_not_found", `[SixbSqlite] Agent run '${id}' not found for project '${projectId}'.`);
+      throw new AgentStorageError3("run_not_found", `[SixbSqlite] Agent run '${id}' not found for project '${projectId}'.`);
     }
     return rowToRunRecord(row);
   }
@@ -4082,7 +4355,7 @@ class SqliteAgentRunStore {
 
 // src/agents/threads.ts
 import {
-  AgentStorageError as AgentStorageError3
+  AgentStorageError as AgentStorageError4
 } from "@sixb/core/storage";
 class SqliteAgentThreadStore {
   db;
@@ -4111,7 +4384,7 @@ class SqliteAgentThreadStore {
         `).run(input.projectId, input.id, input.agentId, input.ownerPrincipal.type, input.ownerPrincipal.id, input.title ?? null, input.status ?? "active", createdAt.toISOString(), updatedAt.toISOString());
     } catch (error) {
       if (isUniqueConstraintError2(error)) {
-        throw new AgentStorageError3("duplicate_id", `[SixbSqlite] Agent thread '${input.id}' already exists for project '${input.projectId}'.`);
+        throw new AgentStorageError4("duplicate_id", `[SixbSqlite] Agent thread '${input.id}' already exists for project '${input.projectId}'.`);
       }
       throw error;
     }
@@ -4158,7 +4431,7 @@ class SqliteAgentThreadStore {
   requireThread(projectId, id) {
     const row = this.db.query("SELECT * FROM agent_threads WHERE project_id = ? AND id = ?").get(projectId, id);
     if (!row) {
-      throw new AgentStorageError3("invalid_state", `[SixbSqlite] Failed to load agent thread '${id}' for project '${projectId}'.`);
+      throw new AgentStorageError4("invalid_state", `[SixbSqlite] Failed to load agent thread '${id}' for project '${projectId}'.`);
     }
     return rowToThreadRecord(row);
   }
@@ -4169,6 +4442,7 @@ class SqliteAgentStorage {
   threads;
   runs;
   messages;
+  checkpoints;
   connection;
   constructor(options) {
     this.connection = openSqliteStoreConnection(options);
@@ -4178,11 +4452,497 @@ class SqliteAgentStorage {
     this.threads = new SqliteAgentThreadStore(this.connection.db);
     this.runs = new SqliteAgentRunStore(this.connection.db, options.executions);
     this.messages = new SqliteAgentMessageStore(this.connection.db);
+    this.checkpoints = new SqliteAgentContextCheckpointStore(this.connection.db);
   }
   close() {
     closeSqliteStoreConnection(this.connection);
   }
 }
+// src/ai-cost-storage.ts
+import {
+  aiModelCallCostDetails,
+  aiModelCallCostMatchesUsage,
+  buildAiAccountingOverviewFromFragments,
+  normalizeAiAccountingQuery,
+  normalizeAiModelCallAccountingQuery,
+  normalizeAiModelCallCostRecord,
+  parseAiModelCallCostDetails,
+  toAccountingItem
+} from "@sixb/core/internal/ai-cost-storage-provider";
+import {
+  AiCostStorageError
+} from "@sixb/core/storage";
+class SqliteAiCostStorage {
+  connection;
+  constructor(connection) {
+    this.connection = connection;
+  }
+  async recordModelCallCost(input) {
+    const record = normalizeAiModelCallCostRecord(input);
+    runImmediateTransaction(this.connection.db, () => {
+      const usage = this.findUsage(record.projectId, record.usageRecordId);
+      if (!usage)
+        throw missingUsage(record);
+      assertCostMatchesUsage(record, usage);
+      if (this.findCost(record.projectId, record.usageRecordId))
+        return;
+      try {
+        this.insertCost(record);
+      } catch (error) {
+        if (!isUniqueConstraintError2(error))
+          throw error;
+        if (!this.findCost(record.projectId, record.usageRecordId))
+          throw error;
+      }
+    });
+  }
+  async summarizeExecutions(input) {
+    assertNonBlank(input.projectId, "cost summary projectId");
+    for (const id of input.executionIds)
+      assertNonBlank(id, "cost summary executionId");
+    if (input.executionIds.length === 0)
+      return [];
+    const rows = this.connection.db.query(`
+          WITH requested AS (SELECT DISTINCT value AS execution_id FROM json_each(?))
+          SELECT usage.execution_id,
+            cost.status,
+            cost.currency,
+            CAST(cost.amount_nanos AS TEXT) AS amount_nanos
+          FROM requested
+          JOIN ai_model_call_usage AS usage
+            ON usage.project_id = ? AND usage.execution_id = requested.execution_id
+          LEFT JOIN ai_model_call_valuations AS cost
+            ON cost.project_id = usage.project_id AND cost.usage_record_id = usage.id
+        `).all(JSON.stringify([...new Set(input.executionIds)]), input.projectId);
+    return aggregateSummaryRows(input.executionIds, rows);
+  }
+  async queryProjectOverview(input) {
+    const query = normalizeAiAccountingQuery(input);
+    const rows = this.connection.db.query(SQLITE_ACCOUNTING_OVERVIEW_SQL).all(query.projectId, query.from.toISOString(), query.to.toISOString(), query.providerId ?? null, query.providerId ?? null, query.modelId ?? null, query.modelId ?? null, input.bucket);
+    return buildAiAccountingOverviewFromFragments(input, rows.map(aggregateFragmentFromRow));
+  }
+  async listModelCalls(input) {
+    const query = normalizeAiModelCallAccountingQuery(input);
+    const parameters = accountingListFilterParameters(query);
+    const count = this.connection.db.query(SQLITE_ACCOUNTING_LIST_COUNT_SQL).get(...parameters);
+    const rows = this.connection.db.query(SQLITE_ACCOUNTING_LIST_PAGE_SQL).all(...parameters, query.limit, query.offset);
+    const items = rows.map((row) => toAccountingItem(accountingItemFromRow(row)));
+    const total = safeSqlCount(count.total, "model-call list total");
+    return structuredClone({
+      items,
+      total,
+      hasMore: query.offset + items.length < total
+    });
+  }
+  insertCost(record) {
+    const rated = record.status === "rated" ? record : undefined;
+    const details = aiModelCallCostDetails(record);
+    this.connection.db.query(`INSERT INTO ai_model_call_valuations (
+          project_id, usage_record_id, status, provider_id, model_id,
+          currency, amount_nanos, reason, details, rated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(record.projectId, record.usageRecordId, record.status, record.billingIdentity?.providerId ?? null, record.billingIdentity?.modelId ?? null, rated?.money.currency ?? null, rated ? BigInt(rated.money.amountNanos) : null, record.status === "unpriceable" ? record.reason : null, JSON.stringify(details), record.ratedAt.toISOString());
+  }
+  findCost(projectId, usageId) {
+    const row = this.connection.db.query(`SELECT *, CAST(amount_nanos AS TEXT) AS amount_nanos
+         FROM ai_model_call_valuations
+         WHERE project_id = ? AND usage_record_id = ?`).get(projectId, usageId);
+    return row ? rowToCost(row) : null;
+  }
+  findUsage(projectId, id) {
+    const row = this.connection.db.query("SELECT * FROM ai_model_call_usage WHERE project_id = ? AND id = ?").get(projectId, id);
+    return row ? usageFromRow(row, []) : null;
+  }
+}
+var SQLITE_ACCOUNTING_LIST_FILTER = `
+  usage.project_id = ? AND usage.occurred_at >= ? AND usage.occurred_at < ?
+  AND (? IS NULL OR usage.provider_id = ?)
+  AND (? IS NULL OR usage.requested_model_id = ?)
+  AND (? IS NULL OR usage.execution_id = ?)
+  AND (
+    ? IS NULL OR ? = CASE
+      WHEN cost.status = 'rated' THEN 'rated'
+      WHEN cost.status = 'unpriceable' THEN 'unpriceable'
+      ELSE 'unvalued'
+    END
+  )
+`;
+var SQLITE_ACCOUNTING_LIST_COUNT_SQL = `
+  SELECT CAST(COUNT(*) AS TEXT) AS total
+  FROM ai_model_call_usage AS usage
+  LEFT JOIN ai_model_call_valuations AS cost
+    ON cost.project_id = usage.project_id AND cost.usage_record_id = usage.id
+  WHERE ${SQLITE_ACCOUNTING_LIST_FILTER}
+`;
+var SQLITE_ACCOUNTING_LIST_PAGE_SQL = `
+  SELECT usage.*,
+    CASE
+      WHEN direct_agent.id IS NOT NULL THEN 'agent'
+      WHEN workflow_agent.node_run_id IS NOT NULL THEN 'workflowAgent'
+      ELSE NULL
+    END AS attribution_kind,
+    COALESCE(direct_agent.agent_id, workflow_agent.agent_id) AS attribution_agent_id,
+    direct_agent.id AS attribution_agent_run_id,
+    direct_agent.thread_id AS attribution_thread_id,
+    workflow_agent.node_run_id AS attribution_node_run_id,
+    workflow_node.workflow_id AS attribution_workflow_id,
+    workflow_node.workflow_run_id AS attribution_workflow_run_id,
+    COALESCE((
+      SELECT json_group_array(group_id) FROM (
+        SELECT group_id FROM ai_model_call_usage_groups
+        WHERE project_id = usage.project_id AND usage_record_id = usage.id
+        ORDER BY group_id
+      )
+    ), '[]') AS requester_group_ids,
+    cost.status AS cost_status,
+    cost.provider_id AS cost_provider_id,
+    cost.model_id AS cost_model_id,
+    cost.currency AS cost_currency,
+    CAST(cost.amount_nanos AS TEXT) AS cost_amount_nanos,
+    cost.reason AS cost_reason,
+    cost.details AS cost_details,
+    cost.rated_at AS cost_rated_at
+  FROM ai_model_call_usage AS usage
+  LEFT JOIN agent_runs AS direct_agent
+    ON direct_agent.project_id = usage.project_id
+    AND direct_agent.execution_id = usage.execution_id
+  LEFT JOIN workflow_agent_node_runs AS workflow_agent
+    ON workflow_agent.project_id = usage.project_id
+    AND workflow_agent.execution_id = usage.execution_id
+  LEFT JOIN workflow_node_runs AS workflow_node
+    ON workflow_node.project_id = workflow_agent.project_id
+    AND workflow_node.id = workflow_agent.node_run_id
+  LEFT JOIN ai_model_call_valuations AS cost
+    ON cost.project_id = usage.project_id AND cost.usage_record_id = usage.id
+  WHERE ${SQLITE_ACCOUNTING_LIST_FILTER}
+  ORDER BY usage.occurred_at DESC, usage.id ASC
+  LIMIT ? OFFSET ?
+`;
+var SQLITE_ACCOUNTING_OVERVIEW_SQL = `
+  WITH classified AS (
+    SELECT usage.provider_id,
+      usage.requested_model_id,
+      usage.occurred_at,
+      usage.input_tokens,
+      usage.output_tokens,
+      usage.uncached_input_tokens,
+      usage.cache_read_input_tokens,
+      usage.cache_write_input_tokens,
+      usage.text_output_tokens,
+      usage.reasoning_output_tokens,
+      usage.reporting_status,
+      COALESCE(direct_agent.agent_id, workflow_agent.agent_id) AS attribution_agent_id,
+      workflow_node.workflow_id AS attribution_workflow_id,
+      CASE
+        WHEN cost.status = 'rated' THEN 'rated'
+        WHEN cost.status = 'unpriceable' THEN 'unpriceable'
+        ELSE 'unvalued'
+      END AS valuation_status,
+      CASE WHEN cost.status = 'rated' THEN cost.currency ELSE NULL END AS amount_currency,
+      CASE WHEN cost.status = 'rated' THEN cost.amount_nanos ELSE NULL END AS amount_nanos
+    FROM ai_model_call_usage AS usage
+    LEFT JOIN agent_runs AS direct_agent
+      ON direct_agent.project_id = usage.project_id
+      AND direct_agent.execution_id = usage.execution_id
+    LEFT JOIN workflow_agent_node_runs AS workflow_agent
+      ON workflow_agent.project_id = usage.project_id
+      AND workflow_agent.execution_id = usage.execution_id
+    LEFT JOIN workflow_node_runs AS workflow_node
+      ON workflow_node.project_id = workflow_agent.project_id
+      AND workflow_node.id = workflow_agent.node_run_id
+    LEFT JOIN ai_model_call_valuations AS cost
+      ON cost.project_id = usage.project_id AND cost.usage_record_id = usage.id
+    WHERE usage.project_id = ? AND usage.occurred_at >= ? AND usage.occurred_at < ?
+      AND (? IS NULL OR usage.provider_id = ?)
+      AND (? IS NULL OR usage.requested_model_id = ?)
+  ), expanded AS (
+    SELECT 'totals' AS dimension, NULL AS key_1, NULL AS key_2, NULL AS bucket_start,
+      classified.*
+    FROM classified
+    UNION ALL
+    SELECT 'series', NULL, NULL,
+      CASE ?
+        WHEN 'hour' THEN strftime('%Y-%m-%dT%H:00:00.000Z', occurred_at)
+        WHEN 'day' THEN strftime('%Y-%m-%dT00:00:00.000Z', occurred_at)
+        ELSE strftime(
+          '%Y-%m-%dT00:00:00.000Z',
+          occurred_at,
+          printf('-%d days', (CAST(strftime('%w', occurred_at) AS INTEGER) + 6) % 7)
+        )
+      END,
+      classified.*
+    FROM classified
+    UNION ALL
+    SELECT 'model', provider_id, requested_model_id, NULL, classified.* FROM classified
+    UNION ALL
+    SELECT 'agent', attribution_agent_id, NULL, NULL, classified.*
+    FROM classified WHERE attribution_agent_id IS NOT NULL
+    UNION ALL
+    SELECT 'workflow', attribution_workflow_id, NULL, NULL, classified.*
+    FROM classified WHERE attribution_workflow_id IS NOT NULL
+  )
+  SELECT dimension,
+    key_1,
+    key_2,
+    bucket_start,
+    amount_currency,
+    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(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,
+    CAST(SUM(output_tokens) AS TEXT) AS output_tokens_sum,
+    CAST(COUNT(uncached_input_tokens) AS TEXT) AS uncached_input_tokens_count,
+    CAST(SUM(uncached_input_tokens) AS TEXT) AS uncached_input_tokens_sum,
+    CAST(COUNT(cache_read_input_tokens) AS TEXT) AS cache_read_input_tokens_count,
+    CAST(SUM(cache_read_input_tokens) AS TEXT) AS cache_read_input_tokens_sum,
+    CAST(COUNT(cache_write_input_tokens) AS TEXT) AS cache_write_input_tokens_count,
+    CAST(SUM(cache_write_input_tokens) AS TEXT) AS cache_write_input_tokens_sum,
+    CAST(COUNT(text_output_tokens) AS TEXT) AS text_output_tokens_count,
+    CAST(SUM(text_output_tokens) AS TEXT) AS text_output_tokens_sum,
+    CAST(COUNT(reasoning_output_tokens) AS TEXT) AS reasoning_output_tokens_count,
+    CAST(SUM(reasoning_output_tokens) AS TEXT) AS reasoning_output_tokens_sum,
+    CAST(SUM(CASE WHEN valuation_status = 'rated' THEN 1 ELSE 0 END) AS TEXT)
+      AS rated_call_count,
+    CAST(SUM(CASE WHEN valuation_status = 'unpriceable' THEN 1 ELSE 0 END) AS TEXT)
+      AS unpriceable_call_count,
+    CAST(SUM(CASE WHEN valuation_status = 'unvalued' THEN 1 ELSE 0 END) AS TEXT)
+      AS unvalued_call_count,
+    CAST(SUM(amount_nanos / 1000000000000) AS TEXT) AS amount_high,
+    CAST(SUM((amount_nanos / 1000000) % 1000000) AS TEXT) AS amount_middle,
+    CAST(SUM(amount_nanos % 1000000) AS TEXT) AS amount_low
+  FROM expanded
+  GROUP BY dimension, key_1, key_2, bucket_start, amount_currency
+`;
+function accountingListFilterParameters(query) {
+  return [
+    query.projectId,
+    query.from.toISOString(),
+    query.to.toISOString(),
+    query.providerId ?? null,
+    query.providerId ?? null,
+    query.modelId ?? null,
+    query.modelId ?? null,
+    query.executionId ?? null,
+    query.executionId ?? null,
+    query.valuationStatus ?? null,
+    query.valuationStatus ?? null
+  ];
+}
+function aggregateFragmentFromRow(row) {
+  const dimensionKeys = row.dimension === "model" ? { providerId: required(row.key_1), modelId: required(row.key_2) } : row.dimension === "agent" ? { agentId: required(row.key_1) } : row.dimension === "workflow" ? { workflowId: required(row.key_1) } : row.dimension === "series" ? { start: new Date(required(row.bucket_start)) } : {};
+  return {
+    dimension: row.dimension,
+    ...dimensionKeys,
+    modelCallCount: row.model_call_count,
+    usage: {
+      reportedCallCount: row.reported_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),
+      cacheReadInputTokens: meterFragment(row.cache_read_input_tokens_count, row.cache_read_input_tokens_sum),
+      cacheWriteInputTokens: meterFragment(row.cache_write_input_tokens_count, row.cache_write_input_tokens_sum),
+      textOutputTokens: meterFragment(row.text_output_tokens_count, row.text_output_tokens_sum),
+      reasoningOutputTokens: meterFragment(row.reasoning_output_tokens_count, row.reasoning_output_tokens_sum)
+    },
+    costs: {
+      ...row.amount_currency === null || row.amount_high === null || row.amount_middle === null || row.amount_low === null ? {} : {
+        amount: {
+          currency: row.amount_currency,
+          amountNanos: sqliteAggregateAmount(row)
+        }
+      },
+      ratedCallCount: row.rated_call_count,
+      unpriceableCallCount: row.unpriceable_call_count,
+      unvaluedCallCount: row.unvalued_call_count
+    }
+  };
+}
+function meterFragment(presentCallCount, total) {
+  return { presentCallCount, total };
+}
+function sqliteAggregateAmount(row) {
+  return (BigInt(required(row.amount_high)) * 1000000000000n + BigInt(required(row.amount_middle)) * 1000000n + BigInt(required(row.amount_low))).toString();
+}
+function accountingItemFromRow(row) {
+  const usage = usageFromRow(row, parseStringArray(row.requester_group_ids));
+  const cost = row.cost_status === null ? undefined : costFromJoinedRow(row);
+  const attribution = row.attribution_kind === null ? undefined : row.attribution_kind === "agent" ? {
+    kind: "agent",
+    agentId: required(row.attribution_agent_id),
+    agentRunId: required(row.attribution_agent_run_id),
+    threadId: required(row.attribution_thread_id)
+  } : {
+    kind: "workflowAgent",
+    agentId: required(row.attribution_agent_id),
+    nodeRunId: required(row.attribution_node_run_id),
+    workflowId: required(row.attribution_workflow_id),
+    workflowRunId: required(row.attribution_workflow_run_id)
+  };
+  return {
+    usage,
+    ...attribution ? { attribution } : {},
+    ...cost ? { cost } : {}
+  };
+}
+function usageFromRow(row, requesterGroupIds) {
+  return {
+    id: row.id,
+    projectId: row.project_id,
+    executionId: row.execution_id,
+    attempt: row.attempt,
+    callId: row.call_id,
+    requesterGroupIds,
+    providerId: row.provider_id,
+    requestedModelId: row.requested_model_id,
+    ...row.response_model_id === null ? {} : { responseModelId: row.response_model_id },
+    responseId: row.response_id,
+    usage: {
+      ...row.input_tokens === null ? {} : { inputTokens: row.input_tokens },
+      ...row.output_tokens === null ? {} : { outputTokens: row.output_tokens },
+      ...row.total_tokens === null ? {} : { totalTokens: row.total_tokens },
+      ...row.uncached_input_tokens === null ? {} : { uncachedInputTokens: row.uncached_input_tokens },
+      ...row.cache_read_input_tokens === null ? {} : { cacheReadInputTokens: row.cache_read_input_tokens },
+      ...row.cache_write_input_tokens === null ? {} : { cacheWriteInputTokens: row.cache_write_input_tokens },
+      ...row.text_output_tokens === null ? {} : { textOutputTokens: row.text_output_tokens },
+      ...row.reasoning_output_tokens === null ? {} : { reasoningOutputTokens: row.reasoning_output_tokens },
+      reportingStatus: row.reporting_status
+    },
+    ...row.raw_usage === null ? {} : { rawUsage: JSON.parse(row.raw_usage) },
+    occurredAt: new Date(row.occurred_at),
+    recordedAt: new Date(row.recorded_at)
+  };
+}
+function rowToCost(row) {
+  return costRecord({
+    projectId: row.project_id,
+    usageId: row.usage_record_id,
+    status: row.status,
+    providerId: row.provider_id,
+    modelId: row.model_id,
+    currency: row.currency,
+    amountNanos: row.amount_nanos,
+    reason: row.reason,
+    details: row.details,
+    ratedAt: row.rated_at
+  });
+}
+function costFromJoinedRow(row) {
+  return costRecord({
+    projectId: row.project_id,
+    usageId: row.id,
+    status: required(row.cost_status),
+    providerId: row.cost_provider_id,
+    modelId: row.cost_model_id,
+    currency: row.cost_currency,
+    amountNanos: row.cost_amount_nanos,
+    reason: row.cost_reason,
+    details: required(row.cost_details),
+    ratedAt: required(row.cost_rated_at)
+  });
+}
+function costRecord(input) {
+  const details = parseAiModelCallCostDetails(input.details);
+  const base = {
+    projectId: input.projectId,
+    usageRecordId: input.usageId,
+    pricingContext: details.pricingContext,
+    priceSource: {
+      ...details.priceSource,
+      observedAt: new Date(details.priceSource.observedAt)
+    },
+    ratedAt: new Date(input.ratedAt)
+  };
+  if (input.status === "rated") {
+    return normalizeAiModelCallCostRecord({
+      ...base,
+      status: "rated",
+      billingIdentity: { providerId: required(input.providerId), modelId: required(input.modelId) },
+      money: { currency: required(input.currency), amountNanos: required(input.amountNanos) },
+      components: required(details.components)
+    });
+  }
+  return normalizeAiModelCallCostRecord({
+    ...base,
+    status: "unpriceable",
+    ...input.providerId && input.modelId ? { billingIdentity: { providerId: input.providerId, modelId: input.modelId } } : {},
+    reason: required(input.reason),
+    ...details.missingMeters ? { missingMeters: details.missingMeters } : {}
+  });
+}
+function aggregateSummaryRows(ids, rows) {
+  const map = new Map(ids.map((id) => [id, accumulator()]));
+  for (const row of rows) {
+    const value = map.get(row.execution_id);
+    if (!value)
+      continue;
+    if (row.status === null)
+      value.unvaluedCallCount += 1;
+    else if (row.status === "unpriceable")
+      value.unpriceableCallCount += 1;
+    else {
+      value.ratedCallCount += 1;
+      add(value.amounts, required(row.currency), required(row.amount_nanos));
+    }
+  }
+  return ids.map((id) => finish(map.get(id)));
+}
+function accumulator() {
+  return {
+    amounts: new Map,
+    ratedCallCount: 0,
+    unpriceableCallCount: 0,
+    unvaluedCallCount: 0
+  };
+}
+function finish(value) {
+  return {
+    amounts: [...value.amounts].sort(([left], [right]) => left.localeCompare(right)).map(([currency, amount]) => ({ currency, amountNanos: amount.toString() })),
+    ratedCallCount: value.ratedCallCount,
+    unpriceableCallCount: value.unpriceableCallCount,
+    unvaluedCallCount: value.unvaluedCallCount
+  };
+}
+function add(amounts, currency, amount) {
+  amounts.set(currency, (amounts.get(currency) ?? 0n) + BigInt(amount));
+}
+function assertCostMatchesUsage(record, usage) {
+  if (!aiModelCallCostMatchesUsage(record, usage)) {
+    throw new AiCostStorageError("cost_mismatch", `[SixbSqlite] AI valuation for usage '${record.usageRecordId}' does not match its usage record.`);
+  }
+}
+function missingUsage(record) {
+  return new AiCostStorageError("missing_usage", `[SixbSqlite] AI usage '${record.usageRecordId}' does not exist.`);
+}
+function parseStringArray(value) {
+  const parsed = JSON.parse(value);
+  if (!Array.isArray(parsed) || parsed.some((item) => typeof item !== "string")) {
+    throw new Error("[SixbSqlite] AI requester group ids are invalid.");
+  }
+  return parsed;
+}
+function assertNonBlank(value, field) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new TypeError(`[Sixb] AI ${field} must be nonblank.`);
+  }
+}
+function safeSqlCount(value, field) {
+  if (!/^(0|[1-9]\d*)$/.test(value)) {
+    throw new Error(`[SixbSqlite] AI accounting ${field} is invalid.`);
+  }
+  const count = Number(value);
+  if (!Number.isSafeInteger(count)) {
+    throw new TypeError(`[Sixb] AI accounting ${field} exceeds the safe integer range.`);
+  }
+  return count;
+}
+function required(value) {
+  if (value === null || value === undefined) {
+    throw new Error("[SixbSqlite] AI valuation column is unexpectedly null.");
+  }
+  return value;
+}
+
 // src/ai-usage-storage.ts
 import {
   AiUsageStorageError,
@@ -4232,6 +4992,17 @@ class SqliteAiUsageStorage {
     });
     return summary;
   }
+  async getLatestForExecution(input) {
+    assertNonBlankProjectId(input.projectId);
+    assertAiUsageExecutionId(input.executionId);
+    const row = this.connection.db.query(`
+          SELECT * FROM ai_model_call_usage
+          WHERE project_id = ? AND execution_id = ?
+          ORDER BY occurred_at DESC, id DESC
+          LIMIT 1
+        `).get(input.projectId, input.executionId);
+    return row ? this.rowToRecord(row) : null;
+  }
   async summarizeExecutions(input) {
     assertNonBlankProjectId(input.projectId);
     for (const executionId of input.executionIds)
@@ -4308,7 +5079,7 @@ class SqliteAiUsageStorage {
       ...row.response_model_id === null ? {} : { responseModelId: row.response_model_id },
       responseId: row.response_id,
       usage: {
-        ...usageFromRow(row),
+        ...usageFromRow2(row),
         ...row.total_tokens === null ? {} : { totalTokens: row.total_tokens },
         reportingStatus: row.reporting_status
       },
@@ -4342,7 +5113,7 @@ function aggregateExecutionRows(executionIds, rows) {
   for (const executionId of executionIds)
     usageByExecutionId.set(executionId, []);
   for (const row of rows) {
-    usageByExecutionId.get(row.execution_id)?.push(usageFromRow(row));
+    usageByExecutionId.get(row.execution_id)?.push(usageFromRow2(row));
   }
   return executionIds.map((executionId) => {
     const usages = usageByExecutionId.get(executionId) ?? [];
@@ -4352,7 +5123,7 @@ function aggregateExecutionRows(executionIds, rows) {
     };
   });
 }
-function usageFromRow(row) {
+function usageFromRow2(row) {
   return {
     ...row.input_tokens === null ? {} : { inputTokens: row.input_tokens },
     ...row.output_tokens === null ? {} : { outputTokens: row.output_tokens },
@@ -6582,7 +7353,7 @@ function connectionRunFromRow(row) {
       ...base,
       status: "waiting",
       waitingFor: "provider_authorization",
-      expiresAt: new Date(required(row.expires_at, "run expiry"))
+      expiresAt: new Date(required2(row.expires_at, "run expiry"))
     };
   }
   if (row.status === "waiting" && row.waiting_for === "account_selection") {
@@ -6590,28 +7361,28 @@ function connectionRunFromRow(row) {
       ...base,
       status: "waiting",
       waitingFor: "account_selection",
-      authorizationId: required(row.authorization_id, "authorization id"),
-      expiresAt: new Date(required(row.expires_at, "run expiry"))
+      authorizationId: required2(row.authorization_id, "authorization id"),
+      expiresAt: new Date(required2(row.expires_at, "run expiry"))
     };
   }
   if (row.status === "running") {
     return {
       ...base,
       status: "running",
-      processingId: required(row.processing_id, "processing id"),
-      callbackStartedAt: new Date(required(row.callback_started_at, "callback start")),
-      expiresAt: new Date(required(row.expires_at, "run expiry")),
+      processingId: required2(row.processing_id, "processing id"),
+      callbackStartedAt: new Date(required2(row.callback_started_at, "callback start")),
+      expiresAt: new Date(required2(row.expires_at, "run expiry")),
       ...row.authorization_id === null ? {} : { authorizationId: row.authorization_id }
     };
   }
-  const finishedAt = new Date(required(row.finished_at, "run finish"));
+  const finishedAt = new Date(required2(row.finished_at, "run finish"));
   if (row.status === "succeeded") {
     return {
       ...base,
       status: "succeeded",
-      authorizationId: required(row.authorization_id, "authorization id"),
+      authorizationId: required2(row.authorization_id, "authorization id"),
       ...row.cleanup_authorization_id === null ? {} : { cleanupAuthorizationId: row.cleanup_authorization_id },
-      connections: parseJson(required(row.connections, "connections")).map(connectionFromSerialized),
+      connections: parseJson(required2(row.connections, "connections")).map(connectionFromSerialized),
       finishedAt
     };
   }
@@ -6619,7 +7390,7 @@ function connectionRunFromRow(row) {
     return {
       ...base,
       status: "failed",
-      error: parseJson(required(row.error, "run error")),
+      error: parseJson(required2(row.error, "run error")),
       ...row.authorization_id === null ? {} : { authorizationId: row.authorization_id },
       finishedAt
     };
@@ -6689,20 +7460,20 @@ function authorizationFromRow(row) {
 function mutationFromRow(row) {
   if (row.mutation_id === null)
     return;
-  const kind = required(row.mutation_kind, "credential mutation kind");
-  const phase = required(row.mutation_phase, "credential mutation phase");
+  const kind = required2(row.mutation_kind, "credential mutation kind");
+  const phase = required2(row.mutation_phase, "credential mutation phase");
   const stagedCredentials = row.staged_credentials === null ? undefined : {
     credentials: parseJson(row.staged_credentials),
     ...row.staged_credential_expires_at === null ? {} : { credentialExpiresAt: new Date(row.staged_credential_expires_at) },
-    scopes: parseJson(required(row.staged_scopes, "staged credential scopes"))
+    scopes: parseJson(required2(row.staged_scopes, "staged credential scopes"))
   };
   return {
     id: row.mutation_id,
     kind,
     phase,
-    holderId: required(row.mutation_holder_id, "credential mutation holder"),
-    expiresAt: new Date(required(row.mutation_expires_at, "credential mutation expiry")),
-    deadlineAt: new Date(required(row.mutation_deadline_at, "credential mutation deadline")),
+    holderId: required2(row.mutation_holder_id, "credential mutation holder"),
+    expiresAt: new Date(required2(row.mutation_expires_at, "credential mutation expiry")),
+    deadlineAt: new Date(required2(row.mutation_deadline_at, "credential mutation deadline")),
     ...row.mutation_expected_connection_ids === null ? {} : {
       expectedConnectionIds: parseJson(row.mutation_expected_connection_ids)
     },
@@ -6745,7 +7516,7 @@ function iso(value) {
 function optionalIso(value) {
   return value?.toISOString() ?? null;
 }
-function required(value, label) {
+function required2(value, label) {
   if (value !== null)
     return value;
   throw new Error(`[SixbSqlite] Stored ${label} is missing.`);
@@ -6850,6 +7621,9 @@ function isDuplicateExecutionError(error) {
   return error instanceof Error && error.message.includes("UNIQUE constraint failed: executions.project_id, executions.id");
 }
 
+// src/object-storage.ts
+import { linkBatchKey, objectBatchKey } from "@sixb/core/storage";
+
 // src/object-query-compiler.ts
 import {
   ObjectQueryExecutionError
@@ -6865,6 +7639,8 @@ function compileObjectQueryInternal(projectId, query, ctx) {
   switch (query.kind) {
     case "start":
       return compileStart(projectId, query);
+    case "refs":
+      return compileRefs(projectId, query);
     case "filter":
       return compileFilter(projectId, query.input, query.predicate);
     case "sort":
@@ -6912,6 +7688,50 @@ function compileStart(projectId, query) {
     }
   };
 }
+function compileRefs(projectId, query) {
+  if (query.refs.length === 0) {
+    throw new Error("[Sixb] SQLite object storage requires at least one ref");
+  }
+  const order = compileOrder(identityOrderFields());
+  const selectedOrder = compileOrder(identityOrderFields(), "selected");
+  const refsJson = JSON.stringify(query.refs);
+  const requested = `
+    SELECT DISTINCT
+      json_extract(ref.value, '$.objectTypeId') AS object_type_id,
+      json_extract(ref.value, '$.primaryId') AS primary_id
+    FROM json_each(?) AS ref
+  `;
+  const sql = `
+    WITH requested AS (${requested})
+    SELECT selected.*, selected.properties AS _cursor_properties
+    FROM requested
+    JOIN objects AS selected
+      ON selected.project_id = ?
+     AND selected.object_type_id = requested.object_type_id
+     AND selected.primary_id = requested.primary_id
+    ORDER BY ${selectedOrder.sql}
+  `;
+  return {
+    sql,
+    args: [refsJson, projectId, ...selectedOrder.args],
+    totalSql: `
+      WITH requested AS (${requested})
+      SELECT COUNT(*) AS total
+      FROM requested
+      JOIN objects AS selected
+        ON selected.project_id = ?
+       AND selected.object_type_id = requested.object_type_id
+       AND selected.primary_id = requested.primary_id
+    `,
+    totalArgs: [refsJson, projectId],
+    order,
+    hasMore: () => false,
+    trimRows: identityRows,
+    nextPageToken: () => {
+      return;
+    }
+  };
+}
 function compileFilter(projectId, inputQuery, predicateNode) {
   const predicate = compilePredicate(predicateNode);
   return compileWhere(projectId, inputQuery, predicate);
@@ -7655,6 +8475,7 @@ var SQLITE_OBJECT_QUERY_CAPABILITIES = {
   facetObjects: true,
   nodes: {
     start: true,
+    refs: true,
     filter: true,
     text: true,
     sort: true,
@@ -7706,7 +8527,7 @@ var SQLITE_OBJECT_QUERY_CAPABILITIES = {
     stablePageTokens: true
   },
   notes: [
-    "SQLite object query pushdown supports start/filter/text/sort/limit/page/traverse/set/project/expand over JSON properties and object links.",
+    "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."
@@ -7785,12 +8606,16 @@ class SqliteObjectStorage {
     const result = new Map;
     if (params.items.length === 0)
       return result;
-    const stmt = this.db.query("SELECT * FROM objects WHERE project_id = ? AND object_type_id = ? AND primary_id = ?");
-    for (const item of params.items) {
-      const row = stmt.get(params.projectId, item.objectTypeId, item.primaryId);
-      if (row) {
-        result.set(`${item.objectTypeId}:${item.primaryId}`, this.rowToObject(row));
-      }
+    const rows = this.db.query(`
+          SELECT object.*
+          FROM json_each(?) AS requested
+          JOIN objects AS object
+            ON object.project_id = ?
+           AND object.object_type_id = json_extract(requested.value, '$.objectTypeId')
+           AND object.primary_id = json_extract(requested.value, '$.primaryId')
+        `).all(JSON.stringify(params.items), params.projectId);
+    for (const row of rows) {
+      result.set(objectBatchKey(row.object_type_id, row.primary_id), this.rowToObject(row));
     }
     return result;
   }
@@ -7802,25 +8627,95 @@ class SqliteObjectStorage {
     for (const item of params.items) {
       const rows = stmt.all(params.projectId, item.objectTypeId, item.objectId, item.linkId);
       if (rows.length > 0) {
-        result.set(`${item.objectTypeId}:${item.objectId}:${item.linkId}`, rows.map((r) => this.rowToLink(r)));
+        result.set(linkBatchKey(item.objectTypeId, item.objectId, item.linkId), rows.map((r) => this.rowToLink(r)));
       }
     }
     return result;
   }
-  async listIncidentLinksBatch(params) {
-    const deduped = new Map;
-    for (const item of params.items) {
-      const rows = await this.listLinks({
-        projectId: params.projectId,
-        objectTypeId: item.objectTypeId,
-        objectId: item.objectId,
-        direction: "both"
-      });
-      for (const row of rows) {
-        deduped.set(`${row.sourceTypeId}:${row.sourceId}:${row.linkId}:${row.targetTypeId}:${row.targetId}`, row);
-      }
+  async queryLinks(params) {
+    assertLinkQueryLimit(params.limit);
+    if (params.objectRefs.length === 0 || params.endpointObjectTypeIds?.length === 0) {
+      return { links: [], hasMore: false };
+    }
+    const sourceJoin = `
+      SELECT link.*
+      FROM links AS link
+      JOIN requested
+        ON requested.object_type_id = link.source_type_id
+       AND requested.object_id = link.source_id
+      WHERE link.project_id = ?
+    `;
+    const targetJoin = `
+      SELECT link.*
+      FROM links AS link
+      JOIN requested
+        ON requested.object_type_id = link.target_type_id
+       AND requested.object_id = link.target_id
+      WHERE link.project_id = ?
+    `;
+    const incidentSql = params.direction === "outgoing" ? sourceJoin : params.direction === "incoming" ? targetJoin : `${sourceJoin} UNION ${targetJoin}`;
+    const args = [JSON.stringify(params.objectRefs), params.projectId];
+    if (params.direction === "both")
+      args.push(params.projectId);
+    const predicates = [];
+    if (params.linkId !== undefined) {
+      predicates.push("link_id = ?");
+      args.push(params.linkId);
+    }
+    if (params.endpointObjectTypeIds !== undefined) {
+      const allowedTypes = JSON.stringify([...new Set(params.endpointObjectTypeIds)]);
+      predicates.push("source_type_id IN (SELECT value FROM json_each(?))", "target_type_id IN (SELECT value FROM json_each(?))");
+      args.push(allowedTypes, allowedTypes);
     }
-    return [...deduped.values()];
+    if (params.after) {
+      predicates.push("(source_type_id, source_id, link_id, target_type_id, target_id) > (?, ?, ?, ?, ?)");
+      args.push(...params.after);
+    }
+    args.push(params.limit + 1);
+    const whereSql = predicates.length > 0 ? `WHERE ${predicates.join(" AND ")}` : "";
+    const rows = this.db.query(`
+          WITH requested AS (
+            SELECT DISTINCT
+              json_extract(value, '$.objectTypeId') AS object_type_id,
+              json_extract(value, '$.primaryId') AS object_id
+            FROM json_each(?)
+          ), incident AS (${incidentSql})
+          SELECT *
+          FROM incident
+          ${whereSql}
+          ORDER BY source_type_id, source_id, link_id, target_type_id, target_id
+          LIMIT ?
+        `).all(...args);
+    return {
+      links: rows.slice(0, params.limit).map((row) => this.rowToLink(row)),
+      hasMore: rows.length > params.limit
+    };
+  }
+  async listIncidentLinksBatch(params) {
+    if (params.items.length === 0)
+      return [];
+    const rows = this.db.query(`
+          WITH requested AS (
+            SELECT
+              json_extract(value, '$.objectTypeId') AS object_type_id,
+              json_extract(value, '$.objectId') AS object_id
+            FROM json_each(?)
+          )
+          SELECT link.*
+          FROM links AS link
+          JOIN requested
+            ON requested.object_type_id = link.source_type_id
+           AND requested.object_id = link.source_id
+          WHERE link.project_id = ?
+          UNION
+          SELECT link.*
+          FROM links AS link
+          JOIN requested
+            ON requested.object_type_id = link.target_type_id
+           AND requested.object_id = link.target_id
+          WHERE link.project_id = ?
+        `).all(JSON.stringify(params.items), params.projectId, params.projectId);
+    return rows.map((row) => this.rowToLink(row));
   }
   async listByPrimaryIdPage(params) {
     assertReconciliationPageLimit(params.limit);
@@ -7932,6 +8827,11 @@ function assertReconciliationPageLimit(limit) {
     throw new Error("Object reconciliation page limit must be a positive safe integer.");
   }
 }
+function assertLinkQueryLimit(limit) {
+  if (!Number.isSafeInteger(limit) || limit <= 0) {
+    throw new Error("Object link query limit must be a positive safe integer.");
+  }
+}
 function readTotal(db, compiled) {
   const row = db.query(compiled.totalSql).get(...compiled.totalArgs);
   return row.total;
@@ -8561,13 +9461,13 @@ class SqliteMaterializationStateReader {
           ORDER BY requested.scope_sort_key, ${linkSortExpression("links")}
         `).iterate(requestedJson, this.projectId);
     for (const row of rows) {
-      const accumulator = accumulators.get(row.scope_sort_key);
-      if (!accumulator) {
+      const accumulator2 = accumulators.get(row.scope_sort_key);
+      if (!accumulator2) {
         throw new MaterializationConflictError2("effective-state", `Unexpected link scope '${row.scope_sort_key}' returned by storage.`);
       }
       const snapshot = effectiveLinkSnapshot(row);
-      appendScopeSnapshot(accumulator, snapshot);
-      effective.set(row.scope_sort_key, accumulator.effectiveCount === 1 ? snapshot : null);
+      appendScopeSnapshot(accumulator2, snapshot);
+      effective.set(row.scope_sort_key, accumulator2.effectiveCount === 1 ? snapshot : null);
     }
     return scopes.map(({ source, linkId }) => {
       const key = linkScopeSortKey(source, linkId);
@@ -8927,6 +9827,7 @@ function storedObjectOverride(row) {
   return {
     ref,
     value: parseJson2(row.value),
+    editedAt: parseJson2(row.edited_at),
     lastCommitId: row.last_commit_id,
     updatedAt: row.updated_at
   };
@@ -9416,8 +10317,9 @@ class SqliteMaterializationWriter {
       if (item.expectedLastCommitId === null) {
         try {
           this.db.query(`INSERT INTO ontology_object_overrides (
-                 project_id, object_type_id, primary_id, value, last_commit_id, updated_at
-               ) VALUES (?, ?, ?, json(?), ?, ?)`).run(projectId, item.ref.objectTypeId, item.ref.primaryId, canonicalJson(item.value), item.lastCommitId, item.updatedAt);
+                 project_id, object_type_id, primary_id, value, edited_at,
+                 last_commit_id, updated_at
+               ) VALUES (?, ?, ?, json(?), json(?), ?, ?)`).run(projectId, item.ref.objectTypeId, item.ref.primaryId, canonicalJson(item.value), canonicalJson(item.editedAt), item.lastCommitId, item.updatedAt);
         } catch (error) {
           if (isSqliteConstraintError(error)) {
             throw effectiveConflict("Expected object override changed.");
@@ -9427,9 +10329,9 @@ class SqliteMaterializationWriter {
         continue;
       }
       requireChanges(this.db.query(`UPDATE ontology_object_overrides
-             SET value = json(?), last_commit_id = ?, updated_at = ?
+             SET value = json(?), edited_at = json(?), last_commit_id = ?, updated_at = ?
              WHERE project_id = ? AND object_type_id = ? AND primary_id = ?
-               AND last_commit_id = ?`).run(canonicalJson(item.value), item.lastCommitId, item.updatedAt, projectId, item.ref.objectTypeId, item.ref.primaryId, item.expectedLastCommitId).changes, "effective-state", "Expected object override changed.");
+               AND last_commit_id = ?`).run(canonicalJson(item.value), canonicalJson(item.editedAt), item.lastCommitId, item.updatedAt, projectId, item.ref.objectTypeId, item.ref.primaryId, item.expectedLastCommitId).changes, "effective-state", "Expected object override changed.");
     }
     for (const item of chunk.overrides.objects.deletes) {
       requireChanges(this.db.query(`DELETE FROM ontology_object_overrides
@@ -12984,6 +13886,7 @@ class SqliteStorage {
   executions;
   agents;
   aiUsage;
+  aiCosts;
   actionRuns;
   pipelineRuns;
   syncRuns;
@@ -13030,6 +13933,7 @@ class SqliteStorage {
     this.executions = createOperationScopedFacade(stores.executions, scope);
     this.agents = createAgentOperationScope(stores.agents, scope);
     this.aiUsage = createOperationScopedFacade(stores.aiUsage, scope);
+    this.aiCosts = createOperationScopedFacade(stores.aiCosts, scope);
     this.actionRuns = createOperationScopedFacade(stores.actionRuns, scope);
     this.pipelineRuns = createOperationScopedFacade(stores.pipelineRuns, scope);
     this.timeseries = createOperationScopedFacade(readTimeseries, readScope);
@@ -13149,6 +14053,7 @@ function createSqliteStores(connection, options) {
     executions,
     agents: new SqliteAgentStorage({ connection, executions }),
     aiUsage: new SqliteAiUsageStorage({ connection }),
+    aiCosts: new SqliteAiCostStorage(connection),
     actionRuns: new SqliteActionRunStorage({ connection, executions }),
     pipelineRuns: new SqlitePipelineRunStorage({ connection, executions }),
     timeseries: new SqliteTimeseriesStorage({ connection }),
@@ -13166,4 +14071,4 @@ export {
   SqliteStorage
 };
 
-//# debugId=7215BBCFE4EA2F6564756E2164756E21
+//# debugId=2D24EFD822513C9E64756E2164756E21