@sixb/core 0.1.6 → 0.1.8

package/dist/{chunk-nva1xkjz.js → chunk-xajtptbw.js}

@@ -3,14 +3,24 @@ import {
   SyncValidationError,
   createConnectorRuntime,
   requestSyncRun
-} from "./chunk-tg5mee00.js";
+} from "./chunk-wtf06et8.js";
+import {
+  aiLimitSubjectsFromAttribution,
+  aiUsageLimitExceededError,
+  aiUsageLimitUnavailableError,
+  applicableAiLimitPolicyStatuses
+} from "./chunk-c15dr03f.js";
+import {
+  compileShareAccessPlan
+} from "./chunk-v4en4jc2.js";
 import {
   PipelineError,
   requestPipelineRun
-} from "./chunk-8gv5z0zm.js";
+} from "./chunk-w9tg6yyb.js";
 import {
   appendTelemetry,
   createObjectSet,
+  getLatestTelemetryPoint,
   getTelemetryHistoryBatch,
   listObjects,
   removeLink1 as removeLink,
@@ -18,80 +28,83 @@ import {
   upsertLinkBatch1 as upsertLinkBatch,
   upsertObject1 as upsertObject,
   upsertObjectBatch1 as upsertObjectBatch
-} from "./chunk-5sxb1168.js";
+} from "./chunk-aa2pen2v.js";
 import {
   shareOntologyMutationRuntime
 } from "./chunk-xhy826cz.js";
