@sixb/core 0.1.7 → 0.1.9

package/src/projections/run-dispatch.ts

@@ -4,7 +4,7 @@ import { createSixbError, toSixbFailure } from "../errors/internal"
 import type { SixbFailure } from "../errors/types"
 import type { RunDispatcher } from "../execution/dispatch"
 import { createPrimitiveExecutionRecord } from "../execution/durable"
-import type { LakeStorage } from "../lake-storage"
+import type { DatasetProducer, LakeStorage } from "../lake-storage"
 import type { Queues } from "../queues"
 import type { SixbDefinitions } from "../runtime/definitions"
 import type { ExecutionRecord, ProjectionRunRecord, Storage } from "../storage"
@@ -144,6 +144,7 @@ async function persistProjectionRun(input: {
         versionId: input.identity.datasetVersion.versionId,
       },
       correlationId: input.producerExecution?.correlationId ?? input.runId,
+      requesterGroupIds: input.producerExecution?.requesterGroupIds,
       ...(input.producerExecution?.requestedBy === undefined
         ? {}
         : { requestedBy: input.producerExecution.requestedBy }),
@@ -289,14 +290,11 @@ async function assertExistingRun(
 async function resolveProducerExecution(
   storage: Storage,
   projectId: string,
-  producer:
-    | {
-        readonly kind: "sync" | "pipeline"
-        readonly id?: string
-        readonly runId?: string
-      }
-    | undefined
+  producer: DatasetProducer | undefined
 ): Promise<ExecutionRecord | null> {
+  if (producer?.kind === "ingest") {
+    return producer.id ? storage.executions.getById({ projectId, id: producer.id }) : null
+  }
   if (!producer?.runId) return null
   if (producer.kind === "sync") {
     const run = await storage.syncRuns?.getById({ projectId, id: producer.runId })
@@ -342,10 +340,7 @@ async function requireProducerExecution(input: {
   )
 }
 
-function assertProducerId(
-  producer: { readonly kind: "sync" | "pipeline"; readonly id?: string; readonly runId?: string },
-  runOwnerId: string
-): void {
+function assertProducerId(producer: DatasetProducer, runOwnerId: string): void {
   if (producer.id === undefined || producer.id === runOwnerId) return
   throw new ProjectionValidationError(
     `[Sixb] Dataset producer '${producer.kind}:${producer.id}' does not match run '${producer.runId}'.`

package/src/query.ts

@@ -40,7 +40,6 @@ export type {
   ObjectQueryTraverse,
   ObjectQueryVector,
 } from "./objects/query/ir"
-export { normalizeObjectQuery } from "./objects/query/normalize"
 export { createObjectQueryBuilder } from "./objects/sdk/query-builder"
 export type {
   ObjectQueryExecutor,

package/src/queues/index.ts

@@ -7,14 +7,16 @@ export type {
   ModelRoute,
 } from "../models"
 export type { ModelProviderIds } from "../models/events"
+export type {
+  AiModelCallAccountingPayload,
+  AiModelCallRecordPayload,
+} from "../models/execution/types"
 export type { ProviderScope } from "../provider-scope"
 export { QueueError } from "./errors"
 export { InMemoryQueues } from "./in-memory"
 export type {
   ActionQueueJobFailureCode,
   ActionRunRequestedQueueJob,
-  AgentAiUsageAccountingPayload,
-  AgentAiUsageRecordPayload,
   AgentAiUsageRecordRequestedQueueJob,
   AgentQueueJob,
   AgentQueueJobFailureCode,

package/src/queues/types.ts

@@ -1,11 +1,13 @@
 import type { SixbErrorCode, SixbFailure } from "../errors/types"
 import type { JsonValue } from "../json"
-import type { ModelCallCost, ModelCostEstimate, ModelRoute } from "../models"
+import type {
+  AiModelCallAccountingPayload,
+  AiModelCallRecordPayload,
+} from "../models/execution/types"
 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 { RecordAiModelCallInput } from "../storage/ai-usage"
 import type { PipelineRunFailureCode } from "../storage/pipeline-runs/types"
 import type { SyncRunFailureCode } from "../storage/sync-runs/types"
 import type { WorkflowRunFailureCode } from "../storage/workflow-runs/types"
@@ -210,33 +212,12 @@ export interface AgentWorkflowNodeRequestedQueueJob
     }
   > {}
 
-/** JSON-safe representation of one model-call ledger append awaiting durable recovery. */
-export type AgentAiUsageRecordPayload = Omit<
-  RecordAiModelCallInput,
-  "projectId" | "usage" | "occurredAt" | "recordedAt"
-> & {
-  readonly usage: {
-    readonly [Field in keyof RecordAiModelCallInput["usage"]]: RecordAiModelCallInput["usage"][Field]
-  }
-  readonly occurredAt: string
-}
-
-export interface AgentAiUsageAccountingPayload {
-  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
   extends QueueJob<
     "agent.ai-usage.record.requested",
     {
-      readonly record: AgentAiUsageRecordPayload
-      /** Absent only on legacy jobs that predate atomic valuation recovery. */
-      readonly accounting?: AgentAiUsageAccountingPayload
+      readonly record: AiModelCallRecordPayload
+      readonly accounting: AiModelCallAccountingPayload
     }
   > {}
 

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

@@ -10,7 +10,8 @@ import type { ConnectorConnectionOptions, ConnectorDefinition } from "../connect
 import type { DatasetDefinition } from "../datasets"
 import type { SixbErrorHandler } from "../error-reporting/types"
 import type { LakeStorage } from "../lake-storage"
-import type { LoggerProvider, ObservabilityOptions } from "../logging"
+import type { LoggerProvider } from "../logging"
+import type { ObservabilityOptions } from "../logging/service"
 import type { OntologyMaintenanceOptions } from "../maintenance"
 import type { ModelCatalogInput } from "../models"
 import type { PipelineDefinition } from "../pipelines/types"
@@ -20,6 +21,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"
@@ -63,6 +65,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
 }
@@ -72,7 +76,7 @@ export interface CreateSixbOptions {
  *
  * The host auto-discovers exported definitions from `ontology/`, `actions/`, `datasets/`,
  * `connectors/`, `syncs/`, `schedules/`, `pipelines/`, `projections/`,
- * `rules/`, `workflows/`, and `security/{groups,roles,policies}/`
+ * `rules/`, `workflows/`, `shares/`, and `security/{groups,roles,policies}/`
  * relative to `projectRoot`.
  */
 export async function createSixb(
@@ -124,6 +128,7 @@ export async function createSixb(
     membershipPolicies: [...(options.membershipPolicies ?? []), ...definitions.membershipPolicies],
     models: options.models,
     tools: options.tools,
+    shares: [...(options.shares ?? []), ...definitions.shares],
     auth: options.auth,
   })
 }

package/src/runtime/definitions.ts

@@ -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"
 
@@ -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

@@ -36,10 +36,15 @@ 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"
+import type { LoggerProvider } from "../logging"
+import { LoggingService, type ObservabilityOptions } from "../logging/service"
 import {
   OntologyMaintenance,
   type OntologyMaintenanceHandle,
@@ -63,6 +68,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"
@@ -114,6 +120,7 @@ export interface SixbHostOptions<TOntologySources extends readonly OntologySourc
   groups?: readonly GroupDefinition[]
   roles?: readonly RoleDefinition[]
   membershipPolicies?: readonly MembershipPolicyDefinition[]
+  shares?: readonly ShareDefinition[]
   auth?: SixbAuthConfig
 }
 
@@ -239,24 +246,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 {
@@ -318,6 +337,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

@@ -19,6 +19,7 @@ import {
   type RoleDefinition,
   SecurityRegistry,
 } from "../security"
+import { type ShareDefinition, validateSharesAtStartup } from "../shares"
 import type { SyncDefinition } from "../syncs"
 import {
   validateKeyedDatasetWriterTopology,
@@ -43,6 +44,7 @@ interface DefinitionOptions {
   readonly workflows?: readonly WorkflowDefinition[]
   readonly tools?: readonly AgentToolDefinition[]
   readonly models?: ModelCatalogInput
+  readonly shares?: readonly ShareDefinition[]
   readonly groups?: readonly GroupDefinition[]
   readonly roles?: readonly RoleDefinition[]
   readonly membershipPolicies?: readonly MembershipPolicyDefinition[]
@@ -61,6 +63,11 @@ export function resolveDefinitions(options: DefinitionOptions): ResolvedDefiniti
   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 models = options.models === undefined ? undefined : createModelCatalog(options.models)
   const tools = createAgentToolCatalog(options.tools)
@@ -142,6 +149,7 @@ export function resolveDefinitions(options: DefinitionOptions): ResolvedDefiniti
     pipelineIds: new Set(pipelinesById.keys()),
     agentAvailable: models !== undefined,
     connectorIds: new Set(connectorsById.keys()),
+    shareIds: new Set(sharesById.keys()),
     getSubTypes: (objectTypeId) => ontology.listSubTypes(objectTypeId),
   })
   validateWorkflowAgentStepGroupReferences(workflows, security)
@@ -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),
   })

package/src/runtime/sixb.ts

@@ -11,13 +11,19 @@ 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 { createModelsRuntime } from "../models/execution"
+import type { ModelsRuntime } from "../models/generation-types"
 import { createObjectsRuntime, type ObjectsRuntime } from "../objects/execution"
 import { createPipelinesRuntime, type PipelinesRuntime } from "../pipelines/execution"
 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"
@@ -38,10 +44,12 @@ export interface Sixb<
   readonly projections: ProjectionsRuntime
   readonly rules: RulesRuntime
   readonly agent: AgentRuntime
+  readonly models: ModelsRuntime
   readonly aiUsage: AiUsageRuntime
   readonly events: EventsRuntime
   readonly logs: LogsRuntime
   readonly schedules: SchedulesRuntime
+  readonly shares: SharesRuntime
   readonly connector: ConnectorRuntime
   readonly blobs: BlobsRuntime
 }
@@ -54,6 +62,7 @@ export interface SixbDependencies {
   readonly connectorService: ConnectorService
   readonly connectorConnections?: ConnectorConnectionProcess
   readonly blobStorage: BlobStorage
+  readonly lakeStorage: LakeStorage
 }
 
 export function createBoundSixb<TOntologySources extends readonly OntologySource[]>(
@@ -61,6 +70,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),
@@ -91,17 +108,25 @@ 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),
     agent: createAgentRuntime(runtime, execution, dependencies.definitions.models),
+    models: createModelsRuntime(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/sandboxes/errors.ts

@@ -6,6 +6,11 @@ export class SandboxError extends Error {
   readonly name: string = "SandboxError"
 }
 
+/** The named sandbox or its saved filesystem no longer exists. Explicit recreation is required. */
+export class SandboxStateUnavailableError extends SandboxError {
+  override readonly name = "SandboxStateUnavailableError"
+}
+
 /** runCommand / stop / destroy called after the sandbox is stopped or destroyed. */
 export class SandboxNotRunningError extends SandboxError {
   override readonly name = "SandboxNotRunningError"

package/src/sandboxes/index.ts

@@ -2,6 +2,7 @@ export {
   SandboxError,
   SandboxIsolationUnavailableError,
   SandboxNotRunningError,
+  SandboxStateUnavailableError,
   SandboxTimeoutError,
 } from "./errors"
 export type { ExecOptions } from "./exec"
@@ -9,11 +10,13 @@ export { exec } from "./exec"
 export type {
   CommandResult,
   CreateSandboxOptions,
+  ResumeSandboxOptions,
   RunCommandOptions,
   Sandbox,
   SandboxFactory,
   SandboxFileRecord,
   SandboxNetworkPolicy,
   SandboxNetworkTarget,
+  SandboxSessionOptions,
   SandboxStatus,
 } from "./sandbox"

package/src/sandboxes/sandbox.ts

@@ -72,17 +72,25 @@ export interface SandboxNetworkTarget {
   readonly origin: string
 }
 
-/**
- * Options accepted by every SandboxFactory.create. Provider-specific factories
- * may extend this type with their own options.
- */
-export interface CreateSandboxOptions {
+/** Current execution defaults, supplied on both creation and resume, never recovered from files. */
+export interface SandboxSessionOptions {
   readonly workingDirectory?: string
   readonly env?: Readonly<Record<string, string>>
   readonly timeout?: number
   readonly network?: SandboxNetworkPolicy
 }
 
+/** Options accepted by every SandboxFactory.create. */
+export interface CreateSandboxOptions extends SandboxSessionOptions {
+  /** Create new named state; reject an existing name or unsupported persistence before provisioning. */
+  readonly persistence?: { readonly name: string }
+}
+
+/** Resume changes execution defaults, not the identity or creation configuration of saved state. */
+export interface ResumeSandboxOptions extends SandboxSessionOptions {
+  readonly persistence?: never
+}
+
 export interface Sandbox {
   readonly id: string
   /** Provider id matching the package suffix, for example "local". */
@@ -109,16 +117,36 @@ export interface Sandbox {
    */
   writeFiles(files: readonly SandboxFileRecord[]): Promise<void>
 
-  /** Mark the sandbox stopped; subsequent runCommand calls reject. Idempotent. */
+  /** Stop this session; subsequent operations reject. Idempotent.
+   * Persistent handles confirm preservation and share the outcome, including failure,
+   * across repeated/concurrent calls.
+   */
   stop(): Promise<void>
-  /** Stop and reclaim any provider-side resources. Idempotent. */
+  /** Stop and reclaim resources, permanently deleting named state when persistent. Idempotent.
+   * Requires exclusive lifecycle ownership, including after stop(); never routine persistent teardown.
+   */
   destroy(): Promise<void>
 }
 
 /**
  * What createSixb({ sandboxes }) accepts. Provider-specific factories hold
  * their defaults set once and expose create(options) for each run.
+ * Persistent files are retention-bound, not a durable file store or a distributed lock.
+ * Callers own namespacing and must serialize the entire create/resume/use/stop/destroy lifecycle.
+ * Credentials and current authority must be supplied again, never inferred from saved files.
  */
 export interface SandboxFactory {
+  /** Create an ephemeral sandbox unless persistence is requested. Existing names must fail,
+   * never attach or overwrite. Unsupported providers must reject persistence before provisioning.
+   * A persistent handle targets one session; operations must not automatically resume another VM.
+   */
   create(options?: CreateSandboxOptions): Promise<Sandbox>
+  /**
+   * Present only when named persistent creation and resume are supported.
+   * Resume an existing, stopped sandbox. Missing/expired state throws SandboxStateUnavailableError;
+   * it must never create an empty replacement. An already running sandbox must be rejected.
+   * Returns a handle bound to the resumed session, with no automatic resume on use.
+   * Runtime options must be provided again; no creation settings or persistence option are accepted.
+   */
+  resume?(name: string, options?: ResumeSandboxOptions): Promise<Sandbox>
 }

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

@@ -16,6 +16,7 @@ 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"
@@ -31,6 +32,7 @@ export const BREADTH_TARGETS = [
   "pipeline",
   "application",
   "connector",
+  "share",
 ] as const
 
 export type BreadthTarget = (typeof BREADTH_TARGETS)[number]
@@ -44,6 +46,7 @@ interface BreadthTargetInput {
   pipeline: PipelineDefinition
   application: ApplicationDefinition
   connector: ConnectorDefinition
+  share: ShareDefinition
 }
 
 /**
@@ -105,4 +108,5 @@ export const every = {
   pipeline: (): BreadthSelector<"pipeline"> => all("pipeline"),
   application: (): BreadthSelector<"application"> => all("application"),
   connector: (): BreadthSelector<"connector"> => all("connector"),
+  share: (): BreadthSelector<"share"> => all("share"),
 }