@sixb/core 0.1.11 → 0.1.13

package/src/edits/types.ts

@@ -114,25 +114,24 @@ export type EditablePropertyId<TObjectType extends ObjectType> =
 
 type StaticPropertyMap<
   TProperties extends readonly Property[],
-  TValueTypes extends readonly ValueType[],
   TMode extends "create" | "update",
 > = string extends TProperties[number]["id"]
   ? Record<string, unknown>
   : Simplify<{
       [TProp in TProperties[number] as TMode extends "create"
         ? CreatablePropertyId<TProp>
-        : SettablePropertyId<TProp>]?: InferPropertyValue<TProp, TValueTypes>
+        : SettablePropertyId<TProp>]?: InferPropertyValue<TProp>
     }>
 
-export type EditCreateProperties<
-  TObjectType extends ObjectType,
-  TValueTypes extends readonly ValueType[] = [],
-> = StaticPropertyMap<TObjectType["properties"], TValueTypes, "create">
+export type EditCreateProperties<TObjectType extends ObjectType> = StaticPropertyMap<
+  TObjectType["properties"],
+  "create"
+>
 
-export type EditUpdateProperties<
-  TObjectType extends ObjectType,
-  TValueTypes extends readonly ValueType[] = [],
-> = StaticPropertyMap<TObjectType["properties"], TValueTypes, "update">
+export type EditUpdateProperties<TObjectType extends ObjectType> = StaticPropertyMap<
+  TObjectType["properties"],
+  "update"
+>
 
 type LinkProperties<TLink extends { properties?: readonly Property[] }> = TLink extends {
   properties: infer TProperties extends readonly Property[]
@@ -147,23 +146,18 @@ type RequiredLinkPropertyId<TProperty extends Property> = TProperty extends { re
   ? LinkPropertyId<TProperty>
   : never
 
-type EditLinkProperties<
-  TLink extends { properties?: readonly Property[] },
-  TValueTypes extends readonly ValueType[],
-> = string extends LinkProperties<TLink>[number]["id"]
-  ? Record<string, unknown>
-  : Simplify<
-      {
-        [TProp in LinkProperties<TLink>[number] as RequiredLinkPropertyId<TProp>]: InferPropertyValue<
-          TProp,
-          TValueTypes
-        >
-      } & {
-        [TProp in LinkProperties<TLink>[number] as TProp extends { required: true }
-          ? never
-          : LinkPropertyId<TProp>]?: InferPropertyValue<TProp, TValueTypes>
-      }
-    >
+type EditLinkProperties<TLink extends { properties?: readonly Property[] }> =
+  string extends LinkProperties<TLink>[number]["id"]
+    ? Record<string, unknown>
+    : Simplify<
+        {
+          [TProp in LinkProperties<TLink>[number] as RequiredLinkPropertyId<TProp>]: InferPropertyValue<TProp>
+        } & {
+          [TProp in LinkProperties<TLink>[number] as TProp extends { required: true }
+            ? never
+            : LinkPropertyId<TProp>]?: InferPropertyValue<TProp>
+        }
+      >
 
 type RequiredLinkPropertyIds<TLink extends { properties?: readonly Property[] }> =
   LinkProperties<TLink>[number] extends infer TProperty extends Property
@@ -191,34 +185,32 @@ type EditLinkTargetRef<TLinkToken extends LinkToken<string, string, string | rea
     ? EditObjectRef<string>
     : EditObjectRef<ResolveTargetObjectTypeId<TLinkToken["targetObjectTypeId"]>>
 
-type EditLinkOptionsArg<
-  TLinkToken extends LinkToken<string, string, string | readonly string[]>,
-  TValueTypes extends readonly ValueType[],
-> = string extends TLinkToken["id"]
-  ? [options?: { readonly properties?: Readonly<Record<string, unknown>> }]
-  : HasLinkProperties<TLinkToken["link"]> extends false
-    ? [options?: { readonly properties?: never }]
-    : HasRequiredLinkProperties<TLinkToken["link"]> extends true
-      ? [
-          options: {
-            readonly properties: EditLinkProperties<TLinkToken["link"], TValueTypes>
-          },
-        ]
-      : [
-          options?: {
-            readonly properties?: EditLinkProperties<TLinkToken["link"], TValueTypes>
-          },
-        ]
+type EditLinkOptionsArg<TLinkToken extends LinkToken<string, string, string | readonly string[]>> =
+  string extends TLinkToken["id"]
+    ? [options?: { readonly properties?: Readonly<Record<string, unknown>> }]
+    : HasLinkProperties<TLinkToken["link"]> extends false
+      ? [options?: { readonly properties?: never }]
+      : HasRequiredLinkProperties<TLinkToken["link"]> extends true
+        ? [
+            options: {
+              readonly properties: EditLinkProperties<TLinkToken["link"]>
+            },
+          ]
+        : [
+            options?: {
+              readonly properties?: EditLinkProperties<TLinkToken["link"]>
+            },
+          ]
 
 export interface RecordEditsOptions {
   readonly runId: string
   readonly valueTypesById?: ReadonlyMap<string, ValueType>
 }
 
-export interface RecordEditsContext<TValueTypes extends readonly ValueType[] = []> {
+export interface RecordEditsContext {
   objects<const TObjectType extends ObjectTypeWithPropertyTokens>(
     objectType: TObjectType
-  ): EditObjectSetRecorder<TObjectType, TValueTypes>
+  ): EditObjectSetRecorder<TObjectType>
 }
 
 export type RecordEditsHandlerResult = ReturnType<() => void>
@@ -226,26 +218,18 @@ export type RecordEditsHandlerResult = ReturnType<() => void>
 export type RecordEditsHandlerReturn = RecordEditsHandlerResult | Promise<RecordEditsHandlerResult>
 
 export type RecordEditsHandler<
-  TValueTypes extends readonly ValueType[] = [],
   TResult extends RecordEditsHandlerReturn = RecordEditsHandlerReturn,
-> = (ctx: RecordEditsContext<TValueTypes>) => TResult
+> = (ctx: RecordEditsContext) => TResult
 
-export interface EditObjectSetRecorder<
-  TObjectType extends ObjectType,
-  TValueTypes extends readonly ValueType[] = [],
-> {
-  byId(primaryId: string): EditObjectHandle<TObjectType, TValueTypes>
+export interface EditObjectSetRecorder<TObjectType extends ObjectType> {
+  byId(primaryId: string): EditObjectHandle<TObjectType>
 
-  create(
-    properties: EditCreateProperties<TObjectType, TValueTypes>
-  ): EditObjectHandle<TObjectType, TValueTypes>
+  create(properties: EditCreateProperties<TObjectType>): EditObjectHandle<TObjectType>
 }
 
-export interface EditObjectHandle<
-  TObjectType extends ObjectType = ObjectType,
-  TValueTypes extends readonly ValueType[] = [],
-> extends TypedEditObjectRef<TObjectType> {
-  update(properties: EditUpdateProperties<TObjectType, TValueTypes>): void
+export interface EditObjectHandle<TObjectType extends ObjectType = ObjectType>
+  extends TypedEditObjectRef<TObjectType> {
+  update(properties: EditUpdateProperties<TObjectType>): void
 
   /** Clears managed values, leaving the property absent from managed authority. */
   unset(...propertyIds: readonly EditablePropertyId<TObjectType>[]): void
@@ -260,7 +244,7 @@ export interface EditObjectHandle<
   link<const TLinkToken extends LinkToken<TObjectType["id"], string, string | readonly string[]>>(
     link: TLinkToken,
     target: EditLinkTargetRef<TLinkToken>,
-    ...options: EditLinkOptionsArg<TLinkToken, TValueTypes>
+    ...options: EditLinkOptionsArg<TLinkToken>
   ): void
 
   unlink<const TLinkToken extends LinkToken<TObjectType["id"], string, string | readonly string[]>>(

package/src/error-reporting/capability.ts

@@ -4,10 +4,12 @@ import {
   type ReportEventDeliveryFailureInput,
   type ReportRuleEvaluationFailureInput,
   type ReportRunFailureInput,
+  type ReportVectorIndexingFailureInput,
   reportActionPhaseFailure as reportActionPhaseFailureWith,
   reportEventDeliveryFailure as reportEventDeliveryFailureWith,
   reportRuleEvaluationFailure as reportRuleEvaluationFailureWith,
   reportRunFailure as reportRunFailureWith,
+  reportVectorIndexingFailure as reportVectorIndexingFailureWith,
 } from "./reports"
 import type { SixbErrorHandler } from "./types"
 
@@ -48,6 +50,7 @@ export type {
   ReportEventDeliveryFailureInput,
   ReportRuleEvaluationFailureInput,
   ReportRunFailureInput,
+  ReportVectorIndexingFailureInput,
 }
 
 export function reportActionPhaseFailure(
@@ -85,3 +88,11 @@ export function reportRuleEvaluationFailure(
 export async function flushSixbErrors(host: unknown, timeoutMs?: number): Promise<void> {
   await resolveSixbErrorReporter(host).flush(timeoutMs)
 }
+
+export function reportVectorIndexingFailure(
+  host: object,
+  error: unknown,
+  input: ReportVectorIndexingFailureInput
+): void {
+  reportVectorIndexingFailureWith(resolveSixbErrorReporter(host), error, input)
+}

package/src/error-reporting/reports.ts

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto"
 import { captureSixbFailure } from "../errors/internal"
 import type { SixbFailure } from "../errors/types"
 import type { ActionRunFailure } from "../storage/action-runs"
+import type { VectorIndexingFailureCode } from "../storage/ontology/vector-indexing"
 import type { ErrorReporter } from "./reporter"
 import type { SixbFailedRun } from "./types"
 
@@ -170,3 +171,25 @@ export function reportRuleEvaluationFailure(
     ...(input.subject === undefined ? {} : { subject: input.subject }),
   })
 }
+
+export interface ReportVectorIndexingFailureInput {
+  readonly projectId: string
+  readonly indexingId: string
+  readonly failure: SixbFailure<VectorIndexingFailureCode>
+  readonly objectTypeId: string
+  readonly primaryId: string
+  readonly profile: string
+}
+
+export function reportVectorIndexingFailure(
+  reporter: ErrorReporter,
+  error: unknown,
+  input: ReportVectorIndexingFailureInput
+): void {
+  reporter.report(error, {
+    ...input,
+    type: "vector.indexing.failed",
+    occurredAt: input.failure.at,
+    notificationId: `vector-indexing:${input.projectId}:${input.indexingId}`,
+  })
+}

package/src/error-reporting/types.ts

@@ -1,6 +1,7 @@
 import type { SixbFailure } from "../errors/types"
 import type { ActionRunFailure } from "../storage/action-runs"
 import type { AgentRunFailureCode } from "../storage/agents"
+import type { VectorIndexingFailureCode } from "../storage/ontology/vector-indexing"
 import type { PipelineRunFailureCode } from "../storage/pipeline-runs"
 import type { ProjectionRunFailureCode } from "../storage/projection-runs"
 import type { SyncRunFailureCode } from "../storage/sync-runs"
@@ -166,12 +167,22 @@ export interface SixbRuleEvaluationFailedContext
   readonly subject?: { readonly objectTypeId: string; readonly primaryId: string }
 }
 
+/** A terminal automatic-indexing failure, correlated with its persisted request and profile. */
+export interface SixbVectorIndexingFailedContext
+  extends SixbFailureContext<"vector.indexing.failed"> {
+  readonly failure: SixbFailure<VectorIndexingFailureCode>
+  readonly indexingId: string
+  readonly objectTypeId: string
+  readonly primaryId: string
+  readonly profile: string
+}
+
 /**
  * Context supplied to the global Sixb error handler, discriminated by `type`.
- *
  * Failure notifications never change the outcome of the operation they observe.
  */
 export type SixbErrorContext =
+  | SixbVectorIndexingFailedContext
   | SixbActionPhaseFailedContext
   | SixbRunFailedContext
   | SixbEventDeliveryFailedContext

package/src/errors/catalog.ts

@@ -14,6 +14,10 @@ export const SIXB_ERROR_DEFINITIONS = {
     publicMessage: "Action execution failed.",
     retryable: false,
   },
+  "action.read_conflict": {
+    publicMessage: "Data the Action read changed before its commit.",
+    retryable: true,
+  },
   "agent.execution_failed": {
     publicMessage: "Agent execution failed.",
     retryable: false,
@@ -130,6 +134,18 @@ export const SIXB_ERROR_DEFINITIONS = {
     publicMessage: "Execution was cancelled.",
     retryable: false,
   },
+  "vector.model_unavailable": {
+    publicMessage: "The embedding model configured for this vector profile is unavailable.",
+    retryable: false,
+  },
+  "vector.response_invalid": {
+    publicMessage: "The embedding response is invalid for this vector profile.",
+    retryable: false,
+  },
+  "vector.outcome_unknown": {
+    publicMessage: "The embedding call was interrupted; its outcome and charges may be unknown.",
+    retryable: false,
+  },
   "sync.execution_failed": {
     publicMessage: "Sync execution failed.",
     retryable: false,

package/src/errors/failure-message.ts

@@ -0,0 +1,15 @@
+const messages = new WeakMap<object, string>()
+
+/**
+ * Mark a framework-authored explanation for durable diagnostics. Use schema metadata and fixed
+ * text only, never exception messages, input values, provider payloads, or arbitrary object keys.
+ * Identity-based storage prevents an external error from opting in with a lookalike property.
+ */
+export function withFailureMessage<T extends Error>(error: T, message: string): T {
+  messages.set(error, message)
+  return error
+}
+
+export function failureMessage(error: object): string | undefined {
+  return messages.get(error)
+}

package/src/errors/internal.ts

@@ -1,5 +1,7 @@
 import { cloneJsonValue, isJsonValue, isPlainRecord, type ReadonlyJsonValue } from "../json"
+import { ActionRunFailedError } from "../objects/action/errors"
 import { SIXB_ERROR_CODES, SIXB_ERROR_DEFINITIONS } from "./catalog"
+import { failureMessage } from "./failure-message"
 import { createFailureRedactor } from "./redaction"
 import type { SixbErrorCode, SixbFailure } from "./types"
 
@@ -135,10 +137,15 @@ export function toSixbFailure(
   const code = error.code
   const redactor = createFailureRedactor()
   const details = error.details === undefined ? undefined : redactor.context(error.details)
-  const { detail, truncated } = findFailureDetail(error, code)
+  const { detail, truncated, redacted } = findFailureDetail(error, code)
   const summary = SIXB_ERROR_DEFINITIONS[code].publicMessage
+  const explanation = detail?.message ?? summary
   const message = truncateUtf8(
-    redactor.text(detail && detail.message !== summary ? `${summary} ${detail.message}` : summary),
+    redactor.text(
+      explanation === summary || explanation.startsWith(`${summary} `)
+        ? explanation
+        : `${summary} ${explanation}`
+    ),
     SIXB_FAILURE_MAX_MESSAGE_BYTES
   )
   const failure: SixbFailure = {
@@ -148,7 +155,7 @@ export function toSixbFailure(
     at: failureTimestamp(options.at),
     ...(details === undefined ? {} : { details: cloneJsonValue(details, "Sixb failure details") }),
     ...(detail?.httpStatus === undefined ? {} : { httpStatus: detail.httpStatus }),
-    ...(redactor.redacted ? { redacted: true } : {}),
+    ...(redactor.redacted || redacted ? { redacted: true } : {}),
     ...(message.truncated || truncated || redactor.truncated ? { truncated: true } : {}),
   }
 
@@ -177,47 +184,72 @@ function isHttpStatus(value: unknown): value is number {
   return typeof value === "number" && Number.isInteger(value) && value >= 100 && value <= 599
 }
 
-/** Select one explanation along the causal chain; unrelated aggregate errors stay separate. */
+/** Follow the causal chain without exposing arbitrary messages or discarding deeper statuses. */
 function findFailureDetail(
   error: SixbCodedError,
   boundaryCode: SixbErrorCode
-): { detail?: { message: string; httpStatus?: number }; truncated: boolean } {
+): {
+  detail?: { message: string; httpStatus?: number }
+  truncated: boolean
+  redacted: boolean
+} {
   const seen = new Set<object>()
+  const messages = new Set<string>()
+  let catalogMessage: string | undefined
+  let httpStatus: number | undefined
+  let truncated = false
+  let redacted = false
   let current: unknown = error
   while (typeof current === "object" && current !== null && !seen.has(current)) {
-    if (seen.size === 8) return { truncated: true }
-    seen.add(current)
-    if (
-      isSixbError(current) &&
-      current.code !== boundaryCode &&
-      current.code !== "internal.unexpected"
-    ) {
-      return {
-        detail: { message: SIXB_ERROR_DEFINITIONS[current.code].publicMessage },
-        truncated: false,
-      }
+    if (seen.size === 8) {
+      truncated = true
+      break
     }
+    seen.add(current)
+    const explanation = failureMessage(current)
+    if (explanation) messages.add(explanation)
     try {
-      // Read only data properties: arbitrary messages and getters remain private.
+      if (current instanceof ActionRunFailedError) {
+        // This is an already durable child failure, not arbitrary provider prose. Revalidate it
+        // before propagation; do not copy its context over the parent's identity or retry policy.
+        const child = parseSixbFailure(Object.getOwnPropertyDescriptor(current, "error")?.value)
+        messages.add(child.message)
+        httpStatus ??= child.httpStatus
+        redacted ||= child.redacted === true
+        truncated ||= child.truncated === true
+      }
+      if (
+        isSixbError(current) &&
+        current.code !== boundaryCode &&
+        current.code !== "internal.unexpected"
+      ) {
+        catalogMessage = SIXB_ERROR_DEFINITIONS[current.code].publicMessage
+      }
+      // Read data properties only: provider accessors, messages and payloads remain private.
       const status =
         Object.getOwnPropertyDescriptor(current, "status")?.value ??
         Object.getOwnPropertyDescriptor(current, "statusCode")?.value
-      if (isHttpStatus(status)) {
-        return {
-          detail: { message: `Upstream request returned HTTP ${status}.`, httpStatus: status },
-          truncated: false,
-        }
-      }
+      if (httpStatus === undefined && isHttpStatus(status)) httpStatus = status
       const code = Object.getOwnPropertyDescriptor(current, "code")?.value
       if (typeof code === "string" && Object.hasOwn(NETWORK_MESSAGES, code)) {
-        return { detail: { message: NETWORK_MESSAGES[code] }, truncated: false }
+        messages.add(NETWORK_MESSAGES[code])
       }
       current = Object.getOwnPropertyDescriptor(current, "cause")?.value
     } catch {
       break
     }
   }
-  return { truncated: false }
+  if (messages.size === 0 && catalogMessage) messages.add(catalogMessage)
+  if (httpStatus !== undefined) {
+    const statusMessage = `Upstream request returned HTTP ${httpStatus}.`
+    if (![...messages].some((message) => message.includes(statusMessage)))
+      messages.add(statusMessage)
+  }
+  return {
+    ...(messages.size === 0 ? {} : { detail: { message: [...messages].join(" "), httpStatus } }),
+    truncated,
+    redacted,
+  }
 }
 
 /** Serializes a validated failure for durable storage. */

package/src/events/envelope.ts

@@ -1,17 +1,5 @@
 import type { JsonValue } from "../json"
 
-/**
- * Who made a change.
- *
- * The type literals are exactly `Principal["type"]` from `auth/types`, on purpose: an actor *is* a
- * principal recorded on an event, and two spellings of the same concept meant a translation layer
- * between them, which is one more place for the two to drift.
- */
-export interface EventActor {
-  type: "user" | "serviceAccount" | "system"
-  id: string
-}
-
 export interface ActionEventOrigin {
   readonly kind: "action"
   readonly actionId: string
@@ -62,7 +50,6 @@ export interface EventEnvelope {
   correlationId?: string
   causationId?: string
   idempotencyKey?: string
-  actor?: EventActor
   origin?: EventOrigin
   metadata?: Record<string, JsonValue>
 }

package/src/events/index.ts

@@ -93,9 +93,9 @@ export type {
   DatasetVersionCommittedEvent,
   DomainEvent,
   DomainEventDraft,
-  EventActor,
   EventDraft,
   EventEnvelope,
+  EventExecutor,
   EventOrigin,
   LinkCreatedEvent,
   LinkDeletedEvent,

package/src/events/service.ts

@@ -12,13 +12,7 @@ import {
   resolveEventStorage,
 } from "./definitions"
 import { EventsError } from "./errors"
-import type {
-  DomainEvent,
-  EventActor,
-  EventDraft,
-  StoredAuthorableEvent,
-  StoredDomainEvent,
-} from "./types"
+import type { DomainEvent, EventDraft, StoredAuthorableEvent, StoredDomainEvent } from "./types"
 
 // Keep domain events as a short recent log. This is 2 days in milliseconds.
 export const DEFAULT_EVENTS_RETENTION_MS = 2 * 24 * 60 * 60 * 1000
@@ -37,7 +31,6 @@ export interface DomainEventServiceOptions {
 }
 
 export interface EventsAppendInput {
-  readonly actor?: EventActor
   readonly correlationId?: string
   readonly causationId?: string
   readonly events: readonly EventDraft[]
@@ -146,7 +139,6 @@ export class DomainEventService implements DomainEventLog, StableEventPublisher
     const payloads = input.events.map((event) =>
       toStoredEventPayload({
         projectId: this.projectId,
-        actor: input.actor,
         correlationId: input.correlationId,
         causationId: input.causationId,
         event,
@@ -306,7 +298,6 @@ type StoredEventPayload = Omit<StoredAuthorableEvent, "cursor">
 
 function toStoredEventPayload(params: {
   projectId: string
-  actor?: EventActor
   correlationId?: string
   causationId?: string
   event: EventDraft
@@ -326,7 +317,6 @@ function toStoredEventPayload(params: {
   setIfDefined(payload, "correlationId", params.correlationId)
   setIfDefined(payload, "causationId", params.causationId)
   setIfDefined(payload, "idempotencyKey", params.event.idempotencyKey)
-  setIfDefined(payload, "actor", params.actor)
   setIfDefined(payload, "origin", params.event.origin)
   setIfDefined(payload, "metadata", params.event.metadata)
 

package/src/events/toStoredEvent.ts

@@ -1,10 +1,9 @@
 import { randomUUID } from "node:crypto"
 import { resolveEventStorage } from "./definitions"
-import type { EventActor, EventDraft, StoredAuthorableEvent } from "./types/index"
+import type { EventDraft, StoredAuthorableEvent } from "./types/index"
 
 export function toStoredEvent(params: {
   projectId: string
-  actor?: EventActor
   correlationId?: string
   causationId?: string
   event: EventDraft
@@ -18,7 +17,6 @@ export function toStoredEvent(params: {
     correlationId: params.correlationId,
     causationId: params.causationId,
     idempotencyKey: params.event.idempotencyKey,
-    actor: params.actor,
     origin: params.event.origin,
     metadata: params.event.metadata,
     cursor: params.cursor,

package/src/events/types/index.ts

@@ -12,9 +12,9 @@ import type { SyncEvent } from "./syncs"
 import type { TelemetryEvent } from "./telemetry"
 import type { WorkflowEvent } from "./workflows"
 
+export type { EventExecutor } from "../../materialization/events"
 export type {
   ActionEventOrigin,
-  EventActor,
   EventEnvelope,
   EventOrigin,
   ProjectionEventOrigin,

package/src/execution/agent.ts

@@ -1,5 +1,4 @@
 import { type AgentExecutionAuthorization, agentServiceAccountId } from "../agents/authority"
-import type { OntologySource } from "../ontology"
 import { isBoundSixb, type Sixb } from "../runtime/sixb"
 import type { ExecutionRecord } from "../storage/executions"
 import { ExecutionStorageError } from "../storage/executions"
@@ -99,7 +98,7 @@ export function bindDurableAgentExecution(
     readonly runId: string
     readonly authorization: AgentExecutionAuthorization
   }
-): Sixb<readonly OntologySource[]> {
+): Sixb {
   const scope = restoreAgentExecutionScope(input)
   const sixb = host.withScope(scope)
   if (!isBoundSixb(sixb)) {

package/src/execution/authorization.ts

@@ -14,6 +14,7 @@ import type {
   CompiledSelectedObjectReadScope,
   SelectedObjectReadScope,
 } from "../storage/objects/types"
+import { kernelOperationFromId, kernelOperationId } from "./kernel-operation"
 import {
   type AuthorizablePrincipal,
   type AuthorizationRef,
@@ -443,7 +444,8 @@ function assertResolvedAuthorizationMatchesExecution(
         resolved.ref.type !== "kernel" ||
         execution.requestedBy !== undefined ||
         resolved.ref.operation.type !== execution.executor.operation.type ||
-        resolved.ref.operation.recoveryId !== execution.executor.operation.recoveryId
+        kernelOperationId(resolved.ref.operation) !==
+          kernelOperationId(execution.executor.operation)
       ) {
         throw invalidExecutionAuthority(
           execution.id,
@@ -546,6 +548,9 @@ function snapshotExecutionExecutor(
 
 function snapshotExecutionSource(source: ExecutionContext["source"]): ExecutionContext["source"] {
   switch (source.type) {
+    case "ontologyCommit":
+      assertNonEmpty(source.commitId, "Execution source commit id")
+      return Object.freeze({ type: source.type, commitId: source.commitId })
     case "http":
       assertNonEmpty(source.requestId, "Execution source request id")
       return Object.freeze({ type: "http", requestId: source.requestId })
@@ -704,11 +709,13 @@ function snapshotTrustedPrimitive(primitive: TrustedPrimitiveRef): TrustedPrimit
 }
 
 function snapshotKernelOperation(operation: KernelOperation): KernelOperation {
-  if (operation.type !== "ontology.recover") {
-    throw new Error(`[Sixb] Unknown kernel operation '${operation.type}'.`)
+  if (operation.type !== "ontology.recover" && operation.type !== "ontology.indexVectors") {
+    throw new Error(
+      `[Sixb] Unknown kernel operation '${String((operation as { type?: unknown }).type)}'.`
+    )
   }
-  assertNonEmpty(operation.recoveryId, "Kernel recovery id")
-  return Object.freeze({ type: operation.type, recoveryId: operation.recoveryId })
+  assertNonEmpty(kernelOperationId(operation), "Kernel operation id")
+  return Object.freeze(kernelOperationFromId(operation.type, kernelOperationId(operation)))
 }
 
 /** Validate, bound, and detach exact delegated Action targets before registering authority. */