@sixb/core 0.1.3 → 0.1.4

package/src/runtime/definitions.ts

@@ -2,6 +2,7 @@ import type { ActionDefinitionCatalog } from "../actions"
 import type { AgentDefinition } from "../agents"
 import type { ConnectorDefinition } from "../connectors"
 import type { DatasetDefinition } from "../datasets"
+import type { ModelCatalog } from "../models"
 import type { OntologyDefinitionCatalog } from "../ontology"
 import type { PipelineDefinition } from "../pipelines"
 import type { ProjectionDefinitionCatalog } from "../projections"
@@ -24,6 +25,8 @@ export interface SixbDefinitions {
   readonly agents: DefinitionCatalog<AgentDefinition>
   readonly connectors: DefinitionCatalog<ConnectorDefinition>
   readonly datasets: DefinitionCatalog<DatasetDefinition>
+  /** Absent until a project configures `models` in createSixb(). */
+  readonly models?: ModelCatalog
   readonly pipelines: DefinitionCatalog<PipelineDefinition>
   readonly projections: ProjectionDefinitionCatalog
   readonly rules: DefinitionCatalog<RuleDefinition>

package/src/runtime/host.ts

@@ -48,6 +48,7 @@ import {
   type SixbReadiness,
 } from "../maintenance"
 import { createOntologyMaterializer, type OntologyMaterializerContract } from "../materializer"
+import type { ModelCatalogInput } from "../models"
 import type { PipelineDefinition } from "../pipelines/types"
 import { registerProjectionRegistry } from "../projections/internal"
 import type { ProjectionDefinition } from "../projections/types"
@@ -108,6 +109,7 @@ export interface SixbHostOptions<TOntologySources extends readonly OntologySourc
   rules?: readonly RuleDefinition[]
   workflows?: readonly WorkflowDefinition[]
   agents?: readonly AgentDefinition[]
+  models?: ModelCatalogInput
   groups?: readonly GroupDefinition[]
   roles?: readonly RoleDefinition[]
   membershipPolicies?: readonly MembershipPolicyDefinition[]

package/src/runtime/resolve-definitions.ts

@@ -5,6 +5,7 @@ import { validateAgentGroupReferences, validateAgentToolsAtStartup } from "../ag
 import type { ConnectorDefinition } from "../connectors"
 import type { DatasetDefinition } from "../datasets/types"
 import { assertDatasetDefinition } from "../datasets/validation"
+import { createModelCatalog, type ModelCatalog, type ModelCatalogInput, modelRef } from "../models"
 import { OntologyRegistry } from "../ontology"
 import type { PipelineDefinition } from "../pipelines/types"
 import { ProjectionRegistry } from "../projections"
@@ -40,6 +41,7 @@ interface DefinitionOptions {
   readonly rules?: readonly RuleDefinition[]
   readonly workflows?: readonly WorkflowDefinition[]
   readonly agents?: readonly AgentDefinition[]
+  readonly models?: ModelCatalogInput
   readonly groups?: readonly GroupDefinition[]
   readonly roles?: readonly RoleDefinition[]
   readonly membershipPolicies?: readonly MembershipPolicyDefinition[]
@@ -60,6 +62,8 @@ export function resolveDefinitions(options: DefinitionOptions): ResolvedDefiniti
 
   const agents = options.agents ?? []
   validateAgentToolsAtStartup(agents)
+  const models = options.models === undefined ? undefined : createModelCatalog(options.models)
+  validateAgentModelReferences(agents, models)
   const agentsById = indexUniqueDefinitions("agent", agents)
   const connectorsById = indexUniqueDefinitions("connector", options.connectors ?? [])
 
@@ -158,6 +162,7 @@ export function resolveDefinitions(options: DefinitionOptions): ResolvedDefiniti
     agents: createDefinitionCatalog(agentsById),
     connectors: createDefinitionCatalog(connectorsById),
     datasets: createDefinitionCatalog(datasetsById),
+    ...(models === undefined ? {} : { models }),
     pipelines: createDefinitionCatalog(pipelinesById),
     projections: projectionRegistry,
     rules: createDefinitionCatalog(rulesById),
@@ -236,3 +241,26 @@ function validateScheduleReferences(
     }
   }
 }
