@elevasis/sdk 1.23.0 → 1.25.0

package/dist/worker/index.js

@@ -1,5 +1,6 @@
 import { workerData, parentPort } from 'worker_threads';
 import { z, ZodError } from 'zod';
+import { createHmac } from 'crypto';
 
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
@@ -2059,6 +2060,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);
@@ -2080,6 +2087,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 [k, v] of Object.entries(value)) {
+      result[k] = truncateForLogging(v);
+    }
+    return result;
+  }
+  return value;
+}
+
 // ../core/src/execution/engine/base/errors.ts
 var ExecutionError = class extends Error {
   /**
@@ -2120,6 +2147,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((r) => r.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 {
@@ -4689,7 +5015,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,
@@ -4728,410 +5054,6 @@ 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" }
-    ]
-  }
-];
-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 LEAD_GEN_ACTION_ENTRY_INPUTS = [
-  {
-    id: "lead-gen.company.source",
-    order: 10,
-    label: "Source companies",
-    description: "Import source companies from a list provider.",
-    scope: { domain: "sales" },
-    resourceId: "lgn-import-workflow",
-    invocations: [{ kind: "api-endpoint", method: "POST", path: "/api/prospecting/companies/source" }]
-  },
-  {
-    id: "lead-gen.company.apollo-import",
-    order: 20,
-    label: "Import from Apollo",
-    description: "Pull companies and seed contact data from an Apollo search or list.",
-    scope: { domain: "sales" },
-    resourceId: "lgn-01c-apollo-import-workflow",
-    invocations: [{ kind: "api-endpoint", method: "POST", path: "/api/prospecting/companies/apollo-import" }]
-  },
-  {
-    id: "lead-gen.contact.discover",
-    order: 30,
-    label: "Discover contact emails",
-    description: "Find email addresses for contacts at qualified companies.",
-    scope: { domain: "sales" },
-    resourceId: "lgn-04-email-discovery-workflow",
-    invocations: [{ kind: "api-endpoint", method: "POST", path: "/api/prospecting/contacts/discover" }]
-  },
-  {
-    id: "lead-gen.contact.verify-email",
-    order: 40,
-    label: "Verify emails",
-    description: "Check email deliverability before outreach.",
-    scope: { domain: "sales" },
-    resourceId: "lgn-05-email-verification-workflow",
-    invocations: [{ kind: "api-endpoint", method: "POST", path: "/api/prospecting/contacts/verify-email" }]
-  },
-  {
-    id: "lead-gen.company.apify-crawl",
-    order: 50,
-    label: "Crawl websites",
-    description: "Crawl company websites via Apify and store raw page markdown in enrichmentData.websiteCrawl.pages for downstream LLM analysis.",
-    scope: { domain: "sales" },
-    resourceId: "lgn-02a-apify-website-crawl-workflow",
-    invocations: [{ kind: "api-endpoint", method: "POST", path: "/api/prospecting/companies/apify-crawl" }]
-  },
-  {
-    id: "lead-gen.company.website-extract",
-    order: 60,
-    label: "Extract website signals",
-    description: "Scrape and analyze company websites for qualification signals.",
-    scope: { domain: "sales" },
-    resourceId: "lgn-02-website-extract-workflow",
-    invocations: [{ kind: "api-endpoint", method: "POST", path: "/api/prospecting/companies/website-extract" }]
-  },
-  {
-    id: "lead-gen.company.qualify",
-    order: 70,
-    label: "Qualify companies",
-    description: "Score and filter companies against the ICP rubric.",
-    scope: { domain: "sales" },
-    resourceId: "lgn-03-company-qualification-workflow",
-    invocations: [{ kind: "api-endpoint", method: "POST", path: "/api/prospecting/companies/qualify" }]
-  },
-  {
-    id: "lead-gen.company.dtc-subscription-qualify",
-    order: 80,
-    label: "Qualify DTC subscription fit",
-    description: "Classify subscription potential and consumable-product fit for DTC brands.",
-    scope: { domain: "sales" },
-    resourceId: "lgn-03b-dtc-subscription-score-workflow",
-    invocations: [{ kind: "api-endpoint", method: "POST", path: "/api/prospecting/companies/dtc-subscription-qualify" }]
-  },
-  {
-    id: "lead-gen.contact.apollo-decision-maker-enrich",
-    order: 90,
-    label: "Enrich decision-makers",
-    description: "Find and enrich qualified contacts at qualified companies via Apollo.",
-    scope: { domain: "sales" },
-    resourceId: "lgn-04b-apollo-decision-maker-enrich-workflow",
-    invocations: [
-      { kind: "api-endpoint", method: "POST", path: "/api/prospecting/contacts/apollo-decision-maker-enrich" }
-    ]
-  },
-  {
-    id: "lead-gen.contact.personalize",
-    order: 100,
-    label: "Personalize outreach",
-    description: "Generate personalized opening lines for each contact.",
-    scope: { domain: "sales" },
-    resourceId: "ist-personalization-workflow",
-    invocations: [{ kind: "api-endpoint", method: "POST", path: "/api/prospecting/contacts/personalize" }]
-  },
-  {
-    id: "lead-gen.review.outreach-ready",
-    order: 110,
-    label: "Upload to outreach",
-    description: "Upload approved contacts to the outreach sequence after QC review.",
-    scope: { domain: "sales" },
-    resourceId: "ist-upload-contacts-workflow",
-    invocations: [{ kind: "api-endpoint", method: "POST", path: "/api/prospecting/review/outreach-ready" }]
-  },
-  {
-    id: "lead-gen.export.list",
-    order: 120,
-    label: "Export lead list",
-    description: "Export approved leads as a downloadable lead list.",
-    scope: { domain: "sales" },
-    resourceId: "lgn-06-export-list-workflow",
-    invocations: [{ kind: "api-endpoint", method: "POST", path: "/api/prospecting/export/list" }]
-  },
-  {
-    id: "lead-gen.company.cleanup",
-    order: 130,
-    label: "Clean up companies",
-    description: "Remove disqualified or duplicate companies from the list.",
-    scope: { domain: "sales" },
-    resourceId: "lgn-company-cleanup-workflow",
-    invocations: [{ kind: "api-endpoint", method: "POST", path: "/api/prospecting/companies/cleanup" }]
-  }
-];
-var LEAD_GEN_ACTION_ENTRIES = Object.fromEntries(
-  LEAD_GEN_ACTION_ENTRY_INPUTS.map((action) => {
-    const parsed = ActionSchema.parse(action);
-    return [parsed.id, parsed];
-  })
-);
-var CRM_ACTION_ENTRY_INPUTS = [
-  {
-    id: "send_reply",
-    order: 210,
-    label: "Send Reply",
-    description: "Send a contextual reply for an active CRM deal.",
-    scope: { domain: "sales" },
-    resourceId: "crm-send-reply-workflow",
-    affects: ["crm.deal"]
-  },
-  {
-    id: "send_link",
-    order: 220,
-    label: "Send Booking Link",
-    description: "Send a booking link to move a deal toward a scheduled call.",
-    scope: { domain: "sales" },
-    resourceId: "crm-send-booking-link-workflow",
-    affects: ["crm.deal"]
-  },
-  {
-    id: "send_nudge",
-    order: 230,
-    label: "Send Nudge",
-    description: "Send a follow-up nudge for a stalled CRM deal.",
-    scope: { domain: "sales" },
-    resourceId: "crm-send-nudge-workflow",
-    affects: ["crm.deal"]
-  },
-  {
-    id: "rebook",
-    order: 240,
-    label: "Rebook",
-    description: "Rebook a missed or rescheduled CRM appointment.",
-    scope: { domain: "sales" },
-    resourceId: "crm-rebook-workflow",
-    affects: ["crm.deal"]
-  },
-  {
-    id: "move_to_proposal",
-    order: 250,
-    label: "Move to Proposal",
-    description: "Advance a qualified CRM deal into the proposal stage.",
-    scope: { domain: "sales" },
-    resourceId: "move_to_proposal-workflow",
-    affects: ["crm.deal"]
-  },
-  {
-    id: "move_to_closing",
-    order: 260,
-    label: "Move to Closing",
-    description: "Advance a proposal-stage CRM deal into closing.",
-    scope: { domain: "sales" },
-    resourceId: "move_to_closing-workflow",
-    affects: ["crm.deal"]
-  },
-  {
-    id: "move_to_closed_won",
-    order: 270,
-    label: "Close Won",
-    description: "Mark a CRM deal as closed won.",
-    scope: { domain: "sales" },
-    resourceId: "move_to_closed_won-workflow",
-    affects: ["crm.deal"]
-  },
-  {
-    id: "move_to_closed_lost",
-    order: 280,
-    label: "Close Lost",
-    description: "Mark a CRM deal as closed lost.",
-    scope: { domain: "sales" },
-    resourceId: "move_to_closed_lost-workflow",
-    affects: ["crm.deal"]
-  },
-  {
-    id: "move_to_nurturing",
-    order: 290,
-    label: "Move to Nurturing",
-    description: "Move a CRM deal into nurturing for future follow-up.",
-    scope: { domain: "sales" },
-    resourceId: "move_to_nurturing-workflow",
-    affects: ["crm.deal"]
-  }
-];
-var CRM_ACTION_ENTRIES = Object.fromEntries(
-  CRM_ACTION_ENTRY_INPUTS.map((action) => {
-    const parsed = ActionSchema.parse(action);
-    return [parsed.id, parsed];
-  })
-);
-var DEFAULT_ORGANIZATION_MODEL_ACTIONS = {
-  ...LEAD_GEN_ACTION_ENTRIES,
-  ...CRM_ACTION_ENTRIES
-};
-
 // ../core/src/organization-model/domains/prospecting.ts
 DisplayMetadataSchema.extend({
   id: ModelIdSchema,
@@ -5269,7 +5191,6 @@ var DTC_RECORD_COLUMNS = {
     ]
   }
 };
-Object.values(LEAD_GEN_ACTION_ENTRIES);
 var PROSPECTING_STEPS = {
   localServices: {
     sourceCompanies: {
@@ -5515,3171 +5436,22 @@ var PROSPECTING_BUILD_TEMPLATE_OPTIONS = BUILD_TEMPLATE_CATALOG.map(({ id, label
 function isProspectingBuildTemplateId(value) {
   return PROSPECTING_BUILD_TEMPLATE_OPTIONS.some((template) => template.id === value);
 }
-
-// ../core/src/organization-model/catalogs/lead-gen.ts
-var LEAD_GEN_STAGE_CATALOG = {
-  // Prospecting - company population
-  scraped: {
-    key: "scraped",
-    label: "Scraped",
-    description: "Company was scraped from a source directory (Apify actor run).",
-    order: 1,
-    entity: "company"
-  },
-  populated: {
-    key: "populated",
-    label: "Companies found",
-    description: "Companies have been found and added to the lead-gen list.",
-    order: 2,
-    entity: "company"
-  },
-  crawled: {
-    key: "crawled",
-    label: "Websites crawled",
-    description: "Company websites have been crawled (e.g. via Apify) and raw page content stored for downstream LLM analysis.",
-    order: 2.5,
-    entity: "company"
-  },
-  extracted: {
-    key: "extracted",
-    label: "Websites analyzed",
-    description: "Company websites have been analyzed for business signals.",
-    order: 3,
-    entity: "company"
-  },
-  enriched: {
-    key: "enriched",
-    label: "Enriched",
-    description: "Company or contact enriched with third-party data (e.g. Tomba, Anymailfinder).",
-    order: 4,
-    entity: "company"
-  },
-  "decision-makers-enriched": {
-    key: "decision-makers-enriched",
-    label: "Decision-makers found",
-    description: "Decision-maker contacts discovered and attached to a qualified company.",
-    order: 6,
-    entity: "company",
-    recordEntity: "contact",
-    recordStageKey: "discovered"
-  },
-  // Prospecting - contact discovery
-  discovered: {
-    key: "discovered",
-    label: "Decision-makers found",
-    description: "Decision-maker contact details have been found.",
-    order: 5,
-    entity: "contact"
-  },
-  verified: {
-    key: "verified",
-    label: "Emails verified",
-    description: "Contact email addresses have been checked for deliverability.",
-    order: 7,
-    entity: "contact"
-  },
-  // Qualification
-  qualified: {
-    key: "qualified",
-    label: "Companies qualified",
-    description: "Companies have been scored against the qualification criteria.",
-    order: 8,
-    entity: "company"
-  },
-  // Outreach
-  personalized: {
-    key: "personalized",
-    label: "Personalized",
-    description: "Outreach message personalized for the contact (Instantly personalization workflow).",
-    order: 9,
-    entity: "contact"
-  },
-  uploaded: {
-    key: "uploaded",
-    label: "Reviewed and exported",
-    description: "Approved records have been reviewed and exported for handoff.",
-    order: 10,
-    entity: "company",
-    additionalEntities: ["contact"]
-  },
-  interested: {
-    key: "interested",
-    label: "Interested",
-    description: "Contact replied with a positive signal (Instantly reply-handler transition).",
-    order: 11,
-    entity: "contact"
-  }
-};
-
-// ../core/src/organization-model/domains/sales.ts
-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: [] }
-  ]
-};
-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 ContentNodeBaseSchema = z.object({
-  /** Human-readable label for the content node. */
-  label: z.string().trim().min(1).max(120).meta({ label: "Label" }),
-  /** Optional one-paragraph description. */
-  description: z.string().trim().min(1).max(2e3).optional().meta({ label: "Description" }),
-  /** Optional display order within the system content map. */
-  order: z.number().int().optional().meta({ label: "Order" }),
-  /**
-   * Local NodeId of the parent content node within the SAME system.
-   * Per B4/L9: MUST resolve to a sibling in the same `system.content` map.
-   * Per L19: parent and child MUST share the same `kind` (meta-category).
-   */
-  parentContentId: z.string().trim().min(1).max(200).optional().meta({ label: "Parent content id" })
-});
-var ContentNodeSchema = ContentNodeBaseSchema.extend({
-  /** Meta-category (e.g. 'schema', 'config', 'knowledge', tenant-defined). */
-  kind: z.string().trim().min(1).max(100).meta({ label: "Kind" }),
-  /** Specific family within the meta-category (e.g. 'pipeline', 'kv'). */
-  type: z.string().trim().min(1).max(100).meta({ label: "Type" }),
-  /** Payload data; validated against registered payloadSchema when (kind, type) is known. */
-  data: z.record(z.string(), z.unknown()).optional().meta({ label: "Data" })
-});
-z.object({
-  /** Meta-category (tenant-defined or registry-shipped). */
-  kind: z.string().trim().min(1).max(100).meta({ label: "Kind" }),
-  /** Specific family within the meta-category. */
-  type: z.string().trim().min(1).max(100).meta({ label: "Type" }),
-  /** Human-readable label shown in the KB tree and describe views. */
-  label: z.string().trim().min(1).max(120).meta({ label: "Label" }),
-  /** Optional description. */
-  description: z.string().trim().min(1).max(2e3).optional().meta({ label: "Description" }),
-  /**
-   * Which KB tree group this extension renders in.
-   * Per L6: 'business-model' places it alongside Customers / Offerings / Goals.
-   */
-  treeGroup: z.union([z.enum(["profile", "business-model", "systems", "graph", "governance-wiring"]), z.string().min(1).max(100)]).meta({ label: "Tree group" }),
-  /** Untyped payload; shape governed by the registered payloadSchema when available. */
-  data: z.record(z.string(), z.unknown()).optional().meta({ label: "Data" })
-});
-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(index) {
-  return SCOPE_KEYS.flatMap((scopeKey) => {
-    const kind = SCOPE_KIND[scopeKey];
-    return Object.entries(index[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(index) {
-  const sorted = createEmptyIndex();
-  for (const scopeKey of SCOPE_KEYS) {
-    const target = sorted[scopeKey];
-    for (const [id, record] of Object.entries(index[scopeKey]).sort(
-      ([leftId], [rightId]) => leftId.localeCompare(rightId)
-    )) {
-      target[id] = record;
-    }
-  }
-  return sorted;
-}
-function childSystemsOf(system) {
-  return system.systems ?? system.subsystems ?? {};
-}
-function addRecord(index, 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);
-  index[scopeKey][parsed.id] = {
-    ...record,
-    origin: originFromContext(context)
-  };
-}
-function addScope(index, 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(index, 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(index, 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(index, 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(index, 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(index, 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(index, diagnostics, sourcesById, "actionTypes", actionType, {
-      source: "legacy.actions",
-      path: ["actions", action.id],
-      kind: "projected",
-      systemPath: ownerSystemId,
-      legacyId: action.id
-    });
-  }
-}
-function addSystemContentProjections(index, diagnostics, sourcesById, systemPath, system, schemaPath) {
-  const content = system.content ?? {};
-  for (const [localId, node] of Object.entries(content)) {
-    if (node.kind !== "schema") continue;
-    const entries = Object.fromEntries(
-      Object.entries(content).filter(([, candidate]) => candidate.parentContentId === localId).map(([entryId, candidate]) => [
-        entryId,
-        {
-          label: candidate.label ?? entryId,
-          type: candidate.type,
-          ...candidate.description !== void 0 ? { description: candidate.description } : {},
-          ...candidate.data !== void 0 ? candidate.data : {}
-        }
-      ])
-    );
-    const catalogType = {
-      id: formatOntologyId({ scope: systemPath, kind: "catalog", localId }),
-      label: node.label ?? localId,
-      description: node.description,
-      ownerSystemId: systemPath,
-      kind: node.type,
-      ...typeof node.data?.["entityId"] === "string" ? { appliesTo: formatOntologyId({ scope: systemPath, kind: "object", localId: node.data["entityId"] }) } : {},
-      ...Object.keys(entries).length > 0 ? { entries } : {},
-      ...node.data !== void 0 ? { data: node.data } : {}
-    };
-    addRecord(index, diagnostics, sourcesById, "catalogTypes", catalogType, {
-      source: "legacy.system.content",
-      path: [...schemaPath, "content", localId],
-      kind: "projected",
-      systemPath,
-      legacyId: `${systemPath}:${localId}`
-    });
-  }
-}
-function addSystemScopes(index, diagnostics, sourcesById, systems, prefix, schemaPath) {
-  for (const [key, system] of Object.entries(systems)) {
-    const systemPath = prefix ? `${prefix}.${key}` : key;
-    const currentPath = [...schemaPath, key];
-    addScope(index, diagnostics, sourcesById, system.ontology, `system:${systemPath}.ontology`, [
-      ...currentPath,
-      "ontology"
-    ]);
-    addSystemContentProjections(index, diagnostics, sourcesById, systemPath, system, currentPath);
-    addSystemScopes(index, 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 content-node:sales.crm:pipeline-id)"
-);
-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(),
-  /**
-   * @deprecated Compatibility-only bridge for old tenant content nodes and
-   * migration readers. New schema/catalog authoring belongs in ontology;
-   * new system-local settings belong in config. Bridge nodes are keyed by
-   * local NodeId and may still project to content-node:* graph IDs.
-   */
-  content: z.record(z.string().trim().min(1).max(200), ContentNodeSchema).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()
-}).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
-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()
-}).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, index) => visit(entry, [...path, index]));
-      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 = {};
-
-// ../core/src/organization-model/content-kinds/registry.ts
-function defineContentType(def) {
-  return def;
-}
-var PipelinePayloadSchema = z.object({
-  /**
-   * Local NodeId of the entity this pipeline applies to (e.g. 'crm.deal').
-   * `.meta({ ref: 'entity' })` enables SchemaDrivenFieldList to render a
-   * clickable graph link to the referenced entity node.
-   */
-  entityId: z.string().trim().min(1).max(200).meta({ label: "Entity", ref: "entity", hint: "The entity type this pipeline tracks" }),
-  /**
-   * Optional Kanban column color token for UI rendering.
-   */
-  kanbanColor: z.string().trim().min(1).max(40).optional().meta({ label: "Kanban color", hint: "UI color token" })
-});
-var pipelineKind = defineContentType({
-  kind: "schema",
-  type: "pipeline",
-  label: "Pipeline",
-  description: "A named progression pipeline that applies to a specific entity type.",
-  payloadSchema: PipelinePayloadSchema,
-  parentTypes: []
-});
-var StagePayloadSchema = z.object({
-  /**
-   * Semantic classification for this stage.
-   * Drives color, icon, and CRM-priority logic in consuming views.
-   * Optional — prospecting stages use data.entityKind instead.
-   * Enum aligned with SalesStageSemanticClassSchema (sales.ts).
-   */
-  semanticClass: z.enum(["open", "active", "nurturing", "closed_won", "closed_lost", "won", "lost", "closed"]).optional().meta({ label: "Semantic class", hint: "Semantic meaning of this stage", color: "blue" })
-});
-var stageKind = defineContentType({
-  kind: "schema",
-  type: "stage",
-  label: "Stage",
-  description: "A stage within a pipeline. Must be parented under a schema:pipeline content node.",
-  payloadSchema: StagePayloadSchema,
-  parentTypes: ["schema:pipeline"]
-});
-var TemplatePayloadSchema = z.object({
-  /**
-   * Optional description surfaced in the KB describe view and tooling.
-   */
-  description: z.string().trim().min(1).max(2e3).optional().meta({ label: "Description", hint: "What this template is used for" })
-});
-var templateKind = defineContentType({
-  kind: "schema",
-  type: "template",
-  label: "Template",
-  description: "A named build template (e.g. a prospecting pipeline sequence).",
-  payloadSchema: TemplatePayloadSchema,
-  parentTypes: []
-});
-var TemplateStepPayloadSchema = z.object({
-  /**
-   * Which entity type this step primarily operates on.
-   */
-  primaryEntity: z.enum(["company", "contact"]).meta({ label: "Primary entity", hint: "Entity type this step processes", color: "blue" }),
-  /**
-   * Action key identifying the workflow action executed by this step.
-   * `.meta({ ref: 'action' })` enables SchemaDrivenFieldList to render a
-   * clickable graph link.
-   */
-  actionKey: z.string().trim().min(1).max(200).meta({ label: "Action", ref: "action", hint: "Workflow action executed by this step" }),
-  /**
-   * IDs of sibling step local NodeIds this step depends on.
-   */
-  dependsOn: z.array(z.string().trim().min(1).max(200)).optional().meta({ label: "Depends on", hint: "Local NodeIds of prerequisite steps" })
-});
-var templateStepKind = defineContentType({
-  kind: "schema",
-  type: "template-step",
-  label: "Template Step",
-  description: "A step within a build template. Must be parented under a schema:template content node.",
-  payloadSchema: TemplateStepPayloadSchema,
-  parentTypes: ["schema:template"]
-});
-var StatusFlowPayloadSchema = z.object({
-  /**
-   * Which entity scope this status flow governs.
-   */
-  appliesTo: z.enum(["project", "milestone", "task"]).meta({ label: "Applies to", hint: "Entity scope governed by this status flow", color: "blue" })
-});
-var statusFlowKind = defineContentType({
-  kind: "schema",
-  type: "status-flow",
-  label: "Status Flow",
-  description: "A named set of statuses governing a project, milestone, or task entity.",
-  payloadSchema: StatusFlowPayloadSchema,
-  parentTypes: []
-});
-var StatusPayloadSchema = z.object({
-  /**
-   * Semantic classification string for this status.
-   * Free-form to allow tenant-defined classifications (e.g. 'active', 'blocked',
-   * 'completed'). Used by UI to apply color and icon fallbacks.
-   * Optional — status nodes may omit this when the label is self-descriptive.
-   */
-  semanticClass: z.string().trim().min(1).max(100).optional().meta({ label: "Semantic class", hint: "Semantic meaning of this status (e.g. active, blocked, completed)" }),
-  /**
-   * Optional UI color token override for this status.
-   */
-  color: z.string().trim().min(1).max(40).optional().meta({ label: "Color", hint: "UI color token" })
-});
-var statusKind = defineContentType({
-  kind: "schema",
-  type: "status",
-  label: "Status",
-  description: "A single status within a status flow. Must be parented under a schema:status-flow content node.",
-  payloadSchema: StatusPayloadSchema,
-  parentTypes: ["schema:status-flow"]
-});
-var ConfigKvPayloadSchema = z.object({
-  /**
-   * Flat key-value entries. Values are JSON primitives.
-   * Keys are short identifiers (e.g. 'maxBatchSize', 'featureEnabled').
-   */
-  entries: z.record(z.string().trim().min(1).max(200), z.union([z.string(), z.number(), z.boolean(), z.null()])).meta({ label: "Entries", hint: "Key-value configuration entries (string, number, boolean, or null values)" })
-});
-var configKvKind = defineContentType({
-  kind: "config",
-  type: "kv",
-  label: "Key-Value Config",
-  description: "A flat key-value configuration store co-located with a system. Values are JSON primitives.",
-  payloadSchema: ConfigKvPayloadSchema,
-  parentTypes: []
-});
-
-// ../core/src/organization-model/content-kinds/index.ts
-var CONTENT_KIND_REGISTRY = {
-  "schema:pipeline": pipelineKind,
-  "schema:stage": stageKind,
-  "schema:template": templateKind,
-  "schema:template-step": templateStepKind,
-  "schema:status-flow": statusFlowKind,
-  "schema:status": statusKind,
-  "config:kv": configKvKind
-};
-function lookupContentType(kind, type) {
-  const key = `${kind}:${type}`;
-  return CONTENT_KIND_REGISTRY[key];
-}
-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",
-  // D4: content nodes are a valid knowledge target after compound-domain data moved into system.content
-  "content-node"
-]).meta({ label: "Target kind" });
-var KnowledgeTargetRefSchema = z.object({
-  kind: KnowledgeTargetKindSchema,
-  // D4: content-node targets use a qualified id format '<system-path>:<local-content-id>'.
-  // 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])])
-});
-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 stageIds = /* @__PURE__ */ new Set();
-  const actionIds = new Set(Object.keys(model.actions));
-  const offeringsById = new Map(Object.entries(model.offerings));
-  const ontologyCompilation = compileOrganizationOntology(model);
-  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((index) => Object.keys(index)));
-  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, index) => validateKnownOntologyReferences(ownerId, entry, [...path, index], 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);
-  });
-  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}"`
-        );
-      }
-    });
-  });
-  function validateSystemContent(system, systemPath) {
-    const childSystems = system.systems ?? system.subsystems;
-    const childKey = system.systems !== void 0 ? "systems" : "subsystems";
-    const content = system.content;
-    if (content === void 0 || Object.keys(content).length === 0) {
-      if (childSystems !== void 0) {
-        Object.entries(childSystems).forEach(([childLocalId, child]) => {
-          validateSystemContent(child, [...systemPath, childKey, childLocalId]);
-        });
-      }
-      return;
-    }
-    Object.entries(content).forEach(([localId, node]) => {
-      if (node.parentContentId !== void 0 && !(node.parentContentId in content)) {
-        addIssue(
-          ctx,
-          [...systemPath, "content", localId, "parentContentId"],
-          `Content node "${localId}" parentContentId "${node.parentContentId}" does not resolve within the same system`
-        );
-      }
-    });
-    Object.entries(content).forEach(([localId, node]) => {
-      const visited = /* @__PURE__ */ new Set();
-      let currentId = node.parentContentId;
-      while (currentId !== void 0) {
-        if (currentId === localId || visited.has(currentId)) {
-          addIssue(
-            ctx,
-            [...systemPath, "content", localId, "parentContentId"],
-            `Content node "${localId}" has a parentContentId cycle`
-          );
-          break;
-        }
-        visited.add(currentId);
-        currentId = content[currentId]?.parentContentId;
-      }
-    });
-    Object.entries(content).forEach(([localId, node]) => {
-      const childDef = lookupContentType(node.kind, node.type);
-      if (childDef !== void 0 && node.data !== void 0) {
-        const result = childDef.payloadSchema.safeParse(node.data);
-        if (!result.success) {
-          addIssue(
-            ctx,
-            [...systemPath, "content", localId, "data"],
-            `Content node "${localId}" (${node.kind}:${node.type}) data failed payload validation: ${result.error.message}`
-          );
-        }
-      }
-      if (node.parentContentId !== void 0 && childDef !== void 0) {
-        const parentNode = content[node.parentContentId];
-        if (parentNode !== void 0) {
-          const parentDef = lookupContentType(parentNode.kind, parentNode.type);
-          if (parentDef !== void 0 && childDef.kind !== parentDef.kind) {
-            addIssue(
-              ctx,
-              [...systemPath, "content", localId, "parentContentId"],
-              `Content node "${localId}" kind "${childDef.kind}" cannot parent under "${node.parentContentId}" kind "${parentDef.kind}": parentContentId must be same-meta-kind (per L19)`
-            );
-          }
-        }
-      }
-    });
-    if (childSystems !== void 0) {
-      Object.entries(childSystems).forEach(([childLocalId, child]) => {
-        validateSystemContent(child, [...systemPath, childKey, childLocalId]);
-      });
-    }
-  }
-  Object.entries(model.systems).forEach(([systemKey, system]) => {
-    validateSystemContent(system, ["systems", systemKey]);
-  });
-  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 = DEFAULT_ORGANIZATION_MODEL_ENTITIES;
-var DEFAULT_ORGANIZATION_MODEL_NAVIGATION = {
-  sidebar: {
-    primary: {
-      dashboard: {
-        type: "surface",
-        label: "Dashboard",
-        path: "/",
-        surfaceType: "dashboard",
-        icon: "dashboard",
-        order: 10,
-        targets: { systems: ["dashboard"] }
-      },
-      business: {
-        type: "group",
-        label: "Business",
-        icon: "briefcase",
-        order: 20,
-        children: {
-          sales: {
-            type: "surface",
-            label: "Sales",
-            path: "/sales",
-            surfaceType: "page",
-            icon: "sales",
-            order: 10,
-            targets: { systems: ["sales"] }
-          },
-          clients: {
-            type: "surface",
-            label: "Clients",
-            path: "/clients",
-            surfaceType: "list",
-            icon: "clients",
-            order: 20,
-            targets: { systems: ["clients"] }
-          },
-          projects: {
-            type: "surface",
-            label: "Projects",
-            path: "/projects",
-            surfaceType: "page",
-            icon: "projects",
-            order: 30,
-            targets: { systems: ["projects"] }
-          }
-        }
-      },
-      operations: {
-        type: "group",
-        label: "Operations",
-        icon: "operations",
-        order: 30,
-        children: {
-          "operations-overview": {
-            type: "surface",
-            label: "Overview",
-            path: "/operations",
-            surfaceType: "page",
-            order: 10,
-            targets: { systems: ["operations.overview"] }
-          },
-          "operations-systems": {
-            type: "surface",
-            label: "Systems",
-            path: "/operations/systems",
-            surfaceType: "page",
-            order: 20,
-            targets: { systems: ["operations"] }
-          },
-          "operations-resources": {
-            type: "surface",
-            label: "Resources",
-            path: "/operations/resources",
-            surfaceType: "list",
-            order: 30,
-            targets: { systems: ["operations.resources"] }
-          },
-          "operations-command-queue": {
-            type: "surface",
-            label: "Command Queue",
-            path: "/operations/command-queue",
-            surfaceType: "list",
-            order: 40,
-            targets: { systems: ["operations.command-queue"] }
-          },
-          "operations-task-scheduler": {
-            type: "surface",
-            label: "Task Scheduler",
-            path: "/operations/task-scheduler",
-            surfaceType: "list",
-            order: 50,
-            targets: { systems: ["operations.task-scheduler"] }
-          }
-        }
-      },
-      monitoring: {
-        type: "group",
-        label: "Monitoring",
-        icon: "monitoring",
-        order: 40,
-        children: {
-          "monitoring-overview": {
-            type: "surface",
-            label: "Overview",
-            path: "/monitoring",
-            surfaceType: "page",
-            order: 10,
-            targets: { systems: ["monitoring"] }
-          },
-          "monitoring-calendar": {
-            type: "surface",
-            label: "Calendar",
-            path: "/monitoring/calendar",
-            surfaceType: "page",
-            order: 20,
-            targets: { systems: ["monitoring.calendar"] }
-          },
-          "monitoring-activity-log": {
-            type: "surface",
-            label: "Activity Log",
-            path: "/monitoring/activity-log",
-            surfaceType: "list",
-            order: 30,
-            targets: { systems: ["monitoring.activity-log"] }
-          },
-          "monitoring-execution-logs": {
-            type: "surface",
-            label: "Execution Logs",
-            path: "/monitoring/execution-logs",
-            surfaceType: "list",
-            order: 40,
-            targets: { systems: ["monitoring.execution-logs"] }
-          },
-          "monitoring-execution-health": {
-            type: "surface",
-            label: "Execution Health",
-            path: "/monitoring/execution-health",
-            surfaceType: "dashboard",
-            order: 50,
-            targets: { systems: ["monitoring.execution-health"] }
-          },
-          "monitoring-notifications": {
-            type: "surface",
-            label: "Notifications",
-            path: "/monitoring/notifications",
-            surfaceType: "list",
-            order: 60,
-            targets: { systems: ["monitoring.notifications"] }
-          },
-          "monitoring-requests": {
-            type: "surface",
-            label: "Requests",
-            path: "/monitoring/requests",
-            surfaceType: "list",
-            order: 70,
-            targets: { systems: ["monitoring.submitted-requests"] }
-          }
-        }
-      },
-      knowledge: {
-        type: "surface",
-        label: "Knowledge Base",
-        path: "/knowledge",
-        surfaceType: "page",
-        icon: "knowledge",
-        order: 50
-      }
-    },
-    bottom: {
-      settings: {
-        type: "group",
-        label: "Settings",
-        icon: "settings",
-        order: 10,
-        children: {
-          "settings-account": {
-            type: "surface",
-            label: "Account",
-            path: "/settings/account",
-            surfaceType: "settings",
-            order: 10,
-            targets: { systems: ["settings.account"] }
-          },
-          "settings-appearance": {
-            type: "surface",
-            label: "Appearance",
-            path: "/settings/appearance",
-            surfaceType: "settings",
-            order: 20,
-            targets: { systems: ["settings.appearance"] }
-          },
-          "settings-roles": {
-            type: "surface",
-            label: "My Roles",
-            path: "/settings/roles",
-            surfaceType: "settings",
-            order: 30,
-            targets: { systems: ["settings.roles"] }
-          },
-          "settings-organization": {
-            type: "surface",
-            label: "Organization",
-            path: "/settings/organization",
-            surfaceType: "settings",
-            order: 40,
-            targets: { systems: ["settings.organization"] }
-          },
-          "settings-credentials": {
-            type: "surface",
-            label: "Credentials",
-            path: "/settings/credentials",
-            surfaceType: "settings",
-            order: 50,
-            targets: { systems: ["settings.credentials"] }
-          },
-          "settings-api-keys": {
-            type: "surface",
-            label: "API Keys",
-            path: "/settings/api-keys",
-            surfaceType: "settings",
-            order: 60,
-            targets: { systems: ["settings.api-keys"] }
-          },
-          "settings-webhooks": {
-            type: "surface",
-            label: "Webhooks",
-            path: "/settings/webhooks",
-            surfaceType: "settings",
-            order: 70,
-            targets: { systems: ["settings.webhooks"] }
-          },
-          "settings-deployments": {
-            type: "surface",
-            label: "Deployments",
-            path: "/settings/deployments",
-            surfaceType: "settings",
-            order: 80,
-            targets: { systems: ["settings.deployments"] }
-          }
-        }
-      },
-      admin: {
-        type: "group",
-        label: "Admin",
-        icon: "admin",
-        order: 20,
-        children: {
-          "admin-dashboard": {
-            type: "surface",
-            label: "Dashboard",
-            path: "/admin/dashboard",
-            surfaceType: "dashboard",
-            order: 10,
-            targets: { systems: ["admin"] },
-            requiresAdmin: true
-          },
-          "admin-system-health": {
-            type: "surface",
-            label: "System Health",
-            path: "/admin/system-health",
-            surfaceType: "dashboard",
-            order: 20,
-            targets: { systems: ["admin.system-health"] },
-            requiresAdmin: true
-          },
-          "admin-organizations": {
-            type: "surface",
-            label: "Organizations",
-            path: "/admin/organizations",
-            surfaceType: "list",
-            order: 30,
-            targets: { systems: ["admin.organizations"] },
-            requiresAdmin: true
-          },
-          "admin-users": {
-            type: "surface",
-            label: "Users",
-            path: "/admin/users",
-            surfaceType: "list",
-            order: 40,
-            targets: { systems: ["admin.users"] },
-            requiresAdmin: true
-          },
-          "admin-design-showcase": {
-            type: "surface",
-            label: "Design Showcase",
-            path: "/admin/design-showcase",
-            surfaceType: "page",
-            order: 50,
-            targets: { systems: ["admin.design-showcase"] },
-            requiresAdmin: true
-          },
-          "admin-debug": {
-            type: "surface",
-            label: "Debug",
-            path: "/admin/debug",
-            surfaceType: "page",
-            order: 60,
-            targets: { systems: ["admin.debug"] },
-            requiresAdmin: true
-          }
-        }
-      }
-    }
-  }
-};
-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,
-  systems: {
-    dashboard: {
-      id: "dashboard",
-      order: 10,
-      label: "Dashboard",
-      enabled: true,
-      lifecycle: "active",
-      path: "/",
-      icon: "dashboard"
-    },
-    platform: {
-      id: "platform",
-      order: 30,
-      label: "Platform",
-      description: "Elevasis platform architecture, capabilities, and implementation patterns",
-      enabled: true,
-      lifecycle: "active",
-      color: "cyan",
-      icon: "platform"
-    },
-    finance: {
-      id: "finance",
-      order: 40,
-      label: "Finance",
-      description: "Finance operations, accounting, billing, reconciliation, and tax prep",
-      enabled: true,
-      lifecycle: "active",
-      color: "green",
-      icon: "finance"
-    },
-    sales: {
-      id: "sales",
-      order: 60,
-      label: "Sales",
-      description: "Revenue workflows and customer acquisition",
-      enabled: true,
-      lifecycle: "active",
-      color: "blue",
-      icon: "sales",
-      path: "/sales"
-    },
-    "sales.crm": {
-      id: "sales.crm",
-      order: 70,
-      label: "CRM",
-      description: "Relationship pipeline and deal management",
-      enabled: true,
-      lifecycle: "active",
-      actions: Object.values(CRM_ACTION_ENTRIES).map((action) => ({
-        actionId: action.id,
-        intent: "exposes"
-      })),
-      color: "blue",
-      icon: "crm",
-      path: "/crm"
-    },
-    "sales.lead-gen": {
-      id: "sales.lead-gen",
-      order: 80,
-      label: "Lead Gen",
-      description: "Prospecting, qualification, and outreach preparation",
-      enabled: true,
-      lifecycle: "active",
-      actions: Object.values(LEAD_GEN_ACTION_ENTRIES).map((action) => ({
-        actionId: action.id,
-        intent: "exposes"
-      })),
-      color: "cyan",
-      icon: "lead-gen",
-      path: "/lead-gen"
-    },
-    projects: {
-      id: "projects",
-      order: 90,
-      label: "Projects",
-      description: "Projects, milestones, and client work execution",
-      enabled: true,
-      lifecycle: "active",
-      color: "orange",
-      icon: "projects",
-      path: "/projects"
-    },
-    clients: {
-      id: "clients",
-      order: 100,
-      label: "Clients",
-      description: "Client relationships, accounts, and business context",
-      enabled: true,
-      lifecycle: "active",
-      color: "orange",
-      icon: "clients",
-      path: "/clients"
-    },
-    operations: {
-      id: "operations",
-      order: 110,
-      label: "Operations",
-      description: "Operational resources, topology, and orchestration visibility",
-      enabled: true,
-      lifecycle: "active",
-      color: "violet",
-      icon: "operations"
-    },
-    "knowledge.command-view": {
-      id: "knowledge.command-view",
-      order: 120,
-      label: "Command View",
-      enabled: true,
-      lifecycle: "active",
-      path: "/knowledge/command-view",
-      devOnly: true
-    },
-    "operations.overview": {
-      id: "operations.overview",
-      order: 130,
-      label: "Overview",
-      enabled: true,
-      lifecycle: "active",
-      path: "/operations"
-    },
-    "operations.resources": {
-      id: "operations.resources",
-      order: 140,
-      label: "Resources",
-      enabled: true,
-      lifecycle: "active",
-      path: "/operations/resources"
-    },
-    "operations.command-queue": {
-      id: "operations.command-queue",
-      order: 150,
-      label: "Command Queue",
-      enabled: true,
-      lifecycle: "active",
-      path: "/operations/command-queue"
-    },
-    "operations.sessions": {
-      id: "operations.sessions",
-      order: 160,
-      label: "Sessions",
-      enabled: false,
-      lifecycle: "deprecated",
-      path: "/operations/sessions"
-    },
-    "operations.task-scheduler": {
-      id: "operations.task-scheduler",
-      order: 170,
-      label: "Task Scheduler",
-      enabled: true,
-      lifecycle: "active",
-      path: "/operations/task-scheduler"
-    },
-    monitoring: {
-      id: "monitoring",
-      order: 180,
-      label: "Monitoring",
-      enabled: true,
-      lifecycle: "active"
-    },
-    "monitoring.calendar": {
-      id: "monitoring.calendar",
-      order: 190,
-      label: "Calendar",
-      description: "Google Calendar events and agenda views",
-      enabled: true,
-      lifecycle: "active",
-      path: "/monitoring/calendar",
-      icon: "calendar"
-    },
-    "monitoring.activity-log": {
-      id: "monitoring.activity-log",
-      order: 200,
-      label: "Activity Log",
-      enabled: true,
-      lifecycle: "active",
-      path: "/monitoring/activity-log"
-    },
-    "monitoring.execution-logs": {
-      id: "monitoring.execution-logs",
-      order: 210,
-      label: "Execution Logs",
-      enabled: true,
-      lifecycle: "active",
-      path: "/monitoring/execution-logs"
-    },
-    "monitoring.execution-health": {
-      id: "monitoring.execution-health",
-      order: 220,
-      label: "Execution Health",
-      enabled: true,
-      lifecycle: "active",
-      path: "/monitoring/execution-health"
-    },
-    "monitoring.cost-analytics": {
-      id: "monitoring.cost-analytics",
-      order: 230,
-      label: "Cost Analytics",
-      enabled: false,
-      lifecycle: "deprecated",
-      path: "/monitoring/cost-analytics"
-    },
-    "monitoring.notifications": {
-      id: "monitoring.notifications",
-      order: 240,
-      label: "Notifications",
-      enabled: true,
-      lifecycle: "active",
-      path: "/monitoring/notifications"
-    },
-    "monitoring.submitted-requests": {
-      id: "monitoring.submitted-requests",
-      order: 250,
-      label: "Submitted Requests",
-      enabled: true,
-      lifecycle: "active",
-      path: "/monitoring/requests"
-    },
-    settings: {
-      id: "settings",
-      order: 260,
-      label: "Settings",
-      enabled: true,
-      lifecycle: "active",
-      icon: "settings"
-    },
-    "settings.account": {
-      id: "settings.account",
-      order: 270,
-      label: "Account",
-      enabled: true,
-      lifecycle: "active",
-      path: "/settings/account"
-    },
-    "settings.appearance": {
-      id: "settings.appearance",
-      order: 280,
-      label: "Appearance",
-      enabled: true,
-      lifecycle: "active",
-      path: "/settings/appearance"
-    },
-    "settings.roles": {
-      id: "settings.roles",
-      order: 290,
-      label: "My Roles",
-      enabled: true,
-      lifecycle: "active",
-      path: "/settings/roles"
-    },
-    "settings.organization": {
-      id: "settings.organization",
-      order: 300,
-      label: "Organization",
-      enabled: true,
-      lifecycle: "active",
-      path: "/settings/organization"
-    },
-    "settings.credentials": {
-      id: "settings.credentials",
-      order: 310,
-      label: "Credentials",
-      enabled: true,
-      lifecycle: "active",
-      path: "/settings/credentials"
-    },
-    "settings.api-keys": {
-      id: "settings.api-keys",
-      order: 320,
-      label: "API Keys",
-      enabled: true,
-      lifecycle: "active",
-      path: "/settings/api-keys"
-    },
-    "settings.webhooks": {
-      id: "settings.webhooks",
-      order: 330,
-      label: "Webhooks",
-      enabled: true,
-      lifecycle: "active",
-      path: "/settings/webhooks"
-    },
-    "settings.deployments": {
-      id: "settings.deployments",
-      order: 340,
-      label: "Deployments",
-      enabled: true,
-      lifecycle: "active",
-      path: "/settings/deployments"
-    },
-    admin: {
-      id: "admin",
-      order: 350,
-      label: "Admin",
-      enabled: true,
-      lifecycle: "active",
-      path: "/admin",
-      icon: "admin",
-      requiresAdmin: true
-    },
-    "admin.system-health": {
-      id: "admin.system-health",
-      order: 360,
-      label: "System Health",
-      enabled: true,
-      lifecycle: "active",
-      path: "/admin/system-health"
-    },
-    "admin.organizations": {
-      id: "admin.organizations",
-      order: 370,
-      label: "Organizations",
-      enabled: true,
-      lifecycle: "active",
-      path: "/admin/organizations"
-    },
-    "admin.users": {
-      id: "admin.users",
-      order: 380,
-      label: "Users",
-      enabled: true,
-      lifecycle: "active",
-      path: "/admin/users"
-    },
-    "admin.design-showcase": {
-      id: "admin.design-showcase",
-      order: 390,
-      label: "Design Showcase",
-      enabled: true,
-      lifecycle: "active",
-      path: "/admin/design-showcase"
-    },
-    "admin.debug": {
-      id: "admin.debug",
-      order: 400,
-      label: "Debug",
-      enabled: true,
-      lifecycle: "active",
-      path: "/admin/debug"
-    },
-    archive: {
-      id: "archive",
-      order: 410,
-      label: "Archive",
-      enabled: true,
-      lifecycle: "active",
-      path: "/archive",
-      icon: "archive",
-      devOnly: true
-    },
-    "archive.agent-chat": {
-      id: "archive.agent-chat",
-      order: 420,
-      label: "Agent Chat",
-      enabled: true,
-      lifecycle: "active",
-      path: "/archive/agent-chat"
-    },
-    "archive.execution-runner": {
-      id: "archive.execution-runner",
-      order: 430,
-      label: "Execution Runner",
-      enabled: true,
-      lifecycle: "active",
-      path: "/archive/execution-runner"
-    },
-    seo: {
-      id: "seo",
-      order: 440,
-      label: "SEO",
-      enabled: false,
-      lifecycle: "deprecated",
-      path: "/seo"
-    },
-    knowledge: {
-      id: "knowledge",
-      order: 450,
-      label: "Knowledge",
-      description: "Operational knowledge, playbooks, and strategy docs",
-      enabled: true,
-      lifecycle: "active",
-      color: "teal",
-      icon: "knowledge"
-    },
-    "knowledge.base": {
-      id: "knowledge.base",
-      order: 460,
-      label: "Knowledge Base",
-      enabled: true,
-      lifecycle: "active",
-      path: "/knowledge"
-    }
-  },
-  ontology: DEFAULT_ONTOLOGY_SCOPE,
-  resources: DEFAULT_ORGANIZATION_MODEL_RESOURCES,
-  topology: DEFAULT_ORGANIZATION_MODEL_TOPOLOGY,
-  actions: DEFAULT_ORGANIZATION_MODEL_ACTIONS,
-  entities: DEFAULT_ORGANIZATION_MODEL_ENTITIES2,
-  policies: DEFAULT_ORGANIZATION_MODEL_POLICIES,
-  // Phase 4 (D1): statuses top-level field removed; bridge status mirrors may
-  // still project from System.content, but primary authoring belongs in ontology.
-  knowledge: DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE
-};
-
-// ../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, index) => [
-        stage.stageKey,
-        {
-          key: stage.stageKey,
-          label: stage.label,
-          order: (index + 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() {
-  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(LEAD_GEN_STAGE_CATALOG).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();
-  }
-  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
-  };
-}
-function asLeadGenStageEntry(key, value) {
-  const record = isPlainRecord(value) ? value : {};
-  const entity = record.entity === "contact" ? "contact" : "company";
-  const additionalEntities = Array.isArray(record.additionalEntities) ? record.additionalEntities.filter(
-    (item) => item === "company" || item === "contact"
-  ) : void 0;
-  const recordEntity = record.recordEntity === "company" || record.recordEntity === "contact" ? record.recordEntity : void 0;
-  const recordStageKey = typeof record.recordStageKey === "string" ? record.recordStageKey : void 0;
-  return {
-    key: typeof record.key === "string" ? record.key : key,
-    label: typeof record.label === "string" ? record.label : key,
-    description: typeof record.description === "string" ? record.description : "",
-    order: typeof record.order === "number" ? record.order : 0,
-    entity,
-    ...additionalEntities !== void 0 ? { additionalEntities } : {},
-    ...recordEntity !== void 0 ? { recordEntity } : {},
-    ...recordStageKey !== void 0 ? { recordStageKey } : {}
-  };
-}
-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, index) => {
-  const stageKey = CRM_STAGE_KEYS_FROM_ONTOLOGY[index];
-  if (stageKey === void 0) return [];
-  return asCrmStageEntry(stageKey, entry).states.map((state) => state.stateKey);
-});
-Object.keys(
-  getCatalogEntries(BUSINESS_ONTOLOGY_VALIDATION_INDEX.leadGenStageCatalog)
-);
-function getLeadGenStageCatalogFromOntology() {
-  return Object.fromEntries(
-    Object.entries(getCatalogEntries(BUSINESS_ONTOLOGY_VALIDATION_INDEX.leadGenStageCatalog)).map(([key, value]) => [
-      key,
-      asLeadGenStageEntry(key, value)
-    ])
-  );
-}
-function getLeadGenStageEntry(stageKey) {
-  return getLeadGenStageCatalogFromOntology()[stageKey];
-}
-function isLeadGenStageKey(stageKey) {
-  return getLeadGenStageEntry(stageKey) !== void 0;
-}
-function isLeadGenRecordStageValidForEntity(stageKey, entity) {
-  const stage = getLeadGenStageEntry(stageKey);
-  return stage !== void 0 && (stage.entity === entity || stage.additionalEntities?.includes(entity) === true || stage.recordEntity === entity);
-}
-function isLeadGenActionKey(actionKey) {
-  return actionKey.startsWith("lead-gen.") && BUSINESS_ONTOLOGY_VALIDATION_INDEX.actionTypesByLegacyId[actionKey] !== void 0;
-}
-
-// ../core/src/business/acquisition/api-schemas.ts
-var ProcessingStageStatusSchema = z.enum(["success", "no_result", "skipped", "error"]);
-var LeadGenStageKeySchema = z.string().refine((value) => isLeadGenStageKey(value), {
-  message: "processing state key must match LEAD_GEN_STAGE_CATALOG"
-});
-var LeadGenActionKeySchema = z.string().refine((value) => isLeadGenActionKey(value), {
-  message: "actionKey must match ACTION_REGISTRY"
-});
-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 ProcessingStateEntrySchema = z.object({
-  status: ProcessingStageStatusSchema,
-  data: z.unknown().optional()
-}).passthrough();
-var ProcessingStateSchema = z.record(LeadGenStageKeySchema, ProcessingStateEntrySchema);
-var CompanyProcessingStateSchema = ProcessingStateSchema;
-var ContactProcessingStateSchema = ProcessingStateSchema;
-var DealStageSchema = CrmStageKeySchema;
-var AcqDealTaskKindSchema = z.enum(["call", "email", "meeting", "other"]);
-z.object({
-  dealId: UuidSchema
+var ProcessingStageStatusSchema = z.enum(["success", "no_result", "skipped", "error"]);
+var LeadGenStageKeySchema = z.string().trim().min(1);
+var LeadGenActionKeySchema = z.string().trim().min(1);
+var CrmStageKeySchema = z.string().trim().min(1);
+var CrmStateKeySchema = z.string().trim().min(1);
+var ProcessingStateEntrySchema = z.object({
+  status: ProcessingStageStatusSchema,
+  data: z.unknown().optional()
+}).passthrough();
+var ProcessingStateSchema = z.record(LeadGenStageKeySchema, ProcessingStateEntrySchema);
+var CompanyProcessingStateSchema = ProcessingStateSchema;
+var ContactProcessingStateSchema = ProcessingStateSchema;
+var DealStageSchema = CrmStageKeySchema;
+var AcqDealTaskKindSchema = z.enum(["call", "email", "meeting", "other"]);
+z.object({
+  dealId: UuidSchema
 });
 z.object({
   dealId: UuidSchema,
@@ -8720,7 +5492,7 @@ z.object({
   expectedUpdatedAt: z.string().datetime().optional()
 }).strict();
 z.object({
-  pipelineKey: z.literal(CRM_PIPELINE_DEFINITION.pipelineKey),
+  pipelineKey: z.string().min(1),
   stageKey: CrmStageKeySchema,
   stateKey: CrmStateKeySchema.nullable().optional(),
   reason: z.string().optional(),
@@ -8921,9 +5693,7 @@ var IcpRubricSchema = z.object({
   customRules: z.string().optional()
 });
 var PipelineStageSchema = z.object({
-  key: z.string().refine((value) => isLeadGenStageKey(value), {
-    message: "pipeline stage key must match LEAD_GEN_STAGE_CATALOG"
-  }),
+  key: LeadGenStageKeySchema,
   label: z.string().optional(),
   enabled: z.boolean().optional(),
   order: z.number().int().optional()
@@ -9391,16 +6161,7 @@ z.object({
   stage: LeadGenStageKeySchema.optional(),
   limit: z.coerce.number().int().min(1).max(500).default(50),
   offset: z.coerce.number().int().min(0).default(0)
-}).strict().superRefine((query, ctx) => {
-  if (!query.stage) return;
-  if (!isLeadGenRecordStageValidForEntity(query.stage, query.entity)) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      message: `stage "${query.stage}" is not valid for ${query.entity} records`,
-      path: ["stage"]
-    });
-  }
-});
+}).strict();
 z.object({
   memberId: UuidSchema
 });
@@ -9682,6 +6443,29 @@ var PostMessageLLMAdapter = class {
 function createPostMessageAdapterFactory() {
   return (config) => new PostMessageLLMAdapter(config.provider, config.model);
 }
+function generateHmacToken(secret, data) {
+  return createHmac("sha256", secret).update(data.toLowerCase().trim()).digest("hex").slice(0, 16);
+}
+function classifyPlatformToolError(err, options = {}) {
+  const {
+    timeoutMessages = [],
+    rateLimitCodes = ["rate_limit_exceeded"],
+    rateLimitMessageCodes = [],
+    rateLimitMessageIncludes = []
+  } = options;
+  if (err instanceof Error && timeoutMessages.includes(err.message)) {
+    return "timeout";
+  }
+  if (err instanceof PlatformToolError) {
+    if (rateLimitCodes.includes(err.code)) {
+      return "rate_limit";
+    }
+    if (rateLimitMessageCodes.includes(err.code) && rateLimitMessageIncludes.some((snippet) => err.message.includes(snippet))) {
+      return "rate_limit";
+    }
+  }
+  return "other";
+}
 
 // src/worker/adapters/create-adapter.ts
 function createAdapter(tool, methods, credential) {
@@ -10011,8 +6795,18 @@ var execution = createAdapter("execution", ["trigger", "triggerAsync"]);
 
 // src/worker/adapters/email.ts
 var email = createAdapter("email", ["send"]);
-var listBuilderStageKeys = Object.keys(LEAD_GEN_STAGE_CATALOG);
-var ListBuilderStageKeySchema = z.enum(listBuilderStageKeys);
+z.object({
+  success: z.boolean(),
+  tool: z.string(),
+  method: z.string(),
+  result: z.unknown().optional(),
+  error: z.string().optional(),
+  durationMs: z.number().optional()
+});
+z.object({
+  credential: z.string().describe("Credential name registered for this integration")
+});
+var ListBuilderStageKeySchema = z.string().min(1);
 
 // src/worker/list-builder-workflow.ts
 var ListBuilderResultSchema = z.object({
@@ -10037,7 +6831,9 @@ function assertNoReservedInputKeys(schema) {
   }
   const reservedKeys = ["params", "batch"].filter((key) => Object.prototype.hasOwnProperty.call(shape, key));
   if (reservedKeys.length > 0) {
-    throw new Error(`listBuilderWorkflow inputSchema cannot define reserved top-level key(s): ${reservedKeys.join(", ")}`);
+    throw new Error(
+      `listBuilderWorkflow inputSchema cannot define reserved top-level key(s): ${reservedKeys.join(", ")}`
+    );
   }
 }
 function resolveListAdapter(context) {
@@ -10047,18 +6843,13 @@ function resolveListAdapter(context) {
 function getRecordId(record) {
   return record.id;
 }
-function assertResultStageTarget(result, defaultStageKey) {
-  const stageKey = result.stageKey ?? defaultStageKey;
-  const catalogEntry = LEAD_GEN_STAGE_CATALOG[stageKey];
-  if (!catalogEntry) {
-    throw new Error(`listBuilderWorkflow result stageKey "${stageKey}" is not in LEAD_GEN_STAGE_CATALOG`);
-  }
-  if (catalogEntry.entity !== result.entity) {
+function assertResultStageTarget(result, defaultStageKey, primaryEntity) {
+  if (result.entity !== primaryEntity && result.stageKey === void 0) {
     throw new Error(
-      `listBuilderWorkflow result for ${result.entity} "${result.id}" targets ${catalogEntry.entity} stage "${stageKey}"; set result.stageKey to a ${result.entity} stage`
+      `[list-builder] cross-entity result for "${result.id}" is a ${result.entity} but the step's primary entity is ${primaryEntity}; set result.stageKey to a ${result.entity} stage.`
     );
   }
-  return stageKey;
+  return result.stageKey ?? defaultStageKey;
 }
 async function filterPendingRecords(records, params, context, options) {
   if (params.forceRefresh) {
@@ -10078,7 +6869,7 @@ async function filterPendingRecords(records, params, context, options) {
   const pending = new Set(pendingIds);
   return records.filter((record) => pending.has(getRecordId(record)));
 }
-async function dispatchResults(envelope, context) {
+async function dispatchResults(envelope, context, primaryEntity) {
   if (!envelope.batch.listId) {
     if (envelope.results.length > 0) {
       context.logger.warn(
@@ -10089,7 +6880,7 @@ async function dispatchResults(envelope, context) {
   }
   const listAdapter = resolveListAdapter(context);
   for (const result of envelope.results) {
-    const stage = assertResultStageTarget(result, envelope.batch.stageKey);
+    const stage = assertResultStageTarget(result, envelope.batch.stageKey, primaryEntity);
     if (result.entity === "company") {
       await listAdapter.updateCompanyStage({
         listId: envelope.batch.listId,
@@ -10114,6 +6905,11 @@ async function dispatchResults(envelope, context) {
 }
 function listBuilderWorkflow(options) {
   const stageKey = ListBuilderStageKeySchema.parse(options.buildStep.stageKey);
+  if (options.stageValidators && !options.stageValidators.isLeadGenStageKey(stageKey)) {
+    throw new Error(
+      `[list-builder] invalid buildStep.stageKey "${stageKey}" \u2014 not a known lead-gen stage in the injected stage catalog.`
+    );
+  }
   assertNoReservedInputKeys(options.inputSchema);
   const outputSchema = options.outputSchema ?? ListBuilderResultsSchema;
   const batchSchema = z.object({
@@ -10187,7 +6983,7 @@ function listBuilderWorkflow(options) {
         outputSchema,
         handler: async (rawInput, context) => {
           const envelope = envelopeSchema.parse(rawInput);
-          const results = await dispatchResults(envelope, context);
+          const results = await dispatchResults(envelope, context, options.buildStep.primaryEntity);
           return outputSchema.parse(results);
         },
         next: null
@@ -10227,34 +7023,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 [k, v] of Object.entries(value)) {
-      result[k] = truncateForLogging(v);
-    }
-    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((k) => k !== "$schema")) {
@@ -10273,84 +7046,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();
   }
@@ -10489,7 +7206,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)`);
@@ -10533,9 +7251,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",
@@ -10567,4 +7286,4 @@ if (workerData != null && workerData.kind === "static") {
   })();
 }
 
-export { ListBuilderResultSchema, ListBuilderResultsSchema, PlatformToolError, acqDb, approval, createAdapter, createAnymailfinderAdapter, createApifyAdapter, createAttioAdapter, createDropboxAdapter, createGmailAdapter, createGoogleSheetsAdapter, createInstantlyAdapter, createMillionVerifierAdapter, createResendAdapter, createSignatureApiAdapter, createStripeAdapter, createTombaAdapter, crm, email, executeWorkflow, execution, list, listBuilderWorkflow, llm, notifications, pdf, platform, projects, scheduler, startWorker, storage };
+export { ListBuilderResultSchema, ListBuilderResultsSchema, PlatformToolError, acqDb, approval, classifyPlatformToolError, createAdapter, createAnymailfinderAdapter, createApifyAdapter, createAttioAdapter, createDropboxAdapter, createGmailAdapter, createGoogleSheetsAdapter, createInstantlyAdapter, createMillionVerifierAdapter, createResendAdapter, createSignatureApiAdapter, createStripeAdapter, createTombaAdapter, crm, email, executeWorkflow, execution, generateHmacToken, list, listBuilderWorkflow, llm, notifications, pdf, platform, projects, scheduler, startWorker, storage };