@sixb/core 0.1.3 → 0.1.5

package/src/testing/ai-usage-storage-contract.ts

@@ -145,6 +145,41 @@ export function runAiUsageStorageContractSuite<TStorage extends AiUsageStorage>(
       })
     })
 
+    test("returns the latest completed call for one execution", async () => {
+      await withStorage(async (storage) => {
+        await expect(
+          storage.getLatestForExecution({ projectId, executionId: agentExecutionId })
+        ).resolves.toBeNull()
+
+        await storage.recordModelCall(
+          modelCallInput({
+            id: "usage_later",
+            callId: "call_later",
+            responseId: "response_later",
+            occurredAt: at("2026-06-23T10:02:00.000Z"),
+          })
+        )
+        await storage.recordModelCall(
+          modelCallInput({
+            id: "usage_earlier",
+            callId: "call_earlier",
+            responseId: "response_earlier",
+            occurredAt: at("2026-06-23T10:01:00.000Z"),
+          })
+        )
+
+        await expect(
+          storage.getLatestForExecution({ projectId, executionId: agentExecutionId })
+        ).resolves.toMatchObject({ id: "usage_later", responseId: "response_later" })
+        await expect(
+          storage.getLatestForExecution({
+            projectId: "other-project",
+            executionId: agentExecutionId,
+          })
+        ).resolves.toBeNull()
+      })
+    })
+
     test("bills the same call and response IDs again on a later delivery attempt", async () => {
       // Regression guard: remove `attempt` from a provider's idempotency key/query/index and the
       // second append collapses into the first, making the aggregate assertions fail.

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

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test"
 import { defineObjectType, link, OntologyRegistry, prop } from "../ontology"
-import type { Storage } from "../storage"
+import { linkBatchKey, objectBatchKey, objectLinkCursor, type Storage } from "../storage"
 import { createMaterializerTestFixture } from "./materializer-fixture"
 
 export interface EffectiveStorageContractSuiteOptions<TStorage extends Storage> {
@@ -19,7 +19,25 @@ const Device = defineObjectType({
   ],
   links: [link.self("peers", { cardinality: "many" })],
 })
-const ontology = new OntologyRegistry({ sources: [Device] })
+const OpaqueA = defineObjectType({
+  id: "A",
+  name: "Opaque A",
+  properties: [
+    prop("id", "string", { primary: true, required: true }),
+    prop("name", "string", { required: true }),
+  ],
+  links: [link.self("D", { cardinality: "many" })],
+})
+const OpaqueAB = defineObjectType({
+  id: "A:B",
+  name: "Opaque AB",
+  properties: [
+    prop("id", "string", { primary: true, required: true }),
+    prop("name", "string", { required: true }),
+  ],
+  links: [link.self("D", { cardinality: "many" })],
+})
+const ontology = new OntologyRegistry({ sources: [Device, OpaqueA, OpaqueAB] })
 
 export function runEffectiveStorageContractSuite<TStorage extends Storage>(
   name: string,
@@ -56,7 +74,7 @@ export function runEffectiveStorageContractSuite<TStorage extends Storage>(
             { objectTypeId: Device.id, primaryId: "missing" },
           ],
         })
-        expect([...batch.keys()]).toEqual([`${Device.id}:a`])
+        expect([...batch.keys()]).toEqual([objectBatchKey(Device.id, "a")])
       })
     })
 
@@ -81,7 +99,179 @@ export function runEffectiveStorageContractSuite<TStorage extends Storage>(
           projectId,
           items: [{ objectTypeId: Device.id, objectId: "a", linkId: "peers" }],
         })