-import {
-  countObjects,
-  executeObjectQuery,
-  executeObjectQueryLinks,
-  existsObjects,
-  facetObjects
-} from "./chunk-md8k0r54.js";
-import {
-  SIXB_API_ROUTES,
-  matchesPathPattern,
-  normalizeRoutePath
-} from "./chunk-qewtks41.js";
 import {
   registerConnectorConnectionsRuntime
 } from "./chunk-nf4r78r4.js";
 import {
-  isActionDefinition,
+  writeDataset
+} from "./chunk-359jm1jw.js";
+import {
+  getDatasetPrimaryKeyColumns
+} from "./chunk-n4khvw9n.js";
+import {
+  assertAuthorizedObjectReaderBinding,
+  canDelegationAccessActionRun,
+  getAuthorizedOntologyView,
   requestAction,
   requestActionAndWait
-} from "./chunk-a44d5zgd.js";
+} from "./chunk-h5vqbfmd.js";
 import {
   createPrimitiveExecutionRecord,
   ensureExecutionRecord,
   executionRecordInputFromRuntime
-} from "./chunk-f6erf2vv.js";
+} from "./chunk-k522z7v6.js";
 import {
+  ObjectNotFoundError,
   WORKFLOW_RUN_FAILURE_CODES
-} from "./chunk-t624af60.js";
+} from "./chunk-sbzzr4kx.js";
+import {
+  ShareGrantStorageError
+} from "./chunk-nx7k8tpr.js";
 import {
   WorkflowRunError
-} from "./chunk-fe5ev6mr.js";
+} from "./chunk-nn0tekr1.js";
 import {
+  ExecutionStorageError
+} from "./chunk-rafagrwr.js";
+import {
+  AGENT_REASONING_LEVELS,
   AgentStorageError
-} from "./chunk-1g8negke.js";
+} from "./chunk-p1rzczbt.js";
 import {
-  agentServiceAccountId,
-  ensureAgentExecutionIdentity,
-  resolveAgentExecutionAuthorization
-} from "./chunk-hceck7dq.js";
+  RuntimeError
+} from "./chunk-p2vqaxkc.js";
 import {
-  ExecutionStorageError
-} from "./chunk-h9kxd41f.js";
-import {
-  isObjectRefSchema,
-  validateSchemaOrRefValue
-} from "./chunk-4gz41why.js";
+  isModelReasoning
+} from "./chunk-trxxmgnf.js";
 import {
-  reportRunFailure
-} from "./chunk-dsrkgtnh.js";
+  reportRunFailure,
+  shareSixbErrorReporter
+} from "./chunk-jq43kdvk.js";
 import {
-  AgentDefinitionError,
-  AgentMessageAdapterError,
   AgentRequestError,
-  AgentToolResultValidationError,
   normalizeAgentContextEntries
-} from "./chunk-rdeagz6b.js";
+} from "./chunk-5e3pq99w.js";
 import {
   publishAgentRunActivity
-} from "./chunk-dm72y8wt.js";
+} from "./chunk-7y0f6rf1.js";
 import {
   SYSTEM_PRINCIPAL,
+  isActionDefinition,
   principalsEqual
-} from "./chunk-1e8m6yn3.js";
+} from "./chunk-4sm0aznx.js";
 import {
   snapshotRequesterGroupIds
-} from "./chunk-rhrbz7d4.js";
+} from "./chunk-4a849fr1.js";
+import {
+  isObjectRefSchema,
+  validateSchemaOrRefValue
+} from "./chunk-2dw777qw.js";
 import {
   AuthorizationError,
+  agentServiceAccountId,
   assertAuthorized,
   assertCanManageConnector,
+  assertObjectReadOutputWithinLimit,
   assertPrivileged,
   assertProviderAccess,
   canViewActionRun,
@@ -102,65 +115,125 @@ import {
   canViewWorkflowIntervention,
   canViewWorkflowRun,
   createAgentRuntimeAuthorization,
+  getAuthorizationRef,
   isAllowed,
-  resolveExecutionScopeAuthorization
-} from "./chunk-f83ka50g.js";
-import {
-  assertObjectTypeRegistered,
-  normalizeSchemaValue,
-  validateSchemaValue
-} from "./chunk-rnshztfq.js";
+  isRuntimeAllowed,
+  resolveExecutionScopeAuthorization,
+  resolveRuntimeAuthorizationForProject
+} from "./chunk-p1x242ad.js";
 import {
-  OntologyValidationError
-} from "./chunk-dktq02ne.js";
+  assertObjectTypeRegistered
+} from "./chunk-h0k55pc7.js";
 import {
-  isFileRef,
   supportsDirectUpload,
   supportsRangeRead
-} from "./chunk-zqysyfjt.js";
+} from "./chunk-08m3b6w8.js";
 import {
   captureSixbFailure
-} from "./chunk-0172wgm9.js";
+} from "./chunk-2xns679x.js";
 import {
-  cloneJsonValue,
-  getInvalidJsonValueReason,
-  isPlainRecord,
-  stableJsonStringify
-} from "./chunk-t8t39h7v.js";
+  isPlainRecord
+} from "./chunk-n6jxh8sw.js";
+
+// src/actions/descriptor.ts
+function snapshotActionDescriptor(action) {
+  const params = Object.fromEntries(Object.entries(action.params).map(([id, config]) => [id, structuredClone(config)]));
+  return deepFreeze({
+    id: action.id,
+    ...action.description === undefined ? {} : { description: action.description },
+    binding: action.binding.kind === "global" ? { kind: "global" } : { kind: "object", objectTypeId: action.binding.objectType.id },
+    params,
+    phases: {
+      validate: action.phases.validate.length > 0,
+      writeback: action.phases.writeback !== undefined,
+      edits: action.phases.edits !== undefined,
+      effects: action.phases.effects !== undefined
+    }
+  });
+}
+function deepFreeze(value, seen = new Set) {
+  if (typeof value !== "object" || value === null || seen.has(value))
+    return value;
+  seen.add(value);
+  for (const key of Reflect.ownKeys(value)) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (descriptor && "value" in descriptor)
+      deepFreeze(descriptor.value, seen);
+  }
+  return Object.freeze(value);
+}
 
 // src/actions/execution.ts
 function createActionsRuntime(runtime, execution) {
-  const canList = (action) => isAllowed(runtime.authorization, { kind: "action.apply", actionId: action.id }) && (action.binding.kind === "global" || isAllowed(runtime.authorization, {
-    kind: "object.view",
-    objectTypeId: action.binding.objectType.id
-  }));
+  const projectId = runtime.projectId;
+  const runtimeAuthorization = runtime.runtimeAuthorization;
+  const objectReader = runtime.objectReader;
+  assertAuthorizedObjectReaderBinding({
+    reader: objectReader,
+    scope: { execution, authorization: runtimeAuthorization }
+  });
+  const authorization = resolveRuntimeAuthorizationForProject({
+    projectId,
+    runtimeAuthorization
+  });
+  const canList = (action) => {
+    if (authorization.type === "denied")
+      return false;
+    if (authorization.type === "delegated") {
+      const binding = action.binding;
+      return binding.kind === "object" && authorization.actionApply.some((target) => target.actionId === action.id && target.subject.objectTypeId === binding.objectType.id) && getAuthorizedOntologyView(objectReader).getObjectTypeById(binding.objectType.id) !== null;
+    }
+    if (authorization.type === "unrestricted")
+      return true;
+    return isAllowed(authorization.context, { kind: "action.apply", actionId: action.id }) && (action.binding.kind === "global" || isAllowed(authorization.context, {
+      kind: "object.view",
+      objectTypeId: action.binding.objectType.id
+    }));
+  };
+  const release = (value) => {
+    if (authorization.type === "delegated") {
+      assertObjectReadOutputWithinLimit(value, authorization.objectRead.limits);
+    }
+    return value;
+  };
+  const describeAll = (actions) => release(actions.filter(canList).map(snapshotActionDescriptor));
   return {
-    list: () => runtime.actionRegistry.list().filter(canList),
+    list: () => describeAll(runtime.actionRegistry.list()),
     getById: (actionId) => {
       const action = runtime.actionRegistry.getById(actionId);
-      return action && canList(action) ? action : null;
+      return release(action && canList(action) ? snapshotActionDescriptor(action) : null);
     },
-    listGlobal: () => runtime.actionRegistry.listGlobal().filter(canList),
-    listForType: (objectType) => runtime.actionRegistry.listForType(objectType).filter(canList),
+    listGlobal: () => describeAll(runtime.actionRegistry.listGlobal()),
+    listForType: (objectType) => describeAll(runtime.actionRegistry.listForType(objectType).filter((action) => authorization.type !== "delegated" || action.binding.kind === "object" && action.binding.objectType.id === objectType.id)),
     request: (input) => requestAction(runtime, execution, input),
     requestAndWait: (input) => requestActionAndWait(runtime, execution, input),
     runs: {
       getById: async (runId) => {
+        if (authorization.type === "denied" || authorization.type === "delegated" && (!authorization.delegation || authorization.actionApply.length === 0))
+          return null;
         const run = await runtime.storage.actionRuns?.getById({
-          projectId: runtime.projectId,
+          projectId,
           id: runId
         }) ?? null;
-        return run && canViewActionRun(runtime.authorization, run) ? run : null;
+        return run && (authorization.type === "unrestricted" || authorization.type === "principal" && canViewActionRun(authorization.context, run) || authorization.type === "delegated" && await canDelegationAccessActionRun({
+          storage: runtime.storage,
+          projectId,
+          authority: authorization,
+          run
+        })) ? release(run) : null;
       },
       list: (input = {}) => {
+        if (authorization.type === "denied" || authorization.type === "delegated") {
+          return Promise.resolve({ runs: [], hasMore: false, total: 0 });
+        }
         const storage = runtime.storage.actionRuns;
         if (!storage)
           return Promise.resolve({ runs: [], hasMore: false, total: 0 });
         return storage.list({
-          projectId: runtime.projectId,
           ...input,
-          actionIds: runtime.authorization ? [...runtime.authorization.grants["apply:action"]] : undefined,
-          objectTypeIds: runtime.authorization ? [...runtime.authorization.grants["view:object"]] : undefined
+          projectId,
+          actionIds: authorization.type === "principal" ? [...authorization.context.grants["apply:action"]] : undefined,
+          objectTypeIds: authorization.type === "principal" ? [...authorization.context.grants["view:object"]] : undefined
         });
       }
     }
@@ -197,13 +270,20 @@ async function resolveExecutionUsage(input) {
 }
 
 // src/agents/ids.ts
-import { randomUUID } from "crypto";
+import { createHash, randomUUID } from "crypto";
 function createAgentThreadId() {
   return `agt_thr_${randomUUID()}`;
 }
 function createAgentRunId() {
   return `agt_run_${randomUUID()}`;
 }
+function createSubagentRunId(parentRunId, spawnKey) {
+  const digest = createHash("sha256").update(parentRunId).update("\x00").update(spawnKey).digest("hex");
+  return `agt_run_child_${digest}`;
+}
+function createSubagentExecutionId(runId) {
+  return `exec_${runId}`;
+}
 function createAgentMessageId() {
   return `agt_msg_${randomUUID()}`;
 }
@@ -229,9 +309,7 @@ async function resolveAgentContextParts(runtime, input) {
     } catch {
       invalidContext(`context references an unknown object type '${objectTypeId}'`);
     }
-    assertAuthorized(runtime, { kind: "object.view", objectTypeId });
-    const object = await runtime.storage.objects.getByPrimaryId({
-      projectId: runtime.projectId,
+    const object = await runtime.objectReader.getByPrimaryId({
       objectTypeId,
       primaryId
     });
@@ -249,6 +327,9 @@ function invalidContext(message) {
 function agentRunQueueJobId(runId) {
   return `agt_job_${runId}`;
 }
+function subagentRunQueueJobId(runId) {
+  return `agt_child_job_${runId}`;
+}
 function workflowAgentNodeQueueJobId(nodeRunId) {
   return `wfa_job_${nodeRunId}`;
 }
@@ -259,11 +340,12 @@ async function dispatchQueuedAgentRuns(input) {
     ids: [...new Set(input.runIds)].slice(0, limit)
   }) : (await input.storage.runs.list({
     projectId: input.projectId,
+    kinds: ["conversation"],
     statuses: ["queued"],
     order: "asc",
     limit
   })).runs;
-  const queued = runs.filter((run) => run.status === "queued");
+  const queued = runs.filter((run) => run.kind === "conversation" && run.status === "queued");
   if (queued.length === 0) {
     return { scanned: 0, dispatched: [], failures: [] };
   }
@@ -293,6 +375,47 @@ async function dispatchQueuedAgentRuns(input) {
     };
   }
 }
+async function dispatchQueuedSubagentRuns(input) {
+  const limit = normalizeLimit(input.limit);
+  const runs = input.runIds ? await input.storage.runs.getByIds({
+    projectId: input.projectId,
+    ids: [...new Set(input.runIds)].slice(0, limit)
+  }) : (await input.storage.runs.list({
+    projectId: input.projectId,
+    kinds: ["subagent"],
+    statuses: ["queued"],
+    order: "asc",
+    limit
+  })).runs;
+  const queued = runs.filter((run) => run.kind === "subagent" && run.status === "queued");
+  if (queued.length === 0)
+    return { scanned: 0, dispatched: [], failures: [] };
+  try {
+    const jobs = await input.queue.enqueue({
+      projectId: input.projectId,
+      jobs: queued.map((run) => ({
+        id: subagentRunQueueJobId(run.id),
+        type: "agent.subagent-run.requested",
+        payload: { runId: run.id }
+      }))
+    });
+    const jobsById = new Set(jobs.map((job) => job.id));
+    const dispatched = queued.map((run) => {
+      const jobId = subagentRunQueueJobId(run.id);
+      if (!jobsById.has(jobId)) {
+        throw new Error(`[Sixb] Subagent queue did not return job '${jobId}'.`);
+      }
+      return { runId: run.id, jobId };
+    });
+    return { scanned: queued.length, dispatched, failures: [] };
+  } catch (error) {
+    return {
+      scanned: queued.length,
+      dispatched: [],
+      failures: queued.map((run) => ({ runId: run.id, error }))
+    };
+  }
+}
 function normalizeLimit(value) {
   if (value === undefined)
     return 100;
@@ -302,16 +425,42 @@ function normalizeLimit(value) {
   return Math.floor(value);
 }
 
+// src/agents/retired-config.ts
+function assertNoAgentDefinitions(input) {
+  if ("agents" in input) {
+    throw new RuntimeError("[Sixb] Agent definitions are no longer supported. Configure 'models' and 'tools' on createSixb() instead.");
+  }
+}
+function assertNoAgentSelector(input) {
+  if ("agentId" in input || "agentIds" in input) {
+    throw new AgentRequestError("agent_selector_removed", "[Sixb] There is one project Agent. Remove the agentId selector and use sixb.agent.");
+  }
+}
+
 // src/agents/request.ts
-async function requestAgentRun(runtime, execution, security, agent, input) {
-  assertAuthorized(runtime, { kind: "agent.run", agentId: agent.id });
+async function requestAgentRun(runtime, execution, models, input) {
+  const authority = resolveExecutionScopeAuthorization(runtime.projectId, {
+    execution,
+    authorization: runtime.runtimeAuthorization
+  });
+  assertNoAgentSelector(input);
+  assertAuthorized(runtime, { kind: "agent.run" });
+  assertRequestAuthorityCanRunAgent(runtime);
+  const spec = resolveConversationRunSpec({ models, input });
   const contextParts = await resolveAgentContextParts(runtime, input.context);
   const agents = requireAgentStorage(runtime);
   const projectId = runtime.projectId;
-  const principal = runtime.authorization?.principal ?? input.principal ?? SYSTEM_PRINCIPAL;
+  const principal = authority.type === "principal" ? authority.context.principal : input.principal ?? SYSTEM_PRINCIPAL;
+  const runId = createAgentRunId();
+  const durableExecution = await prepareDurableAgentExecution(runtime, execution, runId);
+  const requesterGroupIds = durableExecution.requestedBy ? await snapshotRequesterGroupIds({
+    auth: runtime.storage.auth,
+    projectId,
+    principal: durableExecution.requestedBy
+  }) : [];
+  await assertAiLimitPreflight(runtime, durableExecution, requesterGroupIds);
   const { thread, createdThread } = await resolveThread(agents, {
     projectId,
-    agentId: agent.id,
     threadId: input.threadId,
     title: input.title,
     principal
@@ -319,13 +468,6 @@ async function requestAgentRun(runtime, execution, security, agent, input) {
   if (thread.activeRunId !== null) {
     throw new AgentRequestError("active_run_exists", `[Sixb] Agent thread '${thread.id}' already has an active run '${thread.activeRunId}'.`);
   }
-  const runId = createAgentRunId();
-  const durableExecution = await prepareDurableAgentExecution(runtime, execution, security, agent, runId);
-  const requesterGroupIds = durableExecution.requestedBy ? await snapshotRequesterGroupIds({
-    auth: runtime.storage.auth,
-    projectId,
-    principal: durableExecution.requestedBy
-  }) : [];
   const triggerMessageId = input.messageId ?? createAgentMessageId();
   let run;
   try {
@@ -353,8 +495,8 @@ async function requestAgentRun(runtime, execution, security, agent, input) {
         projectId,
         executionId: durableExecution.id,
         threadId: thread.id,
-        agentId: agent.id,
         triggerMessageId,
+        spec,
         requesterGroupIds
       });
     });
@@ -372,22 +514,32 @@ async function requestAgentRun(runtime, execution, security, agent, input) {
     createdThread
   };
 }
-async function retryAgentRun(runtime, execution, security, agent, failedRun) {
-  assertAuthorized(runtime, { kind: "agent.run", agentId: agent.id });
-  if (failedRun.agentId !== agent.id) {
-    throw new AgentRequestError("agent_not_found", `[Sixb] Agent run '${failedRun.id}' does not belong to agent '${agent.id}'.`);
-  }
+async function retryAgentRun(runtime, execution, models, failedRun) {
+  resolveExecutionScopeAuthorization(runtime.projectId, {
+    execution,
+    authorization: runtime.runtimeAuthorization
+  });
+  assertAuthorized(runtime, { kind: "agent.run" });
+  assertRequestAuthorityCanRunAgent(runtime);
   if (failedRun.status !== "failed") {
     throw new AgentRequestError("run_not_retryable", `[Sixb] Only failed Agent runs can be retried.`);
   }
   const agents = requireAgentStorage(runtime);
+  const thread = await agents.threads.getById({
+    projectId: runtime.projectId,
+    id: failedRun.threadId
+  });
+  if (!thread) {
+    throw new AgentRequestError("thread_not_found", `[Sixb] Agent thread '${failedRun.threadId}' was not found.`);
+  }
   const runId = createAgentRunId();
-  const durableExecution = await prepareDurableAgentExecution(runtime, execution, security, agent, runId);
+  const durableExecution = await prepareDurableAgentExecution(runtime, execution, runId);
   const requesterGroupIds = durableExecution.requestedBy ? await snapshotRequesterGroupIds({
     auth: runtime.storage.auth,
     projectId: runtime.projectId,
     principal: durableExecution.requestedBy
   }) : [];
+  await assertAiLimitPreflight(runtime, durableExecution, requesterGroupIds);
   const run = await runtime.storage.transaction(async (tx) => {
     const agents2 = tx.agents;
     if (!agents2) {
@@ -404,8 +556,11 @@ async function retryAgentRun(runtime, execution, security, agent, failedRun) {
       projectId: runtime.projectId,
       executionId: durableExecution.id,
       threadId: failedRun.threadId,
-      agentId: agent.id,
       triggerMessageId: failedRun.triggerMessageId,
+      spec: failedRun.spec ?? resolveConversationRunSpec({
+        models,
+        input: {}
+      }),
       requesterGroupIds
     });
   });
@@ -413,31 +568,61 @@ async function retryAgentRun(runtime, execution, security, agent, failedRun) {
   const jobId = await dispatchAgentRun(runtime, agents, runId);
   return { run, ...jobId ? { jobId } : {}, createdThread: false };
 }
-async function prepareDurableAgentExecution(runtime, execution, security, agent, runId) {
-  const identity = await ensureAgentExecutionIdentity({
-    auth: runtime.storage.auth,
-    projectId: runtime.projectId,
-    agent
-  });
-  const resolved = await resolveAgentExecutionAuthorization({
-    auth: runtime.storage.auth,
-    projectId: runtime.projectId,
-    agentId: agent.id,
-    authorizationRef: { type: "principal", principal: identity.principal },
-    security
+async function assertAiLimitPreflight(runtime, execution, requesterGroupIds) {
+  const limits = runtime.storage.aiLimits;
+  if (!limits)
+    throw aiUsageLimitUnavailableError(["limitStorageUnavailable"]);
+  const subjects = aiLimitSubjectsFromAttribution(execution.requestedBy, requesterGroupIds);
+  let applicable;
+  try {
+    applicable = applicableAiLimitPolicyStatuses(await limits.listPolicyStatuses({ projectId: runtime.projectId }), subjects);
+  } catch {
+    throw aiUsageLimitUnavailableError(["limitStorageUnavailable"]);
+  }
+  const unavailable = applicable.filter((status) => status.accountingStatus === "unavailable");
+  if (unavailable.length > 0) {
+    throw aiUsageLimitUnavailableError(["incompleteAccounting"]);
+  }
+  const exhausted = applicable.filter((status) => status.exhausted);
+  if (exhausted.length > 0) {
+    const resetAt = new Date(Math.min(...exhausted.map((status) => status.period.resetAt.getTime())));
+    throw aiUsageLimitExceededError(resetAt);
+  }
+}
+function resolveConversationRunSpec(input) {
+  if (!input.models) {
+    throw new AgentRequestError("model_not_found", "[Sixb] Configure models.language before starting the Agent.");
+  }
+  const selected = input.input.model ?? input.models.default;
+  const model = input.models.getByRef(selected);
+  if (model === null) {
+    throw new AgentRequestError("model_not_found", `[Sixb] Language model '${selected.provider}/${selected.modelId}' is not in the project model catalog.`);
+  }
+  const reasoning = input.input.reasoning;
+  if (reasoning !== undefined && !isModelReasoning(reasoning)) {
+    throw new AgentRequestError("invalid_model_selection", `[Sixb] Agent reasoning must be one of: ${AGENT_REASONING_LEVELS.join(", ")}, or a nonnegative budgetTokens object.`);
+  }
+  return Object.freeze({
+    model: Object.freeze({ provider: selected.provider, modelId: selected.modelId }),
+    ...reasoning === undefined ? {} : { reasoning }
   });
+}
+async function prepareDurableAgentExecution(runtime, execution, runId) {
   const parent = await ensureExecutionRecord(runtime.storage.executions, executionRecordInputFromRuntime({
     execution,
     runtimeAuthorization: runtime.runtimeAuthorization
   }));
-  return createAgentExecutionRecord({
+  return createInheritedAgentExecutionRecord({
     id: `exec_${randomUUID2()}`,
     parent,
-    agentId: agent.id,
-    runId,
-    principal: resolved.identity.principal
+    runId
   });
 }
+function assertRequestAuthorityCanRunAgent(runtime) {
+  if (!canInheritAgentRequestAuthorization(runtime.runtimeAuthorization)) {
+    throw new AgentRequestError("authority_not_inheritable", "[Sixb] The Agent requires an authenticated user request or disabled authorization.");
+  }
+}
 async function dispatchAgentRun(runtime, agents, runId) {
   try {
     const dispatch = await dispatchQueuedAgentRuns({
@@ -470,16 +655,12 @@ async function resolveThread(agents, params) {
       id: params.threadId
     });
     if (existing) {
-      if (existing.agentId !== params.agentId) {
-        throw new AgentRequestError("thread_agent_mismatch", `[Sixb] Agent thread '${existing.id}' belongs to agent '${existing.agentId}', not '${params.agentId}'.`);
-      }
       return { thread: existing, createdThread: false };
     }
   }
   const thread = await agents.threads.create({
     id: params.threadId ?? createAgentThreadId(),
     projectId: params.projectId,
-    agentId: params.agentId,
     ownerPrincipal: params.principal,
     ...params.title === undefined ? {} : { title: params.title }
   });
@@ -494,44 +675,56 @@ function requireAgentStorage(runtime) {
 }
 
 // src/agents/execution.ts
-function createAgentsRuntime(runtime, execution, source, security) {
-  const principal = runtime.authorization?.principal ?? SYSTEM_PRINCIPAL;
-  const allowed = (agentId) => isAllowed(runtime.authorization, { kind: "agent.run", agentId });
-  const getThread = async (threadId) => {
+function createAgentRuntime(runtime, execution, models) {
+  const authority = resolveRuntimeAuthorizationForProject(runtime);
+  const principal = authority.type === "principal" ? authority.context.principal : SYSTEM_PRINCIPAL;
+  const allowed = () => isRuntimeAllowed(runtime, { kind: "agent.run" });
+  const getVisibleThreadRecord = async (threadId) => {
+    if (authority.type === "denied" || authority.type === "delegated")
+      return null;
     const thread = await runtime.storage.agents?.threads.getById({
       projectId: runtime.projectId,
       id: threadId
     }) ?? null;
-    if (!thread || !allowed(thread.agentId))
+    if (!thread || !allowed())
       return null;
-    return runtime.authorization && !principalsEqual(principal, thread.ownerPrincipal) ? null : thread;
+    return authority.type === "principal" && !principalsEqual(principal, thread.ownerPrincipal) ? null : thread;
   };
-  const getAgent = (agentId) => {
-    const agent = source.getById(agentId);
-    return agent && allowed(agentId) ? agent : null;
+  const getAgent = () => {
+    if (authority.type === "denied" || authority.type === "delegated")
+      return null;
+    const model = models?.language.default;
+    if (!model || !allowed())
+      return null;
+    return {
+      name: "Sixb",
+      model: { provider: model.provider, modelId: model.modelId }
+    };
   };
   const getVisibleRunRecord = async (runId) => {
+    if (authority.type === "denied" || authority.type === "delegated")
+      return null;
     const run = await runtime.storage.agents?.runs.getById({
       projectId: runtime.projectId,
       id: runId
     }) ?? null;
-    if (!run)
+    if (!run || run.kind !== "conversation")
       return null;
-    const thread = await getThread(run.threadId);
-    return thread?.agentId === run.agentId ? run : null;
+    const thread = await getVisibleThreadRecord(run.threadId);
+    return thread ? run : null;
   };
   const getRun = async (runId) => {
     const run = await getVisibleRunRecord(runId);
     return run ? attachRunView(runtime, run) : null;
   };
   return {
-    list: () => source.list().filter((agent) => allowed(agent.id)),
-    getById: getAgent,
+    get: getAgent,
     threads: {
       create: async (input) => {
-        const agent = getAgent(input.agentId);
+        assertNoAgentSelector(input);
+        const agent = getAgent();
         if (!agent) {
-          throw new AgentRequestError("agent_not_found", `[Sixb] Unknown agent '${input.agentId}'.`);
+          throw new AgentRequestError("agent_not_found", "[Sixb] The project Agent is unavailable.");
         }
         const storage = runtime.storage.agents;
         if (!storage) {
@@ -540,35 +733,38 @@ function createAgentsRuntime(runtime, execution, source, security) {
         return storage.threads.create({
           id: input.id ?? createAgentThreadId(),
           projectId: runtime.projectId,
-          agentId: agent.id,
           ownerPrincipal: principal,
           ...input.title === undefined ? {} : { title: input.title }
         });
       },
-      getById: getThread,
-      list: (input = {}) => {
+      getById: getVisibleThreadRecord,
+      list: async (input = {}) => {
+        assertNoAgentSelector(input);
+        if (authority.type === "denied" || authority.type === "delegated") {
+          return { threads: [], hasMore: false, total: 0 };
+        }
         const storage = runtime.storage.agents;
-        if (!storage)
-          return Promise.resolve({ threads: [], hasMore: false, total: 0 });
+        if (!storage || !allowed())
+          return { threads: [], hasMore: false, total: 0 };
         return storage.threads.list({
-          projectId: runtime.projectId,
           ...input,
-          agentIds: runtime.authorization ? [...runtime.authorization.grants["run:agent"]] : undefined,
-          ownerPrincipal: runtime.authorization ? principal : undefined
+          projectId: runtime.projectId,
+          ownerPrincipal: authority.type === "principal" ? principal : undefined
         });
       }
     },
     runs: {
       request: async (input) => {
-        const agent = source.getById(input.agentId);
+        assertNoAgentSelector(input);
+        const agent = getAgent();
         if (!agent) {
-          throw new AgentRequestError("agent_not_found", `[Sixb] Unknown agent '${input.agentId}'.`);
+          throw new AgentRequestError("agent_not_found", "[Sixb] The project Agent is unavailable.");
         }
-        assertAuthorized(runtime, { kind: "agent.run", agentId: agent.id });
-        if (input.threadId && !await getThread(input.threadId)) {
+        assertAuthorized(runtime, { kind: "agent.run" });
+        if (input.threadId && !await getVisibleThreadRecord(input.threadId)) {
           throw new AgentRequestError("thread_not_found", `[Sixb] Agent thread '${input.threadId}' not found.`);
         }
-        const result = await requestAgentRun(runtime, execution, security, agent, {
+        const result = await requestAgentRun(runtime, execution, models?.language, {
           ...input,
           principal
         });
@@ -579,26 +775,27 @@ function createAgentsRuntime(runtime, execution, source, security) {
         if (!failedRun) {
           throw new AgentRequestError("run_not_found", `[Sixb] Agent run '${runId}' was not found.`);
         }
-        const agent = getAgent(failedRun.agentId);
+        const agent = getAgent();
         if (!agent) {
-          throw new AgentRequestError("agent_not_found", `[Sixb] Unknown agent '${failedRun.agentId}'.`);
+          throw new AgentRequestError("agent_not_found", "[Sixb] The project Agent is unavailable.");
         }
-        const result = await retryAgentRun(runtime, execution, security, agent, failedRun);
+        const result = await retryAgentRun(runtime, execution, models?.language, failedRun);
         return { ...result, run: await attachRunView(runtime, result.run) };
       },
       getById: getRun,
       listForThread: async (threadId, input = {}) => {
+        assertNoAgentSelector(input);
         const storage = runtime.storage.agents;
-        if (!storage || !await getThread(threadId))
+        if (!storage || !await getVisibleThreadRecord(threadId))
           return null;
         const result = await storage.runs.list({
-          projectId: runtime.projectId,
           ...input,
+          projectId: runtime.projectId,
           threadId
         });
         return {
           ...result,
-          runs: await attachRunViews(runtime, result.runs)
+          runs: await attachRunViews(runtime, result.runs.filter((run) => run.kind === "conversation"))
         };
       }
     }
@@ -644,6 +841,106 @@ async function attachRunViews(runtime, runs) {
   });
 }
 
+// src/ai-usage/execution.ts
+import { randomUUID as randomUUID3 } from "crypto";
+function createAiUsageRuntime(runtime, security) {
+  const assertObservable = () => assertAuthorized(runtime, { kind: "aiUsage.observe" });
+  const assertManageable = () => assertAuthorized(runtime, { kind: "aiUsage.manage" });
+  const assertPolicyReadable = () => {
+    if (!isRuntimeAllowed(runtime, { kind: "aiUsage.observe" }) && !isRuntimeAllowed(runtime, { kind: "aiUsage.manage" })) {
+      assertObservable();
+    }
+  };
+  const requireCosts = () => {
+    if (!runtime.storage.aiCosts) {
+      throw new Error("[Sixb] AI cost storage is not configured.");
+    }
+    return runtime.storage.aiCosts;
+  };
+  const requireLimits = () => {
+    if (!runtime.storage.aiLimits) {
+      throw new Error("[Sixb] AI limit storage is not configured.");
+    }
+    return runtime.storage.aiLimits;
+  };
+  return {
+    accountingConfigured: runtime.storage.aiCosts !== undefined,
+    limitsConfigured: runtime.storage.aiLimits !== undefined,
+    assertObservable,
+    assertManageable,
+    canManageLimits: () => isRuntimeAllowed(runtime, { kind: "aiUsage.manage" }),
+    queryOverview: (input) => {
+      assertObservable();
+      return requireCosts().queryProjectOverview({ ...input, projectId: runtime.projectId });
+    },
+    listModelCalls: (input) => {
+      assertObservable();
+      return requireCosts().listModelCalls({ ...input, projectId: runtime.projectId });
+    },
+    listModelCallGroups: (input) => {
+      assertObservable();
+      return requireCosts().listModelCallGroups({ ...input, projectId: runtime.projectId });
+    },
+    listLimitPolicies: (input = {}) => {
+      assertPolicyReadable();
+      return requireLimits().listPolicies({ ...input, projectId: runtime.projectId });
+    },
+    listLimitStatuses: (input = {}) => {
+      assertObservable();
+      return requireLimits().listPolicyStatuses({
+        ...input.includeDisabled === undefined ? {} : { includeDisabled: input.includeDisabled },
+        projectId: runtime.projectId,
+        existingGroupIds: security.listGroups().map((group) => group.id)
+      });
+    },
+    listLimitSubjectOptions: async () => {
+      assertManageable();
+      const groups = security.listGroups().map((group) => ({
+        id: group.id,
+        ...group.label === undefined ? {} : { label: group.label },
+        ...group.description === undefined ? {} : { description: group.description }
+      }));
+      const auth = runtime.storage.auth;
+      if (!auth)
+        return { groups, users: [], serviceAccounts: [] };
+      const [users, serviceAccounts] = await Promise.all([
+        auth.users.list({ projectId: runtime.projectId, order: "asc" }),
+        auth.serviceAccounts.list({ projectId: runtime.projectId, order: "asc" })
+      ]);
+      return {
+        groups,
+        users: users.users.map((user) => ({
+          id: user.id,
+          email: user.email,
+          ...user.displayName === undefined ? {} : { displayName: user.displayName },
+          status: user.status
+        })),
+        serviceAccounts: serviceAccounts.serviceAccounts.map((serviceAccount) => ({
+          id: serviceAccount.id,
+          name: serviceAccount.name,
+          ...serviceAccount.description === undefined ? {} : { description: serviceAccount.description },
+          status: serviceAccount.status
+        }))
+      };
+    },
+    createLimitPolicy: (input) => {
+      assertManageable();
+      return requireLimits().createPolicy({
+        ...input,
+        id: input.id ?? `ailim_${randomUUID3()}`,
+        projectId: runtime.projectId
+      });
+    },
+    updateLimitPolicy: (input) => {
+      assertManageable();
+      return requireLimits().updatePolicy({ ...input, projectId: runtime.projectId });
+    },
+    deleteLimitPolicy: (id) => {
+      assertManageable();
+      return requireLimits().deletePolicy({ id, projectId: runtime.projectId });
+    }
+  };
+}
 // src/blob-storage/execution.ts
 function createBlobsRuntime(runtime, execution, blobStorage) {
   const assertAccess = () => assertProviderAccess(runtime, execution, "blobs.access");
@@ -728,21 +1025,88 @@ function commandContext(runtime, execution, connectorId) {
 }
 
 // src/datasets/execution.ts
-function createDatasetsRuntime(runtime, source) {
-  const allowed = (datasetId) => isAllowed(runtime.authorization, { kind: "dataset.view", datasetId });
+function createDatasetsRuntime(runtime, execution, source, lakeStorage, blobStorage) {
+  const authority = resolveRuntimeAuthorizationForProject(runtime);
+  const allowed = (datasetId) => isRuntimeAllowed(runtime, { kind: "dataset.view", datasetId });
   return {
-    list: () => source.list().filter((dataset) => allowed(dataset.id)),
+    list: () => authority.type === "denied" || authority.type === "delegated" ? [] : source.list().filter((dataset) => allowed(dataset.id)),
     getById: (datasetId) => {
+      if (authority.type === "denied" || authority.type === "delegated")
+        return null;
       const dataset = source.getById(datasetId);
       return dataset && allowed(datasetId) ? dataset : null;
+    },
+    async ingest(dataset, input) {
+      assertPrivileged(runtime, "datasets.ingest");
+      const registered = source.getById(dataset.id);
+      if (!registered)
+        throw new Error(`[Sixb] Dataset '${dataset.id}' is not registered.`);
+      if (getDatasetPrimaryKeyColumns(registered) === null) {
+        throw new Error(`[Sixb] Dataset '${dataset.id}' must define a primaryKey before ingestion.`);
+      }
+      if (typeof lakeStorage.beginMerge !== "function") {
+        throw new Error("[Sixb] Dataset ingestion requires a lake provider with merge support.");
+      }
+      const producer = { kind: "ingest", id: execution.id };
+      const result = await writeDataset({
+        lakeStorage,
+        blobStorage,
+        dataset: registered,
+        mode: "merge",
+        signal: input.signal ?? new AbortController().signal,
+        producer,
+        readValues: async () => async function* () {
+          for await (const value of input.changes)
+            yield { value };
+        }()
+      });
+      if (result.outcome === "created") {
+        await runtime.events.emit({
+          events: [
+            {
+              type: "dataset.version.committed",
+              payload: {
+                datasetId: registered.id,
+                versionId: result.version.versionId,
+                createdAt: result.version.createdAt.toISOString(),
+                producer
+              }
+            }
+          ],
+          correlationId: execution.correlationId
+        }, { source: "SixbDatasets" });
+      }
+      return result;
     }
   };
 }
 
 // src/events/execution.ts
 function createEventsRuntime(runtime) {
+  const authority = resolveRuntimeAuthorizationForProject(runtime);
+  const visibleEvents = (events) => {
+    switch (authority.type) {
+      case "denied":
+      case "delegated":
+        return [];
+      case "principal":
+        return events.filter((event) => canViewEvent(authority.context, event));
+      case "unrestricted":
+        return [...events];
+    }
+  };
   return {
-    canRead: (event) => canViewEvent(runtime.authorization, event),
+    canRead: (event) => {
+      switch (authority.type) {
+        case "denied":
+        case "delegated":
+          return false;
+        case "principal":
+          return canViewEvent(authority.context, event);
+        case "unrestricted":
+          return true;
+      }
+    },
     append: (input) => {
       assertPrivileged(runtime, "events.append");
       return runtime.events.append(input);
@@ -752,15 +1116,42 @@ function createEventsRuntime(runtime) {
       return runtime.events.emit(input, options);
     },
     read: async (input) => {
+      switch (authority.type) {
+        case "denied":
+        case "delegated":
+          return [];
+        case "principal":
+        case "unrestricted":
+          break;
+      }
       const events = await runtime.events.read(input);
-      return events.filter((event) => canViewEvent(runtime.authorization, event));
+      return visibleEvents(events);
     },
-    latestCursor: () => runtime.events.latestCursor(),
-    subscribe: (input, handler) => runtime.events.subscribe(input, (events) => {
-      const visible = events.filter((event) => canViewEvent(runtime.authorization, event));
-      if (visible.length > 0)
-        handler(visible);
-    })
+    latestCursor: () => {
+      switch (authority.type) {
+        case "denied":
+        case "delegated":
+          return Promise.resolve(undefined);
+        case "principal":
+        case "unrestricted":
+          return runtime.events.latestCursor();
+      }
+    },
+    subscribe: (input, handler) => {
+      switch (authority.type) {
+        case "denied":
+        case "delegated":
+          return Promise.resolve(() => {});
+        case "principal":
+        case "unrestricted":
+          break;
+      }
+      return runtime.events.subscribe(input, (events) => {
+        const visible = visibleEvents(events);
+        if (visible.length > 0)
+          handler(visible);
+      });
+    }
   };
 }
 
@@ -782,129 +1173,118 @@ function createLogsRuntime(runtime, source) {
 
 // src/objects/execution.ts
 function createObjectsRuntime(runtime, execution) {
+  const runtimeAuthorization = runtime.runtimeAuthorization;
+  const objectReader = runtime.objectReader;
+  assertAuthorizedObjectReaderBinding({
+    reader: objectReader,
+    scope: { execution, authorization: runtimeAuthorization }
+  });
+  const authorization = runtime.authorization;
+  const capturedRuntime = {
+    projectId: runtime.projectId,
+    broker: runtime.broker,
+    ontology: runtime.ontology,
+    actionRegistry: runtime.actionRegistry,
+    events: runtime.events,
+    storage: runtime.storage,
+    queues: runtime.queues,
+    runtimeAuthorization,
+    objectReader,
+    ...authorization === undefined ? {} : { authorization }
+  };
+  shareOntologyMutationRuntime(runtime, capturedRuntime);
+  shareSixbErrorReporter(runtime, capturedRuntime);
+  Object.freeze(capturedRuntime);
+  const ontologyView = () => getAuthorizedOntologyView(objectReader);
   const objects = Object.assign((objectType) => {
-    assertObjectTypeRegistered(runtime.ontology.getObjectTypesById(), objectType);
-    return createObjectSet({ ...runtime, execution, objectType });
+    assertObjectTypeRegistered(capturedRuntime.ontology.getObjectTypesById(), objectType);
+    return createObjectSet({ ...capturedRuntime, execution, objectType });
   }, {
-    listTypes: () => runtime.ontology.listObjectTypes().filter((objectType) => isAllowed(runtime.authorization, {
-      kind: "object.view",
-      objectTypeId: objectType.id
-    })),
-    getTypeById: (objectTypeId) => {
-      const objectType = runtime.ontology.getObjectTypeById(objectTypeId);
-      return objectType && isAllowed(runtime.authorization, { kind: "object.view", objectTypeId }) ? objectType : null;
-    },
-    resolveType: (objectTypeId) => {
-      assertAuthorized(runtime, { kind: "object.view", objectTypeId });
-      return runtime.ontology.resolveObjectType(objectTypeId);
-    },
-    getValueTypesById: () => runtime.ontology.getValueTypesById(),
-    listSubTypes: (objectTypeId) => runtime.ontology.listSubTypes(objectTypeId),
-    isValidLinkTarget: (expected, actual) => runtime.ontology.isValidLinkTarget(expected, actual),
-    executeQuery: (input) => executeObjectQuery({ projectId: runtime.projectId, ...input }, {
-      ontology: runtime.ontology,
-      storage: runtime.storage.objects,
-      runtimeAuthorization: runtime.runtimeAuthorization,
-      authorization: runtime.authorization
-    }),
-    queryLinks: (input) => executeObjectQueryLinks({ projectId: runtime.projectId, ...input }, {
-      ontology: runtime.ontology,
-      storage: runtime.storage.objects,
-      runtimeAuthorization: runtime.runtimeAuthorization,
-      authorization: runtime.authorization
-    }),
-    count: (input) => countObjects({ projectId: runtime.projectId, ...input }, {
-      ontology: runtime.ontology,
-      storage: runtime.storage.objects,
-      runtimeAuthorization: runtime.runtimeAuthorization,
-      authorization: runtime.authorization
-    }),
-    exists: (input) => existsObjects({ projectId: runtime.projectId, ...input }, {
-      ontology: runtime.ontology,
-      storage: runtime.storage.objects,
-      runtimeAuthorization: runtime.runtimeAuthorization,
-      authorization: runtime.authorization
-    }),
-    facet: (input) => facetObjects({ projectId: runtime.projectId, ...input }, {
-      ontology: runtime.ontology,
-      storage: runtime.storage.objects,
-      runtimeAuthorization: runtime.runtimeAuthorization,
-      authorization: runtime.authorization
-    }),
+    listTypes: () => ontologyView().listObjectTypes(),
+    getTypeById: (objectTypeId) => ontologyView().getObjectTypeById(objectTypeId),
+    resolveType: (objectTypeId) => ontologyView().resolveObjectType(objectTypeId),
+    getValueTypesById: () => ontologyView().getValueTypesById(),
+    listSubTypes: (objectTypeId) => ontologyView().listSubTypes(objectTypeId),
+    isValidLinkTarget: (expected, actual) => ontologyView().isValidLinkTarget(expected, actual),
+    executeQuery: (input) => objectReader.executeQuery(input),
+    queryLinks: (input) => objectReader.queryLinks(input),
+    count: (input) => objectReader.count(input),
+    exists: (input) => objectReader.exists(input),
+    facet: (input) => objectReader.facet(input),
     listLinks: async (input) => {
-      assertAuthorized(runtime, { kind: "object.view", objectTypeId: input.objectTypeId });
-      const links = await runtime.storage.objects.listLinks({
-        projectId: runtime.projectId,
-        ...input
-      });
-      return links.filter((link) => isAllowed(runtime.authorization, {
-        kind: "object.view",
-        objectTypeId: link.sourceTypeId
-      }) && isAllowed(runtime.authorization, {
-        kind: "object.view",
-        objectTypeId: link.targetTypeId
-      }));
+      return objectReader.listLinks(input);
     },
-    getTelemetryHistoryBatch: (input) => getTelemetryHistoryBatch({ projectId: runtime.projectId, ...input }, {
-      storage: runtime.storage.timeseries,
-      runtimeAuthorization: runtime.runtimeAuthorization,
-      authorization: runtime.authorization
-    }),
-    getTelemetryHistory: (input) => {
-      assertAuthorized(runtime, { kind: "object.view", objectTypeId: input.objectTypeId });
-      return runtime.storage.timeseries.getHistory({
-        projectId: runtime.projectId,
-        ...input
-      });
+    getTelemetryHistoryBatch: (input) => {
+      const timeseries = capturedRuntime.storage.timeseries;
+      return getTelemetryHistoryBatch(input, { storage: timeseries, objectReader });
     },
-    getLatestTelemetry: (input) => {
-      assertAuthorized(runtime, { kind: "object.view", objectTypeId: input.objectTypeId });
-      return runtime.storage.timeseries.getLatest({
-        projectId: runtime.projectId,
-        ...input
-      });
+    getTelemetryHistory: async (input) => {
+      const timeseries = capturedRuntime.storage.timeseries;
+      const objectTypeId = input.objectTypeId;
+      const objectId = input.objectId;
+      const propertyId = input.propertyId;
+      const from = input.from;
+      const to = input.to;
+      const limit = input.limit;
+      const order = input.order;
+      const [result] = await getTelemetryHistoryBatch({
+        series: [{ objectTypeId, objectId, propertyId }],
+        ...from === undefined ? {} : { from },
+        ...to === undefined ? {} : { to },
+        ...limit === undefined ? {} : { limitPerSeries: limit },
+        ...order === undefined ? {} : { order }
+      }, { storage: timeseries, objectReader });
+      return result?.points ?? [];
     },
-    list: (params) => listObjects(runtime, params),
-    get: async (objectTypeId, primaryId) => {
-      assertAuthorized(runtime, { kind: "object.view", objectTypeId });
-      return runtime.storage.objects.getByPrimaryId({
-        projectId: runtime.projectId,
-        objectTypeId,
-        primaryId
-      });
+    getLatestTelemetry: async (input) => {
+      const timeseries = capturedRuntime.storage.timeseries;
+      const objectTypeId = input.objectTypeId;
+      const objectId = input.objectId;
+      const propertyId = input.propertyId;
+      return getLatestTelemetryPoint({ objectTypeId, objectId, propertyId }, { storage: timeseries, objectReader });
     },
+    list: (params) => listObjects(capturedRuntime, params),
+    get: (objectTypeId, primaryId) => objectReader.getByPrimaryId({ objectTypeId, primaryId }),
     getPrimaryPropertyId: (objectTypeId) => {
-      assertAuthorized(runtime, { kind: "object.view", objectTypeId });
-      return runtime.ontology.getPrimaryPropertyId(objectTypeId);
+      return ontologyView().getPrimaryPropertyId(objectTypeId);
     },
-    upsert: (objectTypeId, properties) => upsertObject(runtime, objectTypeId, properties),
-    upsertBatch: (objectTypeId, items) => upsertObjectBatch(runtime, objectTypeId, items),
-    upsertLink: (objectTypeId, sourceId, linkId, target) => upsertLink(runtime, objectTypeId, sourceId, linkId, target),
-    upsertLinkBatch: (items) => upsertLinkBatch(runtime, items),
-    removeLink: (objectTypeId, sourceId, linkId, target) => removeLink(runtime, objectTypeId, sourceId, linkId, target),
-    appendTelemetry: (objectTypeId, items) => appendTelemetry(runtime, objectTypeId, items)
+    upsert: (objectTypeId, properties) => upsertObject(capturedRuntime, objectTypeId, properties),
+    upsertBatch: (objectTypeId, items) => upsertObjectBatch(capturedRuntime, objectTypeId, items),
+    upsertLink: (objectTypeId, sourceId, linkId, target) => upsertLink(capturedRuntime, objectTypeId, sourceId, linkId, target),
+    upsertLinkBatch: (items) => upsertLinkBatch(capturedRuntime, items),
+    removeLink: (objectTypeId, sourceId, linkId, target) => removeLink(capturedRuntime, objectTypeId, sourceId, linkId, target),
+    appendTelemetry: (objectTypeId, items) => appendTelemetry(capturedRuntime, objectTypeId, items)
   });
   return objects;
 }
 
 // src/pipelines/execution.ts
 function createPipelinesRuntime(runtime, execution, source) {
-  const allowed = (pipelineId) => isAllowed(runtime.authorization, { kind: "pipeline.run", pipelineId });
+  const authority = resolveRuntimeAuthorizationForProject(runtime);
+  const allowed = (pipelineId) => isRuntimeAllowed(runtime, { kind: "pipeline.run", pipelineId });
   const visibleIds = () => source.list().filter((pipeline) => allowed(pipeline.id)).map((pipeline) => pipeline.id);
+  const historyFilterIds = () => authority.type === "unrestricted" ? undefined : authority.type === "principal" ? visibleIds() : [];
   const getRun = async (runId) => {
+    if (authority.type === "denied" || authority.type === "delegated")
+      return null;
     const run = await runtime.storage.pipelineRuns?.getById({
       projectId: runtime.projectId,
       id: runId
     }) ?? null;
-    return run && canViewPipelineRun(runtime.authorization, run) ? run : null;
+    if (!run)
+      return null;
+    return authority.type === "unrestricted" || canViewPipelineRun(authority.context, run) ? run : null;
   };
   return {
-    list: () => source.list().filter((pipeline) => allowed(pipeline.id)),
+    list: () => authority.type === "denied" || authority.type === "delegated" ? [] : source.list().filter((pipeline) => allowed(pipeline.id)),
     getById: (pipelineId) => {
+      if (authority.type === "denied" || authority.type === "delegated")
+        return null;
       const pipeline = source.getById(pipelineId);
       return pipeline && allowed(pipelineId) ? pipeline : null;
     },
     request: async (input) => {
+      assertAuthorized(runtime, { kind: "pipeline.run", pipelineId: input.pipelineId });
       const pipeline = source.getById(input.pipelineId);
       if (!pipeline)
         throw new PipelineError(`[Sixb] Unknown pipeline '${input.pipelineId}'`);
@@ -913,16 +1293,22 @@ function createPipelinesRuntime(runtime, execution, source) {
     runs: {
       getById: getRun,
       list: (input = {}) => {
+        if (authority.type === "denied" || authority.type === "delegated") {
+          return Promise.resolve({ runs: [], hasMore: false, total: 0 });
+        }
         const storage = runtime.storage.pipelineRuns;
         if (!storage)
           return Promise.resolve({ runs: [], hasMore: false, total: 0 });
         return storage.list({
-          projectId: runtime.projectId,
           ...input,
-          pipelineIds: runtime.authorization ? visibleIds() : undefined
+          pipelineIds: historyFilterIds(),
+          projectId: runtime.projectId
         });
       },
       listLatest: (pipelineIds) => {
+        if (authority.type === "denied" || authority.type === "delegated") {
+          return Promise.resolve({ runs: [] });
+        }
         const storage = runtime.storage.pipelineRuns;
         if (!storage || pipelineIds.length === 0)
           return Promise.resolve({ runs: [] });
@@ -937,9 +1323,9 @@ function createPipelinesRuntime(runtime, execution, source) {
         if (!storage || !await getRun(runId))
           return null;
         return storage.listSteps({
-          projectId: runtime.projectId,
           ...input,
-          pipelineRunId: runId
+          pipelineRunId: runId,
+          projectId: runtime.projectId
         });
       }
     }
@@ -948,39 +1334,95 @@ function createPipelinesRuntime(runtime, execution, source) {
 
 // src/projections/execution.ts
 function createProjectionsRuntime(runtime, source) {
-  const visible = (projection) => canViewProjection(runtime.authorization, projection);
+  const authority = resolveRuntimeAuthorizationForProject(runtime);
+  const listVisible = (list) => {
+    switch (authority.type) {
+      case "denied":
+      case "delegated":
+        return [];
+      case "principal":
+        return list().filter((projection) => canViewProjection(authority.context, projection));
+      case "unrestricted":
+        return [...list()];
+    }
+  };
+  const visible = (projection) => {
+    switch (authority.type) {
+      case "denied":
+      case "delegated":
+        return false;
+      case "principal":
+        return canViewProjection(authority.context, projection);
+      case "unrestricted":
+        return true;
+    }
+  };
   const visibleIds = (projectionIds) => projectionIds.filter((projectionId) => {
     const projection = source.getById(projectionId);
     return projection !== null && visible(projection);
   });
   return {
-    list: () => source.list().filter(visible),
-    listObjects: () => source.listObjects().filter(visible),
-    listLinks: () => source.listLinks().filter(visible),
-    listTelemetry: () => source.listTelemetry().filter(visible),
+    list: () => listVisible(() => source.list()),
+    listObjects: () => listVisible(() => source.listObjects()),
+    listLinks: () => listVisible(() => source.listLinks()),
+    listTelemetry: () => listVisible(() => source.listTelemetry()),
     getById: (projectionId) => {
+      switch (authority.type) {
+        case "denied":
+        case "delegated":
+          return null;
+        case "principal":
+        case "unrestricted":
+          break;
+      }
       const projection = source.getById(projectionId);
       return projection && visible(projection) ? projection : null;
     },
     runs: {
       getById: async (runId) => {
+        switch (authority.type) {
+          case "denied":
+          case "delegated":
+            return null;
+          case "principal":
+          case "unrestricted":
+            break;
+        }
         const run = await runtime.storage.projectionRuns?.getById({
           projectId: runtime.projectId,
           id: runId
         }) ?? null;
-        return run && canViewProjectionRun(runtime.authorization, run.target) ? run : null;
+        if (!run)
+          return null;
+        return authority.type === "unrestricted" || canViewProjectionRun(authority.context, run.target) ? run : null;
       },
       list: (input = {}) => {
+        switch (authority.type) {
+          case "denied":
+          case "delegated":
+            return Promise.resolve({ runs: [], hasMore: false, total: 0 });
+          case "principal":
+          case "unrestricted":
+            break;
+        }
         const storage = runtime.storage.projectionRuns;
         if (!storage)
           return Promise.resolve({ runs: [], hasMore: false, total: 0 });
         return storage.list({
-          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
         });
       },
       listLatest: (projectionIds) => {
+        switch (authority.type) {
+          case "denied":
+          case "delegated":
+            return Promise.resolve({ runs: [] });
+          case "principal":
+          case "unrestricted":
+            break;
+        }
         const storage = runtime.storage.projectionRuns;
         if (!storage || projectionIds.length === 0)
           return Promise.resolve({ runs: [] });
@@ -993,25 +1435,35 @@ function createProjectionsRuntime(runtime, source) {
 
 // src/rules/execution.ts
 function createRulesRuntime(runtime, source) {
-  const visible = (rule) => isAllowed(runtime.authorization, {
-    kind: "object.view",
-    objectTypeId: rule.subject.objectTypeId
-  });
+  const authority = resolveRuntimeAuthorizationForProject(runtime);
+  const visible = (rule) => {
+    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
         });
       }
     }
@@ -1019,1179 +1471,382 @@ function createRulesRuntime(runtime, source) {
 }
 
 // src/schedules/execution.ts
-function createSchedulesRuntime(schedules) {
-  return {
-    list: () => schedules.list(),
-    getById: (scheduleId) => schedules.getById(scheduleId)
-  };
-}
-
-// src/syncs/execution.ts
-function createSyncsRuntime(runtime, execution, source) {
-  const allowed = (syncId) => isAllowed(runtime.authorization, { kind: "sync.run", syncId });
-  const visibleIds = () => source.list().filter((sync) => allowed(sync.id)).map((sync) => sync.id);
-  return {
-    list: () => source.list().filter((sync) => allowed(sync.id)),
-    getById: (syncId) => {
-      const sync = source.getById(syncId);
-      return sync && allowed(syncId) ? sync : null;
-    },
-    request: async (input) => {
-      const sync = source.getById(input.syncId);
-      if (!sync)
-        throw new SyncValidationError(`[Sixb] Unknown sync '${input.syncId}'`);
-      return requestSyncRun(runtime, execution, sync, input);
-    },
-    runs: {
-      getById: async (runId) => {
-        const run = await runtime.storage.syncRuns?.getById({
-          projectId: runtime.projectId,
-          id: runId
-        }) ?? null;
-        return run && allowed(run.syncId) ? run : null;
-      },
-      list: (input = {}) => {
-        const storage = runtime.storage.syncRuns;
-        if (!storage)
-          return Promise.resolve({ runs: [], hasMore: false, total: 0 });
-        return storage.list({
-          projectId: runtime.projectId,
-          ...input,
-          syncIds: runtime.authorization ? visibleIds() : undefined
-        });
-      },
-      listLatest: (syncIds) => {
-        const storage = runtime.storage.syncRuns;
-        if (!storage || syncIds.length === 0)
-          return Promise.resolve({ runs: [] });
-        const allowedIds = syncIds.filter(allowed);
-        return allowedIds.length === 0 ? Promise.resolve({ runs: [] }) : storage.listLatestBySyncIds({ projectId: runtime.projectId, syncIds: allowedIds });
-      }
-    }
-  };
-}
-
-// src/workflows/errors.ts
-class WorkflowDefinitionError extends Error {
-  name = "WorkflowDefinitionError";
-}
-
-class WorkflowValidationError extends Error {
-  name = "WorkflowValidationError";
-  cause;
-  constructor(message, options) {
-    super(message);
-    this.cause = options?.cause;
-  }
-}
-
-// src/workflows/run-dispatch.ts
-import { randomUUID as randomUUID3 } from "crypto";
-import { isDeepStrictEqual } from "util";
-
-// src/agents/context-model.ts
-function serializeAgentContextForModel(parts) {
-  if (parts.length === 0)
-    return;
-  const lines = ["<sixb_user_context>"];
-  for (const part of parts) {
-    if (part.context.kind === "object") {
-      lines.push("  <object_context>", `    <object_type_id>${escapeXml(part.context.ref.objectTypeId)}</object_type_id>`, `    <primary_id>${escapeXml(part.context.ref.primaryId)}</primary_id>`, "  </object_context>");
-      continue;
-    }
-    lines.push("  <app_state_context>", `    <id>${escapeXml(part.context.id)}</id>`, `    <description>${escapeXml(part.context.description)}</description>`, `    <value format="json">${escapeXml(stableJsonStringify(part.context.value))}</value>`, "  </app_state_context>");
-  }
-  lines.push("</sixb_user_context>");
-  return lines.join(`
-`);
-}
-function escapeXml(value) {
-  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
-}
-
-// src/agents/tool-result.ts
-function isAgentToolResult(value) {
-  return isPlainRecord(value) && value.kind === "agentToolResult" && getInvalidAgentToolResultReason(value) === undefined;
-}
-function getInvalidAgentToolResultReason(value) {
-  if (!isPlainRecord(value) || value.kind !== "agentToolResult") {
-    return;
-  }
-  if (!Array.isArray(value.content)) {
-    return "result.content must be an array";
-  }
-  const unsupportedKey = Object.keys(value).find((key) => key !== "kind" && key !== "content");
-  if (unsupportedKey) {
-    return `result.${unsupportedKey} is not supported`;
-  }
-  if (value.content.length === 0) {
-    return "result.content must contain at least one content part";
-  }
-  for (let index = 0;index < value.content.length; index += 1) {
-    const part = value.content[index];
-    const path = `result.content[${index}]`;
-    if (!isPlainRecord(part)) {
-      return `${path} must be a text or file content part`;
-    }
-    if (part.type === "text") {
-      if (typeof part.text !== "string") {
-        return `${path}.text must be a string`;
-      }
-      const unsupportedKey2 = Object.keys(part).find((key) => key !== "type" && key !== "text");
-      if (unsupportedKey2) {
-        return `${path}.${unsupportedKey2} is not supported`;
-      }
-      continue;
-    }
-    if (part.type === "file") {
-      if (!isFileRef(part.fileRef)) {
-        return `${path}.fileRef must be a valid FileRef`;
-      }
-      const unsupportedKey2 = Object.keys(part).find((key) => key !== "type" && key !== "fileRef");
-      if (unsupportedKey2) {
-        return `${path}.${unsupportedKey2} is not supported`;
-      }
-      continue;
-    }
-    return `${path}.type must be 'text' or 'file'`;
-  }
-  return;
-}
-
-// src/agents/adapters.ts
-var TOOL_TYPE_PREFIX = "tool-";
-function assertAdapter(condition, message) {
-  if (!condition) {
-    throw new AgentMessageAdapterError(`[Sixb] ${message}`);
-  }
-}
-function requireJson(value, label) {
-  const reason = getInvalidJsonValueReason(value, label);
-  assertAdapter(reason === undefined, `agent message ${label} must be a JSON value; ${reason}`);
-  return value;
-}
-function optionalJson(value, label) {
-  if (value === undefined)
-    return;
-  return requireJson(omitUndefinedObjectProperties(value), label);
-}
-function omitUndefinedObjectProperties(value) {
-  return omitUndefinedObjectPropertiesInternal(value, new Set);
-}
-function omitUndefinedObjectPropertiesInternal(value, seen) {
-  if (typeof value !== "object" || value === null)
-    return value;
-  if (seen.has(value))
-    return value;
-  seen.add(value);
-  try {
-    if (Array.isArray(value)) {
-      return value.map((entry) => omitUndefinedObjectPropertiesInternal(entry, seen));
-    }
-    if (!isPlainRecord(value))
-      return value;
-    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined).map(([key, entry]) => [key, omitUndefinedObjectPropertiesInternal(entry, seen)]));
-  } finally {
-    seen.delete(value);
-  }
-}
-function isToolType(type) {
-  return type === "dynamic-tool" || type.startsWith(TOOL_TYPE_PREFIX);
-}
-function toolNameFromInbound(part) {
-  if (part.type === "dynamic-tool") {
-    assertAdapter(typeof part.toolName === "string" && part.toolName.length > 0, "dynamic-tool part is missing a tool name");
-    return part.toolName;
-  }
-  const name = part.type.slice(TOOL_TYPE_PREFIX.length);
-  assertAdapter(name.length > 0, `tool part type '${part.type}' is missing a tool name`);
-  return name;
-}
-function fromAiSdk(message) {
-  const { role } = message;
-  assertAdapter(role === "system" || role === "user" || role === "assistant", `unsupported message role '${role}'`);
-  const parts = message.parts.map((part) => fromAiSdkPart(part));
-  assertAdapter(role === "user" || !parts.some((part) => part.type === "context"), "context parts are only valid on user messages");
-  const metadata = optionalJson(message.metadata, "metadata");
-  return {
-    role,
-    parts,
-    ...metadata === undefined ? {} : { metadata }
-  };
-}
-function fromAiSdkPart(part) {
-  switch (part.type) {
-    case "text":
-    case "reasoning": {
-      assertAdapter(typeof part.text === "string", `${part.type} part is missing text`);
-      assertAdapter(part.state !== "streaming", `cannot persist a streaming ${part.type} part; messages are written only once finalized`);
-      const providerMetadata = optionalJson(part.providerMetadata, `${part.type}.providerMetadata`);
-      return {
-        type: part.type,
-        text: part.text,
-        ...providerMetadata === undefined ? {} : { providerMetadata }
-      };
-    }
-    case "step-start":
-      return { type: "step-start" };
-    case "file": {
-      assertAdapter(isFileRef(part.fileRef), "file part is missing a valid fileRef");
-      const providerMetadata = optionalJson(part.providerMetadata, "file.providerMetadata");
-      return {
-        type: "file",
-        fileRef: part.fileRef,
-        ...providerMetadata === undefined ? {} : { providerMetadata }
-      };
-    }
-    case "context":
-      return fromUiContextPart(part);
-    default: {
-      assertAdapter(isToolType(part.type), `unsupported message part type '${part.type}'; extend the Sixb message part union to support it`);
-      return fromAiSdkToolPart(part);
-    }
-  }
-}
-function fromUiContextPart(part) {
-  try {
-    const [entry] = normalizeAgentContextEntries([
-      { context: part.context, origin: part.origin }
-    ]);
-    return { type: "context", ...entry };
-  } catch (error) {
-    throw new AgentMessageAdapterError(error instanceof Error ? error.message : "[Sixb] Invalid agent context part.");
-  }
-}
-function fromAiSdkToolPart(part) {
-  const dynamic = part.type === "dynamic-tool";
-  const toolName = toolNameFromInbound(part);
-  assertAdapter(typeof part.toolCallId === "string" && part.toolCallId.length > 0, `tool part '${part.type}' is missing a toolCallId`);
-  assertAdapter(part.state === "output-available" || part.state === "output-error", `cannot persist tool part '${part.toolCallId}' in transient state '${part.state}'; only terminal states are stored`);
-  const input = part.input === undefined ? null : requireJson(part.input, "tool input");
-  const providerMetadata = optionalJson(part.callProviderMetadata, "tool callProviderMetadata");
-  const base = {
-    type: "tool-call",
-    toolCallId: part.toolCallId,
-    toolName,
-    input,
-    ...dynamic ? { dynamic: true } : {},
-    ...part.providerExecuted === undefined ? {} : { providerExecuted: part.providerExecuted },
-    ...providerMetadata === undefined ? {} : { providerMetadata }
-  };
-  if (part.state === "output-available") {
-    return { ...base, state: "output-available", output: requireJson(part.output, "tool output") };
-  }
-  assertAdapter(typeof part.errorText === "string", `tool part '${part.toolCallId}' is missing errorText`);
-  return { ...base, state: "output-error", errorText: part.errorText };
-}
-function toUiMessage(message) {
-  return {
-    role: message.role,
-    parts: message.parts.map((part) => toUiPart(part)),
-    ...message.metadata === undefined ? {} : { metadata: message.metadata }
-  };
-}
-function toUiPart(part) {
-  switch (part.type) {
-    case "text":
-    case "reasoning":
-      return {
-        type: part.type,
-        text: part.text,
-        ...part.providerMetadata === undefined ? {} : { providerMetadata: part.providerMetadata }
-      };
-    case "step-start":
-      return { type: "step-start" };
-    case "file":
-      return {
-        type: "file",
-        fileRef: part.fileRef,
-        ...part.providerMetadata === undefined ? {} : { providerMetadata: part.providerMetadata }
-      };
-    case "context":
-      return { type: "context", context: part.context, origin: part.origin };
-    case "tool-call":
-      return toUiToolPart(part);
-  }
-}
-function toUiToolPart(part) {
-  const body = {
-    toolCallId: part.toolCallId,
-    ...part.providerExecuted === undefined ? {} : { providerExecuted: part.providerExecuted },
-    ...part.providerMetadata === undefined ? {} : { callProviderMetadata: part.providerMetadata }
-  };
-  const state = part.state === "output-available" ? { state: "output-available", input: part.input, output: part.output } : { state: "output-error", input: part.input, errorText: part.errorText };
-  if (part.dynamic) {
-    return { type: "dynamic-tool", toolName: part.toolName, ...body, ...state };
-  }
-  return { type: `tool-${part.toolName}`, ...body, ...state };
-}
-function toModelMessages(messages, options = {}) {
-  const result = [];
-  for (const message of messages) {
-    switch (message.role) {
-      case "system":
-        result.push(systemModelMessage(message));
-        break;
-      case "user":
-        result.push(userModelMessage(message, options));
-        break;
-      case "assistant":
-        appendAssistantModelMessages(result, message, options);
-        break;
-    }
-  }
-  return result;
-}
-function systemModelMessage(message) {
-  const textParts = message.parts.filter(isTextPart);
-  const providerOptions = mergeProviderMetadata(textParts);
+function createSchedulesRuntime(runtime, schedules) {
+  const authority = resolveRuntimeAuthorizationForProject(runtime);
   return {
-    role: "system",
-    content: textParts.map((part) => part.text).join(""),
-    ...providerOptions === undefined ? {} : { providerOptions }
-  };
-}
-function mergeProviderMetadata(parts) {
-  let merged;
-  for (const part of parts) {
-    const meta = part.providerMetadata;
-    if (meta !== undefined && typeof meta === "object" && meta !== null && !Array.isArray(meta)) {
-      merged = { ...merged ?? {}, ...meta };
-    }
-  }
-  return merged;
-}
-function userModelMessage(message, options) {
-  const content = [];
-  const serializedContext = serializeAgentContextForModel(message.parts.filter((part) => part.type === "context"));
-  if (serializedContext) {
-    content.push({ type: "text", text: `${serializedContext}
-
-` });
-  }
-  message.parts.forEach((part, partIndex) => {
-    if (part.type === "text") {
-      content.push({
-        type: "text",
-        text: part.text,
-        ...part.providerMetadata === undefined ? {} : { providerOptions: part.providerMetadata }
-      });
-      return;
-    }
-    if (part.type === "file") {
-      const fileContext = options.fileText?.({ message, part, partIndex });
-      if (fileContext) {
-        content.push({ type: "text", text: fileContext });
+    list: () => {
+      switch (authority.type) {
+        case "denied":
+        case "delegated":
+          return [];
+        case "principal":
+        case "unrestricted":
+          return schedules.list();
       }
-      const resolved = options.fileData?.({ message, part, partIndex });
-      if (resolved) {
-        const projection = resolved instanceof URL ? { data: resolved } : resolved;
-        content.push({
-          type: "file",
-          data: projection.data,
-          mediaType: projection.mediaType ?? part.fileRef.mediaType ?? "application/octet-stream",
-          ...projection.filename !== undefined ? { filename: projection.filename } : part.fileRef.fileName === undefined ? {} : { filename: part.fileRef.fileName },
-          ...part.providerMetadata === undefined ? {} : { providerOptions: part.providerMetadata }
-        });
-      }
-    }
-  });
-  return { role: "user", content };
-}
-function appendAssistantModelMessages(result, message, options) {
-  let block = [];
-  const flush = () => {
-    if (block.length === 0) {
-      return;
-    }
-    const current = block;
-    block = [];
-    const content = [];
-    for (const { part, partIndex } of current) {
-      if (part.type === "text") {
-        content.push({
-          type: "text",
-          text: part.text,
-          ...part.providerMetadata === undefined ? {} : { providerOptions: part.providerMetadata }
-        });
-      } else if (part.type === "reasoning") {
-        content.push({
-          type: "reasoning",
-          text: part.text,
-          ...part.providerMetadata === undefined ? {} : { providerOptions: part.providerMetadata }
-        });
-      } else if (part.type === "file") {
-        const fileContext = options.fileText?.({ message, part, partIndex });
-        if (fileContext) {
-          content.push({ type: "text", text: fileContext });
-        }
-      } else if (part.type === "tool-call") {
-        content.push(toolCallModelPart(part));
-        if (part.providerExecuted === true) {
-          content.push(toolResultModelPart(message, part, partIndex, "json", options));
-        }
-      }
-    }
-    result.push({ role: "assistant", content });
-    const toolResults = current.flatMap(({ part, partIndex }) => part.type === "tool-call" && part.providerExecuted !== true ? [toolResultModelPart(message, part, partIndex, "text", options)] : []);
-    if (toolResults.length > 0) {
-      result.push({ role: "tool", content: toolResults });
-    }
-  };
-  message.parts.forEach((part, partIndex) => {
-    if (part.type === "step-start") {
-      flush();
-    } else {
-      block.push({ part, partIndex });
-    }
-  });
-  flush();
-}
-function toolCallModelPart(part) {
-  return {
-    type: "tool-call",
-    toolCallId: part.toolCallId,
-    toolName: part.toolName,
-    input: part.input,
-    ...part.providerExecuted === undefined ? {} : { providerExecuted: part.providerExecuted },
-    ...part.providerMetadata === undefined ? {} : { providerOptions: part.providerMetadata }
-  };
-}
-function toolResultModelPart(message, part, partIndex, errorMode, options) {
-  return {
-    type: "tool-result",
-    toolCallId: part.toolCallId,
-    toolName: part.toolName,
-    output: toolResultOutput(message, part, partIndex, errorMode, options),
-    ...part.providerMetadata === undefined ? {} : { providerOptions: part.providerMetadata }
-  };
-}
-function toolResultOutput(message, part, partIndex, errorMode, options) {
-  if (part.state === "output-error") {
-    return errorMode === "json" ? { type: "error-json", value: part.errorText } : { type: "error-text", value: part.errorText };
-  }
-  if (isAgentToolResult(part.output)) {
-    const value = [];
-    part.output.content.forEach((contentPart, contentIndex) => {
-      if (contentPart.type === "text") {
-        value.push(contentPart.text);
-        return;
-      }
-      const resolverInput = { message, part, partIndex, contentPart, contentIndex };
-      const fileContext = options.toolResultFileText?.(resolverInput);
-      if (fileContext) {
-        value.push(fileContext);
-      } else {
-        value.push(toolResultFileFallbackText(contentPart));
-      }
-    });
-    return { type: "text", value: value.join(`
-`) };
-  }
-  return typeof part.output === "string" ? { type: "text", value: part.output } : { type: "json", value: part.output };
-}
-function toolResultFileFallbackText(part) {
-  const attributes = [
-    part.fileRef.fileName ? `name=${JSON.stringify(part.fileRef.fileName)}` : undefined,
-    part.fileRef.mediaType ? `mediaType=${JSON.stringify(part.fileRef.mediaType)}` : undefined,
-    `sizeBytes=${part.fileRef.sizeBytes}`
-  ].filter((value) => value !== undefined);
-  return `[Tool-created file: ${attributes.join(" ")}. Contents are not available inline.]`;
-}
-function isTextPart(part) {
-  return part.type === "text";
-}
-// src/agents/api-gateway.ts
-import { createHmac, timingSafeEqual } from "crypto";
-var AGENT_API_GATEWAY_PREFIX = "/__sixb/agent-api";
-var AGENT_API_GATEWAY_CAPABILITY_PREFIX = "sixb_agw_v1_";
-var AGENT_API_ROUTES = SIXB_API_ROUTES.filter((route) => route.agentApi).map((route) => ({ method: route.method, path: route.path }));
-function createAgentApiGatewayCapability(input) {
-  return `${AGENT_API_GATEWAY_CAPABILITY_PREFIX}${capabilityDigest(input)}`;
-}
-function isValidAgentApiGatewayCapability(input) {
-  const expected = createAgentApiGatewayCapability(input);
-  const actual = input.capability;
-  const expectedBuffer = Buffer.from(expected);
-  const actualBuffer = Buffer.from(actual);
-  return expectedBuffer.byteLength === actualBuffer.byteLength && timingSafeEqual(expectedBuffer, actualBuffer);
-}
-function isAllowedAgentApiRequest(method, pathname) {
-  const normalizedMethod = method.toUpperCase();
-  const normalizedPath = normalizeRoutePath(pathname);
-  return AGENT_API_ROUTES.some((route) => route.method === normalizedMethod && matchesPathPattern(normalizedPath, route.path));
-}
-function capabilityDigest(input) {
-  return createHmac("sha256", input.executionToken).update(`agent-api-gateway:${input.projectId}:${input.runId}`).digest("base64url");
-}
-// src/agents/types.ts
-var AGENT_REASONING_LEVELS = [
-  "provider-default",
-  "none",
-  "minimal",
-  "low",
-  "medium",
-  "high",
-  "xhigh"
-];
-
-// src/agents/validation.ts
-var AGENT_TOOL_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_-]{0,63}$/;
-var AGENT_TOOL_PRIMITIVE_SCHEMAS = new Set([
-  "string",
-  "integer",
-  "double",
-  "decimal",
-  "boolean",
-  "date",
-  "timestamp",
-  "uuid",
-  "fileRef"
-]);
-var AGENT_RESERVED_TOOL_NAMES = ["bash", "read", "view_file"];
-function assertNonEmpty(value, field) {
-  if (!value.trim()) {
-    throw new AgentDefinitionError(`[Sixb] Agent ${field} must not be empty.`);
-  }
-}
-function isAgentDefinition(value) {
-  return isRecord(value) && value.kind === "agent" && typeof value.id === "string" && typeof value.name === "string" && typeof value.instructions === "string" && (value.reasoning === undefined || isAgentReasoningLevel(value.reasoning)) && (value.providerOptions === undefined || isProviderOptions(value.providerOptions)) && Array.isArray(value.groupIds) && isAgentToolDefinitionArray(value.tools);
-}
-function isAgentToolDefinition(value) {
-  return isRecord(value) && value.kind === "agentTool" && typeof value.name === "string" && typeof value.description === "string" && isPlainRecord(value.input) && typeof value.handler === "function";
-}
-function assertValidAgentToolName(name) {
-  if (typeof name !== "string" || !AGENT_TOOL_NAME_PATTERN.test(name)) {
-    throw new AgentDefinitionError("[Sixb] Agent tool name must be 1-64 characters, start with a letter or underscore, and contain only letters, numbers, underscores, or hyphens.");
-  }
-  if (AGENT_RESERVED_TOOL_NAMES.includes(name)) {
-    throw new AgentDefinitionError(`[Sixb] Agent tool name '${name}' is reserved by the framework.`);
-  }
-}
-function assertValidAgentToolDescription(name, description) {
-  if (typeof description !== "string" || !description.trim()) {
-    throw new AgentDefinitionError(`[Sixb] Agent tool '${name}' description must not be empty.`);
-  }
-}
-function assertValidAgentToolInput(name, input) {
-  if (!isPlainRecord(input)) {
-    throw new AgentDefinitionError(`[Sixb] Agent tool '${name}' input must be a schema object.`);
-  }
-  for (const [field, schema] of Object.entries(input)) {
-    if (!field.trim()) {
-      throw new AgentDefinitionError(`[Sixb] Agent tool '${name}' input field names must not be empty.`);
-    }
-    assertValidAgentToolSchema(name, schema, `input.${field}`, new Set);
-  }
-}
-function validateAndSnapshotAgentToolInput(toolName, input) {
-  assertValidAgentToolInput(toolName, input);
-  try {
-    return deepFreeze(structuredClone(input));
-  } catch {
-    throw new AgentDefinitionError(`[Sixb] Agent tool '${toolName}' input must be safely snapshot-compatible.`);
-  }
-}
-function validateAndNormalizeAgentToolInput(toolName, shape, value, valueTypesById) {
-  const label = `Agent tool '${toolName}' input`;
-  if (!isPlainRecord(value)) {
-    throw new OntologyValidationError(`[Sixb] ${label} must be a JSON object.`);
-  }
-  const reason = getInvalidJsonValueReason(value, label);
-  if (reason) {
-    throw new OntologyValidationError(`[Sixb] ${label} must be JSON-compatible; ${reason}.`);
-  }
-  const schema = {
-    type: "object",
-    properties: Object.fromEntries(Object.entries(shape).map(([field, fieldSchema]) => [
-      field,
-      { schema: fieldSchema, required: true }
-    ]))
-  };
-  validateSchemaValue(schema, value, label, valueTypesById);
-  return deepFreeze(normalizeSchemaValue(schema, value, label, valueTypesById));
-}
-function validateAgentToolsAtStartup(agents) {
-  for (const agent of agents) {
-    if (!isAgentDefinition(agent)) {
-      throw new AgentDefinitionError("[Sixb] Agents must contain only valid agent definitions.");
-    }
-    assertValidAgentToolDefinitions(agent.id, agent.tools);
-    for (const tool of agent.tools) {
-      deepFreeze(tool.input);
-      Object.freeze(tool);
-    }
-    Object.freeze(agent.tools);
-    Object.freeze(agent);
-  }
-}
-function resolveAgentLoopConfig(loop) {
-  if (loop === undefined)
-    return;
-  const maxSteps = loop?.stopWhen?.maxSteps;
-  if (maxSteps !== undefined && (!Number.isSafeInteger(maxSteps) || maxSteps <= 0)) {
-    throw new AgentDefinitionError("[Sixb] Agent loop.stopWhen.maxSteps must be a positive safe integer.");
-  }
-  if (loop.caching !== undefined && loop.caching !== "auto" && loop.caching !== "off") {
-    throw new AgentDefinitionError("[Sixb] Agent loop.caching must be 'auto' or 'off'.");
-  }
-  const context = loop.context ? snapshotAgentContextConfig(loop.context) : undefined;
-  return Object.freeze({
-    ...loop.stopWhen === undefined ? {} : { stopWhen: Object.freeze({ ...maxSteps === undefined ? {} : { maxSteps } }) },
-    ...context === undefined ? {} : { context },
-    ...loop.caching === undefined ? {} : { caching: loop.caching }
-  });
-}
-function snapshotAgentContextConfig(context) {
-  const snapshot = {};
-  for (const field of ["windowTokens", "reserveTokens", "keepRecentTokens"]) {
-    const value = context[field];
-    if (value === undefined)
-      continue;
-    assertPositiveSafeInteger(value, field);
-    snapshot[field] = value;
-  }
-  return Object.freeze(snapshot);
-}
-function assertPositiveSafeInteger(value, field) {
-  if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
-    throw new AgentDefinitionError(`[Sixb] Agent loop.context.${field} must be a positive safe integer.`);
-  }
-}
-function assertValidReasoningLevel(reasoning) {
-  if (reasoning === undefined) {
-    return;
-  }
-  if (!isAgentReasoningLevel(reasoning)) {
-    throw new AgentDefinitionError(`[Sixb] Agent reasoning must be one of: ${AGENT_REASONING_LEVELS.join(", ")}.`);
-  }
-}
-function assertValidProviderOptions(providerOptions) {
-  if (providerOptions === undefined) {
-    return;
-  }
-  const reason = getInvalidJsonValueReason(providerOptions, "providerOptions");
-  if (!isRecord(providerOptions) || reason) {
-    throw new AgentDefinitionError(`[Sixb] Agent providerOptions must be a provider-keyed JSON object${reason ? `; ${reason}` : "."}`);
-  }
-  for (const [provider, options] of Object.entries(providerOptions)) {
-    if (!provider.trim()) {
-      throw new AgentDefinitionError("[Sixb] Agent providerOptions provider names must not be empty.");
-    }
-    const optionsReason = getInvalidJsonValueReason(options, `providerOptions.${provider}`);
-    if (!isRecord(options) || optionsReason) {
-      throw new AgentDefinitionError(`[Sixb] Agent providerOptions.${provider} must be a JSON object${optionsReason ? `; ${optionsReason}` : "."}`);
-    }
-  }
-}
-function groupIdsFromDefinitions(agentId, groups) {
-  const groupIds = (groups ?? []).map((group) => {
-    if (!isRecord(group) || group.kind !== "group") {
-      throw new AgentDefinitionError(`[Sixb] Agent '${agentId}' groups must contain only group definitions.`);
-    }
-    assertNonEmpty(group.id, `Agent '${agentId}' group id`);
-    return group.id;
-  });
-  assertNoDuplicateGroupIds(agentId, groupIds);
-  return Object.freeze(groupIds);
-}
-function validateAgentGroupReferences(agents, security) {
-  for (const agent of agents) {
-    assertNoDuplicateGroupIds(agent.id, agent.groupIds);
-    for (const groupId of agent.groupIds) {
-      if (!security.getGroupById(groupId)) {
-        throw new AgentDefinitionError(`[Sixb] Agent '${agent.id}' groups references unknown group '${groupId}'. Add it to 'security/groups/' or pass it to createSixb({ groups }).`);
+    },
+    getById: (scheduleId) => {
+      switch (authority.type) {
+        case "denied":
+        case "delegated":
+          return null;
+        case "principal":
+        case "unrestricted":
+          return schedules.getById(scheduleId);
       }
     }
-  }
-}
-function assertNoDuplicateGroupIds(agentId, groupIds) {
-  const seen = new Set;
-  for (const groupId of groupIds) {
-    assertNonEmpty(groupId, `Agent '${agentId}' group id`);
-    if (seen.has(groupId)) {
-      throw new AgentDefinitionError(`[Sixb] Agent '${agentId}' groups contains duplicate group id '${groupId}'.`);
-    }
-    seen.add(groupId);
-  }
-}
-function isAgentReasoningLevel(value) {
-  return typeof value === "string" && AGENT_REASONING_LEVELS.includes(value);
+  };
 }
-function isProviderOptions(value) {
-  if (!isRecord(value) || getInvalidJsonValueReason(value) !== undefined) {
-    return false;
+
+// src/shares/execution.ts
+import { createHash as createHash2, randomBytes, randomUUID as randomUUID4 } from "crypto";
+var MAX_CREATE_ATTEMPTS = 5;
+
+class ShareError extends Error {
+  reason;
+  name = "ShareError";
+  constructor(reason, message, options) {
+    super(message, options);
+    this.reason = reason;
   }
-  return Object.entries(value).every(([provider, options]) => provider.trim().length > 0 && isRecord(options) && getInvalidJsonValueReason(options) === undefined);
 }
-function assertValidAgentToolSchema(toolName, schema, path, visiting) {
-  if (typeof schema === "string") {
-    if (AGENT_TOOL_PRIMITIVE_SCHEMAS.has(schema)) {
-      return;
+function createSharesRuntime(runtime, execution, definitions) {
+  const managementPrincipal = () => {
+    const authority = resolveExecutionScopeAuthorization(runtime.projectId, {
+      execution,
+      authorization: runtime.runtimeAuthorization
+    });
+    if (authority.type !== "principal" || authority.context.principal.type === "system") {
+      throw new ShareError("unauthenticated", "[Sixb] Shared access grants require user or service-account authority.");
     }
-    throw invalidAgentToolSchema(toolName, path);
-  }
-  if (!isPlainRecord(schema) || typeof schema.type !== "string" || visiting.has(schema)) {
-    throw invalidAgentToolSchema(toolName, path);
-  }
-  visiting.add(schema);
-  switch (schema.type) {
-    case "enum": {
-      const values = schema.values;
-      const validValues = isValidAgentToolEnumValues(values, schema.valueType);
-      if (!validValues || new Set(values).size !== values.length) {
-        throw invalidAgentToolSchema(toolName, path);
-      }
-      break;
-    }
-    case "array":
-      assertValidAgentToolSchema(toolName, schema.items, `${path}.items`, visiting);
-      break;
-    case "map":
-      if (schema.keySchema !== "string") {
-        throw invalidAgentToolSchema(toolName, path);
-      }
-      assertValidAgentToolSchema(toolName, schema.valueSchema, `${path}.valueSchema`, visiting);
-      break;
-    case "object": {
-      if (!isPlainRecord(schema.properties)) {
-        throw invalidAgentToolSchema(toolName, path);
-      }
-      for (const [fieldId, field] of Object.entries(schema.properties)) {
-        if (!fieldId.trim() || !isPlainRecord(field) || !("schema" in field)) {
-          throw invalidAgentToolSchema(toolName, `${path}.properties.${fieldId}`);
+    return {
+      type: authority.context.principal.type,
+      id: authority.context.principal.id
+    };
+  };
+  const canManage = (shareId) => {
+    try {
+      managementPrincipal();
+      return isRuntimeAllowed(runtime, { kind: "share.manage", shareId });
+    } catch {
+      return false;
+    }
+  };
+  const resolveManageableDefinition = (definitionId) => {
+    const id = validDefinitionId(definitionId);
+    managementPrincipal();
+    assertCanManage(runtime, id);
+    return resolveDefinition(definitions, id);
+  };
+  const issueByDefinition = async (definition, input) => {
+    assertInputObject(input, "Shared access issue input");
+    const issuer = managementPrincipal();
+    assertCanManage(runtime, definition.id);
+    const storage = requireShareStorage(runtime);
+    const createdAt = new Date;
+    const expiresAt = validFutureDate(input.expiresAt, createdAt);
+    const target = exactTarget(definition, input.target);
+    const object = await runtime.objectReader.getByPrimaryId({
+      objectTypeId: target.objectTypeId,
+      primaryId: target.primaryId
+    });
+    if (!object) {
+      throw new ObjectNotFoundError(target.objectTypeId, target.primaryId, "Share target not found");
+    }
+    const authoritySnapshot = {
+      version: 1,
+      access: compileShareAccessPlan({
+        share: definition,
+        target,
+        ontology: runtime.ontology,
+        actions: runtime.actionRegistry
+      })
+    };
+    for (let attempt = 0;attempt < MAX_CREATE_ATTEMPTS; attempt += 1) {
+      const secret = randomBytes(32).toString("base64url");
+      try {
+        const grant = await storage.create({
+          id: `shr_${randomUUID4()}`,
+          projectId: runtime.projectId,
+          definitionId: definition.id,
+          target,
+          issuedBy: issuer,
+          authoritySnapshot,
+          tokenHash: sha256(secret),
+          destinationPath: input.destinationPath,
+          createdAt,
+          expiresAt
+        });
+        return { grant: publicGrant(grant), secret };
+      } catch (error) {
+        if (error instanceof ShareGrantStorageError && error.code === "invalid_input") {
+          throw new ShareError("invalid_input", error.message, { cause: error });
         }
-        if (field.required !== undefined && typeof field.required !== "boolean" || field.nullable !== undefined && typeof field.nullable !== "boolean" || field.description !== undefined && (typeof field.description !== "string" || !field.description.trim())) {
-          throw invalidAgentToolSchema(toolName, `${path}.properties.${fieldId}`);
+        if (!(error instanceof ShareGrantStorageError) || error.code !== "duplicate" || attempt === MAX_CREATE_ATTEMPTS - 1) {
+          throw storageFailure("issue", error);
         }
-        assertValidAgentToolSchema(toolName, field.schema, `${path}.properties.${fieldId}.schema`, visiting);
       }
-      break;
     }
-    case "valueTypeRef":
-      if (typeof schema.valueTypeId !== "string" || !schema.valueTypeId.trim()) {
-        throw invalidAgentToolSchema(toolName, path);
+    throw storageFailure("issue");
+  };
+  const listByDefinition = async (definition, input = {}) => {
+    assertInputObject(input, "Shared access list input");
+    managementPrincipal();
+    assertCanManage(runtime, definition.id);
+    const storage = requireShareStorage(runtime);
+    const target = input.target === undefined ? undefined : exactTarget(definition, input.target);
+    try {
+      const result = await storage.list({
+        projectId: runtime.projectId,
+        definitionId: definition.id,
+        ...target === undefined ? {} : { target },
+        includeRevoked: input.includeRevoked,
+        includeExpired: input.includeExpired,
+        now: new Date,
+        limit: input.limit,
+        offset: input.offset
+      });
+      return { ...result, grants: result.grants.map(publicGrant) };
+    } catch (error) {
+      if (error instanceof ShareGrantStorageError && error.code === "invalid_input") {
+        throw new ShareError("invalid_input", error.message, { cause: error });
+      }
+      throw storageFailure("list", error);
+    }
+  };
+  return {
+    listDefinitions: () => definitions.list().filter((definition) => canManage(definition.id)),
+    getDefinitionById: (definitionId) => {
+      const definition = definitions.getById(definitionId);
+      return definition && canManage(definition.id) ? definition : null;
+    },
+    async issue(definition, input) {
+      return issueByDefinition(resolveManageableDefinition(definitionIdFromReference(definition)), input);
+    },
+    async issueById(input) {
+      assertInputObject(input, "Shared access issue input");
+      return issueByDefinition(resolveManageableDefinition(input.definitionId), input);
+    },
+    async list(definition, input) {
+      return listByDefinition(resolveManageableDefinition(definitionIdFromReference(definition)), input);
+    },
+    async listById(input) {
+      assertInputObject(input, "Shared access list input");
+      const definition = resolveManageableDefinition(input.definitionId);
+      const { primaryId, includeRevoked, includeExpired, limit, offset } = input;
+      return listByDefinition(definition, {
+        ...primaryId === undefined ? {} : {
+          target: {
+            objectTypeId: definition.target.objectTypeId,
+            primaryId
+          }
+        },
+        includeRevoked,
+        includeExpired,
+        limit,
+        offset
+      });
+    },
+    revoke: async (grantId) => {
+      const actor = managementPrincipal();
+      const storage = requireShareStorage(runtime);
+      if (typeof grantId !== "string" || !grantId.trim()) {
+        throw new ShareError("invalid_input", "[Sixb] Shared access grant id must not be empty.");
       }
-      if (schema._resolved !== undefined) {
-        assertValidAgentToolSchema(toolName, schema._resolved, `${path}._resolved`, visiting);
+      let current;
+      try {
+        current = await storage.getById({ projectId: runtime.projectId, id: grantId });
+      } catch (error) {
+        throw storageFailure("load for revocation", error);
+      }
+      if (!current)
+        return null;
+      if (!definitions.getById(current.definitionId) || !canManage(current.definitionId)) {
+        return null;
+      }
+      try {
+        const revoked = await storage.revoke({
+          projectId: runtime.projectId,
+          id: grantId,
+          revokedAt: new Date,
+          revokedBy: actor
+        });
+        return revoked ? publicGrant(revoked) : null;
+      } catch (error) {
+        throw storageFailure("revoke", error);
       }
-      break;
-    default:
-      throw invalidAgentToolSchema(toolName, path);
-  }
-  visiting.delete(schema);
-}
-function invalidAgentToolSchema(toolName, path) {
-  return new AgentDefinitionError(`[Sixb] Agent tool '${toolName}' ${path} must be a valid Sixb schema.`);
-}
-function isAgentToolDefinitionArray(value) {
-  if (!Array.isArray(value)) {
-    return false;
-  }
-  for (let index = 0;index < value.length; index += 1) {
-    if (!Object.hasOwn(value, index) || !isAgentToolDefinition(value[index])) {
-      return false;
     }
-  }
-  return true;
+  };
 }
-function assertValidAgentToolDefinitions(agentId, tools) {
-  const seen = new Set;
-  for (let index = 0;index < tools.length; index += 1) {
-    const tool = tools[index];
-    if (!Object.hasOwn(tools, index) || !isAgentToolDefinition(tool)) {
-      throw new AgentDefinitionError(`[Sixb] Agent '${agentId}' tools must contain only agent tool definitions.`);
-    }
-    assertValidAgentToolName(tool.name);
-    assertValidAgentToolDescription(tool.name, tool.description);
-    assertValidAgentToolInput(tool.name, tool.input);
-    if (seen.has(tool.name)) {
-      throw new AgentDefinitionError(`[Sixb] Agent '${agentId}' tools contains duplicate tool name '${tool.name}'.`);
-    }
-    seen.add(tool.name);
-  }
+function definitionIdFromReference(value) {
+  return typeof value === "object" && value !== null ? value.id : undefined;
 }
-function isValidAgentToolEnumValues(values, valueType) {
-  if (!Array.isArray(values) || values.length === 0) {
-    return false;
-  }
-  for (let index = 0;index < values.length; index += 1) {
-    if (!Object.hasOwn(values, index)) {
-      return false;
-    }
-    const value = values[index];
-    if (valueType === "string" ? typeof value !== "string" : valueType !== "integer" || typeof value !== "number" || !Number.isInteger(value)) {
-      return false;
-    }
+function assertInputObject(value, label) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new ShareError("invalid_input", `[Sixb] ${label} must be an object.`);
   }
-  return true;
 }
-function deepFreeze(value, seen = new Set) {
-  if (value === null || typeof value !== "object" || seen.has(value)) {
-    return value;
+function resolveDefinition(definitions, definitionId) {
+  const id = validDefinitionId(definitionId);
+  const definition = definitions.getById(id);
+  if (!definition) {
+    throw new ShareError("not_found", `[Sixb] Unknown Share definition '${id}'.`);
   }
-  seen.add(value);
-  for (const key of Reflect.ownKeys(value)) {
-    const descriptor = Object.getOwnPropertyDescriptor(value, key);
-    if (descriptor && "value" in descriptor) {
-      deepFreeze(descriptor.value, seen);
-    }
+  return definition;
+}
+function validDefinitionId(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new ShareError("invalid_input", "[Sixb] Share definition id must not be empty.");
   }
-  return Object.freeze(value);
+  return value;
 }
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function assertCanManage(runtime, shareId) {
+  assertAuthorized(runtime, { kind: "share.manage", shareId });
 }
-
-// src/agents/tool-definition.ts
-var EMPTY_AGENT_TOOLS = Object.freeze([]);
-var normalizedAgentTools = new WeakSet;
-function createAgentToolDefinition(definition) {
-  assertValidAgentToolName(definition.name);
-  assertValidAgentToolDescription(definition.name, definition.description);
-  if (typeof definition.handler !== "function") {
-    throw new AgentDefinitionError(`[Sixb] Agent tool '${definition.name}' handler must be a function.`);
-  }
-  const input = validateAndSnapshotAgentToolInput(definition.name, definition.input);
-  const tool = {
-    kind: "agentTool",
-    name: definition.name,
-    description: definition.description,
-    input,
-    handler: async (context) => {
-      const result = await definition.handler(context);
-      let snapshot;
-      try {
-        snapshot = cloneJsonValue(result, "result");
-      } catch (cause) {
-        throw new AgentToolResultValidationError(definition.name, getInvalidJsonValueReason(result, "result") ?? "result could not be cloned safely", { cause });
-      }
-      const richResultReason = getInvalidAgentToolResultReason(snapshot);
-      if (richResultReason) {
-        throw new AgentToolResultValidationError(definition.name, richResultReason);
-      }
-      return snapshot;
-    }
-  };
-  normalizedAgentTools.add(tool);
-  return Object.freeze(tool);
+function requireShareStorage(runtime) {
+  const storage = runtime.storage.shareGrants;
+  if (!storage) {
+    throw new ShareError("storage_unavailable", "[Sixb] Share grant storage is not configured on this runtime.");
+  }
+  return storage;
 }
-function toolsFromDefinitions(agentId, tools) {
-  if (tools === undefined) {
-    return EMPTY_AGENT_TOOLS;
+function exactTarget(definition, value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new ShareError("invalid_input", "[Sixb] Share target must be an exact object reference.");
   }
-  if (!Array.isArray(tools)) {
-    throw new AgentDefinitionError(`[Sixb] Agent '${agentId}' tools must be an array of agent tool definitions.`);
+  const objectTypeId = value.objectTypeId;
+  const primaryId = value.primaryId;
+  if (typeof objectTypeId !== "string" || typeof primaryId !== "string" || !primaryId.trim()) {
+    throw new ShareError("invalid_input", "[Sixb] Share target must be an exact object reference.");
   }
-  assertValidAgentToolDefinitions(agentId, tools);
-  const normalized = [];
-  for (const tool of tools) {
-    normalized.push(normalizeAgentToolDefinition(tool));
+  if (objectTypeId !== definition.target.objectTypeId) {
+    throw new ShareError("invalid_input", `[Sixb] Share '${definition.id}' targets '${definition.target.objectTypeId}', not '${objectTypeId}'.`);
   }
-  return Object.freeze(normalized);
+  return Object.freeze({ objectTypeId, primaryId });
 }
-function normalizeAgentToolDefinition(tool) {
-  if (normalizedAgentTools.has(tool)) {
-    return tool;
+function validFutureDate(value, now) {
+  if (!(value instanceof Date) || !Number.isFinite(value.getTime()) || value <= now) {
+    throw new ShareError("invalid_input", "[Sixb] Shared access expiry must be a valid future date.");
   }
-  return createAgentToolDefinition({
-    name: tool.name,
-    description: tool.description,
-    input: tool.input,
-    handler: (context) => tool.handler(context)
-  });
+  return new Date(value);
 }
-
-// src/agents/builders.ts
-function defineAgentTool(name) {
-  assertValidAgentToolName(name);
-  return {
-    description(description) {
-      assertValidAgentToolDescription(name, description);
-      return {
-        input(input) {
-          assertValidAgentToolInput(name, input);
-          return {
-            run(handler) {
-              return createAgentToolDefinition({ name, description, input, handler });
-            }
-          };
-        }
-      };
-    }
-  };
+function sha256(value) {
+  return createHash2("sha256").update(value).digest("hex");
 }
-function defineAgent(id, config) {
-  assertNonEmpty(id, "id");
-  assertNonEmpty(config.name, "name");
-  assertNonEmpty(config.instructions, "instructions");
-  if (config.model === undefined || config.model === null) {
-    throw new AgentDefinitionError("[Sixb] Agent model is required.");
-  }
-  assertValidReasoningLevel(config.reasoning);
-  assertValidProviderOptions(config.providerOptions);
-  const loop = resolveAgentLoopConfig(config.loop);
-  const groupIds = groupIdsFromDefinitions(id, config.groups);
-  const tools = toolsFromDefinitions(id, config.tools);
-  return Object.freeze({
-    kind: "agent",
-    id,
-    name: config.name,
-    model: config.model,
-    ...config.reasoning !== undefined ? { reasoning: config.reasoning } : {},
-    ...config.providerOptions !== undefined ? { providerOptions: config.providerOptions } : {},
-    instructions: config.instructions,
-    groupIds,
-    tools,
-    ...config.description !== undefined ? { description: config.description } : {},
-    ...loop !== undefined ? { loop } : {}
-  });
+function publicGrant(record) {
+  const {
+    projectId: _projectId,
+    authoritySnapshot: _authoritySnapshot,
+    authorityDigest: _authorityDigest,
+    tokenHash: _tokenHash,
+    ...grant
+  } = record;
+  return structuredClone(grant);
 }
-// src/agents/context-compaction.ts
-var AGENT_CONTEXT_ESTIMATOR_VERSION = 1;
-var CHARS_PER_TOKEN = 4;
-var REQUEST_OVERHEAD_TOKENS = 8;
-var MESSAGE_OVERHEAD_TOKENS = 8;
-var TOOL_OVERHEAD_TOKENS = 16;
-var STEP_OVERHEAD_TOKENS = 2;
-var IMAGE_ALLOWANCE_TOKENS = 1200;
-var FILE_TEXT_INLINE_MAX_BYTES = 50 * 1024;
-var FILE_TEXT_INLINE_TOTAL_MAX_BYTES = 200 * 1024;
-var TOOL_RESULT_SUMMARY_MAX_CHARS = 2000;
-function shouldCompactAgentContext(input) {
-  return input.estimatedInputTokens > input.inputBudgetTokens;
-}
-function estimateAgentContextRequestTokens(input) {
-  const toolTokens = input.tools.reduce((total, tool) => total + TOOL_OVERHEAD_TOKENS + textTokens(tool.name) + textTokens(tool.description) + textTokens(tool.inputSchema), 0);
-  return {
-    tokens: REQUEST_OVERHEAD_TOKENS + textTokens(input.systemPrompt) + toolTokens + estimateAgentContextMessagesTokens(input.messages).tokens,
-    estimatorVersion: AGENT_CONTEXT_ESTIMATOR_VERSION
-  };
+function storageFailure(operation, cause) {
+  return new ShareError("storage_failure", `[Sixb] Share grant storage failed to ${operation}.`, {
+    cause
+  });
 }
-function estimateAgentContextMessagesTokens(messages) {
-  const attachments = { textBytesRemaining: FILE_TEXT_INLINE_TOTAL_MAX_BYTES };
-  let tokens = 0;
-  for (const message of messages) {
-    tokens += estimateMessageTokens(message, attachments);
-  }
-  return { tokens, estimatorVersion: AGENT_CONTEXT_ESTIMATOR_VERSION };
-}
-function selectAgentContextCompactionBoundary(input) {
-  if (input.messages.length < 2)
-    return null;
-  let retainedTokens = 0;
-  let boundaryIndex = null;
-  let closestDistance = Number.POSITIVE_INFINITY;
-  for (let index = input.messages.length - 1;index > 0; index -= 1) {
-    retainedTokens += estimateAgentContextMessagesTokens([input.messages[index]]).tokens;
-    if (input.messages[index]?.role !== "user")
-      continue;
-    const distance = Math.abs(input.keepRecentTokens - retainedTokens);
-    if (distance <= closestDistance) {
-      boundaryIndex = index;
-      closestDistance = distance;
-    }
-    if (retainedTokens >= input.keepRecentTokens)
-      break;
-  }
-  if (boundaryIndex === null)
-    return null;
-  const summarizedThroughSeq = input.messages[boundaryIndex - 1]?.seq;
-  if (summarizedThroughSeq === undefined)
-    return null;
+
+// src/syncs/execution.ts
+function createSyncsRuntime(runtime, execution, source) {
+  const authority = resolveRuntimeAuthorizationForProject(runtime);
+  const allowed = (syncId) => isRuntimeAllowed(runtime, { kind: "sync.run", syncId });
+  const visibleIds = () => source.list().filter((sync) => allowed(sync.id)).map((sync) => sync.id);
+  const historyFilterIds = () => authority.type === "unrestricted" ? undefined : authority.type === "principal" ? visibleIds() : [];
   return {
-    messagesToSummarize: input.messages.slice(0, boundaryIndex),
-    retainedMessages: input.messages.slice(boundaryIndex),
-    summarizedThroughSeq
-  };
-}
-function serializeAgentMessagesForSummary(messages) {
-  const lines = ["<sixb_conversation_history>"];
-  for (const message of messages) {
-    lines.push(`  <message id="${escapeXml2(message.id)}" seq="${message.seq}" role="${message.role}">`);
-    message.parts.forEach((part, partIndex) => {
-      lines.push(...serializeSummaryPart(message, part, partIndex));
-    });
-    lines.push("  </message>");
-  }
-  lines.push("</sixb_conversation_history>");
-  return lines.join(`
-`);
-}
-function estimateMessageTokens(message, attachments) {
-  let tokens = MESSAGE_OVERHEAD_TOKENS;
-  for (const part of message.parts) {
-    switch (part.type) {
-      case "text":
-      case "reasoning":
-        tokens += textTokens(part.text);
-        break;
-      case "step-start":
-        tokens += STEP_OVERHEAD_TOKENS;
-        break;
-      case "context":
-        tokens += textTokens(stableJsonStringify(part.context));
-        break;
-      case "tool-call":
-        tokens += TOOL_OVERHEAD_TOKENS + textTokens(part.toolName) + textTokens(stableJsonStringify(part.input)) + (part.state === "output-available" ? textTokens(stableJsonStringify(part.output)) : textTokens(part.errorText));
-        break;
-      case "file": {
-        const file = part.fileRef;
-        tokens += textTokens([file.blobId, file.digest, file.fileName, file.mediaType, file.logicalPath].filter((value) => value !== undefined).join(" "));
-        if (message.role !== "assistant") {
-          if (looksLikeImage(file.mediaType, file.fileName)) {
-            tokens += IMAGE_ALLOWANCE_TOKENS;
-          } else {
-            const inlineBytes = Math.min(file.sizeBytes, FILE_TEXT_INLINE_MAX_BYTES, attachments.textBytesRemaining);
-            attachments.textBytesRemaining -= inlineBytes;
-            tokens += Math.ceil(inlineBytes / CHARS_PER_TOKEN);
-          }
+    list: () => authority.type === "denied" || authority.type === "delegated" ? [] : source.list().filter((sync) => allowed(sync.id)),
+    getById: (syncId) => {
+      if (authority.type === "denied" || authority.type === "delegated")
+        return null;
+      const sync = source.getById(syncId);
+      return sync && allowed(syncId) ? sync : null;
+    },
+    request: async (input) => {
+      assertAuthorized(runtime, { kind: "sync.run", syncId: input.syncId });
+      const sync = source.getById(input.syncId);
+      if (!sync)
+        throw new SyncValidationError(`[Sixb] Unknown sync '${input.syncId}'`);
+      return requestSyncRun(runtime, execution, sync, input);
+    },
+    runs: {
+      getById: async (runId) => {
+        if (authority.type === "denied" || authority.type === "delegated")
+          return null;
+        const run = await runtime.storage.syncRuns?.getById({
+          projectId: runtime.projectId,
+          id: runId
+        }) ?? null;
+        return run && allowed(run.syncId) ? run : null;
+      },
+      list: (input = {}) => {
+        if (authority.type === "denied" || authority.type === "delegated") {
+          return Promise.resolve({ runs: [], hasMore: false, total: 0 });
+        }
+        const storage = runtime.storage.syncRuns;
+        if (!storage)
+          return Promise.resolve({ runs: [], hasMore: false, total: 0 });
+        return storage.list({
+          ...input,
+          syncIds: historyFilterIds(),
+          projectId: runtime.projectId
+        });
+      },
+      listLatest: (syncIds) => {
+        if (authority.type === "denied" || authority.type === "delegated") {
+          return Promise.resolve({ runs: [] });
         }
-        break;
+        const storage = runtime.storage.syncRuns;
+        if (!storage || syncIds.length === 0)
+          return Promise.resolve({ runs: [] });
+        const allowedIds = syncIds.filter(allowed);
+        return allowedIds.length === 0 ? Promise.resolve({ runs: [] }) : storage.listLatestBySyncIds({ projectId: runtime.projectId, syncIds: allowedIds });
       }
     }
-  }
-  return tokens;
-}
-function serializeSummaryPart(message, part, partIndex) {
-  const indent = "    ";
-  switch (part.type) {
-    case "text":
-      return [`${indent}<text>${escapeXml2(part.text)}</text>`];
-    case "reasoning":
-    case "step-start":
-      return [];
-    case "context":
-      return part.context.kind === "object" ? [
-        `${indent}<object_context origin="${part.origin}" object_type_id="${escapeXml2(part.context.ref.objectTypeId)}" primary_id="${escapeXml2(part.context.ref.primaryId)}" />`
-      ] : [
-        `${indent}<app_context origin="${part.origin}" id="${escapeXml2(part.context.id)}" label="${escapeXml2(part.context.label)}">`,
-        `${indent}  <description>${escapeXml2(part.context.description)}</description>`,
-        `${indent}  <value format="json">${escapeXml2(stableJsonStringify(part.context.value))}</value>`,
-        `${indent}</app_context>`
-      ];
-    case "file": {
-      const file = part.fileRef;
-      const attributes = [
-        `message_id="${escapeXml2(message.id)}"`,
-        `part_index="${partIndex}"`,
-        `blob_id="${escapeXml2(file.blobId)}"`,
-        `digest="${escapeXml2(file.digest)}"`,
-        `size_bytes="${file.sizeBytes}"`,
-        ...file.fileName === undefined ? [] : [`file_name="${escapeXml2(file.fileName)}"`],
-        ...file.mediaType === undefined ? [] : [`media_type="${escapeXml2(file.mediaType)}"`],
-        ...file.logicalPath === undefined ? [] : [`logical_path="${escapeXml2(file.logicalPath)}"`]
-      ];
-      return [`${indent}<file ${attributes.join(" ")} />`];
-    }
-    case "tool-call": {
-      const output = part.state === "output-available" ? truncateToolResult(stableJsonStringify(part.output)) : truncateToolResult(part.errorText);
-      return [
-        `${indent}<tool_call id="${escapeXml2(part.toolCallId)}" name="${escapeXml2(part.toolName)}" state="${part.state}">`,
-        `${indent}  <input format="json">${escapeXml2(stableJsonStringify(part.input))}</input>`,
-        `${indent}  <result>${escapeXml2(output)}</result>`,
-        `${indent}</tool_call>`
-      ];
-    }
-  }
-}
-function truncateToolResult(value) {
-  if (value.length <= TOOL_RESULT_SUMMARY_MAX_CHARS)
-    return value;
-  return `${value.slice(0, TOOL_RESULT_SUMMARY_MAX_CHARS)}
-[truncated ${value.length - TOOL_RESULT_SUMMARY_MAX_CHARS} characters]`;
-}
-function looksLikeImage(mediaType, fileName) {
-  if (mediaType?.toLowerCase().startsWith("image/"))
-    return true;
-  return /\.(?:avif|gif|jpe?g|png|webp)$/i.test(fileName ?? "");
-}
-function textTokens(value) {
-  return Math.ceil(new TextEncoder().encode(value).byteLength / CHARS_PER_TOKEN);
-}
-function escapeXml2(value) {
-  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
-}
-// src/agents/thread-context-projection.ts
-function projectAgentThreadModelContext(input) {
-  const { checkpoint, messages } = input;
-  if (!checkpoint)
-    return messages;
-  assertConsistentCheckpointProjection(checkpoint, messages);
-  return [
-    {
-      role: "user",
-      parts: [{ type: "text", text: serializeThreadSummary(checkpoint.summary) }]
-    },
-    ...messages
-  ];
-}
-function assertConsistentCheckpointProjection(checkpoint, messages) {
-  if (checkpoint.summaryFormatVersion !== 1 || checkpoint.summary.trim().length === 0) {
-    throw projectionError(checkpoint, "has an invalid summary");
-  }
-  if (checkpoint.summarizedThroughSeq >= checkpoint.observedHeadSeq) {
-    throw projectionError(checkpoint, "does not retain its observed head");
-  }
-  if (messages.length === 0) {
-    throw projectionError(checkpoint, "has no retained messages");
-  }
-  let expectedSeq = checkpoint.summarizedThroughSeq + 1;
-  for (const message of messages) {
-    if (message.projectId !== checkpoint.projectId || message.threadId !== checkpoint.threadId) {
-      throw projectionError(checkpoint, "contains a message from another thread");
-    }
-    if (message.seq !== expectedSeq) {
-      throw projectionError(checkpoint, `has a sequence gap before message '${message.id}'`);
-    }
-    expectedSeq += 1;
-  }
-  if (messages[0]?.role !== "user") {
-    throw projectionError(checkpoint, "does not begin at a user turn boundary");
-  }
-  if ((messages.at(-1)?.seq ?? 0) < checkpoint.observedHeadSeq) {
-    throw projectionError(checkpoint, "ends before the checkpoint's observed head");
-  }
-}
-function serializeThreadSummary(summary) {
-  return [
-    "The earlier conversation was compacted into this continuation summary.",
-    "",
-    "<sixb_thread_summary>",
-    escapeXml3(summary),
-    "</sixb_thread_summary>"
-  ].join(`
-`);
+  };
 }
-function projectionError(checkpoint, detail) {
-  return new Error(`[Sixb] Agent context checkpoint '${checkpoint.id}' for thread '${checkpoint.threadId}' ${detail}.`);
+
+// src/workflows/errors.ts
+class WorkflowDefinitionError extends Error {
+  name = "WorkflowDefinitionError";
 }
-function escapeXml3(value) {
-  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+
+class WorkflowValidationError extends Error {
+  name = "WorkflowValidationError";
+  cause;
+  constructor(message, options) {
+    super(message);
+    this.cause = options?.cause;
+  }
 }
+
+// src/workflows/run-dispatch.ts
+import { randomUUID as randomUUID5 } from "crypto";
+import { isDeepStrictEqual } from "util";
+
 // src/workflows/validation.ts
-function assertNonEmpty2(value, subject, field) {
+function assertNonEmpty(value, subject, field) {
   if (!value.trim()) {
     throw new WorkflowDefinitionError(`${subject} ${field} must not be empty.`);
   }
 }
 function isStepDefinition(value) {
-  return isRecord2(value) && value.kind === "step" && typeof value.id === "string" && isRecord2(value.input) && isRecord2(value.output) && typeof value.handler === "function";
+  return isRecord(value) && value.kind === "step" && typeof value.id === "string" && isRecord(value.input) && isRecord(value.output) && typeof value.handler === "function";
 }
 function isAgentStepDefinition(value) {
-  return isRecord2(value) && value.kind === "agentStep" && typeof value.id === "string" && isAgentDefinition(value.agent) && isRecord2(value.input) && isRecord2(value.output) && typeof value.prompt === "function";
+  return isRecord(value) && value.kind === "agentStep" && typeof value.id === "string" && (value.model === undefined || isLanguageModel(value.model)) && (value.reasoning === undefined || isModelReasoning(value.reasoning)) && typeof value.instructions === "string" && isStringArray(value.groupIds) && isStringArray(value.toolNames) && isRecord(value.input) && isRecord(value.output) && typeof value.prompt === "function";
 }
 function isInterventionDefinition(value) {
-  return isRecord2(value) && value.kind === "intervention" && typeof value.id === "string" && isRecord2(value.input) && isRecord2(value.response) && (value.defaults === undefined || typeof value.defaults === "function");
+  return isRecord(value) && value.kind === "intervention" && typeof value.id === "string" && isRecord(value.input) && isRecord(value.response) && (value.defaults === undefined || typeof value.defaults === "function");
 }
 function isWorkflowDefinition(value) {
-  return isRecord2(value) && value.kind === "workflow" && typeof value.id === "string" && isRecord2(value.input) && Array.isArray(value.triggers) && Array.isArray(value.nodes);
+  return isRecord(value) && value.kind === "workflow" && typeof value.id === "string" && isRecord(value.input) && Array.isArray(value.triggers) && Array.isArray(value.nodes);
 }
 function validateWorkflowDefinition(value) {
   if (!isWorkflowDefinition(value)) {
     throw new WorkflowDefinitionError("Invalid workflow definition.");
   }
-  assertNonEmpty2(value.id, "Workflow", "id");
+  assertNonEmpty(value.id, "Workflow", "id");
   if (value.nodes.length === 0) {
     throw new WorkflowDefinitionError(`Workflow "${value.id}" must contain at least one node.`);
   }
@@ -2219,13 +1874,42 @@ function validateWorkflowsAtStartup(options) {
       if (node.type === "action" && !options.registeredActionIds.has(node.action.id)) {
         throw new WorkflowDefinitionError(`Workflow "${workflow.id}" references unknown action "${node.action.id}". Add it to 'actions' in createSixb() or export it from 'actions/'.`);
       }
-      if (node.type === "agent" && !options.registeredAgentIds.has(node.agentStep.agent.id)) {
-        throw new WorkflowDefinitionError(`Workflow "${workflow.id}" references unknown agent "${node.agentStep.agent.id}". Add it to 'agents' in createSixb() or export it from 'agents/'.`);
+      if (node.type === "agent") {
+        validateWorkflowAgentStepRuntimeReferences(workflow.id, node.agentStep, options);
       }
     }
   }
   return options.workflows;
 }
+function validateWorkflowAgentStepGroupReferences(workflows, security) {
+  for (const workflow of workflows) {
+    for (const node of workflow.nodes) {
+      if (node.type !== "agent")
+        continue;
+      for (const groupId of node.agentStep.groupIds) {
+        if (!security.getGroupById(groupId)) {
+          throw new WorkflowDefinitionError(`Workflow "${workflow.id}" agent step "${node.id}" references unknown group "${groupId}". Add it to 'security/groups/' or pass it to createSixb({ groups }).`);
+        }
+      }
+    }
+  }
+}
+function validateWorkflowAgentStepRuntimeReferences(workflowId, step, options) {
+  if (step.model === undefined && options.models === undefined) {
+    throw new WorkflowDefinitionError(`Workflow "${workflowId}" agent step "${step.id}" needs a model. Configure 'models.language' or pass 'model' to defineAgentStep().`);
+  }
+  if (step.model !== undefined && options.models !== undefined) {
+    const ref = { provider: step.model.providerId, modelId: step.model.modelId };
+    if (options.models.language.getByRef(ref) === null) {
+      throw new WorkflowDefinitionError(`Workflow "${workflowId}" agent step "${step.id}" uses unknown language model "${ref.provider}/${ref.modelId}". Add it to 'models.language' in createSixb().`);
+    }
+  }
+  for (const toolName of step.toolNames) {
+    if (options.tools.getByName(toolName) === null) {
+      throw new WorkflowDefinitionError(`Workflow "${workflowId}" agent step "${step.id}" uses unknown project tool "${toolName}". Add it to 'tools' in createSixb().`);
+    }
+  }
+}
 function validateWorkflowInput(params) {
   return validateWorkflowContractRecord({
     shape: params.workflow.input,
@@ -2277,7 +1961,7 @@ function validateWorkflowInterventionDefaultResponse(params) {
   });
 }
 function validateWorkflowTriggerAtStartup(workflowId, trigger, registeredSchedules, inputFields) {
-  if (!isRecord2(trigger) || trigger.type !== "schedule") {
+  if (!isRecord(trigger) || trigger.type !== "schedule") {
     throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains an unsupported trigger.`);
   }
   validateScheduleWorkflowTrigger(workflowId, trigger, registeredSchedules, inputFields);
@@ -2301,7 +1985,7 @@ function validateScheduleWorkflowTrigger(workflowId, trigger, registeredSchedule
   }
 }
 function validateWorkflowNodeDefinition(workflowId, node) {
-  if (!isRecord2(node)) {
+  if (!isRecord(node)) {
     throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains an invalid node.`);
   }
   if (node.type === "step") {
@@ -2335,10 +2019,39 @@ function validateAgentNodeDefinition(workflowId, node) {
   if (node.id !== node.agentStep.id) {
     throw new WorkflowDefinitionError(`Workflow "${workflowId}" agent node id "${node.id}" does not match agent step definition id "${node.agentStep.id}".`);
   }
+  if (!node.agentStep.instructions.trim()) {
+    throw new WorkflowDefinitionError(`Workflow "${workflowId}" agent step "${node.id}" instructions must not be empty.`);
+  }
+  assertUniqueNonEmptyAgentStepValues(workflowId, node.id, "group", node.agentStep.groupIds);
+  assertUniqueNonEmptyAgentStepValues(workflowId, node.id, "tool", node.agentStep.toolNames);
   if (node.mapper !== undefined && typeof node.mapper !== "function") {
     throw new WorkflowDefinitionError(`Workflow "${workflowId}" agent node "${node.id}" mapper must be a function.`);
   }
 }
+function assertUniqueNonEmptyAgentStepValues(workflowId, stepId, kind, values) {
+  const seen = new Set;
+  for (const value of values) {
+    if (!value.trim()) {
+      throw new WorkflowDefinitionError(`Workflow "${workflowId}" agent step "${stepId}" has an empty ${kind} id.`);
+    }
+    if (seen.has(value)) {
+      throw new WorkflowDefinitionError(`Workflow "${workflowId}" agent step "${stepId}" has duplicate ${kind} '${value}'.`);
+    }
+    seen.add(value);
+  }
+}
+function isLanguageModel(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null;
+}
+function isStringArray(value) {
+  if (!Array.isArray(value))
+    return false;
+  for (let index = 0;index < value.length; index += 1) {
+    if (!Object.hasOwn(value, index) || typeof value[index] !== "string")
+      return false;
+  }
+  return true;
+}
 function validateWorkflowAgentStepInput(params) {
   return validateWorkflowContractRecord({
     shape: params.agentStep.input,
@@ -2407,7 +2120,7 @@ function validateActionNodeDefinition(workflowId, node) {
   }
 }
 function validateWorkflowContractRecord(params) {
-  if (!isRecord2(params.value)) {
+  if (!isRecord(params.value)) {
     throw new WorkflowValidationError(`[Sixb] ${params.path} must be an object`);
   }
   const fieldIds = new Set(Object.keys(params.shape));
@@ -2430,7 +2143,7 @@ function validateWorkflowContractRecord(params) {
   return params.value;
 }
 function validateWorkflowInterventionResponseRecord(params) {
-  if (!isRecord2(params.value)) {
+  if (!isRecord(params.value)) {
     throw new WorkflowValidationError(`[Sixb] ${params.path} must be an object`);
   }
   const fieldIds = new Set(Object.keys(params.response));
@@ -2456,7 +2169,7 @@ function validateWorkflowInterventionResponseRecord(params) {
   return params.value;
 }
 function isInterventionFieldConfig(value) {
-  return isRecord2(value) && "schema" in value;
+  return isRecord(value) && "schema" in value;
 }
 function interventionResponseFieldSchema(field) {
   return isInterventionFieldConfig(field) ? field.schema : field;
@@ -2473,7 +2186,7 @@ function toWorkflowValidationError(error) {
   }
   return new WorkflowValidationError(String(error), { cause: error });
 }
-function isRecord2(value) {
+function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -2588,7 +2301,7 @@ function snapshotWorkflowInterventionResponseRecord(params) {
 }
 function snapshotSchemaOrRefValue(params) {
   if (isObjectRefSchema(params.schema)) {
-    if (!isRecord3(params.value)) {
+    if (!isRecord2(params.value)) {
       throw cannotSerialize(params.path);
     }
     return {
@@ -2629,7 +2342,7 @@ function snapshotSchemaValue(params) {
     }));
   }
   if (schema.type === "map") {
-    if (!isRecord3(value)) {
+    if (!isRecord2(value)) {
       throw cannotSerialize(path);
     }
     const snapshot = {};
@@ -2644,7 +2357,7 @@ function snapshotSchemaValue(params) {
     return snapshot;
   }
   if (schema.type === "object") {
-    if (!isRecord3(value)) {
+    if (!isRecord2(value)) {
       throw cannotSerialize(path);
     }
     const snapshot = {};
@@ -2714,7 +2427,7 @@ function snapshotDate(value, path) {
 function cannotSerialize(path) {
   return new WorkflowValidationError(`[Sixb] ${path} cannot be serialized as workflow IO`);
 }
-function isRecord3(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -2797,7 +2510,7 @@ async function persistWorkflowRun(input, request) {
     assertExistingWorkflowRun(existing, input.workflow.id, request.snapshot);
     return { run: existing, created: false };
   }
-  const execution = await input.createExecution(`exec_${randomUUID3()}`, request.runId);
+  const execution = await input.createExecution(`exec_${randomUUID5()}`, request.runId);
   const queuedAt = new Date;
   try {
     return await input.storage.transaction(async (tx) => {
@@ -2904,7 +2617,7 @@ async function failWorkflowRunPublication(input, run, error) {
 }
 function resolveWorkflowRunId(runId) {
   if (runId === undefined)
-    return `run_${randomUUID3()}`;
+    return `run_${randomUUID5()}`;
   if (!runId.trim()) {
     throw new WorkflowValidationError("[Sixb] Workflow run id must not be empty");
   }
@@ -2950,6 +2663,10 @@ function assertNonBlank(value, label) {
 
 // src/workflows/request.ts
 async function requestWorkflowRun(runtime, execution, workflow, options = {}) {
+  resolveExecutionScopeAuthorization(runtime.projectId, {
+    execution,
+    authorization: runtime.runtimeAuthorization
+  });
   assertAuthorized(runtime, { kind: "workflow.run", workflowId: workflow.id });
   const requesterGroupIds = execution.requestedBy ? await snapshotRequesterGroupIds({
     auth: runtime.storage.auth,
@@ -2984,15 +2701,31 @@ async function requestWorkflowRun(runtime, execution, workflow, options = {}) {
 
 // src/workflows/execution.ts
 function createWorkflowsRuntime(runtime, execution, source) {
-  const allowed = (workflowId) => isAllowed(runtime.authorization, { kind: "workflow.run", workflowId });
-  const canAccessHistory = (workflowId) => allowed(workflowId) && (!runtime.authorization || source.getById(workflowId) !== null);
+  const authority = resolveRuntimeAuthorizationForProject(runtime);
+  const allowed = (workflowId) => isRuntimeAllowed(runtime, { kind: "workflow.run", workflowId });
+  const canAccessHistory = (workflowId) => {
+    switch (authority.type) {
+      case "denied":
+      case "delegated":
+        return false;
+      case "unrestricted":
+        return true;
+      case "principal":
+        return allowed(workflowId) && source.getById(workflowId) !== null;
+    }
+  };
   const visibleIds = () => source.list().filter((workflow) => allowed(workflow.id)).map((workflow) => workflow.id);
+  const historyFilterIds = () => authority.type === "unrestricted" ? undefined : authority.type === "principal" ? visibleIds() : [];
   const getVisibleRunRecord = async (runId) => {
+    if (authority.type === "denied" || authority.type === "delegated")
+      return null;
     const run = await runtime.storage.workflowRuns?.getById({
       projectId: runtime.projectId,
       id: runId
     }) ?? null;
-    return run && canViewWorkflowRun(runtime.authorization, run) && canAccessHistory(run.workflowId) ? run : null;
+    if (!run || !canAccessHistory(run.workflowId))
+      return null;
+    return authority.type === "unrestricted" || canViewWorkflowRun(authority.context, run) ? run : null;
   };
   const getRun = async (runId) => {
     const run = await getVisibleRunRecord(runId);
@@ -3003,9 +2736,9 @@ function createWorkflowsRuntime(runtime, execution, source) {
     if (!storage || !await getVisibleRunRecord(runId))
       return null;
     const result = await storage.nodes.list({
-      projectId: runtime.projectId,
       ...input,
-      workflowRunId: runId
+      workflowRunId: runId,
+      projectId: runtime.projectId
     });
     return {
       ...result,
@@ -3013,13 +2746,16 @@ function createWorkflowsRuntime(runtime, execution, source) {
     };
   };
   return {
-    list: () => source.list().filter((workflow) => allowed(workflow.id)),
+    list: () => authority.type === "denied" || authority.type === "delegated" ? [] : source.list().filter((workflow) => allowed(workflow.id)),
     getById: (workflowId) => {
+      if (authority.type === "denied" || authority.type === "delegated")
+        return null;
       const workflow = source.getById(workflowId);
       return workflow && allowed(workflowId) ? workflow : null;
     },
     request: (workflow, options) => requestWorkflowRun(runtime, execution, workflow, options),
     requestById: async (input) => {
+      assertAuthorized(runtime, { kind: "workflow.run", workflowId: input.workflowId });
       const workflow = source.getById(input.workflowId);
       if (!workflow) {
         throw new WorkflowValidationError(`[Sixb] Unknown workflow '${input.workflowId}'`);
@@ -3029,13 +2765,16 @@ function createWorkflowsRuntime(runtime, execution, source) {
     runs: {
       getById: getRun,
       list: async (input = {}) => {
+        if (authority.type === "denied" || authority.type === "delegated") {
+          return { runs: [], hasMore: false, total: 0 };
+        }
         const storage = runtime.storage.workflowRuns;
         if (!storage)
           return { runs: [], hasMore: false, total: 0 };
         const result = await storage.list({
-          projectId: runtime.projectId,
           ...input,
-          workflowIds: runtime.authorization ? visibleIds() : undefined
+          workflowIds: historyFilterIds(),
+          projectId: runtime.projectId
         });
         return {
           ...result,
@@ -3043,6 +2782,9 @@ function createWorkflowsRuntime(runtime, execution, source) {
         };
       },
       listLatest: async (workflowIds) => {
+        if (authority.type === "denied" || authority.type === "delegated") {
+          return { runs: [] };
+        }
         const storage = runtime.storage.workflowRuns;
         if (!storage || workflowIds.length === 0)
           return { runs: [] };
@@ -3061,20 +2803,27 @@ function createWorkflowsRuntime(runtime, execution, source) {
     },
     interventions: {
       getById: async (interventionId) => {
+        if (authority.type === "denied" || authority.type === "delegated")
+          return null;
         const intervention = await runtime.storage.workflowInterventions?.getById({
           projectId: runtime.projectId,
           id: interventionId
         }) ?? null;
-        return intervention && canViewWorkflowIntervention(runtime.authorization, intervention) && canAccessHistory(intervention.workflowId) ? intervention : null;
+        if (!intervention || !canAccessHistory(intervention.workflowId))
+          return null;
+        return authority.type === "unrestricted" || canViewWorkflowIntervention(authority.context, intervention) ? intervention : null;
       },
       list: (input = {}) => {
+        if (authority.type === "denied" || authority.type === "delegated") {
+          return Promise.resolve({ interventions: [], hasMore: false, total: 0 });
+        }
         const storage = runtime.storage.workflowInterventions;
         if (!storage)
           return Promise.resolve({ interventions: [], hasMore: false, total: 0 });
         return storage.list({
-          projectId: runtime.projectId,
           ...input,
-          workflowIds: runtime.authorization ? visibleIds() : undefined
+          workflowIds: historyFilterIds(),
+          projectId: runtime.projectId
         });
       }
     }
@@ -3121,7 +2870,6 @@ function toWorkflowAgentNodeRunView(execution, usage, cost) {
     projectId: execution.projectId,
     nodeRunId: execution.nodeRunId,
     executionId: execution.executionId,
-    agentId: execution.agentId,
     status: execution.status,
     prompt: execution.prompt,
     modelId: execution.modelId,
@@ -3154,6 +2902,14 @@ async function attachRequestedBy(runtime, run) {
 // src/runtime/sixb.ts
 var boundSixbInstances = new WeakSet;
 function createBoundSixb(runtime, dependencies, execution) {
+  resolveExecutionScopeAuthorization(runtime.projectId, {
+    execution,
+    authorization: runtime.runtimeAuthorization
+  });
+  assertAuthorizedObjectReaderBinding({
+    reader: runtime.objectReader,
+    scope: { execution, authorization: runtime.runtimeAuthorization }
+  });
   const sixb = {
     execution,
     ...createExecutionFacades(runtime, execution, dependencies)
@@ -3172,24 +2928,29 @@ function createExecutionFacades(runtime, execution, dependencies) {
   return {
     objects: createObjectsRuntime(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)
   };
 }
-
 // src/execution/agent.ts
+function canInheritAgentRequestAuthorization(authorization) {
+  const ref = getAuthorizationRef(authorization);
+  return ref.type === "disabled" || ref.type === "principal" && ref.principal.type === "user" && ref.credential !== undefined;
+}
 function createAgentExecutionRecord(input) {
-  assertAgentPrincipal(input.agentId, input.principal);
+  assertAgentPrincipal(input.actorId, input.principal);
   return {
     id: input.id,
     projectId: input.parent.projectId,
@@ -3203,6 +2964,21 @@ function createAgentExecutionRecord(input) {
     }
   };
 }
+function createInheritedAgentExecutionRecord(input) {
+  const authority = input.parent.authorizationRef;
+  if (authority.type !== "disabled" && !(authority.type === "principal" && authority.principal.type === "user" && authority.credential !== undefined)) {
+    throw new ExecutionStorageError("invalid_input", `[Sixb] Agent run '${input.runId}' requires inheritable user or auth-disabled authority.`);
+  }
+  return {
+    id: input.id,
+    projectId: input.parent.projectId,
+    ...input.parent.requestedBy === undefined ? {} : { requestedBy: structuredClone(input.parent.requestedBy) },
+    executor: { type: "agent", runId: input.runId },
+    source: { type: "execution", executionId: input.parent.id },
+    correlationId: input.parent.correlationId,
+    authorizationRef: structuredClone(authority)
+  };
+}
 function bindDurableAgentExecution(host, input) {
   const scope = restoreAgentExecutionScope(input);
   const sixb = host.withScope(scope);
@@ -3217,38 +2993,65 @@ function restoreAgentExecutionScope(input) {
     id: input.execution.id,
     projectId: input.execution.projectId,
     ...input.execution.requestedBy === undefined ? {} : { requestedBy: Object.freeze(structuredClone(input.execution.requestedBy)) },
-    executor: Object.freeze({ type: "agent", agentId: input.agentId, runId: input.runId }),
+    executor: Object.freeze({
+      type: "agent",
+      ...input.actorId === undefined ? {} : { actorId: input.actorId },
+      runId: input.runId
+    }),
     source: Object.freeze(structuredClone(input.execution.source)),
     correlationId: input.execution.correlationId
   });
   return Object.freeze({
     execution: context,
     authorization: createAgentRuntimeAuthorization({
-      projectId: input.execution.projectId,
-      context: input.authorization,
-      executionId: input.execution.id,
-      agentId: input.agentId,
-      runId: input.runId
+      execution: context,
+      authority: input.authorization.type === "principal" ? {
+        type: "principal",
+        context: input.authorization.context,
+        ...input.execution.authorizationRef.type === "principal" && input.execution.authorizationRef.credential !== undefined ? { credential: input.execution.authorizationRef.credential } : {}
+      } : { type: "disabled" }
     })
   });
 }
 function assertAgentExecutionRecord(input) {
   const authority = input.execution.authorizationRef;
-  if (input.execution.executor.type !== "agent" || input.execution.executor.runId !== input.runId || input.execution.source.type !== "execution" || authority.type !== "principal" || authority.principal.type !== "serviceAccount" || input.authorization.principal.type !== "serviceAccount" || authority.principal.id !== input.authorization.principal.id || authority.credential !== undefined) {
+  if (input.execution.executor.type !== "agent" || input.execution.executor.runId !== input.runId || input.execution.source.type !== "execution") {
+    invalidAgentExecution(input.execution.id, input.runId);
+  }
+  if (input.authorization.type === "disabled" || input.authorization.context.principal.type === "user") {
+    assertInheritedAgentAuthority(input.execution, input.runId, input.authorization);
+    return;
+  }
+  if (input.authorization.type !== "principal" || authority.type !== "principal" || authority.principal.type !== "serviceAccount" || input.authorization.context.principal.type !== "serviceAccount" || authority.principal.id !== input.authorization.context.principal.id || authority.credential !== undefined) {
+    invalidAgentExecution(input.execution.id, input.runId);
+  }
+  if (input.actorId === undefined) {
     invalidAgentExecution(input.execution.id, input.runId);
   }
-  assertAgentPrincipal(input.agentId, authority.principal);
+  assertAgentPrincipal(input.actorId, authority.principal);
+}
+function assertInheritedAgentAuthority(execution, runId, authorization) {
+  const authority = execution.authorizationRef;
+  if (authorization.type === "disabled") {
+    if (authority.type !== "disabled")
+      invalidAgentExecution(execution.id, runId);
+    return;
+  }
+  const principal = authorization.context.principal;
+  if (authority.type !== "principal" || authority.principal.type !== "user" || principal.type !== "user" || authority.principal.id !== principal.id || authority.credential === undefined || (authority.credential.type === "session" ? authorization.context.sessionId !== authority.credential.id : authorization.context.sessionId !== undefined)) {
+    invalidAgentExecution(execution.id, runId);
+  }
 }
-function assertAgentPrincipal(agentId, principal) {
-  const expectedId = agentServiceAccountId(agentId);
+function assertAgentPrincipal(actorId, principal) {
+  const expectedId = agentServiceAccountId(actorId);
   if (principal.id !== expectedId) {
-    throw new ExecutionStorageError("invalid_input", `[Sixb] Agent '${agentId}' execution authority must reference service account '${expectedId}'.`);
+    throw new ExecutionStorageError("invalid_input", `[Sixb] Agent '${actorId}' execution authority must reference service account '${expectedId}'.`);
   }
 }
 function invalidAgentExecution(executionId, runId) {
   throw new ExecutionStorageError("invalid_input", `[Sixb] Execution '${executionId}' does not authorize Agent run '${runId}'.`);
 }
 
-export { serializeAgentContextForModel, isAgentToolResult, omitUndefinedObjectProperties, fromAiSdk, toUiMessage, toModelMessages, AGENT_API_GATEWAY_PREFIX, AGENT_API_ROUTES, createAgentApiGatewayCapability, isValidAgentApiGatewayCapability, isAllowedAgentApiRequest, AGENT_REASONING_LEVELS, AGENT_RESERVED_TOOL_NAMES, isAgentDefinition, isAgentToolDefinition, validateAndNormalizeAgentToolInput, validateAgentToolsAtStartup, validateAgentGroupReferences, defineAgentTool, defineAgent, AGENT_CONTEXT_ESTIMATOR_VERSION, shouldCompactAgentContext, estimateAgentContextRequestTokens, estimateAgentContextMessagesTokens, selectAgentContextCompactionBoundary, serializeAgentMessagesForSummary, resolveAgentContextParts, agentRunQueueJobId, workflowAgentNodeQueueJobId, dispatchQueuedAgentRuns, createAgentThreadId, createAgentRunId, createAgentMessageId, agentContextCheckpointId, createAgentRunExecutionToken, WorkflowDefinitionError, WorkflowValidationError, assertNonEmpty2 as assertNonEmpty, isStepDefinition, isAgentStepDefinition, isInterventionDefinition, isWorkflowDefinition, validateWorkflowDefinition, validateWorkflowsAtStartup, validateWorkflowInput, validateWorkflowStepInput, validateWorkflowStepOutput, validateWorkflowInterventionInput, validateWorkflowInterventionResponse, validateWorkflowInterventionDefaultResponse, validateWorkflowAgentStepInput, validateWorkflowAgentStepOutput, snapshotWorkflowAgentStepInput, snapshotWorkflowAgentStepOutput, snapshotWorkflowInput, snapshotWorkflowStepInput, snapshotWorkflowStepOutput, snapshotWorkflowInterventionInput, snapshotWorkflowInterventionResponse, snapshotWorkflowInterventionDefaultResponse, snapshotWorkflowActionInput, WorkflowRunDispatcher, requestWorkflowRun, createBoundSixb, isBoundSixb, createAgentExecutionRecord, bindDurableAgentExecution, restoreAgentExecutionScope, assertAgentExecutionRecord, requestAgentRun, retryAgentRun, projectAgentThreadModelContext };
+export { resolveAgentContextParts, agentRunQueueJobId, subagentRunQueueJobId, workflowAgentNodeQueueJobId, dispatchQueuedAgentRuns, dispatchQueuedSubagentRuns, createAgentThreadId, createAgentRunId, createSubagentRunId, createSubagentExecutionId, createAgentMessageId, agentContextCheckpointId, createAgentRunExecutionToken, assertNoAgentDefinitions, ShareError, WorkflowDefinitionError, WorkflowValidationError, assertNonEmpty, isStepDefinition, isAgentStepDefinition, isInterventionDefinition, isWorkflowDefinition, validateWorkflowDefinition, validateWorkflowsAtStartup, validateWorkflowAgentStepGroupReferences, validateWorkflowInput, validateWorkflowStepInput, validateWorkflowStepOutput, validateWorkflowInterventionInput, validateWorkflowInterventionResponse, validateWorkflowInterventionDefaultResponse, validateWorkflowAgentStepInput, validateWorkflowAgentStepOutput, snapshotWorkflowAgentStepInput, snapshotWorkflowAgentStepOutput, snapshotWorkflowInput, snapshotWorkflowStepInput, snapshotWorkflowStepOutput, snapshotWorkflowInterventionInput, snapshotWorkflowInterventionResponse, snapshotWorkflowInterventionDefaultResponse, snapshotWorkflowActionInput, WorkflowRunDispatcher, requestWorkflowRun, createBoundSixb, isBoundSixb, canInheritAgentRequestAuthorization, createAgentExecutionRecord, createInheritedAgentExecutionRecord, bindDurableAgentExecution, restoreAgentExecutionScope, assertAgentExecutionRecord, requestAgentRun, retryAgentRun };
 
-//# debugId=E5777634D231818464756E2164756E21
+//# debugId=3C841C41C07F660564756E2164756E21