@sixb/core 0.1.6 → 0.1.8

package/src/queues/index.ts

@@ -1,3 +1,12 @@
+export type {
+  ModelCallCost,
+  ModelCostComponent,
+  ModelCostEstimate,
+  ModelCostMeter,
+  ModelMoney,
+  ModelRoute,
+} from "../models"
+export type { ModelProviderIds } from "../models/events"
 export type { ProviderScope } from "../provider-scope"
 export { QueueError } from "./errors"
 export { InMemoryQueues } from "./in-memory"
@@ -22,6 +31,8 @@ export type {
   QueueJobEnvelope,
   QueueJobFailure,
   Queues,
+  SubagentQueueJob,
+  SubagentRunRequestedQueueJob,
   SyncQueueJobFailureCode,
   SyncRunRequestedQueueJob,
   WorkflowQueueJob,

package/src/queues/types.ts

@@ -1,10 +1,10 @@
 import type { SixbErrorCode, SixbFailure } from "../errors/types"
 import type { JsonValue } from "../json"
+import type { ModelCallCost, ModelCostEstimate, ModelRoute } from "../models"
 import type { ProjectionRunFailureCode } from "../projections/types"
 import type { ProviderScope } from "../provider-scope"
 import type { ActionRunFailureCode } from "../storage/action-runs/types"
 import type { AgentRunFailureCode } from "../storage/agents/types"
-import type { AiPricingContext } from "../storage/ai-cost/types"
 import type { RecordAiModelCallInput } from "../storage/ai-usage"
 import type { PipelineRunFailureCode } from "../storage/pipeline-runs/types"
 import type { SyncRunFailureCode } from "../storage/sync-runs/types"
@@ -191,6 +191,17 @@ export interface AgentRunRequestedQueueJob
     }
   > {}
 
+/** A headless child run uses a reserved lane so waiting parents cannot consume its capacity. */
+export interface SubagentRunRequestedQueueJob
+  extends QueueJob<
+    "agent.subagent-run.requested",
+    {
+      readonly runId: string
+    }
+  > {}
+
+export type SubagentQueueJob = SubagentRunRequestedQueueJob
+
 export interface AgentWorkflowNodeRequestedQueueJob
   extends QueueJob<
     "agent.workflow-node.requested",
@@ -211,8 +222,12 @@ export type AgentAiUsageRecordPayload = Omit<
 }
 
 export interface AgentAiUsageAccountingPayload {
-  readonly pricingContext: AiPricingContext
+  readonly estimate?: ModelCostEstimate
+  readonly cost: ModelCallCost
+  readonly route?: ModelRoute
   readonly ratedAt: string
+  /** Absent on pre-limit jobs; those model calls did not create a reservation. */
+  readonly reconcileLimitReservation?: boolean
 }
 
 export interface AgentAiUsageRecordRequestedQueueJob
@@ -220,7 +235,7 @@ export interface AgentAiUsageRecordRequestedQueueJob
     "agent.ai-usage.record.requested",
     {
       readonly record: AgentAiUsageRecordPayload
-      /** Absent on Phase 1 jobs; recovery then uses an empty pricing context. */
+      /** Absent only on legacy jobs that predate atomic valuation recovery. */
       readonly accounting?: AgentAiUsageAccountingPayload
     }
   > {}
