@elevasis/sdk 1.24.0 → 1.26.0

package/dist/test-utils/index.js

@@ -3938,6 +3938,12 @@ var zodToJsonSchema = (schema, options) => {
   }
   return combined;
 };
+
+// ../core/src/execution/engine/workflow/types.ts
+var StepType = {
+  LINEAR: "linear",
+  CONDITIONAL: "conditional"
+};
 function errorToString(error) {
   if (error instanceof ZodError) {
     return JSON.stringify(error.issues, null, 2);
@@ -3959,6 +3965,26 @@ function getErrorDetails(error) {
   return details;
 }
 
+// ../core/src/execution/engine/workflow/log-truncate.ts
+var LOG_STRING_TRUNCATE_LIMIT = 200;
+function truncateForLogging(value) {
+  if (value === null || value === void 0) return value;
+  if (typeof value === "string") {
+    return value.length > LOG_STRING_TRUNCATE_LIMIT ? value.slice(0, LOG_STRING_TRUNCATE_LIMIT) + `\u2026 [${value.length} chars]` : value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(truncateForLogging);
+  }
+  if (typeof value === "object") {
+    const result = {};
+    for (const [k2, v2] of Object.entries(value)) {
+      result[k2] = truncateForLogging(v2);
+    }
+    return result;
+  }
+  return value;
+}
+
 // ../core/src/execution/engine/base/errors.ts
 var ExecutionError = class extends Error {
   /**
@@ -3999,6 +4025,305 @@ var ExecutionError = class extends Error {
   }
 };
 
+// ../core/src/execution/engine/workflow/errors.ts
+var WorkflowStepError = class extends ExecutionError {
+  type = "workflow_step_error";
+  severity = "critical";
+  category = "workflow";
+  constructor(message, context) {
+    super(message, context);
+  }
+};
+var WorkflowValidationError = class extends ExecutionError {
+  type = "workflow_validation_error";
+  severity = "info";
+  category = "validation";
+  constructor(message, context) {
+    super(message, context);
+  }
+};
+
+// ../core/src/execution/engine/workflow/utils.ts
+function validateEntryPoint(steps, entryPoint) {
+  if (!(entryPoint in steps)) {
+    throw new WorkflowValidationError(`Entry point step '${entryPoint}' not found in workflow`, {
+      entryPoint
+    });
+  }
+}
+function findTerminalSteps(steps) {
+  return Object.values(steps).filter((step) => step.next === null);
+}
+function validateTerminalSteps(steps, workflowId) {
+  const terminalSteps = findTerminalSteps(steps);
+  if (terminalSteps.length === 0) {
+    throw new WorkflowValidationError(`Workflow '${workflowId}' must have at least one terminal step (next: null)`, {
+      workflowId
+    });
+  }
+}
+function validateStepReferences(steps) {
+  for (const [id, step] of Object.entries(steps)) {
+    if (step.next === null) {
+      continue;
+    }
+    if (step.next.type === StepType.LINEAR) {
+      if (!(step.next.target in steps)) {
+        throw new WorkflowValidationError(`Step '${id}' references non-existent target '${step.next.target}'`, {
+          stepId: id,
+          target: step.next.target
+        });
+      }
+    } else if (step.next.type === StepType.CONDITIONAL) {
+      const targets = [...step.next.routes.map((r2) => r2.target), step.next.default];
+      for (const target of targets) {
+        if (!(target in steps)) {
+          throw new WorkflowValidationError(`Step '${id}' references non-existent target '${target}'`, {
+            stepId: id,
+            target
+          });
+        }
+      }
+    }
+  }
+}
+function detectCycle(visited, executionPath, currentStepId) {
+  if (visited.has(currentStepId)) {
+    const cycle = executionPath.slice(executionPath.indexOf(currentStepId));
+    throw new WorkflowStepError(`Cycle detected in workflow: ${cycle.join(" -> ")} -> ${currentStepId}`, {
+      stepId: currentStepId,
+      cycle: [...cycle, currentStepId]
+    });
+  }
+}
+function validateTerminalOutput(stepId, output, outputSchema) {
+  if (!outputSchema) {
+    return;
+  }
+  try {
+    outputSchema.parse(output);
+  } catch (error) {
+    throw new WorkflowValidationError(
+      `Terminal step '${stepId}' produced invalid output: ${error instanceof Error ? error.message : String(error)}`,
+      { stepId, validationError: error instanceof Error ? error.message : String(error) }
+    );
+  }
+}
+async function determineNextStep(step, currentData, context) {
+  const { next } = step;
+  if (next === null) {
+    return null;
+  }
+  if (next.type === StepType.LINEAR) {
+    return next.target;
+  }
+  if (next.type === StepType.CONDITIONAL) {
+    return evaluateConditionalRoutes(step.id, next, currentData, context);
+  }
+  throw new WorkflowStepError(`Unknown next configuration type in step ${step.id}`, {
+    stepId: step.id
+  });
+}
+async function evaluateConditionalRoutes(stepId, next, currentData, context) {
+  for (const route of next.routes) {
+    try {
+      if (route.condition(currentData)) {
+        context.logger.debug(`Conditional route taken: ${stepId} -> ${route.target}`, {
+          type: "workflow",
+          contextType: "conditional-route",
+          stepId,
+          target: route.target
+        });
+        return route.target;
+      }
+    } catch (error) {
+      context.logger.warn(`Error evaluating condition in step ${stepId}: ${error}`, {
+        type: "workflow",
+        contextType: "conditional-route",
+        stepId,
+        target: "",
+        error: errorToString(error)
+      });
+    }
+  }
+  context.logger.debug(`Using default route: ${stepId} -> ${next.default}`, {
+    type: "workflow",
+    contextType: "conditional-route",
+    stepId,
+    target: next.default
+  });
+  return next.default;
+}
+function logWorkflowStart(context, workflowId, workflowName) {
+  context.logger.info(`Executing workflow: ${workflowId}`, {
+    type: "workflow",
+    contextType: "workflow-execution",
+    executionId: context.executionId,
+    workflowId,
+    workflowName,
+    organizationId: context.organizationId
+  });
+}
+function logWorkflowSuccess(context, workflowId, executionPath) {
+  context.logger.info(`Workflow completed successfully: ${workflowId}`, {
+    type: "workflow",
+    contextType: "workflow-execution",
+    executionId: context.executionId,
+    workflowId,
+    organizationId: context.organizationId,
+    executionPath
+  });
+}
+function logWorkflowFailure(context, workflowId, error) {
+  context.logger.error(`Execution failed: workflow/${workflowId}`, {
+    type: "workflow",
+    contextType: "workflow-failure",
+    executionId: context.executionId,
+    workflowId,
+    error: errorToString(error)
+  });
+}
+function logStepStart(context, stepId, stepName, input, startTime) {
+  context.logger.info(`Step started: ${stepName}`, {
+    type: "workflow",
+    contextType: "step-started",
+    stepId,
+    stepStatus: "started",
+    input: truncateForLogging(input),
+    startTime
+  });
+}
+function logStepSuccess(context, stepId, stepName, output, duration, isTerminal, startTime, endTime) {
+  context.logger.info(`Step completed: ${stepName}`, {
+    type: "workflow",
+    contextType: "step-completed",
+    stepId,
+    stepStatus: "completed",
+    output: truncateForLogging(output),
+    duration,
+    isTerminal,
+    startTime,
+    endTime
+  });
+}
+function logStepFailure(context, stepId, stepName, error, duration, startTime, endTime) {
+  context.logger.error(`Step failed: ${stepName}`, {
+    type: "workflow",
+    contextType: "step-failed",
+    stepId,
+    stepStatus: "failed",
+    error: errorToString(error),
+    duration,
+    startTime,
+    endTime
+  });
+}
+function logExecutionPath(context, executionPath) {
+  context.logger.info(`Workflow completed. Execution path: ${executionPath.join(" -> ")}`, {
+    type: "workflow",
+    contextType: "execution-path",
+    executionPath
+  });
+}
+
+// ../core/src/execution/engine/workflow/workflow.ts
+var Workflow = class {
+  config;
+  contract;
+  steps;
+  entryPoint;
+  // Derived properties (computed from definition)
+  shouldGenerateOutput;
+  /**
+   * Create a new workflow instance from definition
+   *
+   * @param definition - Workflow definition with config, contract, steps, and entryPoint
+   */
+  constructor(definition) {
+    this.config = definition.config;
+    this.contract = definition.contract;
+    this.steps = definition.steps;
+    this.entryPoint = definition.entryPoint;
+    this.shouldGenerateOutput = !!definition.contract.outputSchema;
+    validateEntryPoint(this.steps, this.entryPoint);
+    validateTerminalSteps(this.steps, this.config.resourceId);
+    validateStepReferences(this.steps);
+  }
+  /**
+   * Execute the workflow with graph-based flow control
+   * Context is required for execution tracking, logging, and organization isolation
+   * @returns Validated output matching contract.outputSchema, or null if no output schema
+   */
+  async execute(input, context) {
+    logWorkflowStart(context, this.config.resourceId, this.config.name);
+    try {
+      const validated = this.contract.inputSchema.parse(input);
+      const visited = /* @__PURE__ */ new Set();
+      const executionPath = [];
+      let currentData = validated;
+      let currentStepId = this.entryPoint;
+      while (currentStepId !== null) {
+        detectCycle(visited, executionPath, currentStepId);
+        visited.add(currentStepId);
+        executionPath.push(currentStepId);
+        const step = this.steps[currentStepId];
+        if (!step) {
+          throw new WorkflowStepError(`Step '${currentStepId}' not found in workflow`, {
+            stepId: currentStepId,
+            workflowId: this.config.resourceId,
+            executionId: context.executionId,
+            organizationId: context.organizationId,
+            executionPath
+          });
+        }
+        const stepStartTime = Date.now();
+        logStepStart(context, step.id, step.name, currentData, stepStartTime);
+        try {
+          const validatedInput = step.inputSchema.parse(currentData);
+          const rawOutput = await step.handler(validatedInput, context);
+          currentData = step.outputSchema.parse(rawOutput);
+          if (step.next === null && this.shouldGenerateOutput) {
+            validateTerminalOutput(step.id, currentData, this.contract.outputSchema);
+          }
+          const stepEndTime = Date.now();
+          const duration = stepEndTime - stepStartTime;
+          logStepSuccess(
+            context,
+            step.id,
+            step.name,
+            currentData,
+            duration,
+            step.next === null,
+            stepStartTime,
+            stepEndTime
+          );
+          currentStepId = await determineNextStep(step, currentData, context);
+        } catch (error) {
+          const stepEndTime = Date.now();
+          const duration = stepEndTime - stepStartTime;
+          logStepFailure(context, step.id, step.name, error, duration, stepStartTime, stepEndTime);
+          throw new WorkflowStepError(`Step failed [${step.id}:${step.name}]: ${errorToString(error)}`, {
+            stepId: step.id,
+            stepName: step.name,
+            workflowId: this.config.resourceId,
+            executionId: context.executionId,
+            duration: stepEndTime - stepStartTime
+          });
+        }
+      }
+      logExecutionPath(context, executionPath);
+      logWorkflowSuccess(context, this.config.resourceId, executionPath);
+      if (!this.shouldGenerateOutput) {
+        return null;
+      }
+      return currentData;
+    } catch (error) {
+      logWorkflowFailure(context, this.config.resourceId, error);
+      throw error;
+    }
+  }
+};
+
 // ../core/src/execution/engine/agent/observability/logging.ts
 function createAgentLogger(logger, agentId, sessionId) {
   return {
@@ -5532,8 +5857,8 @@ async function processMemory(memoryManager, response, logger, iteration) {
         continue;
       }
       const startTime = Date.now();
-      const stringValue2 = typeof content === "string" ? content : JSON.stringify(content);
-      memoryManager.set(key, stringValue2);
+      const stringValue = typeof content === "string" ? content : JSON.stringify(content);
+      memoryManager.set(key, stringValue);
       const endTime = Date.now();
       logger.action("memory-set", `Set: ${key}`, iteration, startTime, endTime, endTime - startTime);
     }
@@ -6598,7 +6923,7 @@ var LabelSchema = z.string().trim().min(1).max(120);
 var DescriptionSchema = z.string().trim().min(1).max(2e3);
 var ColorTokenSchema = z.string().trim().min(1).max(50);
 var IconNameSchema = OrganizationModelIconTokenSchema;
-var PathSchema = z.string().trim().startsWith("/").max(300);
+z.string().trim().startsWith("/").max(300);
 var ReferenceIdsSchema = z.array(ModelIdSchema).default([]);
 var DisplayMetadataSchema = z.object({
   label: LabelSchema,
@@ -6637,190 +6962,25 @@ DisplayMetadataSchema.extend({
   techStack: TechStackEntrySchema.optional()
 });
 
-// ../core/src/organization-model/domains/entities.ts
-var EntityIdSchema = ModelIdSchema;
-var EntityLinkKindSchema = z.enum(["belongs-to", "has-many", "has-one", "many-to-many"]).meta({ label: "Link kind" });
-var EntityLinkSchema = z.object({
-  toEntity: EntityIdSchema.meta({ ref: "entity" }),
-  kind: EntityLinkKindSchema,
-  via: z.string().trim().min(1).max(255).optional(),
-  label: LabelSchema.optional()
-});
-var EntitySchema = z.object({
-  id: EntityIdSchema,
-  /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
-  order: z.number(),
-  label: LabelSchema,
-  description: DescriptionSchema.optional(),
-  ownedBySystemId: ModelIdSchema.meta({ ref: "system" }),
-  table: z.string().trim().min(1).max(255).optional(),
-  rowSchema: ModelIdSchema.optional(),
-  stateCatalogId: ModelIdSchema.optional(),
-  links: z.array(EntityLinkSchema).optional()
-});
-var EntitiesDomainSchema = z.record(z.string(), EntitySchema).refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
-  message: "Each entity entry id must match its map key"
-}).default({});
-var ENTITY_ENTRY_INPUTS = [
-  {
-    id: "crm.deal",
-    order: 10,
-    label: "Deal",
-    description: "A CRM opportunity or sales pipeline record.",
-    ownedBySystemId: "sales.crm",
-    table: "crm_deals",
-    stateCatalogId: "crm.pipeline",
-    links: [{ toEntity: "crm.contact", kind: "has-many", via: "deal_contacts", label: "contacts" }]
-  },
-  {
-    id: "crm.contact",
-    order: 20,
-    label: "CRM Contact",
-    description: "A person associated with a CRM relationship or deal.",
-    ownedBySystemId: "sales.crm",
-    table: "crm_contacts"
-  },
-  {
-    id: "leadgen.list",
-    order: 30,
-    label: "Lead List",
-    description: "A prospecting list that groups companies and contacts for acquisition workflows.",
-    ownedBySystemId: "sales.lead-gen",
-    table: "acq_lists",
-    links: [
-      { toEntity: "leadgen.company", kind: "has-many", via: "acq_list_companies", label: "companies" },
-      { toEntity: "leadgen.contact", kind: "has-many", via: "acq_list_members", label: "contacts" }
-    ]
-  },
-  {
-    id: "leadgen.company",
-    order: 40,
-    label: "Lead Company",
-    description: "A company record sourced, enriched, and qualified during prospecting.",
-    ownedBySystemId: "sales.lead-gen",
-    table: "acq_list_companies",
-    stateCatalogId: "lead-gen.company",
-    links: [
-      { toEntity: "leadgen.list", kind: "belongs-to", via: "list_id", label: "list" },
-      { toEntity: "leadgen.contact", kind: "has-many", via: "company_id", label: "contacts" }
-    ]
-  },
-  {
-    id: "leadgen.contact",
-    order: 50,
-    label: "Lead Contact",
-    description: "A prospect contact discovered or enriched during lead generation.",
-    ownedBySystemId: "sales.lead-gen",
-    table: "acq_list_members",
-    stateCatalogId: "lead-gen.contact",
-    links: [
-      { toEntity: "leadgen.list", kind: "belongs-to", via: "list_id", label: "list" },
-      { toEntity: "leadgen.company", kind: "belongs-to", via: "company_id", label: "company" }
-    ]
-  },
-  {
-    id: "delivery.project",
-    order: 60,
-    label: "Project",
-    description: "A client delivery project.",
-    ownedBySystemId: "projects",
-    table: "projects",
-    links: [
-      { toEntity: "delivery.milestone", kind: "has-many", via: "project_id", label: "milestones" },
-      { toEntity: "delivery.task", kind: "has-many", via: "project_id", label: "tasks" }
-    ]
-  },
-  {
-    id: "delivery.milestone",
-    order: 70,
-    label: "Milestone",
-    description: "A delivery checkpoint within a project.",
-    ownedBySystemId: "projects",
-    table: "project_milestones",
-    links: [
-      { toEntity: "delivery.project", kind: "belongs-to", via: "project_id", label: "project" },
-      { toEntity: "delivery.task", kind: "has-many", via: "milestone_id", label: "tasks" }
-    ]
-  },
-  {
-    id: "delivery.task",
-    order: 80,
-    label: "Task",
-    description: "A delivery task that can move through the task status catalog.",
-    ownedBySystemId: "projects",
-    table: "project_tasks",
-    stateCatalogId: "delivery.task",
-    links: [
-      { toEntity: "delivery.project", kind: "belongs-to", via: "project_id", label: "project" },
-      { toEntity: "delivery.milestone", kind: "belongs-to", via: "milestone_id", label: "milestone" }
-    ]
+// ../core/src/organization-model/helpers.ts
+function childSystemsOf(system) {
+  return system.systems ?? system.subsystems ?? {};
+}
+function listAllSystems(model) {
+  const results = [];
+  function walk(map2, prefix) {
+    for (const [localId, system] of Object.entries(map2)) {
+      const fullPath = prefix ? `${prefix}.${localId}` : localId;
+      results.push({ path: fullPath, system });
+      const childSystems = childSystemsOf(system);
+      if (Object.keys(childSystems).length > 0) {
+        walk(childSystems, fullPath);
+      }
+    }
   }
-];
-var DEFAULT_ORGANIZATION_MODEL_ENTITIES = Object.fromEntries(
-  ENTITY_ENTRY_INPUTS.map((entity) => {
-    const parsed = EntitySchema.parse(entity);
-    return [parsed.id, parsed];
-  })
-);
-
-// ../core/src/organization-model/domains/actions.ts
-var ActionResourceIdSchema = z.string().trim().min(1).max(255).regex(/^[A-Za-z0-9]+(?:[-._][A-Za-z0-9]+)*$/, "Resource IDs must use letters, numbers, -, _, or . separators");
-z.enum(["slash-command", "mcp-tool", "api-endpoint", "script-execution"]).meta({ label: "Invocation kind" });
-var ActionIdSchema = ModelIdSchema;
-var ActionScopeSchema = z.union([
-  z.literal("global"),
-  z.object({
-    domain: ModelIdSchema
-  })
-]);
-var ActionRefSchema = z.object({
-  actionId: ActionIdSchema.meta({ ref: "action" }),
-  intent: z.enum(["exposes", "consumes"]).meta({ label: "Intent" })
-});
-var SlashCommandInvocationSchema = z.object({
-  kind: z.literal("slash-command"),
-  command: z.string().trim().min(1).max(200).regex(/^\/[^\s].*$/, "Slash commands must start with /"),
-  toolFactory: ModelIdSchema.optional()
-});
-var McpToolInvocationSchema = z.object({
-  kind: z.literal("mcp-tool"),
-  server: ModelIdSchema,
-  name: ModelIdSchema
-});
-var ApiEndpointInvocationSchema = z.object({
-  kind: z.literal("api-endpoint"),
-  method: z.enum(["GET", "POST", "PATCH", "DELETE"]).meta({ label: "HTTP method" }),
-  path: z.string().trim().startsWith("/").max(500),
-  requestSchema: ModelIdSchema.optional(),
-  responseSchema: ModelIdSchema.optional()
-});
-var ScriptExecutionInvocationSchema = z.object({
-  kind: z.literal("script-execution"),
-  resourceId: ActionResourceIdSchema
-});
-var ActionInvocationSchema = z.discriminatedUnion("kind", [
-  SlashCommandInvocationSchema,
-  McpToolInvocationSchema,
-  ApiEndpointInvocationSchema,
-  ScriptExecutionInvocationSchema
-]);
-var ActionSchema = z.object({
-  id: ActionIdSchema,
-  /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
-  order: z.number(),
-  label: LabelSchema,
-  description: DescriptionSchema.optional(),
-  scope: ActionScopeSchema.default("global"),
-  resourceId: ActionResourceIdSchema.optional(),
-  affects: z.array(EntityIdSchema.meta({ ref: "entity" })).optional(),
-  invocations: z.array(ActionInvocationSchema).default([]),
-  knowledge: z.array(ModelIdSchema.meta({ ref: "knowledge" })).default([]).optional(),
-  lifecycle: z.enum(["draft", "beta", "active", "deprecated", "archived"]).meta({ label: "Lifecycle", color: "teal" }).default("active")
-});
-var ActionsDomainSchema = z.record(z.string(), ActionSchema).refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
-  message: "Each action entry id must match its map key"
-}).default({});
-var DEFAULT_ORGANIZATION_MODEL_ACTIONS = {};
+  walk(model.systems, "");
+  return results;
+}
 
 // ../core/src/organization-model/domains/prospecting.ts
 DisplayMetadataSchema.extend({
@@ -6874,2469 +7034,13 @@ DisplayMetadataSchema.extend({
   id: ModelIdSchema,
   steps: z.array(ProspectingBuildTemplateStepSchema).min(1)
 });
-var DTC_RECORD_COLUMNS = {
-  populated: {
-    company: [
-      { key: "name", label: "Company", path: "company.name" },
-      { key: "domain", label: "Domain", path: "company.domain" },
-      { key: "employee-count", label: "Employees", path: "company.numEmployees", renderType: "count" },
-      { key: "apollo-industry", label: "Apollo industry", path: "company.category" },
-      { key: "location", label: "Location", path: "company.locationState" }
-    ]
-  },
-  crawled: {
-    company: [
-      { key: "name", label: "Company", path: "company.name" },
-      { key: "domain", label: "Domain", path: "company.domain" },
-      { key: "page-count", label: "Pages", path: "company.enrichmentData.websiteCrawl.pageCount", renderType: "count" },
-      { key: "crawl-status", label: "Crawl status", path: "processingState.crawled.status", renderType: "badge" }
-    ]
-  },
-  extracted: {
-    company: [
-      { key: "name", label: "Company", path: "company.name" },
-      { key: "domain", label: "Domain", path: "company.domain" },
-      { key: "description", label: "Description", path: "company.enrichmentData.websiteCrawl.companyDescription" },
-      { key: "services", label: "Services", path: "company.enrichmentData.websiteCrawl.services", renderType: "json" },
-      {
-        key: "automation-gaps",
-        label: "Automation gaps",
-        path: "company.enrichmentData.websiteCrawl.automationGaps",
-        renderType: "json"
-      },
-      {
-        key: "contact-count",
-        label: "Contacts",
-        path: "company.enrichmentData.websiteCrawl.emailCount",
-        renderType: "count"
-      }
-    ]
-  },
-  qualified: {
-    company: [
-      { key: "name", label: "Company", path: "company.name" },
-      { key: "domain", label: "Domain", path: "company.domain" },
-      { key: "score", label: "Score", path: "company.qualificationScore", renderType: "badge", badgeColor: "green" },
-      { key: "signals", label: "Signals", path: "company.qualificationSignals", renderType: "json" },
-      {
-        key: "disqualified-reason",
-        label: "Disqualified reason",
-        path: "processingState.qualified.data.disqualifiedReason"
-      }
-    ]
-  },
-  decisionMakers: {
-    contact: [
-      { key: "name", label: "Name", path: "contact.name" },
-      { key: "title", label: "Title", path: "contact.title" },
-      { key: "email", label: "Email", path: "contact.email" },
-      { key: "linkedin", label: "LinkedIn", path: "contact.linkedinUrl" },
-      {
-        key: "priority-score",
-        label: "Priority",
-        path: "contact.enrichmentData.apollo.priorityScore",
-        renderType: "badge"
-      }
-    ]
-  },
-  uploaded: {
-    company: [
-      { key: "name", label: "Company", path: "company.name" },
-      { key: "domain", label: "Domain", path: "company.domain" },
-      {
-        key: "contacts",
-        label: "Contacts",
-        path: "company.enrichmentData.approvedLeadListExport.contacts",
-        renderType: "json"
-      },
-      { key: "score", label: "Score", path: "company.qualificationScore", renderType: "badge", badgeColor: "green" },
-      {
-        key: "approval",
-        label: "Approval",
-        path: "company.enrichmentData.approvedLeadListExport.approvalStatus",
-        renderType: "badge"
-      }
-    ]
-  }
-};
-var PROSPECTING_STEPS = {
-  localServices: {
-    sourceCompanies: {
-      id: "source-companies",
-      label: "Companies found",
-      primaryEntity: "company",
-      outputs: ["company"],
-      stageKey: "populated",
-      dependencyMode: "per-record-eligibility",
-      actionKey: "lead-gen.company.source",
-      defaultBatchSize: 100,
-      maxBatchSize: 250
-    },
-    analyzeWebsites: {
-      id: "analyze-websites",
-      label: "Websites analyzed",
-      primaryEntity: "company",
-      outputs: ["company"],
-      stageKey: "extracted",
-      dependsOn: ["source-companies"],
-      dependencyMode: "per-record-eligibility",
-      actionKey: "lead-gen.company.website-extract",
-      defaultBatchSize: 50,
-      maxBatchSize: 100
-    },
-    qualifyCompanies: {
-      id: "qualify-companies",
-      label: "Companies qualified",
-      primaryEntity: "company",
-      outputs: ["company"],
-      stageKey: "qualified",
-      dependsOn: ["analyze-websites"],
-      dependencyMode: "per-record-eligibility",
-      actionKey: "lead-gen.company.qualify",
-      defaultBatchSize: 100,
-      maxBatchSize: 250
-    },
-    findContacts: {
-      id: "find-contacts",
-      label: "Decision-makers found",
-      primaryEntity: "contact",
-      outputs: ["contact"],
-      stageKey: "discovered",
-      dependsOn: ["qualify-companies"],
-      dependencyMode: "per-record-eligibility",
-      actionKey: "lead-gen.contact.discover",
-      defaultBatchSize: 50,
-      maxBatchSize: 100
-    },
-    verifyEmails: {
-      id: "verify-emails",
-      label: "Emails verified",
-      primaryEntity: "contact",
-      outputs: ["contact"],
-      stageKey: "verified",
-      dependsOn: ["find-contacts"],
-      dependencyMode: "per-record-eligibility",
-      actionKey: "lead-gen.contact.verify-email",
-      defaultBatchSize: 100,
-      maxBatchSize: 500
-    },
-    personalize: {
-      id: "personalize",
-      label: "Personalize",
-      primaryEntity: "contact",
-      outputs: ["contact"],
-      stageKey: "personalized",
-      dependsOn: ["verify-emails"],
-      dependencyMode: "per-record-eligibility",
-      actionKey: "lead-gen.contact.personalize",
-      defaultBatchSize: 25,
-      maxBatchSize: 100
-    },
-    review: {
-      id: "review",
-      label: "Reviewed and exported",
-      primaryEntity: "contact",
-      outputs: ["export"],
-      stageKey: "uploaded",
-      dependsOn: ["personalize"],
-      dependencyMode: "per-record-eligibility",
-      actionKey: "lead-gen.review.outreach-ready",
-      defaultBatchSize: 25,
-      maxBatchSize: 100
-    }
-  },
-  dtcApolloClickup: {
-    importApolloSearch: {
-      id: "import-apollo-search",
-      label: "Companies found",
-      description: "Pull companies and seed contact data from a predefined Apollo search or list.",
-      primaryEntity: "company",
-      outputs: ["company", "contact"],
-      stageKey: "populated",
-      dependencyMode: "per-record-eligibility",
-      actionKey: "lead-gen.company.apollo-import",
-      defaultBatchSize: 250,
-      maxBatchSize: 1e3,
-      recordColumns: DTC_RECORD_COLUMNS.populated,
-      credentialRequirements: [
-        {
-          key: "apollo",
-          provider: "apollo",
-          credentialType: "api-key-secret",
-          label: "Apollo API key",
-          required: true,
-          selectionMode: "single",
-          inputPath: "credential"
-        }
-      ]
-    },
-    apifyCrawl: {
-      id: "apify-crawl",
-      label: "Websites crawled",
-      description: "Crawl company websites via Apify and store raw page markdown in enrichmentData.websiteCrawl.pages for downstream LLM analysis. Overwrites the synthetic seed Apollo Import wrote with real page content.",
-      primaryEntity: "company",
-      outputs: ["company"],
-      stageKey: "crawled",
-      dependsOn: ["import-apollo-search"],
-      dependencyMode: "per-record-eligibility",
-      actionKey: "lead-gen.company.apify-crawl",
-      defaultBatchSize: 50,
-      maxBatchSize: 100,
-      recordColumns: DTC_RECORD_COLUMNS.crawled,
-      credentialRequirements: [
-        {
-          key: "apify",
-          provider: "apify",
-          credentialType: "api-key-secret",
-          label: "Apify API token",
-          required: true,
-          selectionMode: "single",
-          inputPath: "credential",
-          verifyOnRun: true
-        }
-      ]
-    },
-    analyzeWebsites: {
-      id: "analyze-websites",
-      label: "Websites analyzed",
-      description: "Extract subscription, product, retention, and tech-stack signals from each brand website.",
-      primaryEntity: "company",
-      outputs: ["company"],
-      stageKey: "extracted",
-      dependsOn: ["apify-crawl"],
-      dependencyMode: "per-record-eligibility",
-      actionKey: "lead-gen.company.website-extract",
-      defaultBatchSize: 50,
-      maxBatchSize: 100,
-      recordColumns: DTC_RECORD_COLUMNS.extracted
-    },
-    scoreDtcFit: {
-      id: "score-dtc-fit",
-      label: "Companies qualified",
-      description: "Classify subscription potential, consumable-product fit, retention maturity, and disqualifiers.",
-      primaryEntity: "company",
-      outputs: ["company"],
-      stageKey: "qualified",
-      dependsOn: ["analyze-websites"],
-      dependencyMode: "per-record-eligibility",
-      actionKey: "lead-gen.company.dtc-subscription-qualify",
-      defaultBatchSize: 100,
-      maxBatchSize: 250,
-      recordColumns: DTC_RECORD_COLUMNS.qualified
-    },
-    enrichDecisionMakers: {
-      id: "enrich-decision-makers",
-      label: "Decision-makers found",
-      description: "Use Apollo to find qualified contacts at qualified companies - founders, retention leads, lifecycle leads, and marketing owners.",
-      primaryEntity: "company",
-      outputs: ["contact"],
-      stageKey: "decision-makers-enriched",
-      recordEntity: "contact",
-      dependsOn: ["score-dtc-fit"],
-      dependencyMode: "per-record-eligibility",
-      actionKey: "lead-gen.contact.apollo-decision-maker-enrich",
-      defaultBatchSize: 100,
-      maxBatchSize: 250,
-      recordColumns: DTC_RECORD_COLUMNS.decisionMakers,
-      credentialRequirements: [
-        {
-          key: "apollo",
-          provider: "apollo",
-          credentialType: "api-key-secret",
-          label: "Apollo API key",
-          required: true,
-          selectionMode: "single",
-          inputPath: "credential"
-        }
-      ]
-    },
-    reviewAndExport: {
-      id: "review-and-export",
-      label: "Reviewed and exported",
-      description: "Operator QC approves or rejects qualified companies, then approved records are exported as a lead list with unverified emails.",
-      primaryEntity: "company",
-      outputs: ["export"],
-      stageKey: "uploaded",
-      recordsStageKey: "uploaded",
-      recordSourceStageKey: "qualified",
-      dependsOn: ["enrich-decision-makers"],
-      dependencyMode: "per-record-eligibility",
-      actionKey: "lead-gen.export.list",
-      defaultBatchSize: 100,
-      maxBatchSize: 250,
-      recordColumns: DTC_RECORD_COLUMNS.uploaded,
-      credentialRequirements: [
-        {
-          key: "clickup",
-          provider: "clickup",
-          credentialType: "api-key-secret",
-          label: "ClickUp API token",
-          required: true,
-          selectionMode: "single",
-          inputPath: "clickupCredential",
-          verifyOnRun: true
-        }
-      ]
-    }
-  }
-};
-
-// ../core/src/business/acquisition/build-templates.ts
-var BUILD_TEMPLATE_CATALOG = [
-  {
-    id: "local-services",
-    label: "Local Services",
-    description: "Source, analyze, qualify, and personalize local service businesses for outreach.",
-    steps: Object.values(PROSPECTING_STEPS.localServices)
-  },
-  {
-    id: "dtc-subscription-apollo-clickup",
-    label: "DTC Subscription (Apollo + ClickUp)",
-    description: "Import DTC brand leads from Apollo, crawl their websites, score fit, enrich contacts, and export via ClickUp.",
-    steps: Object.values(PROSPECTING_STEPS.dtcApolloClickup)
-  }
-];
-var PROSPECTING_BUILD_TEMPLATE_OPTIONS = BUILD_TEMPLATE_CATALOG.map(({ id, label, description }) => ({
-  id,
-  label,
-  description
-}));
-function isProspectingBuildTemplateId(value) {
-  return PROSPECTING_BUILD_TEMPLATE_OPTIONS.some((template) => template.id === value);
-}
-var OrganizationModelBrandingSchema = z.object({
-  organizationName: LabelSchema,
-  productName: LabelSchema,
-  shortName: z.string().trim().min(1).max(40),
-  description: DescriptionSchema.optional(),
-  logos: z.object({
-    light: z.string().trim().min(1).max(2048).optional(),
-    dark: z.string().trim().min(1).max(2048).optional()
-  }).default({})
-});
-var DEFAULT_ORGANIZATION_MODEL_BRANDING = {
-  organizationName: "Default Organization",
-  productName: "Elevasis",
-  shortName: "Elevasis",
-  logos: {}
-};
-var BusinessHoursDaySchema = z.object({
-  open: z.string().trim().regex(/^\d{2}:\d{2}$/, "Expected HH:MM format"),
-  close: z.string().trim().regex(/^\d{2}:\d{2}$/, "Expected HH:MM format")
-});
-var BusinessHoursSchema = z.object({
-  monday: BusinessHoursDaySchema.optional(),
-  tuesday: BusinessHoursDaySchema.optional(),
-  wednesday: BusinessHoursDaySchema.optional(),
-  thursday: BusinessHoursDaySchema.optional(),
-  friday: BusinessHoursDaySchema.optional(),
-  saturday: BusinessHoursDaySchema.optional(),
-  sunday: BusinessHoursDaySchema.optional()
-}).default({});
-var IdentityDomainSchema = z.object({
-  /** Why the organization exists — one or two plain-language sentences. */
-  mission: z.string().trim().max(1e3).default(""),
-  /** Long-term direction the organization is moving toward. */
-  vision: z.string().trim().max(1e3).default(""),
-  /** Legal registered name of the entity. */
-  legalName: z.string().trim().max(200).default(""),
-  /**
-   * Type of legal entity (e.g. "LLC", "Corporation", "Sole Proprietor",
-   * "Non-profit"). Free-form string so it covers any jurisdiction.
-   */
-  entityType: z.string().trim().max(100).default(""),
-  /**
-   * Primary jurisdiction of registration or operation
-   * (e.g. "United States – Delaware", "Canada – Ontario").
-   */
-  jurisdiction: z.string().trim().max(200).default(""),
-  /**
-   * Industry category — broad classification (e.g. "Marketing Agency",
-   * "Software / SaaS", "Professional Services").
-   */
-  industryCategory: z.string().trim().max(200).default(""),
-  /**
-   * Geographic focus — where the organization primarily operates or serves
-   * (e.g. "North America", "Global", "Southeast Asia").
-   */
-  geographicFocus: z.string().trim().max(200).default(""),
-  /**
-   * IANA timezone identifier for the organization's primary operating timezone
-   * (e.g. "America/Los_Angeles", "Europe/London", "UTC").
-   */
-  timeZone: z.string().trim().max(100).default("UTC"),
-  /** Typical operating hours per day of week. Empty object means not configured. */
-  businessHours: BusinessHoursSchema,
-  /**
-   * Long-form markdown capturing client context, problem narrative, and domain
-   * background. Populated by /setup; surfaced to agents as organizational context.
-   * Optional — many projects have no external client.
-   */
-  clientBrief: z.string().trim().default("")
-});
-var DEFAULT_ORGANIZATION_MODEL_IDENTITY = {
-  mission: "",
-  vision: "",
-  legalName: "",
-  entityType: "",
-  jurisdiction: "",
-  industryCategory: "",
-  geographicFocus: "",
-  timeZone: "UTC",
-  businessHours: {},
-  clientBrief: ""
-};
-var FirmographicsSchema = z.object({
-  /** Industry vertical (e.g. "Marketing Agency", "Legal", "Real Estate"). */
-  industry: z.string().trim().max(200).optional(),
-  /**
-   * Company headcount band (e.g. "1–10", "11–50", "51–200", "200+").
-   * Free-form string to accommodate any band notation.
-   */
-  companySize: z.string().trim().max(100).optional(),
-  /**
-   * Primary geographic region the segment operates in or is targeted from
-   * (e.g. "North America", "Europe", "Global").
-   */
-  region: z.string().trim().max(200).optional()
-});
-var CustomerSegmentSchema = z.object({
-  /** Stable unique identifier for the segment (e.g. "segment-smb-agencies"). */
-  id: z.string().trim().min(1).max(100),
-  /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
-  order: z.number(),
-  /** Human-readable name shown to agents and in UI (e.g. "SMB Marketing Agencies"). */
-  name: z.string().trim().max(200).default(""),
-  /** One or two sentences describing who this segment is. */
-  description: z.string().trim().max(2e3).default(""),
-  /**
-   * The primary job(s) this segment is trying to get done — the goal they hire
-   * a product/service to accomplish. Plain-language narrative or bullet list.
-   */
-  jobsToBeDone: z.string().trim().max(2e3).default(""),
-  /**
-   * Pains — frustrations, obstacles, and risks the segment experiences
-   * when trying to accomplish their jobs-to-be-done.
-   */
-  pains: z.array(z.string().trim().max(500)).default([]),
-  /**
-   * Gains — outcomes and benefits the segment desires; positive motivators
-   * beyond merely resolving pains.
-   */
-  gains: z.array(z.string().trim().max(500)).default([]),
-  /** Firmographic profile for targeting and filtering. */
-  firmographics: FirmographicsSchema.default({}),
-  /**
-   * Value proposition — one or two sentences stating why this organization's
-   * offering is uniquely suited for this segment's needs.
-   */
-  valueProp: z.string().trim().max(2e3).default("")
-});
-var CustomersDomainSchema = z.record(z.string(), CustomerSegmentSchema).refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
-  message: "Each segment entry id must match its map key"
-}).default({});
-var DEFAULT_ORGANIZATION_MODEL_CUSTOMERS = {};
-var PricingModelSchema = z.enum(["one-time", "subscription", "usage-based", "custom"]).meta({ label: "Pricing model", color: "green" });
-var ProductSchema = z.object({
-  /** Stable unique identifier for the product (e.g. "product-starter-plan"). */
-  id: z.string().trim().min(1).max(100),
-  /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
-  order: z.number(),
-  /** Human-readable name shown to agents and in UI (e.g. "Starter Plan"). */
-  name: z.string().trim().max(200).default(""),
-  /** One or two sentences describing what this product/service delivers. */
-  description: z.string().trim().max(2e3).default(""),
-  /**
-   * How this product is priced:
-   * - "one-time" — single purchase (setup fee, project fee)
-   * - "subscription" — recurring (monthly/annual SaaS, retainer)
-   * - "usage-based" — metered by consumption (API calls, seats)
-   * - "custom" — negotiated or bespoke pricing
-   */
-  pricingModel: PricingModelSchema.default("custom"),
-  /** Base price amount (≥ 0). Currency unit defined by `currency`. */
-  price: z.number().min(0).default(0),
-  /**
-   * ISO 4217 currency code (e.g. "USD", "EUR", "GBP").
-   * Free-form string to accommodate any currency; defaults to "USD".
-   */
-  currency: z.string().trim().max(10).default("USD"),
-  /**
-   * IDs of customer segments this product targets.
-   * Each id must reference a declared `customers.segments[].id`.
-   * Cross-reference enforced in `OrganizationModelSchema.superRefine()`.
-   */
-  targetSegmentIds: z.array(z.string().trim().min(1)).default([]),
-  /**
-   * Optional: ID of the platform system responsible for delivering this product.
-   * When present, must reference a declared `systems.systems[].id`.
-   * Cross-reference enforced in `OrganizationModelSchema.superRefine()`.
-   */
-  deliveryFeatureId: z.string().trim().min(1).optional()
-});
-var OfferingsDomainSchema = z.record(z.string(), ProductSchema).refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
-  message: "Each product entry id must match its map key"
-}).default({});
-var DEFAULT_ORGANIZATION_MODEL_OFFERINGS = {};
-var OntologyKindSchema = z.enum([
-  "object",
-  "link",
-  "action",
-  "catalog",
-  "event",
-  "interface",
-  "value-type",
-  "property",
-  "group",
-  "surface"
-]);
-var SYSTEM_PATH_PATTERN = "[a-z0-9][a-z0-9-]*(?:\\.[a-z0-9][a-z0-9-]*)*";
-var LOCAL_ID_PATTERN = "[a-z0-9][a-z0-9._-]*";
-var ONTOLOGY_ID_PATTERN = `^(global|${SYSTEM_PATH_PATTERN}):(${OntologyKindSchema.options.join("|")})\\/(${LOCAL_ID_PATTERN})$`;
-var ONTOLOGY_ID_REGEX = new RegExp(ONTOLOGY_ID_PATTERN);
-var OntologyIdSchema = z.string().trim().min(1).max(300).regex(
-  ONTOLOGY_ID_REGEX,
-  "Ontology IDs must use <system-path>:<kind>/<local-id> or global:<kind>/<local-id>"
-);
-function parseOntologyId(id) {
-  const normalized = OntologyIdSchema.parse(id);
-  const match = ONTOLOGY_ID_REGEX.exec(normalized);
-  if (match === null) {
-    throw new Error(`Invalid ontology ID "${id}"`);
-  }
-  return {
-    id: normalized,
-    scope: match[1],
-    kind: match[2],
-    localId: match[3],
-    isGlobal: match[1] === "global"
-  };
-}
-function formatOntologyId(input) {
-  return OntologyIdSchema.parse(`${input.scope}:${input.kind}/${input.localId}`);
-}
-var OntologyReferenceListSchema = z.array(OntologyIdSchema).default([]).optional();
-var OntologyRecordBaseSchema = z.object({
-  id: OntologyIdSchema,
-  label: z.string().trim().min(1).max(160).optional(),
-  description: z.string().trim().min(1).max(2e3).optional(),
-  ownerSystemId: z.string().trim().min(1).max(200).optional(),
-  aliases: z.array(OntologyIdSchema).optional()
-}).passthrough();
-var OntologyObjectTypeSchema = OntologyRecordBaseSchema.extend({
-  properties: z.record(z.string().trim().min(1).max(200), z.unknown()).optional(),
-  storage: z.record(z.string(), z.unknown()).optional()
-});
-var OntologyLinkTypeSchema = OntologyRecordBaseSchema.extend({
-  from: OntologyIdSchema,
-  to: OntologyIdSchema,
-  cardinality: z.string().trim().min(1).max(80).optional(),
-  via: z.string().trim().min(1).max(255).optional()
-});
-var OntologyActionTypeSchema = OntologyRecordBaseSchema.extend({
-  actsOn: OntologyReferenceListSchema,
-  input: z.record(z.string().trim().min(1).max(200), z.unknown()).optional(),
-  effects: z.array(z.record(z.string(), z.unknown())).optional()
-});
-var OntologyCatalogTypeSchema = OntologyRecordBaseSchema.extend({
-  kind: z.string().trim().min(1).max(120).optional(),
-  appliesTo: OntologyIdSchema.optional(),
-  entries: z.record(z.string().trim().min(1).max(200), z.unknown()).optional()
-});
-var OntologyEventTypeSchema = OntologyRecordBaseSchema.extend({
-  payload: z.record(z.string().trim().min(1).max(200), z.unknown()).optional()
-});
-var OntologyInterfaceTypeSchema = OntologyRecordBaseSchema.extend({
-  properties: z.record(z.string().trim().min(1).max(200), z.unknown()).optional()
-});
-var OntologyValueTypeSchema = OntologyRecordBaseSchema.extend({
-  primitive: z.string().trim().min(1).max(120).optional()
-});
-var OntologySharedPropertySchema = OntologyRecordBaseSchema.extend({
-  valueType: OntologyIdSchema.optional(),
-  searchable: z.boolean().optional(),
-  pii: z.boolean().optional()
-});
-var OntologyGroupSchema = OntologyRecordBaseSchema.extend({
-  members: OntologyReferenceListSchema
-});
-var OntologySurfaceTypeSchema = OntologyRecordBaseSchema.extend({
-  route: z.string().trim().min(1).max(500).optional()
-});
-var OntologyScopeSchema = z.object({
-  objectTypes: z.record(OntologyIdSchema, OntologyObjectTypeSchema).default({}).optional(),
-  linkTypes: z.record(OntologyIdSchema, OntologyLinkTypeSchema).default({}).optional(),
-  actionTypes: z.record(OntologyIdSchema, OntologyActionTypeSchema).default({}).optional(),
-  catalogTypes: z.record(OntologyIdSchema, OntologyCatalogTypeSchema).default({}).optional(),
-  eventTypes: z.record(OntologyIdSchema, OntologyEventTypeSchema).default({}).optional(),
-  interfaceTypes: z.record(OntologyIdSchema, OntologyInterfaceTypeSchema).default({}).optional(),
-  valueTypes: z.record(OntologyIdSchema, OntologyValueTypeSchema).default({}).optional(),
-  sharedProperties: z.record(OntologyIdSchema, OntologySharedPropertySchema).default({}).optional(),
-  groups: z.record(OntologyIdSchema, OntologyGroupSchema).default({}).optional(),
-  surfaces: z.record(OntologyIdSchema, OntologySurfaceTypeSchema).default({}).optional()
-}).default({});
-var DEFAULT_ONTOLOGY_SCOPE = {
-  valueTypes: {
-    "global:value-type/uuid": {
-      id: "global:value-type/uuid",
-      label: "UUID",
-      primitive: "string"
-    },
-    "global:value-type/text": {
-      id: "global:value-type/text",
-      label: "Text",
-      primitive: "string"
-    },
-    "global:value-type/url": {
-      id: "global:value-type/url",
-      label: "URL",
-      primitive: "string"
-    },
-    "global:value-type/email": {
-      id: "global:value-type/email",
-      label: "Email",
-      primitive: "string"
-    }
-  }
-};
-var SCOPE_KIND = {
-  objectTypes: "object",
-  linkTypes: "link",
-  actionTypes: "action",
-  catalogTypes: "catalog",
-  eventTypes: "event",
-  interfaceTypes: "interface",
-  valueTypes: "value-type",
-  sharedProperties: "property",
-  groups: "group",
-  surfaces: "surface"
-};
-var SCOPE_KEYS = Object.keys(SCOPE_KIND);
-function listResolvedOntologyRecords(index2) {
-  return SCOPE_KEYS.flatMap((scopeKey) => {
-    const kind = SCOPE_KIND[scopeKey];
-    return Object.entries(index2[scopeKey]).sort(([leftId], [rightId]) => leftId.localeCompare(rightId)).map(([id, record]) => ({
-      id,
-      kind,
-      record
-    }));
-  });
-}
-function originFromContext(context) {
-  return {
-    kind: context.kind,
-    source: context.source,
-    path: context.path,
-    ...context.systemPath !== void 0 ? { systemPath: context.systemPath } : {},
-    ...context.legacyId !== void 0 ? { legacyId: context.legacyId } : {}
-  };
-}
-function createEmptyIndex() {
-  return {
-    objectTypes: {},
-    linkTypes: {},
-    actionTypes: {},
-    catalogTypes: {},
-    eventTypes: {},
-    interfaceTypes: {},
-    valueTypes: {},
-    sharedProperties: {},
-    groups: {},
-    surfaces: {}
-  };
-}
-function sortResolvedOntologyIndex(index2) {
-  const sorted = createEmptyIndex();
-  for (const scopeKey of SCOPE_KEYS) {
-    const target = sorted[scopeKey];
-    for (const [id, record] of Object.entries(index2[scopeKey]).sort(
-      ([leftId], [rightId]) => leftId.localeCompare(rightId)
-    )) {
-      target[id] = record;
-    }
-  }
-  return sorted;
-}
-function childSystemsOf(system) {
-  return system.systems ?? system.subsystems ?? {};
-}
-function addRecord(index2, diagnostics, sourcesById, scopeKey, record, context) {
-  let parsed;
-  try {
-    parsed = parseOntologyId(record.id);
-  } catch {
-    diagnostics.push({
-      code: "invalid_ontology_id",
-      message: `Invalid ontology ID "${record.id}" from ${context.source} at ${context.path.join(".")}`,
-      id: record.id,
-      path: context.path,
-      source: context.source,
-      origin: originFromContext(context)
-    });
-    return;
-  }
-  const expectedKind = SCOPE_KIND[scopeKey];
-  if (parsed.kind !== expectedKind) {
-    diagnostics.push({
-      code: "ontology_kind_mismatch",
-      message: `Ontology ID "${record.id}" has kind "${parsed.kind}" but was authored in ${scopeKey} (${expectedKind}) at ${context.path.join(".")}`,
-      id: record.id,
-      path: context.path,
-      source: context.source,
-      origin: originFromContext(context)
-    });
-    return;
-  }
-  const existing = sourcesById.get(parsed.id);
-  if (existing !== void 0) {
-    diagnostics.push({
-      code: "duplicate_ontology_id",
-      message: `Duplicate ontology ID "${parsed.id}" from ${context.source} at ${context.path.join(".")} conflicts with ${existing.source} at ${existing.path.join(".")}`,
-      id: parsed.id,
-      path: context.path,
-      source: context.source,
-      origin: originFromContext(context),
-      existingSource: existing.source,
-      existingOrigin: originFromContext(existing)
-    });
-    return;
-  }
-  sourcesById.set(parsed.id, context);
-  index2[scopeKey][parsed.id] = {
-    ...record,
-    origin: originFromContext(context)
-  };
-}
-function addScope(index2, diagnostics, sourcesById, scope, source, path) {
-  if (scope === void 0) return;
-  for (const scopeKey of SCOPE_KEYS) {
-    const records = scope[scopeKey] ?? {};
-    for (const [key, record] of Object.entries(records)) {
-      addRecord(index2, diagnostics, sourcesById, scopeKey, record, {
-        source,
-        path: [...path, scopeKey, key],
-        kind: "authored",
-        systemPath: source.startsWith("system:") ? source.slice("system:".length, -".ontology".length) : void 0
-      });
-    }
-  }
-}
-function legacyObjectId(entity) {
-  return formatOntologyId({ scope: entity.ownedBySystemId, kind: "object", localId: entity.id });
-}
-function legacyActionOwner(action, entities) {
-  const firstAffectedEntityId = action.affects?.find((entityId) => entities[entityId] !== void 0);
-  if (firstAffectedEntityId !== void 0) {
-    return entities[firstAffectedEntityId].ownedBySystemId;
-  }
-  if (typeof action.scope === "object") {
-    return action.scope.domain;
-  }
-  return "global";
-}
-function addLegacyEntityProjections(index2, diagnostics, sourcesById, entities) {
-  for (const entity of Object.values(entities)) {
-    const objectType = {
-      id: legacyObjectId(entity),
-      label: entity.label,
-      description: entity.description,
-      ownerSystemId: entity.ownedBySystemId,
-      ...entity.table !== void 0 ? {
-        storage: {
-          kind: "table",
-          table: entity.table
-        }
-      } : {},
-      ...entity.rowSchema !== void 0 ? { rowSchema: entity.rowSchema } : {},
-      ...entity.stateCatalogId !== void 0 ? { stateCatalogId: entity.stateCatalogId } : {}
-    };
-    addRecord(index2, diagnostics, sourcesById, "objectTypes", objectType, {
-      source: "legacy.entities",
-      path: ["entities", entity.id],
-      kind: "projected",
-      systemPath: entity.ownedBySystemId,
-      legacyId: entity.id
-    });
-    entity.links?.forEach((link, linkIndex) => {
-      const targetEntity = entities[link.toEntity];
-      if (targetEntity === void 0) return;
-      const linkType = {
-        id: formatOntologyId({
-          scope: entity.ownedBySystemId,
-          kind: "link",
-          localId: `${entity.id}-${link.toEntity}-${linkIndex}`
-        }),
-        label: link.label ?? link.kind,
-        ownerSystemId: entity.ownedBySystemId,
-        from: legacyObjectId(entity),
-        to: legacyObjectId(targetEntity),
-        cardinality: link.kind,
-        ...link.via !== void 0 ? { via: link.via } : {}
-      };
-      addRecord(index2, diagnostics, sourcesById, "linkTypes", linkType, {
-        source: "legacy.entities.links",
-        path: ["entities", entity.id, "links", linkIndex],
-        kind: "projected",
-        systemPath: entity.ownedBySystemId,
-        legacyId: `${entity.id}.links.${linkIndex}`
-      });
-    });
-  }
-}
-function addLegacyActionProjections(index2, diagnostics, sourcesById, actions, entities) {
-  for (const action of Object.values(actions)) {
-    const ownerSystemId = legacyActionOwner(action, entities);
-    const actionType = {
-      id: formatOntologyId({ scope: ownerSystemId, kind: "action", localId: action.id }),
-      label: action.label,
-      description: action.description,
-      ownerSystemId,
-      actsOn: action.affects?.map((entityId) => entities[entityId] ? legacyObjectId(entities[entityId]) : void 0).filter((id) => id !== void 0),
-      ...action.resourceId !== void 0 ? { resourceId: action.resourceId } : {},
-      ...action.invocations !== void 0 ? { invocations: action.invocations } : {},
-      ...action.lifecycle !== void 0 ? { lifecycle: action.lifecycle } : {},
-      legacyActionId: action.id
-    };
-    addRecord(index2, diagnostics, sourcesById, "actionTypes", actionType, {
-      source: "legacy.actions",
-      path: ["actions", action.id],
-      kind: "projected",
-      systemPath: ownerSystemId,
-      legacyId: action.id
-    });
-  }
-}
-function addSystemScopes(index2, diagnostics, sourcesById, systems, prefix, schemaPath) {
-  for (const [key, system] of Object.entries(systems)) {
-    const systemPath = prefix ? `${prefix}.${key}` : key;
-    const currentPath = [...schemaPath, key];
-    addScope(index2, diagnostics, sourcesById, system.ontology, `system:${systemPath}.ontology`, [
-      ...currentPath,
-      "ontology"
-    ]);
-    addSystemScopes(index2, diagnostics, sourcesById, childSystemsOf(system), systemPath, [
-      ...currentPath,
-      system.systems !== void 0 ? "systems" : "subsystems"
-    ]);
-  }
-}
-function compileOrganizationOntology(model) {
-  const ontology = createEmptyIndex();
-  const diagnostics = [];
-  const sourcesById = /* @__PURE__ */ new Map();
-  addScope(ontology, diagnostics, sourcesById, model.ontology, "organization.ontology", ["ontology"]);
-  addSystemScopes(ontology, diagnostics, sourcesById, model.systems ?? {}, "", ["systems"]);
-  addLegacyEntityProjections(ontology, diagnostics, sourcesById, model.entities ?? {});
-  addLegacyActionProjections(ontology, diagnostics, sourcesById, model.actions ?? {}, model.entities ?? {});
-  return { ontology: sortResolvedOntologyIndex(ontology), diagnostics };
-}
-
-// ../core/src/organization-model/domains/systems.ts
-var SystemKindSchema = z.enum(["product", "operational", "platform", "diagnostic"]).meta({ label: "System kind", color: "blue" });
-var SystemLifecycleSchema = z.enum(["draft", "beta", "active", "deprecated", "archived"]).meta({ label: "Lifecycle", color: "teal" });
-var SystemStatusSchema = z.enum(["active", "deprecated", "archived"]).meta({ label: "Status", color: "teal" });
-var SystemIdSchema = ModelIdSchema;
-var SystemPathSchema = z.string().trim().min(1).regex(
-  /^[a-z0-9][a-z0-9-]*(?:\.[a-z0-9][a-z0-9-]*)*$/,
-  'must be a dotted lowercase path (e.g. "sales.lead-gen" or "sales.crm")'
-);
-var UiPositionSchema = z.enum(["sidebar-primary", "sidebar-bottom"]).meta({ label: "UI position" });
-var NodeIdStringSchema = z.string().trim().min(1).max(200).regex(
-  /^[a-z][a-z-]*:([a-z0-9-]+)(\.[a-z0-9-]+)*(:[a-z0-9.-]+)*$/,
-  "Node references must use kind:dotted-path (e.g. system:sales.crm or resource:lead-gen.company.qualify)"
-);
-var SystemUiSchema = z.object({
-  path: PathSchema,
-  surfaces: ReferenceIdsSchema,
-  icon: IconNameSchema.optional(),
-  order: z.number().int().optional()
-});
-var JsonValueSchema = z.lazy(
-  () => z.union([
-    z.string(),
-    z.number(),
-    z.boolean(),
-    z.null(),
-    z.array(JsonValueSchema),
-    z.record(z.string(), JsonValueSchema)
-  ])
-);
-var SystemConfigSchema = z.record(z.string().trim().min(1).max(200), JsonValueSchema).default({}).optional();
-var SystemEntrySchema = z.object({
-  /** Stable tenant-defined system id (e.g. "sys.lead-gen" or "sales.crm"). */
-  id: SystemIdSchema,
-  /** Human-readable system label shown in UI, governance, and operations surfaces. */
-  label: LabelSchema.optional(),
-  /** @deprecated Use label. Accepted for pre-consolidation System declarations. */
-  title: LabelSchema.optional(),
-  /** One-paragraph purpose statement for the bounded context. */
-  description: DescriptionSchema.optional(),
-  /** Closed system shape enum; catalog values remain tenant-defined. */
-  kind: SystemKindSchema.optional(),
-  /** Optional self-reference for System hierarchy. */
-  parentSystemId: SystemIdSchema.optional(),
-  /** Optional UI presence. Systems without UI omit this. */
-  ui: SystemUiSchema.optional(),
-  /** Canonical lifecycle state. Replaces Feature.enabled/devOnly and System.status. */
-  lifecycle: SystemLifecycleSchema.optional(),
-  /** Optional role responsible for this system. */
-  responsibleRoleId: ModelIdSchema.meta({ ref: "role" }).optional(),
-  /** Optional knowledge nodes that govern this system. */
-  governedByKnowledge: z.array(ModelIdSchema.meta({ ref: "knowledge" })).default([]).optional(),
-  /** Optional actions this system exposes or consumes. */
-  actions: z.array(ActionRefSchema).optional(),
-  /** Optional operational policies that apply to this system. */
-  policies: z.array(ModelIdSchema.meta({ ref: "policy" })).default([]).optional(),
-  /** Optional goals this system contributes to. */
-  drivesGoals: z.array(ModelIdSchema.meta({ ref: "goal" })).default([]).optional(),
-  /** @deprecated Use lifecycle. Accepted for one publish cycle. */
-  status: SystemStatusSchema.optional(),
-  /** @deprecated Use ui.path. Kept for one-cycle Feature compatibility. */
-  path: PathSchema.optional(),
-  /** @deprecated Use ui.icon. Kept for one-cycle Feature compatibility. */
-  icon: IconNameSchema.optional(),
-  /** @deprecated Feature color token, retained for one-cycle compatibility. */
-  color: ColorTokenSchema.optional(),
-  /** @deprecated UI placement hint, retained for one-cycle compatibility. */
-  uiPosition: UiPositionSchema.optional(),
-  /** @deprecated Use lifecycle. */
-  enabled: z.boolean().optional(),
-  /** @deprecated Use lifecycle: "beta". */
-  devOnly: z.boolean().optional(),
-  requiresAdmin: z.boolean().optional(),
-  /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
-  order: z.number(),
-  /**
-   * System-local JSON settings and defaults. Strongly typed OM fields,
-   * secrets, credentials, and runtime state stay outside this bucket.
-   */
-  config: SystemConfigSchema,
-  /**
-   * System-owned ontology declarations. `systems` is now the canonical child
-   * key; this scope holds the object, action, catalog, link, event, and
-   * shared contract records owned by this system.
-   */
-  ontology: OntologyScopeSchema.optional(),
-  /**
-   * Recursive child systems, authored via nesting (per L11).
-   * The key is the local system id; the full path is computed by joining
-   * ancestor keys with `.` (e.g. parent key `'sales'` + child key `'crm'` → `'sales.crm'`).
-   * Per Phase 4: `id` and `parentSystemId` fields will be removed in favour of
-   * position-derived paths. Both still exist on this schema for backward compat.
-   */
-  systems: z.lazy(() => z.record(z.string().trim().min(1).max(100), SystemEntrySchema)).optional(),
-  /** @deprecated Use systems. Accepted as a compatibility alias during the ontology bridge. */
-  subsystems: z.lazy(() => z.record(z.string().trim().min(1).max(100), SystemEntrySchema)).optional()
-}).strict().refine((system) => system.label !== void 0 || system.title !== void 0, {
-  path: ["label"],
-  message: "System must provide label or title"
-}).transform((system) => {
-  const normalizedSystem = system.systems !== void 0 && system.subsystems === void 0 ? { ...system, subsystems: system.systems } : system;
-  if (normalizedSystem.status === void 0) return normalizedSystem;
-  console.warn("[organization-model] System.status is deprecated; use System.lifecycle instead.");
-  return normalizedSystem.lifecycle === void 0 ? { ...normalizedSystem, lifecycle: normalizedSystem.status } : normalizedSystem;
-});
-var SystemsDomainSchema = z.record(z.string(), SystemEntrySchema).refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
-  message: "Each system entry id must match its map key"
-}).default({});
-var DEFAULT_ORGANIZATION_MODEL_SYSTEMS = {};
-
-// ../core/src/organization-model/domains/resources.ts
-var ContractRefSchema = z.string().trim().min(1).max(500).regex(
-  /^[A-Za-z0-9@](?:[A-Za-z0-9_./@-]*[A-Za-z0-9_])?\/?[A-Za-z0-9_./@-]*#[A-Za-z_$][A-Za-z0-9_$]*$/,
-  "ContractRef must be in the format package/subpath#ExportName (e.g. @repo/elevasis-core/contracts/apollo-import#inputSchema)"
-);
-z.enum(["workflow", "agent", "integration", "script"]).meta({ label: "Resource kind", color: "orange" });
-var ResourceGovernanceStatusSchema = z.enum(["active", "deprecated", "archived"]).meta({ label: "Governance status", color: "teal" });
-var AgentKindSchema = z.enum(["orchestrator", "specialist", "utility", "platform"]).meta({ label: "Agent kind", color: "violet" });
-var ScriptResourceLanguageSchema = z.enum(["shell", "sql", "typescript", "python"]).meta({ label: "Language" });
-var CodeReferenceRoleSchema = z.enum(["entrypoint", "handler", "schema", "test", "docs", "config"]).meta({ label: "Code reference role", color: "blue" });
-var ResourceIdSchema = z.string().trim().min(1).max(255).regex(/^[A-Za-z0-9]+(?:[-._][A-Za-z0-9]+)*$/, "Resource IDs must use letters, numbers, -, _, or . separators");
-var EventIdSchema = z.string().trim().min(1).max(300).regex(
-  /^[A-Za-z0-9]+(?:[-._][A-Za-z0-9]+)*:[a-z0-9]+(?:[-._][a-z0-9]+)*$/,
-  "Event IDs must use <owner-id>:<event-key>"
-);
-var EventKeySchema = ModelIdSchema;
-var EventEmissionDescriptorSchema = z.object({
-  eventKey: EventKeySchema,
-  label: z.string().trim().min(1).max(120),
-  payloadSchema: ModelIdSchema.optional(),
-  lifecycle: SystemLifecycleSchema.optional()
-});
-EventEmissionDescriptorSchema.extend({
-  id: EventIdSchema,
-  ownerId: z.union([ResourceIdSchema, ModelIdSchema]),
-  ownerKind: z.enum(["resource", "entity"]).meta({ label: "Owner kind" })
-});
-var ResourceOntologyBindingSchema = z.object({
-  actions: z.array(OntologyIdSchema).optional(),
-  primaryAction: OntologyIdSchema.optional(),
-  reads: z.array(OntologyIdSchema).optional(),
-  writes: z.array(OntologyIdSchema).optional(),
-  usesCatalogs: z.array(OntologyIdSchema).optional(),
-  emits: z.array(OntologyIdSchema).optional(),
-  /**
-   * Optional typed contract binding for this resource's workflow I/O.
-   * Each ref is a `package/subpath#ExportName` string that resolves to a
-   * Zod schema in `@repo/elevasis-core` (or the consumer's equivalent package).
-   *
-   * Absence of this field preserves all existing behavior — it is additive + optional.
-   * Tier-1 validation (schema.ts): ref-string shape only (browser-safe, no imports).
-   * Tier-2 validation (om:verify): intra-package typed-map resolution asserts ZodType.
-   */
-  contract: z.object({
-    input: ContractRefSchema.optional(),
-    output: ContractRefSchema.optional()
-  }).optional()
-}).superRefine((binding, ctx) => {
-  if (binding.primaryAction === void 0) return;
-  if (binding.actions?.includes(binding.primaryAction)) return;
-  ctx.addIssue({
-    code: z.ZodIssueCode.custom,
-    path: ["primaryAction"],
-    message: "Resource ontology primaryAction must be included in actions"
-  });
-});
-var CodeReferenceSchema = z.object({
-  path: z.string().trim().min(1).max(500).regex(/^[A-Za-z0-9_./$@()[\] -]+$/, "Code reference paths must be repo-relative paths"),
-  role: CodeReferenceRoleSchema,
-  symbol: z.string().trim().min(1).max(200).optional(),
-  description: z.string().trim().min(1).max(300).optional()
-});
-var ResourceEntryBaseSchema = z.object({
-  /** Canonical resource id; runtime resourceId derives from this value. */
-  id: ResourceIdSchema,
-  /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
-  order: z.number().default(0),
-  /** Required single System membership — value is a dot-separated system path (e.g. "sales.lead-gen"). */
-  systemPath: SystemPathSchema.meta({ ref: "system" }),
-  /** Executable display title owned by the OM Resource descriptor. */
-  title: LabelSchema.optional(),
-  /** Executable display description owned by the OM Resource descriptor. */
-  description: DescriptionSchema.optional(),
-  /** Optional role responsible for maintaining this resource. */
-  ownerRoleId: ModelIdSchema.meta({ ref: "role" }).optional(),
-  status: ResourceGovernanceStatusSchema,
-  /**
-   * Ontology contract bindings for the semantic work this resource performs.
-   * `emits` stays nested here so top-level resource emits descriptors remain
-   * compatible with graph event projection during the bridge.
-   */
-  ontology: ResourceOntologyBindingSchema.optional(),
-  /** Repo-relative implementation breadcrumbs for agents and operators. */
-  codeRefs: z.array(CodeReferenceSchema).default([])
-});
-var WorkflowResourceEntrySchema = ResourceEntryBaseSchema.extend({
-  kind: z.literal("workflow"),
-  emits: z.array(EventEmissionDescriptorSchema).optional()
-});
-var AgentResourceEntrySchema = ResourceEntryBaseSchema.extend({
-  kind: z.literal("agent"),
-  /** Mirrors code-side AgentConfig.kind. */
-  agentKind: AgentKindSchema,
-  /** Role this agent embodies, if any. */
-  actsAsRoleId: ModelIdSchema.meta({ ref: "role" }).optional(),
-  /** Mirrors AgentConfig.sessionCapable. */
-  sessionCapable: z.boolean(),
-  /** Broad/composite callable entry points orchestrated by this agent. */
-  invocations: z.array(ActionInvocationSchema).default([]),
-  emits: z.array(EventEmissionDescriptorSchema).optional()
-});
-var IntegrationResourceEntrySchema = ResourceEntryBaseSchema.extend({
-  kind: z.literal("integration"),
-  provider: z.string().trim().min(1).max(100)
-});
-var ScriptResourceSourceSchema = z.union([
-  z.string().trim().min(1).max(5e4),
-  z.object({
-    file: z.string().trim().min(1).max(500)
-  })
-]);
-var ScriptResourceEntrySchema = ResourceEntryBaseSchema.extend({
-  kind: z.literal("script"),
-  language: ScriptResourceLanguageSchema,
-  source: ScriptResourceSourceSchema
-});
-var ResourceEntrySchema = z.discriminatedUnion("kind", [
-  WorkflowResourceEntrySchema,
-  AgentResourceEntrySchema,
-  IntegrationResourceEntrySchema,
-  ScriptResourceEntrySchema
-]);
-var ResourcesDomainSchema = z.record(z.string(), ResourceEntrySchema).refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
-  message: "Each resource entry id must match its map key"
-}).default({});
-var DEFAULT_ORGANIZATION_MODEL_RESOURCES = {};
-
-// ../core/src/organization-model/domains/roles.ts
-var RoleIdSchema = ModelIdSchema;
-var HumanRoleHolderSchema = z.object({
-  kind: z.literal("human"),
-  userId: z.string().trim().min(1).max(200)
-});
-var AgentRoleHolderSchema = z.object({
-  kind: z.literal("agent"),
-  agentId: ResourceIdSchema.meta({ ref: "resource" })
-});
-var TeamRoleHolderSchema = z.object({
-  kind: z.literal("team"),
-  memberIds: z.array(z.string().trim().min(1).max(200)).min(1)
-});
-var RoleHolderSchema = z.discriminatedUnion("kind", [
-  HumanRoleHolderSchema,
-  AgentRoleHolderSchema,
-  TeamRoleHolderSchema
-]);
-var RoleHoldersSchema = z.union([RoleHolderSchema, z.array(RoleHolderSchema).min(1)]);
-var RoleSchema = z.object({
-  /** Stable unique identifier for the role (e.g. "role-ceo", "role-head-of-sales"). */
-  id: RoleIdSchema,
-  /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
-  order: z.number(),
-  /** Human-readable title shown to agents and in UI (e.g. "CEO", "Head of Sales"). */
-  title: z.string().trim().min(1).max(200),
-  /**
-   * List of responsibilities this role owns - plain-language descriptions of
-   * what the person in this role is accountable for delivering.
-   * Defaults to empty array so minimal role definitions stay concise.
-   */
-  responsibilities: z.array(z.string().trim().max(500)).default([]),
-  /**
-   * Optional: ID of another role this role reports to.
-   * When present, must reference another `roles[].id` in the same organization.
-   */
-  reportsToId: RoleIdSchema.meta({ ref: "role" }).optional(),
-  /**
-   * Optional: human, agent, or team holder currently filling this role.
-   * Agent holders reference OM Resource IDs and are validated at the model level.
-   */
-  heldBy: RoleHoldersSchema.optional(),
-  /**
-   * Optional Systems this role is accountable for.
-   * Cross-reference enforced in `OrganizationModelSchema.superRefine()`.
-   */
-  responsibleFor: z.array(SystemIdSchema.meta({ ref: "system" })).optional()
-});
-var RolesDomainSchema = z.record(z.string(), RoleSchema).refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
-  message: "Each role entry id must match its map key"
-}).default({});
-var DEFAULT_ORGANIZATION_MODEL_ROLES = {};
-var KeyResultSchema = z.object({
-  /** Stable unique identifier for the measurable outcome (e.g. "kr-revenue-q1"). */
-  id: z.string().trim().min(1).max(100),
-  /** Plain-language description of this measurable outcome (e.g. "Increase trial-to-paid conversion"). */
-  description: z.string().trim().min(1).max(500),
-  /**
-   * What is being measured — the metric name (e.g. "monthly revenue", "NPS score",
-   * "trial-to-paid conversion rate"). Free-form string.
-   */
-  targetMetric: z.string().trim().min(1).max(200),
-  /** Current measured value. Defaults to 0 when not yet tracked. */
-  currentValue: z.number().default(0),
-  /**
-   * Target value to reach for this measurable outcome to be considered achieved.
-   * Optional — omit if the outcome is directional (e.g. "reduce churn") without
-   * a hard numeric target.
-   */
-  targetValue: z.number().optional()
-});
-var ISO_DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
-var ObjectiveSchema = z.object({
-  /** Stable unique identifier for the goal (e.g. "goal-grow-arr-q1-2026"). */
-  id: z.string().trim().min(1).max(100),
-  /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
-  order: z.number(),
-  /** Plain-language description of what the organization wants to achieve. */
-  description: z.string().trim().min(1).max(1e3),
-  /**
-   * Start of the period this goal is active for — ISO 8601 date string (YYYY-MM-DD).
-   * Must be strictly before `periodEnd`.
-   */
-  periodStart: z.string().regex(ISO_DATE_REGEX, "periodStart must be an ISO date string (YYYY-MM-DD)"),
-  /**
-   * End of the period this goal is active for — ISO 8601 date string (YYYY-MM-DD).
-   * Must be strictly after `periodStart`.
-   * Enforced via `OrganizationModelSchema.superRefine()`.
-   */
-  periodEnd: z.string().regex(ISO_DATE_REGEX, "periodEnd must be an ISO date string (YYYY-MM-DD)"),
-  /**
-   * List of measurable outcomes that define success for this goal.
-   * Defaults to empty array so goals can be declared before outcomes are defined.
-   */
-  keyResults: z.array(KeyResultSchema).default([])
-});
-var GoalsDomainSchema = z.record(z.string(), ObjectiveSchema).refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
-  message: "Each objective entry id must match its map key"
-}).default({});
-var DEFAULT_ORGANIZATION_MODEL_GOALS = {};
-var SecretLikeMetadataKeySchema = /(?:secret|password|passwd|token|api[-_]?key|credential|private[-_]?key)/i;
-var SecretLikeMetadataValueSchema = /(?:sk-[A-Za-z0-9_-]{12,}|pk_live_[A-Za-z0-9_-]{12,}|eyJ[A-Za-z0-9_-]{20,}|-----BEGIN (?:RSA |OPENSSH |EC )?PRIVATE KEY-----)/;
-z.enum([
-  "system",
-  "resource",
-  "ontology",
-  "policy",
-  "role",
-  "trigger",
-  "humanCheckpoint",
-  "externalResource"
-]);
-var OmTopologyRelationshipKindSchema = z.enum(["triggers", "uses", "approval"]);
-var OmTopologyNodeRefSchema = z.discriminatedUnion("kind", [
-  z.object({ kind: z.literal("system"), id: ModelIdSchema }),
-  z.object({ kind: z.literal("resource"), id: ResourceIdSchema }),
-  z.object({ kind: z.literal("ontology"), id: OntologyIdSchema }),
-  z.object({ kind: z.literal("policy"), id: ModelIdSchema }),
-  z.object({ kind: z.literal("role"), id: ModelIdSchema }),
-  z.object({ kind: z.literal("trigger"), id: ResourceIdSchema }),
-  z.object({ kind: z.literal("humanCheckpoint"), id: ResourceIdSchema }),
-  z.object({ kind: z.literal("externalResource"), id: ResourceIdSchema })
-]);
-var OmTopologyMetadataSchema = z.record(z.string().trim().min(1).max(120), JsonValueSchema).superRefine((metadata, ctx) => {
-  function visit(value, path) {
-    if (typeof value === "string" && SecretLikeMetadataValueSchema.test(value)) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        path,
-        message: "Topology metadata must not contain secret-like values"
-      });
-      return;
-    }
-    if (Array.isArray(value)) {
-      value.forEach((entry, index2) => visit(entry, [...path, index2]));
-      return;
-    }
-    if (typeof value !== "object" || value === null) return;
-    Object.entries(value).forEach(([key, entry]) => {
-      if (SecretLikeMetadataKeySchema.test(key)) {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          path: [...path, key],
-          message: `Topology metadata key "${key}" looks secret-like`
-        });
-      }
-      visit(entry, [...path, key]);
-    });
-  }
-  visit(metadata, []);
-});
-var OmTopologyRelationshipSchema = z.object({
-  from: OmTopologyNodeRefSchema,
-  kind: OmTopologyRelationshipKindSchema,
-  to: OmTopologyNodeRefSchema,
-  systemPath: SystemPathSchema.optional(),
-  required: z.boolean().optional(),
-  metadata: OmTopologyMetadataSchema.optional()
-});
-var OmTopologyDomainSchema = z.object({
-  version: z.literal(1).default(1),
-  relationships: z.record(z.string().trim().min(1).max(255), OmTopologyRelationshipSchema).default({})
-}).default({ version: 1, relationships: {} });
-var DEFAULT_ORGANIZATION_MODEL_TOPOLOGY = {
-  version: 1,
-  relationships: {}
-};
-var PolicyIdSchema = ModelIdSchema;
-var PolicyApplicabilitySchema = z.object({
-  systemIds: z.array(ModelIdSchema.meta({ ref: "system" })).default([]),
-  actionIds: z.array(ModelIdSchema.meta({ ref: "action" })).default([]),
-  resourceIds: z.array(ModelIdSchema.meta({ ref: "resource" })).default([]),
-  roleIds: z.array(ModelIdSchema.meta({ ref: "role" })).default([])
-});
-var PolicyTriggerSchema = z.discriminatedUnion("kind", [
-  z.object({
-    kind: z.literal("event"),
-    eventId: EventIdSchema.meta({ ref: "event" })
-  }),
-  z.object({
-    kind: z.literal("action-invocation"),
-    actionId: ModelIdSchema.meta({ ref: "action" })
-  }),
-  z.object({
-    kind: z.literal("schedule"),
-    cron: z.string().trim().min(1).max(120)
-  }),
-  z.object({
-    kind: z.literal("manual")
-  })
-]);
-var PolicyPredicateSchema = z.discriminatedUnion("kind", [
-  z.object({
-    kind: z.literal("always")
-  }),
-  z.object({
-    kind: z.literal("expression"),
-    expression: z.string().trim().min(1).max(2e3)
-  }),
-  z.object({
-    kind: z.literal("threshold"),
-    metric: ModelIdSchema,
-    operator: z.enum(["lt", "lte", "eq", "gte", "gt"]).meta({ label: "Operator" }),
-    value: z.number()
-  })
-]);
-var PolicyEffectSchema = z.discriminatedUnion("kind", [
-  z.object({
-    kind: z.literal("require-approval"),
-    roleId: ModelIdSchema.meta({ ref: "role" }).optional()
-  }),
-  z.object({
-    kind: z.literal("invoke-action"),
-    actionId: ModelIdSchema.meta({ ref: "action" })
-  }),
-  z.object({
-    kind: z.literal("notify-role"),
-    roleId: ModelIdSchema.meta({ ref: "role" })
-  }),
-  z.object({
-    kind: z.literal("block")
-  })
-]);
-var PolicySchema = z.object({
-  id: PolicyIdSchema,
-  /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
-  order: z.number(),
-  label: LabelSchema,
-  description: DescriptionSchema.optional(),
-  trigger: PolicyTriggerSchema,
-  predicate: PolicyPredicateSchema.default({ kind: "always" }),
-  actions: z.array(PolicyEffectSchema).min(1),
-  appliesTo: PolicyApplicabilitySchema.default({
-    systemIds: [],
-    actionIds: [],
-    resourceIds: [],
-    roleIds: []
-  }),
-  lifecycle: z.enum(["draft", "beta", "active", "deprecated", "archived"]).meta({ label: "Lifecycle", color: "teal" }).default("active")
-});
-var PoliciesDomainSchema = z.record(z.string(), PolicySchema).refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
-  message: "Each policy entry id must match its map key"
-}).default({});
-var DEFAULT_ORGANIZATION_MODEL_POLICIES = {};
-var SurfaceTypeSchema = z.enum(["page", "dashboard", "graph", "detail", "list", "settings"]).meta({ label: "Surface type", color: "blue" });
-z.object({
-  id: ModelIdSchema,
-  label: LabelSchema,
-  path: PathSchema,
-  surfaceType: SurfaceTypeSchema,
-  description: DescriptionSchema.optional(),
-  enabled: z.boolean().default(true),
-  devOnly: z.boolean().optional(),
-  icon: IconNameSchema.optional(),
-  systemIds: z.array(ModelIdSchema.meta({ ref: "system" })).default([]),
-  entityIds: z.array(ModelIdSchema.meta({ ref: "entity" })).default([]),
-  resourceIds: z.array(ModelIdSchema.meta({ ref: "resource" })).default([]),
-  actionIds: z.array(ModelIdSchema.meta({ ref: "action" })).default([]),
-  parentId: ModelIdSchema.meta({ ref: "surface" }).optional()
-});
-var SidebarSurfaceTargetsSchema = z.object({
-  systems: z.array(ModelIdSchema.meta({ ref: "system" })).default([]).optional(),
-  entities: z.array(ModelIdSchema.meta({ ref: "entity" })).default([]).optional(),
-  resources: z.array(ModelIdSchema.meta({ ref: "resource" })).default([]).optional(),
-  actions: z.array(ModelIdSchema.meta({ ref: "action" })).default([]).optional()
-}).default({});
-var SidebarNodeSchema = z.lazy(
-  () => z.discriminatedUnion("type", [
-    z.object({
-      type: z.literal("group"),
-      label: LabelSchema,
-      description: DescriptionSchema.optional(),
-      icon: IconNameSchema.optional(),
-      order: z.number().int().optional(),
-      children: z.record(z.string(), SidebarNodeSchema).default({})
-    }),
-    z.object({
-      type: z.literal("surface"),
-      label: LabelSchema,
-      path: PathSchema,
-      surfaceType: SurfaceTypeSchema,
-      description: DescriptionSchema.optional(),
-      icon: IconNameSchema.optional(),
-      order: z.number().int().optional(),
-      targets: SidebarSurfaceTargetsSchema.optional(),
-      devOnly: z.boolean().optional(),
-      requiresAdmin: z.boolean().optional()
-    })
-  ])
-);
-var SidebarSectionSchema = z.record(z.string(), SidebarNodeSchema).default({});
-var SidebarNavigationSchema = z.object({
-  primary: SidebarSectionSchema,
-  bottom: SidebarSectionSchema
-}).default({ primary: {}, bottom: {} });
-var OrganizationModelNavigationSchema = z.object({
-  sidebar: SidebarNavigationSchema
-}).default({ sidebar: { primary: {}, bottom: {} } });
-z.object({
-  id: ModelIdSchema,
-  label: LabelSchema,
-  placement: z.string().trim().min(1).max(50),
-  surfaceIds: z.array(ModelIdSchema.meta({ ref: "surface" })).default([])
-});
-var KnowledgeTargetKindSchema = z.enum([
-  "system",
-  "resource",
-  "knowledge",
-  "stage",
-  "action",
-  "role",
-  "goal",
-  "customer-segment",
-  "offering",
-  "ontology"
-]).meta({ label: "Target kind" });
-var KnowledgeTargetRefSchema = z.object({
-  kind: KnowledgeTargetKindSchema,
-  // Ontology targets use the canonical '<scope>:<kind>/<local-id>' ontology id format.
-  // Business-logic validation of target existence is done in OrganizationModelSchema.superRefine.
-  id: z.string().trim().min(1).max(300)
-}).superRefine((target, ctx) => {
-  if (target.kind !== "ontology") return;
-  const result = OntologyIdSchema.safeParse(target.id);
-  if (!result.success) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      path: ["id"],
-      message: "Ontology knowledge targets must use <system-path>:<kind>/<local-id> or global:<kind>/<local-id>"
-    });
-  }
-});
-var LegacyKnowledgeLinkSchema = z.object({
-  nodeId: z.union([NodeIdStringSchema, z.templateLiteral(["ontology:", OntologyIdSchema])])
-}).superRefine((link, ctx) => {
-  const [kind] = link.nodeId.split(":");
-  if (!KnowledgeTargetKindSchema.safeParse(kind).success) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      path: ["nodeId"],
-      message: `Unknown knowledge target kind "${kind}"`
-    });
-  }
-});
-var CanonicalKnowledgeLinkSchema = z.object({
-  target: KnowledgeTargetRefSchema
-});
-function nodeIdFromTarget(target) {
-  return `${target.kind}:${target.id}`;
-}
-function targetFromNodeId(nodeId) {
-  const [kind, ...idParts] = nodeId.split(":");
-  return {
-    kind: KnowledgeTargetKindSchema.parse(kind),
-    id: idParts.join(":")
-  };
-}
-var KnowledgeLinkSchema = z.union([CanonicalKnowledgeLinkSchema, LegacyKnowledgeLinkSchema]).transform((link) => {
-  const target = "target" in link ? link.target : targetFromNodeId(link.nodeId);
-  return {
-    target,
-    nodeId: nodeIdFromTarget(target)
-  };
-});
-var OrgKnowledgeKindSchema = z.enum(["playbook", "strategy", "reference"]).meta({ label: "Knowledge kind", color: "grape" });
-var OrgKnowledgeNodeSchema = z.object({
-  id: ModelIdSchema,
-  kind: OrgKnowledgeKindSchema,
-  title: z.string().trim().min(1).max(200),
-  summary: z.string().trim().min(1).max(1e3),
-  icon: IconNameSchema.optional(),
-  /** Canonical documentation URL when body content is a local summary. */
-  externalUrl: z.string().trim().url().max(500).optional(),
-  /** Optional generated source file path for local MDX-backed knowledge nodes. */
-  sourceFilePath: z.string().trim().min(1).max(500).optional(),
-  /** Raw MDX string. Phase 2 will introduce a structured block format. */
-  body: z.string().trim().min(1),
-  /**
-   * Graph links to other OM nodes this knowledge node governs.
-   * Each link emits a `governs` edge: knowledge-node -> target node.
-   */
-  links: z.array(KnowledgeLinkSchema).default([]),
-  /** Role identifiers that own this knowledge node. */
-  ownerIds: z.array(RoleIdSchema.meta({ ref: "role" })).default([]),
-  /** ISO date string (YYYY-MM-DD or full ISO 8601) of last meaningful update. */
-  updatedAt: z.string().trim().min(1).max(50)
-});
-var KnowledgeDomainSchema = z.record(ModelIdSchema, OrgKnowledgeNodeSchema).default({});
-
-// ../core/src/organization-model/schema.ts
-z.enum([
-  "branding",
-  "identity",
-  "customers",
-  "offerings",
-  "roles",
-  "goals",
-  "systems",
-  "ontology",
-  "resources",
-  "topology",
-  "actions",
-  "entities",
-  "policies",
-  "knowledge"
-]);
-var OrganizationModelDomainMetadataSchema = z.object({
-  version: z.literal(1).default(1),
-  lastModified: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "lastModified must be an ISO date string (YYYY-MM-DD)")
-});
-var DEFAULT_ORGANIZATION_MODEL_DOMAIN_METADATA = {
-  branding: { version: 1, lastModified: "2026-05-10" },
-  identity: { version: 1, lastModified: "2026-05-10" },
-  customers: { version: 1, lastModified: "2026-05-10" },
-  offerings: { version: 1, lastModified: "2026-05-10" },
-  roles: { version: 1, lastModified: "2026-05-10" },
-  goals: { version: 1, lastModified: "2026-05-10" },
-  systems: { version: 1, lastModified: "2026-05-10" },
-  ontology: { version: 1, lastModified: "2026-05-14" },
-  resources: { version: 1, lastModified: "2026-05-10" },
-  topology: { version: 1, lastModified: "2026-05-14" },
-  actions: { version: 1, lastModified: "2026-05-10" },
-  entities: { version: 1, lastModified: "2026-05-10" },
-  policies: { version: 1, lastModified: "2026-05-10" },
-  knowledge: { version: 1, lastModified: "2026-05-10" }
-};
-var OrganizationModelDomainMetadataByDomainSchema = z.object({
-  branding: OrganizationModelDomainMetadataSchema,
-  identity: OrganizationModelDomainMetadataSchema,
-  customers: OrganizationModelDomainMetadataSchema,
-  offerings: OrganizationModelDomainMetadataSchema,
-  roles: OrganizationModelDomainMetadataSchema,
-  goals: OrganizationModelDomainMetadataSchema,
-  systems: OrganizationModelDomainMetadataSchema,
-  ontology: OrganizationModelDomainMetadataSchema,
-  resources: OrganizationModelDomainMetadataSchema,
-  topology: OrganizationModelDomainMetadataSchema,
-  actions: OrganizationModelDomainMetadataSchema,
-  entities: OrganizationModelDomainMetadataSchema,
-  policies: OrganizationModelDomainMetadataSchema,
-  knowledge: OrganizationModelDomainMetadataSchema
-}).partial().default(DEFAULT_ORGANIZATION_MODEL_DOMAIN_METADATA).transform((metadata) => ({ ...DEFAULT_ORGANIZATION_MODEL_DOMAIN_METADATA, ...metadata }));
-var OrganizationModelSchemaBase = z.object({
-  version: z.literal(1).default(1),
-  domainMetadata: OrganizationModelDomainMetadataByDomainSchema,
-  branding: OrganizationModelBrandingSchema,
-  navigation: OrganizationModelNavigationSchema,
-  identity: IdentityDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_IDENTITY),
-  customers: CustomersDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_CUSTOMERS),
-  offerings: OfferingsDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_OFFERINGS),
-  roles: RolesDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_ROLES),
-  goals: GoalsDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_GOALS),
-  systems: SystemsDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_SYSTEMS),
-  ontology: OntologyScopeSchema.default(DEFAULT_ONTOLOGY_SCOPE),
-  resources: ResourcesDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_RESOURCES),
-  topology: OmTopologyDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_TOPOLOGY),
-  actions: ActionsDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_ACTIONS),
-  entities: EntitiesDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_ENTITIES),
-  policies: PoliciesDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_POLICIES),
-  // D3: flat Record<id, OrgKnowledgeNode> — no wrapper object
-  knowledge: KnowledgeDomainSchema.default({})
-});
-function addIssue(ctx, path, message) {
-  ctx.addIssue({
-    code: z.ZodIssueCode.custom,
-    path,
-    message
-  });
-}
-function isLifecycleEnabled(lifecycle, enabled) {
-  if (enabled === false) return false;
-  return lifecycle !== "deprecated" && lifecycle !== "archived";
-}
-function defaultSystemPathFor(id) {
-  return `/${id.replaceAll(".", "/")}`;
-}
-function asRoleHolderArray(heldBy) {
-  return Array.isArray(heldBy) ? heldBy : [heldBy];
-}
-function isKnowledgeKindCompatibleWithTarget(knowledgeKind, targetKind) {
-  if (knowledgeKind === "reference") return true;
-  if (knowledgeKind === "playbook") {
-    return ["system", "resource", "stage", "action", "ontology"].includes(targetKind);
-  }
-  if (knowledgeKind === "strategy") {
-    return ["system", "goal", "offering", "customer-segment", "ontology"].includes(targetKind);
-  }
-  return false;
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-OrganizationModelSchemaBase.superRefine((model, ctx) => {
-  function collectAllSystems(systems, prefix = "", schemaPath = ["systems"]) {
-    const result = [];
-    for (const [key, system] of Object.entries(systems)) {
-      const path = prefix ? `${prefix}.${key}` : key;
-      const currentSchemaPath = [...schemaPath, key];
-      result.push({ path, schemaPath: currentSchemaPath, system });
-      const childSystems = system.systems ?? system.subsystems;
-      if (childSystems !== void 0) {
-        result.push(
-          ...collectAllSystems(childSystems, path, [
-            ...currentSchemaPath,
-            system.systems !== void 0 ? "systems" : "subsystems"
-          ])
-        );
-      }
-    }
-    return result;
-  }
-  const allSystems = collectAllSystems(model.systems);
-  const systemsById = /* @__PURE__ */ new Map();
-  for (const { path, system } of allSystems) {
-    systemsById.set(path, system);
-    systemsById.set(system.id, system);
-  }
-  const systemIdsByEffectivePath = /* @__PURE__ */ new Map();
-  allSystems.forEach(({ path, schemaPath, system }) => {
-    if (system.parentSystemId !== void 0 && !systemsById.has(system.parentSystemId)) {
-      addIssue(
-        ctx,
-        [...schemaPath, "parentSystemId"],
-        `System "${system.id}" references unknown parent "${system.parentSystemId}"`
-      );
-    }
-    const hasChildren = Object.keys(system.systems ?? system.subsystems ?? {}).length > 0 || allSystems.some(
-      (candidate) => candidate.path.startsWith(`${path}.`) && !candidate.path.slice(path.length + 1).includes(".")
-    );
-    const contributesRoutePath = system.ui?.path !== void 0 || system.path !== void 0 || !hasChildren;
-    if (contributesRoutePath) {
-      const effectivePath = system.ui?.path ?? system.path ?? defaultSystemPathFor(path);
-      const existingSystemId = systemIdsByEffectivePath.get(effectivePath);
-      if (existingSystemId !== void 0) {
-        addIssue(
-          ctx,
-          [...schemaPath, system.ui?.path !== void 0 ? "ui" : "path"],
-          `System "${path}" effective path "${effectivePath}" duplicates system "${existingSystemId}"`
-        );
-      } else {
-        systemIdsByEffectivePath.set(effectivePath, path);
-      }
-    }
-    if (hasChildren && isLifecycleEnabled(system.lifecycle, system.enabled)) {
-      const hasEnabledDescendant = Object.values(system.systems ?? system.subsystems ?? {}).some(
-        (candidate) => isLifecycleEnabled(candidate.lifecycle, candidate.enabled)
-      ) || allSystems.some(
-        (candidate) => candidate.path.startsWith(`${path}.`) && !candidate.path.slice(path.length + 1).includes(".") && isLifecycleEnabled(candidate.system.lifecycle, candidate.system.enabled)
-      );
-      if (!hasEnabledDescendant) {
-        addIssue(ctx, [...schemaPath, "lifecycle"], `System "${path}" is active but has no active descendants`);
-      }
-    }
-  });
-  allSystems.forEach(({ schemaPath, system }) => {
-    const visited = /* @__PURE__ */ new Set();
-    let currentParentId = system.parentSystemId;
-    while (currentParentId !== void 0) {
-      if (currentParentId === system.id || visited.has(currentParentId)) {
-        addIssue(ctx, [...schemaPath, "parentSystemId"], `System "${system.id}" has a parent cycle`);
-        return;
-      }
-      visited.add(currentParentId);
-      currentParentId = systemsById.get(currentParentId)?.parentSystemId;
-    }
-  });
-  function normalizeRoutePath(path) {
-    return path.length > 1 ? path.replace(/\/+$/, "") : path;
-  }
-  const sidebarNodeIds = /* @__PURE__ */ new Map();
-  const sidebarSurfacePaths = /* @__PURE__ */ new Map();
-  const sidebarSurfaces = [];
-  function collectSidebarNodes(nodes, schemaPath) {
-    Object.entries(nodes).forEach(([nodeId, node]) => {
-      const nodePath = [...schemaPath, nodeId];
-      const existingNodePath = sidebarNodeIds.get(nodeId);
-      if (existingNodePath !== void 0) {
-        addIssue(ctx, nodePath, `Sidebar node id "${nodeId}" duplicates another sidebar node`);
-      } else {
-        sidebarNodeIds.set(nodeId, nodePath);
-      }
-      if (node.type === "group") {
-        collectSidebarNodes(node.children, [...nodePath, "children"]);
-        return;
-      }
-      sidebarSurfaces.push({ id: nodeId, node, path: nodePath });
-      const normalizedPath = normalizeRoutePath(node.path);
-      const existingSurfaceId = sidebarSurfacePaths.get(normalizedPath);
-      if (existingSurfaceId !== void 0) {
-        addIssue(
-          ctx,
-          [...nodePath, "path"],
-          `Sidebar surface path "${node.path}" duplicates surface "${existingSurfaceId}"`
-        );
-      } else {
-        sidebarSurfacePaths.set(normalizedPath, nodeId);
-      }
-      node.targets?.systems?.forEach((systemId, systemIndex) => {
-        if (!systemsById.has(systemId)) {
-          addIssue(
-            ctx,
-            [...nodePath, "targets", "systems", systemIndex],
-            `Sidebar surface "${nodeId}" references unknown system "${systemId}"`
-          );
-        }
-      });
-    });
-  }
-  collectSidebarNodes(model.navigation.sidebar.primary, ["navigation", "sidebar", "primary"]);
-  collectSidebarNodes(model.navigation.sidebar.bottom, ["navigation", "sidebar", "bottom"]);
-  const segmentsById = new Map(Object.entries(model.customers));
-  Object.values(model.offerings).forEach((product) => {
-    product.targetSegmentIds.forEach((segmentId, segmentIndex) => {
-      if (!segmentsById.has(segmentId)) {
-        addIssue(
-          ctx,
-          ["offerings", product.id, "targetSegmentIds", segmentIndex],
-          `Product "${product.id}" references unknown customer segment "${segmentId}"`
-        );
-      }
-    });
-    if (product.deliveryFeatureId !== void 0 && !systemsById.has(product.deliveryFeatureId)) {
-      addIssue(
-        ctx,
-        ["offerings", product.id, "deliveryFeatureId"],
-        `Product "${product.id}" references unknown delivery system "${product.deliveryFeatureId}"`
-      );
-    }
-  });
-  Object.values(model.goals).forEach((objective) => {
-    if (objective.periodEnd <= objective.periodStart) {
-      addIssue(
-        ctx,
-        ["goals", objective.id, "periodEnd"],
-        `Goal "${objective.id}" has periodEnd "${objective.periodEnd}" which must be strictly after periodStart "${objective.periodStart}"`
-      );
-    }
-  });
-  const goalsById = new Map(Object.entries(model.goals));
-  const knowledgeById = new Map(Object.entries(model.knowledge));
-  const actionsById = new Map(Object.entries(model.actions));
-  const entitiesById = new Map(Object.entries(model.entities));
-  const policiesById = new Map(Object.entries(model.policies));
-  sidebarSurfaces.forEach(({ id, node, path }) => {
-    node.targets?.entities?.forEach((entityId, entityIndex) => {
-      if (!entitiesById.has(entityId)) {
-        addIssue(
-          ctx,
-          [...path, "targets", "entities", entityIndex],
-          `Sidebar surface "${id}" references unknown entity "${entityId}"`
-        );
-      }
-    });
-    node.targets?.actions?.forEach((actionId, actionIndex) => {
-      if (!actionsById.has(actionId)) {
-        addIssue(
-          ctx,
-          [...path, "targets", "actions", actionIndex],
-          `Sidebar surface "${id}" references unknown action "${actionId}"`
-        );
-      }
-    });
-  });
-  Object.values(model.entities).forEach((entity) => {
-    if (!systemsById.has(entity.ownedBySystemId)) {
-      addIssue(
-        ctx,
-        ["entities", entity.id, "ownedBySystemId"],
-        `Entity "${entity.id}" references unknown ownedBySystemId "${entity.ownedBySystemId}"`
-      );
-    }
-    entity.links?.forEach((link, linkIndex) => {
-      if (!entitiesById.has(link.toEntity)) {
-        addIssue(
-          ctx,
-          ["entities", entity.id, "links", linkIndex, "toEntity"],
-          `Entity "${entity.id}" links to unknown entity "${link.toEntity}"`
-        );
-      }
-    });
-  });
-  const rolesById = new Map(Object.entries(model.roles));
-  Object.values(model.roles).forEach((role) => {
-    if (role.reportsToId !== void 0 && !rolesById.has(role.reportsToId)) {
-      addIssue(
-        ctx,
-        ["roles", role.id, "reportsToId"],
-        `Role "${role.id}" references unknown reportsToId "${role.reportsToId}"`
-      );
-    }
-  });
-  Object.values(model.roles).forEach((role) => {
-    const visited = /* @__PURE__ */ new Set();
-    let currentReportsToId = role.reportsToId;
-    while (currentReportsToId !== void 0) {
-      if (currentReportsToId === role.id || visited.has(currentReportsToId)) {
-        addIssue(ctx, ["roles", role.id, "reportsToId"], `Role "${role.id}" has a reportsToId cycle`);
-        return;
-      }
-      visited.add(currentReportsToId);
-      currentReportsToId = rolesById.get(currentReportsToId)?.reportsToId;
-    }
-  });
-  Object.values(model.roles).forEach((role) => {
-    role.responsibleFor?.forEach((systemId, systemIndex) => {
-      if (!systemsById.has(systemId)) {
-        addIssue(
-          ctx,
-          ["roles", role.id, "responsibleFor", systemIndex],
-          `Role "${role.id}" references unknown responsibleFor system "${systemId}"`
-        );
-      }
-    });
-  });
-  allSystems.forEach(({ schemaPath, system }) => {
-    if (system.responsibleRoleId !== void 0 && !rolesById.has(system.responsibleRoleId)) {
-      addIssue(
-        ctx,
-        [...schemaPath, "responsibleRoleId"],
-        `System "${system.id}" references unknown responsibleRoleId "${system.responsibleRoleId}"`
-      );
-    }
-    system.governedByKnowledge?.forEach((nodeId, nodeIndex) => {
-      if (!knowledgeById.has(nodeId)) {
-        addIssue(
-          ctx,
-          [...schemaPath, "governedByKnowledge", nodeIndex],
-          `System "${system.id}" references unknown knowledge node "${nodeId}"`
-        );
-      }
-    });
-    system.drivesGoals?.forEach((goalId, goalIndex) => {
-      if (!goalsById.has(goalId)) {
-        addIssue(
-          ctx,
-          [...schemaPath, "drivesGoals", goalIndex],
-          `System "${system.id}" references unknown goal "${goalId}"`
-        );
-      }
-    });
-    system.actions?.forEach((actionRef, actionIndex) => {
-      if (!actionsById.has(actionRef.actionId)) {
-        addIssue(
-          ctx,
-          [...schemaPath, "actions", actionIndex, "actionId"],
-          `System "${system.id}" references unknown action "${actionRef.actionId}"`
-        );
-      }
-    });
-    system.policies?.forEach((policyId, policyIndex) => {
-      if (!policiesById.has(policyId)) {
-        addIssue(
-          ctx,
-          [...schemaPath, "policies", policyIndex],
-          `System "${system.id}" references unknown policy "${policyId}"`
-        );
-      }
-    });
-  });
-  Object.values(model.actions).forEach((action) => {
-    action.affects?.forEach((entityId, entityIndex) => {
-      if (!entitiesById.has(entityId)) {
-        addIssue(
-          ctx,
-          ["actions", action.id, "affects", entityIndex],
-          `Action "${action.id}" affects unknown entity "${entityId}"`
-        );
-      }
-    });
-  });
-  const resourcesById = new Map(Object.entries(model.resources));
-  sidebarSurfaces.forEach(({ id, node, path }) => {
-    node.targets?.resources?.forEach((resourceId, resourceIndex) => {
-      if (!resourcesById.has(resourceId)) {
-        addIssue(
-          ctx,
-          [...path, "targets", "resources", resourceIndex],
-          `Sidebar surface "${id}" references unknown resource "${resourceId}"`
-        );
-      }
-    });
-  });
-  const actionIds = new Set(Object.keys(model.actions));
-  const offeringsById = new Map(Object.entries(model.offerings));
-  const ontologyCompilation = compileOrganizationOntology(model);
-  const stageIds = /* @__PURE__ */ new Set();
-  for (const catalog of Object.values(ontologyCompilation.ontology.catalogTypes)) {
-    if (catalog.kind !== "stage") continue;
-    for (const stageId of Object.keys(catalog.entries ?? {})) {
-      stageIds.add(stageId);
-    }
-  }
-  const ontologyIndexByKind = {
-    object: ontologyCompilation.ontology.objectTypes,
-    link: ontologyCompilation.ontology.linkTypes,
-    action: ontologyCompilation.ontology.actionTypes,
-    catalog: ontologyCompilation.ontology.catalogTypes,
-    event: ontologyCompilation.ontology.eventTypes,
-    interface: ontologyCompilation.ontology.interfaceTypes,
-    "value-type": ontologyCompilation.ontology.valueTypes,
-    property: ontologyCompilation.ontology.sharedProperties,
-    group: ontologyCompilation.ontology.groups,
-    surface: ontologyCompilation.ontology.surfaces
-  };
-  const ontologyIds = new Set(Object.values(ontologyIndexByKind).flatMap((index2) => Object.keys(index2)));
-  function topologyTargetExists(ref) {
-    if (ref.kind === "system") return systemsById.has(ref.id);
-    if (ref.kind === "resource") return resourcesById.has(ref.id);
-    if (ref.kind === "ontology") return ontologyIds.has(ref.id);
-    if (ref.kind === "policy") return policiesById.has(ref.id);
-    if (ref.kind === "role") return rolesById.has(ref.id);
-    return true;
-  }
-  Object.entries(model.topology.relationships).forEach(([relationshipId, relationship]) => {
-    ["from", "to"].forEach((side) => {
-      const ref = relationship[side];
-      if (topologyTargetExists(ref)) return;
-      addIssue(
-        ctx,
-        ["topology", "relationships", relationshipId, side],
-        `Topology relationship "${relationshipId}" ${side} references unknown ${ref.kind} "${ref.id}"`
-      );
-    });
-  });
-  const ontologyReferenceKeyKinds = {
-    valueType: "value-type",
-    catalogType: "catalog",
-    objectType: "object",
-    eventType: "event",
-    actionType: "action",
-    linkType: "link",
-    interfaceType: "interface",
-    propertyType: "property",
-    groupType: "group",
-    surfaceType: "surface",
-    stepCatalog: "catalog"
-  };
-  function validateKnownOntologyReferences(ownerId, value, path, seen = /* @__PURE__ */ new WeakSet()) {
-    if (Array.isArray(value)) {
-      value.forEach((entry, index2) => validateKnownOntologyReferences(ownerId, entry, [...path, index2], seen));
-      return;
-    }
-    if (!isRecord(value)) return;
-    if (seen.has(value)) return;
-    seen.add(value);
-    Object.entries(value).forEach(([key, entry]) => {
-      const expectedKind = ontologyReferenceKeyKinds[key];
-      if (expectedKind !== void 0) {
-        if (typeof entry !== "string") {
-          addIssue(ctx, [...path, key], `Ontology record "${ownerId}" ${key} must be an ontology ID string`);
-        } else if (ontologyIndexByKind[expectedKind][entry] === void 0) {
-          addIssue(
-            ctx,
-            [...path, key],
-            `Ontology record "${ownerId}" ${key} references unknown ${expectedKind} ontology ID "${entry}"`
-          );
-        }
-      }
-      validateKnownOntologyReferences(ownerId, entry, [...path, key], seen);
-    });
-  }
-  for (const { id, record } of listResolvedOntologyRecords(ontologyCompilation.ontology)) {
-    validateKnownOntologyReferences(id, record, record.origin.path);
-  }
-  Object.values(model.policies).forEach((policy) => {
-    policy.appliesTo.systemIds.forEach((systemId, systemIndex) => {
-      if (!systemsById.has(systemId)) {
-        addIssue(
-          ctx,
-          ["policies", policy.id, "appliesTo", "systemIds", systemIndex],
-          `Policy "${policy.id}" applies to unknown system "${systemId}"`
-        );
-      }
-    });
-    policy.appliesTo.actionIds.forEach((actionId, actionIndex) => {
-      if (!actionsById.has(actionId)) {
-        addIssue(
-          ctx,
-          ["policies", policy.id, "appliesTo", "actionIds", actionIndex],
-          `Policy "${policy.id}" applies to unknown action "${actionId}"`
-        );
-      }
-    });
-    policy.actions.forEach((action, actionIndex) => {
-      if (action.kind === "invoke-action" && !actionsById.has(action.actionId)) {
-        addIssue(
-          ctx,
-          ["policies", policy.id, "actions", actionIndex, "actionId"],
-          `Policy "${policy.id}" invokes unknown action "${action.actionId}"`
-        );
-      }
-      if ((action.kind === "notify-role" || action.kind === "require-approval") && action.roleId !== void 0 && !rolesById.has(action.roleId)) {
-        addIssue(
-          ctx,
-          ["policies", policy.id, "actions", actionIndex, "roleId"],
-          `Policy "${policy.id}" references unknown role "${action.roleId}"`
-        );
-      }
-    });
-    if (policy.trigger.kind === "action-invocation" && !actionsById.has(policy.trigger.actionId)) {
-      addIssue(
-        ctx,
-        ["policies", policy.id, "trigger", "actionId"],
-        `Policy "${policy.id}" references unknown trigger action "${policy.trigger.actionId}"`
-      );
-    }
-  });
-  function knowledgeTargetExists(kind, id) {
-    if (kind === "system") return systemsById.has(id);
-    if (kind === "resource") return resourcesById.has(id);
-    if (kind === "knowledge") return knowledgeById.has(id);
-    if (kind === "stage") return stageIds.has(id);
-    if (kind === "action") return actionIds.has(id);
-    if (kind === "role") return rolesById.has(id);
-    if (kind === "goal") return goalsById.has(id);
-    if (kind === "customer-segment") return segmentsById.has(id);
-    if (kind === "offering") return offeringsById.has(id);
-    if (kind === "ontology") return ontologyIds.has(id);
-    return false;
-  }
-  Object.entries(model.knowledge).forEach(([nodeId, node]) => {
-    node.links.forEach((link, linkIndex) => {
-      if (!knowledgeTargetExists(link.target.kind, link.target.id)) {
-        addIssue(
-          ctx,
-          ["knowledge", nodeId, "links", linkIndex, "target"],
-          `Knowledge node "${node.id}" references unknown ${link.target.kind} target "${link.target.id}"`
-        );
-      }
-      if (!isKnowledgeKindCompatibleWithTarget(node.kind, link.target.kind)) {
-        addIssue(
-          ctx,
-          ["knowledge", nodeId, "links", linkIndex, "target", "kind"],
-          `Knowledge node "${node.id}" kind "${node.kind}" cannot govern ${link.target.kind} targets`
-        );
-      }
-    });
-  });
-  Object.values(model.resources).forEach((resource) => {
-    if (!systemsById.has(resource.systemPath)) {
-      addIssue(
-        ctx,
-        ["resources", resource.id, "systemPath"],
-        `Resource "${resource.id}" references unknown system path "${resource.systemPath}"`
-      );
-    }
-    if (resource.ownerRoleId !== void 0 && !rolesById.has(resource.ownerRoleId)) {
-      addIssue(
-        ctx,
-        ["resources", resource.id, "ownerRoleId"],
-        `Resource "${resource.id}" references unknown ownerRoleId "${resource.ownerRoleId}"`
-      );
-    }
-    if (resource.kind === "agent" && resource.actsAsRoleId !== void 0 && !rolesById.has(resource.actsAsRoleId)) {
-      addIssue(
-        ctx,
-        ["resources", resource.id, "actsAsRoleId"],
-        `Agent resource "${resource.id}" references unknown actsAsRoleId "${resource.actsAsRoleId}"`
-      );
-    }
-  });
-  function validateResourceOntologyBinding(resourceId, bindingKey, expectedKind, ids) {
-    const ontologyIds2 = ids === void 0 ? [] : Array.isArray(ids) ? ids : [ids];
-    ontologyIds2.forEach((ontologyId, ontologyIndex) => {
-      if (ontologyIndexByKind[expectedKind][ontologyId] === void 0) {
-        addIssue(
-          ctx,
-          ["resources", resourceId, "ontology", bindingKey, ...Array.isArray(ids) ? [ontologyIndex] : []],
-          `Resource "${resourceId}" ontology binding "${bindingKey}" references unknown ${expectedKind} ontology ID "${ontologyId}"`
-        );
-      }
-    });
-  }
-  Object.values(model.resources).forEach((resource) => {
-    const binding = resource.ontology;
-    if (binding === void 0) return;
-    validateResourceOntologyBinding(resource.id, "actions", "action", binding.actions);
-    validateResourceOntologyBinding(resource.id, "primaryAction", "action", binding.primaryAction);
-    validateResourceOntologyBinding(resource.id, "reads", "object", binding.reads);
-    validateResourceOntologyBinding(resource.id, "writes", "object", binding.writes);
-    validateResourceOntologyBinding(resource.id, "usesCatalogs", "catalog", binding.usesCatalogs);
-    validateResourceOntologyBinding(resource.id, "emits", "event", binding.emits);
-    if (binding.contract !== void 0) {
-      const contractEntries = [
-        ["input", binding.contract.input],
-        ["output", binding.contract.output]
-      ];
-      for (const [side, ref] of contractEntries) {
-        if (ref === void 0) continue;
-        const result = ContractRefSchema.safeParse(ref);
-        if (!result.success) {
-          addIssue(
-            ctx,
-            ["resources", resource.id, "ontology", "contract", side],
-            `Resource "${resource.id}" contract.${side} "${ref}" is not a valid ContractRef (expected "package/subpath#ExportName")`
-          );
-        }
-      }
-    }
-  });
-  Object.values(model.roles).forEach((role) => {
-    if (role.heldBy === void 0) return;
-    asRoleHolderArray(role.heldBy).forEach((holder, holderIndex) => {
-      if (holder.kind !== "agent") return;
-      const resource = resourcesById.get(holder.agentId);
-      if (resource === void 0) {
-        addIssue(
-          ctx,
-          ["roles", role.id, "heldBy", Array.isArray(role.heldBy) ? holderIndex : "agentId"],
-          `Role "${role.id}" references unknown agent holder resource "${holder.agentId}"`
-        );
-        return;
-      }
-      if (resource.kind !== "agent") {
-        addIssue(
-          ctx,
-          ["roles", role.id, "heldBy", Array.isArray(role.heldBy) ? holderIndex : "agentId"],
-          `Role "${role.id}" agent holder "${holder.agentId}" must reference an agent resource`
-        );
-      }
-    });
-  });
-  Object.entries(model.knowledge).forEach(([nodeId, node]) => {
-    node.ownerIds.forEach((roleId, ownerIndex) => {
-      if (!rolesById.has(roleId)) {
-        addIssue(
-          ctx,
-          ["knowledge", nodeId, "ownerIds", ownerIndex],
-          `Knowledge node "${node.id}" references unknown owner role "${roleId}"`
-        );
-      }
-    });
-  });
-  for (const diagnostic of ontologyCompilation.diagnostics) {
-    addIssue(ctx, diagnostic.path, diagnostic.message);
-  }
-});
-
-// ../core/src/organization-model/defaults.ts
-var DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE = {};
-var DEFAULT_ORGANIZATION_MODEL_ENTITIES2 = {};
-var DEFAULT_ORGANIZATION_MODEL_NAVIGATION = {
-  sidebar: {
-    primary: {},
-    bottom: {}
-  }
-};
-var DEFAULT_ORGANIZATION_MODEL = {
-  version: 1,
-  domainMetadata: DEFAULT_ORGANIZATION_MODEL_DOMAIN_METADATA,
-  branding: DEFAULT_ORGANIZATION_MODEL_BRANDING,
-  navigation: DEFAULT_ORGANIZATION_MODEL_NAVIGATION,
-  identity: DEFAULT_ORGANIZATION_MODEL_IDENTITY,
-  customers: DEFAULT_ORGANIZATION_MODEL_CUSTOMERS,
-  offerings: DEFAULT_ORGANIZATION_MODEL_OFFERINGS,
-  roles: DEFAULT_ORGANIZATION_MODEL_ROLES,
-  goals: DEFAULT_ORGANIZATION_MODEL_GOALS,
-  // Generic empty systems map. Elevasis-specific systems (platform, sales, sales.crm,
-  // sales.lead-gen, monitoring, settings, admin, etc.) have been relocated to
-  // `@repo/elevasis-core/src/organization-model/systems.ts` via `canonicalOrganizationModel`.
-  // Tenant OM configs supply their own systems via `resolveOrganizationModel`.
-  systems: {},
-  ontology: DEFAULT_ONTOLOGY_SCOPE,
-  resources: DEFAULT_ORGANIZATION_MODEL_RESOURCES,
-  topology: DEFAULT_ORGANIZATION_MODEL_TOPOLOGY,
-  // Generic empty actions map. Elevasis-specific action entries have been relocated to
-  // `@repo/elevasis-core/src/organization-model/actions.ts`.
-  actions: {},
-  entities: DEFAULT_ORGANIZATION_MODEL_ENTITIES2,
-  policies: DEFAULT_ORGANIZATION_MODEL_POLICIES,
-  knowledge: DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE
-};
-var SalesStageSemanticClassSchema = z.enum(["open", "active", "nurturing", "closed_won", "closed_lost"]);
-var SalesStageSchema = DisplayMetadataSchema.extend({
-  id: ModelIdSchema,
-  order: z.number().int().min(0),
-  semanticClass: SalesStageSemanticClassSchema,
-  surfaceIds: ReferenceIdsSchema,
-  resourceIds: ReferenceIdsSchema
-});
-z.object({
-  id: ModelIdSchema,
-  label: z.string().trim().min(1).max(120),
-  description: DescriptionSchema.optional(),
-  entityId: ModelIdSchema,
-  stages: z.array(SalesStageSchema).min(1)
-});
-var CRM_DISCOVERY_REPLIED_STATE = {
-  stateKey: "discovery_replied",
-  label: "Discovery Replied"
-};
-var CRM_DISCOVERY_LINK_SENT_STATE = {
-  stateKey: "discovery_link_sent",
-  label: "Discovery Link Sent"
-};
-var CRM_DISCOVERY_NUDGING_STATE = {
-  stateKey: "discovery_nudging",
-  label: "Discovery Nudging"
-};
-var CRM_DISCOVERY_BOOKING_CANCELLED_STATE = {
-  stateKey: "discovery_booking_cancelled",
-  label: "Discovery Booking Cancelled"
-};
-var CRM_REPLY_SENT_STATE = {
-  stateKey: "reply_sent",
-  label: "Reply Sent"
-};
-var CRM_FOLLOWUP_1_SENT_STATE = {
-  stateKey: "followup_1_sent",
-  label: "Follow-up 1 Sent"
-};
-var CRM_FOLLOWUP_2_SENT_STATE = {
-  stateKey: "followup_2_sent",
-  label: "Follow-up 2 Sent"
-};
-var CRM_FOLLOWUP_3_SENT_STATE = {
-  stateKey: "followup_3_sent",
-  label: "Follow-up 3 Sent"
-};
-var CRM_PIPELINE_DEFINITION = {
-  pipelineKey: "crm",
-  label: "CRM",
-  entityKey: "crm.deal",
-  stages: [
-    {
-      stageKey: "interested",
-      label: "Interested",
-      color: "blue",
-      states: [
-        CRM_DISCOVERY_REPLIED_STATE,
-        CRM_DISCOVERY_LINK_SENT_STATE,
-        CRM_DISCOVERY_NUDGING_STATE,
-        CRM_DISCOVERY_BOOKING_CANCELLED_STATE,
-        CRM_REPLY_SENT_STATE,
-        CRM_FOLLOWUP_1_SENT_STATE,
-        CRM_FOLLOWUP_2_SENT_STATE,
-        CRM_FOLLOWUP_3_SENT_STATE
-      ]
-    },
-    { stageKey: "proposal", label: "Proposal", color: "yellow", states: [] },
-    { stageKey: "closing", label: "Closing", color: "orange", states: [] },
-    { stageKey: "closed_won", label: "Closed Won", color: "green", states: [] },
-    { stageKey: "closed_lost", label: "Closed Lost", color: "red", states: [] },
-    { stageKey: "nurturing", label: "Nurturing", color: "grape", states: [] }
-  ]
-};
-
-// ../core/src/organization-model/migration-helpers.ts
-function catalogRecords(model) {
-  return Object.values(compileOrganizationOntology(model).ontology.catalogTypes);
-}
-function systemScope(id, fallback) {
-  return parseOntologyId(id).scope || fallback || "";
-}
-function entriesOf(catalog) {
-  return Object.entries(catalog.entries ?? {}).map(([id, value]) => [
-    id,
-    value && typeof value === "object" && !Array.isArray(value) ? value : {}
-  ]);
-}
-function stringValue(value) {
-  return typeof value === "string" ? value : void 0;
-}
-function stringArray(value) {
-  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
-}
-function numberValue(value, fallback = 0) {
-  return typeof value === "number" ? value : fallback;
-}
-function appliesToLocalId(catalog) {
-  const appliesTo = catalog.appliesTo;
-  if (appliesTo === void 0) return void 0;
-  return parseOntologyId(appliesTo).localId;
-}
-function appliesToEntityKind(catalog) {
-  const id = appliesToLocalId(catalog);
-  if (id === "company" || id === "contact" || id === "project" || id === "milestone" || id === "task") return id;
-  if (id === "deal") return void 0;
-  return void 0;
-}
-function getLeadGenStageCatalog(model) {
-  const results = {};
-  for (const catalog of catalogRecords(model).filter(
-    (record) => record.kind === "stage" && (record.ownerSystemId ?? systemScope(record.id)) === "sales.lead-gen"
-  )) {
-    const catalogEntity = appliesToEntityKind(catalog);
-    if (catalogEntity !== "company" && catalogEntity !== "contact") continue;
-    for (const [entryId, entry] of entriesOf(catalog)) {
-      const entity = entry.entity === "contact" ? "contact" : entry.entity === "company" ? "company" : catalogEntity;
-      const additionalEntities = stringArray(entry.additionalEntities).filter(
-        (item) => item === "company" || item === "contact"
-      );
-      const recordEntity = entry.recordEntity === "company" || entry.recordEntity === "contact" ? entry.recordEntity : void 0;
-      const recordStageKey = stringValue(entry.recordStageKey);
-      results[entryId] = {
-        key: entryId,
-        label: stringValue(entry.label) ?? entryId,
-        description: stringValue(entry.description) ?? "",
-        order: numberValue(entry.order),
-        entity,
-        ...additionalEntities.length > 0 ? { additionalEntities } : {},
-        ...recordEntity ? { recordEntity } : {},
-        ...recordStageKey ? { recordStageKey } : {}
-      };
-    }
-  }
-  return Object.fromEntries(
-    Object.entries(results).sort(([, a3], [, b2]) => a3.order - b2.order || a3.key.localeCompare(b2.key))
-  );
-}
-
-// ../core/src/business/acquisition/ontology-validation.ts
-var CRM_PIPELINE_CATALOG_ONTOLOGY_ID = formatOntologyId({
-  scope: "sales.crm",
-  kind: "catalog",
-  localId: "crm.pipeline"
-});
-var LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID = formatOntologyId({
-  scope: "sales.lead-gen",
-  kind: "catalog",
-  localId: "lead-gen.stage-catalog"
-});
-var CRM_DEAL_OBJECT_ONTOLOGY_ID = formatOntologyId({
-  scope: "sales.crm",
-  kind: "object",
-  localId: "crm.deal"
-});
-function createCrmPipelineCatalog() {
-  return {
-    id: CRM_PIPELINE_CATALOG_ONTOLOGY_ID,
-    label: CRM_PIPELINE_DEFINITION.label,
-    ownerSystemId: "sales.crm",
-    kind: "pipeline",
-    appliesTo: CRM_DEAL_OBJECT_ONTOLOGY_ID,
-    entries: Object.fromEntries(
-      CRM_PIPELINE_DEFINITION.stages.map((stage, index2) => [
-        stage.stageKey,
-        {
-          key: stage.stageKey,
-          label: stage.label,
-          order: (index2 + 1) * 10,
-          ...stage.color !== void 0 ? { color: stage.color } : {},
-          states: stage.states.map((state) => ({ ...state }))
-        }
-      ])
-    ),
-    legacyPipelineKey: CRM_PIPELINE_DEFINITION.pipelineKey,
-    legacyEntityKey: CRM_PIPELINE_DEFINITION.entityKey
-  };
-}
-function createLeadGenStageCatalog(model) {
-  return {
-    id: LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID,
-    label: "Lead Gen Processing Stages",
-    ownerSystemId: "sales.lead-gen",
-    kind: "processing-stage-catalog",
-    entries: Object.fromEntries(
-      Object.entries(getLeadGenStageCatalog(model)).map(([key, entry]) => [
-        key,
-        {
-          ...entry
-        }
-      ])
-    ),
-    legacyCatalogKey: "LEAD_GEN_STAGE_CATALOG"
-  };
-}
-function isPlainRecord(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function mergeBridgeCatalogs(model) {
-  const baseCatalogTypes = model.ontology?.catalogTypes ?? {};
-  const bridgeCatalogTypes = {};
-  if (baseCatalogTypes[CRM_PIPELINE_CATALOG_ONTOLOGY_ID] === void 0) {
-    bridgeCatalogTypes[CRM_PIPELINE_CATALOG_ONTOLOGY_ID] = createCrmPipelineCatalog();
-  }
-  if (baseCatalogTypes[LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID] === void 0) {
-    bridgeCatalogTypes[LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID] = createLeadGenStageCatalog(model);
-  }
-  if (Object.keys(bridgeCatalogTypes).length === 0) return model;
-  return {
-    ...model,
-    ontology: {
-      ...model.ontology ?? {},
-      catalogTypes: {
-        ...baseCatalogTypes,
-        ...bridgeCatalogTypes
-      }
-    }
-  };
-}
-function compileBusinessOntologyValidationIndex(model = DEFAULT_ORGANIZATION_MODEL) {
-  const compilation = compileOrganizationOntology(mergeBridgeCatalogs(model));
-  if (compilation.diagnostics.length > 0) {
-    const summary = compilation.diagnostics.map((diagnostic) => diagnostic.message).join("; ");
-    throw new Error(`Business ontology validation index failed to compile: ${summary}`);
-  }
-  const crmPipelineCatalog = compilation.ontology.catalogTypes[CRM_PIPELINE_CATALOG_ONTOLOGY_ID];
-  const leadGenStageCatalog = compilation.ontology.catalogTypes[LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID];
-  if (crmPipelineCatalog === void 0 || leadGenStageCatalog === void 0) {
-    throw new Error("Business ontology validation index is missing CRM or lead-gen catalog bridge records");
-  }
-  return {
-    ontology: compilation.ontology,
-    crmPipelineCatalog,
-    leadGenStageCatalog,
-    actionTypesByLegacyId: indexActionTypesByLegacyId(compilation.ontology.actionTypes)
-  };
-}
-function indexActionTypesByLegacyId(actionTypes) {
-  const byLegacyId = {};
-  for (const actionType of Object.values(actionTypes)) {
-    const legacyActionId = actionType["legacyActionId"];
-    if (typeof legacyActionId === "string") {
-      byLegacyId[legacyActionId] = actionType;
-    }
-  }
-  return byLegacyId;
-}
-var BUSINESS_ONTOLOGY_VALIDATION_INDEX = compileBusinessOntologyValidationIndex();
-function getCatalogEntries(catalog) {
-  return isPlainRecord(catalog.entries) ? catalog.entries : {};
-}
-function asCrmStageEntry(key, value) {
-  const record = isPlainRecord(value) ? value : {};
-  const label = typeof record.label === "string" ? record.label : key;
-  const order = typeof record.order === "number" ? record.order : 0;
-  const color = typeof record.color === "string" ? record.color : void 0;
-  const rawStates = Array.isArray(record.states) ? record.states : [];
-  const states = rawStates.flatMap((state) => {
-    if (!isPlainRecord(state) || typeof state.stateKey !== "string") return [];
-    return [
-      {
-        stateKey: state.stateKey,
-        label: typeof state.label === "string" ? state.label : state.stateKey
-      }
-    ];
-  });
-  return {
-    key,
-    label,
-    order,
-    ...color !== void 0 ? { color } : {},
-    states
-  };
-}
-var CRM_STAGE_KEYS_FROM_ONTOLOGY = Object.keys(
-  getCatalogEntries(BUSINESS_ONTOLOGY_VALIDATION_INDEX.crmPipelineCatalog)
-);
-var CRM_STATE_KEYS_FROM_ONTOLOGY = Object.values(
-  getCatalogEntries(BUSINESS_ONTOLOGY_VALIDATION_INDEX.crmPipelineCatalog)
-).flatMap((entry, index2) => {
-  const stageKey = CRM_STAGE_KEYS_FROM_ONTOLOGY[index2];
-  if (stageKey === void 0) return [];
-  return asCrmStageEntry(stageKey, entry).states.map((state) => state.stateKey);
-});
-Object.keys(
-  getCatalogEntries(BUSINESS_ONTOLOGY_VALIDATION_INDEX.leadGenStageCatalog)
-);
 
 // ../core/src/business/acquisition/api-schemas.ts
 var ProcessingStageStatusSchema = z.enum(["success", "no_result", "skipped", "error"]);
 var LeadGenStageKeySchema = z.string().trim().min(1);
 var LeadGenActionKeySchema = z.string().trim().min(1);
-var crmStageKeys = CRM_STAGE_KEYS_FROM_ONTOLOGY;
-var crmStateKeys = CRM_STATE_KEYS_FROM_ONTOLOGY;
-var CrmStageKeySchema = z.enum(crmStageKeys);
-var CrmStateKeySchema = z.enum(crmStateKeys);
+var CrmStageKeySchema = z.string().trim().min(1);
+var CrmStateKeySchema = z.string().trim().min(1);
 var ProcessingStateEntrySchema = z.object({
   status: ProcessingStageStatusSchema,
   data: z.unknown().optional()
@@ -9594,8 +7298,10 @@ var PipelineStageSchema = z.object({
   enabled: z.boolean().optional(),
   order: z.number().int().optional()
 });
+var DataModeSchema = z.enum(["mock", "live"]);
 var PipelineConfigSchema = z.object({
-  stages: z.array(PipelineStageSchema).optional()
+  stages: z.array(PipelineStageSchema).optional(),
+  dataMode: DataModeSchema.optional()
 });
 var BuildPlanSnapshotStepSchema = z.object({
   id: z.string().trim().min(1).max(100),
@@ -9652,9 +7358,7 @@ var BuildPlanSnapshotSchema = z.object({
 var AcqListMetadataSchema = z.object({
   buildPlanSnapshot: BuildPlanSnapshotSchema.optional()
 }).catchall(z.unknown());
-var ProspectingBuildTemplateIdSchema = z.string().trim().min(1).max(100).refine(isProspectingBuildTemplateId, {
-  message: "buildTemplateId must match a known prospecting build template"
-});
+var ProspectingBuildTemplateIdSchema = z.string().trim().min(1).max(100);
 var ListStageCountsSchema = z.object({
   // Attempted counts by canonical lead-gen stage. The detailed status
   // distribution lives on ListProgress; telemetry keeps the overview payload small.
@@ -10514,25 +8218,323 @@ createAdapter("execution", ["trigger", "triggerAsync"]);
 
 // src/worker/adapters/email.ts
 createAdapter("email", ["send"]);
-
-// ../core/src/organization-model/helpers.ts
+var OntologyKindSchema = z.enum([
+  "object",
+  "link",
+  "action",
+  "catalog",
+  "event",
+  "interface",
+  "value-type",
+  "property",
+  "group",
+  "surface"
+]);
+var SYSTEM_PATH_PATTERN = "[a-z0-9][a-z0-9-]*(?:\\.[a-z0-9][a-z0-9-]*)*";
+var LOCAL_ID_PATTERN = "[a-z0-9][a-z0-9._-]*";
+var ONTOLOGY_ID_PATTERN = `^(global|${SYSTEM_PATH_PATTERN}):(${OntologyKindSchema.options.join("|")})\\/(${LOCAL_ID_PATTERN})$`;
+var ONTOLOGY_ID_REGEX = new RegExp(ONTOLOGY_ID_PATTERN);
+var OntologyIdSchema = z.string().trim().min(1).max(300).regex(
+  ONTOLOGY_ID_REGEX,
+  "Ontology IDs must use <system-path>:<kind>/<local-id> or global:<kind>/<local-id>"
+);
+function parseOntologyId(id) {
+  const normalized = OntologyIdSchema.parse(id);
+  const match = ONTOLOGY_ID_REGEX.exec(normalized);
+  if (match === null) {
+    throw new Error(`Invalid ontology ID "${id}"`);
+  }
+  return {
+    id: normalized,
+    scope: match[1],
+    kind: match[2],
+    localId: match[3],
+    isGlobal: match[1] === "global"
+  };
+}
+function formatOntologyId(input) {
+  return OntologyIdSchema.parse(`${input.scope}:${input.kind}/${input.localId}`);
+}
+var OntologyReferenceListSchema = z.array(OntologyIdSchema).default([]).optional();
+var OntologyRecordBaseSchema = z.object({
+  id: OntologyIdSchema,
+  label: z.string().trim().min(1).max(160).optional(),
+  description: z.string().trim().min(1).max(2e3).optional(),
+  ownerSystemId: z.string().trim().min(1).max(200).optional(),
+  aliases: z.array(OntologyIdSchema).optional()
+}).passthrough();
+var OntologyObjectTypeSchema = OntologyRecordBaseSchema.extend({
+  properties: z.record(z.string().trim().min(1).max(200), z.unknown()).optional(),
+  storage: z.record(z.string(), z.unknown()).optional()
+});
+var OntologyLinkTypeSchema = OntologyRecordBaseSchema.extend({
+  from: OntologyIdSchema,
+  to: OntologyIdSchema,
+  cardinality: z.string().trim().min(1).max(80).optional(),
+  via: z.string().trim().min(1).max(255).optional()
+});
+var OntologyActionTypeSchema = OntologyRecordBaseSchema.extend({
+  actsOn: OntologyReferenceListSchema,
+  input: z.record(z.string().trim().min(1).max(200), z.unknown()).optional(),
+  effects: z.array(z.record(z.string(), z.unknown())).optional()
+});
+var OntologyCatalogTypeSchema = OntologyRecordBaseSchema.extend({
+  kind: z.string().trim().min(1).max(120).optional(),
+  appliesTo: OntologyIdSchema.optional(),
+  entries: z.record(z.string().trim().min(1).max(200), z.unknown()).optional()
+});
+var OntologyEventTypeSchema = OntologyRecordBaseSchema.extend({
+  payload: z.record(z.string().trim().min(1).max(200), z.unknown()).optional()
+});
+var OntologyInterfaceTypeSchema = OntologyRecordBaseSchema.extend({
+  properties: z.record(z.string().trim().min(1).max(200), z.unknown()).optional()
+});
+var OntologyValueTypeSchema = OntologyRecordBaseSchema.extend({
+  primitive: z.string().trim().min(1).max(120).optional()
+});
+var OntologySharedPropertySchema = OntologyRecordBaseSchema.extend({
+  valueType: OntologyIdSchema.optional(),
+  searchable: z.boolean().optional(),
+  pii: z.boolean().optional()
+});
+var OntologyGroupSchema = OntologyRecordBaseSchema.extend({
+  members: OntologyReferenceListSchema
+});
+var OntologySurfaceTypeSchema = OntologyRecordBaseSchema.extend({
+  route: z.string().trim().min(1).max(500).optional()
+});
+z.object({
+  objectTypes: z.record(OntologyIdSchema, OntologyObjectTypeSchema).default({}).optional(),
+  linkTypes: z.record(OntologyIdSchema, OntologyLinkTypeSchema).default({}).optional(),
+  actionTypes: z.record(OntologyIdSchema, OntologyActionTypeSchema).default({}).optional(),
+  catalogTypes: z.record(OntologyIdSchema, OntologyCatalogTypeSchema).default({}).optional(),
+  eventTypes: z.record(OntologyIdSchema, OntologyEventTypeSchema).default({}).optional(),
+  interfaceTypes: z.record(OntologyIdSchema, OntologyInterfaceTypeSchema).default({}).optional(),
+  valueTypes: z.record(OntologyIdSchema, OntologyValueTypeSchema).default({}).optional(),
+  sharedProperties: z.record(OntologyIdSchema, OntologySharedPropertySchema).default({}).optional(),
+  groups: z.record(OntologyIdSchema, OntologyGroupSchema).default({}).optional(),
+  surfaces: z.record(OntologyIdSchema, OntologySurfaceTypeSchema).default({}).optional()
+}).default({});
+var SCOPE_KIND = {
+  objectTypes: "object",
+  linkTypes: "link",
+  actionTypes: "action",
+  catalogTypes: "catalog",
+  eventTypes: "event",
+  interfaceTypes: "interface",
+  valueTypes: "value-type",
+  sharedProperties: "property",
+  groups: "group",
+  surfaces: "surface"
+};
+var SCOPE_KEYS = Object.keys(SCOPE_KIND);
+function originFromContext(context) {
+  return {
+    kind: context.kind,
+    source: context.source,
+    path: context.path,
+    ...context.systemPath !== void 0 ? { systemPath: context.systemPath } : {},
+    ...context.legacyId !== void 0 ? { legacyId: context.legacyId } : {}
+  };
+}
+function createEmptyIndex() {
+  return {
+    objectTypes: {},
+    linkTypes: {},
+    actionTypes: {},
+    catalogTypes: {},
+    eventTypes: {},
+    interfaceTypes: {},
+    valueTypes: {},
+    sharedProperties: {},
+    groups: {},
+    surfaces: {}
+  };
+}
+function sortResolvedOntologyIndex(index2) {
+  const sorted = createEmptyIndex();
+  for (const scopeKey of SCOPE_KEYS) {
+    const target = sorted[scopeKey];
+    for (const [id, record] of Object.entries(index2[scopeKey]).sort(
+      ([leftId], [rightId]) => leftId.localeCompare(rightId)
+    )) {
+      target[id] = record;
+    }
+  }
+  return sorted;
+}
 function childSystemsOf2(system) {
   return system.systems ?? system.subsystems ?? {};
 }
-function listAllSystems(model) {
-  const results = [];
-  function walk(map2, prefix) {
-    for (const [localId, system] of Object.entries(map2)) {
-      const fullPath = prefix ? `${prefix}.${localId}` : localId;
-      results.push({ path: fullPath, system });
-      const childSystems = childSystemsOf2(system);
-      if (Object.keys(childSystems).length > 0) {
-        walk(childSystems, fullPath);
-      }
+function addRecord(index2, diagnostics, sourcesById, scopeKey, record, context) {
+  let parsed;
+  try {
+    parsed = parseOntologyId(record.id);
+  } catch {
+    diagnostics.push({
+      code: "invalid_ontology_id",
+      message: `Invalid ontology ID "${record.id}" from ${context.source} at ${context.path.join(".")}`,
+      id: record.id,
+      path: context.path,
+      source: context.source,
+      origin: originFromContext(context)
+    });
+    return;
+  }
+  const expectedKind = SCOPE_KIND[scopeKey];
+  if (parsed.kind !== expectedKind) {
+    diagnostics.push({
+      code: "ontology_kind_mismatch",
+      message: `Ontology ID "${record.id}" has kind "${parsed.kind}" but was authored in ${scopeKey} (${expectedKind}) at ${context.path.join(".")}`,
+      id: record.id,
+      path: context.path,
+      source: context.source,
+      origin: originFromContext(context)
+    });
+    return;
+  }
+  const existing = sourcesById.get(parsed.id);
+  if (existing !== void 0) {
+    diagnostics.push({
+      code: "duplicate_ontology_id",
+      message: `Duplicate ontology ID "${parsed.id}" from ${context.source} at ${context.path.join(".")} conflicts with ${existing.source} at ${existing.path.join(".")}`,
+      id: parsed.id,
+      path: context.path,
+      source: context.source,
+      origin: originFromContext(context),
+      existingSource: existing.source,
+      existingOrigin: originFromContext(existing)
+    });
+    return;
+  }
+  sourcesById.set(parsed.id, context);
+  index2[scopeKey][parsed.id] = {
+    ...record,
+    origin: originFromContext(context)
+  };
+}
+function addScope(index2, diagnostics, sourcesById, scope, source, path) {
+  if (scope === void 0) return;
+  for (const scopeKey of SCOPE_KEYS) {
+    const records = scope[scopeKey] ?? {};
+    for (const [key, record] of Object.entries(records)) {
+      addRecord(index2, diagnostics, sourcesById, scopeKey, record, {
+        source,
+        path: [...path, scopeKey, key],
+        kind: "authored",
+        systemPath: source.startsWith("system:") ? source.slice("system:".length, -".ontology".length) : void 0
+      });
     }
   }
-  walk(model.systems, "");
-  return results;
+}
+function legacyObjectId(entity) {
+  return formatOntologyId({ scope: entity.ownedBySystemId, kind: "object", localId: entity.id });
+}
+function legacyActionOwner(action, entities) {
+  const firstAffectedEntityId = action.affects?.find((entityId) => entities[entityId] !== void 0);
+  if (firstAffectedEntityId !== void 0) {
+    return entities[firstAffectedEntityId].ownedBySystemId;
+  }
+  if (typeof action.scope === "object") {
+    return action.scope.domain;
+  }
+  return "global";
+}
+function addLegacyEntityProjections(index2, diagnostics, sourcesById, entities) {
+  for (const entity of Object.values(entities)) {
+    const objectType = {
+      id: legacyObjectId(entity),
+      label: entity.label,
+      description: entity.description,
+      ownerSystemId: entity.ownedBySystemId,
+      ...entity.table !== void 0 ? {
+        storage: {
+          kind: "table",
+          table: entity.table
+        }
+      } : {},
+      ...entity.rowSchema !== void 0 ? { rowSchema: entity.rowSchema } : {},
+      ...entity.stateCatalogId !== void 0 ? { stateCatalogId: entity.stateCatalogId } : {}
+    };
+    addRecord(index2, diagnostics, sourcesById, "objectTypes", objectType, {
+      source: "legacy.entities",
+      path: ["entities", entity.id],
+      kind: "projected",
+      systemPath: entity.ownedBySystemId,
+      legacyId: entity.id
+    });
+    entity.links?.forEach((link, linkIndex) => {
+      const targetEntity = entities[link.toEntity];
+      if (targetEntity === void 0) return;
+      const linkType = {
+        id: formatOntologyId({
+          scope: entity.ownedBySystemId,
+          kind: "link",
+          localId: `${entity.id}-${link.toEntity}-${linkIndex}`
+        }),
+        label: link.label ?? link.kind,
+        ownerSystemId: entity.ownedBySystemId,
+        from: legacyObjectId(entity),
+        to: legacyObjectId(targetEntity),
+        cardinality: link.kind,
+        ...link.via !== void 0 ? { via: link.via } : {}
+      };
+      addRecord(index2, diagnostics, sourcesById, "linkTypes", linkType, {
+        source: "legacy.entities.links",
+        path: ["entities", entity.id, "links", linkIndex],
+        kind: "projected",
+        systemPath: entity.ownedBySystemId,
+        legacyId: `${entity.id}.links.${linkIndex}`
+      });
+    });
+  }
+}
+function addLegacyActionProjections(index2, diagnostics, sourcesById, actions, entities) {
+  for (const action of Object.values(actions)) {
+    const ownerSystemId = legacyActionOwner(action, entities);
+    const actionType = {
+      id: formatOntologyId({ scope: ownerSystemId, kind: "action", localId: action.id }),
+      label: action.label,
+      description: action.description,
+      ownerSystemId,
+      actsOn: action.affects?.map((entityId) => entities[entityId] ? legacyObjectId(entities[entityId]) : void 0).filter((id) => id !== void 0),
+      ...action.resourceId !== void 0 ? { resourceId: action.resourceId } : {},
+      ...action.invocations !== void 0 ? { invocations: action.invocations } : {},
+      ...action.lifecycle !== void 0 ? { lifecycle: action.lifecycle } : {},
+      legacyActionId: action.id
+    };
+    addRecord(index2, diagnostics, sourcesById, "actionTypes", actionType, {
+      source: "legacy.actions",
+      path: ["actions", action.id],
+      kind: "projected",
+      systemPath: ownerSystemId,
+      legacyId: action.id
+    });
+  }
+}
+function addSystemScopes(index2, diagnostics, sourcesById, systems, prefix, schemaPath) {
+  for (const [key, system] of Object.entries(systems)) {
+    const systemPath = prefix ? `${prefix}.${key}` : key;
+    const currentPath = [...schemaPath, key];
+    addScope(index2, diagnostics, sourcesById, system.ontology, `system:${systemPath}.ontology`, [
+      ...currentPath,
+      "ontology"
+    ]);
+    addSystemScopes(index2, diagnostics, sourcesById, childSystemsOf2(system), systemPath, [
+      ...currentPath,
+      system.systems !== void 0 ? "systems" : "subsystems"
+    ]);
+  }
+}
+function compileOrganizationOntology(model) {
+  const ontology = createEmptyIndex();
+  const diagnostics = [];
+  const sourcesById = /* @__PURE__ */ new Map();
+  addScope(ontology, diagnostics, sourcesById, model.ontology, "organization.ontology", ["ontology"]);
+  addSystemScopes(ontology, diagnostics, sourcesById, model.systems ?? {}, "", ["systems"]);
+  addLegacyEntityProjections(ontology, diagnostics, sourcesById, model.entities ?? {});
+  addLegacyActionProjections(ontology, diagnostics, sourcesById, model.actions ?? {}, model.entities ?? {});
+  return { ontology: sortResolvedOntologyIndex(ontology), diagnostics };
 }
 z.object({
   success: z.boolean(),
@@ -11182,34 +9184,11 @@ function captureConsole(executionId, logs) {
     postLog
   };
 }
-var LOG_STRING_TRUNCATE_LIMIT = 200;
-function truncateForLogging(value) {
-  if (value === null || value === void 0) return value;
-  if (typeof value === "string") {
-    return value.length > LOG_STRING_TRUNCATE_LIMIT ? value.slice(0, LOG_STRING_TRUNCATE_LIMIT) + `\u2026 [${value.length} chars]` : value;
-  }
-  if (Array.isArray(value)) {
-    return value.map(truncateForLogging);
-  }
-  if (typeof value === "object") {
-    const result = {};
-    for (const [k2, v2] of Object.entries(value)) {
-      result[k2] = truncateForLogging(v2);
-    }
-    return result;
-  }
-  return value;
-}
-function resolveNext(next, data) {
-  if (next === null) return null;
-  if (next.type === "linear") return next.target;
-  for (const route of next.routes) {
-    if (route.condition(data)) return route.target;
-  }
-  return next.default;
+function isZodSchema(schema) {
+  return typeof schema === "object" && schema !== null && "parse" in schema && "_def" in schema;
 }
 function safeZodToJsonSchema(schema) {
-  if (!schema || typeof schema !== "object" || !("parse" in schema)) return void 0;
+  if (!isZodSchema(schema)) return void 0;
   try {
     const result = zodToJsonSchema(schema, { $refStrategy: "none", errorMessages: true });
     if (result && typeof result === "object" && Object.keys(result).some((k2) => k2 !== "$schema")) {
@@ -11228,84 +9207,28 @@ async function executeWorkflow(workflow, input, context) {
   const logs = [];
   const { restore, postLog } = captureConsole(context.executionId, logs);
   try {
-    let currentData = workflow.contract.inputSchema ? workflow.contract.inputSchema.parse(input) : input;
-    let stepId = workflow.entryPoint;
-    while (stepId !== null) {
-      const step = workflow.steps[stepId];
-      if (!step) {
-        throw new Error(`Step '${stepId}' not found in workflow '${workflow.config.resourceId}'`);
-      }
-      const stepStartTime = Date.now();
-      const stepInput = step.inputSchema.parse(currentData);
-      postLog("info", `Step '${step.name}' started`, {
-        type: "workflow",
-        contextType: "step-started",
-        stepId: step.id,
-        stepStatus: "started",
-        input: truncateForLogging(stepInput),
-        startTime: stepStartTime
-      });
-      try {
-        const rawOutput = await step.handler(stepInput, {
-          executionId: context.executionId,
-          organizationId: context.organizationId,
-          organizationName: context.organizationName,
-          resourceId: workflow.config.resourceId,
-          sessionId: context.sessionId,
-          sessionTurnNumber: context.sessionTurnNumber,
-          parentExecutionId: context.parentExecutionId,
-          executionDepth: context.executionDepth,
-          adapters: context.adapters,
-          store: /* @__PURE__ */ new Map(),
-          logger: {
-            debug: (msg) => console.log(`[debug] ${msg}`),
-            info: (msg) => console.log(`[info] ${msg}`),
-            warn: (msg) => console.warn(`[warn] ${msg}`),
-            error: (msg) => console.error(`[error] ${msg}`)
-          }
-        });
-        currentData = step.outputSchema.parse(rawOutput);
-        const stepEndTime = Date.now();
-        const nextStepId = resolveNext(step.next, currentData);
-        postLog("info", `Step '${step.name}' completed (${stepEndTime - stepStartTime}ms)`, {
-          type: "workflow",
-          contextType: "step-completed",
-          stepId: step.id,
-          stepStatus: "completed",
-          output: truncateForLogging(currentData),
-          duration: stepEndTime - stepStartTime,
-          isTerminal: nextStepId === null,
-          startTime: stepStartTime,
-          endTime: stepEndTime
-        });
-        if (step.next?.type === "conditional" && nextStepId !== null) {
-          postLog("info", `Routing from '${step.name}' to '${nextStepId}'`, {
-            type: "workflow",
-            contextType: "conditional-route",
-            stepId: step.id,
-            target: nextStepId
-          });
-        }
-        stepId = nextStepId;
-      } catch (err) {
-        const stepEndTime = Date.now();
-        postLog("error", `Step '${step.name}' failed: ${String(err)}`, {
-          type: "workflow",
-          contextType: "step-failed",
-          stepId: step.id,
-          stepStatus: "failed",
-          error: String(err),
-          duration: stepEndTime - stepStartTime,
-          startTime: stepStartTime,
-          endTime: stepEndTime
-        });
-        throw err;
+    const workflowInstance = new Workflow(workflow);
+    const workerContext = {
+      executionId: context.executionId,
+      organizationId: context.organizationId,
+      organizationName: context.organizationName,
+      resourceId: workflow.config.resourceId,
+      sessionId: context.sessionId,
+      sessionTurnNumber: context.sessionTurnNumber,
+      parentExecutionId: context.parentExecutionId,
+      executionDepth: context.executionDepth,
+      signal: context.signal,
+      adapters: context.adapters,
+      store: /* @__PURE__ */ new Map(),
+      logger: {
+        debug: (message, logContext) => postLog("debug", message, logContext),
+        info: (message, logContext) => postLog("info", message, logContext),
+        warn: (message, logContext) => postLog("warn", message, logContext),
+        error: (message, logContext) => postLog("error", message, logContext)
       }
-    }
-    if (workflow.contract.outputSchema) {
-      currentData = workflow.contract.outputSchema.parse(currentData);
-    }
-    return { output: currentData, logs };
+    };
+    const output = await workflowInstance.execute(input, workerContext);
+    return { output, logs };
   } finally {
     restore();
   }
@@ -11444,7 +9367,8 @@ function startWorker(org) {
             sessionId,
             sessionTurnNumber,
             parentExecutionId,
-            executionDepth: executionDepth ?? 0
+            executionDepth: executionDepth ?? 0,
+            signal: localAbortController.signal
           });
           const durationMs = Date.now() - startTime;
           console.log(`[SDK-WORKER] Workflow '${resourceId}' completed (${durationMs}ms)`);
@@ -11488,9 +9412,10 @@ function startWorker(org) {
           parentPort.postMessage({ type: "result", status: "completed", output, logs, metrics: { durationMs } });
         } catch (err) {
           const durationMs = Date.now() - startTime;
-          const errorMessage = err?.message ?? String(err);
-          err?.code ?? "unknown";
-          const errorName = err?.name ?? err?.constructor?.name ?? "Error";
+          const errorRecord = err instanceof Error ? err : void 0;
+          const errorMessage = errorRecord?.message ?? String(err);
+          err !== null && typeof err === "object" && "code" in err ? String(err.code) : "unknown";
+          const errorName = errorRecord?.name ?? (err !== null && typeof err === "object" && err.constructor?.name ? err.constructor.name : "Error");
           console.error(`[SDK-WORKER] Agent '${resourceId}' failed (${durationMs}ms): [${errorName}] ${errorMessage}`);
           parentPort.postMessage({
             type: "result",