@sixb/pg 0.1.2 → 0.1.4

package/dist/index.js

@@ -16,8 +16,14 @@ import {
   throwNestedStorageTransaction
 } from "@sixb/core/storage";
 
-// 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";
@@ -149,6 +155,28 @@ function rowToMessageRecord(row) {
     completedAt: row.completed_at ? new Date(row.completed_at) : undefined
   };
 }
+function rowToContextCheckpointRecord(row) {
+  const summaryFormatVersion = Number(row.summary_format_version);
+  if (summaryFormatVersion !== 1) {
+    throw new Error(`[SixbPg] Unsupported agent context checkpoint summary format version '${summaryFormatVersion}'.`);
+  }
+  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: Number(row.summarized_through_seq),
+    observedHeadSeq: Number(row.observed_head_seq),
+    estimatedInputTokensBefore: Number(row.estimated_input_tokens_before),
+    estimatedInputTokensAfter: Number(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;
 }
@@ -184,7 +212,162 @@ async function queryAgentList(input) {
   return { rows, total, hasMore: offset + rows.length < total };
 }
 
+// src/agents/checkpoints.ts
+var PG_CHECKPOINT_RUN_ID_BATCH_SIZE = 1e4;
+
+class PgAgentContextCheckpointStore {
+  sql;
+  constructor(sql) {
+    this.sql = sql;
+  }
+  async create(input) {
+    assertCreateAgentContextCheckpointInput(input, "SixbPg");
+    try {
+      return await runPgTransaction(this.sql, async (tx) => {
+        const [runRow] = await tx`
+          SELECT * FROM agent_runs
+          WHERE project_id = ${input.projectId} AND id = ${input.createdByRunId}
+          FOR UPDATE
+        `;
+        const [threadRow] = await tx`
+          SELECT * FROM agent_threads
+          WHERE project_id = ${input.projectId} AND id = ${input.threadId}
+          FOR UPDATE
+        `;
+        assertAgentContextCheckpointAuthority({
+          create: input,
+          run: runRow ? rowToRunRecord(runRow) : null,
+          thread: threadRow ? rowToThreadRecord(threadRow) : null,
+          prefix: "SixbPg"
+        });
+        const [latestRow] = await tx`
+          SELECT * FROM agent_context_checkpoints
+          WHERE project_id = ${input.projectId} AND thread_id = ${input.threadId}
+          ORDER BY summarized_through_seq DESC, created_at DESC, id DESC
+          LIMIT 1
+        `;
+        const latest = latestRow ? rowToContextCheckpointRecord(latestRow) : null;
+        const [headRow] = await tx`
+          SELECT COALESCE(MAX(seq), 0) AS seq FROM agent_messages
+          WHERE project_id = ${input.projectId} AND thread_id = ${input.threadId}
+        `;
+        const headSeq = Number(headRow?.seq ?? 0);
+        const [existingForRunRow] = await tx`
+          SELECT * FROM agent_context_checkpoints
+          WHERE project_id = ${input.projectId} AND created_by_run_id = ${input.createdByRunId}
+        `;
+        if (existingForRunRow) {
+          const record = rowToContextCheckpointRecord(existingForRunRow);
+          if (agentContextCheckpointMatchesCreateInput(record, input)) {
+            assertAgentContextCheckpointReplayState({
+              create: input,
+              existing: record,
+              latest,
+              headSeq,
+              prefix: "SixbPg"
+            });
+            return record;
+          }
+          throw new AgentStorageError("invalid_state", `[SixbPg] Agent run '${input.createdByRunId}' already created a different context checkpoint.`);
+        }
+        const [duplicateId] = await tx`
+          SELECT 1 AS present FROM agent_context_checkpoints
+          WHERE project_id = ${input.projectId} AND id = ${input.id}
+        `;
+        if (duplicateId) {
+          throw new AgentStorageError("duplicate_id", `[SixbPg] Agent context checkpoint '${input.id}' already exists for project '${input.projectId}'.`);
+        }
+        const [firstRetainedRow] = await tx`
+          SELECT * FROM agent_messages
+          WHERE
+            project_id = ${input.projectId}
+            AND thread_id = ${input.threadId}
+            AND seq > ${input.summarizedThroughSeq}
+          ORDER BY seq ASC
+          LIMIT 1
+        `;
+        assertAgentContextCheckpointAnchors({
+          create: input,
+          latest,
+          headSeq,
+          firstRetained: firstRetainedRow ? rowToMessageRecord(firstRetainedRow) : null,
+          prefix: "SixbPg"
+        });
+        const [row] = await tx`
+          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 (
+            ${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},
+            ${input.createdAt ?? new Date}
+          )
+          RETURNING *
+        `;
+        return rowToContextCheckpointRecord(row);
+      });
+    } catch (error) {
+      if (isUniqueViolation(error)) {
+        throw new AgentStorageError("duplicate_id", `[SixbPg] Agent context checkpoint '${input.id}' already exists for project '${input.projectId}'.`);
+      }
+      throw error;
+    }
+  }
+  async getLatest(input) {
+    const [row] = await this.sql`
+      SELECT * FROM agent_context_checkpoints
+      WHERE project_id = ${input.projectId} AND thread_id = ${input.threadId}
+      ORDER BY summarized_through_seq DESC, created_at DESC, id DESC
+      LIMIT 1
+    `;
+    return row ? rowToContextCheckpointRecord(row) : null;
+  }
+  async getByRunIds(input) {
+    const runIds = [...new Set(input.runIds)];
+    if (runIds.length === 0)
+      return [];
+    const rows = [];
+    for (let offset = 0;offset < runIds.length; offset += PG_CHECKPOINT_RUN_ID_BATCH_SIZE) {
+      const batch = runIds.slice(offset, offset + PG_CHECKPOINT_RUN_ID_BATCH_SIZE);
+      const placeholders = batch.map((_, index) => `$${index + 2}`).join(", ");
+      rows.push(...await this.sql.unsafe(`SELECT * FROM agent_context_checkpoints WHERE project_id = $1 AND created_by_run_id IN (${placeholders})`, [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] : [];
+    });
+  }
+}
+
 // src/agents/messages.ts
+import { AGENT_MESSAGE_CONTENT_VERSION } from "@sixb/core/internal/agents";
+import {
+  AgentStorageError as AgentStorageError2
+} from "@sixb/core/storage";
 class PgAgentMessageStore {
   sql;
   constructor(sql) {
@@ -194,21 +377,23 @@ class PgAgentMessageStore {
     const createdAt = input.createdAt ?? new Date;
     try {
       return await runPgTransaction(this.sql, async (tx) => {
+        if (input.runId !== null) {
+          const [run] = await tx`
+            SELECT id FROM agent_runs
+            WHERE project_id = ${input.projectId} AND id = ${input.runId}
+            FOR UPDATE
+          `;
+          if (!run) {
+            throw new AgentStorageError2("run_not_found", `[SixbPg] Agent run '${input.runId}' not found for project '${input.projectId}'.`);
+          }
+        }
         const [thread] = await tx`
           SELECT id FROM agent_threads
           WHERE project_id = ${input.projectId} AND id = ${input.threadId}
           FOR UPDATE
         `;
         if (!thread) {
-          throw new AgentStorageError("thread_not_found", `[SixbPg] Agent thread '${input.threadId}' not found for project '${input.projectId}'.`);
-        }
-        if (input.runId !== null) {
-          const [run] = await tx`
-            SELECT id FROM agent_runs WHERE project_id = ${input.projectId} AND id = ${input.runId}
-          `;
-          if (!run) {
-            throw new AgentStorageError("run_not_found", `[SixbPg] Agent run '${input.runId}' not found for project '${input.projectId}'.`);
-          }
+          throw new AgentStorageError2("thread_not_found", `[SixbPg] Agent thread '${input.threadId}' not found for project '${input.projectId}'.`);
         }
         const [seqRow] = await tx`
           SELECT COALESCE(MAX(seq), 0) + 1 AS next FROM agent_messages
@@ -255,11 +440,51 @@ class PgAgentMessageStore {
       });
     } catch (error) {
       if (isUniqueViolation(error)) {
-        throw new AgentStorageError("duplicate_id", `[SixbPg] Agent message '${input.id}' already exists for project '${input.projectId}'.`);
+        throw new AgentStorageError2("duplicate_id", `[SixbPg] Agent message '${input.id}' already exists for project '${input.projectId}'.`);
       }
       throw error;
     }
   }
+  async deleteByRunId(input) {
+    return runPgTransaction(this.sql, async (tx) => {
+      const [thread] = await tx`
+        SELECT id FROM agent_threads
+        WHERE project_id = ${input.projectId} AND id = ${input.threadId}
+        FOR UPDATE
+      `;
+      if (!thread) {
+        throw new AgentStorageError2("thread_not_found", `[SixbPg] Agent thread '${input.threadId}' not found for project '${input.projectId}'.`);
+      }
+      const deleted = await tx`
+        DELETE FROM agent_messages
+        WHERE project_id = ${input.projectId}
+          AND thread_id = ${input.threadId}
+          AND run_id = ${input.runId}
+        RETURNING id
+      `;
+      if (deleted.length === 0) {
+        return 0;
+      }
+      const updatedAt = new Date;
+      await tx`
+        UPDATE agent_threads
+        SET
+          message_count = (
+            SELECT COUNT(*) FROM agent_messages
+            WHERE project_id = ${input.projectId} AND thread_id = ${input.threadId}
+          ),
+          last_message_at = (
+            SELECT created_at FROM agent_messages
+            WHERE project_id = ${input.projectId} AND thread_id = ${input.threadId}
+            ORDER BY seq DESC
+            LIMIT 1
+          ),
+          updated_at = ${updatedAt}
+        WHERE project_id = ${input.projectId} AND id = ${input.threadId}
+      `;
+      return deleted.length;
+    });
+  }
   async getById(params) {
     const [row] = await this.sql`
       SELECT * FROM agent_messages WHERE project_id = ${params.projectId} AND id = ${params.id}
@@ -273,6 +498,10 @@ class PgAgentMessageStore {
     const whereClauses = ["project_id = $1", "thread_id = $2"];
     const params = [input.projectId, input.threadId];
     let index = 3;
+    if (input.afterSeq !== undefined) {
+      whereClauses.push(`seq > $${index++}`);
+      params.push(input.afterSeq);
+    }
     if (input.roles) {
       const placeholders = input.roles.map(() => `$${index++}`);
       whereClauses.push(`role IN (${placeholders.join(", ")})`);
@@ -299,7 +528,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
@@ -384,10 +613,10 @@ class PgAgentRunStore {
           FOR UPDATE
         `;
         if (!thread) {
-          throw new AgentStorageError2("thread_not_found", `[SixbPg] Agent thread '${input.threadId}' not found for project '${input.projectId}'.`);
+          throw new AgentStorageError3("thread_not_found", `[SixbPg] Agent thread '${input.threadId}' not found for project '${input.projectId}'.`);
         }
         if (thread.active_run_id !== null) {
-          throw new AgentStorageError2("active_run_exists", `[SixbPg] Agent thread '${input.threadId}' already has an active run '${thread.active_run_id}'.`);
+          throw new AgentStorageError3("active_run_exists", `[SixbPg] Agent thread '${input.threadId}' already has an active run '${thread.active_run_id}'.`);
         }
         const [row] = await tx`
           INSERT INTO agent_runs (
@@ -423,7 +652,7 @@ class PgAgentRunStore {
       });
     } catch (error) {
       if (isUniqueViolation(error)) {
-        throw new AgentStorageError2("duplicate_id", `[SixbPg] Agent run '${input.id}' already exists for project '${input.projectId}'.`);
+        throw new AgentStorageError3("duplicate_id", `[SixbPg] Agent run '${input.id}' already exists for project '${input.projectId}'.`);
       }
       throw error;
     }
@@ -483,7 +712,7 @@ class PgAgentRunStore {
     return runPgTransaction(this.sql, async (tx) => {
       const run = await this.lockRunning(tx, input.projectId, input.id);
       if (run.execution_token !== input.executionToken) {
-        throw new AgentStorageError2("execution_lost", `[SixbPg] Execution token is no longer current on agent run '${input.id}'.`);
+        throw new AgentStorageError3("execution_lost", `[SixbPg] Execution token is no longer current on agent run '${input.id}'.`);
       }
       const [row] = await tx`
         UPDATE agent_runs
@@ -503,7 +732,7 @@ class PgAgentRunStore {
     return runPgTransaction(this.sql, async (tx) => {
       const run = await this.lockRunning(tx, input.projectId, input.id);
       if (run.execution_token !== input.executionToken) {
-        throw new AgentStorageError2("execution_lost", `[SixbPg] Execution token is no longer current on agent run '${input.id}'.`);
+        throw new AgentStorageError3("execution_lost", `[SixbPg] Execution token is no longer current on agent run '${input.id}'.`);
       }
       const [row] = await tx`
         UPDATE agent_runs
@@ -584,10 +813,10 @@ class PgAgentRunStore {
       FOR UPDATE
     `;
     if (!row) {
-      throw new AgentStorageError2("run_not_found", `[SixbPg] Agent run '${id}' not found for project '${projectId}'.`);
+      throw new AgentStorageError3("run_not_found", `[SixbPg] Agent run '${id}' not found for project '${projectId}'.`);
     }
     if (row.status !== status) {
-      throw new AgentStorageError2("invalid_state", `[SixbPg] Agent run '${id}' is not ${status} (status '${row.status}').`);
+      throw new AgentStorageError3("invalid_state", `[SixbPg] Agent run '${id}' is not ${status} (status '${row.status}').`);
     }
     return row;
   }
@@ -601,7 +830,7 @@ class PgAgentRunStore {
 
 // src/agents/threads.ts
 import {
-  AgentStorageError as AgentStorageError3
+  AgentStorageError as AgentStorageError4
 } from "@sixb/core/storage";
 class PgAgentThreadStore {
   sql;
@@ -639,7 +868,7 @@ class PgAgentThreadStore {
       return rowToThreadRecord(row);
     } catch (error) {
       if (isUniqueViolation(error)) {
-        throw new AgentStorageError3("duplicate_id", `[SixbPg] Agent thread '${input.id}' already exists for project '${input.projectId}'.`);
+        throw new AgentStorageError4("duplicate_id", `[SixbPg] Agent thread '${input.id}' already exists for project '${input.projectId}'.`);
       }
       throw error;
     }
@@ -695,10 +924,12 @@ class PgAgentStorage {
   threads;
   runs;
   messages;
+  checkpoints;
   constructor(options) {
     this.threads = new PgAgentThreadStore(options.sql);
     this.runs = new PgAgentRunStore(options.sql, options.executions);
     this.messages = new PgAgentMessageStore(options.sql);
+    this.checkpoints = new PgAgentContextCheckpointStore(options.sql);
   }
 }
 // src/auth-storage/auth-storage.ts
@@ -5915,6 +6146,105 @@ 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(btrim(project_id)) > 0),
+  usage_record_id TEXT NOT NULL CHECK (length(btrim(usage_record_id)) > 0),
+  status TEXT NOT NULL CHECK (status IN ('rated', 'unpriceable')),
+  provider_id TEXT CHECK (provider_id IS NULL OR length(btrim(provider_id)) > 0),
+  model_id TEXT CHECK (model_id IS NULL OR length(btrim(model_id)) > 0),
+  currency TEXT CHECK (currency IS NULL OR currency ~ '^[A-Z]{3}$'),
+  amount_nanos BIGINT CHECK (amount_nanos IS NULL OR amount_nanos >= 0),
+  reason TEXT CHECK (
+    reason IS NULL OR reason IN (
+      'missingBillingIdentity',
+      'missingCatalogEntry',
+      'missingUsageMeter',
+      'unsupportedPricingDimension',
+      'invalidUsageForFormula'
+    )
+  ),
+  details JSONB NOT NULL CHECK (jsonb_typeof(details) = 'object'),
+  rated_at TIMESTAMPTZ NOT NULL,
+  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 BIGINT NOT NULL CHECK (estimated_input_tokens_before >= 0),
+  estimated_input_tokens_after BIGINT NOT NULL CHECK (estimated_input_tokens_after >= 0),
+  summary_model_id TEXT NOT NULL CHECK (length(trim(summary_model_id)) > 0),
+  created_at TIMESTAMPTZ 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 JSONB NOT NULL DEFAULT '{}'::jsonb
+CHECK (jsonb_typeof(edited_at) = 'object');
+`;
+
 // src/migrations.ts
 var POSTGRES_STORAGE_ADAPTER_ID = "SixbPostgresStorage";
 function pgSql(id, sqlText) {
@@ -6114,7 +6444,10 @@ var postgresStorageMigrations = defineMigrations({
     pgSql("022-projection-executions", _022_projection_executions_default),
     pgSql("023-webhook-executions", _023_webhook_executions_default),
     pgSql("024-ontology-commit-executions", _024_ontology_commit_executions_default),
-    pgSql("025-connector-connections", _025_connector_connections_default)
+    pgSql("025-connector-connections", _025_connector_connections_default),
+    pgSql("026-ai-cost-accounting", _026_ai_cost_accounting_default),
+    pgSql("027-agent-context-checkpoints", _027_agent_context_checkpoints_default),
+    pgSql("028-object-override-edit-times", _028_object_override_edit_times_default)
   ]
 });
 
@@ -7159,6 +7492,7 @@ function storedObjectOverride(row) {
   return {
     ref,
     value: structuredClone(row.value),
+    editedAt: structuredClone(row.edited_at),
     lastCommitId: row.last_commit_id,
     updatedAt: toIsoString2(row.updated_at)
   };
@@ -7592,6 +7926,7 @@ class PgMaterializationWriter {
       objectTypeId: item.ref.objectTypeId,
       primaryId: item.ref.primaryId,
       value: item.value,
+      editedAt: item.editedAt,
       lastCommitId: item.lastCommitId,
       updatedAt: item.updatedAt,
       expectedLastCommitId: item.expectedLastCommitId
@@ -7603,10 +7938,10 @@ class PgMaterializationWriter {
           SELECT value FROM jsonb_array_elements(${jsonParameter2(this.sql, objectInserts)}::jsonb)
         )
         INSERT INTO ontology_object_overrides (
-          project_id, object_type_id, primary_id, value, last_commit_id, updated_at
+          project_id, object_type_id, primary_id, value, edited_at, last_commit_id, updated_at
         )
         SELECT ${projectId}, value->>'objectTypeId', value->>'primaryId', value->'value',
-          value->>'lastCommitId',
+          value->'editedAt', value->>'lastCommitId',
           (value->>'updatedAt')::timestamptz
         FROM staged
         ON CONFLICT DO NOTHING
@@ -7622,7 +7957,8 @@ class PgMaterializationWriter {
           SELECT value FROM jsonb_array_elements(${jsonParameter2(this.sql, objectUpdates)}::jsonb)
         )
         UPDATE ontology_object_overrides AS overrides
-        SET value = staged.value->'value', last_commit_id = staged.value->>'lastCommitId',
+        SET value = staged.value->'value', edited_at = staged.value->'editedAt',
+          last_commit_id = staged.value->>'lastCommitId',
           updated_at = (staged.value->>'updatedAt')::timestamptz
         FROM staged
         WHERE overrides.project_id = ${projectId}
@@ -9811,6 +10147,502 @@ function rowToActionSubject(row) {
   };
 }
 
+// src/pg-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 PgAiCostStorage {
+  sql;
+  constructor(sql) {
+    this.sql = sql;
+  }
+  async recordModelCallCost(input) {
+    const record = normalizeAiModelCallCostRecord(input);
+    await runPgTransaction(this.sql, async (tx) => {
+      const usage = await findUsage(tx, record.projectId, record.usageRecordId);
+      if (!usage)
+        throw missingUsage(record);
+      assertCostMatchesUsage(record, usage);
+      if (await findCost(tx, record.projectId, record.usageRecordId))
+        return;
+      const rated = record.status === "rated" ? record : undefined;
+      const inserted = await tx`
+        INSERT INTO ai_model_call_valuations (
+          project_id, usage_record_id, status, provider_id, model_id,
+          currency, amount_nanos, reason, details, rated_at
+        ) VALUES (
+          ${record.projectId}, ${record.usageRecordId}, ${record.status},
+          ${record.billingIdentity?.providerId ?? null},
+          ${record.billingIdentity?.modelId ?? null}, ${rated?.money.currency ?? null},
+          ${rated?.money.amountNanos ?? null},
+          ${record.status === "unpriceable" ? record.reason : null},
+          ${JSON.stringify(aiModelCallCostDetails(record))}::text::jsonb, ${record.ratedAt}
+        )
+        ON CONFLICT DO NOTHING
+        RETURNING usage_record_id
+      `;
+      if (inserted.length === 0 && !await findCost(tx, record.projectId, record.usageRecordId)) {
+        throw new Error("[SixbPg] AI valuation insert conflicted without a visible row.");
+      }
+    });
+  }
+  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 ids = [...new Set(input.executionIds)];
+    const rows = await this.sql`
+      WITH requested(execution_id) AS (
+        SELECT DISTINCT * FROM unnest(${this.sql.array(ids)}::text[])
+      )
+      SELECT usage.execution_id,
+        cost.status,
+        cost.currency,
+        cost.amount_nanos
+      FROM requested
+      JOIN ai_model_call_usage AS usage
+        ON usage.project_id = ${input.projectId} 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
+    `;
+    return aggregateSummaryRows(input.executionIds, rows);
+  }
+  async queryProjectOverview(input) {
+    const query = normalizeAiAccountingQuery(input);
+    const providerId = query.providerId ?? null;
+    const modelId = query.modelId ?? null;
+    const rows = await this.sql`
+      WITH filtered 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,
+          cost.status AS cost_status,
+          cost.currency AS cost_currency,
+          cost.amount_nanos AS cost_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 = ${query.projectId}
+          AND usage.occurred_at >= ${query.from} AND usage.occurred_at < ${query.to}
+          AND (${providerId}::text IS NULL OR usage.provider_id = ${providerId})
+          AND (${modelId}::text IS NULL OR usage.requested_model_id = ${modelId})
+      ), classified AS (
+        SELECT filtered.*,
+          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 filtered
+      ), expanded AS (
+        SELECT 'totals'::text AS dimension,
+          NULL::text AS key_1,
+          NULL::text AS key_2,
+          NULL::timestamptz AS bucket_start,
+          classified.*
+        FROM classified
+        UNION ALL
+        SELECT 'series', NULL, NULL,
+          CASE ${input.bucket}::text
+            WHEN 'hour' THEN
+              date_trunc('hour', occurred_at AT TIME ZONE 'UTC') AT TIME ZONE 'UTC'
+            WHEN 'day' THEN
+              date_trunc('day', occurred_at AT TIME ZONE 'UTC') AT TIME ZONE 'UTC'
+            ELSE date_trunc('week', occurred_at AT TIME ZONE 'UTC') AT TIME ZONE 'UTC'
+          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,
+        COUNT(*)::text AS model_call_count,
+        COUNT(*) FILTER (WHERE reporting_status <> 'unavailable')::text
+          AS reported_usage_call_count,
+        COUNT(input_tokens)::text AS input_tokens_count,
+        SUM(input_tokens)::text AS input_tokens_sum,
+        COUNT(output_tokens)::text AS output_tokens_count,
+        SUM(output_tokens)::text AS output_tokens_sum,
+        COUNT(uncached_input_tokens)::text AS uncached_input_tokens_count,
+        SUM(uncached_input_tokens)::text AS uncached_input_tokens_sum,
+        COUNT(cache_read_input_tokens)::text AS cache_read_input_tokens_count,
+        SUM(cache_read_input_tokens)::text AS cache_read_input_tokens_sum,
+        COUNT(cache_write_input_tokens)::text AS cache_write_input_tokens_count,
+        SUM(cache_write_input_tokens)::text AS cache_write_input_tokens_sum,
+        COUNT(text_output_tokens)::text AS text_output_tokens_count,
+        SUM(text_output_tokens)::text AS text_output_tokens_sum,
+        COUNT(reasoning_output_tokens)::text AS reasoning_output_tokens_count,
+        SUM(reasoning_output_tokens)::text AS reasoning_output_tokens_sum,
+        COUNT(*) FILTER (WHERE valuation_status = 'rated')::text AS rated_call_count,
+        COUNT(*) FILTER (WHERE valuation_status = 'unpriceable')::text
+          AS unpriceable_call_count,
+        COUNT(*) FILTER (WHERE valuation_status = 'unvalued')::text
+          AS unvalued_call_count,
+        SUM(amount_nanos)::text AS amount_nanos
+      FROM expanded
+      GROUP BY dimension, key_1, key_2, bucket_start, amount_currency
+    `;
+    return buildAiAccountingOverviewFromFragments(input, rows.map(aggregateFragmentFromRow));
+  }
+  async listModelCalls(input) {
+    const query = normalizeAiModelCallAccountingQuery(input);
+    const providerId = query.providerId ?? null;
+    const modelId = query.modelId ?? null;
+    const executionId = query.executionId ?? null;
+    const valuationStatus = query.valuationStatus ?? null;
+    const [count] = await this.sql`
+      SELECT COUNT(*)::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 usage.project_id = ${query.projectId}
+        AND usage.occurred_at >= ${query.from} AND usage.occurred_at < ${query.to}
+        AND (${providerId}::text IS NULL OR usage.provider_id = ${providerId})
+        AND (${modelId}::text IS NULL OR usage.requested_model_id = ${modelId})
+        AND (${executionId}::text IS NULL OR usage.execution_id = ${executionId})
+        AND (
+          ${valuationStatus}::text IS NULL OR ${valuationStatus} = CASE
+            WHEN cost.status = 'rated' THEN 'rated'
+            WHEN cost.status = 'unpriceable' THEN 'unpriceable'
+            ELSE 'unvalued'
+          END
+        )
+    `;
+    const rows = await this.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 jsonb_agg(groups.group_id ORDER BY groups.group_id)
+          FROM ai_model_call_usage_groups AS groups
+          WHERE groups.project_id = usage.project_id AND groups.usage_record_id = usage.id
+        ), '[]'::jsonb) 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,
+        cost.amount_nanos 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 usage.project_id = ${query.projectId}
+        AND usage.occurred_at >= ${query.from} AND usage.occurred_at < ${query.to}
+        AND (${providerId}::text IS NULL OR usage.provider_id = ${providerId})
+        AND (${modelId}::text IS NULL OR usage.requested_model_id = ${modelId})
+        AND (${executionId}::text IS NULL OR usage.execution_id = ${executionId})
+        AND (
+          ${valuationStatus}::text IS NULL OR ${valuationStatus} = CASE
+            WHEN cost.status = 'rated' THEN 'rated'
+            WHEN cost.status = 'unpriceable' THEN 'unpriceable'
+            ELSE 'unvalued'
+          END
+        )
+      ORDER BY usage.occurred_at DESC, usage.id ASC
+      LIMIT ${query.limit} OFFSET ${query.offset}
+    `;
+    const items = rows.map((row) => toAccountingItem(accountingItemFromRow(row)));
+    if (!count)
+      throw new Error("[SixbPg] AI accounting count query returned no row.");
+    const total = safeSqlCount(count.total, "model-call list total");
+    return structuredClone({
+      items,
+      total,
+      hasMore: query.offset + items.length < total
+    });
+  }
+}
+async function findCost(sql, projectId, usageId) {
+  const [row] = await sql`
+    SELECT * FROM ai_model_call_valuations
+    WHERE project_id = ${projectId} AND usage_record_id = ${usageId}
+  `;
+  return row ? rowToCost(row) : null;
+}
+async function findUsage(sql, projectId, id) {
+  const [row] = await sql`
+    SELECT * FROM ai_model_call_usage WHERE project_id = ${projectId} AND id = ${id}
+  `;
+  return row ? usageFromRow(row, []) : null;
+}
+function aggregateFragmentFromRow(row) {
+  const dimensionKeys = row.dimension === "model" ? { providerId: required2(row.key_1), modelId: required2(row.key_2) } : row.dimension === "agent" ? { agentId: required2(row.key_1) } : row.dimension === "workflow" ? { workflowId: required2(row.key_1) } : row.dimension === "series" ? { start: new Date(required2(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_nanos === null ? {} : {
+        amount: {
+          currency: row.amount_currency,
+          amountNanos: row.amount_nanos
+        }
+      },
+      ratedCallCount: row.rated_call_count,
+      unpriceableCallCount: row.unpriceable_call_count,
+      unvaluedCallCount: row.unvalued_call_count
+    }
+  };
+}
+function meterFragment(presentCallCount, total) {
+  return { presentCallCount, total };
+}
+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: required2(row.attribution_agent_id),
+    agentRunId: required2(row.attribution_agent_run_id),
+    threadId: required2(row.attribution_thread_id)
+  } : {
+    kind: "workflowAgent",
+    agentId: required2(row.attribution_agent_id),
+    nodeRunId: required2(row.attribution_node_run_id),
+    workflowId: required2(row.attribution_workflow_id),
+    workflowRunId: required2(row.attribution_workflow_run_id)
+  };
+  return {
+    usage,
+    ...attribution ? { attribution } : {},
+    ...cost ? { cost } : {}
+  };
+}
+function usageFromRow(row, requesterGroupIds) {
+  const number = (value) => value === null ? undefined : Number(value);
+  return {
+    id: row.id,
+    projectId: row.project_id,
+    executionId: row.execution_id,
+    attempt: Number(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: {
+      ...number(row.input_tokens) === undefined ? {} : { inputTokens: number(row.input_tokens) },
+      ...number(row.output_tokens) === undefined ? {} : { outputTokens: number(row.output_tokens) },
+      ...number(row.total_tokens) === undefined ? {} : { totalTokens: number(row.total_tokens) },
+      ...number(row.uncached_input_tokens) === undefined ? {} : { uncachedInputTokens: number(row.uncached_input_tokens) },
+      ...number(row.cache_read_input_tokens) === undefined ? {} : { cacheReadInputTokens: number(row.cache_read_input_tokens) },
+      ...number(row.cache_write_input_tokens) === undefined ? {} : { cacheWriteInputTokens: number(row.cache_write_input_tokens) },
+      ...number(row.text_output_tokens) === undefined ? {} : { textOutputTokens: number(row.text_output_tokens) },
+      ...number(row.reasoning_output_tokens) === undefined ? {} : { reasoningOutputTokens: number(row.reasoning_output_tokens) },
+      reportingStatus: row.reporting_status
+    },
+    ...row.raw_usage === null ? {} : { rawUsage: parseJsonObject(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: required2(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: row.cost_details,
+    ratedAt: required2(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: required2(input.providerId), modelId: required2(input.modelId) },
+      money: { currency: required2(input.currency), amountNanos: required2(input.amountNanos) },
+      components: required2(details.components)
+    });
+  }
+  return normalizeAiModelCallCostRecord({
+    ...base,
+    status: "unpriceable",
+    ...input.providerId && input.modelId ? { billingIdentity: { providerId: input.providerId, modelId: input.modelId } } : {},
+    reason: required2(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, required2(row.currency), required2(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 parseStringArray(value) {
+  const parsed = typeof value === "string" ? JSON.parse(value) : value;
+  if (!Array.isArray(parsed) || parsed.some((item) => typeof item !== "string")) {
+    throw new Error("[SixbPg] AI requester group ids are invalid.");
+  }
+  return parsed;
+}
+function parseJsonObject(value) {
+  return typeof value === "string" ? JSON.parse(value) : value;
+}
+function assertCostMatchesUsage(record, usage) {
+  if (!aiModelCallCostMatchesUsage(record, usage)) {
+    throw new AiCostStorageError("cost_mismatch", `[SixbPg] AI valuation for usage '${record.usageRecordId}' does not match its usage record.`);
+  }
+}
+function missingUsage(record) {
+  return new AiCostStorageError("missing_usage", `[SixbPg] AI usage '${record.usageRecordId}' does not exist.`);
+}
+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(`[SixbPg] 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 required2(value) {
+  if (value === null || value === undefined) {
+    throw new Error("[SixbPg] AI valuation column is unexpectedly null.");
+  }
+  return value;
+}
+
 // src/pg-ai-usage-storage.ts
 import {
   AiUsageStorageError,
@@ -9904,6 +10736,17 @@ class PgAiUsageStorage {
     });
     return summary;
   }
+  async getLatestForExecution(input) {
+    assertNonBlankProjectId(input.projectId);
+    assertAiUsageExecutionId(input.executionId);
+    const [row] = await this.sql`
+      SELECT * FROM ai_model_call_usage
+      WHERE project_id = ${input.projectId} AND execution_id = ${input.executionId}
+      ORDER BY occurred_at DESC, id DESC
+      LIMIT 1
+    `;
+    return row ? this.rowToRecord(this.sql, row) : null;
+  }
   async summarizeExecutions(input) {
     assertNonBlankProjectId(input.projectId);
     for (const executionId of input.executionIds)
@@ -9950,7 +10793,7 @@ class PgAiUsageStorage {
       ...row.response_model_id === null ? {} : { responseModelId: row.response_model_id },
       responseId: row.response_id,
       usage: {
-        ...usageFromRow(row),
+        ...usageFromRow2(row),
         ...row.total_tokens === null ? {} : { totalTokens: Number(row.total_tokens) },
         reportingStatus: row.reporting_status
       },
@@ -9987,7 +10830,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) ?? [];
@@ -9997,7 +10840,7 @@ function aggregateExecutionRows(executionIds, rows) {
     };
   });
 }
-function usageFromRow(row) {
+function usageFromRow2(row) {
   return {
     ...row.input_tokens === null ? {} : { inputTokens: Number(row.input_tokens) },
     ...row.output_tokens === null ? {} : { outputTokens: Number(row.output_tokens) },
@@ -10166,6 +11009,9 @@ function toStorageRow(row) {
   };
 }
 
+// src/pg-object-storage.ts
+import { linkBatchKey, objectBatchKey } from "@sixb/core/storage";
+
 // src/pg-object-query-compiler.ts
 import {
   ObjectQueryExecutionError
@@ -10231,6 +11077,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":
@@ -10277,6 +11125,50 @@ function compileStart(projectId, query) {
     }
   };
 }
+function compileRefs(projectId, query) {
+  if (query.refs.length === 0) {
+    throw new Error("[SixbPg] PostgreSQL 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
+      ref.value ->> 'objectTypeId' AS object_type_id,
+      ref.value ->> 'primaryId' AS primary_id
+    FROM jsonb_array_elements(?::text::jsonb) AS ref(value)
+  `;
+  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(*)::bigint 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) {
   return compileWhere(projectId, inputQuery, compilePredicate(predicateNode));
 }
@@ -10641,6 +11533,8 @@ function compileAggregateSource(projectId, query) {
   switch (query.kind) {
     case "start":
       return compileAggregateStart(projectId, query);
+    case "refs":
+      return compileAggregateRefs(projectId, query);
     case "filter":
       return compileAggregateWhere(projectId, query.input, compilePredicate(query.predicate));
     case "text": {
@@ -10658,7 +11552,7 @@ function compileAggregateSource(projectId, query) {
     case "page":
       return compileRowQueryAggregateSource(projectId, query);
     case "vector":
-      throw new Error(`[SixbPg] PostgreSQL object storage does not support query node 'vector'`);
+      throw new Error(`[SixbPg] PostgreSQL object storage does not support query node '${query.kind}'`);
   }
 }
 function compileAggregateStart(projectId, query) {
@@ -10674,6 +11568,27 @@ function compileAggregateStart(projectId, query) {
     args: [projectId, query.objectTypeId]
   };
 }
+function compileAggregateRefs(projectId, query) {
+  if (query.refs.length === 0) {
+    throw new Error("[SixbPg] PostgreSQL object storage requires at least one ref");
+  }
+  return {
+    sql: `
+      SELECT selected.project_id, selected.object_type_id, selected.primary_id, selected.properties
+      FROM (
+        SELECT DISTINCT
+          ref.value ->> 'objectTypeId' AS object_type_id,
+          ref.value ->> 'primaryId' AS primary_id
+        FROM jsonb_array_elements(?::text::jsonb) AS ref(value)
+      ) AS 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
+    `,
+    args: [JSON.stringify(query.refs), projectId]
+  };
+}
 function compileAggregateWhere(projectId, inputQuery, predicate) {
   const input = compileAggregateSource(projectId, inputQuery);
   return {
@@ -11219,6 +12134,7 @@ var PG_OBJECT_QUERY_CAPABILITIES = {
   facetObjects: true,
   nodes: {
     start: true,
+    refs: true,
     filter: true,
     text: true,
     sort: true,
@@ -11270,7 +12186,7 @@ var PG_OBJECT_QUERY_CAPABILITIES = {
     stablePageTokens: true
   },
   notes: [
-    "PostgreSQL object query pushdown supports start/filter/text/sort/limit/page/traverse/set/project/expand over JSONB properties and object links.",
+    "PostgreSQL object query pushdown supports start/refs/filter/text/sort/limit/page/traverse/set/project/expand over JSONB properties and object links.",
     "expand hydrates linked objects in-database (top-N per parent via LATERAL + jsonb_agg); core resolves each expansion's cardinality before pushdown, and a mixed/unresolved one stays on the fallback.",
     "Exact decimal predicates, ordering, and keyset pagination use PostgreSQL numeric casts.",
     "Relevance sorting, vector search, and unresolved start.includeSubtypes remain planner fallback or rejection cases."
@@ -11357,7 +12273,7 @@ class PgObjectStorage {
       return result;
     const rows = await valuesJoin(this.sql, "SELECT o.* FROM objects o", ["object_type_id", "primary_id"], params.items.map((i) => [i.objectTypeId, i.primaryId]), `WHERE o.project_id = $1`, [params.projectId]);
     for (const row of rows) {
-      result.set(`${row.object_type_id}:${row.primary_id}`, rowToObject(row));
+      result.set(objectBatchKey(row.object_type_id, row.primary_id), rowToObject(row));
     }
     return result;
   }
@@ -11367,13 +12283,73 @@ class PgObjectStorage {
       return result;
     const rows = await valuesJoin(this.sql, "SELECT l.* FROM links l", ["source_type_id", "source_id", "link_id"], params.items.map((i) => [i.objectTypeId, i.objectId, i.linkId]), `WHERE l.project_id = $1`, [params.projectId]);
     for (const row of rows) {
-      const key = `${row.source_type_id}:${row.source_id}:${row.link_id}`;
+      const key = linkBatchKey(row.source_type_id, row.source_id, row.link_id);
       const existing = result.get(key) ?? [];
       existing.push(rowToLink(row));
       result.set(key, existing);
     }
     return result;
   }
+  async queryLinks(params) {
+    assertLinkQueryLimit(params.limit);
+    if (params.objectRefs.length === 0 || params.endpointObjectTypeIds?.length === 0) {
+      return { links: [], hasMore: false };
+    }
+    const args = [JSON.stringify(params.objectRefs), params.projectId];
+    const addArg = (value) => {
+      args.push(value);
+      return `$${args.length}`;
+    };
+    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 = $2
+    `;
+    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 = $2
+    `;
+    const incidentSql = params.direction === "outgoing" ? sourceJoin : params.direction === "incoming" ? targetJoin : `${sourceJoin} UNION ${targetJoin}`;
+    const predicates = [];
+    if (params.linkId !== undefined) {
+      predicates.push(`link_id = ${addArg(params.linkId)}::text`);
+    }
+    if (params.endpointObjectTypeIds !== undefined) {
+      const allowedTypes = addArg(JSON.stringify([...new Set(params.endpointObjectTypeIds)]));
+      predicates.push(`source_type_id IN (SELECT jsonb_array_elements_text(${allowedTypes}::text::jsonb))`, `target_type_id IN (SELECT jsonb_array_elements_text(${allowedTypes}::text::jsonb))`);
+    }
+    if (params.after) {
+      const cursor = params.after.map((value) => `${addArg(value)}::text`);
+      predicates.push(`(source_type_id, source_id, link_id, target_type_id, target_id) > (${cursor.join(", ")})`);
+    }
+    const limit = addArg(params.limit + 1);
+    const whereSql = predicates.length > 0 ? `WHERE ${predicates.join(" AND ")}` : "";
+    const rows = await this.sql.unsafe(`
+        WITH requested AS (
+          SELECT DISTINCT
+            requested."objectTypeId" AS object_type_id,
+            requested."primaryId" AS object_id
+          FROM jsonb_to_recordset($1::text::jsonb)
+            AS requested("objectTypeId" text, "primaryId" text)
+        ), incident AS (${incidentSql})
+        SELECT *
+        FROM incident
+        ${whereSql}
+        ORDER BY source_type_id, source_id, link_id, target_type_id, target_id
+        LIMIT ${limit}
+      `, args);
+    return {
+      links: rows.slice(0, params.limit).map((row) => rowToLink(row)),
+      hasMore: rows.length > params.limit
+    };
+  }
   async listIncidentLinksBatch(params) {
     if (params.items.length === 0)
       return [];
@@ -11383,7 +12359,7 @@ class PgObjectStorage {
     const deduped = new Map;
     for (const row of [...sourceRows, ...targetRows]) {
       const link = rowToLink(row);
-      deduped.set(`${link.sourceTypeId}:${link.sourceId}:${link.linkId}:${link.targetTypeId}:${link.targetId}`, link);
+      deduped.set(linkIdentity(link), link);
     }
     return [...deduped.values()];
   }
@@ -11565,6 +12541,20 @@ function rowToLink(row) {
     lastCommitId: row.last_commit_id
   };
 }
+function linkIdentity(link) {
+  return JSON.stringify([
+    link.sourceTypeId,
+    link.sourceId,
+    link.linkId,
+    link.targetTypeId,
+    link.targetId
+  ]);
+}
+function assertLinkQueryLimit(limit) {
+  if (!Number.isSafeInteger(limit) || limit <= 0) {
+    throw new Error("Object link query limit must be a positive safe integer.");
+  }
+}
 
 // src/pg-pipeline-run-storage.ts
 import { parseSixbFailure as parseSixbFailure3, serializeSixbFailure as serializeSixbFailure3 } from "@sixb/core/internal/errors";
@@ -14190,6 +15180,7 @@ class PostgresStorage {
   executions;
   agents;
   aiUsage;
+  aiCosts;
   actionRuns;
   pipelineRuns;
   workflowRuns;
@@ -14239,6 +15230,7 @@ class PostgresStorage {
     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.workflowRuns = createWorkflowRunOperationScope(stores.workflowRuns, scope);
@@ -14327,6 +15319,7 @@ function createPostgresStores(sql, options) {
     executions,
     agents: new PgAgentStorage({ sql, executions }),
     aiUsage: new PgAiUsageStorage(sql),
+    aiCosts: new PgAiCostStorage(sql),
     actionRuns: new PgActionRunStorage(sql, executions),
     pipelineRuns: new PgPipelineRunStorage(sql, executions),
     workflowRuns: new PgWorkflowRunStorage(sql, executions),
@@ -14353,4 +15346,4 @@ export {
   PostgresStorage
 };
 
-//# debugId=C543A4DF0CE709F964756E2164756E21
+//# debugId=0531F72AD7BC178764756E2164756E21