@@ -237,6 +252,8 @@ export interface Queues {
   readonly workflows: Queue<WorkflowQueueJob, WorkflowQueueJobFailureCode>
   readonly actions: Queue<ActionRunRequestedQueueJob, ActionQueueJobFailureCode>
   readonly agents: Queue<AgentQueueJob, AgentQueueJobFailureCode>
+  /** Internal capacity reserved for headless child runs. */
+  readonly agentChildren: Queue<SubagentQueueJob, AgentQueueJobFailureCode>
 
   /**
    * Whether these queues can be shared across processes.

package/src/rules/execution.ts

@@ -1,4 +1,5 @@
-import { isAllowed } from "../authorization"
+import { isRuntimeAllowed } from "../authorization"
+import { resolveRuntimeAuthorizationForProject } from "../execution/authorization"
 import type { DefinitionCatalog } from "../runtime/definitions"
 import type { SixbRuntimeContext } from "../runtime/types"
 import type { ListActiveRuleStatesInput, ListActiveRuleStatesResult } from "../storage/rules"
@@ -20,28 +21,39 @@ export function createRulesRuntime(
   runtime: SixbRuntimeContext,
   source: DefinitionCatalog<RuleDefinition>
 ): RulesRuntime {
-  const visible = (rule: RuleDefinition) =>
-    isAllowed(runtime.authorization, {
+  const authority = resolveRuntimeAuthorizationForProject(runtime)
+  const visible = (rule: RuleDefinition) => {
+    if (authority.type === "denied" || authority.type === "delegated") return false
+    return isRuntimeAllowed(runtime, {
       kind: "object.view",
       objectTypeId: rule.subject.objectTypeId,
     })
+  }
 
   return {
-    list: () => source.list().filter(visible),
+    list: () =>
+      authority.type === "denied" || authority.type === "delegated"
+        ? []
+        : source.list().filter(visible),
     getById: (ruleId) => {
+      if (authority.type === "denied" || authority.type === "delegated") return null
       const rule = source.getById(ruleId)
       return rule && visible(rule) ? rule : null
     },
     states: {
       list: (input = {}) => {
+        if (authority.type === "denied" || authority.type === "delegated") {
+          return Promise.resolve({ states: [], hasMore: false, total: 0 })
+        }
         const storage = runtime.storage.rules
         if (!storage) return Promise.resolve({ states: [], hasMore: false, total: 0 })
         return storage.listActive({
-          projectId: runtime.projectId,
           ...input,
-          objectTypeIds: runtime.authorization
-            ? [...runtime.authorization.grants["view:object"]]
-            : undefined,
+          objectTypeIds:
+            authority.type === "principal"
+              ? [...authority.context.grants["view:object"]]
+              : undefined,
+          projectId: runtime.projectId,
         })
       },
     },

package/src/runtime/create.ts

@@ -1,6 +1,7 @@
 import { resolve } from "node:path"
 import type { ActionDefinition } from "../actions"
-import type { AgentDefinition } from "../agents"
+import type { AgentToolDefinition } from "../agents"
+import { assertNoAgentDefinitions } from "../agents/retired-config"
 import type { SixbAuthConfig } from "../auth"
 import type { BlobStorage } from "../blob-storage"
 import { discoverOntologySources, discoverProjectDefinitions } from "../bootstrap"
@@ -19,6 +20,7 @@ import type { RuleDefinition } from "../rules"
 import type { SandboxFactory } from "../sandboxes"
 import type { ScheduleDefinition } from "../schedules"
 import type { GroupDefinition, MembershipPolicyDefinition, RoleDefinition } from "../security"
+import type { ShareDefinition } from "../shares"
 import type { Storage } from "../storage"
 import type { SyncDefinition } from "../syncs"
 import type { WorkflowDefinition } from "../workflows"
@@ -44,10 +46,10 @@ export interface CreateSixbOptions {
   ontologyMaintenance?: OntologyMaintenanceOptions
   ontologies?: readonly OntologySource[]
   actions?: readonly ActionDefinition[]
-  /** Agent definitions to register in addition to auto-discovered `agents/` exports. */
-  agents?: readonly AgentDefinition[]
   /** Models this project allows Sixb to use. The first of each kind is the default. */
   models?: ModelCatalogInput
+  /** Project tools available to Agent runtimes. */
+  tools?: readonly AgentToolDefinition[]
   datasets?: readonly DatasetDefinition[]
   /** Connector definitions to register in addition to auto-discovered `connectors/` exports. */
   connectors?: readonly ConnectorDefinition[]
@@ -62,6 +64,8 @@ export interface CreateSixbOptions {
   groups?: readonly GroupDefinition[]
   roles?: readonly RoleDefinition[]
   membershipPolicies?: readonly MembershipPolicyDefinition[]
+  /** Share definitions to register in addition to auto-discovered `shares/` exports. */
+  shares?: readonly ShareDefinition[]
   auth?: SixbAuthConfig
   projectRoot?: string
 }
@@ -71,12 +75,13 @@ export interface CreateSixbOptions {
  *
  * The host auto-discovers exported definitions from `ontology/`, `actions/`, `datasets/`,
  * `connectors/`, `syncs/`, `schedules/`, `pipelines/`, `projections/`,
- * `rules/`, `workflows/`, `agents/`, and `security/{groups,roles,policies}/`
+ * `rules/`, `workflows/`, `shares/`, and `security/{groups,roles,policies}/`
  * relative to `projectRoot`.
  */
 export async function createSixb(
   options: CreateSixbOptions
 ): Promise<SixbHost<readonly OntologySource[]>> {
+  assertNoAgentDefinitions(options)
   const projectRoot = resolve(options.projectRoot ?? process.cwd())
 
   const discoveredOntology = await discoverOntologySources(projectRoot)
@@ -120,8 +125,9 @@ export async function createSixb(
     groups: [...(options.groups ?? []), ...definitions.groups],
     roles: [...(options.roles ?? []), ...definitions.roles],
     membershipPolicies: [...(options.membershipPolicies ?? []), ...definitions.membershipPolicies],
-    agents: [...(options.agents ?? []), ...definitions.agents],
     models: options.models,
+    tools: options.tools,
+    shares: [...(options.shares ?? []), ...definitions.shares],
     auth: options.auth,
   })
 }

package/src/runtime/definitions.ts

@@ -1,5 +1,5 @@
 import type { ActionDefinitionCatalog } from "../actions"
-import type { AgentDefinition } from "../agents"
+import type { AgentToolCatalog } from "../agents"
 import type { ConnectorDefinition } from "../connectors"
 import type { DatasetDefinition } from "../datasets"
 import type { ModelCatalog } from "../models"
@@ -9,6 +9,7 @@ import type { ProjectionDefinitionCatalog } from "../projections"
 import type { RuleDefinition } from "../rules"
 import type { ScheduleDefinition } from "../schedules"
 import type { SecurityDefinitionCatalog } from "../security"
+import type { ShareDefinition } from "../shares"
 import type { SyncDefinition } from "../syncs"
 import type { WorkflowDefinition } from "../workflows"
 
@@ -22,7 +23,7 @@ export interface DefinitionCatalog<TDefinition> {
 export interface SixbDefinitions {
   readonly ontology: OntologyDefinitionCatalog
   readonly actions: ActionDefinitionCatalog
-  readonly agents: DefinitionCatalog<AgentDefinition>
+  readonly tools: AgentToolCatalog
   readonly connectors: DefinitionCatalog<ConnectorDefinition>
   readonly datasets: DefinitionCatalog<DatasetDefinition>
   /** Absent until a project configures `models` in createSixb(). */
@@ -32,6 +33,7 @@ export interface SixbDefinitions {
   readonly rules: DefinitionCatalog<RuleDefinition>
   readonly schedules: DefinitionCatalog<ScheduleDefinition>
   readonly security: SecurityDefinitionCatalog
+  readonly shares: DefinitionCatalog<ShareDefinition>
   readonly syncs: DefinitionCatalog<SyncDefinition>
   readonly workflows: DefinitionCatalog<WorkflowDefinition>
 }

package/src/runtime/host.ts

@@ -7,7 +7,7 @@
 
 import { resolve } from "node:path"
 import type { ActionDefinition } from "../actions/types"
-import type { AgentDefinition } from "../agents"
+import type { AgentToolDefinition } from "../agents"
 import {
   AuthRuntime,
   AuthRuntimeError,
@@ -36,7 +36,11 @@ import {
   type DomainEventService,
   OntologyOutboxDispatcher,
 } from "../events"
-import { resolveExecutionScopeAuthorization } from "../execution/authorization"
+import {
+  captureExecutionScope,
+  resolveExecutionScopeAuthorization,
+} from "../execution/authorization"
+import { createAuthorizedObjectReader } from "../execution/authorized-object-reader"
 import type { ExecutionScope } from "../execution/types"
 import type { LakeStorage } from "../lake-storage"
 import { type LoggerProvider, LoggingService, type ObservabilityOptions } from "../logging"
@@ -63,6 +67,7 @@ import type {
   RoleDefinition,
   SecurityDefinitionCatalog,
 } from "../security"
+import type { ShareDefinition } from "../shares"
 import type { Storage } from "../storage"
 import type { SyncDefinition } from "../syncs"
 import type { RegisteredWebhook } from "../webhooks"
@@ -108,11 +113,13 @@ export interface SixbHostOptions<TOntologySources extends readonly OntologySourc
   projections?: readonly ProjectionDefinition[]
   rules?: readonly RuleDefinition[]
   workflows?: readonly WorkflowDefinition[]
-  agents?: readonly AgentDefinition[]
   models?: ModelCatalogInput
+  /** Project tools available to Agent runtimes. */
+  tools?: readonly AgentToolDefinition[]
   groups?: readonly GroupDefinition[]
   roles?: readonly RoleDefinition[]
   membershipPolicies?: readonly MembershipPolicyDefinition[]
+  shares?: readonly ShareDefinition[]
   auth?: SixbAuthConfig
 }
 
@@ -238,24 +245,36 @@ export class SixbHost<
 
   /** Bind an existing opaque scope. This method never creates or escalates authority. */
   withScope(scope: ExecutionScope): Sixb<TOntologySources> {
-    const authorization = resolveExecutionScopeAuthorization(this.projectId, scope)
-    if (authorization.ref.type === "kernel") {
+    const capturedScope = captureExecutionScope(scope)
+    const authorization = resolveExecutionScopeAuthorization(this.projectId, capturedScope)
+    if (authorization.type === "unrestricted" && authorization.ref.type === "kernel") {
       throw new Error("[Sixb] Kernel authority cannot be bound to the domain SDK.")
     }
 
+    const objectReader = createAuthorizedObjectReader({
+      scope: capturedScope,
+      ontology: this.hostContext.ontology,
+      objectStorage: this.storage.objects,
+    })
+
     const runtime: SixbRuntimeContext = {
       ...this.hostContext,
-      runtimeAuthorization: scope.authorization,
+      runtimeAuthorization: capturedScope.authorization,
+      objectReader,
       ...(authorization.type === "principal" ? { authorization: authorization.context } : {}),
     }
     registerOntologyMutationRuntime(
       runtime,
       createOntologyMutationRuntime({
-        materializer: this.materializer.withScope(scope),
+        materializer: this.materializer.withScope(capturedScope),
         notifyCommittedFacts: () => this.committedFacts.notify(),
       })
     )
-    return createBoundSixb<TOntologySources>(runtime, this.sixbDependencies(), scope.execution)
+    return createBoundSixb<TOntologySources>(
+      runtime,
+      this.sixbDependencies(),
+      capturedScope.execution
+    )
   }
 
   get id(): string {
@@ -317,6 +336,7 @@ export class SixbHost<
         ? {}
         : { connectorConnections: this.connectorService.connectionProcess }),
       blobStorage: this.blobStorage,
+      lakeStorage: this.lakeStorage,
     }
   }
 }

package/src/runtime/internal.ts

@@ -9,6 +9,7 @@ export type {
   StartConnectorAuthorizationResult,
 } from "../connectors/connections/contracts"
 export type { ConnectorConnectionsRuntime } from "../connectors/connections/execution"
+export type { AuthorizedObjectReader } from "../execution/authorized-object-reader"
 export type { OntologyMutationRuntime } from "./ontology-mutations"
 export {
   createOntologyMutationRuntime,

package/src/runtime/resolve-definitions.ts

@@ -1,11 +1,12 @@
 import { ActionRegistry } from "../actions"
 import type { ActionDefinition } from "../actions/types"
-import type { AgentDefinition } from "../agents"
-import { validateAgentGroupReferences, validateAgentToolsAtStartup } from "../agents"
+import type { AgentToolDefinition } from "../agents"
+import { assertNoAgentDefinitions } from "../agents/retired-config"
+import { createAgentToolCatalog } from "../agents/tool-catalog"
 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 { createModelCatalog, type ModelCatalogInput } from "../models"
 import { OntologyRegistry } from "../ontology"
 import type { PipelineDefinition } from "../pipelines/types"
 import { ProjectionRegistry } from "../projections"
@@ -18,13 +19,14 @@ import {
   type RoleDefinition,
   SecurityRegistry,
 } from "../security"
+import { type ShareDefinition, validateSharesAtStartup } from "../shares"
 import type { SyncDefinition } from "../syncs"
 import {
   validateKeyedDatasetWriterTopology,
   validateMergeSyncProjectionSafety,
 } from "../syncs/validation"
 import type { WorkflowDefinition } from "../workflows"
-import { validateWorkflowsAtStartup } from "../workflows"
+import { validateWorkflowAgentStepGroupReferences, validateWorkflowsAtStartup } from "../workflows"
 import { createDefinitionCatalog, type SixbDefinitions } from "./definitions"
 import { RuntimeError } from "./errors"
 import type { OntologySource } from "./types"
@@ -40,8 +42,9 @@ interface DefinitionOptions {
   readonly projections?: readonly ProjectionDefinition[]
   readonly rules?: readonly RuleDefinition[]
   readonly workflows?: readonly WorkflowDefinition[]
-  readonly agents?: readonly AgentDefinition[]
+  readonly tools?: readonly AgentToolDefinition[]
   readonly models?: ModelCatalogInput
+  readonly shares?: readonly ShareDefinition[]
   readonly groups?: readonly GroupDefinition[]
   readonly roles?: readonly RoleDefinition[]
   readonly membershipPolicies?: readonly MembershipPolicyDefinition[]
@@ -56,15 +59,18 @@ interface ResolvedDefinitions extends SixbDefinitions {
 
 /** Resolve and cross-validate every registered definition before runtime services are composed. */
 export function resolveDefinitions(options: DefinitionOptions): ResolvedDefinitions {
+  assertNoAgentDefinitions(options)
   const ontology = new OntologyRegistry({ sources: options.ontology })
   const actionRegistry = new ActionRegistry({ actions: options.actions ?? [], ontology })
   const registeredActionIds = new Set(actionRegistry.list().map((action) => action.id))
+  const sharesById = validateSharesAtStartup({
+    shares: options.shares ?? [],
+    ontology,
+    actions: actionRegistry,
+  })
 
-  const agents = options.agents ?? []
-  validateAgentToolsAtStartup(agents)
   const models = options.models === undefined ? undefined : createModelCatalog(options.models)
-  validateAgentModelReferences(agents, models)
-  const agentsById = indexUniqueDefinitions("agent", agents)
+  const tools = createAgentToolCatalog(options.tools)
   const connectorsById = indexUniqueDefinitions("connector", options.connectors ?? [])
 
   // Datasets resolve first because syncs, pipelines, projections, and security depend on them.
@@ -126,7 +132,8 @@ export function resolveDefinitions(options: DefinitionOptions): ResolvedDefiniti
     workflows: options.workflows ?? [],
     registeredSchedules: schedulesById,
     registeredActionIds,
-    registeredAgentIds: new Set(agentsById.keys()),
+    ...(models === undefined ? {} : { models }),
+    tools,
   })
   const workflowsById = indexUniqueDefinitions("workflow", workflows)
 
@@ -140,11 +147,12 @@ export function resolveDefinitions(options: DefinitionOptions): ResolvedDefiniti
     workflowIds: new Set(workflowsById.keys()),
     syncIds: new Set(syncsById.keys()),
     pipelineIds: new Set(pipelinesById.keys()),
-    agentIds: new Set(agentsById.keys()),
+    agentAvailable: models !== undefined,
     connectorIds: new Set(connectorsById.keys()),
+    shareIds: new Set(sharesById.keys()),
     getSubTypes: (objectTypeId) => ontology.listSubTypes(objectTypeId),
   })
-  validateAgentGroupReferences(agents, security)
+  validateWorkflowAgentStepGroupReferences(workflows, security)
 
   const projectionRegistry = new ProjectionRegistry({
     projections: options.projections ?? [],
@@ -159,7 +167,7 @@ export function resolveDefinitions(options: DefinitionOptions): ResolvedDefiniti
   return Object.freeze({
     ontology,
     actions: actionRegistry,
-    agents: createDefinitionCatalog(agentsById),
+    tools,
     connectors: createDefinitionCatalog(connectorsById),
     datasets: createDefinitionCatalog(datasetsById),
     ...(models === undefined ? {} : { models }),
@@ -168,6 +176,7 @@ export function resolveDefinitions(options: DefinitionOptions): ResolvedDefiniti
     rules: createDefinitionCatalog(rulesById),
     schedules: createDefinitionCatalog(schedulesById),
     security,
+    shares: createDefinitionCatalog(sharesById),
     syncs: createDefinitionCatalog(syncsById),
     workflows: createDefinitionCatalog(workflowsById),
   })
@@ -241,26 +250,3 @@ 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/runtime/sixb.ts

@@ -1,5 +1,6 @@
 import { type ActionsRuntime, createActionsRuntime } from "../actions/execution"
-import { type AgentsRuntime, createAgentsRuntime } from "../agents/execution"
+import { type AgentRuntime, createAgentRuntime } from "../agents/execution"
+import { type AiUsageRuntime, createAiUsageRuntime } from "../ai-usage"
 import { type BlobsRuntime, createBlobsRuntime } from "../blob-storage/execution"
 import type { BlobStorage } from "../blob-storage/types"
 import { registerConnectorConnectionsRuntime } from "../connectors/connections/capability"
@@ -10,6 +11,9 @@ import type { ConnectorService } from "../connectors/service"
 import { createDatasetsRuntime, type DatasetsRuntime } from "../datasets/execution"
 import { createEventsRuntime, type EventsRuntime } from "../events/execution"
 import type { ExecutionContext } from "../execution"
+import { resolveExecutionScopeAuthorization } from "../execution/authorization"
+import { assertAuthorizedObjectReaderBinding } from "../execution/authorized-object-reader"
+import type { LakeStorage } from "../lake-storage/types"
 import { createLogsRuntime, type LogsRuntime } from "../logging/execution"
 import type { LoggingService } from "../logging/service"
 import { createObjectsRuntime, type ObjectsRuntime } from "../objects/execution"
@@ -17,6 +21,7 @@ import { createPipelinesRuntime, type PipelinesRuntime } from "../pipelines/exec
 import { createProjectionsRuntime, type ProjectionsRuntime } from "../projections/execution"
 import { createRulesRuntime, type RulesRuntime } from "../rules/execution"
 import { createSchedulesRuntime, type SchedulesRuntime } from "../schedules/execution"
+import { createSharesRuntime, type SharesRuntime } from "../shares/execution"
 import { createSyncsRuntime, type SyncsRuntime } from "../syncs/execution"
 import { createWorkflowsRuntime, type WorkflowsRuntime } from "../workflows/execution"
 import type { SixbDefinitions } from "./definitions"
@@ -36,10 +41,12 @@ export interface Sixb<
   readonly pipelines: PipelinesRuntime
   readonly projections: ProjectionsRuntime
   readonly rules: RulesRuntime
-  readonly agents: AgentsRuntime
+  readonly agent: AgentRuntime
+  readonly aiUsage: AiUsageRuntime
   readonly events: EventsRuntime
   readonly logs: LogsRuntime
   readonly schedules: SchedulesRuntime
+  readonly shares: SharesRuntime
   readonly connector: ConnectorRuntime
   readonly blobs: BlobsRuntime
 }
@@ -52,6 +59,7 @@ export interface SixbDependencies {
   readonly connectorService: ConnectorService
   readonly connectorConnections?: ConnectorConnectionProcess
   readonly blobStorage: BlobStorage
+  readonly lakeStorage: LakeStorage
 }
 
 export function createBoundSixb<TOntologySources extends readonly OntologySource[]>(
@@ -59,6 +67,14 @@ export function createBoundSixb<TOntologySources extends readonly OntologySource
   dependencies: SixbDependencies,
   execution: ExecutionContext
 ): Sixb<TOntologySources> {
+  resolveExecutionScopeAuthorization(runtime.projectId, {
+    execution,
+    authorization: runtime.runtimeAuthorization,
+  })
+  assertAuthorizedObjectReaderBinding({
+    reader: runtime.objectReader,
+    scope: { execution, authorization: runtime.runtimeAuthorization },
+  })
   const sixb: Sixb<TOntologySources> = {
     execution,
     ...createExecutionFacades<TOntologySources>(runtime, execution, dependencies),
@@ -89,21 +105,24 @@ function createExecutionFacades<TOntologySources extends readonly OntologySource
   return {
     objects: createObjectsRuntime<TOntologySources>(runtime, execution),
     actions: createActionsRuntime(runtime, execution),
-    datasets: createDatasetsRuntime(runtime, dependencies.definitions.datasets),
+    datasets: createDatasetsRuntime(
+      runtime,
+      execution,
+      dependencies.definitions.datasets,
+      dependencies.lakeStorage,
+      dependencies.blobStorage
+    ),
     workflows: createWorkflowsRuntime(runtime, execution, dependencies.definitions.workflows),
     syncs: createSyncsRuntime(runtime, execution, dependencies.definitions.syncs),
     pipelines: createPipelinesRuntime(runtime, execution, dependencies.definitions.pipelines),
     projections: createProjectionsRuntime(runtime, dependencies.definitions.projections),
     rules: createRulesRuntime(runtime, dependencies.definitions.rules),
-    agents: createAgentsRuntime(
-      runtime,
-      execution,
-      dependencies.definitions.agents,
-      dependencies.definitions.security
-    ),
+    agent: createAgentRuntime(runtime, execution, dependencies.definitions.models),
+    aiUsage: createAiUsageRuntime(runtime, dependencies.definitions.security),
     events: createEventsRuntime(runtime),
     logs: createLogsRuntime(runtime, dependencies.logging),
-    schedules: createSchedulesRuntime(dependencies.definitions.schedules),
+    schedules: createSchedulesRuntime(runtime, dependencies.definitions.schedules),
+    shares: createSharesRuntime(runtime, execution, dependencies.definitions.shares),
     connector: createConnectorRuntime(runtime, execution, dependencies.connectorService),
     blobs: createBlobsRuntime(runtime, execution, dependencies.blobStorage),
   }

package/src/runtime/types.ts

@@ -15,6 +15,7 @@ import type { AuthorizationContext } from "../authorization"
 import type { Broker } from "../broker"
 import type { DomainEventLog } from "../events"
 import type { RuntimeAuthorization } from "../execution"
+import type { AuthorizedObjectReader } from "../execution/authorized-object-reader"
 import type {
   ObjectQuery,
   ObjectQueryExplanation,
@@ -60,6 +61,8 @@ export interface SixbHostContext {
 /** Host dependencies paired with the process-local authority of one bound execution. */
 export interface SixbRuntimeContext extends SixbHostContext {
   readonly runtimeAuthorization: RuntimeAuthorization
+  /** Core-owned read boundary carrying this exact execution authority. */
+  readonly objectReader: AuthorizedObjectReader
   /**
    * Resolved principal grants. Absent for trusted primitive and explicitly disabled executions.
    * The opaque `runtimeAuthorization` remains the source of authority.

package/src/schedules/execution.ts

@@ -1,14 +1,36 @@
+import { resolveRuntimeAuthorizationForProject } from "../execution/authorization"
 import type { DefinitionCatalog } from "../runtime/definitions"
+import type { SixbRuntimeContext } from "../runtime/types"
 import type { ScheduleDefinition } from "./types"
 
 /** Schedule definitions visible to an execution; process lifecycle remains on the host. */
 export type SchedulesRuntime = DefinitionCatalog<ScheduleDefinition>
 
 export function createSchedulesRuntime(
+  runtime: SixbRuntimeContext,
   schedules: DefinitionCatalog<ScheduleDefinition>
 ): SchedulesRuntime {
+  const authority = resolveRuntimeAuthorizationForProject(runtime)
   return {
-    list: () => schedules.list(),
-    getById: (scheduleId) => schedules.getById(scheduleId),
+    list: () => {
+      switch (authority.type) {
+        case "denied":
+        case "delegated":
+          return []
+        case "principal":
+        case "unrestricted":
+          return schedules.list()
+      }
+    },
+    getById: (scheduleId) => {
+      switch (authority.type) {
+        case "denied":
+        case "delegated":
+          return null
+        case "principal":
+        case "unrestricted":
+          return schedules.getById(scheduleId)
+      }
+    },
   }
 }

package/src/security/every.ts

@@ -12,11 +12,11 @@
  */
 
 import type { ActionDefinition } from "../actions/types"
-import type { AgentDefinition } from "../agents/types"
 import type { ConnectorDefinition } from "../connectors"
 import type { DatasetDefinition } from "../datasets"
 import type { ObjectType } from "../ontology"
 import type { PipelineDefinition } from "../pipelines"
+import type { ShareDefinition } from "../shares"
 import type { SyncDefinition } from "../syncs"
 import type { WorkflowDefinition } from "../workflows/types"
 import { SecurityValidationError } from "./errors"
@@ -30,9 +30,9 @@ export const BREADTH_TARGETS = [
   "workflow",
   "sync",
   "pipeline",
-  "agent",
   "application",
   "connector",
+  "share",
 ] as const
 
 export type BreadthTarget = (typeof BREADTH_TARGETS)[number]
@@ -44,9 +44,9 @@ interface BreadthTargetInput {
   workflow: WorkflowDefinition
   sync: SyncDefinition
   pipeline: PipelineDefinition
-  agent: AgentDefinition
   application: ApplicationDefinition
   connector: ConnectorDefinition
+  share: ShareDefinition
 }
 
 /**
@@ -106,7 +106,7 @@ export const every = {
   workflow: (): BreadthSelector<"workflow"> => all("workflow"),
   sync: (): BreadthSelector<"sync"> => all("sync"),
   pipeline: (): BreadthSelector<"pipeline"> => all("pipeline"),
-  agent: (): BreadthSelector<"agent"> => all("agent"),
   application: (): BreadthSelector<"application"> => all("application"),
   connector: (): BreadthSelector<"connector"> => all("connector"),
+  share: (): BreadthSelector<"share"> => all("share"),
 }