@sixb/core 0.1.2 → 0.1.4

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

@@ -55,6 +55,23 @@ const devices = defineDataset("storage_contract_devices", {
 const readings = defineDataset("storage_contract_readings", {
   schema: [col("device_id", "string"), col("at", "timestamp"), col("value", "float64")],
 })
+const ConflictDevice = defineObjectType({
+  id: "StorageContractConflictDevice",
+  name: "Conflict device",
+  properties: [
+    prop("id", "string", { primary: true, required: true }),
+    prop("name", "string", { required: true }),
+    prop("state", "string", { required: true }),
+  ],
+})
+const conflictDevices = defineDataset("storage_contract_conflict_devices", {
+  schema: [
+    col("id", "string"),
+    col("name", "string"),
+    col("state", "string"),
+    col("updated_at", "timestamp"),
+  ],
+})
 const deviceProjection = defineProjection("storage_contract_devices", Device)
   .fromDataset(devices)
   .properties({ id: "id", name: "name" })
@@ -71,14 +88,22 @@ const temperatureProjection = defineProjection(
 )
   .fromDataset(readings)
   .points({ objectId: "device_id", at: "at", value: "value" })
+const conflictDeviceProjection = defineProjection(
+  "storage_contract_conflict_devices",
+  ConflictDevice
+)
+  .fromDataset(conflictDevices)
+  .properties({ id: "id", name: "name", state: "state" })
+  .resolveConflicts({ strategy: "mostRecent", sourceTimestamp: "updated_at" })
 
-const ontology = new OntologyRegistry({ sources: [Device] })
+const ontology = new OntologyRegistry({ sources: [Device, ConflictDevice] })
 const projections = new ProjectionRegistry({
-  projections: [deviceProjection, temperatureProjection],
+  projections: [deviceProjection, temperatureProjection, conflictDeviceProjection],
   ontology,
   datasetsById: new Map<string, DatasetDefinition>([
     [devices.id, devices],
     [readings.id, readings],
+    [conflictDevices.id, conflictDevices],
   ]),
 })
 
@@ -339,6 +364,99 @@ export function runMaterializerStorageContractSuite<TStorage extends Storage>(
     }
   })
 
+  test(`${name} persists per-property Action edit times`, async () => {
+    const createdStorage = await provider.createStorage()
+    const storage = requireContractStorage(createdStorage)
+    let materializationOrdinal = 0
+    let now = new Date("2026-02-01T00:00:10.000Z")
+    const materializer = createOntologyMaterializer({
+      projectId: "materializer-storage-contract",
+      ontology,
+      projections,
+      storage,
+      dependencies: {
+        batching: { sourceStageRows: 1, statePageRows: 1, planChunkRows: 1 },
+        clock: () => now,
+        materializationId: () => `conflict-contract-candidate-${++materializationOrdinal}`,
+      },
+    })
+    const runtimeMaterializer = materializer.withScope(runtimeScope())
+    const ref = { objectTypeId: ConflictDevice.id, primaryId: "one" }
+    const replace = async (
+      versionId: string,
+      sourceUpdatedAt: string,
+      name: string,
+      state: string
+    ) => {
+      const datasetVersion = {
+        datasetId: conflictDevices.id,
+        versionId,
+        createdAt: sourceUpdatedAt,
+      }
+      const execution = await claim(storage, {
+        runId: `conflict-${versionId}`,
+        projectionId: conflictDeviceProjection.id,
+        protocol: "replacement",
+        datasetVersion,
+      })
+      const projectionMaterializerForRun = await projectionMaterializer(
+        materializer,
+        storage,
+        conflictDeviceProjection.id,
+        `conflict-${versionId}`
+      )
+      await projectionMaterializerForRun.projections.replace({
+        source: { projectionId: conflictDeviceProjection.id },
+        datasetVersion,
+        execution,
+        entries: entries([
+          {
+            root: { kind: "object", ref },
+            assertions: [{ kind: "object", ref, properties: { name, state }, sourceUpdatedAt }],
+          },
+        ]),
+      })
+    }
+    const edit = (requestId: string, propertyId: "name" | "state", value: string) =>
+      runtimeMaterializer.edits.commit({
+        mode: "atomic",
+        source: { kind: "runtime", requestId },
+        operations: [
+          {
+            id: requestId,
+            kind: "object.patch",
+            ref,
+            set: { [propertyId]: value },
+            unset: [],
+            reset: [],
+          },
+        ],
+        expectedObjects: [],
+        expectedLinks: [],
+        expectedLinkScopes: [],
+      })
+
+    try {
+      await replace("v1", "2026-02-01T00:00:10.000Z", "Source A", "source-open")
+
+      now = new Date("2026-02-01T00:00:11.000Z")
+      await edit("conflict-name", "name", "Action B")
+      now = new Date("2026-02-01T00:00:13.000Z")
+      await edit("conflict-state", "state", "action-closed")
+
+      await replace("v2", "2026-02-01T00:00:12.000Z", "Source C", "source-changed")
+      expect(
+        await storage.objects.getByPrimaryId({
+          projectId: "materializer-storage-contract",
+          objectTypeId: ConflictDevice.id,
+          primaryId: "one",
+        })
+      ).toMatchObject({ properties: { id: "one", name: "Source C", state: "action-closed" } })
+    } finally {
+      await provider.cleanup?.(createdStorage)
+    }
+  })
+
   test(`${name} persists cardinality-one edit authority by scope`, async () => {
     const createdStorage = await provider.createStorage()
     const storage = requireContractStorage(createdStorage)

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/src/workers/queue-worker.ts

@@ -66,11 +66,16 @@ export abstract class QueueWorker<
       failureCodes: config.failureCodes,
       workerId: config.workerId,
       leaseMs: config.leaseMs ?? DEFAULT_LEASE_MS,
-      claimLimit: config.claimLimit ?? DEFAULT_CLAIM_LIMIT,
+      claimLimit: normalizeClaimLimit(config.claimLimit),
       idlePollMs: config.idlePollMs ?? DEFAULT_IDLE_POLL_MS,
     }
   }
 
