@sixb/sqlite 0.1.26 → 0.2.1

package/dist/index.js

@@ -5975,6 +5975,56 @@ ALTER TABLE agent_threads ADD COLUMN runs_on TEXT CHECK (runs_on IS NULL OR runs
 ALTER TABLE agent_threads ADD COLUMN computer_id TEXT;
 `;
 
+// src/migrations/082-agent-token-rates.sql
+var _082_agent_token_rates_default = `-- What each model's tokenizer measured on a project's agent runs, one row per run: the bytes of a
+-- request's text as the Agent's context estimator weighs them, against the text tokens the
+-- provider counted. A record deletes the model's rows past its newest 20, so the table stays small.
+-- Timestamps are ISO-8601 UTC text and compare lexicographically.
+CREATE TABLE agent_token_rates (
+  project_id TEXT NOT NULL CHECK (length(trim(project_id)) > 0),
+  run_id TEXT NOT NULL CHECK (length(trim(run_id)) > 0),
+  provider_id TEXT NOT NULL CHECK (length(trim(provider_id)) > 0),
+  model_id TEXT NOT NULL CHECK (length(trim(model_id)) > 0),
+  bytes INTEGER NOT NULL CHECK (bytes > 0),
+  tokens INTEGER NOT NULL CHECK (tokens > 0),
+  measured_at TEXT NOT NULL,
+  PRIMARY KEY (project_id, run_id)
+);
+
+CREATE INDEX idx_agent_token_rates_model
+  ON agent_token_rates (project_id, provider_id, model_id, measured_at DESC, run_id DESC);
+`;
+
+// src/migrations/083-agent-computer-sessions.sql
+var _083_agent_computer_sessions_default = `-- Where a computer's thread runs: the computer's name and the folder there, beside its id. A
+-- computer kept before folders were has none until its owner moves the thread.
+ALTER TABLE agent_threads ADD COLUMN computer_name TEXT;
+ALTER TABLE agent_threads ADD COLUMN computer_folder TEXT;
+UPDATE agent_threads SET computer_id = NULL WHERE computer_id IS NOT NULL;
+-- When its turns last moved to where they run now: the files earlier turns used are not there.
+ALTER TABLE agent_threads ADD COLUMN moved_at TEXT;
+
+-- Each open sixb on its owner's computers, a lease it renews: while one is live, the threads that
+-- run on its computer in its folder are reachable there.
+CREATE TABLE agent_computer_sessions (
+  project_id TEXT NOT NULL,
+  owner_principal_type TEXT NOT NULL CHECK (owner_principal_type IN ('user', 'serviceAccount', 'system')),
+  owner_principal_id TEXT NOT NULL CHECK (length(owner_principal_id) > 0),
+  id TEXT NOT NULL CHECK (length(id) > 0),
+  computer_id TEXT NOT NULL,
+  computer_name TEXT NOT NULL,
+  folder TEXT NOT NULL,
+  expires_at TEXT NOT NULL,
+  PRIMARY KEY (project_id, owner_principal_type, owner_principal_id, id)
+);
+CREATE INDEX agent_computer_sessions_by_expiry ON agent_computer_sessions (project_id, expires_at);
+
+-- Each open sixb asks every 20 seconds which of its owner's threads here have a turn active.
+CREATE INDEX agent_threads_active_on_computer
+  ON agent_threads (project_id, owner_principal_type, owner_principal_id, computer_id, computer_folder)
+  WHERE active_run_id IS NOT NULL;
+`;
+
 // src/migrations.ts
 var MIGRATIONS_TABLE_SQL = `
   CREATE TABLE IF NOT EXISTS sixb_migrations (
@@ -6110,7 +6160,9 @@ var sqliteStorageMigrations = defineMigrations({
     }, { checksum: checksum(_078_subagent_threads_default) }),
     sqliteSql("079-subagent-questions", _079_subagent_questions_default),
     sqliteSql("080-agent-run-cancel-requests", _080_agent_run_cancel_requests_default),
-    sqliteSql("081-agent-thread-runs-on", _081_agent_thread_runs_on_default)
+    sqliteSql("081-agent-thread-runs-on", _081_agent_thread_runs_on_default),
+    sqliteSql("082-agent-token-rates", _082_agent_token_rates_default),
+    sqliteSql("083-agent-computer-sessions", _083_agent_computer_sessions_default)
   ]
 });
 function sqliteStoragePath(basePath) {
@@ -7077,7 +7129,10 @@ function rowToThreadRecord(row) {
     },
     ...row.sandbox_params == null ? {} : { sandboxParams: snapshotAgentThreadSandboxParams(JSON.parse(row.sandbox_params)) },
     ...row.runs_on == null ? {} : { runsOn: row.runs_on },
-    ...row.computer_id == null ? {} : { computerId: row.computer_id },
+    ...row.computer_id == null || row.computer_name == null || row.computer_folder == null ? {} : {
+      computer: { id: row.computer_id, name: row.computer_name, folder: row.computer_folder }
+    },
+    ...row.moved_at == null ? {} : { movedAt: new Date(row.moved_at) },
     status: row.status,
     activeRunId: row.active_run_id,
     lastMessageAt: row.last_message_at ? new Date(row.last_message_at) : undefined,
@@ -7560,6 +7615,55 @@ class SqliteAgentContextCheckpointStore {
   }
 }
 
