@sixb/core 0.1.17 → 0.1.19

package/dist/{chunk-dam456ve.js → chunk-aff7cyea.js}

@@ -1,24 +1,26 @@
 // @bun
 import {
-  OntologyRegistry2
-} from "./chunk-xyvy73tj.js";
+  supportsDirectUpload2
+} from "./chunk-jhm3zsa7.js";
 import {
-  ProjectionRegistry2,
-  createOntologyMaterializer2
-} from "./chunk-fggq3d9k.js";
+  SecurityValidationError2
+} from "./chunk-xt1zt7gv.js";
+import {
+  OntologyRegistry2
+} from "./chunk-bpgy64fw.js";
 import {
   captureSixbFailure2,
   isSixbError2
-} from "./chunk-6fsr7y93.js";
-import {
-  SecurityRegistry,
-  AuthRuntime2
-} from "./chunk-svabwqdq.js";
+} from "./chunk-8mx7qw3y.js";
 import {
   captureExecutionScope,
   resolveExecutionScopeAuthorization,
   AuthorizationError2
-} from "./chunk-5be2ath4.js";
+} from "./chunk-y7rqfrgg.js";
+import {
+  SecurityRegistry,
+  AuthRuntime2
+} from "./chunk-3gnrh4ve.js";
 import {
   AuthRuntimeError2,
   isMagicLinkAuthStrategy2,
@@ -31,37 +33,40 @@ import {
   RerankingModelResponseError2,
   createModelCatalog2,
   estimateModelCall
-} from "./chunk-s7ftxrdr.js";
+} from "./chunk-29yx306f.js";
 import {
   FileUploadSessionError2
-} from "./chunk-33saed7g.js";
+} from "./chunk-7kg3k1m9.js";
 import {
   isMigrationCapableStorage2,
   checkStorageSchema2
-} from "./chunk-5yd8cchh.js";
+} from "./chunk-j2bp5ryw.js";
 import {
-  createAuthorizedObjectReader
-} from "./chunk-10styjgk.js";
+  ActionRegistry2,
+  createAuthorizedObjectReader,
+  DEFAULT_PROJECT_LOCALE,
+  DEFAULT_PROJECT_TIME_ZONE,
+  canonicalLocale,
+  canonicalTimeZone,
+  assertNoAgentDefinitions,
+  validateWorkflowsAtStartup2,
+  validateWorkflowAgentStepGroupReferences2,
+  createBoundSixb,
+  ActionRunExecutor,
+  registerActionRunExecutor
+} from "./chunk-ey3pyej1.js";
 import {
   attachSixbErrorReporter2,
   shareSixbErrorReporter2
-} from "./chunk-vjcd8d27.js";
-import {
-  ActionRegistry2
-} from "./chunk-9g6jz9kk.js";
-import {
-  assertDatasetDefinition2
-} from "./chunk-cd234ba4.js";
-import {
-  OntologyOutboxDispatcher2,
-  createDomainEventService2
-} from "./chunk-70jmg2zx.js";
+} from "./chunk-fa02jy15.js";
 import {
-  validateSchedulesAtStartup2
-} from "./chunk-e1c18xjx.js";
+  registerOntologyMutationRuntime2,
+  createOntologyMutationRuntime2,
+  ModelExecutionSession
+} from "./chunk-wwdfe68s.js";
 import {
-  createSandboxDefinition
-} from "./chunk-2am3db31.js";
+  registerConnectorConnectionCallbackProcess
+} from "./chunk-5a4a52tq.js";
 import {
   ConnectorError2,
   ConnectorNotFoundError2,
@@ -73,56 +78,57 @@ import {
   isConnectorStorageError,
   storageBoundaryError,
   recoverConnectorFailure
-} from "./chunk-jnfxmr3f.js";
+} from "./chunk-wz0xs816.js";
 import {
-  toolsFromProjectConfig
-} from "./chunk-cnb5kv05.js";
+  assertDatasetDefinition2
+} from "./chunk-rz53yb4v.js";
 import {
-  assertNoAgentDefinitions,
-  validateWorkflowsAtStartup2,
-  validateWorkflowAgentStepGroupReferences2,
-  createBoundSixb
-} from "./chunk-6wbm6ymz.js";
+  ProjectionRegistry2,
+  createOntologyMaterializer2
+} from "./chunk-zrmy8zvw.js";
 import {
-  registerConnectorConnectionCallbackProcess
-} from "./chunk-5a4a52tq.js";
+  LoggingService2
+} from "./chunk-3qms4nax.js";
 import {
-  registerOntologyMutationRuntime2,
-  createOntologyMutationRuntime2
-} from "./chunk-85cd7e8c.js";
+  OntologyOutboxDispatcher2,
+  createDomainEventService2
+} from "./chunk-yzwja0mj.js";
+import {
+  validateSchedulesAtStartup2
+} from "./chunk-nq6gpjt7.js";
+import {
+  createSandboxDefinition
+} from "./chunk-9gyp8hg1.js";
+import {
+  toolsFromProjectConfig
+} from "./chunk-tpn40322.js";
 import {
   SchedulerRuntime2
-} from "./chunk-z5rnrmz1.js";
+} from "./chunk-yw9pyg66.js";
 import {
+  discoverOntologyFiles,
+  discoverAgentSkills,
+  discoverProjectInstructions,
   validateRulesAtStartup,
   validateSharesAtStartup,
-  discoverOntologySources2,
+  discoverOntologySources,
   discoverProjectDefinitions2
-} from "./chunk-xcy5ddha.js";
-import {
-  LoggingService2
-} from "./chunk-3qms4nax.js";
+} from "./chunk-80mc0971.js";
 import {
   bindEmbeddingModels,
   createVectorIndexingRuntime,
   registerVectorIndexingRuntime,
   getApiPublicOrigin
-} from "./chunk-vp3z1ckh.js";
+} from "./chunk-kyzq4wy9.js";
 import {
   registerProjectionRegistry2
-} from "./chunk-f1xh7a32.js";
+} from "./chunk-q1vkr2ys.js";
 import {
   SyncValidationError2
-} from "./chunk-k4g51s47.js";
-import {
-  ModelExecutionSession
-} from "./chunk-52c5zb0z.js";
-import {
-  isOAuthConnectorDefinition2
-} from "./chunk-9x8dybsb.js";
+} from "./chunk-t6vq7bff.js";
 import {
   ensureExecutionRecord2
-} from "./chunk-a7er86jd.js";
+} from "./chunk-nre82s12.js";
 import {
   ConnectorConnectionStorageError2,
   CONNECTOR_CONNECTION_RUN_FAILURE_CODES2
@@ -132,13 +138,13 @@ import {
 } from "./chunk-m4ehq95f.js";
 import {
   reportEventDeliveryFailure3
-} from "./chunk-kkqwzy6h.js";
+} from "./chunk-7t429e3f.js";
+import {
+  isOAuthConnectorDefinition2
+} from "./chunk-9x8dybsb.js";
 import {
   sameEmbeddingModel
 } from "./chunk-kyjcwqz6.js";