+
+/**
+ * Keep every agent on a model the project actually allows.
+ *
+ * Only enforced once a project configures `models`; without a catalog an agent's model is its own
+ * declaration, which is the pre-catalog behavior.
+ */
+function validateAgentModelReferences(
+  agents: readonly AgentDefinition[],
+  models: ModelCatalog | undefined
+): void {
+  if (models === undefined) {
+    return
+  }
+  for (const agent of agents) {
+    const ref = modelRef(agent.model)
+    if (models.language.getById(ref) === null) {
+      throw new RuntimeError(
+        `[Sixb] Agent '${agent.id}' uses unknown language model '${ref}'. Add it to 'models.language' in createSixb().`
+      )
+    }
+  }
+}

package/src/storage/agents/in-memory.ts

@@ -642,6 +642,21 @@ class InMemoryAgentContextCheckpointStore implements AgentContextCheckpointStore
     return record ? clone(record) : null
   }
 
+  async getByRunIds(input: {
+    readonly projectId: string
+    readonly runIds: readonly string[]
+  }): Promise<readonly AgentContextCheckpointRecord[]> {
+    const byRunId = new Map(
+      [...this.state.checkpoints.values()]
+        .filter((checkpoint) => checkpoint.projectId === input.projectId)
+        .map((checkpoint) => [checkpoint.createdByRunId, checkpoint] as const)
+    )
+    return [...new Set(input.runIds)].flatMap((runId) => {
+      const checkpoint = byRunId.get(runId)
+      return checkpoint ? [clone(checkpoint)] : []
+    })
+  }
+
   private findLatest(projectId: string, threadId: string): AgentContextCheckpointRecord | null {
     return (
       [...this.state.checkpoints.values()]

package/src/storage/agents/types.ts

@@ -408,6 +408,11 @@ export interface AgentContextCheckpointStore {
    * Repeating the same payload for the same creating run is idempotent.
    */
   create(input: CreateAgentContextCheckpointInput): Promise<AgentContextCheckpointRecord>
+  /** Return checkpoints created by the requested runs, in first-occurrence input order. */
+  getByRunIds(input: {
+    readonly projectId: string
+    readonly runIds: readonly string[]
+  }): Promise<readonly AgentContextCheckpointRecord[]>
   getLatest(input: {
     readonly projectId: string
     readonly threadId: string

package/src/storage/ai-usage/in-memory.ts

@@ -5,6 +5,7 @@ import type {
   AiModelCallUsageRecord,
   AiUsageExecutionSummary,
   AiUsageStorage,
+  GetLatestAiModelCallForExecutionInput,
   RecordAiModelCallInput,
   RecordAiModelCallResult,
   SummarizeAiUsageExecutionInput,
@@ -69,6 +70,28 @@ export class InMemoryAiUsageStorage implements AiUsageStorage {
     return { record: structuredClone(record), created: true }
   }
 
+  async getLatestForExecution(
+    input: GetLatestAiModelCallForExecutionInput
+  ): Promise<AiModelCallUsageRecord | null> {
+    assertAiUsageExecutionId(input.executionId)
+    if (typeof input.projectId !== "string" || input.projectId.trim().length === 0) {
+      throw new TypeError("[Sixb] AI usage projectId must be nonblank.")
+    }
+
+    let latest: AiModelCallUsageRecord | null = null
+    for (const record of this.records.values()) {
+      if (record.projectId !== input.projectId || record.executionId !== input.executionId) continue
+      if (
+        !latest ||
+        record.occurredAt.getTime() > latest.occurredAt.getTime() ||
+        (record.occurredAt.getTime() === latest.occurredAt.getTime() && record.id > latest.id)
+      ) {
+        latest = record
+      }
+    }
+    return latest ? structuredClone(latest) : null
+  }
+
   async summarizeExecution(
     input: SummarizeAiUsageExecutionInput
   ): Promise<AiUsageExecutionSummary> {

package/src/storage/ai-usage/index.ts

@@ -13,6 +13,7 @@ export type {
   AiUsageExecutionSummary,
   AiUsageReportingStatus,
   AiUsageStorage,
+  GetLatestAiModelCallForExecutionInput,
   RecordAiModelCallInput,
   RecordAiModelCallResult,
   SummarizeAiUsageExecutionInput,

package/src/storage/ai-usage/types.ts

@@ -80,6 +80,11 @@ export interface SummarizeAiUsageExecutionsInput {
   readonly executionIds: readonly string[]
 }
 
+export interface GetLatestAiModelCallForExecutionInput {
+  readonly projectId: string
+  readonly executionId: string
+}
+
 /** Durable, provider-neutral accounting for completed language-model calls. */
 export interface AiUsageStorage {
   /**
@@ -88,6 +93,11 @@ export interface AiUsageStorage {
    */
   recordModelCall(input: RecordAiModelCallInput): Promise<RecordAiModelCallResult>
 
+  /** Latest completed provider call for one execution, ordered by occurrence and stable id. */
+  getLatestForExecution(
+    input: GetLatestAiModelCallForExecutionInput
+  ): Promise<AiModelCallUsageRecord | null>
+
   /** Aggregate normalized usage and call presence across every attempt of one execution. */
   summarizeExecution(input: SummarizeAiUsageExecutionInput): Promise<AiUsageExecutionSummary>
 

package/src/storage/index.ts

@@ -138,6 +138,7 @@ export type {
   AiUsageReportingStatus,
   AiUsageStorage,
   AiUsageStorageErrorCode,
+  GetLatestAiModelCallForExecutionInput,
   InMemoryAiUsageGroupRow,
   InMemoryAiUsageStorageSnapshot,
   RecordAiModelCallInput,
@@ -352,10 +353,13 @@ export type {
   ExpandedObjectRow,
   FacetObjectsInput,
   FacetObjectsResult,
+  LinkBatchKey,
   LinkDirection,
+  ObjectBatchKey,
   ObjectFacetBucket,
   ObjectFacetRequest,
   ObjectFacetResult,
+  ObjectLinkCursor,
   ObjectLinkRow,
   ObjectQueryCapabilities,
   ObjectQueryCapabilityMap,
@@ -364,9 +368,16 @@ export type {
   ObjectRow,
   ObjectRowLinks,
   ObjectStorage,
+  QueryObjectLinksInput,
+  QueryObjectLinksResult,
   QueryObjectsInput,
   QueryObjectsResult,
 } from "./objects"
+export {
+  linkBatchKey,
+  objectBatchKey,
+  objectLinkCursor,
+} from "./objects"
 export type {
   AbandonSourceMaterializationCandidateInput,
   AbandonSourceMaterializationInput,

package/src/storage/objects/in-memory.ts

@@ -1,6 +1,14 @@
 import type { EffectiveLinkSnapshot, EffectiveObjectSnapshot } from "../../materialization/model"
 import type { ObjectQuery, ObjectQueryPredicate, ObjectQuerySortField } from "../../objects/query"
 import { compareQueryScalarValues, queryScalarValuesEqual } from "../../objects/query/scalar-values"
+import type { LinkBatchKey, ObjectBatchKey } from "./keys"
+import {
+  compareObjectLinkCursors,
+  compareObjectLinks,
+  linkBatchKey,
+  objectBatchKey,
+  objectLinkCursor,
+} from "./keys"
 import type {
   CountObjectsInput,
   CountObjectsResult,
@@ -15,6 +23,8 @@ import type {
   ObjectQueryCapabilities,
   ObjectRow,
   ObjectStorage,
+  QueryObjectLinksInput,
+  QueryObjectLinksResult,
   QueryObjectsInput,
   QueryObjectsResult,
 } from "./types"
@@ -26,6 +36,7 @@ const IN_MEMORY_OBJECT_QUERY_CAPABILITIES: ObjectQueryCapabilities = {
   facetObjects: true,
   nodes: {
     start: true,
+    refs: true,
     filter: true,
     text: true,
     vector: true,
@@ -80,25 +91,41 @@ const IN_MEMORY_OBJECT_QUERY_CAPABILITIES: ObjectQueryCapabilities = {
 }
 
 function objectRowKey(projectId: string, objectTypeId: string): string {
-  return `${projectId}:${objectTypeId}`
+  return JSON.stringify([projectId, objectTypeId])
 }
 
-function comparePrimaryIds(left: string, right: string): number {
+function objectRowProjectPrefix(projectId: string): string {
+  return `[${JSON.stringify(projectId)},`
+}
+
+function compareStrings(left: string, right: string): number {
   if (left < right) return -1
   if (left > right) return 1
   return 0
 }
 
+function assertLinkQueryLimit(limit: number): void {
+  if (!Number.isSafeInteger(limit) || limit <= 0) {
+    throw new Error("Object link query limit must be a positive safe integer.")
+  }
+}
+
 function sourceLinkBucketKey(projectId: string, sourceTypeId: string, sourceId: string): string {
-  return `${projectId}:${sourceTypeId}:${sourceId}`
+  return JSON.stringify([projectId, sourceTypeId, sourceId])
 }
 
 function linkRowKey(linkId: string, targetTypeId: string, targetId: string): string {
-  return `${linkId}:${targetTypeId}:${targetId}`
+  return JSON.stringify([linkId, targetTypeId, targetId])
 }
 
 function fullLinkRowKey(row: ObjectLinkRow): string {
-  return `${row.sourceTypeId}:${row.sourceId}:${row.linkId}:${row.targetTypeId}:${row.targetId}`
+  return JSON.stringify([
+    row.sourceTypeId,
+    row.sourceId,
+    row.linkId,
+    row.targetTypeId,
+    row.targetId,
+  ])
 }
 
 type QueryEntry = {
@@ -343,6 +370,8 @@ export class InMemoryObjectStorage implements ObjectStorage {
     switch (query.kind) {
       case "start":
         return this.evaluateStart(projectId, query.objectTypeId)
+      case "refs":
+        return this.evaluateRefs(projectId, query.refs)
       case "filter": {
         const input = this.evaluateObjectQuery(projectId, query.input)
         const entries = input.entries.filter((entry) =>
@@ -446,6 +475,29 @@ export class InMemoryObjectStorage implements ObjectStorage {
     return completeEvaluation(entries)
   }
 
+  private evaluateRefs(
+    projectId: string,
+    refs: readonly { objectTypeId: string; primaryId: string }[]
+  ): QueryEvaluation {
+    const seen = new Set<string>()
+    const entries = refs
+      .flatMap((ref) => {
+        const key = JSON.stringify([ref.objectTypeId, ref.primaryId])
+        if (seen.has(key)) return []
+        seen.add(key)
+        const row = this.rows.get(objectRowKey(projectId, ref.objectTypeId))?.get(ref.primaryId)
+        return row ? [row] : []
+      })
+      .sort(
+        (left, right) =>
+          compareStrings(left.objectTypeId, right.objectTypeId) ||
+          compareStrings(left.primaryId, right.primaryId)
+      )
+      .map((row, order) => ({ row, score: 0, order }))
+
+    return completeEvaluation(entries)
+  }
+
   private evaluateSet(
     projectId: string,
     op: "union" | "intersect" | "subtract",
@@ -602,8 +654,8 @@ export class InMemoryObjectStorage implements ObjectStorage {
   async getByPrimaryIdBatch(params: {
     projectId: string
     items: readonly { objectTypeId: string; primaryId: string }[]
-  }): Promise<Map<string, ObjectRow>> {
-    const result = new Map<string, ObjectRow>()
+  }): Promise<Map<ObjectBatchKey, ObjectRow>> {
+    const result = new Map<ObjectBatchKey, ObjectRow>()
     for (const item of params.items) {
       const row = await this.getByPrimaryId({
         projectId: params.projectId,
@@ -611,7 +663,7 @@ export class InMemoryObjectStorage implements ObjectStorage {
         primaryId: item.primaryId,
       })
       if (row) {
-        result.set(`${item.objectTypeId}:${item.primaryId}`, row)
+        result.set(objectBatchKey(item.objectTypeId, item.primaryId), row)
       }
     }
     return result
@@ -620,8 +672,8 @@ export class InMemoryObjectStorage implements ObjectStorage {
   async listLinksBatch(params: {
     projectId: string
     items: readonly { objectTypeId: string; objectId: string; linkId: string }[]
-  }): Promise<Map<string, ObjectLinkRow[]>> {
-    const result = new Map<string, ObjectLinkRow[]>()
+  }): Promise<Map<LinkBatchKey, ObjectLinkRow[]>> {
+    const result = new Map<LinkBatchKey, ObjectLinkRow[]>()
     for (const item of params.items) {
       const rows = await this.listLinks({
         projectId: params.projectId,
@@ -630,12 +682,48 @@ export class InMemoryObjectStorage implements ObjectStorage {
         linkId: item.linkId,
       })
       if (rows.length > 0) {
-        result.set(`${item.objectTypeId}:${item.objectId}:${item.linkId}`, [...rows])
+        result.set(linkBatchKey(item.objectTypeId, item.objectId, item.linkId), [...rows])
       }
     }
     return result
   }
 
+  async queryLinks(params: QueryObjectLinksInput): Promise<QueryObjectLinksResult> {
+    assertLinkQueryLimit(params.limit)
+    if (params.objectRefs.length === 0 || params.endpointObjectTypeIds?.length === 0) {
+      return { links: [], hasMore: false }
+    }
+
+    const allowedTypes = params.endpointObjectTypeIds
+      ? new Set(params.endpointObjectTypeIds)
+      : undefined
+    const deduped = new Map<string, ObjectLinkRow>()
+    for (const object of params.objectRefs) {
+      const rows = await this.listLinks({
+        projectId: params.projectId,
+        objectTypeId: object.objectTypeId,
+        objectId: object.primaryId,
+        direction: params.direction,
+        ...(params.linkId === undefined ? {} : { linkId: params.linkId }),
+      })
+      for (const row of rows) {
+        if (
+          allowedTypes &&
+          (!allowedTypes.has(row.sourceTypeId) || !allowedTypes.has(row.targetTypeId))
+        ) {
+          continue
+        }
+        if (params.after && compareObjectLinkCursors(objectLinkCursor(row), params.after) <= 0) {
+          continue
+        }
+        deduped.set(fullLinkRowKey(row), row)
+      }
+    }
+
+    const rows = [...deduped.values()].sort(compareObjectLinks).slice(0, params.limit + 1)
+    return { links: rows.slice(0, params.limit), hasMore: rows.length > params.limit }
+  }
+
   async listIncidentLinksBatch(params: {
     projectId: string
     items: readonly { objectTypeId: string; objectId: string }[]
@@ -665,10 +753,9 @@ export class InMemoryObjectStorage implements ObjectStorage {
     const bucket = this.rows.get(objectRowKey(params.projectId, params.objectTypeId))
     const rows = [...(bucket?.values() ?? [])]
       .filter(
-        (row) =>
-          !params.afterPrimaryId || comparePrimaryIds(row.primaryId, params.afterPrimaryId) > 0
+        (row) => !params.afterPrimaryId || compareStrings(row.primaryId, params.afterPrimaryId) > 0
       )
-      .sort((left, right) => comparePrimaryIds(left.primaryId, right.primaryId))
+      .sort((left, right) => compareStrings(left.primaryId, right.primaryId))
       .slice(0, params.limit + 1)
     const hasMore = rows.length > params.limit
     const objects = rows.slice(0, params.limit).map((row) => structuredClone(row))
@@ -707,7 +794,7 @@ export class InMemoryObjectStorage implements ObjectStorage {
       }
     } else {
       for (const [key, bucket] of this.rows) {
-        if (key.startsWith(`${params.projectId}:`)) {
+        if (key.startsWith(objectRowProjectPrefix(params.projectId))) {
           allRows.push(...bucket.values())
         }
       }
@@ -1113,7 +1200,7 @@ function rowIdentityKey(row: ObjectRow): string {
 }
 
 function rowIdentityKeyParts(objectTypeId: string, primaryId: string): string {
-  return `${objectTypeId}:${primaryId}`
+  return objectBatchKey(objectTypeId, primaryId)
 }
 
 function upsertEntry(entriesByKey: Map<string, QueryEntry>, entry: QueryEntry): void {

package/src/storage/objects/index.ts

@@ -1,3 +1,9 @@
+export type { LinkBatchKey, ObjectBatchKey } from "./keys"
+export {
+  linkBatchKey,
+  objectBatchKey,
+  objectLinkCursor,
+} from "./keys"
 export type {
   CountObjectsInput,
   CountObjectsResult,
@@ -11,6 +17,7 @@ export type {
   ObjectFacetBucket,
   ObjectFacetRequest,
   ObjectFacetResult,
+  ObjectLinkCursor,
   ObjectLinkRow,
   ObjectQueryCapabilities,
   ObjectQueryCapabilityMap,
@@ -19,6 +26,8 @@ export type {
   ObjectRow,
   ObjectRowLinks,
   ObjectStorage,
+  QueryObjectLinksInput,
+  QueryObjectLinksResult,
   QueryObjectsInput,
   QueryObjectsResult,
 } from "./types"

package/src/storage/objects/keys.ts

@@ -0,0 +1,36 @@
+import type { ObjectLinkCursor, ObjectLinkRow } from "./types"
+
+export type ObjectBatchKey = string & {
+  readonly __sixbObjectBatchKey: true
+}
+
+export type LinkBatchKey = string & {
+  readonly __sixbLinkBatchKey: true
+}
+
+/** Collision-safe key for object batch-read results. */
+export function objectBatchKey(objectTypeId: string, primaryId: string): ObjectBatchKey {
+  return JSON.stringify([objectTypeId, primaryId]) as ObjectBatchKey
+}
+
+/** Collision-safe key for outgoing-link batch-read results. */
+export function linkBatchKey(objectTypeId: string, objectId: string, linkId: string): LinkBatchKey {
+  return JSON.stringify([objectTypeId, objectId, linkId]) as LinkBatchKey
+}
+
+/** Canonical storage ordering and cursor for physical links. */
+export function objectLinkCursor(link: ObjectLinkRow): ObjectLinkCursor {
+  return [link.sourceTypeId, link.sourceId, link.linkId, link.targetTypeId, link.targetId]
+}
+
+export function compareObjectLinkCursors(left: ObjectLinkCursor, right: ObjectLinkCursor): number {
+  for (let index = 0; index < left.length; index += 1) {
+    if (left[index] < right[index]) return -1
+    if (left[index] > right[index]) return 1
+  }
+  return 0
+}
+
+export function compareObjectLinks(left: ObjectLinkRow, right: ObjectLinkRow): number {
+  return compareObjectLinkCursors(objectLinkCursor(left), objectLinkCursor(right))
+}

package/src/storage/objects/types.ts

@@ -6,6 +6,7 @@ import type {
   ObjectQuerySortField,
   QueryScalarKind,
 } from "../../objects/query"
+import type { LinkBatchKey, ObjectBatchKey } from "./keys"
 
 /**
  * Latest-state projection storage for objects and links.
@@ -64,6 +65,26 @@ export interface ObjectLinkRow {
 
 export type LinkDirection = "outgoing" | "incoming" | "both"
 
+/** Stable physical-link order: source type/id, link id, then target type/id. */
+export type ObjectLinkCursor = readonly [string, string, string, string, string]
+
+export interface QueryObjectLinksInput {
+  projectId: string
+  /** Object identities are treated as a set; duplicate refs do not duplicate links. */
+  objectRefs: readonly { objectTypeId: string; primaryId: string }[]
+  direction: LinkDirection
+  linkId?: string
+  /** When present, both endpoints must belong to this set. An empty set matches no links. */
+  endpointObjectTypeIds?: readonly string[]
+  after?: ObjectLinkCursor
+  limit: number
+}
+
+export interface QueryObjectLinksResult {
+  links: readonly ObjectLinkRow[]
+  hasMore: boolean
+}
+
 export type ObjectQueryCapabilityMap<T extends string> = Readonly<Partial<Record<T, boolean>>>
 
 export type ObjectQueryScalarOperation = "equality" | "ordering"
@@ -192,27 +213,34 @@ export interface ObjectStorage {
 
   /**
    * Batch fetch objects by (objectTypeId, primaryId) pairs.
-   * Returns a Map keyed by "objectTypeId:primaryId". Missing items are absent.
+   * Returns a Map keyed by {@link objectBatchKey}. Missing items are absent.
    */
   getByPrimaryIdBatch(params: {
     projectId: string
     items: readonly { objectTypeId: string; primaryId: string }[]
-  }): Promise<Map<string, ObjectRow>>
+  }): Promise<ReadonlyMap<ObjectBatchKey, ObjectRow>>
 
   /**
    * Batch fetch outgoing links by (objectTypeId, objectId, linkId) tuples.
-   * Returns a Map keyed by "objectTypeId:objectId:linkId". Missing entries are absent.
+   * Returns a Map keyed by {@link linkBatchKey}. Missing entries are absent.
    */
   listLinksBatch(params: {
     projectId: string
     items: readonly { objectTypeId: string; objectId: string; linkId: string }[]
-  }): Promise<Map<string, ObjectLinkRow[]>>
+  }): Promise<ReadonlyMap<LinkBatchKey, ObjectLinkRow[]>>
+
+  /**
+   * Read one canonical page of physical links incident to an object set.
+   * Filtering, endpoint-type scope, cursoring, ordering, and the limit are provider-owned so a
+   * bounded response never requires loading every incident link into the runtime.
+   */
+  queryLinks(params: QueryObjectLinksInput): Promise<QueryObjectLinksResult>
 
   /**
    * Batch fetch every link incident to any of the given objects, in BOTH directions (the object as
    * link source or target). Returns a flat, de-duplicated list: a physical link incident to two
-   * listed objects appears once. Used to load cascade-delete state for `object.delete` operations,
-   * which {@link listLinksBatch} cannot express because it keys on a specific linkId.
+   * listed objects appears once. This unpaged primitive exists for internal materialization and
+   * per-parent expansion work; interactive reads use {@link queryLinks}.
    */
   listIncidentLinksBatch(params: {
     projectId: string

package/src/storage/ontology/provider-header-validation.ts

@@ -155,9 +155,9 @@ function assertProjectionTelemetryBatch(
   if (source.sourceRowsSkipped > source.sourceRowCount) {
     invalidCorrelation("Projection telemetry skipped rows exceed its source row count.")
   }
-  if (source.sourceRowCount !== inputPointCount + source.sourceRowsSkipped) {
+  if (inputPointCount < source.sourceRowCount - source.sourceRowsSkipped) {
     invalidCorrelation(
-      "Projection telemetry source row count does not match input points plus skipped rows."
+      "Projection telemetry input points do not account for every non-skipped source row."
     )
   }
   if (typeof source.inputExhausted !== "boolean") {

package/src/testing/agent-storage-contract.ts

@@ -1077,6 +1077,18 @@ export function runAgentStorageContractSuite<TStorage extends AgentStorageContra
           await storage.checkpoints.getLatest({ projectId: otherProjectId, threadId: "thr_1" })
         ).toBeNull()
         expect(await storage.checkpoints.getLatest({ projectId, threadId: "thr_2" })).toBeNull()
+        await expect(
+          storage.checkpoints.getByRunIds({
+            projectId,
+            runIds: ["run_2", "missing", "run_2"],
+          })
+        ).resolves.toEqual([created])
+        await expect(
+          storage.checkpoints.getByRunIds({
+            projectId: otherProjectId,
+            runIds: ["run_2"],
+          })
+        ).resolves.toEqual([])
 
         const retained = await storage.messages.list({
           projectId,