@elevasis/ui 2.31.0 → 2.32.0

package/dist/chunk-T35FWDAB.js

@@ -0,0 +1,4342 @@
+import { z } from 'zod';
+
+// ../core/src/organization-model/domains/systems.ts
+var ORGANIZATION_MODEL_ICON_TOKENS = [
+  "nav.dashboard",
+  "nav.calendar",
+  "nav.sales",
+  "nav.crm",
+  "nav.lead-gen",
+  "nav.projects",
+  "nav.operations",
+  "nav.monitoring",
+  "nav.knowledge",
+  "nav.settings",
+  "nav.admin",
+  "nav.archive",
+  "knowledge.playbook",
+  "knowledge.strategy",
+  "knowledge.reference",
+  "feature.dashboard",
+  "feature.calendar",
+  "feature.business",
+  "feature.sales",
+  "feature.crm",
+  "feature.finance",
+  "feature.lead-gen",
+  "feature.platform",
+  "feature.projects",
+  "feature.operations",
+  "feature.knowledge",
+  "feature.monitoring",
+  "feature.settings",
+  "feature.admin",
+  "feature.archive",
+  "feature.seo",
+  "resource.agent",
+  "resource.workflow",
+  "resource.integration",
+  "resource.database",
+  "resource.user",
+  "resource.team",
+  "integration.gmail",
+  "integration.google-sheets",
+  "integration.attio",
+  "surface.dashboard",
+  "surface.calendar",
+  "surface.overview",
+  "surface.command-view",
+  "surface.command-queue",
+  "surface.pipeline",
+  "surface.lists",
+  "surface.resources",
+  "surface.settings",
+  "status.success",
+  "status.error",
+  "status.warning",
+  "status.info",
+  "status.pending",
+  "action.approve",
+  "action.reject",
+  "action.retry",
+  "action.edit",
+  "action.view",
+  "action.launch",
+  "action.message",
+  "action.escalate",
+  "action.promote",
+  "action.submit",
+  "action.email"
+];
+var CustomIconTokenSchema = z.string().trim().max(80).regex(/^custom\.[a-z0-9]+(?:[-._][a-z0-9]+)*$/, "Custom icon tokens must start with custom.");
+var OrganizationModelBuiltinIconTokenSchema = z.enum(ORGANIZATION_MODEL_ICON_TOKENS);
+var OrganizationModelIconTokenSchema = z.union([
+  OrganizationModelBuiltinIconTokenSchema,
+  CustomIconTokenSchema
+]);
+
+// ../core/src/organization-model/domains/shared.ts
+var ModelIdSchema = z.string().trim().min(1).max(100).regex(/^[a-z0-9]+(?:[-._][a-z0-9]+)*$/, "IDs must be lowercase and use -, _, or . separators");
+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);
+var ReferenceIdsSchema = z.array(ModelIdSchema).default([]);
+var DisplayMetadataSchema = z.object({
+  label: LabelSchema,
+  description: DescriptionSchema.optional(),
+  color: ColorTokenSchema.optional(),
+  icon: IconNameSchema.optional()
+});
+var TechStackEntrySchema = z.object({
+  /** Name of the external platform (e.g. "HubSpot", "Stripe", "Notion"). */
+  platform: z.string().trim().min(1).max(200),
+  /** Free-form description of what this integration is used for. */
+  purpose: z.string().trim().min(1).max(500),
+  /**
+   * Health of the credential backing this integration.
+   * - configured: credential present and valid
+   * - pending: not yet set up
+   * - expired: credential existed but has lapsed
+   * - missing: expected but not present
+   */
+  credentialStatus: z.enum(["configured", "pending", "expired", "missing"]),
+  /**
+   * Whether this integration is the primary system of record for its domain
+   * (e.g. HubSpot is SoR for contacts). Defaults to false.
+   */
+  isSystemOfRecord: z.boolean().default(false)
+});
+DisplayMetadataSchema.extend({
+  id: ModelIdSchema,
+  resourceId: z.string().trim().min(1).max(255),
+  resourceType: z.enum(["workflow", "agent", "trigger", "integration", "external", "human_checkpoint"]),
+  systemIds: ReferenceIdsSchema,
+  entityIds: ReferenceIdsSchema,
+  surfaceIds: ReferenceIdsSchema,
+  actionIds: ReferenceIdsSchema,
+  /** Optional tech-stack metadata for external-SaaS integrations. */
+  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 DEFAULT_ORGANIZATION_MODEL_ACTIONS = LEAD_GEN_ACTION_ENTRIES;
+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" })
+});
+
+// ../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 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-scoped operational data, co-located with the owning system.
+   * Per L1, L3, L13: keyed by local NodeId (the key is the local id; qualified
+   * id is `<system-path>:<local-id>`, computed by graph projection).
+   * Per L14: every ContentNode carries both `kind` and `type`.
+   * Per D2: unregistered (kind, type) pairs parse successfully.
+   */
+  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.
+   */
+  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) => {
+  if (system.status === void 0) return system;
+  console.warn("[organization-model] System.status is deprecated; use System.lifecycle instead.");
+  return system.lifecycle === void 0 ? { ...system, lifecycle: system.status } : system;
+});
+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 = {};
+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: ""
+};
+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 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 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" }),
+  /** Optional role responsible for maintaining this resource. */
+  ownerRoleId: ModelIdSchema.meta({ ref: "role" }).optional(),
+  status: ResourceGovernanceStatusSchema
+});
+var WorkflowResourceEntrySchema = ResourceEntryBaseSchema.extend({
+  kind: z.literal("workflow"),
+  /** Mirrors WorkflowConfig.actionKey when the runtime workflow has one. */
+  actionKey: z.string().trim().min(1).max(255).optional(),
+  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/helpers.ts
+function defaultPathFor(id) {
+  return `/${id.replaceAll(".", "/")}`;
+}
+function parentIdOf(id) {
+  const index = id.lastIndexOf(".");
+  return index === -1 ? void 0 : id.slice(0, index);
+}
+function findById(systems, id) {
+  return systems[id];
+}
+function findByPath(systems, path) {
+  return Object.values(systems).find((system) => (system.path ?? system.ui?.path ?? defaultPathFor(system.id)) === path);
+}
+function childrenOf(systems, id) {
+  const prefix = `${id}.`;
+  return Object.values(systems).filter(
+    (system) => system.id.startsWith(prefix) && !system.id.slice(prefix.length).includes(".")
+  );
+}
+function topLevel(systems) {
+  return Object.values(systems).filter((system) => !system.id.includes("."));
+}
+function ancestorsOf(systems, id) {
+  const segments = id.split(".");
+  const ids = segments.map((_, index) => segments.slice(0, index + 1).join("."));
+  return ids.map((ancestorId) => findById(systems, ancestorId)).filter((system) => Boolean(system));
+}
+function parentOf(systems, id) {
+  const parentId = parentIdOf(id);
+  return parentId ? findById(systems, parentId) : void 0;
+}
+function inheritedValue(systems, id, getValue) {
+  return ancestorsOf(systems, id).slice().reverse().map(getValue).find((value) => value !== void 0);
+}
+function requiresAdminFor(systems, id) {
+  return inheritedValue(systems, id, (system) => system.requiresAdmin) ?? false;
+}
+function devOnlyFor(systems, id) {
+  return inheritedValue(systems, id, (system) => system.devOnly || system.lifecycle === "beta" || void 0) ?? false;
+}
+function getSystem(model, path) {
+  const segments = path.split(".");
+  let current = model.systems;
+  let node;
+  for (const seg of segments) {
+    node = current[seg];
+    if (node === void 0) return void 0;
+    current = node.subsystems ?? {};
+  }
+  return node;
+}
+function getSystemAncestors(model, path) {
+  const segments = path.split(".");
+  const result = [];
+  let current = model.systems;
+  for (const seg of segments) {
+    const node = current[seg];
+    if (node === void 0) return [];
+    result.push(node);
+    current = node.subsystems ?? {};
+  }
+  return result;
+}
+function listAllSystems(model) {
+  const results = [];
+  function walk(map, prefix) {
+    for (const [localId, system] of Object.entries(map)) {
+      const fullPath = prefix ? `${prefix}.${localId}` : localId;
+      results.push({ path: fullPath, system });
+      if (system.subsystems) {
+        walk(system.subsystems, fullPath);
+      }
+    }
+  }
+  walk(model.systems, "");
+  return results;
+}
+function getContent(model, qualifiedId) {
+  const colonIndex = qualifiedId.indexOf(":");
+  if (colonIndex === -1) return void 0;
+  const systemPath = qualifiedId.slice(0, colonIndex);
+  const localId = qualifiedId.slice(colonIndex + 1);
+  if (!systemPath || !localId) return void 0;
+  const system = getSystem(model, systemPath);
+  return system?.content?.[localId];
+}
+function getResourcesForSystem(model, systemPath, options = {}) {
+  const { includeDescendants = false } = options;
+  const prefix = systemPath + ".";
+  return Object.values(model.resources ?? {}).filter(
+    (r) => r.systemPath === systemPath || includeDescendants && r.systemPath.startsWith(prefix)
+  );
+}
+DisplayMetadataSchema.extend({
+  id: ModelIdSchema,
+  order: z.number().min(0)
+});
+var RecordColumnConfigSchema = z.object({
+  key: ModelIdSchema,
+  label: z.string().trim().min(1).max(120),
+  path: z.string().trim().min(1).max(500),
+  width: z.union([z.number().positive(), z.string().trim().min(1).max(100)]).optional(),
+  renderType: z.enum(["text", "badge", "datetime", "count", "json"]).optional(),
+  badgeColor: z.string().trim().min(1).max(40).optional()
+});
+var RecordColumnsConfigSchema = z.object({
+  company: z.array(RecordColumnConfigSchema).optional(),
+  contact: z.array(RecordColumnConfigSchema).optional()
+}).refine((columns) => Boolean(columns.company?.length || columns.contact?.length), {
+  message: "recordColumns must include at least one entity column set"
+});
+var CredentialRequirementSchema = z.object({
+  key: ModelIdSchema,
+  provider: ModelIdSchema,
+  credentialType: z.enum(["api-key", "api-key-secret", "oauth", "webhook-secret"]),
+  label: z.string().trim().min(1).max(120),
+  required: z.boolean(),
+  selectionMode: z.enum(["single", "multiple"]).optional(),
+  inputPath: z.string().trim().min(1).max(500),
+  verifyOnRun: z.boolean().optional()
+});
+var ProspectingBuildTemplateStepSchema = DisplayMetadataSchema.extend({
+  id: ModelIdSchema,
+  primaryEntity: z.enum(["company", "contact"]),
+  outputs: z.array(z.enum(["company", "contact", "export"])).min(1),
+  stageKey: ModelIdSchema,
+  recordEntity: z.enum(["company", "contact"]).optional(),
+  recordsStageKey: ModelIdSchema.optional(),
+  recordSourceStageKey: ModelIdSchema.optional(),
+  dependsOn: z.array(ModelIdSchema).optional(),
+  dependencyMode: z.literal("per-record-eligibility"),
+  actionKey: ModelIdSchema,
+  defaultBatchSize: z.number().int().positive(),
+  maxBatchSize: z.number().int().positive(),
+  recordColumns: RecordColumnsConfigSchema.optional(),
+  credentialRequirements: z.array(CredentialRequirementSchema).optional()
+}).refine((step) => step.defaultBatchSize <= step.maxBatchSize, {
+  message: "defaultBatchSize must be less than or equal to maxBatchSize",
+  path: ["defaultBatchSize"]
+});
+DisplayMetadataSchema.extend({
+  id: ModelIdSchema,
+  steps: z.array(ProspectingBuildTemplateStepSchema).min(1)
+});
+var DTC_RECORD_COLUMNS = {
+  populated: {
+    company: [
+      { key: "name", label: "Company", path: "company.name" },
+      { key: "domain", label: "Domain", path: "company.domain" },
+      { key: "employee-count", label: "Employees", path: "company.numEmployees", renderType: "count" },
+      { key: "apollo-industry", label: "Apollo industry", path: "company.category" },
+      { key: "location", label: "Location", path: "company.locationState" }
+    ]
+  },
+  crawled: {
+    company: [
+      { key: "name", label: "Company", path: "company.name" },
+      { key: "domain", label: "Domain", path: "company.domain" },
+      { key: "page-count", label: "Pages", path: "company.enrichmentData.websiteCrawl.pageCount", renderType: "count" },
+      { key: "crawl-status", label: "Crawl status", path: "processingState.crawled.status", renderType: "badge" }
+    ]
+  },
+  extracted: {
+    company: [
+      { key: "name", label: "Company", path: "company.name" },
+      { key: "domain", label: "Domain", path: "company.domain" },
+      { key: "description", label: "Description", path: "company.enrichmentData.websiteCrawl.companyDescription" },
+      { key: "services", label: "Services", path: "company.enrichmentData.websiteCrawl.services", renderType: "json" },
+      {
+        key: "automation-gaps",
+        label: "Automation gaps",
+        path: "company.enrichmentData.websiteCrawl.automationGaps",
+        renderType: "json"
+      },
+      {
+        key: "contact-count",
+        label: "Contacts",
+        path: "company.enrichmentData.websiteCrawl.emailCount",
+        renderType: "count"
+      }
+    ]
+  },
+  qualified: {
+    company: [
+      { key: "name", label: "Company", path: "company.name" },
+      { key: "domain", label: "Domain", path: "company.domain" },
+      { key: "score", label: "Score", path: "company.qualificationScore", renderType: "badge", badgeColor: "green" },
+      { key: "signals", label: "Signals", path: "company.qualificationSignals", renderType: "json" },
+      {
+        key: "disqualified-reason",
+        label: "Disqualified reason",
+        path: "processingState.qualified.data.disqualifiedReason"
+      }
+    ]
+  },
+  decisionMakers: {
+    contact: [
+      { key: "name", label: "Name", path: "contact.name" },
+      { key: "title", label: "Title", path: "contact.title" },
+      { key: "email", label: "Email", path: "contact.email" },
+      { key: "linkedin", label: "LinkedIn", path: "contact.linkedinUrl" },
+      {
+        key: "priority-score",
+        label: "Priority",
+        path: "contact.enrichmentData.apollo.priorityScore",
+        renderType: "badge"
+      }
+    ]
+  },
+  uploaded: {
+    company: [
+      { key: "name", label: "Company", path: "company.name" },
+      { key: "domain", label: "Domain", path: "company.domain" },
+      {
+        key: "contacts",
+        label: "Contacts",
+        path: "company.enrichmentData.approvedLeadListExport.contacts",
+        renderType: "json"
+      },
+      { key: "score", label: "Score", path: "company.qualificationScore", renderType: "badge", badgeColor: "green" },
+      {
+        key: "approval",
+        label: "Approval",
+        path: "company.enrichmentData.approvedLeadListExport.approvalStatus",
+        renderType: "badge"
+      }
+    ]
+  }
+};
+Object.values(LEAD_GEN_ACTION_ENTRIES);
+var PROSPECTING_STEPS = {
+  localServices: {
+    sourceCompanies: {
+      id: "source-companies",
+      label: "Companies found",
+      primaryEntity: "company",
+      outputs: ["company"],
+      stageKey: "populated",
+      dependencyMode: "per-record-eligibility",
+      actionKey: "lead-gen.company.source",
+      defaultBatchSize: 100,
+      maxBatchSize: 250
+    },
+    analyzeWebsites: {
+      id: "analyze-websites",
+      label: "Websites analyzed",
+      primaryEntity: "company",
+      outputs: ["company"],
+      stageKey: "extracted",
+      dependsOn: ["source-companies"],
+      dependencyMode: "per-record-eligibility",
+      actionKey: "lead-gen.company.website-extract",
+      defaultBatchSize: 50,
+      maxBatchSize: 100
+    },
+    qualifyCompanies: {
+      id: "qualify-companies",
+      label: "Companies qualified",
+      primaryEntity: "company",
+      outputs: ["company"],
+      stageKey: "qualified",
+      dependsOn: ["analyze-websites"],
+      dependencyMode: "per-record-eligibility",
+      actionKey: "lead-gen.company.qualify",
+      defaultBatchSize: 100,
+      maxBatchSize: 250
+    },
+    findContacts: {
+      id: "find-contacts",
+      label: "Decision-makers found",
+      primaryEntity: "contact",
+      outputs: ["contact"],
+      stageKey: "discovered",
+      dependsOn: ["qualify-companies"],
+      dependencyMode: "per-record-eligibility",
+      actionKey: "lead-gen.contact.discover",
+      defaultBatchSize: 50,
+      maxBatchSize: 100
+    },
+    verifyEmails: {
+      id: "verify-emails",
+      label: "Emails verified",
+      primaryEntity: "contact",
+      outputs: ["contact"],
+      stageKey: "verified",
+      dependsOn: ["find-contacts"],
+      dependencyMode: "per-record-eligibility",
+      actionKey: "lead-gen.contact.verify-email",
+      defaultBatchSize: 100,
+      maxBatchSize: 500
+    },
+    personalize: {
+      id: "personalize",
+      label: "Personalize",
+      primaryEntity: "contact",
+      outputs: ["contact"],
+      stageKey: "personalized",
+      dependsOn: ["verify-emails"],
+      dependencyMode: "per-record-eligibility",
+      actionKey: "lead-gen.contact.personalize",
+      defaultBatchSize: 25,
+      maxBatchSize: 100
+    },
+    review: {
+      id: "review",
+      label: "Reviewed and exported",
+      primaryEntity: "contact",
+      outputs: ["export"],
+      stageKey: "uploaded",
+      dependsOn: ["personalize"],
+      dependencyMode: "per-record-eligibility",
+      actionKey: "lead-gen.review.outreach-ready",
+      defaultBatchSize: 25,
+      maxBatchSize: 100
+    }
+  },
+  dtcApolloClickup: {
+    importApolloSearch: {
+      id: "import-apollo-search",
+      label: "Companies found",
+      description: "Pull companies and seed contact data from a predefined Apollo search or list.",
+      primaryEntity: "company",
+      outputs: ["company", "contact"],
+      stageKey: "populated",
+      dependencyMode: "per-record-eligibility",
+      actionKey: "lead-gen.company.apollo-import",
+      defaultBatchSize: 250,
+      maxBatchSize: 1e3,
+      recordColumns: DTC_RECORD_COLUMNS.populated,
+      credentialRequirements: [
+        {
+          key: "apollo",
+          provider: "apollo",
+          credentialType: "api-key-secret",
+          label: "Apollo API key",
+          required: true,
+          selectionMode: "single",
+          inputPath: "credential"
+        }
+      ]
+    },
+    apifyCrawl: {
+      id: "apify-crawl",
+      label: "Websites crawled",
+      description: "Crawl company websites via Apify and store raw page markdown in enrichmentData.websiteCrawl.pages for downstream LLM analysis. Overwrites the synthetic seed Apollo Import wrote with real page content.",
+      primaryEntity: "company",
+      outputs: ["company"],
+      stageKey: "crawled",
+      dependsOn: ["import-apollo-search"],
+      dependencyMode: "per-record-eligibility",
+      actionKey: "lead-gen.company.apify-crawl",
+      defaultBatchSize: 50,
+      maxBatchSize: 100,
+      recordColumns: DTC_RECORD_COLUMNS.crawled,
+      credentialRequirements: [
+        {
+          key: "apify",
+          provider: "apify",
+          credentialType: "api-key-secret",
+          label: "Apify API token",
+          required: true,
+          selectionMode: "single",
+          inputPath: "credential",
+          verifyOnRun: true
+        }
+      ]
+    },
+    analyzeWebsites: {
+      id: "analyze-websites",
+      label: "Websites analyzed",
+      description: "Extract subscription, product, retention, and tech-stack signals from each brand website.",
+      primaryEntity: "company",
+      outputs: ["company"],
+      stageKey: "extracted",
+      dependsOn: ["apify-crawl"],
+      dependencyMode: "per-record-eligibility",
+      actionKey: "lead-gen.company.website-extract",
+      defaultBatchSize: 50,
+      maxBatchSize: 100,
+      recordColumns: DTC_RECORD_COLUMNS.extracted
+    },
+    scoreDtcFit: {
+      id: "score-dtc-fit",
+      label: "Companies qualified",
+      description: "Classify subscription potential, consumable-product fit, retention maturity, and disqualifiers.",
+      primaryEntity: "company",
+      outputs: ["company"],
+      stageKey: "qualified",
+      dependsOn: ["analyze-websites"],
+      dependencyMode: "per-record-eligibility",
+      actionKey: "lead-gen.company.dtc-subscription-qualify",
+      defaultBatchSize: 100,
+      maxBatchSize: 250,
+      recordColumns: DTC_RECORD_COLUMNS.qualified
+    },
+    enrichDecisionMakers: {
+      id: "enrich-decision-makers",
+      label: "Decision-makers found",
+      description: "Use Apollo to find qualified contacts at qualified companies - founders, retention leads, lifecycle leads, and marketing owners.",
+      primaryEntity: "company",
+      outputs: ["contact"],
+      stageKey: "decision-makers-enriched",
+      recordEntity: "contact",
+      dependsOn: ["score-dtc-fit"],
+      dependencyMode: "per-record-eligibility",
+      actionKey: "lead-gen.contact.apollo-decision-maker-enrich",
+      defaultBatchSize: 100,
+      maxBatchSize: 250,
+      recordColumns: DTC_RECORD_COLUMNS.decisionMakers,
+      credentialRequirements: [
+        {
+          key: "apollo",
+          provider: "apollo",
+          credentialType: "api-key-secret",
+          label: "Apollo API key",
+          required: true,
+          selectionMode: "single",
+          inputPath: "credential"
+        }
+      ]
+    },
+    reviewAndExport: {
+      id: "review-and-export",
+      label: "Reviewed and exported",
+      description: "Operator QC approves or rejects qualified companies, then approved records are exported as a lead list with unverified emails.",
+      primaryEntity: "company",
+      outputs: ["export"],
+      stageKey: "uploaded",
+      recordsStageKey: "uploaded",
+      recordSourceStageKey: "qualified",
+      dependsOn: ["enrich-decision-makers"],
+      dependencyMode: "per-record-eligibility",
+      actionKey: "lead-gen.export.list",
+      defaultBatchSize: 100,
+      maxBatchSize: 250,
+      recordColumns: DTC_RECORD_COLUMNS.uploaded,
+      credentialRequirements: [
+        {
+          key: "clickup",
+          provider: "clickup",
+          credentialType: "api-key-secret",
+          label: "ClickUp API token",
+          required: true,
+          selectionMode: "single",
+          inputPath: "clickupCredential",
+          verifyOnRun: true
+        }
+      ]
+    }
+  }
+};
+
+// ../core/src/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"
+  }
+};
+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)
+});
+function findPipeline(definitions, pipelineKey) {
+  return definitions.find((def) => def.pipelineKey === pipelineKey);
+}
+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 CRM_PRIORITY_BUCKETS = [
+  { bucketKey: "needs_response", label: "Needs Response", rank: 10, color: "red" },
+  { bucketKey: "follow_up_due", label: "Follow-up Due", rank: 20, color: "orange" },
+  { bucketKey: "waiting", label: "Waiting", rank: 30, color: "blue" },
+  { bucketKey: "stale", label: "Stale", rank: 40, color: "gray" },
+  { bucketKey: "closed_low", label: "Closed", rank: 50, color: "dark" }
+];
+var DEFAULT_CRM_PRIORITY_RULE_CONFIG = {
+  buckets: CRM_PRIORITY_BUCKETS,
+  closedStageKeys: ["closed_won", "closed_lost"],
+  followUpAfterDaysByStateKey: {
+    discovery_link_sent: 3,
+    discovery_nudging: 2,
+    reply_sent: 3,
+    followup_1_sent: 3,
+    followup_2_sent: 5,
+    followup_3_sent: 7
+  },
+  staleAfterDays: 14
+};
+var PENDING_STATE = { stateKey: "pending", label: "Pending" };
+var ACQ_LIST_MEMBERS_LEAD_GEN_PIPELINE = {
+  pipelineKey: "lead-gen",
+  label: "Lead Generation",
+  entityKey: "acq.list-member",
+  stages: [
+    {
+      stageKey: "outreach",
+      label: "Outreach",
+      states: [
+        PENDING_STATE,
+        { stateKey: "personalized", label: "Personalized" },
+        { stateKey: "uploaded", label: "Uploaded" },
+        { stateKey: "interested", label: "Interested" }
+      ]
+    },
+    {
+      stageKey: "prospecting",
+      label: "Prospecting",
+      states: [
+        PENDING_STATE,
+        { stateKey: "discovered", label: "Discovered" },
+        { stateKey: "verified", label: "Verified" }
+      ]
+    },
+    {
+      stageKey: "qualification",
+      label: "Qualification",
+      states: [PENDING_STATE]
+    }
+  ]
+};
+var ACQ_LIST_COMPANIES_LEAD_GEN_PIPELINE = {
+  pipelineKey: "lead-gen",
+  label: "Lead Generation",
+  entityKey: "acq.list-company",
+  stages: [
+    {
+      stageKey: "outreach",
+      label: "Outreach",
+      states: [PENDING_STATE, { stateKey: "uploaded", label: "Uploaded" }]
+    },
+    {
+      stageKey: "prospecting",
+      label: "Prospecting",
+      states: [
+        PENDING_STATE,
+        { stateKey: "populated", label: "Populated" },
+        { stateKey: "extracted", label: "Extracted" }
+      ]
+    },
+    {
+      stageKey: "qualification",
+      label: "Qualification",
+      states: [PENDING_STATE, { stateKey: "qualified", label: "Qualified" }]
+    }
+  ]
+};
+var LEAD_GEN_PIPELINE_DEFINITIONS = {
+  "acq.list-member": [ACQ_LIST_MEMBERS_LEAD_GEN_PIPELINE],
+  "acq.list-company": [ACQ_LIST_COMPANIES_LEAD_GEN_PIPELINE]
+};
+
+// ../core/src/organization-model/contracts.ts
+var PROJECTS_VIEW_ACTION_ID = "delivery.projects.view";
+
+// ../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 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 SurfaceTypeSchema = z.enum(["page", "dashboard", "graph", "detail", "list", "settings"]).meta({ label: "Surface type", color: "blue" });
+var SurfaceDefinitionSchema = 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: {} } });
+function getSortedSidebarEntries(nodes) {
+  return Object.entries(nodes).sort(([leftId, left], [rightId, right]) => {
+    const orderDelta = (left.order ?? Number.MAX_SAFE_INTEGER) - (right.order ?? Number.MAX_SAFE_INTEGER);
+    return orderDelta === 0 ? leftId.localeCompare(rightId) : orderDelta;
+  });
+}
+z.object({
+  id: ModelIdSchema,
+  label: LabelSchema,
+  placement: z.string().trim().min(1).max(50),
+  surfaceIds: z.array(ModelIdSchema.meta({ ref: "surface" })).default([])
+});
+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 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 KnowledgeTargetKindSchema = z.enum([
+  "system",
+  "resource",
+  "knowledge",
+  "stage",
+  "action",
+  "role",
+  "goal",
+  "customer-segment",
+  "offering",
+  // 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>'
+  // which contains a colon separator and cannot satisfy ModelIdSchema. Use a permissive
+  // string schema here; business-logic validation of target existence is done in
+  // OrganizationModelSchema.superRefine (knowledgeTargetExists).
+  id: z.string().trim().min(1).max(300)
+});
+var LegacyKnowledgeLinkSchema = z.object({
+  nodeId: NodeIdStringSchema
+});
+var CanonicalKnowledgeLinkSchema = z.object({
+  target: KnowledgeTargetRefSchema
+});
+function nodeIdFromTarget(target) {
+  return `${target.kind}:${target.id}`;
+}
+function targetFromNodeId(nodeId2) {
+  const [kind, ...idParts] = nodeId2.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(),
+  /** 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({});
+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/schema.ts
+z.enum([
+  "branding",
+  "identity",
+  "customers",
+  "offerings",
+  "roles",
+  "goals",
+  "systems",
+  "resources",
+  "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" },
+  resources: { version: 1, lastModified: "2026-05-10" },
+  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,
+  resources: 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),
+  resources: ResourcesDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_RESOURCES),
+  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"].includes(targetKind);
+  }
+  if (knowledgeKind === "strategy") {
+    return ["system", "goal", "offering", "customer-segment"].includes(targetKind);
+  }
+  return false;
+}
+var OrganizationModelSchema = 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 });
+      if (system.subsystems !== void 0) {
+        result.push(...collectAllSystems(system.subsystems, path, [...currentSchemaPath, "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.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.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(([nodeId2, node]) => {
+      const nodePath = [...schemaPath, nodeId2];
+      const existingNodePath = sidebarNodeIds.get(nodeId2);
+      if (existingNodePath !== void 0) {
+        addIssue(ctx, nodePath, `Sidebar node id "${nodeId2}" duplicates another sidebar node`);
+      } else {
+        sidebarNodeIds.set(nodeId2, nodePath);
+      }
+      if (node.type === "group") {
+        collectSidebarNodes(node.children, [...nodePath, "children"]);
+        return;
+      }
+      sidebarSurfaces.push({ id: nodeId2, 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, nodeId2);
+      }
+      node.targets?.systems?.forEach((systemId, systemIndex) => {
+        if (!systemsById.has(systemId)) {
+          addIssue(
+            ctx,
+            [...nodePath, "targets", "systems", systemIndex],
+            `Sidebar surface "${nodeId2}" 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((nodeId2, nodeIndex) => {
+      if (!knowledgeById.has(nodeId2)) {
+        addIssue(
+          ctx,
+          [...schemaPath, "governedByKnowledge", nodeIndex],
+          `System "${system.id}" references unknown knowledge node "${nodeId2}"`
+        );
+      }
+    });
+    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));
+  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);
+    return false;
+  }
+  Object.entries(model.knowledge).forEach(([nodeId2, node]) => {
+    node.links.forEach((link, linkIndex) => {
+      if (!knowledgeTargetExists(link.target.kind, link.target.id)) {
+        addIssue(
+          ctx,
+          ["knowledge", nodeId2, "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", nodeId2, "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}"`
+      );
+    }
+  });
+  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(([nodeId2, node]) => {
+    node.ownerIds.forEach((roleId, ownerIndex) => {
+      if (!rolesById.has(roleId)) {
+        addIssue(
+          ctx,
+          ["knowledge", nodeId2, "ownerIds", ownerIndex],
+          `Knowledge node "${node.id}" references unknown owner role "${roleId}"`
+        );
+      }
+    });
+  });
+  function validateSystemContent(system, systemPath) {
+    const content = system.content;
+    if (content === void 0 || Object.keys(content).length === 0) {
+      if (system.subsystems !== void 0) {
+        Object.entries(system.subsystems).forEach(([childKey, child]) => {
+          validateSystemContent(child, [...systemPath, "subsystems", childKey]);
+        });
+      }
+      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 (system.subsystems !== void 0) {
+      Object.entries(system.subsystems).forEach(([childKey, child]) => {
+        validateSystemContent(child, [...systemPath, "subsystems", childKey]);
+      });
+    }
+  }
+  Object.entries(model.systems).forEach(([systemKey, system]) => {
+    validateSystemContent(system, ["systems", systemKey]);
+  });
+});
+
+// ../core/src/organization-model/graph/schema.ts
+var OrganizationGraphNodeKindSchema = z.enum([
+  "organization",
+  "system",
+  "role",
+  "action",
+  "entity",
+  "event",
+  "policy",
+  "stage",
+  "resource",
+  "knowledge",
+  "customer-segment",
+  "offering",
+  "goal",
+  "surface",
+  "navigation-group",
+  // Phase 3 preview — Phase 4 populates via graph projection of system.content entries.
+  "content-node"
+]);
+var OrganizationGraphEdgeKindSchema = z.enum([
+  "contains",
+  "references",
+  "maps_to",
+  "uses",
+  "governs",
+  "links",
+  "affects",
+  "emits",
+  "originates_from",
+  "triggers",
+  "applies_to",
+  "effects"
+]);
+var OrganizationGraphNodeSchema = z.object({
+  id: z.string().trim().min(1).max(200),
+  kind: OrganizationGraphNodeKindSchema,
+  label: LabelSchema,
+  sourceId: z.string().trim().min(1).max(255).optional(),
+  description: DescriptionSchema.optional(),
+  icon: IconNameSchema.optional(),
+  enabled: z.boolean().optional(),
+  resourceType: z.enum(["workflow", "agent", "trigger", "integration", "external", "human_checkpoint", "script"]).optional()
+});
+var OrganizationGraphEdgeSchema = z.object({
+  id: z.string().trim().min(1).max(250),
+  kind: OrganizationGraphEdgeKindSchema,
+  sourceId: z.string().trim().min(1).max(200),
+  targetId: z.string().trim().min(1).max(200),
+  label: z.string().trim().min(1).max(120).optional(),
+  relationshipType: z.enum(["triggers", "uses", "approval"]).optional()
+});
+var OrganizationGraphSchema = z.object({
+  version: z.literal(1),
+  organizationModelVersion: OrganizationModelSchema.shape.version,
+  nodes: z.array(OrganizationGraphNodeSchema),
+  edges: z.array(OrganizationGraphEdgeSchema)
+});
+var BuildOrganizationGraphInputSchema = z.object({
+  organizationModel: OrganizationModelSchema,
+  commandViewData: z.unknown().optional()
+});
+
+// ../core/src/organization-model/migration-helpers.ts
+function getAllPipelines(model) {
+  const results = [];
+  for (const { path: systemPath, system } of listAllSystems(model)) {
+    const content = system.content ?? {};
+    for (const [localId, node] of Object.entries(content)) {
+      if (node.kind !== "schema" || node.type !== "pipeline") continue;
+      const data = node.data ?? {};
+      const stages = Object.entries(content).filter(([, s]) => s.kind === "schema" && s.type === "stage" && s.parentContentId === localId).map(([stageLocalId, s]) => {
+        const sd = s.data ?? {};
+        return {
+          id: stageLocalId,
+          label: s.label ?? stageLocalId,
+          order: typeof sd.order === "number" ? sd.order : 0,
+          semanticClass: sd.semanticClass ?? "open",
+          surfaceIds: Array.isArray(sd.surfaceIds) ? sd.surfaceIds : [],
+          resourceIds: Array.isArray(sd.resourceIds) ? sd.resourceIds : [],
+          color: typeof sd.color === "string" ? sd.color : void 0
+        };
+      }).sort((a, b) => a.order - b.order);
+      const pipeline = {
+        id: localId,
+        label: node.label ?? localId,
+        entityId: typeof data.entityId === "string" ? data.entityId : "",
+        stages,
+        ...typeof node.description === "string" ? { description: node.description } : {}
+      };
+      results.push({ systemPath, pipeline });
+    }
+  }
+  return results;
+}
+function getAllBuildTemplates(model) {
+  const results = [];
+  for (const { system } of listAllSystems(model)) {
+    const content = system.content ?? {};
+    for (const [localId, node] of Object.entries(content)) {
+      if (node.kind !== "schema" || node.type !== "template") continue;
+      const nd = node.data ?? {};
+      const steps = Object.entries(content).filter(([, s]) => s.kind === "schema" && s.type === "template-step" && s.parentContentId === localId).map(([stepLocalId, s]) => {
+        const sd = s.data ?? {};
+        return {
+          id: stepLocalId,
+          label: s.label ?? stepLocalId,
+          ...s.description ? { description: s.description } : {},
+          // Pass through all data fields — template-step payload is richer than Pipeline;
+          // Wave 2 authors the canonical shape; Wave 4 verifies round-trip fidelity.
+          ...sd
+        };
+      });
+      results.push({
+        id: localId,
+        label: node.label ?? localId,
+        ...node.description ? { description: node.description } : {},
+        ...typeof nd.color === "string" ? { color: nd.color } : {},
+        // BuildTemplate requires steps array — cast via spread; Wave 4 adds type-safe assertions.
+        steps
+      });
+    }
+  }
+  return results;
+}
+function getAllProspectingStages(model, kind) {
+  const results = [];
+  for (const { system } of listAllSystems(model)) {
+    const content = system.content ?? {};
+    for (const [localId, node] of Object.entries(content)) {
+      if (node.kind !== "schema" || node.type !== "stage") continue;
+      const sd = node.data ?? {};
+      if (sd.entityKind !== kind) continue;
+      results.push({
+        id: localId,
+        label: node.label ?? localId,
+        order: typeof sd.order === "number" ? sd.order : 0,
+        ...typeof sd.color === "string" ? { color: sd.color } : {},
+        ...node.description ? { description: node.description } : {}
+      });
+    }
+  }
+  return results.sort((a, b) => a.order - b.order);
+}
+function getAllProjectStatuses(model, appliesTo) {
+  const results = [];
+  for (const { system } of listAllSystems(model)) {
+    const content = system.content ?? {};
+    for (const [flowLocalId, flowNode] of Object.entries(content)) {
+      if (flowNode.kind !== "schema" || flowNode.type !== "status-flow") continue;
+      const fd = flowNode.data ?? {};
+      if (fd.appliesTo !== appliesTo) continue;
+      for (const [statusLocalId, statusNode] of Object.entries(content)) {
+        if (statusNode.kind !== "schema" || statusNode.type !== "status") continue;
+        if (statusNode.parentContentId !== flowLocalId) continue;
+        const sd = statusNode.data ?? {};
+        results.push({
+          id: statusLocalId,
+          label: statusNode.label ?? statusLocalId,
+          order: typeof sd.order === "number" ? sd.order : 0,
+          ...typeof sd.color === "string" ? { color: sd.color } : {},
+          ...statusNode.description ? { description: statusNode.description } : {}
+        });
+      }
+    }
+  }
+  return results.sort((a, b) => a.order - b.order);
+}
+
+// ../core/src/organization-model/graph/build.ts
+function nodeId(kind, sourceId) {
+  return kind === "organization" ? "organization-model" : `${kind}:${sourceId ?? ""}`;
+}
+function edgeId(kind, sourceId, targetId, variant) {
+  return variant ? `edge:${kind}:${variant}:${sourceId}:${targetId}` : `edge:${kind}:${sourceId}:${targetId}`;
+}
+function pushUniqueNode(nodes, seen, node) {
+  if (seen.has(node.id)) return;
+  seen.add(node.id);
+  nodes.push(node);
+}
+function pushUniqueEdge(edges, seen, edge) {
+  if (seen.has(edge.id)) return;
+  seen.add(edge.id);
+  edges.push(edge);
+}
+function collectSidebarGraphNodes(nodes, groups, surfaces, parentGroupId) {
+  Object.entries(nodes).sort(([leftId, left], [rightId, right]) => {
+    const orderDelta = (left.order ?? Number.MAX_SAFE_INTEGER) - (right.order ?? Number.MAX_SAFE_INTEGER);
+    return orderDelta === 0 ? leftId.localeCompare(rightId) : orderDelta;
+  }).forEach(([id, node]) => {
+    if (node.type === "group") {
+      groups.push({ id, node, ...parentGroupId !== void 0 ? { parentGroupId } : {} });
+      collectSidebarGraphNodes(node.children, groups, surfaces, id);
+      return;
+    }
+    surfaces.push({ id, node, ...parentGroupId !== void 0 ? { parentGroupId } : {} });
+  });
+}
+function upsertResourceNode(nodes, seen, resourceNodesById, node) {
+  const existing = resourceNodesById.get(node.id);
+  if (existing) {
+    if (!existing.label || existing.label === existing.sourceId) {
+      existing.label = node.label;
+    }
+    if (!existing.description && node.description) {
+      existing.description = node.description;
+    }
+    if (!existing.sourceId && node.sourceId) {
+      existing.sourceId = node.sourceId;
+    }
+    if (!existing.resourceType && node.resourceType) {
+      existing.resourceType = node.resourceType;
+    }
+    return existing;
+  }
+  resourceNodesById.set(node.id, node);
+  pushUniqueNode(nodes, seen, node);
+  return node;
+}
+function ensureResourceNode(nodes, seen, resourceNodesById, resourceId) {
+  const existing = resourceNodesById.get(nodeId("resource", resourceId));
+  if (existing) return existing;
+  return upsertResourceNode(nodes, seen, resourceNodesById, {
+    id: nodeId("resource", resourceId),
+    kind: "resource",
+    label: resourceId,
+    sourceId: resourceId
+  });
+}
+function normalizeCommandViewResourceType(resourceType) {
+  return resourceType === "human" ? "human_checkpoint" : resourceType;
+}
+function normalizeOrganizationModelResourceType(resourceType) {
+  return resourceType;
+}
+function collectCommandViewResources(commandViewData) {
+  return [
+    ...commandViewData.workflows,
+    ...commandViewData.agents,
+    ...commandViewData.triggers,
+    ...commandViewData.integrations,
+    ...commandViewData.externalResources,
+    ...commandViewData.humanCheckpoints
+  ];
+}
+function invocationSignature(invocation) {
+  switch (invocation.kind) {
+    case "slash-command":
+      return `${invocation.kind}:${invocation.command}`;
+    case "mcp-tool":
+      return `${invocation.kind}:${invocation.server}:${invocation.name}`;
+    case "api-endpoint":
+      return `${invocation.kind}:${invocation.method}:${invocation.path}`;
+    case "script-execution":
+      return `${invocation.kind}:${invocation.resourceId}`;
+  }
+}
+function invocationLabel(invocation) {
+  switch (invocation.kind) {
+    case "slash-command":
+      return invocation.command;
+    case "mcp-tool":
+      return `${invocation.server}.${invocation.name}`;
+    case "api-endpoint":
+      return `${invocation.method} ${invocation.path}`;
+    case "script-execution":
+      return `script ${invocation.resourceId}`;
+  }
+}
+function eventNodeId(eventId) {
+  return nodeId("event", eventId);
+}
+function buildResourceEventDescriptor(resourceId, emission) {
+  return {
+    ...emission,
+    id: `${resourceId}:${emission.eventKey}`,
+    ownerId: resourceId,
+    ownerKind: "resource"
+  };
+}
+function buildEntityEventDescriptor(entity, eventKey, label) {
+  return {
+    id: `${entity.id}:${eventKey}`,
+    ownerId: entity.id,
+    ownerKind: "entity",
+    eventKey,
+    label
+  };
+}
+function pushEventProjection(nodes, nodeIds, edges, edgeIds, eventNodeIdsByEventId, event, sourceNodeId, edgeKind) {
+  const id = eventNodeId(event.id);
+  eventNodeIdsByEventId.set(event.id, id);
+  pushUniqueNode(nodes, nodeIds, {
+    id,
+    kind: "event",
+    label: event.label,
+    sourceId: event.id
+  });
+  const sourceId = edgeKind === "originates_from" ? id : sourceNodeId;
+  const targetId = edgeKind === "originates_from" ? sourceNodeId : id;
+  pushUniqueEdge(edges, edgeIds, {
+    id: edgeId(edgeKind, sourceId, targetId),
+    kind: edgeKind,
+    sourceId,
+    targetId
+  });
+}
+function buildOrganizationGraph(input) {
+  const parsed = BuildOrganizationGraphInputSchema.parse(input);
+  const organizationModel = parsed.organizationModel;
+  const commandViewData = parsed.commandViewData;
+  const nodes = [];
+  const edges = [];
+  const nodeIds = /* @__PURE__ */ new Set();
+  const edgeIds = /* @__PURE__ */ new Set();
+  const resourceNodesById = /* @__PURE__ */ new Map();
+  const organizationModelResourceIds = new Set(Object.keys(organizationModel.resources));
+  const actionIdsByInvocation = /* @__PURE__ */ new Map();
+  const projectedEventNodeIdsByEventId = /* @__PURE__ */ new Map();
+  const organizationNode = {
+    id: nodeId("organization"),
+    kind: "organization",
+    label: "Organization Model"
+  };
+  pushUniqueNode(nodes, nodeIds, organizationNode);
+  const systemsWithPaths = listAllSystems(organizationModel);
+  const systemPathByRef = /* @__PURE__ */ new Map();
+  for (const { path, system } of systemsWithPaths) {
+    systemPathByRef.set(path, path);
+    systemPathByRef.set(system.id, path);
+  }
+  const validSystemRefs = new Set(systemPathByRef.keys());
+  const systemNodeId = (systemRef) => nodeId("system", systemPathByRef.get(systemRef) ?? systemRef);
+  for (const { path, system } of systemsWithPaths.sort((a, b) => a.path.localeCompare(b.path))) {
+    const id = nodeId("system", path);
+    pushUniqueNode(nodes, nodeIds, {
+      id,
+      kind: "system",
+      label: system.label ?? system.title ?? system.id,
+      sourceId: path,
+      description: system.description,
+      icon: system.ui?.icon ?? system.icon,
+      enabled: system.enabled
+    });
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId("contains", organizationNode.id, id),
+      kind: "contains",
+      sourceId: organizationNode.id,
+      targetId: id
+    });
+    const parentSystemId = path.includes(".") ? path.slice(0, path.lastIndexOf(".")) : void 0;
+    if (parentSystemId !== void 0) {
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("contains", nodeId("system", parentSystemId), id),
+        kind: "contains",
+        sourceId: nodeId("system", parentSystemId),
+        targetId: id
+      });
+    }
+  }
+  for (const role of Object.values(organizationModel.roles).sort((a, b) => a.id.localeCompare(b.id))) {
+    const id = nodeId("role", role.id);
+    pushUniqueNode(nodes, nodeIds, {
+      id,
+      kind: "role",
+      label: role.title,
+      sourceId: role.id,
+      description: role.responsibilities.length > 0 ? role.responsibilities.join("; ") : void 0
+    });
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId("contains", organizationNode.id, id),
+      kind: "contains",
+      sourceId: organizationNode.id,
+      targetId: id
+    });
+    if (role.reportsToId !== void 0) {
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("references", id, nodeId("role", role.reportsToId), "reports-to"),
+        kind: "references",
+        sourceId: id,
+        targetId: nodeId("role", role.reportsToId),
+        label: "reports to"
+      });
+    }
+    for (const systemId of role.responsibleFor ?? []) {
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("governs", id, systemNodeId(systemId), "responsible-for"),
+        kind: "governs",
+        sourceId: id,
+        targetId: systemNodeId(systemId),
+        label: "responsible for"
+      });
+    }
+  }
+  for (const node of Object.values(organizationModel.knowledge).sort((a, b) => a.id.localeCompare(b.id))) {
+    const id = nodeId("knowledge", node.id);
+    pushUniqueNode(nodes, nodeIds, {
+      id,
+      kind: "knowledge",
+      label: node.title,
+      sourceId: node.id,
+      description: node.summary,
+      icon: node.icon
+    });
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId("contains", organizationNode.id, id),
+      kind: "contains",
+      sourceId: organizationNode.id,
+      targetId: id
+    });
+    for (const link of node.links) {
+      const targetId = link.target.kind === "system" ? systemNodeId(link.target.id) : link.nodeId;
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("governs", id, targetId),
+        kind: "governs",
+        sourceId: id,
+        targetId
+      });
+    }
+  }
+  const allStages = [
+    ...getAllProspectingStages(organizationModel, "company"),
+    ...getAllProspectingStages(organizationModel, "contact")
+  ].sort((a, b) => a.order - b.order || a.id.localeCompare(b.id));
+  for (const stage of allStages) {
+    const id = nodeId("stage", stage.id);
+    pushUniqueNode(nodes, nodeIds, {
+      id,
+      kind: "stage",
+      label: stage.label,
+      sourceId: stage.id,
+      ...stage.description ? { description: stage.description } : {},
+      ...stage.icon ? { icon: stage.icon } : {}
+    });
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId("contains", organizationNode.id, id),
+      kind: "contains",
+      sourceId: organizationNode.id,
+      targetId: id
+    });
+  }
+  for (const action of Object.values(organizationModel.actions).sort((a, b) => a.id.localeCompare(b.id))) {
+    const id = nodeId("action", action.id);
+    pushUniqueNode(nodes, nodeIds, {
+      id,
+      kind: "action",
+      label: action.label,
+      sourceId: action.id,
+      description: action.description
+    });
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId("contains", organizationNode.id, id),
+      kind: "contains",
+      sourceId: organizationNode.id,
+      targetId: id
+    });
+    if (action.resourceId !== void 0) {
+      const resourceNode = ensureResourceNode(nodes, nodeIds, resourceNodesById, action.resourceId);
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("maps_to", id, resourceNode.id),
+        kind: "maps_to",
+        sourceId: id,
+        targetId: resourceNode.id
+      });
+    }
+    for (const entityId of action.affects ?? []) {
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("affects", id, nodeId("entity", entityId)),
+        kind: "affects",
+        sourceId: id,
+        targetId: nodeId("entity", entityId)
+      });
+    }
+    for (const invocation of action.invocations) {
+      const key = invocationSignature(invocation);
+      const existing = actionIdsByInvocation.get(key);
+      if (existing) {
+        existing.push(id);
+      } else {
+        actionIdsByInvocation.set(key, [id]);
+      }
+    }
+  }
+  for (const entity of Object.values(organizationModel.entities).sort(
+    (a, b) => a.order - b.order || a.id.localeCompare(b.id)
+  )) {
+    const id = nodeId("entity", entity.id);
+    pushUniqueNode(nodes, nodeIds, {
+      id,
+      kind: "entity",
+      label: entity.label,
+      sourceId: entity.id,
+      description: entity.description
+    });
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId("contains", systemNodeId(entity.ownedBySystemId), id, "system-entity"),
+      kind: "contains",
+      sourceId: systemNodeId(entity.ownedBySystemId),
+      targetId: id
+    });
+    for (const [linkIndex, link] of (entity.links ?? []).entries()) {
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("links", id, nodeId("entity", link.toEntity), `${link.kind}-${linkIndex}`),
+        kind: "links",
+        sourceId: id,
+        targetId: nodeId("entity", link.toEntity),
+        label: link.label ?? link.kind
+      });
+    }
+    if (entity.stateCatalogId !== void 0) {
+      const stateEvents = [];
+      if (entity.stateCatalogId === "crm.pipeline") {
+        for (const { pipeline } of getAllPipelines(organizationModel).filter(({ pipeline: p }) => p.entityId === entity.id).sort((a, b) => a.pipeline.id.localeCompare(b.pipeline.id))) {
+          for (const stage of [...pipeline.stages].sort((a, b) => a.order - b.order || a.id.localeCompare(b.id))) {
+            stateEvents.push(buildEntityEventDescriptor(entity, stage.id, stage.label));
+          }
+        }
+      }
+      if (entity.stateCatalogId === "delivery.task") {
+        for (const status of getAllProjectStatuses(organizationModel, "task").sort(
+          (a, b) => a.order - b.order || a.id.localeCompare(b.id)
+        )) {
+          stateEvents.push(buildEntityEventDescriptor(entity, status.id, status.label));
+        }
+      }
+      if (entity.stateCatalogId === "lead-gen.company" || entity.stateCatalogId === "lead-gen.contact") {
+        const leadGenEntity = entity.stateCatalogId === "lead-gen.company" ? "company" : "contact";
+        for (const stage of Object.values(LEAD_GEN_STAGE_CATALOG).sort(
+          (a, b) => a.order - b.order || a.key.localeCompare(b.key)
+        )) {
+          if (stage.entity !== leadGenEntity && !(stage.additionalEntities ?? []).includes(leadGenEntity)) continue;
+          stateEvents.push(buildEntityEventDescriptor(entity, stage.key, stage.label));
+        }
+      }
+      for (const event of stateEvents) {
+        pushEventProjection(
+          nodes,
+          nodeIds,
+          edges,
+          edgeIds,
+          projectedEventNodeIdsByEventId,
+          event,
+          id,
+          "originates_from"
+        );
+      }
+    }
+  }
+  for (const { path, system } of systemsWithPaths.sort((a, b) => a.path.localeCompare(b.path))) {
+    for (const actionRef of system.actions ?? []) {
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("uses", nodeId("system", path), nodeId("action", actionRef.actionId), actionRef.intent),
+        kind: "uses",
+        sourceId: nodeId("system", path),
+        targetId: nodeId("action", actionRef.actionId),
+        label: actionRef.intent
+      });
+    }
+  }
+  const validSystemPaths = /* @__PURE__ */ new Set([...validSystemRefs]);
+  for (const resource of Object.values(organizationModel.resources).sort((a, b) => a.id.localeCompare(b.id))) {
+    const resourceNode = upsertResourceNode(nodes, nodeIds, resourceNodesById, {
+      id: nodeId("resource", resource.id),
+      kind: "resource",
+      label: resource.id,
+      sourceId: resource.id,
+      resourceType: normalizeOrganizationModelResourceType(resource.kind)
+    });
+    if (validSystemPaths.has(resource.systemPath)) {
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("contains", systemNodeId(resource.systemPath), resourceNode.id, "system-resource"),
+        kind: "contains",
+        sourceId: systemNodeId(resource.systemPath),
+        targetId: resourceNode.id
+      });
+    }
+    if (resource.kind === "workflow" || resource.kind === "agent") {
+      for (const emission of resource.emits ?? []) {
+        pushEventProjection(
+          nodes,
+          nodeIds,
+          edges,
+          edgeIds,
+          projectedEventNodeIdsByEventId,
+          buildResourceEventDescriptor(resource.id, emission),
+          resourceNode.id,
+          "emits"
+        );
+      }
+    }
+    if (resource.kind === "agent") {
+      for (const [index, invocation] of resource.invocations.entries()) {
+        const label = invocationLabel(invocation);
+        if (invocation.kind === "script-execution") {
+          const targetNode = ensureResourceNode(nodes, nodeIds, resourceNodesById, invocation.resourceId);
+          pushUniqueEdge(edges, edgeIds, {
+            id: edgeId("uses", resourceNode.id, targetNode.id, `agent-invocation-${index}`),
+            kind: "uses",
+            sourceId: resourceNode.id,
+            targetId: targetNode.id,
+            label
+          });
+          continue;
+        }
+        for (const actionNodeId of actionIdsByInvocation.get(invocationSignature(invocation)) ?? []) {
+          pushUniqueEdge(edges, edgeIds, {
+            id: edgeId("references", resourceNode.id, actionNodeId, `agent-invocation-${index}`),
+            kind: "references",
+            sourceId: resourceNode.id,
+            targetId: actionNodeId,
+            label
+          });
+        }
+      }
+    }
+  }
+  for (const policy of Object.values(organizationModel.policies).sort(
+    (a, b) => a.order - b.order || a.id.localeCompare(b.id)
+  )) {
+    const id = nodeId("policy", policy.id);
+    pushUniqueNode(nodes, nodeIds, {
+      id,
+      kind: "policy",
+      label: policy.label,
+      sourceId: policy.id,
+      description: policy.description
+    });
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId("contains", organizationNode.id, id),
+      kind: "contains",
+      sourceId: organizationNode.id,
+      targetId: id
+    });
+    for (const systemId of policy.appliesTo.systemIds) {
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("applies_to", id, systemNodeId(systemId), "system"),
+        kind: "applies_to",
+        sourceId: id,
+        targetId: systemNodeId(systemId)
+      });
+    }
+    for (const actionId of policy.appliesTo.actionIds) {
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("applies_to", id, nodeId("action", actionId), "action"),
+        kind: "applies_to",
+        sourceId: id,
+        targetId: nodeId("action", actionId)
+      });
+    }
+    for (const resourceId of policy.appliesTo.resourceIds) {
+      const resourceNode = ensureResourceNode(nodes, nodeIds, resourceNodesById, resourceId);
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("applies_to", id, resourceNode.id, "resource"),
+        kind: "applies_to",
+        sourceId: id,
+        targetId: resourceNode.id
+      });
+    }
+    for (const roleId of policy.appliesTo.roleIds) {
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("applies_to", id, nodeId("role", roleId), "role"),
+        kind: "applies_to",
+        sourceId: id,
+        targetId: nodeId("role", roleId)
+      });
+    }
+    if (policy.trigger.kind === "event") {
+      const eventNode = projectedEventNodeIdsByEventId.get(policy.trigger.eventId);
+      if (eventNode !== void 0) {
+        pushUniqueEdge(edges, edgeIds, {
+          id: edgeId("triggers", eventNode, id),
+          kind: "triggers",
+          sourceId: eventNode,
+          targetId: id
+        });
+      }
+    } else if (policy.trigger.kind === "action-invocation") {
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("triggers", nodeId("action", policy.trigger.actionId), id),
+        kind: "triggers",
+        sourceId: nodeId("action", policy.trigger.actionId),
+        targetId: id
+      });
+    }
+    for (const [effectIndex, effect] of policy.actions.entries()) {
+      if (effect.kind === "invoke-action") {
+        pushUniqueEdge(edges, edgeIds, {
+          id: edgeId("effects", id, nodeId("action", effect.actionId), `invoke-action-${effectIndex}`),
+          kind: "effects",
+          sourceId: id,
+          targetId: nodeId("action", effect.actionId),
+          label: "invoke action"
+        });
+      }
+      if ((effect.kind === "notify-role" || effect.kind === "require-approval") && effect.roleId !== void 0) {
+        pushUniqueEdge(edges, edgeIds, {
+          id: edgeId("effects", id, nodeId("role", effect.roleId), `${effect.kind}-${effectIndex}`),
+          kind: "effects",
+          sourceId: id,
+          targetId: nodeId("role", effect.roleId),
+          label: effect.kind
+        });
+      }
+    }
+  }
+  for (const segment of Object.values(organizationModel.customers).sort(
+    (a, b) => a.order - b.order || a.id.localeCompare(b.id)
+  )) {
+    const id = nodeId("customer-segment", segment.id);
+    pushUniqueNode(nodes, nodeIds, {
+      id,
+      kind: "customer-segment",
+      label: segment.name,
+      sourceId: segment.id,
+      description: segment.description || void 0
+    });
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId("contains", organizationNode.id, id),
+      kind: "contains",
+      sourceId: organizationNode.id,
+      targetId: id
+    });
+  }
+  for (const product of Object.values(organizationModel.offerings).sort(
+    (a, b) => a.order - b.order || a.id.localeCompare(b.id)
+  )) {
+    const id = nodeId("offering", product.id);
+    pushUniqueNode(nodes, nodeIds, {
+      id,
+      kind: "offering",
+      label: product.name,
+      sourceId: product.id,
+      description: product.description || void 0
+    });
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId("contains", organizationNode.id, id),
+      kind: "contains",
+      sourceId: organizationNode.id,
+      targetId: id
+    });
+    for (const segmentId of product.targetSegmentIds) {
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("applies_to", id, nodeId("customer-segment", segmentId), "targets-segment"),
+        kind: "applies_to",
+        sourceId: id,
+        targetId: nodeId("customer-segment", segmentId),
+        label: "targets"
+      });
+    }
+  }
+  for (const objective of Object.values(organizationModel.goals).sort(
+    (a, b) => a.order - b.order || a.id.localeCompare(b.id)
+  )) {
+    const id = nodeId("goal", objective.id);
+    pushUniqueNode(nodes, nodeIds, {
+      id,
+      kind: "goal",
+      label: objective.description,
+      sourceId: objective.id
+    });
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId("contains", organizationNode.id, id),
+      kind: "contains",
+      sourceId: organizationNode.id,
+      targetId: id
+    });
+  }
+  const sidebarGroups = [];
+  const sidebarSurfaces = [];
+  collectSidebarGraphNodes(organizationModel.navigation.sidebar.primary, sidebarGroups, sidebarSurfaces);
+  collectSidebarGraphNodes(organizationModel.navigation.sidebar.bottom, sidebarGroups, sidebarSurfaces);
+  for (const { id: surfaceSourceId, node: surface, parentGroupId } of sidebarSurfaces) {
+    const id = nodeId("surface", surfaceSourceId);
+    pushUniqueNode(nodes, nodeIds, {
+      id,
+      kind: "surface",
+      label: surface.label,
+      sourceId: surfaceSourceId,
+      description: surface.description,
+      icon: surface.icon,
+      enabled: true
+    });
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId("contains", parentGroupId ? nodeId("navigation-group", parentGroupId) : organizationNode.id, id),
+      kind: "contains",
+      sourceId: parentGroupId ? nodeId("navigation-group", parentGroupId) : organizationNode.id,
+      targetId: id
+    });
+    for (const systemId of surface.targets?.systems ?? []) {
+      if (!validSystemRefs.has(systemId)) continue;
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("applies_to", id, systemNodeId(systemId), "surface-system"),
+        kind: "applies_to",
+        sourceId: id,
+        targetId: systemNodeId(systemId)
+      });
+    }
+  }
+  for (const { id: groupSourceId, node: group, parentGroupId } of sidebarGroups) {
+    const id = nodeId("navigation-group", groupSourceId);
+    pushUniqueNode(nodes, nodeIds, {
+      id,
+      kind: "navigation-group",
+      label: group.label,
+      sourceId: groupSourceId
+    });
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId("contains", parentGroupId ? nodeId("navigation-group", parentGroupId) : organizationNode.id, id),
+      kind: "contains",
+      sourceId: parentGroupId ? nodeId("navigation-group", parentGroupId) : organizationNode.id,
+      targetId: id
+    });
+  }
+  for (const { path, system } of listAllSystems(organizationModel).sort((a, b) => a.path.localeCompare(b.path))) {
+    const contentMap = system.content ?? {};
+    const systemSpineId = nodeId("system", path);
+    for (const [localId, contentNode] of Object.entries(contentMap).sort(([a], [b]) => a.localeCompare(b))) {
+      const contentNodeGraphId = `content-node:${path}:${localId}`;
+      pushUniqueNode(nodes, nodeIds, {
+        id: contentNodeGraphId,
+        kind: "content-node",
+        label: contentNode.label,
+        sourceId: `${path}:${localId}`,
+        description: contentNode.description
+        // Spread contentKind and contentType into attributes; the node schema
+        // does not have custom attribute slots, so we encode them in the label
+        // suffix for now. The actual kind/type are recoverable from sourceId +
+        // the registry lookup by consumers.
+      });
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("contains", systemSpineId, contentNodeGraphId, "system-content"),
+        kind: "contains",
+        sourceId: systemSpineId,
+        targetId: contentNodeGraphId
+      });
+      if (contentNode.parentContentId) {
+        const parentContentNodeGraphId = `content-node:${path}:${contentNode.parentContentId}`;
+        pushUniqueEdge(edges, edgeIds, {
+          id: edgeId("contains", parentContentNodeGraphId, contentNodeGraphId, "content-parent"),
+          kind: "contains",
+          sourceId: parentContentNodeGraphId,
+          targetId: contentNodeGraphId
+        });
+      }
+      if (contentNode.kind === "schema" && contentNode.type === "pipeline" && contentNode.data && typeof contentNode.data["entityId"] === "string") {
+        const targetEntityId = nodeId("entity", contentNode.data["entityId"]);
+        pushUniqueEdge(edges, edgeIds, {
+          id: edgeId("references", contentNodeGraphId, targetEntityId, "pipeline-entity"),
+          kind: "references",
+          sourceId: contentNodeGraphId,
+          targetId: targetEntityId,
+          label: "applies to entity"
+        });
+      }
+    }
+  }
+  for (const template of getAllBuildTemplates(organizationModel).sort((a, b) => a.id.localeCompare(b.id))) {
+    const steps = template.steps;
+    const stepById = new Map(steps.map((s) => [s.id, s]));
+    for (const step of [...steps].sort((a, b) => a.id.localeCompare(b.id))) {
+      const stageNodeId = nodeId("stage", step.stageKey);
+      const actionNodeId = nodeId("action", step.actionKey);
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("uses", stageNodeId, actionNodeId, step.id),
+        kind: "uses",
+        sourceId: stageNodeId,
+        targetId: actionNodeId
+      });
+      for (const depId of step.dependsOn ?? []) {
+        const depStep = stepById.get(depId);
+        if (depStep) {
+          const depStageNodeId = nodeId("stage", depStep.stageKey);
+          pushUniqueEdge(edges, edgeIds, {
+            id: edgeId("references", stageNodeId, depStageNodeId, step.id),
+            kind: "references",
+            sourceId: stageNodeId,
+            targetId: depStageNodeId
+          });
+        }
+      }
+    }
+  }
+  if (commandViewData) {
+    const commandViewResources = collectCommandViewResources(commandViewData).sort(
+      (a, b) => a.resourceId.localeCompare(b.resourceId)
+    );
+    for (const resource of commandViewResources) {
+      const id = nodeId("resource", resource.resourceId);
+      const resourceNode = upsertResourceNode(nodes, nodeIds, resourceNodesById, {
+        id,
+        kind: "resource",
+        label: resource.name,
+        sourceId: resource.resourceId,
+        description: resource.description,
+        resourceType: normalizeCommandViewResourceType(resource.type)
+      });
+      if (!organizationModelResourceIds.has(resource.resourceId)) {
+        pushUniqueEdge(edges, edgeIds, {
+          id: edgeId("contains", organizationNode.id, resourceNode.id),
+          kind: "contains",
+          sourceId: organizationNode.id,
+          targetId: resourceNode.id
+        });
+      }
+    }
+    for (const relationship of [...commandViewData.edges].sort((a, b) => a.id.localeCompare(b.id))) {
+      const sourceNode = ensureResourceNode(nodes, nodeIds, resourceNodesById, relationship.source);
+      const targetNode = ensureResourceNode(nodes, nodeIds, resourceNodesById, relationship.target);
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("contains", organizationNode.id, sourceNode.id),
+        kind: "contains",
+        sourceId: organizationNode.id,
+        targetId: sourceNode.id
+      });
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("contains", organizationNode.id, targetNode.id),
+        kind: "contains",
+        sourceId: organizationNode.id,
+        targetId: targetNode.id
+      });
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("references", sourceNode.id, targetNode.id, relationship.relationship),
+        kind: "references",
+        sourceId: sourceNode.id,
+        targetId: targetNode.id,
+        label: relationship.relationship,
+        relationshipType: relationship.relationship
+      });
+    }
+  }
+  const graph = {
+    version: 1,
+    organizationModelVersion: organizationModel.version,
+    nodes,
+    edges
+  };
+  return OrganizationGraphSchema.parse(graph);
+}
+
+// ../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: "feature.dashboard",
+        order: 10,
+        targets: { systems: ["dashboard"] }
+      },
+      business: {
+        type: "group",
+        label: "Business",
+        icon: "feature.business",
+        order: 20,
+        children: {
+          sales: {
+            type: "surface",
+            label: "Sales",
+            path: "/sales",
+            surfaceType: "page",
+            icon: "feature.sales",
+            order: 10,
+            targets: { systems: ["sales"] }
+          },
+          clients: {
+            type: "surface",
+            label: "Clients",
+            path: "/clients",
+            surfaceType: "list",
+            icon: "feature.projects",
+            order: 20,
+            targets: { systems: ["clients"] }
+          },
+          projects: {
+            type: "surface",
+            label: "Projects",
+            path: "/projects",
+            surfaceType: "page",
+            icon: "feature.projects",
+            order: 30,
+            targets: { systems: ["projects"] }
+          }
+        }
+      },
+      operations: {
+        type: "group",
+        label: "Operations",
+        icon: "feature.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: "feature.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: "group",
+        label: "Knowledge",
+        icon: "feature.knowledge",
+        order: 50,
+        children: {
+          "knowledge-base": {
+            type: "surface",
+            label: "Knowledge Base",
+            path: "/knowledge",
+            surfaceType: "page",
+            order: 10,
+            targets: { systems: ["knowledge.base"] }
+          },
+          "knowledge-command-view": {
+            type: "surface",
+            label: "Command View",
+            path: "/knowledge/command-view",
+            surfaceType: "graph",
+            order: 20,
+            targets: { systems: ["knowledge.command-view"] },
+            devOnly: true
+          }
+        }
+      }
+    },
+    bottom: {
+      settings: {
+        type: "group",
+        label: "Settings",
+        icon: "feature.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: "feature.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: "feature.dashboard"
+    },
+    platform: {
+      id: "platform",
+      order: 30,
+      label: "Platform",
+      description: "Elevasis platform architecture, capabilities, and implementation patterns",
+      enabled: true,
+      lifecycle: "active",
+      color: "cyan",
+      icon: "feature.platform"
+    },
+    finance: {
+      id: "finance",
+      order: 40,
+      label: "Finance",
+      description: "Finance operations, accounting, billing, reconciliation, and tax prep",
+      enabled: true,
+      lifecycle: "active",
+      color: "green",
+      icon: "feature.finance"
+    },
+    sales: {
+      id: "sales",
+      order: 60,
+      label: "Sales",
+      description: "Revenue workflows and customer acquisition",
+      enabled: true,
+      lifecycle: "active",
+      color: "blue",
+      icon: "feature.sales",
+      path: "/sales"
+    },
+    "sales.crm": {
+      id: "sales.crm",
+      order: 70,
+      label: "CRM",
+      description: "Relationship pipeline and deal management",
+      enabled: true,
+      lifecycle: "active",
+      color: "blue",
+      icon: "feature.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(DEFAULT_ORGANIZATION_MODEL_ACTIONS).map((action) => ({
+        actionId: action.id,
+        intent: "exposes"
+      })),
+      color: "cyan",
+      icon: "feature.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: "feature.projects",
+      path: "/projects"
+    },
+    clients: {
+      id: "clients",
+      order: 100,
+      label: "Clients",
+      description: "Client relationships, accounts, and business context",
+      enabled: true,
+      lifecycle: "active",
+      color: "orange",
+      icon: "feature.projects",
+      path: "/clients"
+    },
+    operations: {
+      id: "operations",
+      order: 110,
+      label: "Operations",
+      description: "Operational resources, topology, and orchestration visibility",
+      enabled: true,
+      lifecycle: "active",
+      color: "violet",
+      icon: "feature.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: "feature.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: "feature.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: "feature.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: "feature.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: "feature.knowledge"
+    },
+    "knowledge.base": {
+      id: "knowledge.base",
+      order: 460,
+      label: "Knowledge Base",
+      enabled: true,
+      lifecycle: "active",
+      path: "/knowledge"
+    }
+  },
+  resources: DEFAULT_ORGANIZATION_MODEL_RESOURCES,
+  actions: DEFAULT_ORGANIZATION_MODEL_ACTIONS,
+  entities: DEFAULT_ORGANIZATION_MODEL_ENTITIES2,
+  policies: DEFAULT_ORGANIZATION_MODEL_POLICIES,
+  // Phase 4 (D1): statuses top-level field removed; status data lives in system.content.
+  knowledge: DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE
+};
+
+// ../core/src/organization-model/resolve.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepMerge(base, override) {
+  if (override === void 0) {
+    return base;
+  }
+  if (Array.isArray(base)) {
+    return override ?? base;
+  }
+  if (!isPlainObject(base) || !isPlainObject(override)) {
+    return override ?? base;
+  }
+  const result = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    if (value === void 0) continue;
+    const existing = result[key];
+    result[key] = isPlainObject(existing) && isPlainObject(value) ? deepMerge(existing, value) : value;
+  }
+  return result;
+}
+function resolveOrganizationModel(override, organizationId) {
+  const merged = deepMerge(DEFAULT_ORGANIZATION_MODEL, override);
+  return OrganizationModelSchema.parse(merged);
+}
+
+// ../core/src/organization-model/surface-projection.ts
+function collectSystemsById(model) {
+  const systemsById = /* @__PURE__ */ new Map();
+  for (const { path, system } of listAllSystems(model)) {
+    systemsById.set(path, system);
+    systemsById.set(system.id, system);
+  }
+  return systemsById;
+}
+function getSystemWithAncestors(systemsById, systemId) {
+  const systems = [];
+  let current = systemsById.get(systemId);
+  while (current !== void 0) {
+    systems.unshift(current);
+    current = current.parentSystemId ? systemsById.get(current.parentSystemId) : void 0;
+  }
+  return systems;
+}
+function hasInheritedFlag(systemsById, systemIds, flag) {
+  return systemIds.some(
+    (systemId) => getSystemWithAncestors(systemsById, systemId).some((system) => system[flag] === true)
+  );
+}
+function isLifecycleEnabled2(system) {
+  if (system.enabled === false) return false;
+  return system.lifecycle !== "deprecated" && system.lifecycle !== "archived";
+}
+function isLifecycleDevOnly(system) {
+  return system.devOnly === true || system.lifecycle === "beta";
+}
+function isSystemEnabled(systemsById, systemId) {
+  const systemLineage = getSystemWithAncestors(systemsById, systemId);
+  return systemLineage.length > 0 && systemLineage.every(isLifecycleEnabled2);
+}
+function unique(values) {
+  return [...new Set(values)];
+}
+function collectSidebarSurfaces(nodes, schemaPath, surfaces = []) {
+  getSortedSidebarEntries(nodes).forEach(([id, node]) => {
+    const nodePath = [...schemaPath, id];
+    if (node.type === "group") {
+      collectSidebarSurfaces(node.children, [...nodePath, "children"], surfaces);
+      return;
+    }
+    surfaces.push({ id, surface: node, path: nodePath });
+  });
+  return surfaces;
+}
+function getSidebarSurfaces(model) {
+  return [
+    ...collectSidebarSurfaces(model.navigation.sidebar.primary, ["navigation", "sidebar", "primary"]),
+    ...collectSidebarSurfaces(model.navigation.sidebar.bottom, ["navigation", "sidebar", "bottom"])
+  ];
+}
+function projectOrganizationSurfaces(model) {
+  const systemsById = collectSystemsById(model);
+  return getSidebarSurfaces(model).map(({ id, surface }) => {
+    const targets = surface.targets ?? {};
+    const systemIds = unique((targets.systems ?? []).filter((systemId) => systemsById.has(systemId)));
+    const enabled = systemIds.every((candidate) => isSystemEnabled(systemsById, candidate));
+    const devOnly = surface.devOnly === true || hasInheritedFlag(systemsById, systemIds, "devOnly") || systemIds.some((candidate) => getSystemWithAncestors(systemsById, candidate).some(isLifecycleDevOnly));
+    const requiresAdmin = hasInheritedFlag(systemsById, systemIds, "requiresAdmin");
+    return {
+      id,
+      label: surface.label,
+      path: surface.path,
+      surfaceType: surface.surfaceType,
+      ...surface.description !== void 0 ? { description: surface.description } : {},
+      ...surface.icon !== void 0 ? { icon: surface.icon } : {},
+      ...surface.order !== void 0 ? { order: surface.order } : {},
+      systemIds,
+      entityIds: [...targets.entities ?? []],
+      resourceIds: [...targets.resources ?? []],
+      actionIds: [...targets.actions ?? []],
+      enabled,
+      ...devOnly ? { devOnly } : {},
+      ...surface.requiresAdmin === true || requiresAdmin ? { requiresAdmin: true } : {}
+    };
+  });
+}
+
+export { ActionSchema, AgentResourceEntrySchema, CRM_DISCOVERY_BOOKING_CANCELLED_STATE, CRM_DISCOVERY_LINK_SENT_STATE, CRM_DISCOVERY_NUDGING_STATE, CRM_DISCOVERY_REPLIED_STATE, CRM_PIPELINE_DEFINITION, CRM_PRIORITY_BUCKETS, DEFAULT_CRM_PRIORITY_RULE_CONFIG, EntitySchema, IdentityDomainSchema, IntegrationResourceEntrySchema, LEAD_GEN_PIPELINE_DEFINITIONS, LEAD_GEN_STAGE_CATALOG, PROJECTS_VIEW_ACTION_ID, PROSPECTING_STEPS, PolicySchema, RoleSchema, SalesStageSchema, ScriptResourceEntrySchema, SurfaceDefinitionSchema, SystemEntrySchema, WorkflowResourceEntrySchema, ancestorsOf, buildOrganizationGraph, childrenOf, defaultPathFor, devOnlyFor, findById, findByPath, findPipeline, getContent, getResourcesForSystem, getSortedSidebarEntries, getSystem, getSystemAncestors, listAllSystems, lookupContentType, parentOf, projectOrganizationSurfaces, requiresAdminFor, resolveOrganizationModel, topLevel };