@elevasis/ui 2.32.0 → 2.33.1

package/dist/{chunk-T35FWDAB.js → chunk-DYIDXUJS.js}

@@ -1,74 +1,469 @@
 import { z } from 'zod';
 
-// ../core/src/organization-model/domains/systems.ts
+// ../core/src/organization-model/ontology.ts
+var OntologyKindSchema = z.enum([
+  "object",
+  "link",
+  "action",
+  "catalog",
+  "event",
+  "interface",
+  "value-type",
+  "property",
+  "group",
+  "surface"
+]);
+var SYSTEM_PATH_PATTERN = "[a-z0-9][a-z0-9-]*(?:\\.[a-z0-9][a-z0-9-]*)*";
+var LOCAL_ID_PATTERN = "[a-z0-9][a-z0-9._-]*";
+var ONTOLOGY_ID_PATTERN = `^(global|${SYSTEM_PATH_PATTERN}):(${OntologyKindSchema.options.join("|")})\\/(${LOCAL_ID_PATTERN})$`;
+var ONTOLOGY_ID_REGEX = new RegExp(ONTOLOGY_ID_PATTERN);
+var OntologyIdSchema = z.string().trim().min(1).max(300).regex(
+  ONTOLOGY_ID_REGEX,
+  "Ontology IDs must use <system-path>:<kind>/<local-id> or global:<kind>/<local-id>"
+);
+function parseOntologyId(id) {
+  const normalized = OntologyIdSchema.parse(id);
+  const match = ONTOLOGY_ID_REGEX.exec(normalized);
+  if (match === null) {
+    throw new Error(`Invalid ontology ID "${id}"`);
+  }
+  return {
+    id: normalized,
+    scope: match[1],
+    kind: match[2],
+    localId: match[3],
+    isGlobal: match[1] === "global"
+  };
+}
+function formatOntologyId(input) {
+  return OntologyIdSchema.parse(`${input.scope}:${input.kind}/${input.localId}`);
+}
+var OntologyReferenceListSchema = z.array(OntologyIdSchema).default([]).optional();
+var OntologyRecordBaseSchema = z.object({
+  id: OntologyIdSchema,
+  label: z.string().trim().min(1).max(160).optional(),
+  description: z.string().trim().min(1).max(2e3).optional(),
+  ownerSystemId: z.string().trim().min(1).max(200).optional(),
+  aliases: z.array(OntologyIdSchema).optional()
+}).passthrough();
+var OntologyObjectTypeSchema = OntologyRecordBaseSchema.extend({
+  properties: z.record(z.string().trim().min(1).max(200), z.unknown()).optional(),
+  storage: z.record(z.string(), z.unknown()).optional()
+});
+var OntologyLinkTypeSchema = OntologyRecordBaseSchema.extend({
+  from: OntologyIdSchema,
+  to: OntologyIdSchema,
+  cardinality: z.string().trim().min(1).max(80).optional(),
+  via: z.string().trim().min(1).max(255).optional()
+});
+var OntologyActionTypeSchema = OntologyRecordBaseSchema.extend({
+  actsOn: OntologyReferenceListSchema,
+  input: z.record(z.string().trim().min(1).max(200), z.unknown()).optional(),
+  effects: z.array(z.record(z.string(), z.unknown())).optional()
+});
+var OntologyCatalogTypeSchema = OntologyRecordBaseSchema.extend({
+  kind: z.string().trim().min(1).max(120).optional(),
+  appliesTo: OntologyIdSchema.optional(),
+  entries: z.record(z.string().trim().min(1).max(200), z.unknown()).optional()
+});
+var OntologyEventTypeSchema = OntologyRecordBaseSchema.extend({
+  payload: z.record(z.string().trim().min(1).max(200), z.unknown()).optional()
+});
+var OntologyInterfaceTypeSchema = OntologyRecordBaseSchema.extend({
+  properties: z.record(z.string().trim().min(1).max(200), z.unknown()).optional()
+});
+var OntologyValueTypeSchema = OntologyRecordBaseSchema.extend({
+  primitive: z.string().trim().min(1).max(120).optional()
+});
+var OntologySharedPropertySchema = OntologyRecordBaseSchema.extend({
+  valueType: OntologyIdSchema.optional(),
+  searchable: z.boolean().optional(),
+  pii: z.boolean().optional()
+});
+var OntologyGroupSchema = OntologyRecordBaseSchema.extend({
+  members: OntologyReferenceListSchema
+});
+var OntologySurfaceTypeSchema = OntologyRecordBaseSchema.extend({
+  route: z.string().trim().min(1).max(500).optional()
+});
+var OntologyScopeSchema = z.object({
+  objectTypes: z.record(OntologyIdSchema, OntologyObjectTypeSchema).default({}).optional(),
+  linkTypes: z.record(OntologyIdSchema, OntologyLinkTypeSchema).default({}).optional(),
+  actionTypes: z.record(OntologyIdSchema, OntologyActionTypeSchema).default({}).optional(),
+  catalogTypes: z.record(OntologyIdSchema, OntologyCatalogTypeSchema).default({}).optional(),
+  eventTypes: z.record(OntologyIdSchema, OntologyEventTypeSchema).default({}).optional(),
+  interfaceTypes: z.record(OntologyIdSchema, OntologyInterfaceTypeSchema).default({}).optional(),
+  valueTypes: z.record(OntologyIdSchema, OntologyValueTypeSchema).default({}).optional(),
+  sharedProperties: z.record(OntologyIdSchema, OntologySharedPropertySchema).default({}).optional(),
+  groups: z.record(OntologyIdSchema, OntologyGroupSchema).default({}).optional(),
+  surfaces: z.record(OntologyIdSchema, OntologySurfaceTypeSchema).default({}).optional()
+}).default({});
+var DEFAULT_ONTOLOGY_SCOPE = {
+  valueTypes: {
+    "global:value-type/uuid": {
+      id: "global:value-type/uuid",
+      label: "UUID",
+      primitive: "string"
+    },
+    "global:value-type/text": {
+      id: "global:value-type/text",
+      label: "Text",
+      primitive: "string"
+    },
+    "global:value-type/url": {
+      id: "global:value-type/url",
+      label: "URL",
+      primitive: "string"
+    },
+    "global:value-type/email": {
+      id: "global:value-type/email",
+      label: "Email",
+      primitive: "string"
+    }
+  }
+};
+var SCOPE_KIND = {
+  objectTypes: "object",
+  linkTypes: "link",
+  actionTypes: "action",
+  catalogTypes: "catalog",
+  eventTypes: "event",
+  interfaceTypes: "interface",
+  valueTypes: "value-type",
+  sharedProperties: "property",
+  groups: "group",
+  surfaces: "surface"
+};
+var SCOPE_KEYS = Object.keys(SCOPE_KIND);
+function ontologyGraphNodeId(id) {
+  return `ontology:${OntologyIdSchema.parse(id)}`;
+}
+function listResolvedOntologyRecords(index) {
+  return SCOPE_KEYS.flatMap((scopeKey) => {
+    const kind = SCOPE_KIND[scopeKey];
+    return Object.entries(index[scopeKey]).sort(([leftId], [rightId]) => leftId.localeCompare(rightId)).map(([id, record]) => ({
+      id,
+      kind,
+      record
+    }));
+  });
+}
+function originFromContext(context) {
+  return {
+    kind: context.kind,
+    source: context.source,
+    path: context.path,
+    ...context.systemPath !== void 0 ? { systemPath: context.systemPath } : {},
+    ...context.legacyId !== void 0 ? { legacyId: context.legacyId } : {}
+  };
+}
+function createEmptyIndex() {
+  return {
+    objectTypes: {},
+    linkTypes: {},
+    actionTypes: {},
+    catalogTypes: {},
+    eventTypes: {},
+    interfaceTypes: {},
+    valueTypes: {},
+    sharedProperties: {},
+    groups: {},
+    surfaces: {}
+  };
+}
+function sortResolvedOntologyIndex(index) {
+  const sorted = createEmptyIndex();
+  for (const scopeKey of SCOPE_KEYS) {
+    const target = sorted[scopeKey];
+    for (const [id, record] of Object.entries(index[scopeKey]).sort(
+      ([leftId], [rightId]) => leftId.localeCompare(rightId)
+    )) {
+      target[id] = record;
+    }
+  }
+  return sorted;
+}
+function childSystemsOf(system) {
+  return system.systems ?? system.subsystems ?? {};
+}
+function addRecord(index, diagnostics, sourcesById, scopeKey, record, context) {
+  let parsed;
+  try {
+    parsed = parseOntologyId(record.id);
+  } catch {
+    diagnostics.push({
+      code: "invalid_ontology_id",
+      message: `Invalid ontology ID "${record.id}" from ${context.source} at ${context.path.join(".")}`,
+      id: record.id,
+      path: context.path,
+      source: context.source,
+      origin: originFromContext(context)
+    });
+    return;
+  }
+  const expectedKind = SCOPE_KIND[scopeKey];
+  if (parsed.kind !== expectedKind) {
+    diagnostics.push({
+      code: "ontology_kind_mismatch",
+      message: `Ontology ID "${record.id}" has kind "${parsed.kind}" but was authored in ${scopeKey} (${expectedKind}) at ${context.path.join(".")}`,
+      id: record.id,
+      path: context.path,
+      source: context.source,
+      origin: originFromContext(context)
+    });
+    return;
+  }
+  const existing = sourcesById.get(parsed.id);
+  if (existing !== void 0) {
+    diagnostics.push({
+      code: "duplicate_ontology_id",
+      message: `Duplicate ontology ID "${parsed.id}" from ${context.source} at ${context.path.join(".")} conflicts with ${existing.source} at ${existing.path.join(".")}`,
+      id: parsed.id,
+      path: context.path,
+      source: context.source,
+      origin: originFromContext(context),
+      existingSource: existing.source,
+      existingOrigin: originFromContext(existing)
+    });
+    return;
+  }
+  sourcesById.set(parsed.id, context);
+  index[scopeKey][parsed.id] = {
+    ...record,
+    origin: originFromContext(context)
+  };
+}
+function addScope(index, diagnostics, sourcesById, scope, source, path) {
+  if (scope === void 0) return;
+  for (const scopeKey of SCOPE_KEYS) {
+    const records = scope[scopeKey] ?? {};
+    for (const [key, record] of Object.entries(records)) {
+      addRecord(index, diagnostics, sourcesById, scopeKey, record, {
+        source,
+        path: [...path, scopeKey, key],
+        kind: "authored",
+        systemPath: source.startsWith("system:") ? source.slice("system:".length, -".ontology".length) : void 0
+      });
+    }
+  }
+}
+function legacyObjectId(entity) {
+  return formatOntologyId({ scope: entity.ownedBySystemId, kind: "object", localId: entity.id });
+}
+function legacyActionOwner(action, entities) {
+  const firstAffectedEntityId = action.affects?.find((entityId) => entities[entityId] !== void 0);
+  if (firstAffectedEntityId !== void 0) {
+    return entities[firstAffectedEntityId].ownedBySystemId;
+  }
+  if (typeof action.scope === "object") {
+    return action.scope.domain;
+  }
+  return "global";
+}
+function addLegacyEntityProjections(index, diagnostics, sourcesById, entities) {
+  for (const entity of Object.values(entities)) {
+    const objectType = {
+      id: legacyObjectId(entity),
+      label: entity.label,
+      description: entity.description,
+      ownerSystemId: entity.ownedBySystemId,
+      ...entity.table !== void 0 ? {
+        storage: {
+          kind: "table",
+          table: entity.table
+        }
+      } : {},
+      ...entity.rowSchema !== void 0 ? { rowSchema: entity.rowSchema } : {},
+      ...entity.stateCatalogId !== void 0 ? { stateCatalogId: entity.stateCatalogId } : {}
+    };
+    addRecord(index, diagnostics, sourcesById, "objectTypes", objectType, {
+      source: "legacy.entities",
+      path: ["entities", entity.id],
+      kind: "projected",
+      systemPath: entity.ownedBySystemId,
+      legacyId: entity.id
+    });
+    entity.links?.forEach((link, linkIndex) => {
+      const targetEntity = entities[link.toEntity];
+      if (targetEntity === void 0) return;
+      const linkType = {
+        id: formatOntologyId({
+          scope: entity.ownedBySystemId,
+          kind: "link",
+          localId: `${entity.id}-${link.toEntity}-${linkIndex}`
+        }),
+        label: link.label ?? link.kind,
+        ownerSystemId: entity.ownedBySystemId,
+        from: legacyObjectId(entity),
+        to: legacyObjectId(targetEntity),
+        cardinality: link.kind,
+        ...link.via !== void 0 ? { via: link.via } : {}
+      };
+      addRecord(index, diagnostics, sourcesById, "linkTypes", linkType, {
+        source: "legacy.entities.links",
+        path: ["entities", entity.id, "links", linkIndex],
+        kind: "projected",
+        systemPath: entity.ownedBySystemId,
+        legacyId: `${entity.id}.links.${linkIndex}`
+      });
+    });
+  }
+}
+function addLegacyActionProjections(index, diagnostics, sourcesById, actions, entities) {
+  for (const action of Object.values(actions)) {
+    const ownerSystemId = legacyActionOwner(action, entities);
+    const actionType = {
+      id: formatOntologyId({ scope: ownerSystemId, kind: "action", localId: action.id }),
+      label: action.label,
+      description: action.description,
+      ownerSystemId,
+      actsOn: action.affects?.map((entityId) => entities[entityId] ? legacyObjectId(entities[entityId]) : void 0).filter((id) => id !== void 0),
+      ...action.resourceId !== void 0 ? { resourceId: action.resourceId } : {},
+      ...action.invocations !== void 0 ? { invocations: action.invocations } : {},
+      ...action.lifecycle !== void 0 ? { lifecycle: action.lifecycle } : {},
+      legacyActionId: action.id
+    };
+    addRecord(index, diagnostics, sourcesById, "actionTypes", actionType, {
+      source: "legacy.actions",
+      path: ["actions", action.id],
+      kind: "projected",
+      systemPath: ownerSystemId,
+      legacyId: action.id
+    });
+  }
+}
+function addSystemContentProjections(index, diagnostics, sourcesById, systemPath, system, schemaPath) {
+  const content = system.content ?? {};
+  for (const [localId, node] of Object.entries(content)) {
+    if (node.kind !== "schema") continue;
+    const entries = Object.fromEntries(
+      Object.entries(content).filter(([, candidate]) => candidate.parentContentId === localId).map(([entryId, candidate]) => [
+        entryId,
+        {
+          label: candidate.label ?? entryId,
+          type: candidate.type,
+          ...candidate.description !== void 0 ? { description: candidate.description } : {},
+          ...candidate.data !== void 0 ? candidate.data : {}
+        }
+      ])
+    );
+    const catalogType = {
+      id: formatOntologyId({ scope: systemPath, kind: "catalog", localId }),
+      label: node.label ?? localId,
+      description: node.description,
+      ownerSystemId: systemPath,
+      kind: node.type,
+      ...typeof node.data?.["entityId"] === "string" ? { appliesTo: formatOntologyId({ scope: systemPath, kind: "object", localId: node.data["entityId"] }) } : {},
+      ...Object.keys(entries).length > 0 ? { entries } : {},
+      ...node.data !== void 0 ? { data: node.data } : {}
+    };
+    addRecord(index, diagnostics, sourcesById, "catalogTypes", catalogType, {
+      source: "legacy.system.content",
+      path: [...schemaPath, "content", localId],
+      kind: "projected",
+      systemPath,
+      legacyId: `${systemPath}:${localId}`
+    });
+  }
+}
+function addSystemScopes(index, diagnostics, sourcesById, systems, prefix, schemaPath) {
+  for (const [key, system] of Object.entries(systems)) {
+    const systemPath = prefix ? `${prefix}.${key}` : key;
+    const currentPath = [...schemaPath, key];
+    addScope(index, diagnostics, sourcesById, system.ontology, `system:${systemPath}.ontology`, [
+      ...currentPath,
+      "ontology"
+    ]);
+    addSystemContentProjections(index, diagnostics, sourcesById, systemPath, system, currentPath);
+    addSystemScopes(index, diagnostics, sourcesById, childSystemsOf(system), systemPath, [
+      ...currentPath,
+      system.systems !== void 0 ? "systems" : "subsystems"
+    ]);
+  }
+}
+function compileOrganizationOntology(model) {
+  const ontology = createEmptyIndex();
+  const diagnostics = [];
+  const sourcesById = /* @__PURE__ */ new Map();
+  addScope(ontology, diagnostics, sourcesById, model.ontology, "organization.ontology", ["ontology"]);
+  addSystemScopes(ontology, diagnostics, sourcesById, model.systems ?? {}, "", ["systems"]);
+  addLegacyEntityProjections(ontology, diagnostics, sourcesById, model.entities ?? {});
+  addLegacyActionProjections(ontology, diagnostics, sourcesById, model.actions ?? {}, model.entities ?? {});
+  return { ontology: sortResolvedOntologyIndex(ontology), diagnostics };
+}
 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"
