@sixb/core 0.1.1 → 0.1.2

package/dist/{chunk-raq0x6bd.js → chunk-ys1nse2v.js}

@@ -16,6 +16,7 @@ import {
   compareCardinalityWork,
   compareEventWork,
   comparePlanWork,
+  createEventId,
   finishScopeAccumulator,
   invalidCorrelation,
   isExactStagingManifest,
@@ -26,7 +27,7 @@ import {
   startScopeAccumulator,
   uniqueSorted,
   workUniquenessKey
-} from "./chunk-hb9xcx9c.js";
+} from "./chunk-fmx1sz2h.js";
 import {
   createAgentOperationScope,
   createAuthOperationScope,
@@ -34,20 +35,28 @@ import {
   createOperationScopedFacade,
   createStorageOperationScope,
   createWorkflowRunOperationScope
-} from "./chunk-xqbtf4wn.js";
+} from "./chunk-57r1cpxx.js";
+import {
+  PipelineRunError,
+  assertPipelineRunExecution
+} from "./chunk-cy0n5dms.js";
 import {
   ProjectionRunError,
   advanceProjectionTelemetry,
   assertGenericProgressDoesNotAdvanceTelemetry,
   assertProjectionMissingTarget,
-  assertProjectionRunExecution,
+  assertProjectionRunAttempt,
+  assertProjectionRunDurableExecution,
   assertProjectionRunIdentityMatches,
   assertProjectionRunListWindow,
   assertProjectionRunNonEmpty,
+  assertProjectionRunQueueInput,
   assertProjectionRunRunning,
   assertProjectionRunStartInput,
+  canRequeueProjectionRunAfterEnqueueFailure,
   createProjectionRunClaim,
   createProjectionRunRecord,
+  failProjectionRunEnqueue,
   finishProjectionRunRecord,
   immutableDatasetVersionConflict,
   mergeProjectionRunProgress,
@@ -57,50 +66,83 @@ import {
   publicProjectionRunRecord,
   requireTelemetryProjectionRun,
   staleProjectionRunExecution
-} from "./chunk-50kv63vj.js";
+} from "./chunk-dysw7nsm.js";
 import {
-  compareQueryScalarValues,
-  queryScalarValuesEqual
-} from "./chunk-6wetht33.js";
+  SyncRunError,
+  assertSyncRunExecution
+} from "./chunk-62c7t4jc.js";
+import {
+  WebhookRunError,
+  assertWebhookRunExecution
+} from "./chunk-ezake7g1.js";
+import {
+  WorkflowRunError,
+  assertWorkflowAgentNodeRunExecution,
+  assertWorkflowRunExecution
+} from "./chunk-4x43bkbp.js";
+import {
+  parseActionRunFailure
+} from "./chunk-htq0qh7z.js";
+import {
+  ActionRunError,
+  assertActionRunExecution
+} from "./chunk-xkthy56g.js";
 import {
-  createEventId
-} from "./chunk-bh8bwma3.js";
+  AgentStorageError,
+  assertAgentRunExecution
+} from "./chunk-vp1vc6ee.js";
+import {
+  CONNECTOR_CONNECTION_RUN_FAILURE_CODES,
+  ConnectorConnectionStorageError
+} from "./chunk-5gd7tpv6.js";
+import {
+  ExecutionStorageError,
+  cloneExecutionRecord,
+  normalizeExecutionRecord,
+  validateExecutionRecordReferences
+} from "./chunk-h9kxd41f.js";
 import {
   assertPinnedDatasetWatermark
 } from "./chunk-9dzba0f2.js";
 import {
   linkRefKey,
   linkRefSortKey,
+  linkScopeKey,
   linkScopeSortKey,
   objectRefKey,
   objectRefSortKey,
   projectionEntityKey,
   telemetryPointKey,
   telemetryPointSortKey
-} from "./chunk-8kv2sez0.js";
+} from "./chunk-vybf6pkp.js";
 import {
   MaterializationConflictError,
   MaterializationValidationError
 } from "./chunk-ry24jbr1.js";
 import {
-  InMemoryAgentStorage
-} from "./chunk-9k3hgv8h.js";
+  compareQueryScalarValues,
+  queryScalarValuesEqual
+} from "./chunk-6wetht33.js";
+import {
+  AGENT_RUN_FAILURE_CODES
+} from "./chunk-663csy96.js";
 import {
   InMemoryAuthStorage,
-  SYSTEM_PRINCIPAL,
-  paginate
-} from "./chunk-xt6qx9sh.js";
+  normalizeRequesterGroupIds,
+  paginate,
+  principalsEqual
+} from "./chunk-jaj13078.js";
 import {
+  createSixbError,
+  parseSixbFailure,
+  toSixbFailure
+} from "./chunk-0172wgm9.js";
+import {
+  assertJsonValue,
   cloneJsonValue,
+  isPlainRecord,
   stableJsonStringify
-} from "./chunk-be9vm29v.js";
-// src/storage/action-runs/errors.ts
-class ActionRunError extends MaterializationConflictError {
-  name = "ActionRunError";
-  constructor(message) {
-    super("run-correlation", message);
-  }
-}
+} from "./chunk-t8t39h7v.js";
 // src/storage/action-runs/idempotency.ts
 function actionSubjectsEqual(left, right) {
   if (left.kind !== right.kind)
@@ -121,10 +163,10 @@ function finishActionRunPhase(input, current) {
   if (input.status === "succeeded") {
     return input.phase ?? current ?? "validation";
   }
-  return input.phase ?? input.error?.phase ?? current ?? "validation";
+  return input.error.details.phase;
 }
 function canRequeueActionRunAfterEnqueueFailure(existing, input) {
-  return existing.status === "failed" && existing.phase === "enqueue" && existing.actionId === input.actionId && existing.idempotencyKey === input.idempotencyKey && actionSubjectsEqual(existing.subject, input.subject) && actionRunParamsEqual(existing.params, input.params);
+  return existing.status === "failed" && existing.phase === "enqueue" && existing.executionId === input.executionId && existing.error?.retryable === true && existing.actionId === input.actionId && existing.idempotencyKey === input.idempotencyKey && actionSubjectsEqual(existing.subject, input.subject) && actionRunParamsEqual(existing.params, input.params);
 }
 function isTerminalActionRun(record) {
   return record.status === "succeeded" || record.status === "failed" || record.status === "cancelled";
@@ -152,8 +194,8 @@ function normalizeParams(params) {
 function normalizeSubject(subject) {
   return structuredClone(subject);
 }
-function normalizeError(error) {
-  return error ? structuredClone(error) : undefined;
+function normalizeError(error, expectedPhase) {
+  return expectedPhase === undefined ? parseActionRunFailure(error) : parseActionRunFailure(error, expectedPhase);
 }
 function normalizeWriteback(input, completedAt) {
   if (input.status === "succeeded") {
@@ -166,7 +208,7 @@ function normalizeWriteback(input, completedAt) {
   return {
     status: "failed",
     completedAt,
-    error: normalizeError(input.error)
+    error: normalizeError(input.error, "writeback")
   };
 }
 function normalizeEffects(input, completedAt) {
@@ -179,7 +221,7 @@ function normalizeEffects(input, completedAt) {
   return {
     status: "failed",
     completedAt,
-    error: normalizeError(input.error)
+    error: normalizeError(input.error, "effects")
   };
 }
 function compareRuns(a, b, order) {
@@ -196,9 +238,11 @@ function compareRuns(a, b, order) {
 }
 
 class InMemoryActionRunStorage {
+  executions;
   rows = new Map;
   runRootOperation;
-  constructor(input = {}) {
+  constructor(executions, input = {}) {
+    this.executions = executions;
     this.runRootOperation = input.runRootOperation ?? runDirectly;
   }
   snapshot() {
@@ -214,15 +258,26 @@ class InMemoryActionRunStorage {
     return this.runRootOperation(() => cloneActionRunRecord(this.requireMaterializationRun(input)));
   }
   async queue(input) {
-    return this.runRootOperation(() => {
+    return this.runRootOperation(async () => {
       const key = actionRunKey(input.projectId, input.id);
       const existing = this.rows.get(key);
       if (existing && !canRequeueActionRunAfterEnqueueFailure(existing, input)) {
         throw new ActionRunError(`[Sixb] Action run '${input.id}' already exists for project '${input.projectId}'.`);
       }
+      if ([...this.rows.values()].some((run) => run.projectId === input.projectId && run.id !== input.id && run.executionId === input.executionId)) {
+        throw new ActionRunError(`[Sixb] Execution '${input.executionId}' already belongs to another Action run.`);
+      }
+      await assertActionRunExecution({
+        executions: this.executions,
+        projectId: input.projectId,
+        executionId: input.executionId,
+        runId: input.id,
+        actionId: input.actionId
+      });
       const record = {
         id: input.id,
         projectId: input.projectId,
+        executionId: input.executionId,
         actionId: input.actionId,
         subject: normalizeSubject(input.subject),
         status: "queued",
@@ -333,7 +388,7 @@ class InMemoryActionRunStorage {
       if (isTerminalActionRun(existing)) {
         throw new ActionRunError(`[Sixb] Action run '${input.id}' cannot finish from terminal status '${existing.status}'.`);
       }
-      const phase = input.status === "succeeded" ? input.phase ?? existing.phase : input.phase ?? input.error?.phase ?? existing.phase;
+      const phase = input.status === "succeeded" ? input.phase ?? existing.phase : input.error.details.phase;
       const base = {
         ...existing,
         status: input.status,
@@ -401,6 +456,1440 @@ class InMemoryActionRunStorage {
     return existing;
   }
 }
+// src/agents/message.ts
+var AGENT_MESSAGE_CONTENT_VERSION = 1;
+
+// src/storage/agents/in-memory.ts
+function normalizeFailure(failure) {
+  return failure ? parseSixbFailure(failure, AGENT_RUN_FAILURE_CODES) : undefined;
+}
+function key(projectId, id) {
+  return `${projectId}:${id}`;
+}
+function clone(value) {
+  return structuredClone(value);
+}
+function compareByDate(left, right, leftId, rightId, order) {
+  const delta = (left?.getTime() ?? 0) - (right?.getTime() ?? 0);
+  if (delta !== 0) {
+    return order === "asc" ? delta : -delta;
+  }
+  if (leftId === rightId) {
+    return 0;
+  }
+  return order === "asc" ? leftId.localeCompare(rightId) : rightId.localeCompare(leftId);
+}
+function applyWindow(rows, offset = 0, limit) {
+  const total = rows.length;
+  const end = limit === undefined ? total : offset + limit;
+  const page = rows.slice(offset, end);
+  return { page, hasMore: offset + page.length < total, total };
+}
+
+class InMemoryAgentThreadStore {
+  state;
+  constructor(state) {
+    this.state = state;
+  }
+  async create(input) {
+    const threadKey = key(input.projectId, input.id);
+    if (this.state.threads.has(threadKey)) {
+      throw new AgentStorageError("duplicate_id", `[Sixb] Agent thread '${input.id}' already exists for project '${input.projectId}'.`);
+    }
+    const createdAt = new Date(input.createdAt ?? new Date);
+    const record = {
+      id: input.id,
+      projectId: input.projectId,
+      agentId: input.agentId,
+      ownerPrincipal: clone(input.ownerPrincipal),
+      ...input.title === undefined ? {} : { title: input.title },
+      status: input.status ?? "active",
+      activeRunId: null,
+      messageCount: 0,
+      createdAt,
+      updatedAt: new Date(input.updatedAt ?? createdAt)
+    };
+    this.state.threads.set(threadKey, clone(record));
+    return clone(record);
+  }
+  async getById(params) {
+    const record = this.state.threads.get(key(params.projectId, params.id));
+    return record ? clone(record) : null;
+  }
+  async list(input) {
+    const order = input.order ?? "desc";
+    const statuses = input.statuses ? new Set(input.statuses) : null;
+    const agentIds = input.agentIds ? new Set(input.agentIds) : null;
+    const filtered = [...this.state.threads.values()].filter((thread) => thread.projectId === input.projectId).filter((thread) => input.agentId ? thread.agentId === input.agentId : true).filter((thread) => agentIds ? agentIds.has(thread.agentId) : true).filter((thread) => statuses ? statuses.has(thread.status) : true).filter((thread) => input.ownerPrincipal ? principalsEqual(thread.ownerPrincipal, input.ownerPrincipal) : true).sort((a, b) => compareByDate(a.lastMessageAt ?? a.createdAt, b.lastMessageAt ?? b.createdAt, a.id, b.id, order));
+    const { page, hasMore, total } = applyWindow(filtered, input.offset, input.limit);
+    return { threads: page.map(clone), hasMore, total };
+  }
+}
+
+class InMemoryAgentRunStore {
+  state;
+  executions;
+  constructor(state, executions) {
+    this.state = state;
+    this.executions = executions;
+  }
+  async create(input) {
+    await assertAgentRunExecution({
+      executions: this.executions,
+      projectId: input.projectId,
+      executionId: input.executionId,
+      runId: input.id,
+      agentId: input.agentId
+    });
+    const threadKey = key(input.projectId, input.threadId);
+    const thread = this.state.threads.get(threadKey);
+    if (!thread) {
+      throw new AgentStorageError("thread_not_found", `[Sixb] Agent thread '${input.threadId}' not found for project '${input.projectId}'.`);
+    }
+    if (thread.activeRunId !== null) {
+      throw new AgentStorageError("active_run_exists", `[Sixb] Agent thread '${input.threadId}' already has an active run '${thread.activeRunId}'.`);
+    }
+    const runKey = key(input.projectId, input.id);
+    if (this.state.runs.has(runKey)) {
+      throw new AgentStorageError("duplicate_id", `[Sixb] Agent run '${input.id}' already exists for project '${input.projectId}'.`);
+    }
+    if ([...this.state.runs.values()].some((run2) => run2.projectId === input.projectId && run2.executionId === input.executionId)) {
+      throw new AgentStorageError("duplicate_id", `[Sixb] Execution '${input.executionId}' already belongs to another Agent run.`);
+    }
+    const createdAt = new Date(input.createdAt ?? new Date);
+    const run = {
+      id: input.id,
+      projectId: input.projectId,
+      executionId: input.executionId,
+      threadId: input.threadId,
+      agentId: input.agentId,
+      triggerMessageId: input.triggerMessageId,
+      requesterGroupIds: normalizeRequesterGroupIds(input.requesterGroupIds),
+      status: "queued",
+      attempt: 0,
+      createdAt
+    };
+    this.state.runs.set(runKey, clone(run));
+    const updatedThread = {
+      ...thread,
+      activeRunId: run.id,
+      updatedAt: createdAt
+    };
+    this.state.threads.set(threadKey, clone(updatedThread));
+    return clone(run);
+  }
+  async start(input) {
+    const run = this.requireStatus(input.projectId, input.id, "queued");
+    const startedAt = new Date(input.startedAt ?? new Date);
+    const next = {
+      ...run,
+      status: "running",
+      ...input.modelId === undefined ? {} : { modelId: input.modelId },
+      attempt: 1,
+      execution: clone(input.execution),
+      startedAt
+    };
+    this.state.runs.set(key(input.projectId, input.id), clone(next));
+    return clone(next);
+  }
+  async finishQueued(input) {
+    const run = this.requireStatus(input.projectId, input.id, "queued");
+    const completedAt = new Date(input.completedAt ?? new Date);
+    const next = {
+      ...run,
+      status: input.status,
+      ...input.error === undefined ? {} : { error: normalizeFailure(input.error) },
+      completedAt
+    };
+    this.state.runs.set(key(input.projectId, input.id), clone(next));
+    this.releaseThread(run, completedAt);
+    return clone(next);
+  }
+  async reclaim(input) {
+    const run = this.requireRunning(input.projectId, input.id);
+    const next = {
+      ...run,
+      attempt: run.attempt + 1,
+      execution: clone(input.execution)
+    };
+    this.state.runs.set(key(input.projectId, input.id), clone(next));
+    return clone(next);
+  }
+  async confirmExecutionOwnership(input) {
+    const run = this.requireRunning(input.projectId, input.id);
+    if (!run.execution || run.execution.token !== input.executionToken) {
+      throw new AgentStorageError("execution_lost", `[Sixb] Execution token is no longer current on agent run '${input.id}'.`);
+    }
+    const next = {
+      ...run,
+      execution: {
+        ...run.execution,
+        queueLeaseExpiresAt: new Date(Math.max(run.execution.queueLeaseExpiresAt.getTime(), input.queueLeaseExpiresAt.getTime()))
+      }
+    };
+    this.state.runs.set(key(input.projectId, input.id), clone(next));
+    return clone(next);
+  }
+  async finish(input) {
+    const run = this.requireRunning(input.projectId, input.id);
+    if (!run.execution || run.execution.token !== input.executionToken) {
+      throw new AgentStorageError("execution_lost", `[Sixb] Execution token is no longer current on agent run '${input.id}'.`);
+    }
+    const completedAt = new Date(input.completedAt ?? new Date);
+    const next = {
+      ...run,
+      status: input.status,
+      ...input.modelId === undefined ? {} : { modelId: input.modelId },
+      ...input.finishReason === undefined ? {} : { finishReason: input.finishReason },
+      ...input.diagnostics === undefined ? {} : { diagnostics: clone(input.diagnostics) },
+      ...input.status === "succeeded" || input.error === undefined ? {} : { error: normalizeFailure(input.error) },
+      execution: undefined,
+      completedAt
+    };
+    this.state.runs.set(key(input.projectId, input.id), clone(next));
+    this.releaseThread(run, completedAt);
+    return clone(next);
+  }
+  async getById(params) {
+    const record = this.state.runs.get(key(params.projectId, params.id));
+    return record ? clone(record) : null;
+  }
+  async getByIds(params) {
+    return [...new Set(params.ids)].map((id) => this.state.runs.get(key(params.projectId, id))).filter((record) => record !== undefined).map(clone);
+  }
+  async list(input) {
+    const order = input.order ?? "desc";
+    const statuses = input.statuses ? new Set(input.statuses) : null;
+    const filtered = [...this.state.runs.values()].filter((run) => run.projectId === input.projectId).filter((run) => input.threadId ? run.threadId === input.threadId : true).filter((run) => input.agentId ? run.agentId === input.agentId : true).filter((run) => statuses ? statuses.has(run.status) : true).filter((run) => input.startedAfter ? (run.startedAt ?? run.createdAt) >= input.startedAfter : true).filter((run) => input.startedBefore ? (run.startedAt ?? run.createdAt) <= input.startedBefore : true).sort((a, b) => compareByDate(a.startedAt ?? a.createdAt, b.startedAt ?? b.createdAt, a.id, b.id, order));
+    const { page, hasMore, total } = applyWindow(filtered, input.offset, input.limit);
+    return { runs: page.map(clone), hasMore, total };
+  }
+  requireRunning(projectId, id) {
+    return this.requireStatus(projectId, id, "running");
+  }
+  requireStatus(projectId, id, status) {
+    const run = this.state.runs.get(key(projectId, id));
+    if (!run) {
+      throw new AgentStorageError("run_not_found", `[Sixb] Agent run '${id}' not found for project '${projectId}'.`);
+    }
+    if (run.status !== status) {
+      throw new AgentStorageError("invalid_state", `[Sixb] Agent run '${id}' is not ${status} (status '${run.status}').`);
+    }
+    return run;
+  }
+  releaseThread(run, completedAt) {
+    const threadKey = key(run.projectId, run.threadId);
+    const thread = this.state.threads.get(threadKey);
+    if (thread && thread.activeRunId === run.id) {
+      this.state.threads.set(threadKey, clone({ ...thread, activeRunId: null, updatedAt: completedAt }));
+    }
+  }
+}
+
+class InMemoryAgentMessageStore {
+  state;
+  constructor(state) {
+    this.state = state;
+  }
+  async append(input) {
+    const threadKey = key(input.projectId, input.threadId);
+    const thread = this.state.threads.get(threadKey);
+    if (!thread) {
+      throw new AgentStorageError("thread_not_found", `[Sixb] Agent thread '${input.threadId}' not found for project '${input.projectId}'.`);
+    }
+    const messageKey = key(input.projectId, input.id);
+    if (this.state.messages.has(messageKey)) {
+      throw new AgentStorageError("duplicate_id", `[Sixb] Agent message '${input.id}' already exists for project '${input.projectId}'.`);
+    }
+    if (input.runId !== null && !this.state.runs.has(key(input.projectId, input.runId))) {
+      throw new AgentStorageError("run_not_found", `[Sixb] Agent run '${input.runId}' not found for project '${input.projectId}'.`);
+    }
+    const createdAt = new Date(input.createdAt ?? new Date);
+    const seq = this.nextSeq(input.projectId, input.threadId);
+    const message = {
+      id: input.id,
+      projectId: input.projectId,
+      threadId: input.threadId,
+      runId: input.runId,
+      role: input.role,
+      ...input.authorPrincipal === undefined ? {} : { authorPrincipal: clone(input.authorPrincipal) },
+      seq,
+      parts: clone(input.parts),
+      ...input.metadata === undefined ? {} : { metadata: clone(input.metadata) },
+      contentVersion: AGENT_MESSAGE_CONTENT_VERSION,
+      createdAt,
+      ...input.completedAt === undefined ? {} : { completedAt: new Date(input.completedAt) }
+    };
+    this.state.messages.set(messageKey, clone(message));
+    this.state.threads.set(threadKey, clone({
+      ...thread,
+      messageCount: thread.messageCount + 1,
+      lastMessageAt: createdAt,
+      updatedAt: createdAt
+    }));
+    return clone(message);
+  }
+  async getById(params) {
+    const record = this.state.messages.get(key(params.projectId, params.id));
+    return record ? clone(record) : null;
+  }
+  async list(input) {
+    const order = input.order ?? "asc";
+    const roles = input.roles ? new Set(input.roles) : null;
+    const filtered = [...this.state.messages.values()].filter((message) => message.projectId === input.projectId).filter((message) => message.threadId === input.threadId).filter((message) => roles ? roles.has(message.role) : true).sort((a, b) => order === "asc" ? a.seq - b.seq : b.seq - a.seq);
+    const { page, hasMore, total } = applyWindow(filtered, input.offset, input.limit);
+    return { messages: page.map(clone), hasMore, total };
+  }
+  nextSeq(projectId, threadId) {
+    let max = 0;
+    for (const message of this.state.messages.values()) {
+      if (message.projectId === projectId && message.threadId === threadId && message.seq > max) {
+        max = message.seq;
+      }
+    }
+    return max + 1;
+  }
+}
+
+class InMemoryAgentStorage {
+  state = {
+    threads: new Map,
+    runs: new Map,
+    messages: new Map
+  };
+  threads;
+  runs;
+  messages;
+  constructor(executions) {
+    this.threads = new InMemoryAgentThreadStore(this.state);
+    this.runs = new InMemoryAgentRunStore(this.state, executions);
+    this.messages = new InMemoryAgentMessageStore(this.state);
+  }
+  snapshot() {
+    return {
+      threads: structuredClone(this.state.threads),
+      runs: structuredClone(this.state.runs),
+      messages: structuredClone(this.state.messages)
+    };
+  }
+  restore(snapshot) {
+    replace(this.state.threads, snapshot.threads);
+    replace(this.state.runs, snapshot.runs);
+    replace(this.state.messages, snapshot.messages);
+  }
+}
+function replace(target, source) {
+  target.clear();
+  for (const [k, value] of structuredClone(source)) {
+    target.set(k, value);
+  }
+}
+// src/storage/ai-usage/errors.ts
+class AiUsageStorageError extends Error {
+  code;
+  name = "AiUsageStorageError";
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+}
+// src/storage/ai-usage/usage.ts
+var USAGE_FIELDS = [
+  "inputTokens",
+  "outputTokens",
+  "uncachedInputTokens",
+  "cacheReadInputTokens",
+  "cacheWriteInputTokens",
+  "textOutputTokens",
+  "reasoningOutputTokens"
+];
+function normalizeAiModelCallUsage(input) {
+  for (const field of USAGE_FIELDS) {
+    assertUsageCount(input[field], field);
+  }
+  const totalTokens = input.inputTokens === undefined || input.outputTokens === undefined ? undefined : addUsageCounts(input.inputTokens, input.outputTokens, "totalTokens");
+  const reportingStatus = input.inputTokens !== undefined && input.outputTokens !== undefined ? "complete" : USAGE_FIELDS.some((field) => input[field] !== undefined) ? "partial" : "unavailable";
+  return {
+    ...input.inputTokens === undefined ? {} : { inputTokens: input.inputTokens },
+    ...input.outputTokens === undefined ? {} : { outputTokens: input.outputTokens },
+    ...totalTokens === undefined ? {} : { totalTokens },
+    ...input.uncachedInputTokens === undefined ? {} : { uncachedInputTokens: input.uncachedInputTokens },
+    ...input.cacheReadInputTokens === undefined ? {} : { cacheReadInputTokens: input.cacheReadInputTokens },
+    ...input.cacheWriteInputTokens === undefined ? {} : { cacheWriteInputTokens: input.cacheWriteInputTokens },
+    ...input.textOutputTokens === undefined ? {} : { textOutputTokens: input.textOutputTokens },
+    ...input.reasoningOutputTokens === undefined ? {} : { reasoningOutputTokens: input.reasoningOutputTokens },
+    reportingStatus
+  };
+}
+function aggregateAiModelCallUsage(usages) {
+  const normalized = Array.from(usages, normalizeAiModelCallUsage);
+  const fields = Object.fromEntries(USAGE_FIELDS.map((field) => [field, sumUsageField(normalized, field)]));
+  const aggregate = normalizeAiModelCallUsage(fields);
+  if (aggregate.reportingStatus === "unavailable" && normalized.some((usage) => usage.reportingStatus !== "unavailable")) {
+    return { ...aggregate, reportingStatus: "partial" };
+  }
+  return aggregate;
+}
+function sumUsageField(usages, field) {
+  if (usages.length === 0)
+    return;
+  let total = 0;
+  for (const usage of usages) {
+    const value = usage[field];
+    if (value === undefined)
+      return;
+    total = addUsageCounts(total, value, `aggregate ${field}`);
+  }
+  return total;
+}
+function assertUsageCount(value, field) {
+  if (value !== undefined && (!Number.isSafeInteger(value) || value < 0)) {
+    throw new TypeError(`[Sixb] AI model-call usage ${field} must be a non-negative safe integer.`);
+  }
+}
+function addUsageCounts(left, right, field) {
+  const result = left + right;
+  if (!Number.isSafeInteger(result)) {
+    throw new TypeError(`[Sixb] AI model-call usage ${field} exceeds the safe integer range.`);
+  }
+  return result;
+}
+
+// src/storage/ai-usage/record.ts
+function normalizeAiModelCallRecord(input) {
+  assertNonBlank2(input.id, "id");
+  assertNonBlank2(input.projectId, "projectId");
+  assertAiUsageExecutionId(input.executionId);
+  assertPositiveSafeInteger(input.attempt, "attempt");
+  assertNonBlank2(input.callId, "callId");
+  assertNonBlank2(input.providerId, "providerId");
+  assertNonBlank2(input.requestedModelId, "requestedModelId");
+  if (input.responseModelId !== undefined) {
+    assertNonBlank2(input.responseModelId, "responseModelId");
+  }
+  assertNonBlank2(input.responseId, "responseId");
+  const occurredAt = cloneValidDate(input.occurredAt, "occurredAt");
+  const recordedAt = cloneValidDate(input.recordedAt ?? new Date, "recordedAt");
+  const requesterGroupIds = normalizeRequesterGroupIds(input.requesterGroupIds);
+  const rawUsage = cloneRawUsage(input.rawUsage);
+  return {
+    id: input.id,
+    projectId: input.projectId,
+    executionId: input.executionId,
+    attempt: input.attempt,
+    callId: input.callId,
+    requesterGroupIds,
+    providerId: input.providerId,
+    requestedModelId: input.requestedModelId,
+    ...input.responseModelId === undefined ? {} : { responseModelId: input.responseModelId },
+    responseId: input.responseId,
+    usage: normalizeAiModelCallUsage(input.usage),
+    ...rawUsage === undefined ? {} : { rawUsage },
+    occurredAt,
+    recordedAt
+  };
+}
+function assertAiUsageExecutionId(executionId) {
+  assertNonBlank2(executionId, "executionId");
+}
+function cloneRawUsage(rawUsage) {
+  if (rawUsage === undefined)
+    return;
+  if (!isPlainRecord(rawUsage)) {
+    throw new TypeError("[Sixb] AI usage rawUsage must be a JSON object.");
+  }
+  assertJsonValue(rawUsage, "AI usage rawUsage");
+  return structuredClone(rawUsage);
+}
+function assertNonBlank2(value, field) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new TypeError(`[Sixb] AI usage ${field} must be nonblank.`);
+  }
+}
+function assertPositiveSafeInteger(value, field) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new TypeError(`[Sixb] AI usage ${field} must be a positive safe integer.`);
+  }
+}
+function cloneValidDate(value, field) {
+  if (!(value instanceof Date) || !Number.isFinite(value.getTime())) {
+    throw new TypeError(`[Sixb] AI usage ${field} must be a valid Date.`);
+  }
+  return new Date(value);
+}
+
+// src/storage/ai-usage/in-memory.ts
+class InMemoryAiUsageStorage {
+  executions;
+  records = new Map;
+  recordKeysByIdempotencyKey = new Map;
+  groupRows = new Map;
+  constructor(executions) {
+    this.executions = executions;
+  }
+  async recordModelCall(input) {
+    const record = normalizeAiModelCallRecord(input);
+    await this.assertExecutionExists(record.projectId, record.executionId);
+    const idempotencyKey = modelCallIdempotencyKey(record);
+    const existingRecordKey = this.recordKeysByIdempotencyKey.get(idempotencyKey);
+    if (existingRecordKey !== undefined) {
+      const existing = this.records.get(existingRecordKey);
+      if (!existing) {
+        throw new Error("[Sixb] In-memory AI usage idempotency index is inconsistent.");
+      }
+      return { record: structuredClone(existing), created: false };
+    }
+    const recordKey = modelCallRecordKey(record.projectId, record.id);
+    if (this.records.has(recordKey)) {
+      throw new AiUsageStorageError("duplicate_id", `[Sixb] AI usage record '${record.id}' already exists for project '${record.projectId}'.`);
+    }
+    this.records.set(recordKey, structuredClone(record));
+    this.recordKeysByIdempotencyKey.set(idempotencyKey, recordKey);
+    for (const groupId of record.requesterGroupIds) {
+      const row = {
+        projectId: record.projectId,
+        usageRecordId: record.id,
+        groupId,
+        occurredAt: record.occurredAt
+      };
+      this.groupRows.set(groupRowKey(row), row);
+    }
+    return { record: structuredClone(record), created: true };
+  }
+  async summarizeExecution(input) {
+    const [summary] = await this.summarizeExecutions({
+      projectId: input.projectId,
+      executionIds: [input.executionId]
+    });
+    return summary;
+  }
+  async summarizeExecutions(input) {
+    if (typeof input.projectId !== "string" || input.projectId.trim().length === 0) {
+      throw new TypeError("[Sixb] AI usage projectId must be nonblank.");
+    }
+    const usageByExecutionId = new Map;
+    for (const executionId of input.executionIds) {
+      assertAiUsageExecutionId(executionId);
+      usageByExecutionId.set(executionId, []);
+    }
+    if (usageByExecutionId.size === 0)
+      return [];
+    for (const record of this.records.values()) {
+      if (record.projectId !== input.projectId)
+        continue;
+      usageByExecutionId.get(record.executionId)?.push(record.usage);
+    }
+    return input.executionIds.map((executionId) => {
+      const usages = usageByExecutionId.get(executionId) ?? [];
+      return {
+        modelCallCount: usages.length,
+        usage: aggregateAiModelCallUsage(usages)
+      };
+    });
+  }
+  snapshot() {
+    return structuredClone({
+      records: this.records,
+      recordKeysByIdempotencyKey: this.recordKeysByIdempotencyKey,
+      groupRows: this.groupRows
+    });
+  }
+  restore(snapshot) {
+    replaceMap(this.records, snapshot.records);
+    replaceMap(this.recordKeysByIdempotencyKey, snapshot.recordKeysByIdempotencyKey);
+    replaceMap(this.groupRows, snapshot.groupRows);
+  }
+  async assertExecutionExists(projectId, executionId) {
+    const execution = await this.executions.getById({ projectId, id: executionId });
+    if (execution)
+      return;
+    throw new AiUsageStorageError("missing_execution", `[Sixb] AI usage execution '${executionId}' does not exist in project '${projectId}'.`);
+  }
+}
+function modelCallRecordKey(projectId, id) {
+  return JSON.stringify([projectId, id]);
+}
+function modelCallIdempotencyKey(record) {
+  return JSON.stringify([
+    record.projectId,
+    record.executionId,
+    record.attempt,
+    record.callId,
+    record.responseId
+  ]);
+}
+function groupRowKey(row) {
+  return JSON.stringify([row.projectId, row.usageRecordId, row.groupId]);
+}
+function replaceMap(target, source) {
+  target.clear();
+  for (const [key2, value] of structuredClone(source)) {
+    target.set(key2, value);
+  }
+}
+// src/storage/connector-connections/in-memory.ts
+import { timingSafeEqual } from "crypto";
+function connectionRunBase(record, updatedAt) {
+  return {
+    id: record.id,
+    projectId: record.projectId,
+    connectorId: record.connectorId,
+    kind: record.kind,
+    owner: structuredClone(record.owner),
+    slot: record.slot,
+    initiatedByExecutionId: record.initiatedByExecutionId,
+    createdAt: new Date(record.createdAt),
+    updatedAt: new Date(updatedAt)
+  };
+}
+function expireConnectionRun(record, now) {
+  return {
+    ...connectionRunBase(record, now),
+    status: "expired",
+    ...record.waitingFor === "account_selection" ? { authorizationId: record.authorizationId } : {},
+    finishedAt: new Date(now)
+  };
+}
+function failExpiredProcessingRun(record, now) {
+  return {
+    ...connectionRunBase(record, now),
+    status: "failed",
+    ...record.authorizationId === undefined ? {} : { authorizationId: record.authorizationId },
+    error: toSixbFailure(createSixbError("internal.unexpected", "[Sixb] Connector callback processing did not complete before its deadline."), { allowedCodes: CONNECTOR_CONNECTION_RUN_FAILURE_CODES, at: now }),
+    finishedAt: new Date(now)
+  };
+}
+
+class InMemoryConnectorConnectionStorage {
+  options;
+  durability = "ephemeral";
+  attempts = new Map;
+  connectionRuns = new Map;
+  authorizations = new Map;
+  connections = new Map;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async createAuthorizationAttempt(input) {
+    assertPositiveDuration(input.ttlMs, "authorization attempt TTL");
+    if (this.attempts.has(input.id)) {
+      throw new ConnectorConnectionStorageError("attempt_conflict", "[Sixb] Connector authorization attempt already exists.");
+    }
+    if (input.connectionRunId !== undefined) {
+      const run = this.connectionRuns.get(input.connectionRunId);
+      const existingAttempt = this.findAuthorizationAttemptByConnectionRunId(input.connectionRunId);
+      if (!run || existingAttempt || run.projectId !== input.projectId || run.connectorId !== input.connectorId || run.status !== "waiting" || run.waitingFor !== "provider_authorization" || run.slot !== input.slot || run.initiatedByExecutionId !== input.initiatedByExecutionId) {
+        throw new ConnectorConnectionStorageError("attempt_conflict", "[Sixb] Connector authorization attempt does not match its connection run.");
+      }
+    }
+    const now = this.now();
+    const record = {
+      id: input.id,
+      projectId: input.projectId,
+      connectorId: input.connectorId,
+      owner: structuredClone(input.owner),
+      slot: input.slot,
+      initiatedByExecutionId: input.initiatedByExecutionId,
+      stateHash: input.stateHash,
+      codeVerifier: structuredClone(input.codeVerifier),
+      redirectUri: input.redirectUri,
+      ...input.connectionRunId === undefined ? {} : { connectionRunId: input.connectionRunId },
+      ...input.returnTo === undefined ? {} : { returnTo: input.returnTo },
+      ...input.callbackBindingHash === undefined ? {} : { callbackBindingHash: input.callbackBindingHash },
+      ...input.reauthorizationId === undefined ? {} : { reauthorizationId: input.reauthorizationId },
+      ...input.reauthorizationRevision === undefined ? {} : { reauthorizationRevision: input.reauthorizationRevision },
+      ...input.reauthorizationConnectionIds === undefined ? {} : { reauthorizationConnectionIds: [...input.reauthorizationConnectionIds] },
+      createdAt: now,
+      expiresAt: new Date(now.getTime() + input.ttlMs)
+    };
+    this.attempts.set(record.id, record);
+    return structuredClone(record);
+  }
+  async consumeAuthorizationAttempt(input) {
+    const record = this.attempts.get(input.id);
+    if (record && record.expiresAt.getTime() <= this.now().getTime()) {
+      this.attempts.delete(record.id);
+      throw invalidAttempt();
+    }
+    if (!record || record.projectId !== input.projectId || record.connectorId !== input.connectorId || record.redirectUri !== input.redirectUri || !safeEqual(record.stateHash, input.stateHash)) {
+      throw invalidAttempt();
+    }
+    this.attempts.delete(input.id);
+    return structuredClone(record);
+  }
+  async createConnectionRun(input) {
+    assertPositiveDuration(input.ttlMs, "connection run TTL");
+    if (this.connectionRuns.has(input.id)) {
+      throw new ConnectorConnectionStorageError("run_conflict", "[Sixb] Connector connection run already exists.");
+    }
+    const now = this.now();
+    const record = {
+      id: input.id,
+      projectId: input.projectId,
+      connectorId: input.connectorId,
+      kind: input.kind,
+      owner: structuredClone(input.owner),
+      slot: input.slot,
+      initiatedByExecutionId: input.initiatedByExecutionId,
+      status: "waiting",
+      waitingFor: "provider_authorization",
+      createdAt: now,
+      updatedAt: now,
+      expiresAt: new Date(now.getTime() + input.ttlMs)
+    };
+    this.connectionRuns.set(record.id, record);
+    return structuredClone(record);
+  }
+  async createConnectionSelectionRun(input) {
+    assertPositiveDuration(input.ttlMs, "connection run TTL");
+    if (this.connectionRuns.has(input.id)) {
+      throw new ConnectorConnectionStorageError("run_conflict", "[Sixb] Connector connection run already exists.");
+    }
+    const authorization = this.authorizations.get(input.authorizationId);
+    if (!sameAuthorizationScope(authorization, input) || authorization.status !== "active" || authorization.credentialMutation) {
+      throw authorizationConflict();
+    }
+    const now = this.now();
+    const record = {
+      id: input.id,
+      projectId: input.projectId,
+      connectorId: input.connectorId,
+      kind: "connect",
+      owner: structuredClone(input.owner),
+      slot: input.slot,
+      initiatedByExecutionId: input.initiatedByExecutionId,
+      status: "waiting",
+      waitingFor: "account_selection",
+      authorizationId: input.authorizationId,
+      createdAt: now,
+      updatedAt: now,
+      expiresAt: new Date(now.getTime() + input.ttlMs)
+    };
+    this.connectionRuns.set(record.id, record);
+    return structuredClone(record);
+  }
+  async claimConnectionRunCallback(input) {
+    assertPositiveDuration(input.processingTtlMs, "connection run processing TTL");
+    const attempt = this.attempts.get(input.attemptId);
+    if (!attempt || attempt.projectId !== input.projectId || attempt.connectionRunId === undefined || attempt.returnTo === undefined || attempt.callbackBindingHash === undefined || attempt.redirectUri !== input.redirectUri || !safeEqual(attempt.stateHash, input.stateHash) || !safeEqual(attempt.callbackBindingHash, input.callbackBindingHash)) {
+      return null;
+    }
+    const run = this.connectionRuns.get(attempt.connectionRunId);
+    if (!run || run.projectId !== input.projectId || run.connectorId !== attempt.connectorId || run.status !== "waiting" || run.waitingFor !== "provider_authorization" || run.slot !== attempt.slot || run.initiatedByExecutionId !== attempt.initiatedByExecutionId) {
+      return null;
+    }
+    const now = this.now();
+    this.attempts.delete(attempt.id);
+    if (attempt.expiresAt.getTime() <= now.getTime() || run.expiresAt.getTime() <= now.getTime()) {
+      const expired = expireConnectionRun(run, now);
+      this.connectionRuns.set(run.id, expired);
+      return { type: "expired", run: structuredClone(expired), returnTo: attempt.returnTo };
+    }
+    const processing = {
+      ...connectionRunBase(run, now),
+      status: "running",
+      processingId: input.processingId,
+      callbackStartedAt: now,
+      expiresAt: new Date(now.getTime() + input.processingTtlMs),
+      ...attempt.reauthorizationId === undefined ? {} : { authorizationId: attempt.reauthorizationId }
+    };
+    this.connectionRuns.set(run.id, processing);
+    return {
+      type: "claimed",
+      run: structuredClone(processing),
+      attempt: structuredClone(attempt),
+      returnTo: attempt.returnTo
+    };
+  }
+  async attachConnectionRunAuthorization(input) {
+    const run = this.currentConnectionRun(input.runId);
+    const authorization = this.authorizations.get(input.authorizationId);
+    if (!sameConnectionRunScope(run, input) || run.status !== "running" || run.processingId !== input.processingId || run.authorizationId !== undefined && run.authorizationId !== input.authorizationId || !sameAuthorizationScope(authorization, input) || authorization.status !== "pending_selection") {
+      return null;
+    }
+    const updated = {
+      ...run,
+      authorizationId: input.authorizationId,
+      updatedAt: this.now()
+    };
+    this.connectionRuns.set(run.id, updated);
+    return structuredClone(updated);
+  }
+  async waitForConnectionRunSelection(input) {
+    const run = this.currentConnectionRun(input.runId);
+    if (!sameConnectionRunScope(run, input) || run.status !== "running" || run.kind !== "connect" || run.processingId !== input.processingId || run.authorizationId !== input.authorizationId) {
+      return null;
+    }
+    const now = this.now();
+    const waiting = {
+      ...connectionRunBase(run, now),
+      status: "waiting",
+      waitingFor: "account_selection",
+      authorizationId: input.authorizationId,
+      expiresAt: new Date(input.expiresAt)
+    };
+    this.connectionRuns.set(run.id, waiting);
+    return structuredClone(waiting);
+  }
+  async finishConnectionRun(input) {
+    const run = this.currentConnectionRun(input.runId);
+    if (!sameConnectionRunScope(run, input) || run.status !== "running")
+      return null;
+    if (input.processingId !== run.processingId)
+      return null;
+    const now = this.now();
+    const authorizationId = input.status === "succeeded" ? input.authorizationId : input.status === "failed" ? input.authorizationId ?? run.authorizationId : run.authorizationId;
+    if (input.status !== "succeeded" && run.kind === "connect" && authorizationId) {
+      this.markPendingAuthorizationForCleanup(run.connectorId, authorizationId, now);
+    }
+    const base = connectionRunBase(run, now);
+    const finished = input.status === "succeeded" ? {
+      ...base,
+      status: "succeeded",
+      authorizationId: input.authorizationId,
+      ...input.cleanupAuthorizationId === undefined ? {} : { cleanupAuthorizationId: input.cleanupAuthorizationId },
+      connections: structuredClone(input.connections),
+      finishedAt: now
+    } : input.status === "failed" ? {
+      ...base,
+      status: "failed",
+      ...authorizationId === undefined ? {} : { authorizationId },
+      error: parseSixbFailure(input.error, CONNECTOR_CONNECTION_RUN_FAILURE_CODES),
+      finishedAt: now
+    } : {
+      ...base,
+      status: "cancelled",
+      ...authorizationId === undefined ? {} : { authorizationId },
+      finishedAt: now
+    };
+    this.connectionRuns.set(run.id, finished);
+    return structuredClone(finished);
+  }
+  async getConnectionRun(input) {
+    const run = this.currentConnectionRun(input.runId);
+    return sameConnectionRunScope(run, input) ? structuredClone(run) : null;
+  }
+  async createAuthorization(input) {
+    assertPositiveDuration(input.selectionTtlMs, "account selection TTL");
+    if (this.authorizations.has(input.id)) {
+      throw new ConnectorConnectionStorageError("authorization_conflict", "[Sixb] Connector authorization already exists.");
+    }
+    const now = this.now();
+    const record = {
+      id: input.id,
+      projectId: input.projectId,
+      connectorId: input.connectorId,
+      authorizedBy: structuredClone(input.authorizedBy),
+      credentials: structuredClone(input.credentials),
+      ...input.credentialExpiresAt === undefined ? {} : { credentialExpiresAt: new Date(input.credentialExpiresAt) },
+      scopes: [...input.scopes],
+      accounts: structuredClone(input.accounts),
+      status: "pending_selection",
+      selectionExpiresAt: new Date(now.getTime() + input.selectionTtlMs),
+      revision: 0,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.authorizations.set(record.id, record);
+    return structuredClone(record);
+  }
+  async initializeAuthorizationAccounts(input) {
+    const record = this.authorizations.get(input.authorizationId);
+    if (!sameAuthorizationScope(record, input) || record.revision !== input.expectedRevision || record.status !== "pending_selection" || record.credentialMutation) {
+      return null;
+    }
+    const updated = {
+      ...record,
+      accounts: structuredClone(input.accounts),
+      revision: record.revision + 1,
+      updatedAt: this.now()
+    };
+    this.authorizations.set(record.id, updated);
+    return structuredClone(updated);
+  }
+  async getAuthorization(input) {
+    const authorization = this.authorizations.get(input.authorizationId);
+    return sameAuthorizationScope(authorization, input) ? structuredClone(authorization) : null;
+  }
+  async getAuthorizationByConnectionId(input) {
+    const connection = this.connections.get(input.connectionId);
+    if (!sameConnectionScope(connection, input))
+      return null;
+    const authorization = this.authorizations.get(connection.authorizationId);
+    return sameAuthorizationScope(authorization, input) ? structuredClone(authorization) : null;
+  }
+  async claimCredentialMutation(input) {
+    assertPositiveDuration(input.leaseDurationMs, "credential mutation lease duration");
+    assertPositiveDuration(input.operationTimeoutMs, "credential mutation timeout");
+    const now = this.now();
+    const record = this.authorizations.get(input.authorizationId);
+    if (!sameAuthorizationScope(record, input) || record.revision !== input.expectedRevision || !canClaimMutation(record.status, input.mutation.kind)) {
+      return null;
+    }
+    if (record.credentialMutation) {
+      const canReplacePrepared = record.credentialMutation.phase === "prepared" && record.credentialMutation.expiresAt.getTime() <= now.getTime();
+      if (!canReplacePrepared)
+        return null;
+    }
+    const attached = this.connectedConnectionsForAuthorization(record.id);
+    if (input.mutation.kind === "reauthorization" && !sameIds(attached.map((connection) => connection.id), input.expectedConnectionIds ?? [])) {
+      return null;
+    }
+    const deadlineAt = new Date(now.getTime() + input.operationTimeoutMs);
+    const mutation = {
+      ...structuredClone(input.mutation),
+      phase: "prepared",
+      expiresAt: leaseExpiry(now, input.leaseDurationMs, deadlineAt),
+      deadlineAt,
+      ...input.mutation.kind === "reauthorization" ? { expectedConnectionIds: [...input.expectedConnectionIds ?? []] } : {}
+    };
+    const startsRevocation = input.mutation.kind === "revocation" && record.status !== "revocation_pending";
+    const updated = {
+      ...record,
+      status: input.mutation.kind === "revocation" ? "revocation_pending" : record.status,
+      selectionExpiresAt: input.mutation.kind === "revocation" ? undefined : record.selectionExpiresAt,
+      revision: startsRevocation ? record.revision + 1 : record.revision,
+      credentialMutation: mutation,
+      updatedAt: now
+    };
+    this.authorizations.set(record.id, updated);
+    const disconnected = [];
+    if (input.mutation.kind === "revocation") {
+      for (const connection of attached) {
+        const updatedConnection = disconnectConnectionRecord(connection, now);
+        this.connections.set(connection.id, updatedConnection);
+        disconnected.push(structuredClone(updatedConnection));
+      }
+    }
+    return { authorization: structuredClone(updated), disconnected };
+  }
+  async markCredentialMutationExecuting(input) {
+    const now = this.now();
+    const record = this.authorizations.get(input.authorizationId);
+    if (!matchesMutation(record, input, input.holderId) || record.credentialMutation.phase !== "prepared" || mutationExpired(record, now)) {
+      return null;
+    }
+    const updated = {
+      ...record,
+      credentialMutation: { ...record.credentialMutation, phase: "executing" },
+      updatedAt: now
+    };
+    this.authorizations.set(record.id, updated);
+    return structuredClone(updated);
+  }
+  async renewCredentialMutation(input) {
+    assertPositiveDuration(input.leaseDurationMs, "credential mutation lease duration");
+    const now = this.now();
+    const record = this.authorizations.get(input.authorizationId);
+    if (!matchesMutation(record, input, input.holderId) || record.credentialMutation.phase === "result_staged" || mutationExpired(record, now)) {
+      return null;
+    }
+    const updated = {
+      ...record,
+      credentialMutation: {
+        ...record.credentialMutation,
+        expiresAt: leaseExpiry(now, input.leaseDurationMs, record.credentialMutation.deadlineAt)
+      }
+    };
+    this.authorizations.set(record.id, updated);
+    return structuredClone(updated);
+  }
+  async stageCredentialMutationCredentials(input) {
+    const now = this.now();
+    const record = this.authorizations.get(input.authorizationId);
+    if (!matchesMutation(record, input, input.holderId) || record.credentialMutation.phase !== "executing" || mutationExpired(record, now) || record.credentialMutation.kind === "revocation") {
+      return null;
+    }
+    const updated = {
+      ...record,
+      credentialMutation: {
+        ...record.credentialMutation,
+        phase: "result_staged",
+        stagedCredentials: {
+          credentials: structuredClone(input.credentials),
+          ...input.credentialExpiresAt === undefined ? {} : { credentialExpiresAt: new Date(input.credentialExpiresAt) },
+          scopes: [...input.scopes]
+        }
+      },
+      updatedAt: now
+    };
+    this.authorizations.set(record.id, updated);
+    return structuredClone(updated);
+  }
+  async stageCredentialMutationRevocation(input) {
+    const now = this.now();
+    const record = this.authorizations.get(input.authorizationId);
+    if (!matchesMutation(record, input, input.holderId) || record.credentialMutation.phase !== "executing" || record.credentialMutation.kind !== "revocation" || mutationExpired(record, now)) {
+      return null;
+    }
+    const updated = {
+      ...record,
+      credentialMutation: { ...record.credentialMutation, phase: "result_staged" },
+      updatedAt: now
+    };
+    this.authorizations.set(record.id, updated);
+    return structuredClone(updated);
+  }
+  async releaseCredentialMutation(input) {
+    const record = this.authorizations.get(input.authorizationId);
+    if (!matchesMutation(record, input, input.holderId) || record.credentialMutation.phase === "result_staged") {
+      return false;
+    }
+    this.authorizations.set(record.id, {
+      ...record,
+      credentialMutation: undefined,
+      updatedAt: this.now()
+    });
+    return true;
+  }
+  async recoverExpiredCredentialMutation(input) {
+    const record = this.authorizations.get(input.authorizationId);
+    if (!sameAuthorizationScope(record, input) || !record.credentialMutation)
+      return null;
+    if (record.credentialMutation.phase === "result_staged")
+      return structuredClone(record);
+    const now = this.now();
+    if (!mutationExpired(record, now))
+      return null;
+    const ambiguous = record.credentialMutation.phase === "executing";
+    const failClosed = ambiguous && record.credentialMutation.kind !== "revocation";
+    const updated = {
+      ...record,
+      status: failClosed ? "needs_reauthorization" : record.status,
+      selectionExpiresAt: failClosed ? undefined : record.selectionExpiresAt,
+      revision: failClosed ? record.revision + 1 : record.revision,
+      credentialMutation: undefined,
+      updatedAt: now
+    };
+    this.authorizations.set(record.id, updated);
+    return structuredClone(updated);
+  }
+  async markNeedsReauthorization(input) {
+    const record = this.authorizations.get(input.authorizationId);
+    if (!matchesMutation(record, input))
+      return null;
+    const staged = record.credentialMutation.stagedCredentials;
+    const updated = {
+      ...record,
+      ...staged ? {
+        credentials: structuredClone(staged.credentials),
+        credentialExpiresAt: staged.credentialExpiresAt === undefined ? undefined : new Date(staged.credentialExpiresAt),
+        scopes: [...staged.scopes]
+      } : {},
+      status: "needs_reauthorization",
+      selectionExpiresAt: undefined,
+      revision: record.revision + 1,
+      credentialMutation: undefined,
+      updatedAt: this.now()
+    };
+    this.authorizations.set(record.id, updated);
+    return structuredClone(updated);
+  }
+  async finalizeRefresh(input) {
+    const record = this.authorizations.get(input.authorizationId);
+    const staged = stagedCredentials(record, input, "refresh");
+    if (!record || !staged)
+      return null;
+    const updated = applyStagedCredentials(record, staged, this.now(), {
+      status: "active",
+      accounts: record.accounts
+    });
+    this.authorizations.set(record.id, updated);
+    return structuredClone(updated);
+  }
+  async finalizeReauthorization(input) {
+    const record = this.authorizations.get(input.authorizationId);
+    const staged = stagedCredentials(record, input, "reauthorization");
+    if (!record || !staged || !record.credentialMutation)
+      return null;
+    const attached = this.connectedConnectionsForAuthorization(record.id);
+    if (!sameIds(attached.map((connection) => connection.id), record.credentialMutation.expectedConnectionIds ?? [])) {
+      throw new ConnectorConnectionStorageError("authorization_conflict", "[Sixb] Connections attached to the connector authorization changed during reauthorization.");
+    }
+    const accountsById = new Map(input.accounts.map((account) => [account.id, account]));
+    if (attached.some((connection) => !accountsById.has(connection.account.id))) {
+      throw new ConnectorConnectionStorageError("authorization_conflict", "[Sixb] Reauthorized connector grant no longer exposes every attached account.");
+    }
+    const now = this.now();
+    const updated = applyStagedCredentials(record, staged, now, {
+      status: "active",
+      accounts: input.accounts
+    });
+    this.authorizations.set(record.id, updated);
+    for (const connection of attached) {
+      this.connections.set(connection.id, {
+        ...connection,
+        account: structuredClone(accountsById.get(connection.account.id)),
+        updatedAt: now
+      });
+    }
+    return structuredClone(updated);
+  }
+  async finalizeRevocation(input) {
+    const record = this.authorizations.get(input.authorizationId);
+    if (!matchesMutation(record, input) || record.credentialMutation.kind !== "revocation" || record.credentialMutation.phase !== "result_staged") {
+      return null;
+    }
+    const updated = {
+      ...record,
+      status: "revoked",
+      credentials: undefined,
+      credentialExpiresAt: undefined,
+      scopes: [],
+      accounts: [],
+      selectionExpiresAt: undefined,
+      revision: record.revision + 1,
+      credentialMutation: undefined,
+      updatedAt: this.now()
+    };
+    this.authorizations.set(record.id, updated);
+    return structuredClone(updated);
+  }
+  async putConnection(input) {
+    return this.putConnectionNow(input, this.now());
+  }
+  async putConnectionFromRun(input) {
+    const run = this.currentConnectionRun(input.runId);
+    if (!sameConnectionRunScope(run, input) || run.status !== "waiting" || run.waitingFor !== "account_selection") {
+      throw invalidRun();
+    }
+    const now = this.now();
+    const result = this.putConnectionNow({
+      id: input.id,
+      projectId: input.projectId,
+      connectorId: input.connectorId,
+      owner: run.owner,
+      slot: run.slot,
+      authorizationId: run.authorizationId,
+      account: input.account,
+      replace: input.replace
+    }, now);
+    const succeeded = {
+      ...connectionRunBase(run, now),
+      status: "succeeded",
+      authorizationId: run.authorizationId,
+      ...result.revocationPendingAuthorizationId === undefined ? {} : { cleanupAuthorizationId: result.revocationPendingAuthorizationId },
+      connections: [structuredClone(result.connection)],
+      finishedAt: now
+    };
+    this.connectionRuns.set(run.id, succeeded);
+    return { ...result, run: structuredClone(succeeded) };
+  }
+  putConnectionNow(input, now) {
+    let authorization = this.authorizations.get(input.authorizationId);
+    if (!sameAuthorizationScope(authorization, input) || !isSelectable(authorization.status) || authorization.credentialMutation?.kind === "reauthorization") {
+      throw authorizationConflict();
+    }
+    if (authorization.status === "pending_selection" && authorization.selectionExpiresAt.getTime() <= now.getTime()) {
+      authorization = {
+        ...authorization,
+        status: "revocation_pending",
+        selectionExpiresAt: undefined,
+        revision: authorization.revision + 1,
+        updatedAt: now
+      };
+      this.authorizations.set(authorization.id, authorization);
+      throw authorizationConflict();
+    }
+    const account = authorization.accounts.find((candidate) => candidate.id === input.account.id);
+    if (!account) {
+      throw new ConnectorConnectionStorageError("authorization_conflict", "[Sixb] Connector connection account is not exposed by its authorization.");
+    }
+    const existing = this.findConnectionRecord(input);
+    const sameAccount = existing?.account.id === account.id;
+    if (existing && !sameAccount && !input.replace) {
+      throw new ConnectorConnectionStorageError("connection_conflict", `[Sixb] Connector slot '${input.slot}' is already connected to another account; explicit replacement is required.`);
+    }
+    if (!existing && this.connections.has(input.id)) {
+      throw new ConnectorConnectionStorageError("connection_conflict", "[Sixb] Connector connection id already exists.");
+    }
+    let revocationPendingAuthorizationId;
+    if (existing?.status === "connected" && existing.authorizationId !== authorization.id) {
+      const previous = this.authorizations.get(existing.authorizationId);
+      if (!previous) {
+        throw new ConnectorConnectionStorageError("authorization_conflict", "[Sixb] Existing connector connection references an unavailable authorization.");
+      }
+      const remaining = this.connectedConnectionsForAuthorization(previous.id).filter((connection2) => connection2.id !== existing.id);
+      this.assertConnectionCanMove(existing, previous, remaining.length === 0);
+      if (remaining.length === 0) {
+        const pending = markAuthorizationRevocationPending(previous, now);
+        this.authorizations.set(previous.id, pending);
+        revocationPendingAuthorizationId = previous.id;
+      }
+    } else if (existing?.status === "connected") {
+      const previous = this.authorizations.get(existing.authorizationId);
+      if (previous)
+        this.assertConnectionCanMove(existing, previous, false);
+    }
+    const updatedAuthorization = authorization.status === "pending_selection" ? {
+      ...authorization,
+      status: "active",
+      selectionExpiresAt: undefined,
+      revision: authorization.revision + 1,
+      updatedAt: now
+    } : authorization;
+    const connection = existing ? {
+      ...existing,
+      authorizationId: input.authorizationId,
+      account: structuredClone(account),
+      status: "connected",
+      disconnectedAt: undefined,
+      updatedAt: now
+    } : {
+      id: input.id,
+      projectId: input.projectId,
+      connectorId: input.connectorId,
+      owner: structuredClone(input.owner),
+      slot: input.slot,
+      authorizationId: input.authorizationId,
+      account: structuredClone(account),
+      status: "connected",
+      createdAt: now,
+      updatedAt: now
+    };
+    if (updatedAuthorization !== authorization) {
+      this.authorizations.set(updatedAuthorization.id, updatedAuthorization);
+    }
+    this.connections.set(connection.id, connection);
+    return {
+      connection: structuredClone(connection),
+      authorization: structuredClone(updatedAuthorization),
+      ...revocationPendingAuthorizationId === undefined ? {} : { revocationPendingAuthorizationId },
+      created: existing === undefined,
+      replaced: existing !== undefined && !sameAccount
+    };
+  }
+  async getConnection(input) {
+    const connection = this.findConnectionRecord(input);
+    return connection?.status === "connected" ? structuredClone(connection) : null;
+  }
+  async getConnectionById(input) {
+    const connection = this.connections.get(input.connectionId);
+    return sameConnectionScope(connection, input) ? structuredClone(connection) : null;
+  }
+  async listConnections(input) {
+    return [...this.connections.values()].filter((connection) => sameConnectionScope(connection, input)).map((connection) => structuredClone(connection));
+  }
+  async listConnectionsByAuthorization(input) {
+    const authorization = this.authorizations.get(input.authorizationId);
+    if (!sameAuthorizationScope(authorization, input))
+      return [];
+    return this.connectedConnectionsForAuthorization(input.authorizationId).filter((connection) => sameConnectionScope(connection, input)).map((connection) => structuredClone(connection));
+  }
+  async disconnectConnection(input) {
+    const connection = this.connections.get(input.connectionId);
+    if (!connection || connection.projectId !== input.projectId || connection.connectorId !== input.connectorId) {
+      return null;
+    }
+    const authorization = this.authorizations.get(connection.authorizationId);
+    if (!sameAuthorizationScope(authorization, input)) {
+      throw new ConnectorConnectionStorageError("authorization_conflict", "[Sixb] Connector connection references an unavailable authorization.");
+    }
+    if (connection.status === "disconnected") {
+      return {
+        connection: structuredClone(connection),
+        authorization: structuredClone(authorization),
+        ...authorization.status === "revocation_pending" ? { revocationPendingAuthorizationId: authorization.id } : {}
+      };
+    }
+    const now = this.now();
+    const remaining = this.connectedConnectionsForAuthorization(authorization.id).filter((candidate) => candidate.id !== connection.id);
+    this.assertConnectionCanMove(connection, authorization, remaining.length === 0);
+    const disconnected = disconnectConnectionRecord(connection, now);
+    this.connections.set(connection.id, disconnected);
+    const updatedAuthorization = remaining.length === 0 ? markAuthorizationRevocationPending(authorization, now) : authorization;
+    if (updatedAuthorization !== authorization) {
+      this.authorizations.set(authorization.id, updatedAuthorization);
+    }
+    return {
+      connection: structuredClone(disconnected),
+      authorization: structuredClone(updatedAuthorization),
+      ...updatedAuthorization.status === "revocation_pending" && remaining.length === 0 ? { revocationPendingAuthorizationId: updatedAuthorization.id } : {}
+    };
+  }
+  snapshot() {
+    return {
+      attempts: structuredClone(this.attempts),
+      connectionRuns: structuredClone(this.connectionRuns),
+      authorizations: structuredClone(this.authorizations),
+      connections: structuredClone(this.connections)
+    };
+  }
+  restore(snapshot) {
+    replaceMap2(this.attempts, snapshot.attempts);
+    replaceMap2(this.connectionRuns, snapshot.connectionRuns);
+    replaceMap2(this.authorizations, snapshot.authorizations);
+    replaceMap2(this.connections, snapshot.connections);
+  }
+  now() {
+    return new Date(this.options.now?.() ?? new Date);
+  }
+  currentConnectionRun(runId) {
+    const run = this.connectionRuns.get(runId);
+    if (!run || run.status !== "waiting" && run.status !== "running")
+      return run;
+    const now = this.now();
+    if (run.expiresAt.getTime() > now.getTime())
+      return run;
+    if (run.status === "waiting" && run.waitingFor === "provider_authorization") {
+      const attempt = this.findAuthorizationAttemptByConnectionRunId(run.id);
+      if (attempt)
+        this.attempts.delete(attempt.id);
+    }
+    if (run.status === "waiting") {
+      if (run.kind === "connect" && run.waitingFor === "account_selection") {
+        this.markPendingAuthorizationForCleanup(run.connectorId, run.authorizationId, now);
+      }
+      const expired = expireConnectionRun(run, now);
+      this.connectionRuns.set(run.id, expired);
+      return expired;
+    }
+    if (run.kind === "connect" && run.authorizationId) {
+      this.markPendingAuthorizationForCleanup(run.connectorId, run.authorizationId, now);
+    }
+    const failed = failExpiredProcessingRun(run, now);
+    this.connectionRuns.set(run.id, failed);
+    return failed;
+  }
+  findConnectionRecord(input) {
+    for (const connection of this.connections.values()) {
+      if (connection.projectId === input.projectId && connection.connectorId === input.connectorId && connection.owner.type === input.owner.type && connection.slot === input.slot) {
+        return connection;
+      }
+    }
+    return;
+  }
+  findAuthorizationAttemptByConnectionRunId(connectionRunId) {
+    for (const attempt of this.attempts.values()) {
+      if (attempt.connectionRunId === connectionRunId)
+        return attempt;
+    }
+    return;
+  }
+  connectionRecordsForAuthorization(authorizationId) {
+    return [...this.connections.values()].filter((connection) => connection.authorizationId === authorizationId);
+  }
+  connectedConnectionsForAuthorization(authorizationId) {
+    return this.connectionRecordsForAuthorization(authorizationId).filter((connection) => connection.status === "connected");
+  }
+  assertConnectionCanMove(_connection, authorization, removingLastConnection = true) {
+    const mutation = authorization.credentialMutation;
+    if (mutation?.kind === "reauthorization") {
+      throw new ConnectorConnectionStorageError("authorization_conflict", "[Sixb] Connections cannot change while their connector authorization is being reauthorized.");
+    }
+    if (removingLastConnection && mutation) {
+      throw new ConnectorConnectionStorageError("authorization_conflict", "[Sixb] The last connector connection cannot be removed while credentials are being mutated.");
+    }
+  }
+  markPendingAuthorizationForCleanup(connectorId, authorizationId, now) {
+    const authorization = this.authorizations.get(authorizationId);
+    if (!authorization || authorization.connectorId !== connectorId || authorization.status !== "pending_selection") {
+      return;
+    }
+    this.authorizations.set(authorization.id, markAuthorizationRevocationPending(authorization, now));
+  }
+}
+function disconnectConnectionRecord(connection, now) {
+  return {
+    ...connection,
+    status: "disconnected",
+    disconnectedAt: new Date(now),
+    updatedAt: new Date(now)
+  };
+}
+function markAuthorizationRevocationPending(authorization, now) {
+  if (authorization.status === "revocation_pending" || authorization.status === "revoked") {
+    return authorization;
+  }
+  if (authorization.credentialMutation) {
+    throw new ConnectorConnectionStorageError("authorization_conflict", "[Sixb] Connector authorization cannot begin revocation while credentials are being mutated.");
+  }
+  return {
+    ...authorization,
+    status: "revocation_pending",
+    selectionExpiresAt: undefined,
+    revision: authorization.revision + 1,
+    updatedAt: new Date(now)
+  };
+}
+function safeEqual(left, right) {
+  const leftBytes = Buffer.from(left);
+  const rightBytes = Buffer.from(right);
+  return leftBytes.length === rightBytes.length && timingSafeEqual(leftBytes, rightBytes);
+}
+function invalidRun() {
+  return new ConnectorConnectionStorageError("run_invalid", "[Sixb] Connector connection run is invalid, expired, or already used.");
+}
+function replaceMap2(target, source) {
+  target.clear();
+  for (const [key2, value] of structuredClone(source))
+    target.set(key2, value);
+}
+function sameIds(left, right) {
+  const leftSorted = [...left].sort();
+  const rightSorted = [...right].sort();
+  return leftSorted.length === rightSorted.length && leftSorted.every((value, index) => value === rightSorted[index]);
+}
+function invalidAttempt() {
+  return new ConnectorConnectionStorageError("attempt_invalid", "[Sixb] Connector authorization attempt is invalid, expired, or already used.");
+}
+function authorizationConflict() {
+  return new ConnectorConnectionStorageError("authorization_conflict", "[Sixb] Connector connection requires a selectable authorization from the same project and connector.");
+}
+function assertPositiveDuration(value, name) {
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new ConnectorConnectionStorageError("invalid_input", `[Sixb] Connector ${name} must be positive.`);
+  }
+}
+function sameAuthorizationScope(record, input) {
+  return record !== undefined && record.projectId === input.projectId && record.connectorId === input.connectorId;
+}
+function sameConnectionScope(record, input) {
+  return record !== undefined && record.projectId === input.projectId && record.connectorId === input.connectorId;
+}
+function sameConnectionRunScope(record, input) {
+  return record !== undefined && record.projectId === input.projectId && record.connectorId === input.connectorId;
+}
+function canClaimMutation(status, kind) {
+  if (kind === "refresh")
+    return status === "active";
+  if (kind === "reauthorization") {
+    return status === "active" || status === "needs_reauthorization";
+  }
+  return status !== "revoked";
+}
+function isSelectable(status) {
+  return status === "pending_selection" || status === "active";
+}
+function leaseExpiry(now, durationMs, deadlineAt) {
+  return new Date(Math.min(now.getTime() + durationMs, deadlineAt.getTime()));
+}
+function mutationExpired(record, now) {
+  return record.credentialMutation.expiresAt.getTime() <= now.getTime() || record.credentialMutation.deadlineAt.getTime() <= now.getTime();
+}
+function matchesMutation(record, input, holderId) {
+  return sameAuthorizationScope(record, input) && record.revision === input.expectedRevision && record.credentialMutation?.id === input.mutationId && (holderId === undefined || record.credentialMutation.holderId === holderId);
+}
+function stagedCredentials(record, input, kind) {
+  if (!matchesMutation(record, input) || record.credentialMutation.kind !== kind || record.credentialMutation.phase !== "result_staged") {
+    return null;
+  }
+  return record.credentialMutation.stagedCredentials ?? null;
+}
+function applyStagedCredentials(record, staged, now, input) {
+  return {
+    ...record,
+    credentials: structuredClone(staged.credentials),
+    credentialExpiresAt: staged.credentialExpiresAt === undefined ? undefined : new Date(staged.credentialExpiresAt),
+    scopes: [...staged.scopes],
+    accounts: structuredClone(input.accounts),
+    status: input.status,
+    selectionExpiresAt: undefined,
+    revision: record.revision + 1,
+    credentialMutation: undefined,
+    updatedAt: now
+  };
+}
 // src/storage/errors.ts
 class ObjectNotFoundError extends Error {
   objectTypeId;
@@ -589,6 +2078,55 @@ class InMemoryFileUploadSessions {
 // src/storage/in-memory/index.ts
 import { AsyncLocalStorage } from "async_hooks";
 
+// src/storage/executions/in-memory.ts
+var runDirectly2 = async (run) => run();
+function executionKey(projectId, id) {
+  return JSON.stringify([projectId, id]);
+}
+
+class InMemoryExecutionStorage {
+  auth;
+  rows = new Map;
+  runRootOperation;
+  constructor(auth, input = {}) {
+    this.auth = auth;
+    this.runRootOperation = input.runRootOperation ?? runDirectly2;
+  }
+  snapshot() {
+    return structuredClone(this.rows);
+  }
+  restore(snapshot) {
+    this.rows.clear();
+    for (const [key2, record] of structuredClone(snapshot)) {
+      this.rows.set(key2, record);
+    }
+  }
+  async create(input) {
+    return this.runRootOperation(async () => {
+      const record = normalizeExecutionRecord(input);
+      const key2 = executionKey(record.projectId, record.id);
+      if (this.rows.has(key2)) {
+        throw new ExecutionStorageError("duplicate_execution", `[Sixb] Execution '${record.id}' already exists in project '${record.projectId}'.`);
+      }
+      await validateExecutionRecordReferences(record, {
+        auth: this.auth,
+        getExecution: async ({ projectId, id }) => {
+          const existing = this.rows.get(executionKey(projectId, id));
+          return existing ? cloneExecutionRecord(existing) : null;
+        }
+      });
+      this.rows.set(key2, cloneExecutionRecord(record));
+      return cloneExecutionRecord(record);
+    });
+  }
+  async getById(params) {
+    return this.runRootOperation(() => {
+      const record = this.rows.get(executionKey(params.projectId, params.id));
+      return record ? cloneExecutionRecord(record) : null;
+    });
+  }
+}
+
 // src/storage/objects/in-memory.ts
 var IN_MEMORY_OBJECT_QUERY_CAPABILITIES = {
   queryObjects: true,
@@ -715,12 +2253,12 @@ class InMemoryObjectStorage {
   }
   restore(snapshot) {
     this.rows.clear();
-    for (const [key, bucket] of cloneObjectBuckets(snapshot.rows)) {
-      this.rows.set(key, bucket);
+    for (const [key2, bucket] of cloneObjectBuckets(snapshot.rows)) {
+      this.rows.set(key2, bucket);
     }
     this.links.clear();
-    for (const [key, bucket] of cloneLinkBuckets(snapshot.links)) {
-      this.links.set(key, bucket);
+    for (const [key2, bucket] of cloneLinkBuckets(snapshot.links)) {
+      this.links.set(key2, bucket);
     }
   }
   getExactObjectRow(projectId, objectTypeId, primaryId) {
@@ -907,8 +2445,8 @@ class InMemoryObjectStorage {
     if (op === "intersect") {
       const otherKeySets = evaluations.slice(1).map((evaluation) => new Set(evaluation.entries.map((entry) => rowIdentityKey(entry.row))));
       const entries = first.entries.filter((entry) => {
-        const key = rowIdentityKey(entry.row);
-        return otherKeySets.every((keys) => keys.has(key));
+        const key2 = rowIdentityKey(entry.row);
+        return otherKeySets.every((keys) => keys.has(key2));
       });
       return completeEvaluation(entries);
     }
@@ -1055,8 +2593,8 @@ class InMemoryObjectStorage {
         }
       }
     } else {
-      for (const [key, bucket] of this.rows) {
-        if (key.startsWith(`${params.projectId}:`)) {
+      for (const [key2, bucket] of this.rows) {
+        if (key2.startsWith(`${params.projectId}:`)) {
           allRows.push(...bucket.values());
         }
       }
@@ -1113,18 +2651,18 @@ function assertReconciliationPageLimit(limit) {
   }
 }
 function cloneObjectBuckets(rows) {
-  const clone = new Map;
-  for (const [key, bucket] of rows) {
-    clone.set(key, new Map([...bucket.entries()].map(([primaryId, row]) => [primaryId, structuredClone(row)])));
+  const clone2 = new Map;
+  for (const [key2, bucket] of rows) {
+    clone2.set(key2, new Map([...bucket.entries()].map(([primaryId, row]) => [primaryId, structuredClone(row)])));
   }
-  return clone;
+  return clone2;
 }
 function cloneLinkBuckets(links) {
-  const clone = new Map;
-  for (const [key, bucket] of links) {
-    clone.set(key, new Map([...bucket.entries()].map(([linkId, row]) => [linkId, structuredClone(row)])));
+  const clone2 = new Map;
+  for (const [key2, bucket] of links) {
+    clone2.set(key2, new Map([...bucket.entries()].map(([linkId, row]) => [linkId, structuredClone(row)])));
   }
-  return clone;
+  return clone2;
 }
 function completeEvaluation(entries) {
   return {
@@ -1302,12 +2840,12 @@ function buildFacetBuckets(rows, facet) {
     const value = row.properties[facet.propertyId];
     if (value === undefined)
       continue;
-    const key = facetValueKey(value);
-    const existing = buckets.get(key);
+    const key2 = facetValueKey(value);
+    const existing = buckets.get(key2);
     if (existing) {
       existing.count += 1;
     } else {
-      buckets.set(key, { value, count: 1 });
+      buckets.set(key2, { value, count: 1 });
     }
   }
   return [...buckets.values()].sort((left, right) => right.count - left.count || facetValueSortKey(left.value).localeCompare(facetValueSortKey(right.value))).slice(0, facet.limit);
@@ -1325,14 +2863,14 @@ function rowIdentityKeyParts(objectTypeId, primaryId) {
   return `${objectTypeId}:${primaryId}`;
 }
 function upsertEntry(entriesByKey, entry) {
-  const key = rowIdentityKey(entry.row);
-  const existing = entriesByKey.get(key);
+  const key2 = rowIdentityKey(entry.row);
+  const existing = entriesByKey.get(key2);
   if (!existing) {
-    entriesByKey.set(key, entry);
+    entriesByKey.set(key2, entry);
     return;
   }
   if (entry.score > existing.score) {
-    entriesByKey.set(key, {
+    entriesByKey.set(key2, {
       ...existing,
       score: entry.score
     });
@@ -1366,6 +2904,7 @@ function createInMemoryOntologyState() {
     sourceMaterializations: new Map,
     objectOverrides: new Map,
     linkOverrides: new Map,
+    linkSlotOverrides: new Map,
     outbox: new Map
   };
 }
@@ -1387,8 +2926,8 @@ function sourceMaterializationRecord(materialization) {
 function commitKey(projectId, commitId) {
   return JSON.stringify([projectId, commitId]);
 }
-function idempotencyKey(projectId, key) {
-  return JSON.stringify([projectId, key]);
+function idempotencyKey(projectId, key2) {
+  return JSON.stringify([projectId, key2]);
 }
 function ontologyCommitOriginSelector(origin) {
   if (origin.kind === "action")
@@ -1422,9 +2961,9 @@ function cloneOntologyState(state) {
   return structuredClone(state);
 }
 function restoreOntologyState(target, snapshot) {
-  for (const key of Object.keys(target)) {
-    const targetMap = target[key];
-    const sourceMap = structuredClone(snapshot[key]);
+  for (const key2 of Object.keys(target)) {
+    const targetMap = target[key2];
+    const sourceMap = structuredClone(snapshot[key2]);
     targetMap.clear();
     for (const [entryKey, value] of sourceMap)
       targetMap.set(entryKey, value);
@@ -1555,8 +3094,8 @@ class InMemoryTimeseriesStorage {
   }
   restore(snapshot) {
     this.pointsByKey.clear();
-    for (const [key, points] of structuredClone(snapshot.pointsByKey)) {
-      this.pointsByKey.set(key, points);
+    for (const [key2, points] of structuredClone(snapshot.pointsByKey)) {
+      this.pointsByKey.set(key2, points);
     }
   }
   getExactPoint(projectId, series, at) {
@@ -1580,8 +3119,8 @@ class InMemoryTimeseriesStorage {
     return latest;
   }
   applyExactPoint(projectId, point) {
-    const key = pointKey(projectId, point.series.object.objectTypeId, point.series.object.primaryId, point.series.propertyId);
-    const series = this.pointsByKey.get(key) ?? new Map;
+    const key2 = pointKey(projectId, point.series.object.objectTypeId, point.series.object.primaryId, point.series.propertyId);
+    const series = this.pointsByKey.get(key2) ?? new Map;
     series.set(new Date(point.at).getTime(), {
       projectId,
       objectTypeId: point.series.object.objectTypeId,
@@ -1592,12 +3131,12 @@ class InMemoryTimeseriesStorage {
       at: new Date(point.at),
       lastCommitId: point.lastCommitId
     });
-    this.pointsByKey.set(key, series);
+    this.pointsByKey.set(key2, series);
   }
   async getHistory(params) {
-    const key = pointKey(params.projectId, params.objectTypeId, params.objectId, params.propertyId);
+    const key2 = pointKey(params.projectId, params.objectTypeId, params.objectId, params.propertyId);
     const { from, to } = params;
-    let points = [...this.pointsByKey.get(key)?.values() ?? []];
+    let points = [...this.pointsByKey.get(key2)?.values() ?? []];
     if (from || to) {
       points = points.filter((point) => (!from || point.at >= from) && (!to || point.at <= to));
     }
@@ -1665,7 +3204,13 @@ function publicObjectOverride(value) {
   const { projectId: _, ...stored } = value;
   return stored;
 }
-function publicLinkOverride(value) {
+function publicLinkOverride(value) {
+  if (!value)
+    return null;
+  const { projectId: _, ...stored } = value;
+  return stored;
+}
+function publicLinkSlotOverride(value) {
   if (!value)
     return null;
   const { projectId: _, ...stored } = value;
@@ -1751,15 +3296,15 @@ function storedSourceLink(sourceId, materializationId, row) {
   return storedSource(sourceId, materializationId, row);
 }
 function addReplacementLink(replacement, ref, diffRequired) {
-  const key = linkRefKey(ref);
-  const existing = replacement.links.get(key);
+  const key2 = linkRefKey(ref);
+  const existing = replacement.links.get(key2);
   if (existing) {
     existing.diffRequired ||= diffRequired;
     if (diffRequired)
       replacement.affectedScopes.add(linkScopeSortKey(ref.source, ref.linkId));
     return;
   }
-  replacement.links.set(key, {
+  replacement.links.set(key2, {
     ref: structuredClone(ref),
     sortKey: linkRefSortKey(ref),
     diffRequired
@@ -1921,9 +3466,9 @@ function remainingClassifiedCount(classified, created, updated, deleted) {
   return classified - created - updated - deleted;
 }
 function effectiveChangeCountsMatch(actual, expected) {
-  return effectiveChangeCountKeys.every((key) => {
-    const count = actual[key];
-    return Number.isSafeInteger(count) && count >= 0 && count === expected[key];
+  return effectiveChangeCountKeys.every((key2) => {
+    const count = actual[key2];
+    return Number.isSafeInteger(count) && count >= 0 && count === expected[key2];
   });
 }
 function telemetryCountsCorrelate(session, pointCount, actual) {
@@ -1946,7 +3491,7 @@ function telemetryCountsCorrelate(session, pointCount, actual) {
     pointsUnchanged: pointCount - pointsCreated - pointsUpdated,
     latestObjectsChanged
   };
-  return expected.pointsUnchanged >= 0 && Object.keys(expected).every((key) => Number.isSafeInteger(actual[key]) && actual[key] >= 0 && actual[key] === expected[key]);
+  return expected.pointsUnchanged >= 0 && Object.keys(expected).every((key2) => Number.isSafeInteger(actual[key2]) && actual[key2] >= 0 && actual[key2] === expected[key2]);
 }
 function assertSourceActivationCorrelation(activation, session, state) {
   const { header } = session;
@@ -2017,10 +3562,11 @@ function assertFinalizedWork(session, state, objects) {
   }
 }
 function assertFinalCardinality(records, projectId, objects) {
+  const effectiveOccupants = records.filter((record) => record.view === "effective");
   const scopes = new Map;
   let currentScope = null;
   let occupiedCount = 0;
-  for (const record of records) {
+  for (const record of effectiveOccupants) {
     if (record.scopeSortKey !== currentScope) {
       currentScope = record.scopeSortKey;
       occupiedCount = 0;
@@ -2062,7 +3608,7 @@ function assertReplacementFullyStreamed(session, activation) {
     invalidCorrelation("Link projection replacement state was not fully streamed.");
   }
   const expectedObjectKeys = activation.projectionKind === "object" ? [...replacement.objects.keys()].sort() : [];
-  const expectedLinkKeys = [...replacement.links.entries()].filter(([, value]) => value.diffRequired).map(([key]) => key).sort();
+  const expectedLinkKeys = [...replacement.links.entries()].filter(([, value]) => value.diffRequired).map(([key2]) => key2).sort();
   if (stableJsonStringify(classificationKeys(session, "object")) !== stableJsonStringify(expectedObjectKeys) || stableJsonStringify(classificationKeys(session, "link")) !== stableJsonStringify(expectedLinkKeys) || classificationKeys(session, "point").length > 0) {
     invalidCorrelation("Projection replacement classification coverage does not match its streamed state.");
   }
@@ -2082,15 +3628,17 @@ class InMemoryOntologyMaterializationStorage {
   timeseries;
   getTransactionToken;
   getMaterializationLifecycle;
+  executionExists;
   hooks;
   sessions = new WeakMap;
   liveSessions = new Set;
-  constructor(state, objects, timeseries, getTransactionToken, getMaterializationLifecycle, hooks = {}) {
+  constructor(state, objects, timeseries, getTransactionToken, getMaterializationLifecycle, executionExists, hooks = {}) {
     this.state = state;
     this.objects = objects;
     this.timeseries = timeseries;
     this.getTransactionToken = getTransactionToken;
     this.getMaterializationLifecycle = getMaterializationLifecycle;
+    this.executionExists = executionExists;
     this.hooks = hooks;
   }
   async begin(input) {
@@ -2100,6 +3648,9 @@ class InMemoryOntologyMaterializationStorage {
       throw new MaterializationValidationError("Materialization sessions require an active storage transaction.");
     }
     assertMaterializationHeader(input);
+    if (!await this.executionExists(input.commit.projectId, input.commit.executionId)) {
+      throw new MaterializationValidationError(`Ontology commit execution '${input.commit.executionId}' does not exist in project '${input.commit.projectId}'.`);
+    }
     this.assertCommitAbsent(input);
     for (const expected of input.expected.sources)
       this.assertSource(expected, input.commit.projectId);
@@ -2109,9 +3660,9 @@ class InMemoryOntologyMaterializationStorage {
       await this.assertLink(expected, input.commit.projectId);
     const expectedScopeStates = new Map;
     for (const expected of input.expected.linkScopes) {
-      const key = linkScopeSortKey(expected.source, expected.linkId);
-      const current = expectedScopeStates.get(key) ?? this.computeLinkScopeState(input.commit.projectId, expected.source, expected.linkId);
-      expectedScopeStates.set(key, current);
+      const key2 = linkScopeSortKey(expected.source, expected.linkId);
+      const current = expectedScopeStates.get(key2) ?? this.computeLinkScopeState(input.commit.projectId, expected.source, expected.linkId);
+      expectedScopeStates.set(key2, current);
       if (current.fingerprint !== expected.fingerprint) {
         throw new MaterializationConflictError("effective-state", `Expected link scope changed for ${expected.source.objectTypeId}:${expected.source.primaryId}.${expected.linkId}.`);
       }
@@ -2249,11 +3800,11 @@ class InMemoryOntologyMaterializationStorage {
         const selected = replacement.orderedObjects.slice(offset, offset + input.pageRows);
         const objects = [];
         for (const entry of selected) {
-          const key = projectionEntityKey({ kind: "object", ref: entry.ref });
+          const key2 = projectionEntityKey({ kind: "object", ref: entry.ref });
           const base = await this.objectState(session, entry.ref);
           objects.push({
             ref: base.ref,
-            candidateSource: storedSourceObject(input.source.projectionId, replacement.candidate.materializationId, replacement.candidate.rowsByEntity.get(key)),
+            candidateSource: storedSourceObject(input.source.projectionId, replacement.candidate.materializationId, replacement.candidate.rowsByEntity.get(key2)),
             override: base.override,
             effective: base.effective,
             latestTelemetry: base.latestTelemetry
@@ -2281,13 +3832,14 @@ class InMemoryOntologyMaterializationStorage {
       const selected = replacement.orderedLinks.slice(offset, offset + input.pageRows);
       const links = [];
       for (const entry of selected) {
-        const key = projectionEntityKey({ kind: "link", ref: entry.ref });
+        const key2 = projectionEntityKey({ kind: "link", ref: entry.ref });
         const base = await this.linkState(session, entry.ref);
-        const ownedByReplacement = replacement.previous?.rowsByEntity.has(key) || replacement.candidate.rowsByEntity.has(key);
+        const ownedByReplacement = replacement.previous?.rowsByEntity.has(key2) || replacement.candidate.rowsByEntity.has(key2);
         links.push({
           ref: base.ref,
-          candidateSource: ownedByReplacement ? storedSourceLink(input.source.projectionId, replacement.candidate.materializationId, replacement.candidate.rowsByEntity.get(key)) : base.source,
+          candidateSource: ownedByReplacement ? storedSourceLink(input.source.projectionId, replacement.candidate.materializationId, replacement.candidate.rowsByEntity.get(key2)) : base.source,
           override: base.override,
+          slotOverride: base.slotOverride,
           effective: base.effective,
           diffRequired: entry.diffRequired
         });
@@ -2389,11 +3941,11 @@ class InMemoryOntologyMaterializationStorage {
       this.hooks.beforeWrite?.(boundary, session.writeOrdinal++);
       apply();
     };
-    for (const item of input.chunk.overrides.objectUpserts)
+    for (const item of input.chunk.overrides.objects.upserts)
       write("override.object.upsert", () => {
-        const key = projectEntityKey(projectId, objectRefKey(item.ref));
-        assertLastCommit(this.state.objectOverrides.get(key), item.expectedLastCommitId, "object override");
-        this.state.objectOverrides.set(key, structuredClone({
+        const key2 = projectEntityKey(projectId, objectRefKey(item.ref));
+        assertLastCommit(this.state.objectOverrides.get(key2), item.expectedLastCommitId, "object override");
+        this.state.objectOverrides.set(key2, structuredClone({
           projectId,
           ref: item.ref,
           value: item.value,
@@ -2401,17 +3953,17 @@ class InMemoryOntologyMaterializationStorage {
           updatedAt: item.updatedAt
         }));
       });
-    for (const item of input.chunk.overrides.objectDeletes)
+    for (const item of input.chunk.overrides.objects.deletes)
       write("override.object.delete", () => {
-        const key = projectEntityKey(projectId, objectRefKey(item.ref));
-        assertLastCommit(this.state.objectOverrides.get(key), item.expectedLastCommitId, "object override");
-        this.state.objectOverrides.delete(key);
+        const key2 = projectEntityKey(projectId, objectRefKey(item.ref));
+        assertLastCommit(this.state.objectOverrides.get(key2), item.expectedLastCommitId, "object override");
+        this.state.objectOverrides.delete(key2);
       });
-    for (const item of input.chunk.overrides.linkUpserts)
+    for (const item of input.chunk.overrides.links.edges.upserts)
       write("override.link.upsert", () => {
-        const key = projectEntityKey(projectId, linkRefKey(item.ref));
-        assertLastCommit(this.state.linkOverrides.get(key), item.expectedLastCommitId, "link override");
-        this.state.linkOverrides.set(key, structuredClone({
+        const key2 = projectEntityKey(projectId, linkRefKey(item.ref));
+        assertLastCommit(this.state.linkOverrides.get(key2), item.expectedLastCommitId, "link edge override");
+        this.state.linkOverrides.set(key2, structuredClone({
           projectId,
           ref: item.ref,
           value: item.value,
@@ -2419,11 +3971,29 @@ class InMemoryOntologyMaterializationStorage {
           updatedAt: item.updatedAt
         }));
       });
-    for (const item of input.chunk.overrides.linkDeletes)
+    for (const item of input.chunk.overrides.links.edges.deletes)
       write("override.link.delete", () => {
-        const key = projectEntityKey(projectId, linkRefKey(item.ref));
-        assertLastCommit(this.state.linkOverrides.get(key), item.expectedLastCommitId, "link override");
-        this.state.linkOverrides.delete(key);
+        const key2 = projectEntityKey(projectId, linkRefKey(item.ref));
+        assertLastCommit(this.state.linkOverrides.get(key2), item.expectedLastCommitId, "link edge override");
+        this.state.linkOverrides.delete(key2);
+      });
+    for (const item of input.chunk.overrides.links.slots.upserts)
+      write("override.link-slot.upsert", () => {
+        const key2 = projectEntityKey(projectId, linkScopeKey(item.ref.source, item.ref.linkId));
+        assertLastCommit(this.state.linkSlotOverrides.get(key2), item.expectedLastCommitId, "link slot override");
+        this.state.linkSlotOverrides.set(key2, structuredClone({
+          projectId,
+          ref: item.ref,
+          value: item.value,
+          lastCommitId: item.lastCommitId,
+          updatedAt: item.updatedAt
+        }));
+      });
+    for (const item of input.chunk.overrides.links.slots.deletes)
+      write("override.link-slot.delete", () => {
+        const key2 = projectEntityKey(projectId, linkScopeKey(item.ref.source, item.ref.linkId));
+        assertLastCommit(this.state.linkSlotOverrides.get(key2), item.expectedLastCommitId, "link slot override");
+        this.state.linkSlotOverrides.delete(key2);
       });
     for (const item of input.chunk.effective.linkDeletes)
       write("effective.link.delete", () => {
@@ -2466,20 +4036,20 @@ class InMemoryOntologyMaterializationStorage {
         assertTimestamp2(item.availableAt, "Outbox availableAt");
         assertTimestamp2(item.createdAt, "Outbox createdAt");
         assertTimestamp2(envelope.occurredAt, "Outbox event occurredAt");
-        const key = outboxKey(projectId, envelope.id);
-        if (this.state.outbox.has(key)) {
+        const key2 = outboxKey(projectId, envelope.id);
+        if (this.state.outbox.has(key2)) {
           throw new MaterializationConflictError("effective-state", `Duplicate outbox event '${envelope.id}'.`);
         }
         if (session.outboxEnvelopes.has(envelope.commitOrdinal))
           throw new MaterializationConflictError("effective-state", "Duplicate outbox commit ordinal.");
-        this.state.outbox.set(key, {
+        this.state.outbox.set(key2, {
           envelope: structuredClone(envelope),
           availableAt: item.availableAt,
           attempts: 0,
           leaseId: null,
           leaseExpiresAt: null,
           publishedAt: null,
-          lastError: null,
+          lastFailure: null,
           createdAt: item.createdAt
         });
         session.outboxEnvelopes.set(envelope.commitOrdinal, structuredClone(envelope));
@@ -2610,6 +4180,17 @@ class InMemoryOntologyMaterializationStorage {
       if (touchesIncident(override.ref))
         addReplacementLink(replacement, override.ref, true);
     }
+    for (const override of this.state.linkSlotOverrides.values()) {
+      if (override.projectId !== projectId)
+        continue;
+      const ref = {
+        source: override.ref.source,
+        linkId: override.ref.linkId,
+        target: override.value.target
+      };
+      if (touchesIncident(ref))
+        addReplacementLink(replacement, ref, true);
+    }
     for (const active of this.state.sourceMaterializations.values()) {
       if (active.projectId !== projectId || active.status !== "active")
         continue;
@@ -2625,6 +4206,15 @@ class InMemoryOntologyMaterializationStorage {
         addReplacementLink(replacement, ref, false);
       }
     });
+    for (const override of this.state.linkSlotOverrides.values()) {
+      if (override.projectId === projectId && replacement.affectedScopes.has(linkScopeSortKey(override.ref.source, override.ref.linkId))) {
+        addReplacementLink(replacement, {
+          source: override.ref.source,
+          linkId: override.ref.linkId,
+          target: override.value.target
+        }, false);
+      }
+    }
     replacement.linksExpanded = true;
     replacement.orderedLinks = null;
   }
@@ -2714,24 +4304,25 @@ class InMemoryOntologyMaterializationStorage {
       ref: structuredClone(ref),
       source: this.findActiveLinkSource(projectId, ref),
       override: structuredClone(publicLinkOverride(this.state.linkOverrides.get(projectEntityKey(projectId, linkRefKey(ref))))),
+      slotOverride: structuredClone(publicLinkSlotOverride(this.state.linkSlotOverrides.get(projectEntityKey(projectId, linkScopeKey(ref.source, ref.linkId))))),
       effective: row ? linkSnapshot(row) : null
     };
   }
   linkScopeState(session, source, linkId) {
     session.linkScopeStates ??= new Map;
-    const key = linkScopeSortKey(source, linkId);
-    const existing = session.linkScopeStates.get(key);
+    const key2 = linkScopeSortKey(source, linkId);
+    const existing = session.linkScopeStates.get(key2);
     if (existing)
       return structuredClone(existing);
     const computed = this.computeLinkScopeState(session.header.commit.projectId, source, linkId);
-    session.linkScopeStates.set(key, computed);
+    session.linkScopeStates.set(key2, computed);
     return structuredClone(computed);
   }
   computeLinkScopeState(projectId, source, linkId) {
     const rows = [];
     getInMemoryObjectMaterializerAdapter(this.objects).visitExactScopeLinks(projectId, source.objectTypeId, source.primaryId, linkId, (row) => rows.push(row));
     rows.sort((left, right) => linkRefSortKey(linkRef(left)).localeCompare(linkRefSortKey(linkRef(right))));
-    const accumulator = startScopeAccumulator(source, linkId, linkScopeSortKey(source, linkId));
+    const accumulator = startScopeAccumulator(source, linkId);
     for (let offset = 0;offset < rows.length; offset += 1000) {
       const page = rows.slice(offset, offset + 1000);
       this.hooks.observeBuffer?.("state.link-scope.page", page.length);
@@ -2739,7 +4330,30 @@ class InMemoryOntologyMaterializationStorage {
         appendScopeSnapshot(accumulator, linkSnapshot(row));
       }
     }
-    return finishScopeAccumulator(accumulator);
+    const effective = rows.length === 1 ? linkSnapshot(rows[0]) : null;
+    return {
+      ...finishScopeAccumulator(accumulator),
+      sourceAssertion: this.findActiveLinkScopeSource(projectId, source, linkId),
+      override: structuredClone(publicLinkSlotOverride(this.state.linkSlotOverrides.get(projectEntityKey(projectId, linkScopeKey(source, linkId))))),
+      effective
+    };
+  }
+  findActiveLinkScopeSource(projectId, source, linkId) {
+    let found = null;
+    for (const active of this.state.sourceMaterializations.values()) {
+      if (active.projectId !== projectId || active.status !== "active")
+        continue;
+      for (const row of active.rowsByEntity.values()) {
+        if (row.assertion.kind !== "link" || objectRefKey(row.assertion.ref.source) !== objectRefKey(source) || row.assertion.ref.linkId !== linkId) {
+          continue;
+        }
+        if (found) {
+          throw new MaterializationConflictError("source-materialization", `Multiple active source links assert cardinality-one scope '${source.objectTypeId}.${linkId}'.`);
+        }
+        found = storedSource(active.source.projectionId, active.materializationId, row);
+      }
+    }
+    return structuredClone(found);
   }
   findActiveObjectSource(projectId, ref) {
     const found = this.findActiveSource(projectId, projectionEntityKey({ kind: "object", ref }));
@@ -2780,10 +4394,10 @@ class InMemoryOntologyMaterializationStorage {
     const consider = (ref) => {
       const sortKey = linkRefSortKey(ref);
       for (const endpoint of [ref.source, ref.target]) {
-        const key = objectRefKey(endpoint);
-        const links = mutable.get(key) ?? new Map;
+        const key2 = objectRefKey(endpoint);
+        const links = mutable.get(key2) ?? new Map;
         links.set(sortKey, structuredClone(ref));
-        mutable.set(key, links);
+        mutable.set(key2, links);
       }
     };
     getInMemoryObjectMaterializerAdapter(this.objects).visitExactLinks(projectId, (row) => consider(linkRef(row)));
@@ -2791,6 +4405,15 @@ class InMemoryOntologyMaterializationStorage {
       if (override.projectId === projectId)
         consider(override.ref);
     }
+    for (const override of this.state.linkSlotOverrides.values()) {
+      if (override.projectId !== projectId)
+        continue;
+      consider({
+        source: override.ref.source,
+        linkId: override.ref.linkId,
+        target: override.value.target
+      });
+    }
     for (const active of this.state.sourceMaterializations.values()) {
       if (active.projectId !== projectId || active.status !== "active")
         continue;
@@ -2857,8 +4480,8 @@ class InMemoryOntologyOutboxStorage {
     assertNonblank(input.leaseId, "Ontology outbox lease id");
     assertTimestamp2(input.publishedAt, "Ontology outbox publishedAt");
     const rows = this.validateLeaseBatch(input.projectId, input.ids, input.leaseId);
-    for (const [key, row] of rows) {
-      this.state.outbox.set(key, {
+    for (const [key2, row] of rows) {
+      this.state.outbox.set(key2, {
         ...row,
         publishedAt: input.publishedAt,
         leaseId: null,
@@ -2874,11 +4497,11 @@ class InMemoryOntologyOutboxStorage {
     assertNonblank(input.leaseId, "Ontology outbox lease id");
     assertTimestamp2(input.availableAt, "Ontology outbox availableAt");
     const rows = this.validateLeaseBatch(input.projectId, input.ids, input.leaseId);
-    for (const [key, row] of rows) {
-      this.state.outbox.set(key, {
+    for (const [key2, row] of rows) {
+      this.state.outbox.set(key2, {
         ...row,
         availableAt: input.availableAt,
-        lastError: input.error,
+        lastFailure: input.failure === undefined ? row.lastFailure : structuredClone(input.failure),
         leaseId: null,
         leaseExpiresAt: null
       });
@@ -2920,12 +4543,12 @@ class InMemoryOntologyOutboxStorage {
       }
       insertBounded(rows, entry, input.limit, ([, left], [, right]) => comparePublishedRows(left, right));
     }
-    for (const [key] of rows)
-      this.state.outbox.delete(key);
+    for (const [key2] of rows)
+      this.state.outbox.delete(key2);
     return rows.length;
   }
-  requireLease(key, leaseId) {
-    const row = this.state.outbox.get(key);
+  requireLease(key2, leaseId) {
+    const row = this.state.outbox.get(key2);
     if (!row || row.leaseId !== leaseId || row.leaseExpiresAt === null) {
       throw new MaterializationConflictError("outbox-lease", "Ontology outbox lease does not match.");
     }
@@ -2939,8 +4562,8 @@ class InMemoryOntologyOutboxStorage {
         throw new MaterializationValidationError(`Ontology outbox lease batch repeats event '${id}'.`);
       }
       seen.add(id);
-      const key = outboxKey(projectId, id);
-      return [key, this.requireLease(key, leaseId)];
+      const key2 = outboxKey(projectId, id);
+      return [key2, this.requireLease(key2, leaseId)];
     });
   }
 }
@@ -2975,8 +4598,8 @@ class InMemoryOntologySourceStorage {
     return this.runRootOperation(async () => {
       assertSourceBeginInput(input);
       await this.assertCurrentExecution(input);
-      const key = sourceMaterializationKey(input.projectId, input.source.projectionId, input.materializationId);
-      const existing = this.state.sourceMaterializations.get(key);
+      const key2 = sourceMaterializationKey(input.projectId, input.source.projectionId, input.materializationId);
+      const existing = this.state.sourceMaterializations.get(key2);
       if (existing) {
         if (isExactStagingManifest(sourceMaterializationRecord(existing), input)) {
           return sourceMaterializationRecord(existing);
@@ -3012,7 +4635,7 @@ class InMemoryOntologySourceStorage {
         rootOrdinals: new Map,
         ordinalRoots: new Map
       };
-      this.state.sourceMaterializations.set(key, materialization);
+      this.state.sourceMaterializations.set(key2, materialization);
       return sourceMaterializationRecord(materialization);
     });
   }
@@ -3097,10 +4720,10 @@ class InMemoryOntologySourceStorage {
       let remaining = input.limit;
       let rowsDeleted = 0;
       let materializationsDeleted = 0;
-      for (const [key, candidate] of candidates) {
+      for (const [key2, candidate] of candidates) {
         if (remaining === 0)
           break;
-        const current = this.state.sourceMaterializations.get(key);
+        const current = this.state.sourceMaterializations.get(key2);
         if (current !== candidate)
           continue;
         current.rootOrdinals.clear();
@@ -3113,7 +4736,7 @@ class InMemoryOntologySourceStorage {
           remaining -= 1;
         }
         if (current.rowsByEntity.size === 0 && remaining > 0) {
-          this.state.sourceMaterializations.delete(key);
+          this.state.sourceMaterializations.delete(key2);
           materializationsDeleted += 1;
           remaining -= 1;
         }
@@ -3320,7 +4943,7 @@ class InMemoryOntologyStorage {
     this.commits = new InMemoryOntologyCommitStorage(this.state, options.runRootOperation);
     this.sources = new InMemoryOntologySourceStorage(this.state, options.runRootOperation, options.assertSourceMaterializationExecution);
     this.outbox = new InMemoryOntologyOutboxStorage(this.state, options.runRootOperation);
-    this.materializations = new InMemoryOntologyMaterializationStorage(this.state, objects, timeseries, options.getTransactionToken, options.getMaterializationLifecycle, {
+    this.materializations = new InMemoryOntologyMaterializationStorage(this.state, objects, timeseries, options.getTransactionToken, options.getMaterializationLifecycle, options.executionExists, {
       beforeRead: (boundary) => this.testHooks.beforeRead?.(boundary),
       beforeWrite: (boundary, ordinal) => this.testHooks.beforeWrite?.(boundary, ordinal),
       observeBuffer: (boundary, rows) => this.testHooks.observeBuffer?.(boundary, rows),
@@ -3344,10 +4967,9 @@ class InMemoryOntologyStorage {
     this.materializations.deactivateTransaction(transactionToken);
   }
 }
-
-// src/storage/pipeline-runs/errors.ts
-class PipelineRunError extends Error {
-  name = "PipelineRunError";
+// src/storage/pipeline-runs/idempotency.ts
+function canRequeuePipelineRunAfterEnqueueFailure(existing, input) {
+  return existing.status === "failed" && existing.error?.code === "queue.enqueue_failed" && existing.error.retryable && existing.executionId === input.executionId && existing.pipelineId === input.pipelineId;
 }
 // src/storage/run-listing.ts
 function storageKey(projectId, id) {
@@ -3366,16 +4988,17 @@ function matchesRunListDateFilters(record, filters) {
   if (filters.statuses && !filters.statuses.has(record.status)) {
     return false;
   }
-  if (filters.startedAfter && record.startedAt < filters.startedAfter) {
+  const startedAt = effectiveStartedAt(record);
+  if (filters.startedAfter && startedAt < filters.startedAfter) {
     return false;
   }
-  if (filters.startedBefore && record.startedAt > filters.startedBefore) {
+  if (filters.startedBefore && startedAt > filters.startedBefore) {
     return false;
   }
   return true;
 }
 function compareStartedAt(left, right, order) {
-  const delta = left.startedAt.getTime() - right.startedAt.getTime();
+  const delta = effectiveStartedAt(left).getTime() - effectiveStartedAt(right).getTime();
   if (delta !== 0) {
     return order === "asc" ? delta : -delta;
   }
@@ -3406,10 +5029,25 @@ function latestStartedAtByOwnerId(records, ownerIds, ownerIdFor) {
     return record ? [record] : [];
   });
 }
+function effectiveStartedAt(record) {
+  const value = record.startedAt ?? record.queuedAt;
+  if (!value) {
+    throw new Error(`[Sixb] Run '${record.id}' has neither startedAt nor queuedAt.`);
+  }
+  return value;
+}
+
+// src/storage/pipeline-runs/types.ts
+var PIPELINE_RUN_FAILURE_CODES = [
+  "internal.unexpected",
+  "runtime.cancelled",
+  "queue.enqueue_failed",
+  "pipeline.step_failed"
+];
 
 // src/storage/pipeline-runs/in-memory.ts
 function normalizeError2(error) {
-  return error ? cloneRecord(error) : undefined;
+  return error ? parseSixbFailure(error, PIPELINE_RUN_FAILURE_CODES) : undefined;
 }
 function assertNonNegativeInteger(value, fieldName) {
   if (value !== undefined && (!Number.isInteger(value) || value < 0)) {
@@ -3418,8 +5056,12 @@ function assertNonNegativeInteger(value, fieldName) {
 }
 
 class InMemoryPipelineRunStorage {
+  executions;
   runs = new Map;
   steps = new Map;
+  constructor(executions) {
+    this.executions = executions;
+  }
   snapshot() {
     return {
       runs: structuredClone(this.runs),
@@ -3428,31 +5070,79 @@ class InMemoryPipelineRunStorage {
   }
   restore(snapshot) {
     this.runs.clear();
-    for (const [key, record] of structuredClone(snapshot.runs)) {
-      this.runs.set(key, record);
+    for (const [key2, record] of structuredClone(snapshot.runs)) {
+      this.runs.set(key2, record);
     }
     this.steps.clear();
-    for (const [key, record] of structuredClone(snapshot.steps)) {
-      this.steps.set(key, record);
+    for (const [key2, record] of structuredClone(snapshot.steps)) {
+      this.steps.set(key2, record);
     }
   }
-  async start(input) {
-    const key = storageKey(input.projectId, input.id);
-    if (this.runs.has(key)) {
+  async queue(input) {
+    const key2 = storageKey(input.projectId, input.id);
+    const existing = this.runs.get(key2);
+    if (existing && !canRequeuePipelineRunAfterEnqueueFailure(existing, input)) {
       throw new PipelineRunError(`[Sixb] Pipeline run '${input.id}' already exists for project '${input.projectId}'.`);
     }
+    if ([...this.runs.values()].some((run) => run.projectId === input.projectId && run.id !== input.id && run.executionId === input.executionId)) {
+      throw new PipelineRunError(`[Sixb] Execution '${input.executionId}' already belongs to another Pipeline run.`);
+    }
+    await assertPipelineRunExecution({
+      executions: this.executions,
+      projectId: input.projectId,
+      executionId: input.executionId,
+      runId: input.id,
+      pipelineId: input.pipelineId
+    });
+    const queuedAt = new Date(input.queuedAt ?? new Date);
+    if (existing) {
+      const next = {
+        ...existing,
+        status: "queued",
+        queuedAt,
+        startedAt: undefined,
+        finishedAt: undefined,
+        output: undefined,
+        error: undefined
+      };
+      this.runs.set(key2, cloneRecord(next));
+      return cloneRecord(next);
+    }
     const record = {
       id: input.id,
       projectId: input.projectId,
+      executionId: input.executionId,
       pipelineId: input.pipelineId,
-      status: "running",
-      startedAt: new Date(input.startedAt ?? new Date)
+      status: "queued",
+      queuedAt
     };
-    this.runs.set(key, cloneRecord(record));
+    this.runs.set(key2, cloneRecord(record));
     return cloneRecord(record);
   }
+  async start(input) {
+    const key2 = storageKey(input.projectId, input.id);
+    const existing = this.runs.get(key2);
+    if (!existing) {
+      throw new PipelineRunError(`[Sixb] Pipeline run '${input.id}' not found for project '${input.projectId}'.`);
+    }
+    if (existing.status !== "queued") {
+      throw new PipelineRunError(`[Sixb] Pipeline run '${input.id}' cannot start from status '${existing.status}'.`);
+    }
+    const next = {
+      ...existing,
+      status: "running",
+      startedAt: new Date(input.startedAt ?? new Date),
+      error: undefined
+    };
+    this.runs.set(key2, cloneRecord(next));
+    return cloneRecord(next);
+  }
   async finish(input) {
-    const existing = this.requireRunningPipelineRun(input.projectId, input.id);
+    const existing = this.requireExistingPipelineRun(input.projectId, input.id);
+    const enqueueFailure = input.status === "failed" && input.error.code === "queue.enqueue_failed";
+    if (enqueueFailure && existing.status !== "queued" || !enqueueFailure && existing.status !== "running") {
+      throw new PipelineRunError(`[Sixb] Pipeline run '${input.id}' cannot finish from status '${existing.status}'.`);
+    }
     const base = {
       ...existing,
       status: input.status,
@@ -3475,8 +5165,8 @@ class InMemoryPipelineRunStorage {
     if (pipelineRun.pipelineId !== input.pipelineId) {
       throw new PipelineRunError(`[Sixb] Pipeline step run '${input.id}' pipeline '${input.pipelineId}' does not match pipeline run '${input.pipelineRunId}' pipeline '${pipelineRun.pipelineId}'.`);
     }
-    const key = storageKey(input.projectId, input.id);
-    if (this.steps.has(key)) {
+    const key2 = storageKey(input.projectId, input.id);
+    if (this.steps.has(key2)) {
       throw new PipelineRunError(`[Sixb] Pipeline step run '${input.id}' already exists for project '${input.projectId}'.`);
     }
     const record = {
@@ -3491,7 +5181,7 @@ class InMemoryPipelineRunStorage {
       startedAt: new Date(input.startedAt ?? new Date),
       inputs: cloneRecord(input.inputs)
     };
-    this.steps.set(key, cloneRecord(record));
+    this.steps.set(key2, cloneRecord(record));
     return cloneRecord(record);
   }
   async finishStep(input) {
@@ -3600,17 +5290,12 @@ class InMemoryPipelineRunStorage {
 }
 // src/storage/projection-runs/in-memory.ts
 import { randomUUID as randomUUID2 } from "crypto";
-var runDirectly2 = async (run) => run();
+var runDirectly3 = async (run) => run();
 function projectionRunKey(projectId, id) {
   return JSON.stringify([projectId, id]);
 }
 function compareRuns2(a, b, order) {
-  const delta = a.startedAt.getTime() - b.startedAt.getTime();
-  if (delta !== 0)
-    return order === "asc" ? delta : -delta;
-  if (a.id === b.id)
-    return 0;
-  return order === "asc" ? a.id.localeCompare(b.id) : b.id.localeCompare(a.id);
+  return compareStartedAt(a, b, order);
 }
 
 class InMemoryProjectionRunStorage {
@@ -3618,10 +5303,12 @@ class InMemoryProjectionRunStorage {
   executionTokensByRun = new Map;
   runRootOperation;
   createExecutionToken;
-  constructor(input = {}) {
-    this.runRootOperation = input.runRootOperation ?? runDirectly2;
+  constructor(input) {
+    this.executions = input.executions;
+    this.runRootOperation = input.runRootOperation ?? runDirectly3;
     this.createExecutionToken = input.executionToken ?? randomUUID2;
   }
+  executions;
   snapshot() {
     return structuredClone({
       rows: this.rows,
@@ -3631,25 +5318,71 @@ class InMemoryProjectionRunStorage {
   restore(snapshot) {
     this.rows.clear();
     this.executionTokensByRun.clear();
-    for (const [key, record] of structuredClone(snapshot.rows))
-      this.rows.set(key, record);
-    for (const [key, tokens] of structuredClone(snapshot.executionTokensByRun)) {
-      this.executionTokensByRun.set(key, tokens);
+    for (const [key2, record] of structuredClone(snapshot.rows))
+      this.rows.set(key2, record);
+    for (const [key2, tokens] of structuredClone(snapshot.executionTokensByRun)) {
+      this.executionTokensByRun.set(key2, tokens);
     }
   }
+  async queue(input) {
+    return this.runRootOperation(async () => {
+      assertProjectionRunQueueInput(input);
+      this.assertDatasetVersionIsImmutable(input);
+      const key2 = projectionRunKey(input.projectId, input.id);
+      const existing = this.rows.get(key2);
+      if (existing && !canRequeueProjectionRunAfterEnqueueFailure(existing, input)) {
+        throw new ProjectionRunError(`[Sixb] Projection run '${input.id}' already exists for project '${input.projectId}'.`);
+      }
+      if ([...this.rows.values()].some((run) => run.projectId === input.projectId && run.id !== input.id && run.executionId === input.executionId)) {
+        throw new ProjectionRunError(`[Sixb] Execution '${input.executionId}' already belongs to another Projection run.`);
+      }
+      await assertProjectionRunDurableExecution({
+        executions: this.executions,
+        projectId: input.projectId,
+        executionId: input.executionId,
+        runId: input.id,
+        projectionId: input.identity.projectionId,
+        datasetId: input.identity.datasetVersion.datasetId,
+        datasetVersionId: input.identity.datasetVersion.versionId
+      });
+      const record = createProjectionRunRecord(input);
+      this.rows.set(key2, structuredClone(record));
+      return publicProjectionRunRecord(record);
+    });
+  }
   async startOrReclaim(input) {
     return this.runRootOperation(() => {
       assertProjectionRunStartInput(input);
-      this.assertDatasetVersionIsImmutable(input);
-      const key = projectionRunKey(input.projectId, input.id);
-      const existing = this.rows.get(key);
-      const attempt = existing ? planProjectionRunReclaim(existing, input).attempt : 1;
-      const executionToken = this.issueExecutionToken(key, input.id, existing?.executionToken);
-      const record = existing ? { ...existing, attempt, executionToken } : { ...createProjectionRunRecord(input), executionToken };
-      this.rows.set(key, structuredClone(record));
+      const key2 = projectionRunKey(input.projectId, input.id);
+      const existing = this.rows.get(key2);
+      if (!existing)
+        throw projectionRunNotFound(input.projectId, input.id);
+      const attempt = planProjectionRunReclaim(existing, input).attempt;
+      const executionToken = this.issueExecutionToken(key2, input.id, existing.executionToken);
+      const record = {
+        ...existing,
+        status: "running",
+        attempt,
+        executionToken,
+        startedAt: existing.startedAt ?? new Date(input.startedAt ?? new Date),
+        finishedAt: undefined,
+        error: undefined
+      };
+      this.rows.set(key2, structuredClone(record));
       return createProjectionRunClaim(record);
     });
   }
+  async failEnqueue(input) {
+    return this.runRootOperation(() => {
+      const key2 = projectionRunKey(input.projectId, input.id);
+      const existing = this.rows.get(key2);
+      if (!existing)
+        throw projectionRunNotFound(input.projectId, input.id);
+      const next = failProjectionRunEnqueue(existing, input);
+      this.rows.set(key2, structuredClone(next));
+      return publicProjectionRunRecord(next);
+    });
+  }
   async lockForMaterialization(input) {
     return this.runRootOperation(() => publicProjectionRunRecord(this.requireExecution(input)));
   }
@@ -3733,7 +5466,11 @@ class InMemoryProjectionRunStorage {
       const limit = input.limit ?? this.rows.size;
       const statuses = input.statuses ? new Set(input.statuses) : null;
       const objectTypeIds = input.objectTypeIds ? new Set(input.objectTypeIds) : null;
-      const filtered = [...this.rows.values()].filter((record) => record.projectId === input.projectId).filter((record) => input.projectionId ? record.identity.projectionId === input.projectionId : true).filter((record) => input.projectionKind ? record.identity.projectionKind === input.projectionKind : true).filter((record) => input.datasetId ? record.identity.datasetVersion.datasetId === input.datasetId : true).filter((record) => input.datasetVersionId ? record.identity.datasetVersion.versionId === input.datasetVersionId : true).filter((record) => objectTypeIds ? projectionRunObjectTypesVisible(record, (id) => objectTypeIds.has(id)) : true).filter((record) => statuses ? statuses.has(record.status) : true).filter((record) => input.startedAfter ? record.startedAt >= input.startedAfter : true).filter((record) => input.startedBefore ? record.startedAt <= input.startedBefore : true).sort((left, right) => compareRuns2(left, right, order));
+      const filtered = [...this.rows.values()].filter((record) => record.projectId === input.projectId).filter((record) => input.projectionId ? record.identity.projectionId === input.projectionId : true).filter((record) => input.projectionKind ? record.identity.projectionKind === input.projectionKind : true).filter((record) => input.datasetId ? record.identity.datasetVersion.datasetId === input.datasetId : true).filter((record) => input.datasetVersionId ? record.identity.datasetVersion.versionId === input.datasetVersionId : true).filter((record) => objectTypeIds ? projectionRunObjectTypesVisible(record, (id) => objectTypeIds.has(id)) : true).filter((record) => statuses ? statuses.has(record.status) : true).filter((record) => matchesRunListDateFilters(record, {
+        statuses,
+        startedAfter: input.startedAfter,
+        startedBefore: input.startedBefore
+      })).sort((left, right) => compareRuns2(left, right, order));
       const total = filtered.length;
       const runs = filtered.slice(offset, offset + limit).map(publicProjectionRunRecord);
       return { runs, hasMore: offset + runs.length < total, total };
@@ -3752,22 +5489,22 @@ class InMemoryProjectionRunStorage {
       }
     }
   }
-  issueExecutionToken(key, runId, currentToken) {
+  issueExecutionToken(key2, runId, currentToken) {
     const executionToken = this.createExecutionToken();
     assertProjectionRunNonEmpty(executionToken, "executionToken");
-    const usedTokens = this.executionTokensByRun.get(key) ?? new Set;
+    const usedTokens = this.executionTokensByRun.get(key2) ?? new Set;
     if (currentToken)
       usedTokens.add(currentToken);
     if (usedTokens.has(executionToken)) {
       throw new ProjectionRunError(`[Sixb] Projection run '${runId}' execution token was already used.`);
     }
     usedTokens.add(executionToken);
-    this.executionTokensByRun.set(key, usedTokens);
+    this.executionTokensByRun.set(key2, usedTokens);
     return executionToken;
   }
   requireExecution(input) {
     const record = this.requireRunning(input.projectId, input.id);
-    assertProjectionRunExecution(record, input);
+    assertProjectionRunAttempt(record, input);
     return record;
   }
   requireTelemetryExecution(input) {
@@ -3827,8 +5564,8 @@ class InMemoryRulesStorage {
   }
   restore(snapshot) {
     this.active.clear();
-    for (const [key, record] of structuredClone(snapshot)) {
-      this.active.set(key, record);
+    for (const [key2, record] of structuredClone(snapshot)) {
+      this.active.set(key2, record);
     }
   }
   async getActive(params) {
@@ -3899,10 +5636,18 @@ class InMemoryRulesStorage {
     }
   }
 }
-// src/storage/sync-runs/errors.ts
-class SyncRunError extends Error {
-  name = "SyncRunError";
+// src/storage/sync-runs/idempotency.ts
+function canRequeueSyncRunAfterEnqueueFailure(existing, input) {
+  return existing.status === "failed" && existing.error?.code === "queue.enqueue_failed" && existing.error.retryable && existing.executionId === input.executionId && existing.syncId === input.syncId && existing.datasetId === input.datasetId && existing.mode === input.mode && existing.expectedLatestVersionId === input.expectedLatestVersionId && existing.commitMessage === input.commitMessage;
 }
+// src/storage/sync-runs/types.ts
+var SYNC_RUN_FAILURE_CODES = [
+  "internal.unexpected",
+  "runtime.cancelled",
+  "queue.enqueue_failed",
+  "sync.execution_failed"
+];
+
 // src/storage/sync-runs/in-memory.ts
 function syncRunKey(projectId, id) {
   return `${projectId}:${id}`;
@@ -3914,45 +5659,99 @@ function normalizeCheckpoint(checkpoint) {
   return checkpoint !== undefined ? cloneJsonValue(checkpoint) : undefined;
 }
 function normalizeError3(error) {
-  return error ? structuredClone(error) : undefined;
+  return error ? parseSixbFailure(error, SYNC_RUN_FAILURE_CODES) : undefined;
 }
 
 class InMemorySyncRunStorage {
+  executions;
   rows = new Map;
+  constructor(executions) {
+    this.executions = executions;
+  }
   snapshot() {
     return structuredClone(this.rows);
   }
   restore(snapshot) {
     this.rows.clear();
-    for (const [key, record] of structuredClone(snapshot)) {
-      this.rows.set(key, record);
+    for (const [key2, record] of structuredClone(snapshot)) {
+      this.rows.set(key2, record);
     }
   }
-  async start(input) {
-    const key = syncRunKey(input.projectId, input.id);
-    if (this.rows.has(key)) {
+  async queue(input) {
+    const key2 = syncRunKey(input.projectId, input.id);
+    const existing = this.rows.get(key2);
+    if (existing && !canRequeueSyncRunAfterEnqueueFailure(existing, input)) {
       throw new SyncRunError(`[Sixb] Sync run '${input.id}' already exists for project '${input.projectId}'.`);
     }
+    if ([...this.rows.values()].some((run) => run.projectId === input.projectId && run.id !== input.id && run.executionId === input.executionId)) {
+      throw new SyncRunError(`[Sixb] Execution '${input.executionId}' already belongs to another Sync run.`);
+    }
+    await assertSyncRunExecution({
+      executions: this.executions,
+      projectId: input.projectId,
+      executionId: input.executionId,
+      runId: input.id,
+      syncId: input.syncId
+    });
+    const queuedAt = new Date(input.queuedAt ?? new Date);
+    if (existing) {
+      const next = {
+        ...existing,
+        status: "queued",
+        queuedAt,
+        startedAt: undefined,
+        finishedAt: undefined,
+        rowsRead: undefined,
+        output: undefined,
+        error: undefined,
+        checkpoint: undefined
+      };
+      this.rows.set(key2, structuredClone(next));
+      return cloneSyncRunRecord(next);
+    }
     const record = {
       id: input.id,
       projectId: input.projectId,
+      executionId: input.executionId,
       syncId: input.syncId,
       datasetId: input.datasetId,
       mode: input.mode,
-      status: "running",
-      startedAt: new Date(input.startedAt ?? new Date),
+      status: "queued",
+      queuedAt,
       expectedLatestVersionId: input.expectedLatestVersionId,
       commitMessage: input.commitMessage
     };
-    this.rows.set(key, structuredClone(record));
+    this.rows.set(key2, structuredClone(record));
     return cloneSyncRunRecord(record);
   }
+  async start(input) {
+    const key2 = syncRunKey(input.projectId, input.id);
+    const existing = this.rows.get(key2);
+    if (!existing) {
+      throw new SyncRunError(`[Sixb] Sync run '${input.id}' not found for project '${input.projectId}'.`);
+    }
+    if (existing.status !== "queued") {
+      throw new SyncRunError(`[Sixb] Sync run '${input.id}' cannot start from status '${existing.status}'.`);
+    }
+    const next = {
+      ...existing,
+      status: "running",
+      startedAt: new Date(input.startedAt ?? new Date),
+      error: undefined
+    };
+    this.rows.set(key2, structuredClone(next));
+    return cloneSyncRunRecord(next);
+  }
   async finish(input) {
-    const key = syncRunKey(input.projectId, input.id);
-    const existing = this.rows.get(key);
+    const key2 = syncRunKey(input.projectId, input.id);
+    const existing = this.rows.get(key2);
     if (!existing) {
       throw new SyncRunError(`[Sixb] 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") {
+      throw new SyncRunError(`[Sixb] Sync run '${input.id}' cannot finish from status '${existing.status}'.`);
+    }
     if (input.status === "succeeded") {
       if (input.output && input.output.datasetId !== existing.datasetId) {
         throw new SyncRunError(`[Sixb] Sync run '${input.id}' output dataset '${input.output.datasetId}' does not match '${existing.datasetId}'.`);
@@ -3979,7 +5778,7 @@ class InMemorySyncRunStorage {
       error: normalizeError3(input.error),
       checkpoint: undefined
     };
-    this.rows.set(key, structuredClone(next));
+    this.rows.set(key2, structuredClone(next));
     return cloneSyncRunRecord(next);
   }
   async getById(params) {
@@ -4054,133 +5853,85 @@ function throwNestedStorageTransaction() {
     code: "nested_transaction"
   });
 }
-
-// src/storage/webhook-deliveries/in-memory.ts
-function cloneDeliveryRecord(record) {
-  return structuredClone(record);
+// src/storage/webhook-runs/types.ts
+var WEBHOOK_RUN_FAILURE_CODES = [
+  "internal.unexpected",
+  "webhook.delivery_failed",
+  "webhook.delivery_rejected"
+];
+function canRetryWebhookRun(run) {
+  return run.status === "failed" && run.error?.retryable === true;
 }
 
-class InMemoryWebhookDeliveryStorage {
-  deliveries = new Map;
-  snapshot() {
-    return structuredClone(this.deliveries);
-  }
-  restore(snapshot) {
-    this.deliveries.clear();
-    for (const [key, record] of structuredClone(snapshot)) {
-      this.deliveries.set(key, record);
-    }
-  }
-  async claim(input) {
-    const key = serializeKey(input);
-    const existing = this.deliveries.get(key);
-    if (existing?.status === "completed") {
-      return {
-        ...cloneDeliveryRecord(existing),
-        claimResult: "duplicate"
-      };
-    }
-    if (existing?.status === "in_progress") {
-      return {
-        ...cloneDeliveryRecord(existing),
-        claimResult: "in_progress"
-      };
-    }
-    const next = {
-      projectId: input.projectId,
-      connectorId: input.connectorId,
-      webhookId: input.webhookId,
-      idempotencyKey: input.idempotencyKey,
-      status: "in_progress",
-      receivedAt: input.receivedAt
-    };
-    this.deliveries.set(key, structuredClone(next));
-    return {
-      ...cloneDeliveryRecord(next),
-      claimResult: "claimed"
-    };
-  }
-  async complete(input) {
-    const key = serializeKey(input);
-    const next = {
-      projectId: input.projectId,
-      connectorId: input.connectorId,
-      webhookId: input.webhookId,
-      idempotencyKey: input.idempotencyKey,
-      ...this.deliveries.get(key),
-      status: "completed",
-      completedAt: input.completedAt,
-      failedAt: undefined,
-      error: undefined
-    };
-    this.deliveries.set(key, structuredClone(next));
-    return cloneDeliveryRecord(next);
-  }
-  async fail(input) {
-    const key = serializeKey(input);
-    const next = {
-      projectId: input.projectId,
-      connectorId: input.connectorId,
-      webhookId: input.webhookId,
-      idempotencyKey: input.idempotencyKey,
-      ...this.deliveries.get(key),
-      status: "failed",
-      failedAt: input.failedAt,
-      error: input.error,
-      completedAt: undefined
-    };
-    this.deliveries.set(key, structuredClone(next));
-    return cloneDeliveryRecord(next);
-  }
-}
-function serializeKey(key) {
-  return JSON.stringify([key.projectId, key.connectorId, key.webhookId, key.idempotencyKey]);
-}
-// src/storage/webhook-runs/errors.ts
-class WebhookRunError extends Error {
-  name = "WebhookRunError";
-}
 // src/storage/webhook-runs/in-memory.ts
 class InMemoryWebhookRunStorage {
+  executions;
   runs = new Map;
+  constructor(executions) {
+    this.executions = executions;
+  }
   snapshot() {
     return structuredClone(this.runs);
   }
   restore(snapshot) {
     this.runs.clear();
-    for (const [key, record] of structuredClone(snapshot)) {
-      this.runs.set(key, record);
+    for (const [key2, record] of structuredClone(snapshot)) {
+      this.runs.set(key2, record);
     }
   }
   async start(input) {
-    const key = storageKey(input.projectId, input.id);
-    if (this.runs.has(key)) {
-      throw new WebhookRunError(`[Sixb] Webhook run '${input.id}' already exists for project '${input.projectId}'.`);
+    await assertWebhookRunExecution({
+      executions: this.executions,
+      projectId: input.projectId,
+      executionId: input.executionId,
+      runId: input.id,
+      route: input.route
+    });
+    const key2 = storageKey(input.projectId, input.id);
+    if (this.runs.has(key2) || this.findByDelivery(input)) {
+      throw new WebhookRunError(`[Sixb] Webhook run '${input.id}' or delivery key already exists for project '${input.projectId}'.`, "duplicate_run");
     }
     const record = {
       id: input.id,
       projectId: input.projectId,
+      executionId: input.executionId,
       connectorId: input.connectorId,
       webhookId: input.webhookId,
       status: "running",
       method: input.method,
       route: input.route,
-      startedAt: new Date(input.startedAt ?? new Date)
+      startedAt: new Date(input.startedAt ?? new Date),
+      requestBodyBytes: input.requestBodyBytes,
+      requestBodySha256: input.requestBodySha256,
+      idempotencyKey: input.idempotencyKey
     };
-    this.runs.set(key, cloneRecord(record));
+    this.runs.set(key2, cloneRecord(record));
     return cloneRecord(record);
   }
+  async restart(input) {
+    const existing = this.requireWebhookRun(input.projectId, input.id);
+    if (!canRetryWebhookRun(existing)) {
+      throw new WebhookRunError(`[Sixb] Webhook run '${input.id}' cannot restart from status '${existing.status}'.`, "invalid_transition");
+    }
+    const next = {
+      ...existing,
+      status: "running",
+      startedAt: new Date(input.startedAt ?? new Date),
+      finishedAt: undefined,
+      responseStatus: undefined,
+      error: undefined
+    };
+    this.runs.set(storageKey(input.projectId, input.id), cloneRecord(next));
+    return cloneRecord(next);
+  }
   async finish(input) {
     const existing = this.requireRunningWebhookRun(input.projectId, input.id);
     const next = {
       ...existing,
       status: input.status,
       finishedAt: new Date(input.finishedAt ?? new Date),
-      requestBodyBytes: input.requestBodyBytes,
       responseStatus: input.responseStatus,
-      idempotencyKey: input.idempotencyKey,
-      deliveryClaimResult: input.deliveryClaimResult,
-      error: input.status === "succeeded" ? undefined : input.error
+      error: input.status === "failed" ? parseSixbFailure(input.error, WEBHOOK_RUN_FAILURE_CODES) : undefined
     };
     this.runs.set(storageKey(input.projectId, input.id), cloneRecord(next));
     return cloneRecord(next);
@@ -4189,6 +5940,10 @@ class InMemoryWebhookRunStorage {
     const record = this.runs.get(storageKey(params.projectId, params.id));
     return record ? cloneRecord(record) : null;
   }
+  async getByDelivery(input) {
+    const record = this.findByDelivery(input);
+    return record ? cloneRecord(record) : null;
+  }
   async list(input) {
     if (hasEmptyStatuses(input)) {
       return {
@@ -4211,16 +5966,25 @@ class InMemoryWebhookRunStorage {
       total
     };
   }
-  requireRunningWebhookRun(projectId, id) {
+  requireWebhookRun(projectId, id) {
     const record = this.runs.get(storageKey(projectId, id));
     if (!record) {
-      throw new WebhookRunError(`[Sixb] Webhook run '${id}' not found for project '${projectId}'.`);
+      throw new WebhookRunError(`[Sixb] Webhook run '${id}' not found for project '${projectId}'.`, "not_found");
     }
+    return record;
+  }
+  requireRunningWebhookRun(projectId, id) {
+    const record = this.requireWebhookRun(projectId, id);
     if (record.status !== "running") {
-      throw new WebhookRunError(`[Sixb] Webhook run '${id}' for project '${projectId}' is already terminal.`);
+      throw new WebhookRunError(`[Sixb] Webhook run '${id}' for project '${projectId}' is already terminal.`, "invalid_transition");
     }
     return record;
   }
+  findByDelivery(input) {
+    if (input.idempotencyKey === undefined)
+      return;
+    return [...this.runs.values()].find((run) => run.projectId === input.projectId && run.connectorId === input.connectorId && run.webhookId === input.webhookId && run.idempotencyKey === input.idempotencyKey);
+  }
 }
 // src/storage/workflow-interventions/errors.ts
 class WorkflowInterventionError extends Error {
@@ -4240,14 +6004,14 @@ class InMemoryWorkflowInterventionStorage {
   }
   restore(snapshot) {
     this.interventions.clear();
-    for (const [key, record] of structuredClone(snapshot)) {
-      this.interventions.set(key, record);
+    for (const [key2, record] of structuredClone(snapshot)) {
+      this.interventions.set(key2, record);
     }
   }
   async create(input) {
     assertNonNegativeInteger2(input.nodeIndex, "nodeIndex");
-    const key = storageKey(input.projectId, input.id);
-    if (this.interventions.has(key)) {
+    const key2 = storageKey(input.projectId, input.id);
+    if (this.interventions.has(key2)) {
       throw new WorkflowInterventionError(`[Sixb] Workflow intervention '${input.id}' already exists for project '${input.projectId}'.`);
     }
     const record = {
@@ -4266,7 +6030,7 @@ class InMemoryWorkflowInterventionStorage {
       requestedAt: new Date(input.requestedAt ?? new Date),
       expiresAt: input.expiresAt ? new Date(input.expiresAt) : undefined
     };
-    this.interventions.set(key, cloneRecord(record));
+    this.interventions.set(key2, cloneRecord(record));
     return cloneRecord(record);
   }
   async submit(input) {
@@ -4346,11 +6110,20 @@ function compareRequestedAt(left, right, order) {
   }
   return order === "asc" ? left.id.localeCompare(right.id) : right.id.localeCompare(left.id);
 }
-// src/storage/workflow-runs/errors.ts
-class WorkflowRunError extends Error {
-  name = "WorkflowRunError";
-}
+// src/storage/workflow-runs/types.ts
+var WORKFLOW_RUN_FAILURE_CODES = [
+  "internal.unexpected",
+  "runtime.cancelled",
+  "workflow.node_failed"
+];
+
 // src/storage/workflow-runs/in-memory.ts
+function normalizeFailure2(failure) {
+  return failure ? parseSixbFailure(failure, WORKFLOW_RUN_FAILURE_CODES) : undefined;
+}
+function normalizeAgentFailure(failure) {
+  return failure ? parseSixbFailure(failure, AGENT_RUN_FAILURE_CODES) : undefined;
+}
 function assertNonNegativeInteger3(value, fieldName) {
   if (!Number.isInteger(value) || value < 0) {
     throw new WorkflowRunError(`[Sixb] Workflow run ${fieldName} must be a non-negative integer.`);
@@ -4358,18 +6131,21 @@ function assertNonNegativeInteger3(value, fieldName) {
 }
 
 class InMemoryWorkflowRunStorage {
+  executions;
   nodes;
   agentNodes;
   runs = new Map;
-  constructor() {
+  constructor(executions) {
+    this.executions = executions;
     this.nodes = new InMemoryWorkflowNodeRunStorage({
       requireRunningWorkflowRun: (projectId, id) => this.requireRunningWorkflowRun(projectId, id),
       requireActiveWorkflowRun: (projectId, id) => this.requireActiveWorkflowRun(projectId, id),
       assertExecutionOwnership: (projectId, id, token) => this.assertExecutionOwnership(projectId, id, token)
     });
     this.agentNodes = new InMemoryWorkflowAgentNodeRunStorage({
-      requireAgentNodeRun: (projectId, id) => this.nodes.requireAgentNodeRun(projectId, id)
-    });
+      requireAgentNodeRun: (projectId, id) => this.nodes.requireAgentNodeRun(projectId, id),
+      requireWorkflowRun: (projectId, id) => this.requireExistingWorkflowRun(projectId, id)
+    }, this.executions);
   }
   snapshot() {
     return {
@@ -4380,71 +6156,60 @@ class InMemoryWorkflowRunStorage {
   }
   restore(snapshot) {
     this.runs.clear();
-    for (const [key, record] of structuredClone(snapshot.runs)) {
-      this.runs.set(key, record);
+    for (const [key2, record] of structuredClone(snapshot.runs)) {
+      this.runs.set(key2, record);
     }
     this.nodes.restore(snapshot.nodes);
     this.agentNodes.restore(snapshot.agentNodes);
   }
   async queue(input) {
-    const key = storageKey(input.projectId, input.id);
-    if (this.runs.has(key)) {
+    const key2 = storageKey(input.projectId, input.id);
+    if (this.runs.has(key2)) {
       throw new WorkflowRunError(`[Sixb] Workflow run '${input.id}' already exists for project '${input.projectId}'.`);
     }
+    if ([...this.runs.values()].some((run) => run.projectId === input.projectId && run.executionId === input.executionId)) {
+      throw new WorkflowRunError(`[Sixb] Execution '${input.executionId}' already belongs to another workflow run.`);
+    }
+    await assertWorkflowRunExecution({
+      executions: this.executions,
+      projectId: input.projectId,
+      executionId: input.executionId,
+      runId: input.id,
+      workflowId: input.workflowId
+    });
     const queuedAt = new Date(input.queuedAt ?? new Date);
     const record = {
       id: input.id,
       projectId: input.projectId,
+      executionId: input.executionId,
       workflowId: input.workflowId,
       status: "queued",
       input: cloneRecord(input.input),
       queuedAt,
       startedAt: queuedAt,
       attempt: 0,
-      requestedByPrincipal: cloneRecord(input.requestedByPrincipal ?? SYSTEM_PRINCIPAL),
-      ...input.source ? { source: cloneRecord(input.source) } : {}
+      requesterGroupIds: normalizeRequesterGroupIds(input.requesterGroupIds)
     };
-    this.runs.set(key, cloneRecord(record));
+    this.runs.set(key2, cloneRecord(record));
     return cloneRecord(record);
   }
   async start(input) {
-    const key = storageKey(input.projectId, input.id);
-    const existing = this.runs.get(key);
-    if (existing) {
-      if (existing.status !== "queued") {
-        throw new WorkflowRunError(`[Sixb] Workflow run '${input.id}' already exists for project '${input.projectId}'.`);
-      }
-      if (existing.workflowId !== input.workflowId) {
-        throw new WorkflowRunError(`[Sixb] Workflow run '${input.id}' workflow '${input.workflowId}' does not match existing workflow '${existing.workflowId}'.`);
-      }
-      const next = {
-        ...existing,
-        status: "running",
-        input: cloneRecord(input.input),
-        startedAt: new Date(input.startedAt ?? new Date),
-        finishedAt: undefined,
-        error: undefined,
-        source: existing.source ?? (input.source === undefined ? undefined : cloneRecord(input.source)),
-        attempt: existing.attempt + 1,
-        execution: input.execution ? cloneRecord(input.execution) : undefined
-      };
-      this.runs.set(key, cloneRecord(next));
-      return cloneRecord(next);
+    const key2 = storageKey(input.projectId, input.id);
+    const existing = this.runs.get(key2);
+    if (!existing || existing.status !== "queued") {
+      throw new WorkflowRunError(existing ? `[Sixb] Workflow run '${input.id}' cannot start from status '${existing.status}'.` : `[Sixb] Workflow run '${input.id}' not found for project '${input.projectId}'.`);
     }
-    const record = {
-      id: input.id,
-      projectId: input.projectId,
-      workflowId: input.workflowId,
+    const next = {
+      ...existing,
       status: "running",
-      input: cloneRecord(input.input),
       startedAt: new Date(input.startedAt ?? new Date),
-      attempt: 1,
-      requestedByPrincipal: cloneRecord(input.requestedByPrincipal ?? SYSTEM_PRINCIPAL),
-      ...input.execution ? { execution: cloneRecord(input.execution) } : {},
-      ...input.source ? { source: cloneRecord(input.source) } : {}
+      finishedAt: undefined,
+      error: undefined,
+      attempt: existing.attempt + 1,
+      execution: input.execution ? cloneRecord(input.execution) : undefined
     };
-    this.runs.set(key, cloneRecord(record));
-    return cloneRecord(record);
+    this.runs.set(key2, cloneRecord(next));
+    return cloneRecord(next);
   }
   async finish(input) {
     const existing = this.requireFinishableWorkflowRun(input);
@@ -4462,7 +6227,7 @@ class InMemoryWorkflowRunStorage {
     } : {
       ...base,
       output: undefined,
-      error: input.error
+      error: normalizeFailure2(input.error)
     };
     this.runs.set(storageKey(input.projectId, input.id), cloneRecord(next));
     return cloneRecord(next);
@@ -4611,8 +6376,8 @@ class InMemoryWorkflowNodeRunStorage {
   }
   restore(snapshot) {
     this.nodes.clear();
-    for (const [key, record] of structuredClone(snapshot)) {
-      this.nodes.set(key, record);
+    for (const [key2, record] of structuredClone(snapshot)) {
+      this.nodes.set(key2, record);
     }
   }
   async start(input) {
@@ -4622,8 +6387,8 @@ class InMemoryWorkflowNodeRunStorage {
     if (workflowRun.workflowId !== input.workflowId) {
       throw new WorkflowRunError(`[Sixb] Workflow node run '${input.id}' workflow '${input.workflowId}' does not match workflow run '${input.workflowRunId}' workflow '${workflowRun.workflowId}'.`);
     }
-    const key = storageKey(input.projectId, input.id);
-    if (this.nodes.has(key)) {
+    const key2 = storageKey(input.projectId, input.id);
+    if (this.nodes.has(key2)) {
       throw new WorkflowRunError(`[Sixb] Workflow node run '${input.id}' already exists for project '${input.projectId}'.`);
     }
     const record = {
@@ -4639,7 +6404,7 @@ class InMemoryWorkflowNodeRunStorage {
       input: cloneRecord(input.input),
       startedAt: new Date(input.startedAt ?? new Date)
     };
-    this.nodes.set(key, cloneRecord(record));
+    this.nodes.set(key2, cloneRecord(record));
     return cloneRecord(record);
   }
   async finish(input) {
@@ -4657,7 +6422,7 @@ class InMemoryWorkflowNodeRunStorage {
     } : {
       ...base,
       output: undefined,
-      error: input.error
+      error: normalizeFailure2(input.error)
     };
     this.nodes.set(storageKey(input.projectId, input.id), cloneRecord(next));
     return cloneRecord(next);
@@ -4736,37 +6501,52 @@ class InMemoryWorkflowNodeRunStorage {
 
 class InMemoryWorkflowAgentNodeRunStorage {
   nodes;
+  executions;
   runs = new Map;
-  constructor(nodes) {
+  constructor(nodes, executions) {
     this.nodes = nodes;
+    this.executions = executions;
   }
   snapshot() {
     return structuredClone(this.runs);
   }
   restore(snapshot) {
     this.runs.clear();
-    for (const [key, record] of structuredClone(snapshot))
-      this.runs.set(key, record);
+    for (const [key2, record] of structuredClone(snapshot))
+      this.runs.set(key2, record);
   }
   async create(input) {
     const node = this.nodes.requireAgentNodeRun(input.projectId, input.nodeRunId);
+    const workflowRun = this.nodes.requireWorkflowRun(input.projectId, node.workflowRunId);
+    await assertWorkflowAgentNodeRunExecution({
+      executions: this.executions,
+      projectId: input.projectId,
+      executionId: input.executionId,
+      nodeRunId: input.nodeRunId,
+      agentId: input.agentId,
+      workflowExecutionId: workflowRun.executionId
+    });
     if (node.status !== "running") {
       throw new WorkflowRunError(`[Sixb] Agent workflow node run '${input.nodeRunId}' must be running when queued.`);
     }
-    const key = storageKey(input.projectId, input.nodeRunId);
-    if (this.runs.has(key)) {
+    const key2 = storageKey(input.projectId, input.nodeRunId);
+    if (this.runs.has(key2)) {
       throw new WorkflowRunError(`[Sixb] Agent execution already exists for workflow node run '${input.nodeRunId}'.`);
     }
+    if ([...this.runs.values()].some((run) => run.projectId === input.projectId && run.executionId === input.executionId)) {
+      throw new WorkflowRunError(`[Sixb] Execution '${input.executionId}' already belongs to another Workflow Agent-node run.`);
+    }
     const record = {
       projectId: input.projectId,
       nodeRunId: input.nodeRunId,
+      executionId: input.executionId,
       agentId: input.agentId,
       status: "queued",
       prompt: input.prompt,
       attempt: 0,
       createdAt: new Date(input.createdAt ?? new Date)
     };
-    this.runs.set(key, cloneRecord(record));
+    this.runs.set(key2, cloneRecord(record));
     return cloneRecord(record);
   }
   async start(input) {
@@ -4774,7 +6554,6 @@ class InMemoryWorkflowAgentNodeRunStorage {
     const next = {
       ...run,
       status: "running",
-      ...input.executionPrincipal ? { executionPrincipal: cloneRecord(input.executionPrincipal) } : {},
       ...input.modelId ? { modelId: input.modelId } : {},
       attempt: 1,
       execution: cloneRecord(input.execution),
@@ -4803,10 +6582,9 @@ class InMemoryWorkflowAgentNodeRunStorage {
       status: input.status,
       ...input.modelId === undefined ? {} : { modelId: input.modelId },
       ...input.finishReason === undefined ? {} : { finishReason: input.finishReason },
-      ...input.usage === undefined ? {} : { usage: cloneRecord(input.usage) },
       ...input.trace === undefined ? {} : { trace: cloneRecord(input.trace) },
       ...input.diagnostics === undefined ? {} : { diagnostics: cloneRecord(input.diagnostics) },
-      ...input.status === "succeeded" || input.error === undefined ? {} : { error: input.error },
+      ...input.status === "succeeded" || input.error === undefined ? {} : { error: normalizeAgentFailure(input.error) },
       execution: undefined,
       completedAt: new Date(input.completedAt ?? new Date)
     });
@@ -4820,7 +6598,7 @@ class InMemoryWorkflowAgentNodeRunStorage {
       ...run,
       status: "cancelled",
       execution: undefined,
-      error: input.error,
+      error: normalizeAgentFailure(input.error),
       completedAt: new Date(input.completedAt ?? new Date)
     });
   }
@@ -4878,50 +6656,60 @@ class InMemoryStorage {
   timeseriesStorage = new InMemoryTimeseriesStorage;
   ontologyStorage;
   authStorage = new InMemoryAuthStorage;
-  agentStorage = new InMemoryAgentStorage;
-  actionRunStorage = new InMemoryActionRunStorage;
-  syncRunStorage = new InMemorySyncRunStorage;
-  pipelineRunStorage = new InMemoryPipelineRunStorage;
-  projectionRunStorage = new InMemoryProjectionRunStorage;
-  workflowRunStorage = new InMemoryWorkflowRunStorage;
+  executionStorage = new InMemoryExecutionStorage(this.authStorage);
+  agentStorage = new InMemoryAgentStorage(this.executionStorage);
+  aiUsageStorage = new InMemoryAiUsageStorage(this.executionStorage);
+  actionRunStorage = new InMemoryActionRunStorage(this.executionStorage);
+  syncRunStorage = new InMemorySyncRunStorage(this.executionStorage);
+  pipelineRunStorage = new InMemoryPipelineRunStorage(this.executionStorage);
+  projectionRunStorage = new InMemoryProjectionRunStorage({
+    executions: this.executionStorage
+  });
+  workflowRunStorage = new InMemoryWorkflowRunStorage(this.executionStorage);
   workflowInterventionStorage = new InMemoryWorkflowInterventionStorage;
-  webhookDeliveryStorage = new InMemoryWebhookDeliveryStorage;
-  webhookRunStorage = new InMemoryWebhookRunStorage;
+  webhookRunStorage = new InMemoryWebhookRunStorage(this.executionStorage);
   rulesStorage = new InMemoryRulesStorage;
   fileUploadSessionStorage = new InMemoryFileUploadSessions;
+  connectorConnectionStorage;
   auth;
+  executions;
   agents;
+  aiUsage;
   actionRuns;
   syncRuns;
   pipelineRuns;
   projectionRuns;
   workflowRuns;
   workflowInterventions;
-  webhookDeliveries;
   webhookRuns;
   rules;
   fileUploadSessions;
-  constructor() {
+  connectorConnections;
+  constructor(options = {}) {
+    this.connectorConnectionStorage = new InMemoryConnectorConnectionStorage(options.connectorConnections);
     const scope = createStorageOperationScope((run) => this.withStorageOperation(run), () => this.assertRootOperationAvailable());
     this.objects = createOperationScopedFacade(this.objectStorage, scope);
     this.timeseries = createOperationScopedFacade(this.timeseriesStorage, scope);
     this.auth = createAuthOperationScope(this.authStorage, scope);
+    this.executions = createOperationScopedFacade(this.executionStorage, scope);
     this.agents = createAgentOperationScope(this.agentStorage, scope);
+    this.aiUsage = createOperationScopedFacade(this.aiUsageStorage, scope);
     this.actionRuns = createOperationScopedFacade(this.actionRunStorage, scope);
     this.syncRuns = createOperationScopedFacade(this.syncRunStorage, scope);
     this.pipelineRuns = createOperationScopedFacade(this.pipelineRunStorage, scope);
     this.projectionRuns = createOperationScopedFacade(this.projectionRunStorage, scope);
     this.workflowRuns = createWorkflowRunOperationScope(this.workflowRunStorage, scope);
     this.workflowInterventions = createOperationScopedFacade(this.workflowInterventionStorage, scope);
-    this.webhookDeliveries = createOperationScopedFacade(this.webhookDeliveryStorage, scope);
     this.webhookRuns = createOperationScopedFacade(this.webhookRunStorage, scope);
     this.rules = createOperationScopedFacade(this.rulesStorage, scope);
     this.fileUploadSessions = createOperationScopedFacade(this.fileUploadSessionStorage, scope);
+    this.connectorConnections = createOperationScopedFacade(this.connectorConnectionStorage, scope);
     this.ontologyStorage = new InMemoryOntologyStorage(this.objectStorage, this.timeseriesStorage, {
       runRootOperation: async (run) => run(),
       getTransactionToken: () => this.getActiveTransactionToken(),
       getMaterializationLifecycle: () => this.getActiveMaterializationLifecycle(),
-      assertSourceMaterializationExecution: (input) => this.projectionRunStorage.assertSourceMaterializationExecutionUnlocked(input)
+      assertSourceMaterializationExecution: (input) => this.projectionRunStorage.assertSourceMaterializationExecutionUnlocked(input),
+      executionExists: async (projectId, executionId) => await this.executionStorage.getById({ projectId, id: executionId }) !== null
     });
     this.ontology = createOntologyOperationScope(this.ontologyStorage, scope);
     this.ontologyStorage.registerTestingAlias(this.ontology);
@@ -5004,17 +6792,19 @@ class InMemoryStorage {
       timeseries: this.timeseriesStorage,
       ontology: this.ontologyStorage,
       auth: this.authStorage,
+      executions: this.executionStorage,
       agents: this.agentStorage,
+      aiUsage: this.aiUsageStorage,
       actionRuns: this.actionRunStorage,
       syncRuns: this.syncRunStorage,
       pipelineRuns: this.pipelineRunStorage,
       projectionRuns: this.projectionRunStorage,
       workflowRuns: this.workflowRunStorage,
       workflowInterventions: this.workflowInterventionStorage,
-      webhookDeliveries: this.webhookDeliveryStorage,
       webhookRuns: this.webhookRunStorage,
       rules: this.rulesStorage,
       fileUploadSessions: this.fileUploadSessionStorage,
+      connectorConnections: this.connectorConnectionStorage,
       ping: async () => {
         return;
       },
@@ -5029,17 +6819,19 @@ class InMemoryStorage {
       timeseries: this.timeseriesStorage.snapshot(),
       ontology: this.ontologyStorage.snapshot(),
       auth: this.authStorage.snapshot(),
+      executions: this.executionStorage.snapshot(),
       agents: this.agentStorage.snapshot(),
+      aiUsage: this.aiUsageStorage.snapshot(),
       actionRuns: this.actionRunStorage.snapshot(),
       syncRuns: this.syncRunStorage.snapshot(),
       pipelineRuns: this.pipelineRunStorage.snapshot(),
       projectionRuns: this.projectionRunStorage.snapshot(),
       workflowRuns: this.workflowRunStorage.snapshot(),
       workflowInterventions: this.workflowInterventionStorage.snapshot(),
-      webhookDeliveries: this.webhookDeliveryStorage.snapshot(),
       webhookRuns: this.webhookRunStorage.snapshot(),
       rules: this.rulesStorage.snapshot(),
-      fileUploadSessions: this.fileUploadSessionStorage.snapshot()
+      fileUploadSessions: this.fileUploadSessionStorage.snapshot(),
+      connectorConnections: this.connectorConnectionStorage.snapshot()
     };
   }
   restore(snapshot) {
@@ -5047,17 +6839,19 @@ class InMemoryStorage {
     this.timeseriesStorage.restore(snapshot.timeseries);
     this.ontologyStorage.restore(snapshot.ontology);
     this.authStorage.restore(snapshot.auth);
+    this.executionStorage.restore(snapshot.executions);
     this.agentStorage.restore(snapshot.agents);
+    this.aiUsageStorage.restore(snapshot.aiUsage);
     this.actionRunStorage.restore(snapshot.actionRuns);
     this.syncRunStorage.restore(snapshot.syncRuns);
     this.pipelineRunStorage.restore(snapshot.pipelineRuns);
     this.projectionRunStorage.restore(snapshot.projectionRuns);
     this.workflowRunStorage.restore(snapshot.workflowRuns);
     this.workflowInterventionStorage.restore(snapshot.workflowInterventions);
-    this.webhookDeliveryStorage.restore(snapshot.webhookDeliveries);
     this.webhookRunStorage.restore(snapshot.webhookRuns);
     this.rulesStorage.restore(snapshot.rules);
     this.fileUploadSessionStorage.restore(snapshot.fileUploadSessions);
+    this.connectorConnectionStorage.restore(snapshot.connectorConnections);
   }
 }
 // src/storage/migrations/migrate-storage.ts
@@ -5269,6 +7063,6 @@ function assertAppliedPrefix(migrations, rows) {
   }
   return [...rows].sort((a, b) => a.version - b.version);
 }
-export { ActionRunError, actionSubjectsEqual, actionRunParamsEqual, actionRunPhaseRecordsEqual, finishActionRunPhase, canRequeueActionRunAfterEnqueueFailure, isTerminalActionRun, InMemoryActionRunStorage, ObjectNotFoundError, ObjectStorageError, StorageTransactionError, isStorageSerializationFailure, FileUploadSessionError, DEFAULT_FILE_UPLOAD_SESSION_TTL_MS, DEFAULT_FILE_UPLOAD_TERMINAL_SESSION_TTL_MS, createUploadExpiresAt, createFileUploadId, InMemoryFileUploadSessions, PipelineRunError, InMemoryPipelineRunStorage, InMemoryProjectionRunStorage, InMemoryRulesStorage, SyncRunError, InMemorySyncRunStorage, createTransactionStorageProxy, assertTransactionActive, throwNestedStorageTransaction, InMemoryWebhookDeliveryStorage, WebhookRunError, InMemoryWebhookRunStorage, WorkflowInterventionError, InMemoryWorkflowInterventionStorage, WorkflowRunError, InMemoryWorkflowRunStorage, InMemoryWorkflowNodeRunStorage, InMemoryWorkflowAgentNodeRunStorage, InMemoryStorage, isMigrationCapableStorage, migrateStorage, checkStorageSchema, step, defineMigrations, runMigrationSet, describeMigrationHistory };
+export { actionSubjectsEqual, actionRunParamsEqual, actionRunPhaseRecordsEqual, finishActionRunPhase, canRequeueActionRunAfterEnqueueFailure, isTerminalActionRun, InMemoryActionRunStorage, AGENT_MESSAGE_CONTENT_VERSION, InMemoryAgentStorage, AiUsageStorageError, normalizeAiModelCallUsage, aggregateAiModelCallUsage, normalizeAiModelCallRecord, assertAiUsageExecutionId, InMemoryAiUsageStorage, InMemoryConnectorConnectionStorage, ObjectNotFoundError, ObjectStorageError, StorageTransactionError, isStorageSerializationFailure, FileUploadSessionError, DEFAULT_FILE_UPLOAD_SESSION_TTL_MS, DEFAULT_FILE_UPLOAD_TERMINAL_SESSION_TTL_MS, createUploadExpiresAt, createFileUploadId, InMemoryFileUploadSessions, canRequeuePipelineRunAfterEnqueueFailure, PIPELINE_RUN_FAILURE_CODES, InMemoryPipelineRunStorage, InMemoryProjectionRunStorage, InMemoryRulesStorage, canRequeueSyncRunAfterEnqueueFailure, SYNC_RUN_FAILURE_CODES, InMemorySyncRunStorage, createTransactionStorageProxy, assertTransactionActive, throwNestedStorageTransaction, WEBHOOK_RUN_FAILURE_CODES, canRetryWebhookRun, InMemoryWebhookRunStorage, WorkflowInterventionError, InMemoryWorkflowInterventionStorage, WORKFLOW_RUN_FAILURE_CODES, InMemoryWorkflowRunStorage, InMemoryWorkflowNodeRunStorage, InMemoryWorkflowAgentNodeRunStorage, InMemoryStorage, isMigrationCapableStorage, migrateStorage, checkStorageSchema, step, defineMigrations, runMigrationSet, describeMigrationHistory };
 
-//# debugId=C433A1A4FF67E92364756E2164756E21
+//# debugId=0974A6B3A889270064756E2164756E21