-        expect(linksByScope.get(`${Device.id}:a:peers`)).toHaveLength(2)
+        expect(linksByScope.get(linkBatchKey(Device.id, "a", "peers"))).toHaveLength(2)
+      })
+    })
+
+    test("pages and filters incident links in the provider", async () => {
+      await withStorage(async (storage) => {
+        const first = await storage.objects.queryLinks({
+          projectId,
+          objectRefs: [{ objectTypeId: Device.id, primaryId: "a" }],
+          direction: "outgoing",
+          linkId: "peers",
+          endpointObjectTypeIds: [Device.id],
+          limit: 1,
+        })
+        expect(first.links.map((row) => row.targetId)).toEqual(["b"])
+        expect(first.hasMore).toBe(true)
+
+        const second = await storage.objects.queryLinks({
+          projectId,
+          objectRefs: [{ objectTypeId: Device.id, primaryId: "a" }],
+          direction: "outgoing",
+          linkId: "peers",
+          endpointObjectTypeIds: [Device.id],
+          after: objectLinkCursor(first.links[0]),
+          limit: 1,
+        })
+        expect(second.links.map((row) => row.targetId)).toEqual(["c"])
+        expect(second.hasMore).toBe(false)
+
+        const duplicateRefs = await storage.objects.queryLinks({
+          projectId,
+          objectRefs: [
+            { objectTypeId: Device.id, primaryId: "a" },
+            { objectTypeId: Device.id, primaryId: "a" },
+          ],
+          direction: "outgoing",
+          limit: 10,
+        })
+        expect(duplicateRefs.links.map((row) => row.targetId)).toEqual(["b", "c"])
+
+        const incoming = await storage.objects.queryLinks({
+          projectId,
+          objectRefs: [{ objectTypeId: Device.id, primaryId: "b" }],
+          direction: "incoming",
+          limit: 10,
+        })
+        expect(incoming.links.map((row) => [row.sourceId, row.targetId])).toEqual([["a", "b"]])
+
+        const bothDirections = await storage.objects.queryLinks({
+          projectId,
+          objectRefs: [
+            { objectTypeId: Device.id, primaryId: "a" },
+            { objectTypeId: Device.id, primaryId: "b" },
+          ],
+          direction: "both",
+          endpointObjectTypeIds: [Device.id],
+          limit: 10,
+        })
+        expect(bothDirections.links.map((row) => [row.sourceId, row.targetId])).toEqual([
+          ["a", "b"],
+          ["a", "c"],
+        ])
+
+        const unauthorized = await storage.objects.queryLinks({
+          projectId,
+          objectRefs: [{ objectTypeId: Device.id, primaryId: "a" }],
+          direction: "both",
+          endpointObjectTypeIds: [],
+          limit: 10,
+        })
+        expect(unauthorized).toEqual({ links: [], hasMore: false })
+      })
+    })
+
+    test("keeps delimiter-bearing object and batch-link identities distinct", async () => {
+      await withStorage(async (storage) => {
+        const opaqueProjectId = `${projectId}-opaque-batch-keys`
+        const fixture = createMaterializerTestFixture({
+          projectId: opaqueProjectId,
+          ontology,
+          storage,
+        })
+        await fixture.seed({
+          objects: [
+            {
+              ref: { objectTypeId: OpaqueA.id, primaryId: "B:C" },
+              properties: { id: "B:C", name: "First" },
+            },
+            {
+              ref: { objectTypeId: OpaqueAB.id, primaryId: "C" },
+              properties: { id: "C", name: "Second" },
+            },
+          ],
+          links: [
+            {
+              ref: {
+                source: { objectTypeId: OpaqueA.id, primaryId: "B:C" },
+                linkId: "D",
+                target: { objectTypeId: OpaqueA.id, primaryId: "B:C" },
+              },
+            },
+            {
+              ref: {
+                source: { objectTypeId: OpaqueAB.id, primaryId: "C" },
+                linkId: "D",
+                target: { objectTypeId: OpaqueAB.id, primaryId: "C" },
+              },
+            },
+          ],
+        })
+
+        const objects = await storage.objects.getByPrimaryIdBatch({
+          projectId: opaqueProjectId,
+          items: [
+            { objectTypeId: OpaqueA.id, primaryId: "B:C" },
+            { objectTypeId: OpaqueAB.id, primaryId: "C" },
+          ],
+        })
+        expect(objects.get(objectBatchKey(OpaqueA.id, "B:C"))?.properties.name).toBe("First")
+        expect(objects.get(objectBatchKey(OpaqueAB.id, "C"))?.properties.name).toBe("Second")
+
+        const links = await storage.objects.listLinksBatch({
+          projectId: opaqueProjectId,
+          items: [
+            { objectTypeId: OpaqueA.id, objectId: "B:C", linkId: "D" },
+            { objectTypeId: OpaqueAB.id, objectId: "C", linkId: "D" },
+          ],
+        })
+        expect(links.get(linkBatchKey(OpaqueA.id, "B:C", "D"))).toHaveLength(1)
+        expect(links.get(linkBatchKey(OpaqueAB.id, "C", "D"))).toHaveLength(1)
+      })
+    })
+
+    test("preserves distinct incident links when opaque ids contain delimiters", async () => {
+      await withStorage(async (storage) => {
+        const opaqueIdsProjectId = `${projectId}-opaque-link-ids`
+        const firstSourceId = "opaque:source"
+        const firstTargetId = `target:peers:${Device.id}:opaque:end`
+        const secondSourceId = `${firstSourceId}:peers:${Device.id}:target`
+        const secondTargetId = "opaque:end"
+        const fixture = createMaterializerTestFixture({
+          projectId: opaqueIdsProjectId,
+          ontology,
+          storage,
+        })
+        await fixture.seed({
+          objects: [
+            device(firstSourceId, "First source"),
+            device(firstTargetId, "First target"),
+            device(secondSourceId, "Second source"),
+            device(secondTargetId, "Second target"),
+          ],
+          links: [peer(firstSourceId, firstTargetId), peer(secondSourceId, secondTargetId)],
+        })
+
+        const incident = await storage.objects.listIncidentLinksBatch({
+          projectId: opaqueIdsProjectId,
+          items: [
+            { objectTypeId: Device.id, objectId: firstSourceId },
+            { objectTypeId: Device.id, objectId: secondSourceId },
+          ],
+        })
+        const matching = incident.filter(
+          (row) => row.sourceId === firstSourceId || row.sourceId === secondSourceId
+        )
+
+        expect(matching.map((row) => [row.sourceId, row.linkId, row.targetId])).toEqual(
+          expect.arrayContaining([
+            [firstSourceId, "peers", firstTargetId],
+            [secondSourceId, "peers", secondTargetId],
+          ])
+        )
+        expect(matching).toHaveLength(2)
       })
     })
 

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