-import {
-  supportsDirectUpload2
-} from "./chunk-h3v76ams.js";
 import {
   isJsonObject2
 } from "./chunk-wy0qdqfm.js";
@@ -3177,6 +3183,22 @@ function settled(promise) {
   });
 }
 
+// src/agents/skills.ts
+function createAgentSkillCatalog(definitions) {
+  const skills = Object.freeze([...definitions ?? []]);
+  const skillsByName = new Map;
+  for (const skill of skills) {
+    if (skillsByName.has(skill.name)) {
+      throw new RuntimeError2(`[Sixb] Duplicate Agent Skill name: ${skill.name}`);
+    }
+    skillsByName.set(skill.name, skill);
+  }
+  return Object.freeze({
+    list: () => skills,
+    getByName: (name) => skillsByName.get(name) ?? null
+  });
+}
+
 // src/agents/tool-catalog.ts
 function createAgentToolCatalog(definitions) {
   const tools = toolsFromProjectConfig(definitions);
@@ -3187,6 +3209,290 @@ function createAgentToolCatalog(definitions) {
   });
 }
 
+// src/ontology/docs.ts
+function createOntologyDocsCatalog(input) {
+  const modules = input.docs?.modules ?? [];
+  const scripts = Object.freeze([...input.docs?.scripts ?? []]);
+  const claimedPaths = new Map(scripts.map((script) => [script.path.toLowerCase(), `script 'ontology/${script.path}'`]));
+  const claim = (path, owner) => {
+    const claimedBy = claimedPaths.get(path.toLowerCase());
+    if (claimedBy !== undefined) {
+      throw new RuntimeError2(`[Sixb] The ${owner} at 'ontology/${path}' collides with ${claimedBy}, which only differs ` + "by case or not at all. Rename one of them.");
+    }
+    claimedPaths.set(path.toLowerCase(), `the ${owner}`);
+  };
+  const docPathByType = new Map;
+  const typeIdsByNotesPath = new Map;
+  const addNotesPath = (path, objectTypeIds) => {
+    const typeIds = typeIdsByNotesPath.get(path.toLowerCase()) ?? new Set;
+    for (const objectTypeId of objectTypeIds)
+      typeIds.add(objectTypeId);
+    typeIdsByNotesPath.set(path.toLowerCase(), typeIds);
+  };
+  for (const objectType of input.objectTypes) {
+    const path = docPathFor(objectType.id, modules);
+    claim(path, `doc of object type '${objectType.id}'`);
+    docPathByType.set(objectType.id, path);
+    addNotesPath(path, [objectType.id]);
+  }
+  for (const module of modules) {
+    if (module.objectTypeIds.length > 0) {
+      addNotesPath(`${withoutExtension(module.path)}.md`, module.objectTypeIds);
+    }
+  }
+  const notesByType = new Map;
+  const docs = [];
+  const docPaths = new Map;
+  for (const doc of input.docs?.docs ?? []) {
+    const sameName = docPaths.get(doc.path.toLowerCase());
+    if (sameName !== undefined) {
+      throw new RuntimeError2(`[Sixb] The ontology docs 'ontology/${sameName}' and 'ontology/${doc.path}' only differ ` + "by case. Rename one of them.");
+    }
+    docPaths.set(doc.path.toLowerCase(), doc.path);
+    const objectTypeIds = typeIdsByNotesPath.get(doc.path.toLowerCase());
+    if (objectTypeIds === undefined) {
+      docs.push(doc);
+      continue;
+    }
+    for (const objectTypeId of objectTypeIds) {
+      notesByType.set(objectTypeId, [...notesByType.get(objectTypeId) ?? [], doc]);
+    }
+  }
+  for (const notes of notesByType.values())
+    notes.sort(byPath);
+  Object.freeze(docs);
+  const wildcardLinks = new Set(input.objectTypes.flatMap((objectType) => objectType.links.filter((link) => link.targetObjectTypeId === "*").map((link) => linkKey(objectType.id, link.id))));
+  return Object.freeze({
+    docPathFor: (objectTypeId) => {
+      const path = docPathByType.get(objectTypeId);
+      if (path === undefined) {
+        throw new RuntimeError2(`[Sixb] Object type '${objectTypeId}' is not registered.`);
+      }
+      return path;
+    },
+    notesFor: (objectTypeId) => notesByType.get(objectTypeId) ?? [],
+    listDocs: () => docs,
+    listScripts: () => scripts,
+    isWildcardLink: (objectTypeId, linkId) => wildcardLinks.has(linkKey(objectTypeId, linkId))
+  });
+}
+function docPathFor(objectTypeId, modules) {
+  const rank = (module) => {
+    const name = basename(withoutExtension(module.path));
+    return [
+      kebabCase(name) === kebabCase(objectTypeId) ? 0 : 1,
+      name === "index" ? 1 : 0,
+      module.objectTypeIds.length
+    ];
+  };
+  let owner;
+  for (const module of modules) {
+    if (!module.objectTypeIds.includes(objectTypeId))
+      continue;
+    if (owner === undefined || compareRanks(rank(module), rank(owner)) < 0)
+      owner = module;
+  }
+  const fileName = `${objectTypeId.replaceAll(/[^A-Za-z0-9._-]/g, "_")}.md`;
+  if (owner === undefined)
+    return fileName;
+  const base = withoutExtension(owner.path);
+  return owner.objectTypeIds.length === 1 ? `${base}.md` : `${base}/${fileName}`;
+}
+function compareRanks(left, right) {
+  for (const [index, value] of left.entries()) {
+    const difference = value - (right[index] ?? 0);
+    if (difference !== 0)
+      return difference;
+  }
+  return 0;
+}
+function kebabCase(name) {
+  return name.replaceAll(/([a-z0-9])([A-Z])/g, "$1-$2").replaceAll(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replaceAll(/[\s_]+/g, "-").toLowerCase();
+}
+function withoutExtension(path) {
+  return path.replace(/\.[^./]+$/, "");
+}
+function basename(path) {
+  return path.slice(path.lastIndexOf("/") + 1);
+}
+function linkKey(objectTypeId, linkId) {
+  return JSON.stringify([objectTypeId, linkId]);
+}
+function byPath(left, right) {
+  return left.path < right.path ? -1 : left.path > right.path ? 1 : 0;
+}
+
+// src/security/markings.ts
+function validateMarkingsAtStartup(input) {
+  validatePropertyMarkings(input.ontology, input.markingIds);
+  validateColumnMarkings(input.datasetsById, input.markingIds);
+  rejectPipelineStepsOverMarkedColumns(input.pipelines, input.datasetsById);
+  validateProjectionMarkings(input.projections, input.ontology, input.datasetsById);
+}
+function validatePropertyMarkings(ontology, markingIds) {
+  for (const objectType of ontology.listObjectTypes()) {
+    for (const property of objectType.properties) {
+      validateProperty(objectType, property, markingIds);
+    }
+    for (const link of objectType.links) {
+      for (const property of link.properties ?? []) {
+        if (property.markings !== undefined) {
+          throw new SecurityValidationError2(`[Sixb] Link property '${objectType.id}.${link.id}.${property.id}' cannot carry markings. Mark object properties instead.`);
+        }
+      }
+    }
+    assertSubtypeKeepsParentMarkings(objectType, ontology);
+  }
+}
+function validateProperty(objectType, property, markingIds) {
+  if (property.markings === undefined)
+    return;
+  const path = `${objectType.id}.${property.id}`;
+  assertMarkingList(property.markings, `Property '${path}'`, markingIds);
+  if (property.primary) {
+    throw new SecurityValidationError2(`[Sixb] Primary property '${path}' cannot carry markings: it identifies the object.`);
+  }
+  if (property.mode === "telemetry") {
+    throw new SecurityValidationError2(`[Sixb] Telemetry property '${path}' cannot carry markings yet.`);
+  }
+}
+function assertSubtypeKeepsParentMarkings(objectType, ontology) {
+  if (!objectType.extends)
+    return;
+  const parent = ontology.getObjectTypeById(objectType.extends);
+  if (!parent)
+    return;
+  for (const parentProperty of parent.properties) {
+    const property = objectType.properties.find((candidate) => candidate.id === parentProperty.id);
+    const missing = missingMarkings(parentProperty.markings, property?.markings);
+    if (missing.length > 0) {
+      throw new SecurityValidationError2(`[Sixb] Property '${objectType.id}.${parentProperty.id}' must keep the markings of '${parent.id}.${parentProperty.id}': add ${missing.map((markingId) => `'${markingId}'`).join(", ")}.`);
+    }
+  }
+}
+function validateColumnMarkings(datasetsById, markingIds) {
+  for (const dataset of datasetsById.values()) {
+    for (const column of dataset.schema.columns) {
+      if (column.markings === undefined)
+        continue;
+      assertMarkingList(column.markings, `Dataset column '${dataset.id}.${column.name}'`, markingIds);
+    }
+  }
+}
+function assertMarkingList(markings, subject, markingIds) {
+  if (!Array.isArray(markings) || markings.length === 0) {
+    throw new SecurityValidationError2(`[Sixb] ${subject} markings must be a non-empty list of marking ids.`);
+  }
+  if (new Set(markings).size !== markings.length) {
+    throw new SecurityValidationError2(`[Sixb] ${subject} lists the same marking twice.`);
+  }
+  for (const markingId of markings) {
+    if (typeof markingId !== "string" || !markingIds.has(markingId)) {
+      throw new SecurityValidationError2(`[Sixb] ${subject} references unknown marking '${String(markingId)}'. Add it to 'security/markings/' or pass it to createSixb({ markings }).`);
+    }
+  }
+}
+function rejectPipelineStepsOverMarkedColumns(pipelines, datasetsById) {
+  for (const pipeline of pipelines) {
+    for (const { step } of pipeline.graph.nodes) {
+      for (const input of Object.values(step.inputs)) {
+        const dataset = datasetsById.get(input.id);
+        const column = dataset?.schema.columns.find((candidate) => candidate.markings);
+        if (!dataset || !column)
+          continue;
+        throw new SecurityValidationError2(`[Sixb] Pipeline '${pipeline.id}' step '${step.id}' reads column '${dataset.id}.${column.name}', which carries ${markingList(column.markings)}. Pipeline steps cannot read marked columns yet.`);
+      }
+    }
+  }
+}
+function validateProjectionMarkings(projections, ontology, datasetsById) {
+  for (const projection of projections.listObjects()) {
+    const objectType = ontology.getObjectTypeById(projection.objectTypeId);
+    if (objectType)
+      validateObjectProjection(projection, objectType, datasetsById);
+  }
+  for (const projection of projections.listLinks()) {
+    const role = `keys link '${projection.sourceObjectTypeId}.${projection.linkId}'`;
+    for (const columnName of [projection.sourceField, projection.targetField]) {
+      assertUnmarkedColumn(projection, sourceColumn(projection, columnName, datasetsById), role);
+    }
+  }
+  for (const projection of projections.listTelemetry()) {
+    const columnNames = [
+      projection.objectIdField,
+      projection.atField,
+      ...Object.values(projection.properties).flatMap((mapping) => mapping.unitField === undefined ? [mapping.valueField] : [mapping.valueField, mapping.unitField])
+    ];
+    for (const columnName of columnNames) {
+      const column = sourceColumn(projection, columnName, datasetsById);
+      if (!column.markings)
+        continue;
+      throw new SecurityValidationError2(`[Sixb] Projection '${projection.id}' reads column '${column.path}', which carries ${markingList(column.markings)}. Telemetry projections cannot read marked columns yet.`);
+    }
+  }
+}
+function validateObjectProjection(projection, objectType, datasetsById) {
+  const keyRoles = objectProjectionKeyRoles(projection, objectType);
+  for (const [propertyId, columnName] of Object.entries(projection.properties)) {
+    const column = sourceColumn(projection, columnName, datasetsById);
+    const property = objectType.properties.find((candidate) => candidate.id === propertyId);
+    const path = `${objectType.id}.${propertyId}`;
+    const keyRole = keyRoles.get(propertyId);
+    if (keyRole) {
+      assertUnmarkedColumn(projection, column, keyRole);
+      if (property?.markings) {
+        throw new SecurityValidationError2(`[Sixb] Projection '${projection.id}': property '${path}' ${keyRole} and cannot carry markings.`);
+      }
+      continue;
+    }
+    const missing = missingMarkings(column.markings, property?.markings);
+    if (missing.length > 0) {
+      throw new SecurityValidationError2(`[Sixb] Projection '${projection.id}': property '${path}' is projected from column '${column.path}', which carries ${markingList(column.markings)}. Add markings: ${markingList(missing)} to the property.`);
+    }
+  }
+  for (const [linkId, link] of Object.entries(projection.links)) {
+    if (link.sourceField === undefined)
+      continue;
+    assertUnmarkedColumn(projection, sourceColumn(projection, link.sourceField, datasetsById), `keys link '${objectType.id}.${linkId}'`);
+  }
+  const conflictResolution = projection.conflictResolution;
+  if (conflictResolution?.strategy === "mostRecent") {
+    assertUnmarkedColumn(projection, sourceColumn(projection, conflictResolution.sourceTimestamp, datasetsById), "decides which value wins under 'mostRecent'");
+  }
+}
+function objectProjectionKeyRoles(projection, objectType) {
+  const roles = new Map;
+  for (const property of objectType.properties) {
+    if (property.primary)
+      roles.set(property.id, `becomes the id of '${objectType.id}'`);
+  }
+  for (const [linkId, link] of Object.entries(projection.links)) {
+    if (link.sourcePropertyId === undefined)
+      continue;
+    roles.set(link.sourcePropertyId, `keys link '${objectType.id}.${linkId}'`);
+  }
+  return roles;
+}
+function sourceColumn(projection, columnName, datasetsById) {
+  const column = datasetsById.get(projection.datasetId)?.schema.columns.find((candidate) => candidate.name === columnName);
+  if (!column) {
+    throw new Error(`[Sixb] Projection '${projection.id}' maps unknown column '${columnName}'.`);
+  }
+  return { path: `${projection.datasetId}.${columnName}`, markings: column.markings };
+}
+function assertUnmarkedColumn(projection, column, role) {
+  if (!column.markings)
+    return;
+  throw new SecurityValidationError2(`[Sixb] Projection '${projection.id}': column '${column.path}' ${role} and cannot carry markings.`);
+}
+function missingMarkings(required, declared) {
+  const present = new Set(declared ?? []);
+  return (required ?? []).filter((markingId) => !present.has(markingId));
+}
+function markingList(markings) {
+  return `[${(markings ?? []).join(", ")}]`;
+}
+
 // src/syncs/validation.ts
 function validateKeyedDatasetWriterTopology(input) {
   for (const sync of input.syncs) {
@@ -3263,6 +3569,11 @@ function resolveDefinitions(options) {
     }
   }
   const tools = createAgentToolCatalog(options.tools);
+  const skills = createAgentSkillCatalog(options.agent?.skills);
+  const ontologyDocs = createOntologyDocsCatalog({
+    objectTypes: ontology.listObjectTypes(),
+    ...options.agent?.ontologyDocs === undefined ? {} : { docs: options.agent.ontologyDocs }
+  });
   const connectorsById = indexUniqueDefinitions("connector", options.connectors ?? []);
   const datasetsById = new Map;
   for (const dataset of options.datasets ?? []) {
@@ -3294,7 +3605,6 @@ function resolveDefinitions(options) {
   const rulesById = indexUniqueDefinitions("rule", rules);
   validateSchedulesAtStartup2(schedules, ontology, {
     registeredRuleIds: new Set(rulesById.keys()),
-    registeredActionIds,
     registeredDatasetIds: new Set(datasetsById.keys()),
     registeredSyncIds: new Set(syncsById.keys()),
     registeredPipelineIds: new Set(pipelinesById.keys())
@@ -3310,10 +3620,12 @@ function resolveDefinitions(options) {
     registeredSchedules: schedulesById,
     registeredActionIds,
     ...models === undefined ? {} : { models },
-    tools
+    tools,
+    skills
   });
   const workflowsById = indexUniqueDefinitions("workflow", workflows);
   const security = new SecurityRegistry({
+    markings: options.markings ?? [],
     groups: options.groups ?? [],
     roles: options.roles ?? [],
     membershipPolicies: options.membershipPolicies ?? [],
@@ -3338,10 +3650,22 @@ function resolveDefinitions(options) {
     syncs,
     telemetryProjections: projectionRegistry.listTelemetry()
   });
+  validateMarkingsAtStartup({
+    markingIds: new Set(security.listMarkings().map((marking) => marking.id)),
+    ontology,
+    datasetsById,
+    pipelines,
+    projections: projectionRegistry
+  });
   return Object.freeze({
     ontology,
     actions: actionRegistry,
     tools,
+    agent: Object.freeze({
+      skills,
+      ...options.agent?.instructions === undefined ? {} : { instructions: options.agent.instructions },
+      ontologyDocs
+    }),
     connectors: createDefinitionCatalog(connectorsById),
     datasets: createDefinitionCatalog(datasetsById),
     ...models === undefined ? {} : { models },
@@ -3461,6 +3785,8 @@ function positiveInteger2(value, name) {
 // src/runtime/host.ts
 class SixbHost2 {
   projectId;
+  locale;
+  timeZone;
   webhookRegistry;
   hostContext;
   committedFacts;
@@ -3486,6 +3812,8 @@ class SixbHost2 {
   constructor(options) {
     const errorReporter = attachSixbErrorReporter2(this, options.onError);
     this.projectId = options.id ?? "default";
+    this.locale = resolveProjectLocale(options.locale);
+    this.timeZone = resolveProjectTimeZone(options.timeZone);
     this.broker = options.broker;
     this.eventService = createDomainEventService2({
       projectId: this.projectId,
@@ -3569,10 +3897,14 @@ class SixbHost2 {
     };
     registerProjectionRegistry2(this.hostContext, definitions.projections);
     shareSixbErrorReporter2(this, this.hostContext);
+    const executor = new ActionRunExecutor(this);
+    registerActionRunExecutor(this, executor);
+    registerActionRunExecutor(this.hostContext, executor);
     registerVectorIndexingRuntime(this, createVectorIndexingRuntime(this.hostContext, this.materializer));
     this.scheduler = new SchedulerRuntime2({
       schedules: definitions.schedules.list(),
-      events: this.eventService
+      events: this.eventService,
+      timeZone: this.timeZone
     });
   }
   withScope(scope) {
@@ -3659,6 +3991,24 @@ class SixbHost2 {
     };
   }
 }
+function resolveProjectLocale(locale) {
+  if (locale === undefined)
+    return DEFAULT_PROJECT_LOCALE;
+  const canonical = canonicalLocale(locale);
+  if (canonical === undefined) {
+    throw new RuntimeError2(`[Sixb] 'locale' must be a BCP 47 language tag such as "fr-FR"; received ${JSON.stringify(locale)}.`);
+  }
+  return canonical;
+}
+function resolveProjectTimeZone(timeZone) {
+  if (timeZone === undefined)
+    return DEFAULT_PROJECT_TIME_ZONE;
+  const canonical = canonicalTimeZone(timeZone);
+  if (canonical === undefined) {
+    throw new RuntimeError2(`[Sixb] 'timeZone' must be an IANA time zone such as "Europe/Paris"; received ${JSON.stringify(timeZone)}.`);
+  }
+  return canonical;
+}
 function validateAuthStrategySecurityReferences(strategy, security) {
   if (!isMagicLinkAuthStrategy2(strategy) && !isOidcAuthStrategy2(strategy)) {
     return;
@@ -3685,14 +4035,19 @@ function assertWebhookRunStorage(connectors, storage) {
 async function createSixb2(options) {
   assertNoAgentDefinitions(options);
   const projectRoot = resolve2(options.projectRoot ?? process.cwd());
-  const discoveredOntology = await discoverOntologySources2(projectRoot);
-  const allSources = [...options.ontologies ?? [], ...discoveredOntology];
+  const discoveredOntology = await discoverOntologySources(projectRoot);
+  const allSources = [...options.ontologies ?? [], ...discoveredOntology.sources];
   if (allSources.length === 0) {
     throw new RuntimeError2("No ontology found. Create an 'ontology/' folder or pass 'ontologies' to createSixb().");
   }
   const definitions = await discoverProjectDefinitions2(projectRoot);
+  const skills = await discoverAgentSkills(projectRoot);
+  const instructions = await discoverProjectInstructions(projectRoot);
+  const ontologyFiles = await discoverOntologyFiles(projectRoot);
   return new SixbHost2({
     id: options.id,
+    locale: options.locale,
+    timeZone: options.timeZone,
     ontology: allSources,
     broker: options.broker,
     storage: options.storage,
@@ -3715,15 +4070,21 @@ async function createSixb2(options) {
     projections: [...options.projections ?? [], ...definitions.projections],
     rules: [...options.rules ?? [], ...definitions.rules],
     workflows: [...options.workflows ?? [], ...definitions.workflows],
+    markings: [...options.markings ?? [], ...definitions.markings],
     groups: [...options.groups ?? [], ...definitions.groups],
     roles: [...options.roles ?? [], ...definitions.roles],
     membershipPolicies: [...options.membershipPolicies ?? [], ...definitions.membershipPolicies],
     models: options.models,
     tools: options.tools,
+    agent: {
+      skills,
+      ...instructions === undefined ? {} : { instructions },
+      ontologyDocs: { modules: discoveredOntology.modules, ...ontologyFiles }
+    },
     shares: [...options.shares ?? [], ...definitions.shares],
     auth: options.auth
   });
 }
 export { WebhookValidationError2, defineWebhook2, webhookConnector2, UnverifiedWebhookError2, resolveWebhookVerification2, warnUnverifiedWebhook2, SixbHost2, createSixb2 };
 
-//# debugId=CC8274E37BA99FA964756E2164756E21
+//# debugId=FFB103AB39C9032D64756E2164756E21