+  // Navigation / app areas
+  "dashboard",
+  "calendar",
+  "sales",
+  "crm",
+  "lead-gen",
+  "projects",
+  "operations",
+  "monitoring",
+  "knowledge",
+  "settings",
+  "admin",
+  "archive",
+  "business",
+  "finance",
+  "platform",
+  "seo",
+  // Knowledge kinds
+  "playbook",
+  "strategy",
+  "reference",
+  // Resource kinds
+  "agent",
+  "workflow",
+  "integration",
+  "database",
+  "user",
+  "team",
+  // Integration specifics
+  "gmail",
+  "google-sheets",
+  "attio",
+  // Surface / UI views
+  "overview",
+  "command-view",
+  "command-queue",
+  "pipeline",
+  "lists",
+  "resources",
+  // Actions
+  "approve",
+  "reject",
+  "retry",
+  "edit",
+  "view",
+  "launch",
+  "message",
+  "escalate",
+  "promote",
+  "submit",
+  "email",
+  // Status
+  "success",
+  "error",
+  "warning",
+  "info",
+  "pending",
+  // OM / UI group icons
+  "bolt",
+  "building",
+  "briefcase",
+  "apps",
+  "graph",
+  "shield",
+  "users",
+  "chart-bar",
+  "search"
 ];