+  /** Maximum jobs this worker process claims and executes at once. */
+  get concurrency(): number {
+    return this.config.claimLimit
+  }
+
   protected async run(signal: AbortSignal): Promise<void> {
     const inFlight = new Set<Promise<void>>()
     let runError: unknown = null
@@ -243,6 +248,14 @@ export abstract class QueueWorker<
   }
 }
 
+function normalizeClaimLimit(value: number | undefined): number {
+  const claimLimit = value ?? DEFAULT_CLAIM_LIMIT
+  if (!Number.isSafeInteger(claimLimit) || claimLimit < 1) {
+    throw new Error("[SixbQueueWorker] Worker concurrency must be a positive safe integer.")
+  }
+  return claimLimit
+}
+
 async function settleOrLog<TJob extends QueueJob, TFailureCode extends SixbErrorCode>(
   delivery: QueueDelivery<TJob, TFailureCode>,
   operation: string,

package/src/workflows/execution.ts

@@ -1,7 +1,9 @@
 import { canViewWorkflowIntervention, canViewWorkflowRun, isAllowed } from "../authorization"
 import type { AuthorizablePrincipal, ExecutionContext } from "../execution"
+import { resolveExecutionCosts } from "../runtime/ai-cost"
 import { resolveExecutionUsage } from "../runtime/ai-usage"
 import type { SixbRuntimeContext } from "../runtime/types"
+import type { AiCostSummary } from "../storage/ai-cost"
 import type { AiModelCallUsage } from "../storage/ai-usage"
 import type {
   ListWorkflowInterventionsInput,
@@ -61,6 +63,8 @@ export type ListWorkflowRunNodesInput = Omit<
 /** Execution-facing Agent node view derived from its run row and model-call ledger. */
 export interface WorkflowAgentNodeRunView extends Omit<WorkflowAgentNodeRunRecord, "execution"> {
   readonly usage?: AiModelCallUsage
+  /** Preferred valuation; omitted when there are no calls or cost storage is unavailable. */
+  readonly cost?: AiCostSummary
 }
 
 /** Execution-facing workflow node view with optional Agent execution details. */
@@ -226,29 +230,45 @@ async function attachWorkflowNodeViews(
   )
   if (agentExecutions.length === 0) return nodes
 
-  const usages = await resolveExecutionUsage({
-    storage: runtime.storage.aiUsage,
-    projectId: runtime.projectId,
-    executionIds: agentExecutions.map((execution) => execution.executionId),
-  })
-  const usageByExecutionId = new Map(
-    agentExecutions.map((execution, index) => [execution.executionId, usages[index]] as const)
+  const executionIds = agentExecutions.map((execution) => execution.executionId)
+  const [usages, costs] = await Promise.all([
+    resolveExecutionUsage({
+      storage: runtime.storage.aiUsage,
+      projectId: runtime.projectId,
+      executionIds,
+    }),
+    resolveExecutionCosts({
+      storage: runtime.storage.aiCosts,
+      projectId: runtime.projectId,
+      executionIds,
+    }),
+  ])
+  const accountingByExecutionId = new Map(
+    agentExecutions.map((execution, index) => [
+      execution.executionId,
+      { usage: usages[index], cost: costs[index] },
+    ])
   )
 
   return nodes.map((node, index) => {
     const execution = executions[index]
     if (!execution) return node
-    const usage = usageByExecutionId.get(execution.executionId)
+    const accounting = accountingByExecutionId.get(execution.executionId)
     return {
       ...node,
-      agentExecution: toWorkflowAgentNodeRunView(execution, usage),
+      agentExecution: toWorkflowAgentNodeRunView(
+        execution,
+        accounting?.usage,
+        accounting?.usage === undefined ? undefined : accounting.cost
+      ),
     }
   })
 }
 
 function toWorkflowAgentNodeRunView(
   execution: WorkflowAgentNodeRunRecord,
-  usage: AiModelCallUsage | undefined
+  usage: AiModelCallUsage | undefined,
+  cost: AiCostSummary | undefined
 ): WorkflowAgentNodeRunView {
   return {
     projectId: execution.projectId,
@@ -267,6 +287,7 @@ function toWorkflowAgentNodeRunView(
     startedAt: execution.startedAt,
     completedAt: execution.completedAt,
     ...(usage === undefined ? {} : { usage }),
+    ...(usage === undefined || cost === undefined ? {} : { cost }),
   }
 }
 

package/dist/agents/prompt.d.ts

@@ -1,15 +0,0 @@
-export declare const DEFAULT_AGENT_SYSTEM_CONTEXT: string;
-export declare const DEFAULT_AGENT_TASK_SYSTEM_CONTEXT: string;
-export interface BuildAgentSystemPromptInput {
-    readonly instructions: string;
-    readonly addendum?: string;
-    readonly mode?: "conversation" | "task";
-}
-/**
- * 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;
-//# 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,QAQ7B,CAAA;AAEZ,eAAO,MAAM,iCAAiC,QAKlC,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,MAAM,CAAA;CACxC;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,2BAA2B,GAAG,MAAM,CAcjF"}