+// src/agents/computers.ts
+import { assertAgentComputerSession } from "@sixb/core/internal/agent-run-storage-provider";
+
+class SqliteAgentComputerSessionStore {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async hold(input) {
+    assertAgentComputerSession(input, "SixbSqlite");
+    this.db.query(`INSERT INTO agent_computer_sessions (
+           project_id, owner_principal_type, owner_principal_id, id,
+           computer_id, computer_name, folder, expires_at
+         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT (project_id, owner_principal_type, owner_principal_id, id)
+         DO UPDATE SET
+           computer_id = excluded.computer_id,
+           computer_name = excluded.computer_name,
+           folder = excluded.folder,
+           expires_at = excluded.expires_at`).run(input.projectId, input.ownerPrincipal.type, input.ownerPrincipal.id, input.id, input.computer.id, input.computer.name, input.computer.folder, input.expiresAt.toISOString());
+  }
+  async release(input) {
+    const row = this.db.query(`DELETE FROM agent_computer_sessions
+         WHERE project_id = ? AND owner_principal_type = ? AND owner_principal_id = ? AND id = ?
+         RETURNING *`).get(input.projectId, input.ownerPrincipal.type, input.ownerPrincipal.id, input.id);
+    return row && rowToSession(row);
+  }
+  async listLive(input) {
+    const rows = this.db.query(`SELECT * FROM agent_computer_sessions
+         WHERE project_id = ? AND owner_principal_type = ? AND owner_principal_id = ?
+           AND expires_at > ?
+         ORDER BY id`).all(input.projectId, input.ownerPrincipal.type, input.ownerPrincipal.id, input.now.toISOString());
+    return rows.map(rowToSession);
+  }
+  async removeLapsed(input) {
+    const rows = this.db.query(`DELETE FROM agent_computer_sessions WHERE project_id = ? AND expires_at <= ? RETURNING *`).all(input.projectId, input.now.toISOString());
+    return rows.map(rowToSession);
+  }
+}
+function rowToSession(row) {
+  return {
+    projectId: row.project_id,
+    id: row.id,
+    ownerPrincipal: { type: row.owner_principal_type, id: row.owner_principal_id },
+    computer: { id: row.computer_id, name: row.computer_name, folder: row.folder },
+    expiresAt: new Date(row.expires_at)
+  };
+}
+
 // src/agents/memory.ts
 import {
   agentMemoryConflicts,
@@ -7806,7 +7910,9 @@ import {
   assertConversationAgentRunSpec,
   assertConversationThreadRow,
   assertCreateSubagentRunInput,
+  assertStartsOnComputer,
   assertSubagentThreadTakesRun,
+  assertTurnInThreadPlace,
   newSubagentThreadRecord,
   subagentRunMatchesCreateInput
 } from "@sixb/core/internal/agent-run-storage-provider";
@@ -7888,7 +7994,7 @@ class SqliteAgentRunStore {
       runId: input.id
     });
     return this.db.transaction(() => {
-      const thread = this.db.query("SELECT id, kind, active_run_id FROM agent_threads WHERE project_id = ? AND id = ?").get(input.projectId, input.threadId);
+      const thread = this.db.query("SELECT id, kind, active_run_id, runs_on FROM agent_threads WHERE project_id = ? AND id = ?").get(input.projectId, input.threadId);
       if (!thread) {
         throw new AgentStorageError4("thread_not_found", `[SixbSqlite] Agent thread '${input.threadId}' not found for project '${input.projectId}'.`);
       }
@@ -7896,6 +8002,7 @@ class SqliteAgentRunStore {
       if (thread.active_run_id !== null) {
         throw new AgentStorageError4("active_run_exists", `[SixbSqlite] Agent thread '${input.threadId}' already has an active run '${thread.active_run_id}'.`);
       }
+      assertTurnInThreadPlace(thread.runs_on, input.spec, input.threadId, "SixbSqlite");
       try {
         this.db.query(`
             INSERT INTO agent_runs (
@@ -7995,7 +8102,11 @@ class SqliteAgentRunStore {
   async start(input) {
     const startedAt = input.startedAt ?? new Date;
     return this.db.transaction(() => {
-      this.requireStatus(input.projectId, input.id, "queued");
+      const run = this.requireStatus(input.projectId, input.id, "queued");
+      if (input.onComputer) {
+        const thread = this.db.query("SELECT computer_id AS id, computer_folder AS folder FROM agent_threads WHERE project_id = ? AND id = ?").get(input.projectId, run.thread_id);
+        assertStartsOnComputer(rowToRunRecord(run), thread?.id ? thread : undefined, input.onComputer, "SixbSqlite");
+      }
       this.db.query(`
           UPDATE agent_runs
           SET
@@ -8179,6 +8290,9 @@ class SqliteAgentRunStore {
       whereClauses.push("parent_run_id = ?");
       args.push(input.parentRunId);
     }
+    if (input.excludeComputerTurns) {
+      whereClauses.push("json_extract(spec, '$.runsOn') IS NOT 'computer'");
+    }
     appendRunListFilters(whereClauses, args, input, "COALESCE(started_at, created_at)");
     const { rows, total, hasMore } = queryRunList({
       db: this.db,
@@ -8296,12 +8410,15 @@ class SqliteAgentApprovalModeStore {
 
 // src/agents/threads.ts
 import {
+  assertAgentThreadComputer,
   assertAssignableComputer,
-  assertComputerId,
+  assertComputerPlace,
   assertConversationThreadRow as assertConversationThreadRow2,
-  assertRunsOn,
+  assertMovableToCloud,
+  movesComputerPlace,
   participantsToAdd,
   planAgentThreadFork,
+  queuedTurnInCloud,
   remapArtifactIds,
   snapshotAgentThreadSandboxParams as snapshotAgentThreadSandboxParams2,
   transitionAgentThreadSandbox
@@ -8324,7 +8441,7 @@ class SqliteAgentThreadStore {
     }).immediate();
   }
   async create(input) {
-    assertRunsOn(input.runsOn, "Agent thread", "SixbSqlite");
+    assertComputerPlace(input.runsOn, input.computer, "SixbSqlite");
     const sandboxParams = input.sandboxParams === undefined ? null : JSON.stringify(snapshotAgentThreadSandboxParams2(input.sandboxParams));
     const createdAt = input.createdAt ?? new Date;
     const updatedAt = input.updatedAt ?? createdAt;
@@ -8338,14 +8455,17 @@ class SqliteAgentThreadStore {
             title,
             sandbox_params,
             runs_on,
+            computer_id,
+            computer_name,
+            computer_folder,
             status,
             active_run_id,
             last_message_at,
             message_count,
             created_at,
             updated_at
-          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, 0, ?, ?)
-        `).run(input.projectId, input.id, input.ownerPrincipal.type, input.ownerPrincipal.id, input.title ?? null, sandboxParams, input.runsOn ?? null, input.status ?? "active", createdAt.toISOString(), updatedAt.toISOString());
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, 0, ?, ?)
+        `).run(input.projectId, input.id, input.ownerPrincipal.type, input.ownerPrincipal.id, input.title ?? null, sandboxParams, input.runsOn ?? null, input.computer?.id ?? null, input.computer?.name ?? null, input.computer?.folder ?? null, input.status ?? "active", createdAt.toISOString(), updatedAt.toISOString());
     } catch (error) {
       if (isUniqueConstraintError(error)) {
         throw new AgentStorageError6("duplicate_id", `[SixbSqlite] Agent thread '${input.id}' already exists for project '${input.projectId}'.`);
@@ -8354,9 +8474,13 @@ class SqliteAgentThreadStore {
     }
     return this.requireThread(input.projectId, input.id);
   }
+  activeRunOf(projectId, thread) {
+    const row = thread?.activeRunId ? this.db.query("SELECT * FROM agent_runs WHERE project_id = ? AND id = ?").get(projectId, thread.activeRunId) : null;
+    return row ? rowToRunRecord(row) : null;
+  }
   async fork(input) {
     return this.db.transaction(() => {
-      const source = this.db.query("SELECT id, kind, active_run_id FROM agent_threads WHERE project_id = ? AND id = ?").get(input.projectId, input.sourceThreadId);
+      const source = this.db.query("SELECT id, kind, active_run_id, runs_on, moved_at FROM agent_threads WHERE project_id = ? AND id = ?").get(input.projectId, input.sourceThreadId);
       if (!source) {
         throw new AgentStorageError6("thread_not_found", `[SixbSqlite] Agent thread '${input.sourceThreadId}' not found for project '${input.projectId}'.`);
       }
@@ -8378,6 +8502,7 @@ class SqliteAgentThreadStore {
             ORDER BY summarized_through_seq DESC, created_at DESC, id DESC
           `).all(input.projectId, source.id);
       const plan = planAgentThreadFork(input, {
+        workspace: { runsOn: source.runs_on, movedAt: source.moved_at },
         ...activeRun?.trigger_message_id ? { triggerMessageId: activeRun.trigger_message_id } : {},
         messages,
         checkpoints: checkpoints.map(rowToContextCheckpointRecord)
@@ -8480,6 +8605,10 @@ class SqliteAgentThreadStore {
       )`);
       args.push(input.participantPrincipal.type, input.participantPrincipal.id);
     }
+    if (input.activeOnComputer) {
+      whereClauses.push("computer_id = ? AND computer_folder = ? AND active_run_id IS NOT NULL");
+      args.push(input.activeOnComputer.id, input.activeOnComputer.folder);
+    }
     const dir = input.order === "asc" ? "ASC" : "DESC";
     const { rows, total, hasMore } = queryAgentList({
       db: this.db,
@@ -8527,16 +8656,40 @@ class SqliteAgentThreadStore {
     return result.changes > 0;
   }
   async assignComputer(input) {
-    assertComputerId(input.computerId, "SixbSqlite");
-    this.db.query(`
-        UPDATE agent_threads SET computer_id = ?
-        WHERE project_id = ? AND id = ? AND runs_on = 'computer'
-          ${input.ifUnassigned ? "AND computer_id IS NULL" : ""}
-      `).run(input.computerId, input.projectId, input.id);
-    const row = this.db.query("SELECT * FROM agent_threads WHERE project_id = ? AND id = ?").get(input.projectId, input.id);
-    const thread = row ? rowToThreadRecord(row) : null;
-    assertAssignableComputer(thread, input.id, "SixbSqlite");
-    return thread;
+    assertAgentThreadComputer(input.computer, "SixbSqlite");
+    return this.db.transaction(() => {
+      const row = this.db.query("SELECT * FROM agent_threads WHERE project_id = ? AND id = ?").get(input.projectId, input.id);
+      const thread = row ? rowToThreadRecord(row) : null;
+      assertAssignableComputer(thread, this.activeRunOf(input.projectId, thread), input.computer, input.id, "SixbSqlite");
+      const movedAt = movesComputerPlace(thread, input.computer) ? (input.movedAt ?? new Date).toISOString() : null;
+      this.db.query(`
+            UPDATE agent_threads
+            SET computer_id = ?, computer_name = ?, computer_folder = ?,
+              moved_at = COALESCE(?, moved_at)
+            WHERE project_id = ? AND id = ?
+          `).run(input.computer.id, input.computer.name, input.computer.folder, movedAt, input.projectId, input.id);
+      return this.requireThread(input.projectId, input.id);
+    }).immediate();
+  }
+  async moveToCloud(input) {
+    return this.db.transaction(() => {
+      const row = this.db.query("SELECT * FROM agent_threads WHERE project_id = ? AND id = ?").get(input.projectId, input.id);
+      const thread = row ? rowToThreadRecord(row) : null;
+      const active = this.activeRunOf(input.projectId, thread);
+      assertMovableToCloud(thread, active, input.id, "SixbSqlite");
+      const queued = queuedTurnInCloud(active);
+      if (queued) {
+        this.db.query("UPDATE agent_runs SET spec = ? WHERE project_id = ? AND id = ?").run(JSON.stringify(queued.spec), input.projectId, queued.id);
+      }
+      this.db.query(`
+            UPDATE agent_threads
+            SET runs_on = NULL, computer_id = NULL, computer_name = NULL, computer_folder = NULL,
+              moved_at = ?
+            WHERE project_id = ? AND id = ?
+          `).run((input.movedAt ?? new Date).toISOString(), input.projectId, input.id);
+      const moved = this.requireThread(input.projectId, input.id);
+      return { thread: moved, ...queued ? { queued } : {} };
+    }).immediate();
   }
   async listParticipants(input) {
     return this.selectParticipants(input.projectId, [...new Set(input.threadIds)]);
@@ -8572,10 +8725,11 @@ class SqliteAgentThreadStore {
             active_run_id,
             last_message_at,
             message_count,
+            moved_at,
             created_at,
             updated_at
-          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?, ?)
-        `).run(thread.projectId, thread.id, thread.ownerPrincipal.type, thread.ownerPrincipal.id, thread.title ?? null, thread.sandboxParams === undefined ? null : JSON.stringify(thread.sandboxParams), thread.sandboxState === undefined ? null : JSON.stringify(thread.sandboxState), thread.status, thread.lastMessageAt?.toISOString() ?? null, thread.messageCount, thread.createdAt.toISOString(), thread.updatedAt.toISOString());
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?, ?, ?)
+        `).run(thread.projectId, thread.id, thread.ownerPrincipal.type, thread.ownerPrincipal.id, thread.title ?? null, thread.sandboxParams === undefined ? null : JSON.stringify(thread.sandboxParams), thread.sandboxState === undefined ? null : JSON.stringify(thread.sandboxState), thread.status, thread.lastMessageAt?.toISOString() ?? null, thread.messageCount, thread.movedAt?.toISOString() ?? null, thread.createdAt.toISOString(), thread.updatedAt.toISOString());
     } catch (error) {
       if (isUniqueConstraintError(error)) {
         throw new AgentStorageError6("duplicate_id", `[SixbSqlite] Agent thread '${thread.id}' already exists for project '${thread.projectId}'.`);
@@ -8623,6 +8777,53 @@ class SqliteAgentThreadStore {
   }
 }
 
+// src/agents/token-rates.ts
+import {
+  AGENT_TOKEN_RATE_SAMPLES,
+  assertAgentTokenRateRecord
+} from "@sixb/core/internal/agent-run-storage-provider";
+class SqliteAgentTokenRateStore {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async record(input) {
+    assertAgentTokenRateRecord(input, "SixbSqlite");
+    runImmediateTransaction(this.db, () => {
+      this.db.query(`INSERT INTO agent_token_rates (
+             project_id, run_id, provider_id, model_id, bytes, tokens, measured_at
+           ) VALUES (?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT (project_id, run_id) DO UPDATE SET
+             provider_id = excluded.provider_id, model_id = excluded.model_id,
+             bytes = excluded.bytes, tokens = excluded.tokens, measured_at = excluded.measured_at`).run(input.projectId, input.runId, input.providerId, input.modelId, input.bytes, input.tokens, input.measuredAt.toISOString());
+      this.db.query(`DELETE FROM agent_token_rates
+           WHERE project_id = ?1 AND provider_id = ?2 AND model_id = ?3
+             AND run_id NOT IN (
+               SELECT run_id FROM agent_token_rates
+               WHERE project_id = ?1 AND provider_id = ?2 AND model_id = ?3
+               ORDER BY measured_at DESC, run_id DESC
+               LIMIT ?4
+             )`).run(input.projectId, input.providerId, input.modelId, AGENT_TOKEN_RATE_SAMPLES);
+    });
+  }
+  async listLatest(input) {
+    const rows = this.db.query(`SELECT project_id, run_id, provider_id, model_id, bytes, tokens, measured_at
+         FROM agent_token_rates
+         WHERE project_id = ? AND provider_id = ? AND model_id = ?
+         ORDER BY measured_at DESC, run_id DESC
+         LIMIT ?`).all(input.projectId, input.providerId, input.modelId, AGENT_TOKEN_RATE_SAMPLES);
+    return rows.map((row) => ({
+      projectId: row.project_id,
+      providerId: row.provider_id,
+      modelId: row.model_id,
+      runId: row.run_id,
+      bytes: row.bytes,
+      tokens: row.tokens,
+      measuredAt: new Date(row.measured_at)
+    }));
+  }
+}
+
 // src/agents/agent-storage.ts
 class SqliteAgentStorage {
   threads;
@@ -8632,6 +8833,8 @@ class SqliteAgentStorage {
   memory;
   approvals;
   approvalModes;
+  computers;
+  tokenRates;
   connection;
   constructor(options) {
     this.connection = openSqliteStoreConnection(options);
@@ -8642,6 +8845,8 @@ class SqliteAgentStorage {
     this.memory = new SqliteAgentMemoryStore(this.connection.db);
     this.approvals = new SqliteAgentApprovalStore(this.connection.db);
     this.approvalModes = new SqliteAgentApprovalModeStore(this.connection.db);
+    this.computers = new SqliteAgentComputerSessionStore(this.connection.db);
+    this.tokenRates = new SqliteAgentTokenRateStore(this.connection.db);
   }
   close() {
     closeSqliteStoreConnection(this.connection);
@@ -8665,15 +8870,52 @@ import {
   AiCostStorageError
 } from "@sixb/core/storage";
 
+// src/ai-accounting-filters.ts
+var SQLITE_SOURCE_WORKFLOW = `COALESCE(
+  workflow_node.workflow_id,
+  CASE WHEN execution.executor_kind = 'workflow' THEN execution.authority_primitive_id END
+)`;
+var SQLITE_SOURCE_KIND = `CASE
+  WHEN direct_agent.id IS NOT NULL THEN 'agent'
+  WHEN ${SQLITE_SOURCE_WORKFLOW} IS NOT NULL THEN 'workflow'
+  WHEN execution.executor_kind = 'action' THEN 'action'
+  ELSE 'other'
+END`;
+function sqliteAccountingFilter(columns) {
+  return `(? IS NULL OR ${columns.kind} = ?)
+    AND (? IS NULL OR ${columns.sourceKind} = ?)
+    AND (? IS NULL OR ${columns.sourceWorkflow} = ?)
+    AND (
+      ? IS NULL
+      OR (? = 'none' AND ${columns.userId} IS NULL AND ${columns.serviceAccountId} IS NULL)
+      OR (? = 'user' AND ${columns.userId} = ?)
+      OR (? = 'serviceAccount' AND ${columns.serviceAccountId} = ?)
+    )`;
+}
+function sqliteAccountingFilterParameters(query) {
+  const kind = query.modelKind ?? null;
+  const source = query.source?.kind ?? null;
+  const workflow = query.source?.kind === "workflow" ? query.source.workflowId ?? null : null;
+  const mode = query.requester === undefined ? null : query.requester === "none" ? "none" : query.requester.type;
+  const id = query.requester === undefined || query.requester === "none" ? null : query.requester.id;
+  return [kind, kind, source, source, workflow, workflow, mode, mode, mode, id, mode, id];
+}
+
 // src/ai-cost-groups.ts
 import {
   aiModelCallGroupFragmentFromRow,
   buildAiModelCallGroupsFromFragments,
   normalizeAiModelCallAccountingQuery,
+  normalizeAiModelCallGroupSort,
   TOKENLESS_MODEL_KINDS
 } from "@sixb/core/internal/ai-cost-storage-provider";
+function numbered(sql, start) {
+  let next = start;
+  return sql.replace(/\?(?!\d)/g, () => `?${next++}`);
+}
 async function listAiModelCallGroups(connection, input) {
   const query = normalizeAiModelCallAccountingQuery(input);
+  const sort = normalizeAiModelCallGroupSort(input.sort);
   const parameters = [
     query.projectId,
     query.from.toISOString(),
@@ -8682,20 +8924,28 @@ async function listAiModelCallGroups(connection, input) {
     query.modelId ?? null,
     query.valuationStatus ?? null
   ];
-  const count = connection.db.query(COUNT_SQL).get(...parameters);
-  const rows = connection.db.query(PAGE_SQL).all(...parameters, query.limit, query.offset);
+  const filters = sqliteAccountingFilterParameters(query);
+  const count = connection.db.query(COUNT_SQL).get(...parameters, ...filters);
+  const rows = connection.db.query(PAGE_SQL).all(...parameters, ...filters, query.limit, query.offset, sort);
   const total = Number(count?.total);
   if (!Number.isSafeInteger(total) || total < 0)
     throw new RangeError("[Sixb] Invalid model-call group count.");
-  const items = buildAiModelCallGroupsFromFragments(rows.map(aiModelCallGroupFragmentFromRow));
+  const items = buildAiModelCallGroupsFromFragments(rows.map(aiModelCallGroupFragmentFromRow), sort);
   return { items, total, hasMore: query.offset + items.length < total };
 }
 var TOKENLESS_KINDS = TOKENLESS_MODEL_KINDS.map((kind) => `'${kind}'`).join(", ");
 var FILTERED_SQL = `
 WITH filtered AS (
   SELECT COALESCE(root_agent.execution_id, usage.execution_id) AS root_execution_id,
+    -- What the call is listed under, as aiModelCallGroupKey computes it.
+    CASE
+      WHEN root_agent.thread_id IS NOT NULL THEN 'thread:' || root_agent.thread_id
+      WHEN workflow_node.workflow_run_id IS NOT NULL THEN 'workflowRun:' || workflow_node.workflow_run_id
+      ELSE COALESCE(root_agent.execution_id, usage.execution_id)
+    END AS group_key,
     usage.execution_id, usage.provider_id, usage.requested_model_id, usage.occurred_at,
-    usage.total_tokens, usage.model_kind, usage.output_images, usage.input_characters,
+    usage.total_tokens, usage.input_tokens, usage.cache_read_input_tokens,
+    usage.model_kind, usage.output_images, usage.input_characters,
     usage.audio_duration_ms,
     execution.executor_kind, execution.executor_id, execution.authority_primitive_id AS primitive_id,
     COALESCE(cost.status, 'unvalued') AS valuation_status,
@@ -8708,7 +8958,8 @@ WITH filtered AS (
     workflow_node.node_id AS workflow_agent_step_id,
     workflow_agent.node_run_id AS workflow_node_run_id,
     workflow_node.workflow_id AS workflow_id,
-    workflow_node.workflow_run_id AS workflow_run_id
+    workflow_node.workflow_run_id AS workflow_run_id,
+    execution.requested_by_user_id, execution.requested_by_service_account_id
   FROM ai_model_call_usage AS usage
   JOIN executions AS execution ON execution.project_id = usage.project_id AND execution.id = usage.execution_id
   LEFT JOIN agent_runs AS direct_agent
@@ -8728,23 +8979,33 @@ WITH filtered AS (
     AND (?4 IS NULL OR usage.provider_id = ?4)
     AND (?5 IS NULL OR usage.requested_model_id = ?5)
     AND (?6 IS NULL OR COALESCE(cost.status, 'unvalued') = ?6)
+    AND ${numbered(sqliteAccountingFilter({
+  kind: "usage.model_kind",
+  sourceKind: SQLITE_SOURCE_KIND,
+  sourceWorkflow: SQLITE_SOURCE_WORKFLOW,
+  userId: "execution.requested_by_user_id",
+  serviceAccountId: "execution.requested_by_service_account_id"
+}), 7)}
 ), roots AS (
-  SELECT root_execution_id, MAX(occurred_at) AS last_call_at
-  FROM filtered GROUP BY root_execution_id
+  SELECT group_key, MAX(occurred_at) AS last_call_at, TOTAL(amount_nanos) AS cost_nanos
+  FROM filtered GROUP BY group_key
 )
 `;
 var COUNT_SQL = `${FILTERED_SQL} SELECT CAST(COUNT(*) AS TEXT) AS total FROM roots`;
 var PAGE_SQL = `${FILTERED_SQL}, page AS (
-  SELECT root_execution_id FROM roots
-  ORDER BY last_call_at DESC, root_execution_id ASC LIMIT ?7 OFFSET ?8
+  SELECT group_key FROM roots
+  ORDER BY CASE WHEN ?21 = 'cost' THEN cost_nanos END DESC, last_call_at DESC, group_key ASC
+  LIMIT ?19 OFFSET ?20
 )
-SELECT filtered.root_execution_id, execution_id, provider_id, requested_model_id,
+SELECT filtered.group_key, root_execution_id, execution_id, provider_id, requested_model_id,
   MIN(occurred_at) AS first_call_at, MAX(occurred_at) AS last_call_at,
   CAST(COUNT(*) AS TEXT) AS call_count,
   CAST(COUNT(total_tokens) AS TEXT) AS token_count,
   CAST(COUNT(CASE WHEN total_tokens IS NULL AND model_kind IN (${TOKENLESS_KINDS}) THEN 1 END) AS TEXT)
     AS tokenless_count,
   CAST(SUM(total_tokens) AS TEXT) AS total_tokens,
+  CAST(SUM(input_tokens) AS TEXT) AS input_tokens,
+  CAST(SUM(cache_read_input_tokens) AS TEXT) AS cache_read_input_tokens,
   CAST(SUM(output_images) AS TEXT) AS output_images,
   CAST(SUM(input_characters) AS TEXT) AS input_characters,
   CAST(SUM(audio_duration_ms) AS TEXT) AS audio_duration_ms,
@@ -8761,9 +9022,11 @@ SELECT filtered.root_execution_id, execution_id, provider_id, requested_model_id
   MAX(workflow_agent_step_id) AS workflow_agent_step_id,
   MAX(workflow_node_run_id) AS workflow_node_run_id,
   MAX(workflow_id) AS workflow_id,
-  MAX(workflow_run_id) AS workflow_run_id
-FROM filtered JOIN page ON page.root_execution_id = filtered.root_execution_id
-GROUP BY filtered.root_execution_id, execution_id, provider_id, requested_model_id,
+  MAX(workflow_run_id) AS workflow_run_id,
+  MAX(requested_by_user_id) AS requested_by_user_id,
+  MAX(requested_by_service_account_id) AS requested_by_service_account_id
+FROM filtered JOIN page ON page.group_key = filtered.group_key
+GROUP BY filtered.group_key, root_execution_id, execution_id, provider_id, requested_model_id,
   valuation_status, amount_currency
 `;
 
@@ -9067,7 +9330,7 @@ class SqliteAiCostStorage {
   }
   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);
+    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, ...sqliteAccountingFilterParameters(query), input.bucket, input.bucket);
     return buildAiAccountingOverviewFromFragments(input, rows.map(aggregateFragmentFromRow));
   }
   async listModelCalls(input) {
@@ -9114,12 +9377,32 @@ var SQLITE_ACCOUNTING_LIST_FILTER = `
       ELSE 'unvalued'
     END
   )
+  AND ${sqliteAccountingFilter({
+  kind: "usage.model_kind",
+  sourceKind: SQLITE_SOURCE_KIND,
+  sourceWorkflow: SQLITE_SOURCE_WORKFLOW,
+  userId: "execution.requested_by_user_id",
+  serviceAccountId: "execution.requested_by_service_account_id"
+})}
+`;
+var SQLITE_ACCOUNTING_LIST_JOINS = `
+  JOIN executions AS execution ON execution.project_id = usage.project_id AND execution.id = usage.execution_id
+  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
 `;
 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
+  ${SQLITE_ACCOUNTING_LIST_JOINS}
   WHERE ${SQLITE_ACCOUNTING_LIST_FILTER}
 `;
 var SQLITE_ACCOUNTING_LIST_PAGE_SQL = `
@@ -9154,18 +9437,7 @@ var SQLITE_ACCOUNTING_LIST_PAGE_SQL = `
     cost.details AS cost_details,
     cost.rated_at AS cost_rated_at
   FROM ai_model_call_usage AS usage
-  JOIN executions AS execution ON execution.project_id = usage.project_id AND execution.id = usage.execution_id
-  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
+  ${SQLITE_ACCOUNTING_LIST_JOINS}
   WHERE ${SQLITE_ACCOUNTING_LIST_FILTER}
   ORDER BY usage.occurred_at DESC, usage.id ASC
   LIMIT ? OFFSET ?
@@ -9204,7 +9476,10 @@ var SQLITE_ACCOUNTING_OVERVIEW_SQL = `
         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
+      CASE WHEN cost.status = 'rated' THEN cost.amount_nanos ELSE NULL END AS amount_nanos,
+      execution.requested_by_user_id AS requester_user_id,
+      execution.requested_by_service_account_id AS requester_service_account_id,
+      ${SQLITE_SOURCE_KIND} AS source_kind
     FROM ai_model_call_usage AS usage
     JOIN executions AS execution ON execution.project_id = usage.project_id AND execution.id = usage.execution_id
     LEFT JOIN agent_runs AS direct_agent
@@ -9221,10 +9496,19 @@ var SQLITE_ACCOUNTING_OVERVIEW_SQL = `
     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 = ?)
+  ), filtered AS (
+    SELECT * FROM classified
+    WHERE ${sqliteAccountingFilter({
+  kind: "model_kind",
+  sourceKind: "source_kind",
+  sourceWorkflow: "attribution_workflow_id",
+  userId: "requester_user_id",
+  serviceAccountId: "requester_service_account_id"
+})}
   ), expanded AS (
     SELECT 'totals' AS dimension, NULL AS key_1, NULL AS key_2, NULL AS key_3, NULL AS bucket_start,
-      classified.*
-    FROM classified
+      filtered.*
+    FROM filtered
     UNION ALL
     SELECT 'series', NULL, NULL, NULL,
       CASE ?
@@ -9236,18 +9520,39 @@ var SQLITE_ACCOUNTING_OVERVIEW_SQL = `
           printf('-%d days', (CAST(strftime('%w', occurred_at) AS INTEGER) + 6) % 7)
         )
       END,
-      classified.*
-    FROM classified
+      filtered.*
+    FROM filtered
     UNION ALL
-    SELECT 'model', provider_id, requested_model_id, NULL, NULL, classified.* FROM classified
+    SELECT 'modelSeries', provider_id, requested_model_id, 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,
+      filtered.*
+    FROM filtered
+    UNION ALL
+    SELECT 'model', provider_id, requested_model_id, NULL, NULL, filtered.* FROM filtered
+    UNION ALL
+    SELECT 'person',
+      CASE
+        WHEN requester_user_id IS NOT NULL THEN 'user'
+        WHEN requester_service_account_id IS NOT NULL THEN 'serviceAccount'
+      END,
+      COALESCE(requester_user_id, requester_service_account_id), NULL, NULL, filtered.*
+    FROM filtered
     UNION ALL
-    SELECT 'kind', model_kind, NULL, NULL, NULL, classified.* FROM classified
+    SELECT 'kind', model_kind, NULL, NULL, NULL, filtered.* FROM filtered
     UNION ALL
-    SELECT 'agent', attribution_agent_kind, attribution_workflow_id, attribution_agent_step_id, NULL, classified.*
-    FROM classified WHERE attribution_agent_kind IS NOT NULL
+    SELECT 'agent', attribution_agent_kind, attribution_workflow_id, attribution_agent_step_id, NULL, filtered.*
+    FROM filtered WHERE attribution_agent_kind IS NOT NULL
     UNION ALL
-    SELECT 'workflow', attribution_workflow_id, NULL, NULL, NULL, classified.*
-    FROM classified WHERE attribution_workflow_id IS NOT NULL
+    SELECT 'workflow', attribution_workflow_id, NULL, NULL, NULL, filtered.*
+    FROM filtered WHERE attribution_workflow_id IS NOT NULL
   )
   SELECT dimension,
     key_1,
@@ -9308,11 +9613,16 @@ function accountingListFilterParameters(query) {
     query.executionId ?? null,
     query.executionId ?? null,
     query.valuationStatus ?? null,
-    query.valuationStatus ?? null
+    query.valuationStatus ?? null,
+    ...sqliteAccountingFilterParameters(query)
   ];
 }
 function aggregateFragmentFromRow(row) {
-  const dimensionKeys = row.dimension === "model" ? { providerId: required(row.key_1), modelId: required(row.key_2) } : row.dimension === "kind" ? withModelKind(aiAccountingModelKind(row.key_1)) : row.dimension === "agent" ? {
+  const dimensionKeys = row.dimension === "model" ? { providerId: required(row.key_1), modelId: required(row.key_2) } : row.dimension === "modelSeries" ? {
+    providerId: required(row.key_1),
+    modelId: required(row.key_2),
+    start: new Date(required(row.bucket_start))
+  } : row.dimension === "person" ? row.key_1 && row.key_2 ? { requesterType: row.key_1, requesterId: row.key_2 } : {} : row.dimension === "kind" ? withModelKind(aiAccountingModelKind(row.key_1)) : row.dimension === "agent" ? {
     agentKind: required(row.key_1),
     ...row.key_1 === "workflowAgent" ? { workflowId: required(row.key_2), agentStepId: required(row.key_3) } : {}
   } : row.dimension === "workflow" ? { workflowId: required(row.key_1) } : row.dimension === "series" ? { start: new Date(required(row.bucket_start)) } : {};
@@ -13263,6 +13573,7 @@ import {
 import {
   hasVectorProfile,
   isVectorProfileQuery,
+  linkEndpointObjectTypeIds,
   normalizeVector,
   vectorSearchCandidateLimit
 } from "@sixb/core/internal/query";
@@ -13324,7 +13635,7 @@ function compileObjectQueryInternal(projectId, query, ctx) {
     case "page":
       return compilePage(projectId, query.input, query.pageSize, query.pageToken, ctx);
     case "traverse":
-      return compileTraversal(projectId, query.input, query.linkId, query.direction, query.sourceObjectTypeId, ctx);
+      return compileTraversal(projectId, query, ctx);
     case "set":
       return compileSet(projectId, query.op, query.inputs, ctx);
     case "project":
@@ -13605,9 +13916,11 @@ function compilePage(projectId, inputQuery, rawPageSize, pageToken, ctx) {
     }
   };
 }
-function compileTraversal(projectId, inputQuery, linkId, direction, sourceObjectTypeId, ctx) {
-  const input = compileObjectQueryInternal(projectId, inputQuery, exactContext(ctx));
+function compileTraversal(projectId, traversal, ctx) {
+  const { linkId, direction, sourceObjectTypeId } = traversal;
+  const input = compileObjectQueryInternal(projectId, traversal.input, exactContext(ctx));
   const outputAlias = direction === "outgoing" ? "target_object" : "source_object";
+  const endpointType = compileEndpointTypes(outputAlias, linkEndpointObjectTypeIds(traversal));
   const joinSql = direction === "outgoing" ? `
         JOIN ${ctx.source.linksTable} AS edge
           ON edge.project_id = input.project_id
@@ -13618,6 +13931,7 @@ function compileTraversal(projectId, inputQuery, linkId, direction, sourceObject
           ON target_object.project_id = edge.project_id
          AND target_object.object_type_id = edge.target_type_id
          AND target_object.primary_id = edge.target_id
+         ${endpointType.sql}
       ` : `
         JOIN ${ctx.source.linksTable} AS edge
           ON edge.project_id = input.project_id
@@ -13629,6 +13943,7 @@ function compileTraversal(projectId, inputQuery, linkId, direction, sourceObject
           ON source_object.project_id = edge.project_id
          AND source_object.object_type_id = edge.source_type_id
          AND source_object.primary_id = edge.source_id
+         ${endpointType.sql}
       `;
   const order = compileOrder(identityOrderFields());
   const qualifiedOrder = compileOrder(identityOrderFields(), outputAlias);
@@ -13641,7 +13956,8 @@ function compileTraversal(projectId, inputQuery, linkId, direction, sourceObject
   const args = [
     ...input.args,
     linkId,
-    ...sourceObjectTypeId === undefined ? [] : [sourceObjectTypeId],
+    ...direction === "incoming" && sourceObjectTypeId !== undefined ? [sourceObjectTypeId] : [],
+    ...endpointType.args,
     ...qualifiedOrder.args
   ];
   return {
@@ -13657,6 +13973,14 @@ function compileTraversal(projectId, inputQuery, linkId, direction, sourceObject
     }
   };
 }
+function compileEndpointTypes(alias, objectTypeIds) {
+  if (!objectTypeIds?.length)
+    return { sql: "", args: [] };
+  return {
+    sql: `AND ${alias}.object_type_id IN (${objectTypeIds.map(() => "?").join(", ")})`,
+    args: [...objectTypeIds]
+  };
+}
 function compileExpand(projectId, inputQuery, expansions, ctx) {
   const input = compileObjectQueryInternal(projectId, inputQuery, exactContext(ctx));
   const expand = compileExpansionsObject(expansions, { project: "input.project_id", type: "input.object_type_id", id: "input.primary_id" }, "", ctx);
@@ -13707,7 +14031,8 @@ function compileExpansionValue(expansion, parent, path, ctx) {
     `${parentId} = ${parent.id}`,
     `${edge}.link_id = ?`
   ];
-  const whereArgs = [expansion.linkId];
+  const endpointType = compileEndpointTypes(target, expansion.endpointObjectTypeIds);
+  const whereArgs = [...endpointType.args, expansion.linkId];
   if (incoming && expansion.sourceObjectTypeId !== undefined) {
     whereParts.push(`${edge}.source_type_id = ?`);
     whereArgs.push(expansion.sourceObjectTypeId);
@@ -13718,6 +14043,7 @@ function compileExpansionValue(expansion, parent, path, ctx) {
       ON ${target}.project_id = ${edge}.project_id
      AND ${target}.object_type_id = ${neighborType}
      AND ${target}.primary_id = ${neighborId}
+     ${endpointType.sql}
     WHERE ${whereParts.join(" AND ")}
   `;
   if (expansion.cardinality === "one") {
@@ -15620,6 +15946,9 @@ class SqliteOntologyCommitStorage {
       assertNonnegativeInteger(offset, "Ontology commit list offset");
       if (limit !== -1)
         assertNonnegativeInteger(limit, "Ontology commit list limit");
+      if (input.committedAt !== undefined) {
+        assertTimestamp(input.committedAt, "Ontology commit list committedAt");
+      }
       const filters = ["project_id = ?"];
       const values = [input.projectId];
       if (input.run?.kind === "action") {
@@ -15629,6 +15958,10 @@ class SqliteOntologyCommitStorage {
         filters.push("origin_run_id = ? AND origin_kind IN ('projection', 'telemetry')");
         values.push(input.run.id);
       }
+      if (input.committedAt !== undefined) {
+        filters.push("committed_at = ?");
+        values.push(input.committedAt);
+      }
       const where = filters.join(" AND ");
       const totalRow = this.db.query(`SELECT COUNT(*) AS total FROM ontology_commits WHERE ${where}`).get(...values);
       const direction = input.order === "desc" ? "DESC" : "ASC";
@@ -15680,6 +16013,7 @@ import {
   invalidCorrelation as invalidCorrelation2,
   materializationOutboxWrite,
   materializationPlanChunk,
+  prepareMaterializationStateRead,
   sameNonnegativeCounts as sameCounts,
   uniqueSorted
 } from "@sixb/core/internal/ontology-storage-provider";
@@ -17851,6 +18185,17 @@ class SqliteOntologyMaterializationStorage {
       }
     }
   }
+  async readState(input) {
+    const request = prepareMaterializationStateRead(input);
+    return runDeferredReadTransaction(this.db, () => {
+      const reader = new SqliteMaterializationStateReader(this.db, request.projectId);
+      return {
+        objects: reader.objectStates(request.objects),
+        links: reader.linkStates(request.links),
+        linkScopes: reader.linkSlotStates(request.linkScopes)
+      };
+    });
+  }
   async stageWork(input) {
     this.sessions.stage(input);
     await yieldSqliteEventLoop();
@@ -18973,7 +19318,10 @@ class SqliteOntologyStorage {
 // src/pipeline-run-storage.ts
 import { parseSixbFailure as parseSixbFailure4, serializeSixbFailure as serializeSixbFailure3 } from "@sixb/core/internal/errors";
 import { assertPipelineRunExecution } from "@sixb/core/internal/pipeline-run-storage-provider";
-import { canRequeuePipelineRunAfterEnqueueFailure } from "@sixb/core/internal/storage";
+import {
+  canFinishPipelineRun,
+  canRequeuePipelineRunAfterEnqueueFailure
+} from "@sixb/core/internal/storage";
 import { PIPELINE_RUN_FAILURE_CODES, PipelineRunError } from "@sixb/core/storage";
 
 // src/latest-run-query.ts
@@ -19089,8 +19437,7 @@ class SqlitePipelineRunStorage {
       if (!existing) {
         throw new PipelineRunError(`[SixbSqlite] Pipeline run '${input.id}' not found for project '${input.projectId}'.`);
       }
-      const enqueueFailure = input.status === "failed" && input.error.code === "queue.enqueue_failed";
-      if (enqueueFailure && existing.status !== "queued" || !enqueueFailure && existing.status !== "running") {
+      if (!canFinishPipelineRun(existing.status, input)) {
         throw new PipelineRunError(`[SixbSqlite] Pipeline run '${input.id}' cannot finish from status '${existing.status}'.`);
       }
       this.db.query(`
@@ -20301,7 +20648,7 @@ function invalidRecord2(message) {
 
 // src/sync-run-storage.ts
 import { parseSixbFailure as parseSixbFailure5, serializeSixbFailure as serializeSixbFailure5 } from "@sixb/core/internal/errors";
-import { canRequeueSyncRunAfterEnqueueFailure } from "@sixb/core/internal/storage";
+import { canFinishSyncRun, canRequeueSyncRunAfterEnqueueFailure } from "@sixb/core/internal/storage";
 import { assertSyncRunExecution } from "@sixb/core/internal/sync-run-storage-provider";
 import { SYNC_RUN_FAILURE_CODES, SyncRunError } from "@sixb/core/storage";
 class SqliteSyncRunStorage {
@@ -20389,8 +20736,7 @@ class SqliteSyncRunStorage {
       if (!existing) {
         throw new SyncRunError(`[SixbSqlite] Sync run '${input.id}' not found for project '${input.projectId}'.`);
       }
-      const enqueueFailure = input.status === "failed" && input.error.code === "queue.enqueue_failed";
-      if (enqueueFailure && existing.status !== "queued" || !enqueueFailure && existing.status !== "running") {
+      if (!canFinishSyncRun(existing.status, input)) {
         throw new SyncRunError(`[SixbSqlite] Sync run '${input.id}' cannot finish from status '${existing.status}'.`);
       }
       if (input.status === "succeeded") {
@@ -21865,4 +22211,4 @@ export {
   migrateSqliteStorage
 };
 
-//# debugId=21418853CB8E412664756E2164756E21
+//# debugId=70BDC079F392018764756E2164756E21