-var CustomIconTokenSchema = z.string().trim().max(80).regex(/^custom\.[a-z0-9]+(?:[-._][a-z0-9]+)*$/, "Custom icon tokens must start with custom.");
+var CustomIconTokenSchema = z.string().trim().max(80).regex(
+  /^custom\.[a-z0-9]+(?:[-._][a-z0-9]+)*$/,
+  'Custom icon tokens must start with "custom." followed by lowercase alphanumeric segments'
+);
 var OrganizationModelBuiltinIconTokenSchema = z.enum(ORGANIZATION_MODEL_ICON_TOKENS);
 var OrganizationModelIconTokenSchema = z.union([
   OrganizationModelBuiltinIconTokenSchema,
@@ -430,7 +825,99 @@ var LEAD_GEN_ACTION_ENTRIES = Object.fromEntries(
     return [parsed.id, parsed];
   })
 );
-var DEFAULT_ORGANIZATION_MODEL_ACTIONS = LEAD_GEN_ACTION_ENTRIES;
+var CRM_ACTION_ENTRY_INPUTS = [
+  {
+    id: "send_reply",
+    order: 210,
+    label: "Send Reply",
+    description: "Send a contextual reply for an active CRM deal.",
+    scope: { domain: "sales" },
+    resourceId: "crm-send-reply-workflow",
+    affects: ["crm.deal"]
+  },
+  {
+    id: "send_link",
+    order: 220,
+    label: "Send Booking Link",
+    description: "Send a booking link to move a deal toward a scheduled call.",
+    scope: { domain: "sales" },
+    resourceId: "crm-send-booking-link-workflow",
+    affects: ["crm.deal"]
+  },
+  {
+    id: "send_nudge",
+    order: 230,
+    label: "Send Nudge",
+    description: "Send a follow-up nudge for a stalled CRM deal.",
+    scope: { domain: "sales" },
+    resourceId: "crm-send-nudge-workflow",
+    affects: ["crm.deal"]
+  },
+  {
+    id: "rebook",
+    order: 240,
+    label: "Rebook",
+    description: "Rebook a missed or rescheduled CRM appointment.",
+    scope: { domain: "sales" },
+    resourceId: "crm-rebook-workflow",
+    affects: ["crm.deal"]
+  },
+  {
+    id: "move_to_proposal",
+    order: 250,
+    label: "Move to Proposal",
+    description: "Advance a qualified CRM deal into the proposal stage.",
+    scope: { domain: "sales" },
+    resourceId: "move_to_proposal-workflow",
+    affects: ["crm.deal"]
+  },
+  {
+    id: "move_to_closing",
+    order: 260,
+    label: "Move to Closing",
+    description: "Advance a proposal-stage CRM deal into closing.",
+    scope: { domain: "sales" },
+    resourceId: "move_to_closing-workflow",
+    affects: ["crm.deal"]
+  },
+  {
+    id: "move_to_closed_won",
+    order: 270,
+    label: "Close Won",
+    description: "Mark a CRM deal as closed won.",
+    scope: { domain: "sales" },
+    resourceId: "move_to_closed_won-workflow",
+    affects: ["crm.deal"]
+  },
+  {
+    id: "move_to_closed_lost",
+    order: 280,
+    label: "Close Lost",
+    description: "Mark a CRM deal as closed lost.",
+    scope: { domain: "sales" },
+    resourceId: "move_to_closed_lost-workflow",
+    affects: ["crm.deal"]
+  },
+  {
+    id: "move_to_nurturing",
+    order: 290,
+    label: "Move to Nurturing",
+    description: "Move a CRM deal into nurturing for future follow-up.",
+    scope: { domain: "sales" },
+    resourceId: "move_to_nurturing-workflow",
+    affects: ["crm.deal"]
+  }
+];
+var CRM_ACTION_ENTRIES = Object.fromEntries(
+  CRM_ACTION_ENTRY_INPUTS.map((action) => {
+    const parsed = ActionSchema.parse(action);
+    return [parsed.id, parsed];
+  })
+);
+var DEFAULT_ORGANIZATION_MODEL_ACTIONS = {
+  ...LEAD_GEN_ACTION_ENTRIES,
+  ...CRM_ACTION_ENTRIES
+};
 var ContentNodeBaseSchema = z.object({
   /** Human-readable label for the content node. */
   label: z.string().trim().min(1).max(120).meta({ label: "Label" }),
@@ -491,6 +978,17 @@ var SystemUiSchema = z.object({
   icon: IconNameSchema.optional(),
   order: z.number().int().optional()
 });
+var JsonValueSchema = z.lazy(
+  () => z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+    z.array(JsonValueSchema),
+    z.record(z.string(), JsonValueSchema)
+  ])
+);
+var SystemConfigSchema = z.record(z.string().trim().min(1).max(200), JsonValueSchema).default({}).optional();
 var SystemEntrySchema = z.object({
   /** Stable tenant-defined system id (e.g. "sys.lead-gen" or "sales.crm"). */
   id: SystemIdSchema,
@@ -536,11 +1034,21 @@ var SystemEntrySchema = z.object({
   /** 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.
+   * System-local JSON settings and defaults. Strongly typed OM fields,
+   * secrets, credentials, and runtime state stay outside this bucket.
+   */
+  config: SystemConfigSchema,
+  /**
+   * System-owned ontology declarations. `systems` is now the canonical child
+   * key; this scope holds the object, action, catalog, link, event, and
+   * shared contract records owned by this system.
+   */
+  ontology: OntologyScopeSchema.optional(),
+  /**
+   * @deprecated Compatibility-only bridge for old tenant content nodes and
+   * migration readers. New schema/catalog authoring belongs in ontology;
+   * new system-local settings belong in config. Bridge nodes are keyed by
+   * local NodeId and may still project to content-node:* graph IDs.
    */
   content: z.record(z.string().trim().min(1).max(200), ContentNodeSchema).optional(),
   /**
@@ -550,14 +1058,17 @@ var SystemEntrySchema = z.object({
    * Per Phase 4: `id` and `parentSystemId` fields will be removed in favour of
    * position-derived paths. Both still exist on this schema for backward compat.
    */
+  systems: z.lazy(() => z.record(z.string().trim().min(1).max(100), SystemEntrySchema)).optional(),
+  /** @deprecated Use systems. Accepted as a compatibility alias during the ontology bridge. */
   subsystems: z.lazy(() => z.record(z.string().trim().min(1).max(100), SystemEntrySchema)).optional()
 }).refine((system) => system.label !== void 0 || system.title !== void 0, {
   path: ["label"],
   message: "System must provide label or title"
 }).transform((system) => {
-  if (system.status === void 0) return system;
+  const normalizedSystem = system.systems !== void 0 && system.subsystems === void 0 ? { ...system, subsystems: system.systems } : system;
+  if (normalizedSystem.status === void 0) return normalizedSystem;
   console.warn("[organization-model] System.status is deprecated; use System.lifecycle instead.");
-  return system.lifecycle === void 0 ? { ...system, lifecycle: system.status } : system;
+  return normalizedSystem.lifecycle === void 0 ? { ...normalizedSystem, lifecycle: normalizedSystem.status } : normalizedSystem;
 });
 var SystemsDomainSchema = z.record(z.string(), SystemEntrySchema).refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
   message: "Each system entry id must match its map key"
@@ -633,6 +1144,7 @@ z.enum(["workflow", "agent", "integration", "script"]).meta({ label: "Resource k
 var ResourceGovernanceStatusSchema = z.enum(["active", "deprecated", "archived"]).meta({ label: "Governance status", color: "teal" });
 var AgentKindSchema = z.enum(["orchestrator", "specialist", "utility", "platform"]).meta({ label: "Agent kind", color: "violet" });
 var ScriptResourceLanguageSchema = z.enum(["shell", "sql", "typescript", "python"]).meta({ label: "Language" });
+var CodeReferenceRoleSchema = z.enum(["entrypoint", "handler", "schema", "test", "docs", "config"]).meta({ label: "Code reference role", color: "blue" });
 var ResourceIdSchema = z.string().trim().min(1).max(255).regex(/^[A-Za-z0-9]+(?:[-._][A-Za-z0-9]+)*$/, "Resource IDs must use letters, numbers, -, _, or . separators");
 var EventIdSchema = z.string().trim().min(1).max(300).regex(
   /^[A-Za-z0-9]+(?:[-._][A-Za-z0-9]+)*:[a-z0-9]+(?:[-._][a-z0-9]+)*$/,
@@ -650,6 +1162,28 @@ EventEmissionDescriptorSchema.extend({
   ownerId: z.union([ResourceIdSchema, ModelIdSchema]),
   ownerKind: z.enum(["resource", "entity"]).meta({ label: "Owner kind" })
 });
+var ResourceOntologyBindingSchema = z.object({
+  actions: z.array(OntologyIdSchema).optional(),
+  primaryAction: OntologyIdSchema.optional(),
+  reads: z.array(OntologyIdSchema).optional(),
+  writes: z.array(OntologyIdSchema).optional(),
+  usesCatalogs: z.array(OntologyIdSchema).optional(),
+  emits: z.array(OntologyIdSchema).optional()
+}).superRefine((binding, ctx) => {
+  if (binding.primaryAction === void 0) return;
+  if (binding.actions?.includes(binding.primaryAction)) return;
+  ctx.addIssue({
+    code: z.ZodIssueCode.custom,
+    path: ["primaryAction"],
+    message: "Resource ontology primaryAction must be included in actions"
+  });
+});
+var CodeReferenceSchema = z.object({
+  path: z.string().trim().min(1).max(500).regex(/^[A-Za-z0-9_./$@()[\] -]+$/, "Code reference paths must be repo-relative paths"),
+  role: CodeReferenceRoleSchema,
+  symbol: z.string().trim().min(1).max(200).optional(),
+  description: z.string().trim().min(1).max(300).optional()
+});
 var ResourceEntryBaseSchema = z.object({
   /** Canonical resource id; runtime resourceId derives from this value. */
   id: ResourceIdSchema,
@@ -657,14 +1191,24 @@ var ResourceEntryBaseSchema = z.object({
   order: z.number().default(0),
   /** Required single System membership — value is a dot-separated system path (e.g. "sales.lead-gen"). */
   systemPath: SystemPathSchema.meta({ ref: "system" }),
+  /** Executable display title owned by the OM Resource descriptor. */
+  title: LabelSchema.optional(),
+  /** Executable display description owned by the OM Resource descriptor. */
+  description: DescriptionSchema.optional(),
   /** Optional role responsible for maintaining this resource. */
   ownerRoleId: ModelIdSchema.meta({ ref: "role" }).optional(),
-  status: ResourceGovernanceStatusSchema
+  status: ResourceGovernanceStatusSchema,
+  /**
+   * Ontology contract bindings for the semantic work this resource performs.
+   * `emits` stays nested here so top-level resource emits descriptors remain
+   * compatible with graph event projection during the bridge.
+   */
+  ontology: ResourceOntologyBindingSchema.optional(),
+  /** Repo-relative implementation breadcrumbs for agents and operators. */
+  codeRefs: z.array(CodeReferenceSchema).default([])
 });
 var WorkflowResourceEntrySchema = ResourceEntryBaseSchema.extend({
   kind: z.literal("workflow"),
-  /** 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({
@@ -706,6 +1250,9 @@ var ResourcesDomainSchema = z.record(z.string(), ResourceEntrySchema).refine((re
 var DEFAULT_ORGANIZATION_MODEL_RESOURCES = {};
 
 // ../core/src/organization-model/helpers.ts
+function childSystemsOf2(system) {
+  return system.systems ?? system.subsystems ?? {};
+}
 function defaultPathFor(id) {
   return `/${id.replaceAll(".", "/")}`;
 }
@@ -753,7 +1300,7 @@ function getSystem(model, path) {
   for (const seg of segments) {
     node = current[seg];
     if (node === void 0) return void 0;
-    current = node.subsystems ?? {};
+    current = childSystemsOf2(node);
   }
   return node;
 }
@@ -765,7 +1312,7 @@ function getSystemAncestors(model, path) {
     const node = current[seg];
     if (node === void 0) return [];
     result.push(node);
-    current = node.subsystems ?? {};
+    current = childSystemsOf2(node);
   }
   return result;
 }
@@ -775,8 +1322,9 @@ function listAllSystems(model) {
     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);
+      const childSystems = childSystemsOf2(system);
+      if (Object.keys(childSystems).length > 0) {
+        walk(childSystems, fullPath);
       }
     }
   }
@@ -792,6 +1340,30 @@ function getContent(model, qualifiedId) {
   const system = getSystem(model, systemPath);
   return system?.content?.[localId];
 }
+function isPlainJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeJsonConfig(base, override) {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    const existing = result[key];
+    result[key] = isPlainJsonObject(existing) && isPlainJsonObject(value) ? mergeJsonConfig(existing, value) : value;
+  }
+  return result;
+}
+function resolveSystemConfig(model, path) {
+  const system = getSystem(model, path);
+  if (system === void 0) return {};
+  let resolved = {};
+  for (const node of Object.values(system.content ?? {})) {
+    if (node.kind !== "config" || node.type !== "kv") continue;
+    const entries = node.data?.entries;
+    if (isPlainJsonObject(entries)) {
+      resolved = mergeJsonConfig(resolved, entries);
+    }
+  }
+  return mergeJsonConfig(resolved, system.config ?? {});
+}
 function getResourcesForSystem(model, systemPath, options = {}) {
   const { includeDescendants = false } = options;
   const prefix = systemPath + ".";
@@ -1843,19 +2415,29 @@ var KnowledgeTargetKindSchema = z.enum([
   "goal",
   "customer-segment",
   "offering",
+  "ontology",
   // D4: content nodes are a valid knowledge target after compound-domain data moved into system.content
   "content-node"
 ]).meta({ label: "Target kind" });
 var KnowledgeTargetRefSchema = z.object({
   kind: KnowledgeTargetKindSchema,
-  // D4: content-node targets use a qualified id format '<system-path>:<local-content-id>'
-  // 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).
+  // D4: content-node targets use a qualified id format '<system-path>:<local-content-id>'.
+  // Ontology targets use the canonical '<scope>:<kind>/<local-id>' ontology id format.
+  // Business-logic validation of target existence is done in OrganizationModelSchema.superRefine.
   id: z.string().trim().min(1).max(300)
+}).superRefine((target, ctx) => {
+  if (target.kind !== "ontology") return;
+  const result = OntologyIdSchema.safeParse(target.id);
+  if (!result.success) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["id"],
+      message: "Ontology knowledge targets must use <system-path>:<kind>/<local-id> or global:<kind>/<local-id>"
+    });
+  }
 });
 var LegacyKnowledgeLinkSchema = z.object({
-  nodeId: NodeIdStringSchema
+  nodeId: z.union([NodeIdStringSchema, z.templateLiteral(["ontology:", OntologyIdSchema])])
 });
 var CanonicalKnowledgeLinkSchema = z.object({
   target: KnowledgeTargetRefSchema
@@ -1886,6 +2468,8 @@ var OrgKnowledgeNodeSchema = z.object({
   icon: IconNameSchema.optional(),
   /** Canonical documentation URL when body content is a local summary. */
   externalUrl: z.string().trim().url().max(500).optional(),
+  /** Optional generated source file path for local MDX-backed knowledge nodes. */
+  sourceFilePath: z.string().trim().min(1).max(500).optional(),
   /** Raw MDX string. Phase 2 will introduce a structured block format. */
   body: z.string().trim().min(1),
   /**
@@ -1899,6 +2483,73 @@ var OrgKnowledgeNodeSchema = z.object({
   updatedAt: z.string().trim().min(1).max(50)
 });
 var KnowledgeDomainSchema = z.record(ModelIdSchema, OrgKnowledgeNodeSchema).default({});
+var SecretLikeMetadataKeySchema = /(?:secret|password|passwd|token|api[-_]?key|credential|private[-_]?key)/i;
+var SecretLikeMetadataValueSchema = /(?:sk-[A-Za-z0-9_-]{12,}|pk_live_[A-Za-z0-9_-]{12,}|eyJ[A-Za-z0-9_-]{20,}|-----BEGIN (?:RSA |OPENSSH |EC )?PRIVATE KEY-----)/;
+z.enum([
+  "system",
+  "resource",
+  "ontology",
+  "policy",
+  "role",
+  "trigger",
+  "humanCheckpoint",
+  "externalResource"
+]);
+var OmTopologyRelationshipKindSchema = z.enum(["triggers", "uses", "approval"]);
+var OmTopologyNodeRefSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("system"), id: ModelIdSchema }),
+  z.object({ kind: z.literal("resource"), id: ResourceIdSchema }),
+  z.object({ kind: z.literal("ontology"), id: OntologyIdSchema }),
+  z.object({ kind: z.literal("policy"), id: ModelIdSchema }),
+  z.object({ kind: z.literal("role"), id: ModelIdSchema }),
+  z.object({ kind: z.literal("trigger"), id: ResourceIdSchema }),
+  z.object({ kind: z.literal("humanCheckpoint"), id: ResourceIdSchema }),
+  z.object({ kind: z.literal("externalResource"), id: ResourceIdSchema })
+]);
+var OmTopologyMetadataSchema = z.record(z.string().trim().min(1).max(120), JsonValueSchema).superRefine((metadata, ctx) => {
+  function visit(value, path) {
+    if (typeof value === "string" && SecretLikeMetadataValueSchema.test(value)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path,
+        message: "Topology metadata must not contain secret-like values"
+      });
+      return;
+    }
+    if (Array.isArray(value)) {
+      value.forEach((entry, index) => visit(entry, [...path, index]));
+      return;
+    }
+    if (typeof value !== "object" || value === null) return;
+    Object.entries(value).forEach(([key, entry]) => {
+      if (SecretLikeMetadataKeySchema.test(key)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: [...path, key],
+          message: `Topology metadata key "${key}" looks secret-like`
+        });
+      }
+      visit(entry, [...path, key]);
+    });
+  }
+  visit(metadata, []);
+});
+var OmTopologyRelationshipSchema = z.object({
+  from: OmTopologyNodeRefSchema,
+  kind: OmTopologyRelationshipKindSchema,
+  to: OmTopologyNodeRefSchema,
+  systemPath: SystemPathSchema.optional(),
+  required: z.boolean().optional(),
+  metadata: OmTopologyMetadataSchema.optional()
+});
+var OmTopologyDomainSchema = z.object({
+  version: z.literal(1).default(1),
+  relationships: z.record(z.string().trim().min(1).max(255), OmTopologyRelationshipSchema).default({})
+}).default({ version: 1, relationships: {} });
+var DEFAULT_ORGANIZATION_MODEL_TOPOLOGY = {
+  version: 1,
+  relationships: {}
+};
 var PolicyIdSchema = ModelIdSchema;
 var PolicyApplicabilitySchema = z.object({
   systemIds: z.array(ModelIdSchema.meta({ ref: "system" })).default([]),
@@ -1986,7 +2637,9 @@ z.enum([
   "roles",
   "goals",
   "systems",
+  "ontology",
   "resources",
+  "topology",
   "actions",
   "entities",
   "policies",
@@ -2004,7 +2657,9 @@ var DEFAULT_ORGANIZATION_MODEL_DOMAIN_METADATA = {
   roles: { version: 1, lastModified: "2026-05-10" },
   goals: { version: 1, lastModified: "2026-05-10" },
   systems: { version: 1, lastModified: "2026-05-10" },
+  ontology: { version: 1, lastModified: "2026-05-14" },
   resources: { version: 1, lastModified: "2026-05-10" },
+  topology: { version: 1, lastModified: "2026-05-14" },
   actions: { version: 1, lastModified: "2026-05-10" },
   entities: { version: 1, lastModified: "2026-05-10" },
   policies: { version: 1, lastModified: "2026-05-10" },
@@ -2018,7 +2673,9 @@ var OrganizationModelDomainMetadataByDomainSchema = z.object({
   roles: OrganizationModelDomainMetadataSchema,
   goals: OrganizationModelDomainMetadataSchema,
   systems: OrganizationModelDomainMetadataSchema,
+  ontology: OrganizationModelDomainMetadataSchema,
   resources: OrganizationModelDomainMetadataSchema,
+  topology: OrganizationModelDomainMetadataSchema,
   actions: OrganizationModelDomainMetadataSchema,
   entities: OrganizationModelDomainMetadataSchema,
   policies: OrganizationModelDomainMetadataSchema,
@@ -2035,7 +2692,9 @@ var OrganizationModelSchemaBase = z.object({
   roles: RolesDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_ROLES),
   goals: GoalsDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_GOALS),
   systems: SystemsDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_SYSTEMS),
+  ontology: OntologyScopeSchema.default(DEFAULT_ONTOLOGY_SCOPE),
   resources: ResourcesDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_RESOURCES),
+  topology: OmTopologyDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_TOPOLOGY),
   actions: ActionsDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_ACTIONS),
   entities: EntitiesDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_ENTITIES),
   policies: PoliciesDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_POLICIES),
@@ -2062,13 +2721,16 @@ function asRoleHolderArray(heldBy) {
 function isKnowledgeKindCompatibleWithTarget(knowledgeKind, targetKind) {
   if (knowledgeKind === "reference") return true;
   if (knowledgeKind === "playbook") {
-    return ["system", "resource", "stage", "action"].includes(targetKind);
+    return ["system", "resource", "stage", "action", "ontology"].includes(targetKind);
   }
   if (knowledgeKind === "strategy") {
-    return ["system", "goal", "offering", "customer-segment"].includes(targetKind);
+    return ["system", "goal", "offering", "customer-segment", "ontology"].includes(targetKind);
   }
   return false;
 }
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 var OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((model, ctx) => {
   function collectAllSystems(systems, prefix = "", schemaPath = ["systems"]) {
     const result = [];
@@ -2076,8 +2738,11 @@ var OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((model, ct
       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"]));
+      const childSystems = system.systems ?? system.subsystems;
+      if (childSystems !== void 0) {
+        result.push(
+          ...collectAllSystems(childSystems, path, [...currentSchemaPath, system.systems !== void 0 ? "systems" : "subsystems"])
+        );
       }
     }
     return result;
@@ -2097,7 +2762,7 @@ var OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((model, ct
         `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 hasChildren = Object.keys(system.systems ?? system.subsystems ?? {}).length > 0 || allSystems.some((candidate) => candidate.path.startsWith(`${path}.`) && !candidate.path.slice(path.length + 1).includes("."));
     const contributesRoutePath = system.ui?.path !== void 0 || system.path !== void 0 || !hasChildren;
     if (contributesRoutePath) {
       const effectivePath = system.ui?.path ?? system.path ?? defaultSystemPathFor(path);
@@ -2113,7 +2778,7 @@ var OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((model, ct
       }
     }
     if (hasChildren && isLifecycleEnabled(system.lifecycle, system.enabled)) {
-      const hasEnabledDescendant = Object.values(system.subsystems ?? {}).some(
+      const hasEnabledDescendant = Object.values(system.systems ?? system.subsystems ?? {}).some(
         (candidate) => isLifecycleEnabled(candidate.lifecycle, candidate.enabled)
       ) || allSystems.some(
         (candidate) => candidate.path.startsWith(`${path}.`) && !candidate.path.slice(path.length + 1).includes(".") && isLifecycleEnabled(candidate.system.lifecycle, candidate.system.enabled)
@@ -2358,6 +3023,79 @@ var OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((model, ct
   const stageIds = /* @__PURE__ */ new Set();
   const actionIds = new Set(Object.keys(model.actions));
   const offeringsById = new Map(Object.entries(model.offerings));
+  const ontologyCompilation = compileOrganizationOntology(model);
+  const ontologyIndexByKind = {
+    object: ontologyCompilation.ontology.objectTypes,
+    link: ontologyCompilation.ontology.linkTypes,
+    action: ontologyCompilation.ontology.actionTypes,
+    catalog: ontologyCompilation.ontology.catalogTypes,
+    event: ontologyCompilation.ontology.eventTypes,
+    interface: ontologyCompilation.ontology.interfaceTypes,
+    "value-type": ontologyCompilation.ontology.valueTypes,
+    property: ontologyCompilation.ontology.sharedProperties,
+    group: ontologyCompilation.ontology.groups,
+    surface: ontologyCompilation.ontology.surfaces
+  };
+  const ontologyIds = new Set(Object.values(ontologyIndexByKind).flatMap((index) => Object.keys(index)));
+  function topologyTargetExists(ref) {
+    if (ref.kind === "system") return systemsById.has(ref.id);
+    if (ref.kind === "resource") return resourcesById.has(ref.id);
+    if (ref.kind === "ontology") return ontologyIds.has(ref.id);
+    if (ref.kind === "policy") return policiesById.has(ref.id);
+    if (ref.kind === "role") return rolesById.has(ref.id);
+    return true;
+  }
+  Object.entries(model.topology.relationships).forEach(([relationshipId, relationship]) => {
+    ["from", "to"].forEach((side) => {
+      const ref = relationship[side];
+      if (topologyTargetExists(ref)) return;
+      addIssue(
+        ctx,
+        ["topology", "relationships", relationshipId, side],
+        `Topology relationship "${relationshipId}" ${side} references unknown ${ref.kind} "${ref.id}"`
+      );
+    });
+  });
+  const ontologyReferenceKeyKinds = {
+    valueType: "value-type",
+    catalogType: "catalog",
+    objectType: "object",
+    eventType: "event",
+    actionType: "action",
+    linkType: "link",
+    interfaceType: "interface",
+    propertyType: "property",
+    groupType: "group",
+    surfaceType: "surface",
+    stepCatalog: "catalog"
+  };
+  function validateKnownOntologyReferences(ownerId, value, path, seen = /* @__PURE__ */ new WeakSet()) {
+    if (Array.isArray(value)) {
+      value.forEach((entry, index) => validateKnownOntologyReferences(ownerId, entry, [...path, index], seen));
+      return;
+    }
+    if (!isRecord(value)) return;
+    if (seen.has(value)) return;
+    seen.add(value);
+    Object.entries(value).forEach(([key, entry]) => {
+      const expectedKind = ontologyReferenceKeyKinds[key];
+      if (expectedKind !== void 0) {
+        if (typeof entry !== "string") {
+          addIssue(ctx, [...path, key], `Ontology record "${ownerId}" ${key} must be an ontology ID string`);
+        } else if (ontologyIndexByKind[expectedKind][entry] === void 0) {
+          addIssue(
+            ctx,
+            [...path, key],
+            `Ontology record "${ownerId}" ${key} references unknown ${expectedKind} ontology ID "${entry}"`
+          );
+        }
+      }
+      validateKnownOntologyReferences(ownerId, entry, [...path, key], seen);
+    });
+  }
+  for (const { id, record } of listResolvedOntologyRecords(ontologyCompilation.ontology)) {
+    validateKnownOntologyReferences(id, record, record.origin.path);
+  }
   Object.values(model.policies).forEach((policy) => {
     policy.appliesTo.systemIds.forEach((systemId, systemIndex) => {
       if (!systemsById.has(systemId)) {
@@ -2411,6 +3149,7 @@ var OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((model, ct
     if (kind === "goal") return goalsById.has(id);
     if (kind === "customer-segment") return segmentsById.has(id);
     if (kind === "offering") return offeringsById.has(id);
+    if (kind === "ontology") return ontologyIds.has(id);
     return false;
   }
   Object.entries(model.knowledge).forEach(([nodeId2, node]) => {
@@ -2454,6 +3193,34 @@ var OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((model, ct
       );
     }
   });
+  function validateResourceOntologyBinding(resourceId, bindingKey, expectedKind, ids) {
+    const ontologyIds2 = ids === void 0 ? [] : Array.isArray(ids) ? ids : [ids];
+    ontologyIds2.forEach((ontologyId, ontologyIndex) => {
+      if (ontologyIndexByKind[expectedKind][ontologyId] === void 0) {
+        addIssue(
+          ctx,
+          [
+            "resources",
+            resourceId,
+            "ontology",
+            bindingKey,
+            ...Array.isArray(ids) ? [ontologyIndex] : []
+          ],
+          `Resource "${resourceId}" ontology binding "${bindingKey}" references unknown ${expectedKind} ontology ID "${ontologyId}"`
+        );
+      }
+    });
+  }
+  Object.values(model.resources).forEach((resource) => {
+    const binding = resource.ontology;
+    if (binding === void 0) return;
+    validateResourceOntologyBinding(resource.id, "actions", "action", binding.actions);
+    validateResourceOntologyBinding(resource.id, "primaryAction", "action", binding.primaryAction);
+    validateResourceOntologyBinding(resource.id, "reads", "object", binding.reads);
+    validateResourceOntologyBinding(resource.id, "writes", "object", binding.writes);
+    validateResourceOntologyBinding(resource.id, "usesCatalogs", "catalog", binding.usesCatalogs);
+    validateResourceOntologyBinding(resource.id, "emits", "event", binding.emits);
+  });
   Object.values(model.roles).forEach((role) => {
     if (role.heldBy === void 0) return;
     asRoleHolderArray(role.heldBy).forEach((holder, holderIndex) => {
@@ -2488,11 +3255,13 @@ var OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((model, ct
     });
   });
   function validateSystemContent(system, systemPath) {
+    const childSystems = system.systems ?? system.subsystems;
+    const childKey = system.systems !== void 0 ? "systems" : "subsystems";
     const content = system.content;
     if (content === void 0 || Object.keys(content).length === 0) {
-      if (system.subsystems !== void 0) {
-        Object.entries(system.subsystems).forEach(([childKey, child]) => {
-          validateSystemContent(child, [...systemPath, "subsystems", childKey]);
+      if (childSystems !== void 0) {
+        Object.entries(childSystems).forEach(([childLocalId, child]) => {
+          validateSystemContent(child, [...systemPath, childKey, childLocalId]);
         });
       }
       return;
@@ -2548,15 +3317,18 @@ var OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((model, ct
         }
       }
     });
-    if (system.subsystems !== void 0) {
-      Object.entries(system.subsystems).forEach(([childKey, child]) => {
-        validateSystemContent(child, [...systemPath, "subsystems", childKey]);
+    if (childSystems !== void 0) {
+      Object.entries(childSystems).forEach(([childLocalId, child]) => {
+        validateSystemContent(child, [...systemPath, childKey, childLocalId]);
       });
     }
   }
   Object.entries(model.systems).forEach(([systemKey, system]) => {
     validateSystemContent(system, ["systems", systemKey]);
   });
+  for (const diagnostic of ontologyCompilation.diagnostics) {
+    addIssue(ctx, diagnostic.path, diagnostic.message);
+  }
 });
 
 // ../core/src/organization-model/graph/schema.ts
@@ -2577,6 +3349,7 @@ var OrganizationGraphNodeKindSchema = z.enum([
   "surface",
   "navigation-group",
   // Phase 3 preview — Phase 4 populates via graph projection of system.content entries.
+  "ontology",
   "content-node"
 ]);
 var OrganizationGraphEdgeKindSchema = z.enum([
@@ -2590,24 +3363,30 @@ var OrganizationGraphEdgeKindSchema = z.enum([
   "emits",
   "originates_from",
   "triggers",
+  "approval",
   "applies_to",
-  "effects"
+  "effects",
+  "actions",
+  "reads",
+  "writes",
+  "uses_catalog"
 ]);
 var OrganizationGraphNodeSchema = z.object({
-  id: z.string().trim().min(1).max(200),
+  id: z.string().trim().min(1).max(400),
   kind: OrganizationGraphNodeKindSchema,
   label: LabelSchema,
-  sourceId: z.string().trim().min(1).max(255).optional(),
+  sourceId: z.string().trim().min(1).max(400).optional(),
   description: DescriptionSchema.optional(),
   icon: IconNameSchema.optional(),
   enabled: z.boolean().optional(),
+  ontologyKind: z.string().trim().min(1).max(80).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),
+  id: z.string().trim().min(1).max(900),
   kind: OrganizationGraphEdgeKindSchema,
-  sourceId: z.string().trim().min(1).max(200),
-  targetId: z.string().trim().min(1).max(200),
+  sourceId: z.string().trim().min(1).max(400),
+  targetId: z.string().trim().min(1).max(400),
   label: z.string().trim().min(1).max(120).optional(),
   relationshipType: z.enum(["triggers", "uses", "approval"]).optional()
 });
@@ -2668,7 +3447,7 @@ function getAllBuildTemplates(model) {
           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.
+          // Bridge readers preserve the historical shape for round-trip fidelity.
           ...sd
         };
       });
@@ -2832,6 +3611,20 @@ function invocationLabel(invocation) {
 function eventNodeId(eventId) {
   return nodeId("event", eventId);
 }
+function ontologyLabel(id, label) {
+  return label ?? parseOntologyId(id).localId;
+}
+function pushOntologyBindingEdges(edges, edgeIds, resourceNodeId, kind, ids) {
+  ids?.forEach((ontologyId) => {
+    const targetId = ontologyGraphNodeId(ontologyId);
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId(kind, resourceNodeId, targetId),
+      kind,
+      sourceId: resourceNodeId,
+      targetId
+    });
+  });
+}
 function buildResourceEventDescriptor(resourceId, emission) {
   return {
     ...emission,
@@ -2879,6 +3672,7 @@ function buildOrganizationGraph(input) {
   const organizationModelResourceIds = new Set(Object.keys(organizationModel.resources));
   const actionIdsByInvocation = /* @__PURE__ */ new Map();
   const projectedEventNodeIdsByEventId = /* @__PURE__ */ new Map();
+  const ontologyCompilation = compileOrganizationOntology(organizationModel);
   const organizationNode = {
     id: nodeId("organization"),
     kind: "organization",
@@ -2893,6 +3687,32 @@ function buildOrganizationGraph(input) {
   }
   const validSystemRefs = new Set(systemPathByRef.keys());
   const systemNodeId = (systemRef) => nodeId("system", systemPathByRef.get(systemRef) ?? systemRef);
+  function topologyNodeId(ref) {
+    if (ref.kind === "system") return systemNodeId(ref.id);
+    if (ref.kind === "resource") return nodeId("resource", ref.id);
+    if (ref.kind === "ontology") return ontologyGraphNodeId(ref.id);
+    if (ref.kind === "policy") return nodeId("policy", ref.id);
+    if (ref.kind === "role") return nodeId("role", ref.id);
+    return nodeId("resource", ref.id);
+  }
+  function ensureTopologyNode(ref) {
+    const id = topologyNodeId(ref);
+    if (nodeIds.has(id)) return id;
+    if (ref.kind === "resource") {
+      ensureResourceNode(nodes, nodeIds, resourceNodesById, ref.id);
+      return id;
+    }
+    if (ref.kind === "trigger" || ref.kind === "humanCheckpoint" || ref.kind === "externalResource") {
+      pushUniqueNode(nodes, nodeIds, {
+        id,
+        kind: "resource",
+        label: ref.id,
+        sourceId: ref.id,
+        resourceType: ref.kind === "trigger" ? "trigger" : ref.kind === "humanCheckpoint" ? "human_checkpoint" : "external"
+      });
+    }
+    return id;
+  }
   for (const { path, system } of systemsWithPaths.sort((a, b) => a.path.localeCompare(b.path))) {
     const id = nodeId("system", path);
     pushUniqueNode(nodes, nodeIds, {
@@ -2920,6 +3740,78 @@ function buildOrganizationGraph(input) {
       });
     }
   }
+  for (const { id: ontologyId, kind, record } of listResolvedOntologyRecords(ontologyCompilation.ontology).sort(
+    (a, b) => a.id.localeCompare(b.id)
+  )) {
+    const id = ontologyGraphNodeId(ontologyId);
+    const parsedId = parseOntologyId(ontologyId);
+    pushUniqueNode(nodes, nodeIds, {
+      id,
+      kind: "ontology",
+      label: ontologyLabel(ontologyId, record.label),
+      sourceId: ontologyId,
+      description: record.description,
+      ontologyKind: kind
+    });
+    const ownerSystemId = record.ownerSystemId ?? (parsedId.isGlobal ? void 0 : parsedId.scope);
+    if (ownerSystemId !== void 0 && validSystemRefs.has(ownerSystemId)) {
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("contains", systemNodeId(ownerSystemId), id, `ontology-${kind}`),
+        kind: "contains",
+        sourceId: systemNodeId(ownerSystemId),
+        targetId: id
+      });
+    } else {
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("contains", organizationNode.id, id, `ontology-${kind}`),
+        kind: "contains",
+        sourceId: organizationNode.id,
+        targetId: id
+      });
+    }
+    if (kind === "link") {
+      const link = record;
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("links", ontologyGraphNodeId(link.from), ontologyGraphNodeId(link.to), ontologyId),
+        kind: "links",
+        sourceId: ontologyGraphNodeId(link.from),
+        targetId: ontologyGraphNodeId(link.to),
+        label: link.label ?? parsedId.localId
+      });
+    }
+    if (kind === "action") {
+      const action = record;
+      for (const targetOntologyId of action.actsOn ?? []) {
+        pushUniqueEdge(edges, edgeIds, {
+          id: edgeId("affects", id, ontologyGraphNodeId(targetOntologyId), ontologyId),
+          kind: "affects",
+          sourceId: id,
+          targetId: ontologyGraphNodeId(targetOntologyId)
+        });
+      }
+    }
+    if (kind === "catalog") {
+      const catalog = record;
+      if (catalog.appliesTo === void 0) continue;
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("applies_to", id, ontologyGraphNodeId(catalog.appliesTo), ontologyId),
+        kind: "applies_to",
+        sourceId: id,
+        targetId: ontologyGraphNodeId(catalog.appliesTo)
+      });
+    }
+    if (kind === "group") {
+      const group = record;
+      for (const memberOntologyId of group.members ?? []) {
+        pushUniqueEdge(edges, edgeIds, {
+          id: edgeId("contains", id, ontologyGraphNodeId(memberOntologyId), ontologyId),
+          kind: "contains",
+          sourceId: id,
+          targetId: ontologyGraphNodeId(memberOntologyId)
+        });
+      }
+    }
+  }
   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, {
@@ -2971,7 +3863,7 @@ function buildOrganizationGraph(input) {
       targetId: id
     });
     for (const link of node.links) {
-      const targetId = link.target.kind === "system" ? systemNodeId(link.target.id) : link.nodeId;
+      const targetId = link.target.kind === "system" ? systemNodeId(link.target.id) : link.target.kind === "ontology" ? ontologyGraphNodeId(link.target.id) : link.nodeId;
       pushUniqueEdge(edges, edgeIds, {
         id: edgeId("governs", id, targetId),
         kind: "governs",
@@ -3136,6 +4028,11 @@ function buildOrganizationGraph(input) {
         targetId: resourceNode.id
       });
     }
+    pushOntologyBindingEdges(edges, edgeIds, resourceNode.id, "actions", resource.ontology?.actions);
+    pushOntologyBindingEdges(edges, edgeIds, resourceNode.id, "reads", resource.ontology?.reads);
+    pushOntologyBindingEdges(edges, edgeIds, resourceNode.id, "writes", resource.ontology?.writes);
+    pushOntologyBindingEdges(edges, edgeIds, resourceNode.id, "uses_catalog", resource.ontology?.usesCatalogs);
+    pushOntologyBindingEdges(edges, edgeIds, resourceNode.id, "emits", resource.ontology?.emits);
     if (resource.kind === "workflow" || resource.kind === "agent") {
       for (const emission of resource.emits ?? []) {
         pushEventProjection(
@@ -3265,6 +4162,19 @@ function buildOrganizationGraph(input) {
       }
     }
   }
+  for (const [relationshipId, relationship] of Object.entries(organizationModel.topology.relationships).sort(
+    ([a], [b]) => a.localeCompare(b)
+  )) {
+    const sourceId = ensureTopologyNode(relationship.from);
+    const targetId = ensureTopologyNode(relationship.to);
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId(relationship.kind, sourceId, targetId, `topology-${relationshipId}`),
+      kind: relationship.kind,
+      sourceId,
+      targetId,
+      relationshipType: relationship.kind
+    });
+  }
   for (const segment of Object.values(organizationModel.customers).sort(
     (a, b) => a.order - b.order || a.id.localeCompare(b.id)
   )) {
@@ -3510,14 +4420,14 @@ var DEFAULT_ORGANIZATION_MODEL_NAVIGATION = {
         label: "Dashboard",
         path: "/",
         surfaceType: "dashboard",
-        icon: "feature.dashboard",
+        icon: "dashboard",
         order: 10,
         targets: { systems: ["dashboard"] }
       },
       business: {
         type: "group",
         label: "Business",
-        icon: "feature.business",
+        icon: "business",
         order: 20,
         children: {
           sales: {
@@ -3525,7 +4435,7 @@ var DEFAULT_ORGANIZATION_MODEL_NAVIGATION = {
             label: "Sales",
             path: "/sales",
             surfaceType: "page",
-            icon: "feature.sales",
+            icon: "sales",
             order: 10,
             targets: { systems: ["sales"] }
           },
@@ -3534,7 +4444,7 @@ var DEFAULT_ORGANIZATION_MODEL_NAVIGATION = {
             label: "Clients",
             path: "/clients",
             surfaceType: "list",
-            icon: "feature.projects",
+            icon: "projects",
             order: 20,
             targets: { systems: ["clients"] }
           },
@@ -3543,7 +4453,7 @@ var DEFAULT_ORGANIZATION_MODEL_NAVIGATION = {
             label: "Projects",
             path: "/projects",
             surfaceType: "page",
-            icon: "feature.projects",
+            icon: "projects",
             order: 30,
             targets: { systems: ["projects"] }
           }
@@ -3552,7 +4462,7 @@ var DEFAULT_ORGANIZATION_MODEL_NAVIGATION = {
       operations: {
         type: "group",
         label: "Operations",
-        icon: "feature.operations",
+        icon: "operations",
         order: 30,
         children: {
           "operations-overview": {
@@ -3600,7 +4510,7 @@ var DEFAULT_ORGANIZATION_MODEL_NAVIGATION = {
       monitoring: {
         type: "group",
         label: "Monitoring",
-        icon: "feature.monitoring",
+        icon: "monitoring",
         order: 40,
         children: {
           "monitoring-overview": {
@@ -3662,36 +4572,19 @@ var DEFAULT_ORGANIZATION_MODEL_NAVIGATION = {
         }
       },
       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
-          }
-        }
+        type: "surface",
+        label: "Knowledge Base",
+        path: "/knowledge",
+        surfaceType: "page",
+        icon: "knowledge",
+        order: 50
       }
     },
     bottom: {
       settings: {
         type: "group",
         label: "Settings",
-        icon: "feature.settings",
+        icon: "settings",
         order: 10,
         children: {
           "settings-account": {
@@ -3763,7 +4656,7 @@ var DEFAULT_ORGANIZATION_MODEL_NAVIGATION = {
       admin: {
         type: "group",
         label: "Admin",
-        icon: "feature.admin",
+        icon: "admin",
         order: 20,
         children: {
           "admin-dashboard": {
@@ -3843,7 +4736,7 @@ var DEFAULT_ORGANIZATION_MODEL = {
       enabled: true,
       lifecycle: "active",
       path: "/",
-      icon: "feature.dashboard"
+      icon: "dashboard"
     },
     platform: {
       id: "platform",
@@ -3853,7 +4746,7 @@ var DEFAULT_ORGANIZATION_MODEL = {
       enabled: true,
       lifecycle: "active",
       color: "cyan",
-      icon: "feature.platform"
+      icon: "platform"
     },
     finance: {
       id: "finance",
@@ -3863,7 +4756,7 @@ var DEFAULT_ORGANIZATION_MODEL = {
       enabled: true,
       lifecycle: "active",
       color: "green",
-      icon: "feature.finance"
+      icon: "finance"
     },
     sales: {
       id: "sales",
@@ -3873,7 +4766,7 @@ var DEFAULT_ORGANIZATION_MODEL = {
       enabled: true,
       lifecycle: "active",
       color: "blue",
-      icon: "feature.sales",
+      icon: "sales",
       path: "/sales"
     },
     "sales.crm": {
@@ -3883,8 +4776,12 @@ var DEFAULT_ORGANIZATION_MODEL = {
       description: "Relationship pipeline and deal management",
       enabled: true,
       lifecycle: "active",
+      actions: Object.values(CRM_ACTION_ENTRIES).map((action) => ({
+        actionId: action.id,
+        intent: "exposes"
+      })),
       color: "blue",
-      icon: "feature.crm",
+      icon: "crm",
       path: "/crm"
     },
     "sales.lead-gen": {
@@ -3894,12 +4791,12 @@ var DEFAULT_ORGANIZATION_MODEL = {
       description: "Prospecting, qualification, and outreach preparation",
       enabled: true,
       lifecycle: "active",
-      actions: Object.values(DEFAULT_ORGANIZATION_MODEL_ACTIONS).map((action) => ({
+      actions: Object.values(LEAD_GEN_ACTION_ENTRIES).map((action) => ({
         actionId: action.id,
         intent: "exposes"
       })),
       color: "cyan",
-      icon: "feature.lead-gen",
+      icon: "lead-gen",
       path: "/lead-gen"
     },
     projects: {
@@ -3910,7 +4807,7 @@ var DEFAULT_ORGANIZATION_MODEL = {
       enabled: true,
       lifecycle: "active",
       color: "orange",
-      icon: "feature.projects",
+      icon: "projects",
       path: "/projects"
     },
     clients: {
@@ -3921,7 +4818,7 @@ var DEFAULT_ORGANIZATION_MODEL = {
       enabled: true,
       lifecycle: "active",
       color: "orange",
-      icon: "feature.projects",
+      icon: "projects",
       path: "/clients"
     },
     operations: {
@@ -3932,7 +4829,7 @@ var DEFAULT_ORGANIZATION_MODEL = {
       enabled: true,
       lifecycle: "active",
       color: "violet",
-      icon: "feature.operations"
+      icon: "operations"
     },
     "knowledge.command-view": {
       id: "knowledge.command-view",
@@ -3998,7 +4895,7 @@ var DEFAULT_ORGANIZATION_MODEL = {
       enabled: true,
       lifecycle: "active",
       path: "/monitoring/calendar",
-      icon: "feature.calendar"
+      icon: "calendar"
     },
     "monitoring.activity-log": {
       id: "monitoring.activity-log",
@@ -4054,7 +4951,7 @@ var DEFAULT_ORGANIZATION_MODEL = {
       label: "Settings",
       enabled: true,
       lifecycle: "active",
-      icon: "feature.settings"
+      icon: "settings"
     },
     "settings.account": {
       id: "settings.account",
@@ -4127,7 +5024,7 @@ var DEFAULT_ORGANIZATION_MODEL = {
       enabled: true,
       lifecycle: "active",
       path: "/admin",
-      icon: "feature.admin",
+      icon: "admin",
       requiresAdmin: true
     },
     "admin.system-health": {
@@ -4177,7 +5074,7 @@ var DEFAULT_ORGANIZATION_MODEL = {
       enabled: true,
       lifecycle: "active",
       path: "/archive",
-      icon: "feature.archive",
+      icon: "archive",
       devOnly: true
     },
     "archive.agent-chat": {
@@ -4212,7 +5109,7 @@ var DEFAULT_ORGANIZATION_MODEL = {
       enabled: true,
       lifecycle: "active",
       color: "teal",
-      icon: "feature.knowledge"
+      icon: "knowledge"
     },
     "knowledge.base": {
       id: "knowledge.base",
@@ -4223,11 +5120,14 @@ var DEFAULT_ORGANIZATION_MODEL = {
       path: "/knowledge"
     }
   },
+  ontology: DEFAULT_ONTOLOGY_SCOPE,
   resources: DEFAULT_ORGANIZATION_MODEL_RESOURCES,
+  topology: DEFAULT_ORGANIZATION_MODEL_TOPOLOGY,
   actions: DEFAULT_ORGANIZATION_MODEL_ACTIONS,
   entities: DEFAULT_ORGANIZATION_MODEL_ENTITIES2,
   policies: DEFAULT_ORGANIZATION_MODEL_POLICIES,
-  // Phase 4 (D1): statuses top-level field removed; status data lives in system.content.
+  // Phase 4 (D1): statuses top-level field removed; bridge status mirrors may
+  // still project from System.content, but primary authoring belongs in ontology.
   knowledge: DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE
 };
 
@@ -4235,6 +5135,31 @@ var DEFAULT_ORGANIZATION_MODEL = {
 function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function collectNestedSystemPaths(systems, prefix = "") {
+  const paths = /* @__PURE__ */ new Set();
+  for (const [key, value] of Object.entries(systems)) {
+    if (!isPlainObject(value)) continue;
+    const path = prefix ? `${prefix}.${key}` : key;
+    for (const childKey of ["systems", "subsystems"]) {
+      const childSystems = value[childKey];
+      if (!isPlainObject(childSystems)) continue;
+      for (const childPath of collectNestedSystemPaths(childSystems, path)) {
+        paths.add(childPath);
+      }
+    }
+    if (prefix !== "") {
+      paths.add(path);
+    }
+  }
+  return paths;
+}
+function pruneFlatSystemDescendantCollisions(base, override) {
+  const result = { ...base };
+  for (const nestedPath of collectNestedSystemPaths(override)) {
+    delete result[nestedPath];
+  }
+  return result;
+}
 function deepMerge(base, override) {
   if (override === void 0) {
     return base;
@@ -4249,12 +5174,18 @@ function deepMerge(base, override) {
   for (const [key, value] of Object.entries(override)) {
     if (value === void 0) continue;
     const existing = result[key];
+    if (key === "systems" && isPlainObject(existing) && isPlainObject(value)) {
+      result[key] = deepMerge(pruneFlatSystemDescendantCollisions(existing, value), value);
+      continue;
+    }
     result[key] = isPlainObject(existing) && isPlainObject(value) ? deepMerge(existing, value) : value;
   }
   return result;
 }
-function resolveOrganizationModel(override, organizationId) {
-  const merged = deepMerge(DEFAULT_ORGANIZATION_MODEL, override);
+function resolveOrganizationModel(override, organizationIdOrOptions, options) {
+  const resolvedOptions = typeof organizationIdOrOptions === "object" ? organizationIdOrOptions : options;
+  const mergeDefaults = resolvedOptions?.mergeDefaults ?? true;
+  const merged = mergeDefaults ? deepMerge(DEFAULT_ORGANIZATION_MODEL, override) : override ?? {};
   return OrganizationModelSchema.parse(merged);
 }
 
@@ -4339,4 +5270,4 @@ function projectOrganizationSurfaces(model) {
   });
 }
 
-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 };
+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, DEFAULT_ORGANIZATION_MODEL, EntitySchema, IdentityDomainSchema, IntegrationResourceEntrySchema, LEAD_GEN_PIPELINE_DEFINITIONS, LEAD_GEN_STAGE_CATALOG, OntologyIdSchema, PROJECTS_VIEW_ACTION_ID, PROSPECTING_STEPS, PolicySchema, RoleSchema, SalesStageSchema, ScriptResourceEntrySchema, SurfaceDefinitionSchema, SystemEntrySchema, WorkflowResourceEntrySchema, ancestorsOf, buildOrganizationGraph, childrenOf, compileOrganizationOntology, defaultPathFor, devOnlyFor, findById, findByPath, findPipeline, formatOntologyId, getContent, getResourcesForSystem, getSortedSidebarEntries, getSystem, getSystemAncestors, listAllSystems, lookupContentType, ontologyGraphNodeId, parentOf, parseOntologyId, projectOrganizationSurfaces, requiresAdminFor, resolveOrganizationModel, resolveSystemConfig, topLevel };