@@ -438,6 +438,62 @@ export function runLakeStorageContractSuite<TStorage extends LakeStorage>(
         })
       })
 
+      test("creates an initial empty snapshot version", async () => {
+        await withStorage(async (storage) => {
+          await storage.createDataset(writeDataset)
+
+          const write = await storage.beginWrite({ dataset: writeDataset, mode: "snapshot" })
+          const version = await write.commit()
+
+          expect(version).toMatchObject({
+            datasetId: writeDataset.id,
+            mode: "snapshot",
+            outcome: "created",
+            rowCount: 0,
+          })
+          expect(await storage.getLatestVersion(writeDataset.id)).toMatchObject({
+            versionId: version.versionId,
+          })
+          expect(await storage.listVersions(writeDataset.id)).toHaveLength(1)
+
+          const repeatedWrite = await storage.beginWrite({
+            dataset: writeDataset,
+            mode: "snapshot",
+          })
+          const repeatedVersion = await repeatedWrite.commit()
+          expect(repeatedVersion.outcome).toBe("unchanged")
+          expect(repeatedVersion.versionId).toBe(version.versionId)
+          expect(await storage.listVersions(writeDataset.id)).toHaveLength(1)
+
+          await expect(
+            collectRows(storage.readRows({ datasetId: writeDataset.id }))
+          ).resolves.toEqual([])
+        })
+      })
+
+      test("creates an initial empty append version", async () => {
+        await withStorage(async (storage) => {
+          await storage.createDataset(writeDataset)
+
+          const write = await storage.beginWrite({ dataset: writeDataset, mode: "append" })
+          const version = await write.commit()
+
+          expect(version).toMatchObject({
+            datasetId: writeDataset.id,
+            mode: "append",
+            outcome: "created",
+          })
+          expect(version.parentVersionId).toBeUndefined()
+          expect(await storage.getLatestVersion(writeDataset.id)).toMatchObject({
+            versionId: version.versionId,
+          })
+          expect(await storage.listVersions(writeDataset.id)).toHaveLength(1)
+          await expect(
+            collectRows(storage.readRows({ datasetId: writeDataset.id }))
+          ).resolves.toEqual([])
+        })
+      })
+
       test("snapshot writes replace the visible latest rows", async () => {
         await withStorage(async (storage) => {
           await storage.createDataset(writeDataset)

package/src/testing/object-query-contract.ts

@@ -4,6 +4,7 @@ import {
   collectObjectQueryValidationIssues,
   countObjects,
   executeObjectQuery,
+  executeObjectQueryLinks,
   existsObjects,
   facetObjects,
   normalizeObjectQuery,
@@ -145,7 +146,7 @@ export const objectQueryContractOntology = new OntologyRegistry({
  *
  * The contract defines the portable V1 query surface: capability declarations,
  * validation/normalization handoff, provider pushdown, bounded fallback,
- * traversal, set operations, pagination, search profile defaults, and stable
+ * canonical reference sets, traversal, set operations, pagination, search profile defaults, and stable
  * structured rejections for features outside a provider's capability map.
  */
 export function runObjectQueryProviderContractSuite<TStorage extends Storage>(
@@ -345,6 +346,212 @@ export function runObjectQueryProviderContractSuite<TStorage extends Storage>(
       })
     })
 
+    test("queries opaque ids through canonical exact refs", async () => {
+      await withStorage(async ({ objects: storage, fixture }) => {
+        const issue297 = "github:issue:sixb-ai/sixb#297"
+        const issue298 = "github:issue:sixb-ai/sixb#298"
+        await fixture.seed({
+          objects: [
+            objectSeed(Asset.id, issue297, { id: issue297 }),
+            objectSeed(Asset.id, issue298, { id: issue298 }),
+          ],
+        })
+
+        const refs = await executeObjectQuery(
+          {
+            projectId,
+            query: {
+              kind: "refs",
+              refs: [
+                { objectTypeId: Asset.id, primaryId: issue298 },
+                { objectTypeId: Asset.id, primaryId: issue297 },
+              ],
+            },
+          },
+          { ontology: objectQueryContractOntology, storage }
+        )
+
+        // The JSON query body preserves URL-reserved characters without encoding.
+        expect(refs.plan.mode).toBe(
+          storage.queryCapabilities().nodes?.refs === true ? "pushdown" : "fallback"
+        )
+        expect(ids(refs)).toEqual([issue297, issue298])
+      })
+    })
+
+    test("executes canonical heterogeneous refs with pagination and projection", async () => {
+      await withStorage(async ({ objects: storage, fixture }) => {
+        await seedObjectQueryContractData(fixture)
+
+        const refs: Extract<ObjectQuery, { kind: "refs" }>["refs"] = [
+          { objectTypeId: Device.id, primaryId: "device-sensor" },
+          { objectTypeId: Room.id, primaryId: "room-gamma" },
+          { objectTypeId: Room.id, primaryId: "missing" },
+          { objectTypeId: Room.id, primaryId: "room-alpha" },
+        ]
+        const first = await executeObjectQuery(
+          {
+            projectId,
+            query: {
+              kind: "project",
+              properties: ["id"],
+              input: { kind: "page", pageSize: 2, input: { kind: "refs", refs } },
+            },
+          },
+          { ontology: objectQueryContractOntology, storage }
+        )
+        const second = await executeObjectQuery(
+          {
+            projectId,
+            query: {
+              kind: "project",
+              properties: ["id"],
+              input: {
+                kind: "page",
+                pageSize: 2,
+                pageToken: first.nextPageToken,
+                input: { kind: "refs", refs },
+              },
+            },
+          },
+          { ontology: objectQueryContractOntology, storage }
+        )
+        const count = await countObjects(
+          { projectId, query: { kind: "refs", refs } },
+          { ontology: objectQueryContractOntology, storage }
+        )
+
+        const expectedMode =
+          storage.queryCapabilities().nodes?.refs === true ? "pushdown" : "fallback"
+        expect(first.plan.mode).toBe(expectedMode)
+        expect(ids(first)).toEqual(["device-sensor", "room-alpha"])
+        expect(first.objects.map((row) => row.properties)).toEqual([
+          { id: "device-sensor" },
+          { id: "room-alpha" },
+        ])
+        expect(first.total).toBe(3)
+        expect(first.hasMore).toBe(true)
+        expect(first.nextPageToken).toBeTruthy()
+        expect(second.plan.mode).toBe(expectedMode)
+        expect(ids(second)).toEqual(["room-gamma"])
+        expect(second.hasMore).toBe(false)
+        expect(count.plan.mode).toBe(expectedMode)
+        expect(count.count).toBe(3)
+      })
+    })
+
+    test("composes refs with traversal in provider pushdown", async () => {
+      await withStorage(async ({ objects: storage, fixture }) => {
+        if (storage.queryCapabilities().nodes?.refs !== true) return
+        await seedObjectQueryContractData(fixture)
+
+        const result = await executeObjectQuery(
+          {
+            projectId,
+            query: {
+              kind: "traverse",
+              direction: "outgoing",
+              linkId: "hasDevice",
+              input: {
+                kind: "refs",
+                refs: [{ objectTypeId: Room.id, primaryId: "room-alpha" }],
+              },
+            },
+          },
+          { ontology: objectQueryContractOntology, storage }
+        )
+
+        expect(result.plan.mode).toBe("pushdown")
+        expect(ids(result)).toEqual(["device-projector"])
+      })
+    })
+
+    test("queries and paginates incident links over a provider-backed object set", async () => {
+      await withStorage(async ({ objects: storage, fixture }) => {
+        await seedObjectQueryContractData(fixture)
+        const query: ObjectQuery = {
+          kind: "refs",
+          refs: [{ objectTypeId: Device.id, primaryId: "device-projector" }],
+        }
+
+        const first = await executeObjectQueryLinks(
+          {
+            projectId,
+            query,
+            direction: "incoming",
+            includeObjects: true,
+            pageSize: 1,
+          },
+          { ontology: objectQueryContractOntology, storage }
+        )
+        const second = await executeObjectQueryLinks(
+          {
+            projectId,
+            query,
+            direction: "incoming",
+            includeObjects: true,
+            pageSize: 1,
+            pageToken: first.nextPageToken,
+          },
+          { ontology: objectQueryContractOntology, storage }
+        )
+
+        expect(first.links).toEqual([
+          expect.objectContaining({
+            sourceTypeId: Room.id,
+            sourceId: "room-alpha",
+            linkId: "hasDevice",
+            targetTypeId: Device.id,
+            targetId: "device-projector",
+          }),
+        ])
+        expect(first.objects.map((row) => row.primaryId)).toEqual([
+          "device-projector",
+          "room-alpha",
+        ])
+        expect(first.hasMore).toBe(true)
+        expect(first.nextPageToken).toBeTruthy()
+        expect(second.links).toEqual([
+          expect.objectContaining({
+            sourceTypeId: Zone.id,
+            sourceId: "zone-one",
+            linkId: "hasDevice",
+            targetTypeId: Device.id,
+            targetId: "device-projector",
+          }),
+        ])
+        expect(second.objects.map((row) => row.primaryId)).toEqual(["device-projector", "zone-one"])
+        expect(second.hasMore).toBe(false)
+      })
+    })
+
+    test("does not admit a provider page probe into the link selector", async () => {
+      await withStorage(async ({ objects: storage, fixture }) => {
+        await seedObjectQueryContractData(fixture)
+
+        const result = await executeObjectQueryLinks(
+          {
+            projectId,
+            query: {
+              kind: "page",
+              pageSize: 1,
+              input: {
+                kind: "sort",
+                fields: [{ kind: "property", propertyId: "id", direction: "asc" }],
+                input: { kind: "start", objectTypeId: Room.id },
+              },
+            },
+            direction: "outgoing",
+          },
+          { ontology: objectQueryContractOntology, storage }
+        )
+
+        expect(result.links).toEqual([
+          expect.objectContaining({ sourceId: "room-alpha", targetId: "device-projector" }),
+        ])
+      })
+    })
+
     test("matches null, missing, neq, in, and not predicate semantics", async () => {
       await withStorage(async ({ objects: storage, fixture }) => {
         await seedObjectQueryContractData(fixture)

package/dist/agents/prompt.d.ts

@@ -1,21 +0,0 @@
-export declare const DEFAULT_AGENT_SYSTEM_CONTEXT: string;
-export declare const DEFAULT_AGENT_WORKFLOW_SYSTEM_CONTEXT: string;
-export declare const DEFAULT_WORKFLOW_OUTPUT_FINALIZER_SYSTEM_CONTEXT: string;
-export interface BuildAgentSystemPromptInput {
-    readonly instructions: string;
-    readonly addendum?: string;
-    readonly mode?: "conversation" | "workflow";
-}
-export interface BuildWorkflowOutputFinalizerPromptInput {
-    readonly instructions: string;
-}
-/**
- * Compose the framework-owned system prompt for every agent turn.
- *
- * Core Sixb rules are first and explicitly separated from runtime context and project-authored
- * agent instructions so models can distinguish platform behavior from agent-specific goals.
- */
-export declare function buildAgentSystemPrompt(input: BuildAgentSystemPromptInput): string;
-/** Compose the system prompt for the tool-free workflow output projection call. */
-export declare function buildWorkflowOutputFinalizerPrompt(input: BuildWorkflowOutputFinalizerPromptInput): string;
-//# sourceMappingURL=prompt.d.ts.map

package/dist/agents/prompt.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../../src/agents/prompt.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,4BAA4B,QAS7B,CAAA;AAEZ,eAAO,MAAM,qCAAqC,QAKtC,CAAA;AAEZ,eAAO,MAAM,gDAAgD,QASjD,CAAA;AAWZ,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,IAAI,CAAC,EAAE,cAAc,GAAG,UAAU,CAAA;CAC5C;AAED,MAAM,WAAW,uCAAuC;IACtD,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;CAC9B;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,2BAA2B,GAAG,MAAM,CAgBjF;AAED,mFAAmF;AACnF,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,uCAAuC,GAC7C,MAAM,CAKR"}