@elevasis/sdk 1.44.3 → 1.45.0

package/dist/index.js

@@ -623,17 +623,23 @@ var SystemInterfaceResourceScopeSchema = z.array(ModelIdSchema).default([]);
 var SystemApiInterfaceReadinessContractSchema = z.object({
   /** Ontology IDs of object types the interface depends on. */
   requiredObjects: z.array(z.string().trim().min(1)).default([]),
-  /** Ontology IDs of catalog types the interface requires (must be non-empty). */
-  requiredCatalogs: z.array(z.string().trim().min(1)).default([]),
-  /** Optional ontology kind filters (reserved for future profile extensions). */
-  requiredKinds: z.array(z.string().trim().min(1)).optional()
+  /**
+   * Ontology IDs of catalog types the interface requires. Must declare at least one
+   * entry — a `readinessContract` with no `requiredCatalogs` asserts nothing at all,
+   * so it has no `.default([])`; omitting the field is rejected the same as an
+   * explicit empty array.
+   */
+  requiredCatalogs: z.array(z.string().trim().min(1)).min(1)
 }).strict();
 var SystemApiInterfaceSchema = z.object({
   lifecycle: SystemInterfaceLifecycleSchema.default("active"),
   /**
    * Open-string profile id. Built-in platform presets are looked up through
    * the profile registry; custom ids are validated structurally via
-   * `readinessContract`. Optional — `profileForInterface` provides a default.
+   * `readinessContract`. Optional at the schema layer, but readiness
+   * computation rejects an interface that omits it with a
+   * `missing-readiness-profile` diagnostic — there is no positional
+   * fallback to `${systemPath}.${interfaceKey}`.
    */
   readinessProfile: SystemInterfaceReadinessProfileSchema.optional(),
   /**
@@ -664,9 +670,6 @@ function registerReadinessProfile(profileId) {
   _profileRegistry.set(profileId, entry);
   return entry;
 }
-function profileForInterface(systemPath, interfaceKey, readinessProfile) {
-  return readinessProfile ?? `${systemPath}.${interfaceKey}`;
-}
 function isBuiltInReadinessProfile(profileId) {
   return _profileRegistry.get(profileId)?.kind === "built-in";
 }
@@ -1130,6 +1133,7 @@ function appliesToEntityKind(catalog) {
   if (id === "deal") return void 0;
   return void 0;
 }
+formatOntologyId({ scope: "sales.crm", kind: "catalog", localId: "crm.pipeline" });
 function getLeadGenStageCatalog(model) {
   const results = {};
   for (const catalog of catalogRecords(model).filter(
@@ -1214,106 +1218,450 @@ var ProspectingBuildTemplateSchema = DisplayMetadataSchema.extend({
   steps: z.array(ProspectingBuildTemplateStepSchema).min(1)
 });
 
-// src/contract-ref.ts
-var ContractRefResolutionError = class extends Error {
-  constructor(code, message, ref) {
-    super(message);
-    this.code = code;
-    this.ref = ref;
-    this.name = "ContractRefResolutionError";
+// ../core/src/organization-model/readiness/profile-registry.ts
+var _builtInProfileValidators = /* @__PURE__ */ new Map();
+function registerBuiltInReadinessProfile(profileId, registration) {
+  _builtInProfileValidators.set(profileId, registration);
+}
+function getBuiltInReadinessProfile(profileId) {
+  return _builtInProfileValidators.get(profileId);
+}
+var _interfaceMarkerResolvers = /* @__PURE__ */ new Map();
+function interfaceMarkerKey(systemPath, interfaceKey) {
+  return `${systemPath}::${interfaceKey}`;
+}
+function registerReadinessInterfaceMarker(systemPath, interfaceKey, resolver) {
+  _interfaceMarkerResolvers.set(interfaceMarkerKey(systemPath, interfaceKey), resolver);
+}
+function resolveReadinessInterfaceMarker(model, systemPath, interfaceKey) {
+  return _interfaceMarkerResolvers.get(interfaceMarkerKey(systemPath, interfaceKey))?.(model);
+}
+
+// ../core/src/organization-model/readiness/engine.ts
+var SystemInterfaceReadinessError = class extends Error {
+  code;
+  statusCode = 503;
+  systemPath;
+  interfaceKey;
+  readinessProfile;
+  issues;
+  constructor(result) {
+    const firstIssue = result.issues[0];
+    super(formatInterfaceReadinessFailure(result));
+    this.name = "SystemInterfaceReadinessError";
+    this.code = firstIssue?.family ?? "SYSTEM_INTERFACE_NOT_READY";
+    this.systemPath = result.systemPath;
+    this.interfaceKey = result.interfaceKey;
+    this.readinessProfile = result.readinessProfile;
+    this.issues = result.issues;
   }
 };
-function isZodType(value) {
-  return typeof value === "object" && value !== null && "_def" in value;
+function addReadinessIssue(issues, family, code, message, details = {}) {
+  issues.push({
+    family,
+    code,
+    message,
+    ...details
+  });
 }
-function resolveContractRef(ref, registry) {
-  const parsed = parseContractRef(ref);
-  const moduleNamespace = registry[parsed.moduleSpecifier];
-  if (moduleNamespace === void 0) {
-    throw new ContractRefResolutionError(
-      "contract-ref-unknown-module",
-      `ContractRef "${ref}" references unknown module "${parsed.moduleSpecifier}".`,
-      ref
+function formatInterfaceIdentity(systemPath, interfaceKey) {
+  return `${systemPath}/${interfaceKey}`;
+}
+function readinessMarkerPath(context) {
+  return context.interfaceKey === "api" ? `systems.${context.systemPath}.apiInterface` : void 0;
+}
+function readinessMarkerFieldPath(context, suffix) {
+  const base = readinessMarkerPath(context);
+  return base === void 0 ? void 0 : `${base}${suffix}`;
+}
+function formatInterfaceReadinessFailure(result) {
+  const identity = formatInterfaceIdentity(result.systemPath, result.interfaceKey);
+  const issueSummary = result.issues.map((issue) => `${issue.family}:${issue.code}: ${issue.message}`).join("; ");
+  return `${identity} readiness failed${result.readinessProfile ? ` (${result.readinessProfile})` : ""}: ${issueSummary}`;
+}
+function formatSupportedReadinessProfiles() {
+  return SYSTEM_INTERFACE_PROFILES.map((p) => `"${p.readinessProfile}"`).join(", ");
+}
+function isPlainRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function getCatalogEntries(catalog) {
+  return isPlainRecord(catalog.entries) ? catalog.entries : {};
+}
+function getActiveScopedResources(model, resourceIds, issues, context) {
+  const resources = [];
+  for (const [index, resourceId] of resourceIds.entries()) {
+    const resource = model.resources?.[resourceId];
+    const path = readinessMarkerFieldPath(context, `.resourceIds.${index}`);
+    if (resource === void 0) {
+      addReadinessIssue(
+        issues,
+        "SYSTEM_INTERFACE_NOT_READY",
+        "missing-resource",
+        `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" scopes missing resource "${resourceId}".`,
+        { path, ref: resourceId }
+      );
+      continue;
+    }
+    if (resource.systemPath !== context.systemPath) {
+      addReadinessIssue(
+        issues,
+        "SYSTEM_INTERFACE_INVALID",
+        "resource-system-mismatch",
+        `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" scopes resource "${resourceId}" from system "${resource.systemPath}".`,
+        { path, ref: resourceId }
+      );
+      continue;
+    }
+    if (resource.status !== "active") {
+      addReadinessIssue(
+        issues,
+        "SYSTEM_INTERFACE_NOT_READY",
+        "inactive-resource",
+        `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" scopes inactive resource "${resourceId}".`,
+        { path, ref: resourceId }
+      );
+      continue;
+    }
+    resources.push(resource);
+  }
+  return resources;
+}
+function resourceBindingIds(resources, key) {
+  return new Set(resources.flatMap((resource) => resource.ontology?.[key] ?? []));
+}
+function requireScopedBinding(issues, boundIds, bindingKey, ontologyId, context) {
+  if (boundIds.has(ontologyId)) return;
+  addReadinessIssue(
+    issues,
+    "SYSTEM_INTERFACE_NOT_READY",
+    "missing-resource-binding",
+    `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" has no active scoped resource with ontology.${bindingKey} binding "${ontologyId}".`,
+    { path: readinessMarkerFieldPath(context, ".resourceIds"), ref: ontologyId }
+  );
+}
+function ontologyOwnerMatches(ontologyId, expectedSystemPath, catalog) {
+  if (catalog?.ownerSystemId !== void 0) return catalog.ownerSystemId === expectedSystemPath;
+  return parseOntologyId(ontologyId).scope === expectedSystemPath;
+}
+function requireObjectReadiness(issues, index, objectId, context) {
+  const object = index.ontology.objectTypes[objectId];
+  if (object === void 0) {
+    addReadinessIssue(
+      issues,
+      "SYSTEM_INTERFACE_NOT_READY",
+      "missing-object",
+      `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" is missing required object type "${objectId}".`,
+      { ref: objectId }
     );
+    return;
   }
-  const exportValue = moduleNamespace[parsed.exportName];
-  if (exportValue === void 0) {
-    throw new ContractRefResolutionError(
-      "contract-ref-unknown-export",
-      `ContractRef "${ref}" references unknown export "${parsed.exportName}".`,
-      ref
+  const ownerSystemId = object.ownerSystemId ?? parseOntologyId(objectId).scope;
+  if (ownerSystemId !== context.systemPath) {
+    addReadinessIssue(
+      issues,
+      "SYSTEM_INTERFACE_INVALID",
+      "foreign-object",
+      `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" requires object "${objectId}" owned by "${ownerSystemId}".`,
+      { ref: objectId }
     );
   }
-  if (!isZodType(exportValue)) {
-    throw new ContractRefResolutionError(
-      "contract-ref-not-zod-type",
-      `ContractRef "${ref}" resolves to "${parsed.exportName}" but it is not a ZodType.`,
-      ref
+}
+function requireCatalogReadiness(issues, index, catalogId, context) {
+  const catalog = index.ontology.catalogTypes[catalogId];
+  if (catalog === void 0) {
+    addReadinessIssue(
+      issues,
+      "SYSTEM_INTERFACE_NOT_READY",
+      "missing-catalog",
+      `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" is missing required catalog "${catalogId}".`,
+      { ref: catalogId }
     );
+    return void 0;
   }
-  return {
-    ref,
-    moduleSpecifier: parsed.moduleSpecifier,
-    exportName: parsed.exportName,
-    value: exportValue
-  };
+  if (context.allowForeignOwner !== true && !ontologyOwnerMatches(catalogId, context.systemPath, catalog)) {
+    addReadinessIssue(
+      issues,
+      "SYSTEM_INTERFACE_INVALID",
+      "foreign-catalog",
+      `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" requires catalog "${catalogId}" owned by "${catalog.ownerSystemId ?? parseOntologyId(catalogId).scope}".`,
+      { ref: catalogId }
+    );
+  }
+  if (Object.keys(getCatalogEntries(catalog)).length === 0) {
+    addReadinessIssue(
+      issues,
+      "SYSTEM_INTERFACE_NOT_READY",
+      "empty-catalog",
+      `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" requires catalog entries for "${catalogId}".`,
+      { ref: catalogId }
+    );
+  }
+  return catalog;
 }
-async function concurrentPool(opts) {
-  const { items, concurrency, process, onSuccess, onError } = opts;
-  const results = [];
-  let nextIndex = 0;
-  let succeeded = 0;
-  let failed = 0;
-  const active = /* @__PURE__ */ new Set();
-  const enqueue = () => {
-    while (active.size < concurrency && nextIndex < items.length) {
-      const idx = nextIndex++;
-      const item = items[idx];
-      const task = process(item, idx).then((value) => {
-        results.push({ index: idx, value });
-        succeeded++;
-        onSuccess?.(value, item, idx);
-      }).catch((error) => {
-        results.push({ index: idx, error });
-        failed++;
-        onError?.(error, item, idx);
-      }).finally(() => {
-        active.delete(task);
-        enqueue();
-      });
-      active.add(task);
-    }
-  };
-  enqueue();
-  while (active.size > 0) {
-    await Promise.race(active);
+function requireContractReadiness(issues, index, resources, contract, context) {
+  const reads = resourceBindingIds(resources, "reads");
+  const catalogs = resourceBindingIds(resources, "usesCatalogs");
+  for (const objectId of contract.requiredObjects) {
+    requireObjectReadiness(issues, index, objectId, context);
+    requireScopedBinding(issues, reads, "reads", objectId, context);
+  }
+  for (const catalogId of contract.requiredCatalogs) {
+    requireCatalogReadiness(issues, index, catalogId, context);
+    requireScopedBinding(issues, catalogs, "usesCatalogs", catalogId, context);
   }
-  return { results, succeeded, failed };
 }
-var diagnosticOutput = z.object({
-  success: z.boolean(),
-  tool: z.string(),
-  method: z.string(),
-  result: z.unknown().optional(),
-  error: z.string().optional(),
-  durationMs: z.number().optional()
-});
-var integrationInput = z.object({
-  credential: z.string().describe("Credential name registered for this integration")
-});
-async function runDiagnostic(tool, method, fn) {
-  const start = Date.now();
-  try {
-    const result = await fn();
-    return { success: true, tool, method, result, durationMs: Date.now() - start };
-  } catch (error) {
-    return { success: false, tool, method, error: String(error), durationMs: Date.now() - start };
+function getSystemInterfaceReadinessMarker(model, request) {
+  const system = getSystem(model, request.systemPath);
+  if (system === void 0) return void 0;
+  const registeredMarker = resolveReadinessInterfaceMarker(model, request.systemPath, request.interfaceKey);
+  if (registeredMarker !== void 0) return registeredMarker;
+  if (request.interfaceKey === "api" && system.apiInterface !== void 0) {
+    return system.apiInterface;
   }
+  return void 0;
 }
-var NAME_PREFIXES = /^(dr\.?|prof\.?|mr\.?|mrs\.?|ms\.?|rev\.?)\s+/i;
-var NAME_SUFFIXES = /[,\s]+(dvm|md|phd|do|jr\.?|sr\.?|ii|iii|iv|esq\.?|rn|lvt|cvt|rvt)\.?$/i;
-function splitName(name) {
-  const cleaned = name.trim().replace(NAME_PREFIXES, "").replace(NAME_SUFFIXES, "").trim();
+function compileReadinessOntology(model, readinessProfile, prepareModel) {
+  const preparedModel = prepareModel !== void 0 ? prepareModel(model) : model;
+  const compilation = compileOrganizationOntology(preparedModel);
+  if (compilation.diagnostics.length > 0) {
+    const summary = compilation.diagnostics.map((diagnostic) => diagnostic.message).join("; ");
+    throw new Error(`${readinessProfile} ontology validation index failed to compile: ${summary}`);
+  }
+  return { ontology: compilation.ontology };
+}
+function tryCompileReadinessOntology(model, readinessProfile, prepareModel, issues) {
+  try {
+    return compileReadinessOntology(model, readinessProfile, prepareModel);
+  } catch (error) {
+    addReadinessIssue(
+      issues,
+      "SYSTEM_INTERFACE_INVALID",
+      "ontology-compile-failed",
+      error instanceof Error ? error.message : String(error)
+    );
+    return void 0;
+  }
+}
+function computeInterfaceReadiness(model, request) {
+  const issues = [];
+  const system = getSystem(model, request.systemPath);
+  const systemInterface = getSystemInterfaceReadinessMarker(model, request);
+  const readinessProfile = systemInterface?.readinessProfile;
+  const scopedResourceIds = systemInterface?.resourceIds ?? [];
+  if (system === void 0) {
+    addReadinessIssue(
+      issues,
+      "SYSTEM_INTERFACE_MISSING",
+      "missing-system",
+      `System "${request.systemPath}" is missing.`,
+      { ref: request.systemPath }
+    );
+    return {
+      ready: false,
+      systemPath: request.systemPath,
+      interfaceKey: request.interfaceKey,
+      scopedResourceIds,
+      issues
+    };
+  }
+  if (systemInterface === void 0) {
+    addReadinessIssue(
+      issues,
+      "SYSTEM_INTERFACE_MISSING",
+      "missing-interface",
+      `System "${request.systemPath}" does not declare interface "${request.interfaceKey}".`,
+      { path: readinessMarkerPath(request) }
+    );
+    return {
+      ready: false,
+      systemPath: request.systemPath,
+      interfaceKey: request.interfaceKey,
+      scopedResourceIds,
+      issues
+    };
+  }
+  if (systemInterface.lifecycle !== "active") {
+    addReadinessIssue(
+      issues,
+      "SYSTEM_INTERFACE_DISABLED",
+      "inactive-interface",
+      `System Interface "${formatInterfaceIdentity(request.systemPath, request.interfaceKey)}" lifecycle is "${systemInterface.lifecycle}".`,
+      { path: readinessMarkerFieldPath(request, ".lifecycle") }
+    );
+    return {
+      ready: false,
+      systemPath: request.systemPath,
+      interfaceKey: request.interfaceKey,
+      readinessProfile,
+      scopedResourceIds,
+      issues
+    };
+  }
+  if (readinessProfile === void 0) {
+    addReadinessIssue(
+      issues,
+      "SYSTEM_INTERFACE_INVALID",
+      "missing-readiness-profile",
+      `System Interface "${formatInterfaceIdentity(request.systemPath, request.interfaceKey)}" declares an apiInterface but no readinessProfile. Declare a built-in profile (${formatSupportedReadinessProfiles()}) or a custom id paired with a readinessContract.`,
+      { path: readinessMarkerFieldPath(request, ".readinessProfile") }
+    );
+    return {
+      ready: false,
+      systemPath: request.systemPath,
+      interfaceKey: request.interfaceKey,
+      scopedResourceIds,
+      issues
+    };
+  }
+  const isBuiltIn = isBuiltInReadinessProfile(readinessProfile);
+  const readinessContract = systemInterface.readinessContract;
+  if (!isBuiltIn && readinessContract === void 0) {
+    addReadinessIssue(
+      issues,
+      "SYSTEM_INTERFACE_INVALID",
+      "missing-readiness-contract",
+      `System Interface "${formatInterfaceIdentity(request.systemPath, request.interfaceKey)}" uses custom readiness profile "${readinessProfile}" but declares no readinessContract. Built-in profiles: ${formatSupportedReadinessProfiles()}.`,
+      { path: readinessMarkerFieldPath(request, ".readinessContract"), ref: readinessProfile }
+    );
+    return {
+      ready: false,
+      systemPath: request.systemPath,
+      interfaceKey: request.interfaceKey,
+      readinessProfile,
+      scopedResourceIds,
+      issues
+    };
+  }
+  if (scopedResourceIds.length === 0) {
+    addReadinessIssue(
+      issues,
+      "SYSTEM_INTERFACE_NOT_READY",
+      "missing-scoped-resources",
+      `System Interface "${formatInterfaceIdentity(request.systemPath, request.interfaceKey)}" must scope at least one active resource.`,
+      { path: readinessMarkerFieldPath(request, ".resourceIds") }
+    );
+  }
+  const resources = getActiveScopedResources(model, scopedResourceIds, issues, request);
+  const registration = getBuiltInReadinessProfile(readinessProfile);
+  const index = tryCompileReadinessOntology(model, readinessProfile, registration?.prepareModel, issues);
+  if (index !== void 0) {
+    if (registration !== void 0) {
+      registration.validate(issues, index, resources, model, request);
+    } else if (readinessContract !== void 0) {
+      requireContractReadiness(issues, index, resources, readinessContract, request);
+    }
+  }
+  return {
+    ready: issues.length === 0,
+    systemPath: request.systemPath,
+    interfaceKey: request.interfaceKey,
+    readinessProfile,
+    scopedResourceIds,
+    issues
+  };
+}
+
+// src/contract-ref.ts
+var ContractRefResolutionError = class extends Error {
+  constructor(code, message, ref) {
+    super(message);
+    this.code = code;
+    this.ref = ref;
+    this.name = "ContractRefResolutionError";
+  }
+};
+function isZodType(value) {
+  return typeof value === "object" && value !== null && "_def" in value;
+}
+function resolveContractRef(ref, registry) {
+  const parsed = parseContractRef(ref);
+  const moduleNamespace = registry[parsed.moduleSpecifier];
+  if (moduleNamespace === void 0) {
+    throw new ContractRefResolutionError(
+      "contract-ref-unknown-module",
+      `ContractRef "${ref}" references unknown module "${parsed.moduleSpecifier}".`,
+      ref
+    );
+  }
+  const exportValue = moduleNamespace[parsed.exportName];
+  if (exportValue === void 0) {
+    throw new ContractRefResolutionError(
+      "contract-ref-unknown-export",
+      `ContractRef "${ref}" references unknown export "${parsed.exportName}".`,
+      ref
+    );
+  }
+  if (!isZodType(exportValue)) {
+    throw new ContractRefResolutionError(
+      "contract-ref-not-zod-type",
+      `ContractRef "${ref}" resolves to "${parsed.exportName}" but it is not a ZodType.`,
+      ref
+    );
+  }
+  return {
+    ref,
+    moduleSpecifier: parsed.moduleSpecifier,
+    exportName: parsed.exportName,
+    value: exportValue
+  };
+}
+async function concurrentPool(opts) {
+  const { items, concurrency, process, onSuccess, onError } = opts;
+  const results = [];
+  let nextIndex = 0;
+  let succeeded = 0;
+  let failed = 0;
+  const active = /* @__PURE__ */ new Set();
+  const enqueue = () => {
+    while (active.size < concurrency && nextIndex < items.length) {
+      const idx = nextIndex++;
+      const item = items[idx];
+      const task = process(item, idx).then((value) => {
+        results.push({ index: idx, value });
+        succeeded++;
+        onSuccess?.(value, item, idx);
+      }).catch((error) => {
+        results.push({ index: idx, error });
+        failed++;
+        onError?.(error, item, idx);
+      }).finally(() => {
+        active.delete(task);
+        enqueue();
+      });
+      active.add(task);
+    }
+  };
+  enqueue();
+  while (active.size > 0) {
+    await Promise.race(active);
+  }
+  return { results, succeeded, failed };
+}
+var diagnosticOutput = z.object({
+  success: z.boolean(),
+  tool: z.string(),
+  method: z.string(),
+  result: z.unknown().optional(),
+  error: z.string().optional(),
+  durationMs: z.number().optional()
+});
+var integrationInput = z.object({
+  credential: z.string().describe("Credential name registered for this integration")
+});
+async function runDiagnostic(tool, method, fn) {
+  const start = Date.now();
+  try {
+    const result = await fn();
+    return { success: true, tool, method, result, durationMs: Date.now() - start };
+  } catch (error) {
+    return { success: false, tool, method, error: String(error), durationMs: Date.now() - start };
+  }
+}
+var NAME_PREFIXES = /^(dr\.?|prof\.?|mr\.?|mrs\.?|ms\.?|rev\.?)\s+/i;
+var NAME_SUFFIXES = /[,\s]+(dvm|md|phd|do|jr\.?|sr\.?|ii|iii|iv|esq\.?|rn|lvt|cvt|rvt)\.?$/i;
+function splitName(name) {
+  const cleaned = name.trim().replace(NAME_PREFIXES, "").replace(NAME_SUFFIXES, "").trim();
   const parts = cleaned.split(/\s+/);
   return { firstName: parts[0], lastName: parts.length > 1 ? parts.slice(1).join(" ") : void 0 };
 }
@@ -4061,598 +4409,10 @@ function buildIterationResponseSchemaUncached(tools, capabilities) {
     };
   }
   return {
-    type: "object",
-    properties,
-    required: capabilities.message === "required" ? ["nextActions", "message", "reasoning"] : ["nextActions", "reasoning"],
-    additionalProperties: false
-  };
-}
-
-// ../core/src/business/acquisition/ontology-validation.ts
-var LEAD_GEN_API_INTERFACE = SYSTEM_INTERFACE_PROFILES[0];
-var CRM_API_INTERFACE = SYSTEM_INTERFACE_PROFILES[1];
-var LEAD_GEN_CRM_HANDOFF_INTERFACE = SYSTEM_INTERFACE_PROFILES[2];
-var LEAD_GEN_API_READINESS_LABEL = LEAD_GEN_API_INTERFACE.readinessProfile;
-var CRM_API_READINESS_LABEL = CRM_API_INTERFACE.readinessProfile;
-LEAD_GEN_CRM_HANDOFF_INTERFACE.readinessProfile;
-var LEAD_GEN_LIST_OBJECT_ONTOLOGY_ID = formatOntologyId({
-  scope: "sales.lead-gen",
-  kind: "object",
-  localId: "list"
-});
-var LEAD_GEN_COMPANY_OBJECT_ONTOLOGY_ID = formatOntologyId({
-  scope: "sales.lead-gen",
-  kind: "object",
-  localId: "company"
-});
-var LEAD_GEN_CONTACT_OBJECT_ONTOLOGY_ID = formatOntologyId({
-  scope: "sales.lead-gen",
-  kind: "object",
-  localId: "contact"
-});
-var LEAD_GEN_BUILD_TEMPLATE_CATALOG_ONTOLOGY_ID = formatOntologyId({
-  scope: "sales.lead-gen",
-  kind: "catalog",
-  localId: "build-template"
-});
-var LEAD_GEN_COMPANY_STAGE_CATALOG_ONTOLOGY_ID = formatOntologyId({
-  scope: "sales.lead-gen",
-  kind: "catalog",
-  localId: "company-stage"
-});
-var LEAD_GEN_CONTACT_STAGE_CATALOG_ONTOLOGY_ID = formatOntologyId({
-  scope: "sales.lead-gen",
-  kind: "catalog",
-  localId: "contact-stage"
-});
-var CRM_PIPELINE_CATALOG_ONTOLOGY_ID = formatOntologyId({
-  scope: "sales.crm",
-  kind: "catalog",
-  localId: "crm.pipeline"
-});
-var LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID = formatOntologyId({
-  scope: "sales.lead-gen",
-  kind: "catalog",
-  localId: "lead-gen.stage-catalog"
-});
-var SystemInterfaceReadinessError = class extends Error {
-  code;
-  statusCode = 503;
-  systemPath;
-  interfaceKey;
-  readinessProfile;
-  issues;
-  constructor(result) {
-    const firstIssue = result.issues[0];
-    super(formatInterfaceReadinessFailure(result));
-    this.name = "SystemInterfaceReadinessError";
-    this.code = firstIssue?.family ?? "SYSTEM_INTERFACE_NOT_READY";
-    this.systemPath = result.systemPath;
-    this.interfaceKey = result.interfaceKey;
-    this.readinessProfile = result.readinessProfile;
-    this.issues = result.issues;
-  }
-};
-function createLeadGenStageCatalog(model) {
-  return {
-    id: LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID,
-    label: "Lead Gen Processing Stages",
-    ownerSystemId: "sales.lead-gen",
-    kind: "processing-stage-catalog",
-    entries: Object.fromEntries(
-      Object.entries(getLeadGenStageCatalog(model)).map(([key, entry]) => [
-        key,
-        {
-          ...entry
-        }
-      ])
-    ),
-    legacyCatalogKey: "LEAD_GEN_STAGE_CATALOG"
-  };
-}
-function isPlainRecord(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function addReadinessIssue(issues, family, code, message, details = {}) {
-  issues.push({
-    family,
-    code,
-    message,
-    ...details
-  });
-}
-function formatInterfaceIdentity(systemPath, interfaceKey) {
-  return `${systemPath}/${interfaceKey}`;
-}
-function readinessMarkerPath(context) {
-  return context.interfaceKey === "api" ? `systems.${context.systemPath}.apiInterface` : `systems.${context.systemPath}.derivedCrmHandoffReadiness`;
-}
-function formatInterfaceReadinessFailure(result) {
-  const identity = formatInterfaceIdentity(result.systemPath, result.interfaceKey);
-  const issueSummary = result.issues.map((issue) => `${issue.family}:${issue.code}: ${issue.message}`).join("; ");
-  return `${identity} readiness failed${result.readinessProfile ? ` (${result.readinessProfile})` : ""}: ${issueSummary}`;
-}
-function formatSupportedReadinessProfiles() {
-  return SYSTEM_INTERFACE_PROFILES.map((p) => `"${p.readinessProfile}"`).join(", ");
-}
-function throwIfInterfaceNotReady(result) {
-  if (result.ready) return;
-  throw new SystemInterfaceReadinessError(result);
-}
-function getActiveScopedResources(model, resourceIds, issues, context) {
-  const resources = [];
-  for (const [index, resourceId] of resourceIds.entries()) {
-    const resource = model.resources?.[resourceId];
-    const path = `${readinessMarkerPath(context)}.resourceIds.${index}`;
-    if (resource === void 0) {
-      addReadinessIssue(
-        issues,
-        "SYSTEM_INTERFACE_NOT_READY",
-        "missing-resource",
-        `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" scopes missing resource "${resourceId}".`,
-        { path, ref: resourceId }
-      );
-      continue;
-    }
-    if (resource.systemPath !== context.systemPath) {
-      addReadinessIssue(
-        issues,
-        "SYSTEM_INTERFACE_INVALID",
-        "resource-system-mismatch",
-        `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" scopes resource "${resourceId}" from system "${resource.systemPath}".`,
-        { path, ref: resourceId }
-      );
-      continue;
-    }
-    if (resource.status !== "active") {
-      addReadinessIssue(
-        issues,
-        "SYSTEM_INTERFACE_NOT_READY",
-        "inactive-resource",
-        `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" scopes inactive resource "${resourceId}".`,
-        { path, ref: resourceId }
-      );
-      continue;
-    }
-    resources.push(resource);
-  }
-  return resources;
-}
-function resourceBindingIds(resources, key) {
-  return new Set(resources.flatMap((resource) => resource.ontology?.[key] ?? []));
-}
-function requireScopedBinding(issues, boundIds, bindingKey, ontologyId, context) {
-  if (boundIds.has(ontologyId)) return;
-  addReadinessIssue(
-    issues,
-    "SYSTEM_INTERFACE_NOT_READY",
-    "missing-resource-binding",
-    `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" has no active scoped resource with ontology.${bindingKey} binding "${ontologyId}".`,
-    { path: `${readinessMarkerPath(context)}.resourceIds`, ref: ontologyId }
-  );
-}
-function ontologyOwnerMatches(ontologyId, expectedSystemPath, catalog) {
-  if (catalog?.ownerSystemId !== void 0) return catalog.ownerSystemId === expectedSystemPath;
-  return parseOntologyId(ontologyId).scope === expectedSystemPath;
-}
-function requireObjectReadiness(issues, index, objectId, context) {
-  const object = index.ontology.objectTypes[objectId];
-  if (object === void 0) {
-    addReadinessIssue(
-      issues,
-      "SYSTEM_INTERFACE_NOT_READY",
-      "missing-object",
-      `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" is missing required object type "${objectId}".`,
-      { ref: objectId }
-    );
-    return;
-  }
-  const ownerSystemId = object.ownerSystemId ?? parseOntologyId(objectId).scope;
-  if (ownerSystemId !== context.systemPath) {
-    addReadinessIssue(
-      issues,
-      "SYSTEM_INTERFACE_INVALID",
-      "foreign-object",
-      `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" requires object "${objectId}" owned by "${ownerSystemId}".`,
-      { ref: objectId }
-    );
-  }
-}
-function requireCatalogReadiness(issues, index, catalogId, context) {
-  const catalog = index.ontology.catalogTypes[catalogId];
-  if (catalog === void 0) {
-    addReadinessIssue(
-      issues,
-      "SYSTEM_INTERFACE_NOT_READY",
-      "missing-catalog",
-      `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" is missing required catalog "${catalogId}".`,
-      { ref: catalogId }
-    );
-    return void 0;
-  }
-  if (context.allowForeignOwner !== true && !ontologyOwnerMatches(catalogId, context.systemPath, catalog)) {
-    addReadinessIssue(
-      issues,
-      "SYSTEM_INTERFACE_INVALID",
-      "foreign-catalog",
-      `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" requires catalog "${catalogId}" owned by "${catalog.ownerSystemId ?? parseOntologyId(catalogId).scope}".`,
-      { ref: catalogId }
-    );
-  }
-  if (Object.keys(getCatalogEntries(catalog)).length === 0) {
-    addReadinessIssue(
-      issues,
-      "SYSTEM_INTERFACE_NOT_READY",
-      "empty-catalog",
-      `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" requires catalog entries for "${catalogId}".`,
-      { ref: catalogId }
-    );
-  }
-  return catalog;
-}
-function requireLeadGenInterfaceReadiness(issues, index, resources, context) {
-  const reads = resourceBindingIds(resources, "reads");
-  const catalogs = resourceBindingIds(resources, "usesCatalogs");
-  for (const objectId of [
-    LEAD_GEN_LIST_OBJECT_ONTOLOGY_ID,
-    LEAD_GEN_COMPANY_OBJECT_ONTOLOGY_ID,
-    LEAD_GEN_CONTACT_OBJECT_ONTOLOGY_ID
-  ]) {
-    requireObjectReadiness(issues, index, objectId, context);
-    requireScopedBinding(issues, reads, "reads", objectId, context);
-  }
-  for (const catalogId of [
-    LEAD_GEN_BUILD_TEMPLATE_CATALOG_ONTOLOGY_ID,
-    LEAD_GEN_COMPANY_STAGE_CATALOG_ONTOLOGY_ID,
-    LEAD_GEN_CONTACT_STAGE_CATALOG_ONTOLOGY_ID
-  ]) {
-    requireCatalogReadiness(issues, index, catalogId, context);
-    requireScopedBinding(issues, catalogs, "usesCatalogs", catalogId, context);
-  }
-  const templateStepCatalog = findLeadGenTemplateStepCatalog(index);
-  if (templateStepCatalog === void 0) {
-    addReadinessIssue(
-      issues,
-      "SYSTEM_INTERFACE_NOT_READY",
-      "missing-template-step-catalog",
-      `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" is missing a lead-gen template-step catalog.`
-    );
-  } else {
-    requireCatalogReadiness(issues, index, templateStepCatalog.id, context);
-    requireScopedBinding(issues, catalogs, "usesCatalogs", templateStepCatalog.id, context);
-  }
-  const leadGenStageCatalog = requireCatalogReadiness(issues, index, LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID, context);
-  return leadGenStageCatalog;
-}
-function requireCrmInterfaceReadiness(issues, index, resources, context) {
-  const catalogs = resourceBindingIds(resources, "usesCatalogs");
-  const crmPipelineCatalog = requireCatalogReadiness(issues, index, CRM_PIPELINE_CATALOG_ONTOLOGY_ID, context);
-  requireScopedBinding(issues, catalogs, "usesCatalogs", CRM_PIPELINE_CATALOG_ONTOLOGY_ID, context);
-  return crmPipelineCatalog;
-}
-function findSystemInterfaceGrant(model, consumer, provider) {
-  return Object.values(model.topology?.relationships ?? {}).find((relationship) => {
-    const grant = relationship.metadata?.["systemInterfaceGrant"];
-    if (!isPlainRecord(grant) || !isPlainRecord(grant.consumer) || !isPlainRecord(grant.provider)) return false;
-    return grant.consumer.systemPath === consumer.systemPath && grant.consumer.interfaceKey === consumer.interfaceKey && grant.provider.systemPath === provider.systemPath && grant.provider.interfaceKey === provider.interfaceKey;
-  });
-}
-function requireHandoffBridgeReadiness(issues, model, context) {
-  const crmResult = computeInterfaceReadiness(model, CRM_API_INTERFACE);
-  if (!crmResult.ready) {
-    for (const issue of crmResult.issues) {
-      addReadinessIssue(
-        issues,
-        "SYSTEM_BRIDGE_NOT_READY",
-        issue.code,
-        `Provider interface ${formatInterfaceIdentity(CRM_API_INTERFACE.systemPath, CRM_API_INTERFACE.interfaceKey)} is not ready: ${issue.message}`,
-        { path: issue.path, ref: issue.ref }
-      );
-    }
-  }
-  const bridgeGrant = findSystemInterfaceGrant(model, context, CRM_API_INTERFACE);
-  if (bridgeGrant === void 0) {
-    addReadinessIssue(
-      issues,
-      "SYSTEM_BRIDGE_NOT_READY",
-      "missing-topology-grant",
-      `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" requires a scoped topology grant to "${formatInterfaceIdentity(CRM_API_INTERFACE.systemPath, CRM_API_INTERFACE.interfaceKey)}".`
-    );
-  }
-  return bridgeGrant;
-}
-function getLeadGenCrmHandoffResourceIds(model) {
-  return Object.values(model.resources ?? {}).filter(
-    (resource) => resource.systemPath === LEAD_GEN_CRM_HANDOFF_INTERFACE.systemPath && resource.ontology?.usesCatalogs?.includes(CRM_PIPELINE_CATALOG_ONTOLOGY_ID) === true
-  ).map((resource) => resource.id);
-}
-function getSystemInterfaceReadinessMarker(model, request) {
-  const system = getSystem(model, request.systemPath);
-  if (system === void 0) return void 0;
-  if (request.systemPath === LEAD_GEN_CRM_HANDOFF_INTERFACE.systemPath && request.interfaceKey === LEAD_GEN_CRM_HANDOFF_INTERFACE.interfaceKey) {
-    return {
-      lifecycle: "active",
-      readinessProfile: LEAD_GEN_CRM_HANDOFF_INTERFACE.readinessProfile,
-      resourceIds: getLeadGenCrmHandoffResourceIds(model)
-    };
-  }
-  if (request.interfaceKey === "api" && system.apiInterface !== void 0) {
-    return system.apiInterface;
-  }
-  return void 0;
-}
-function mergeLeadGenDerivedCatalogs(model) {
-  const baseCatalogTypes = model.ontology?.catalogTypes ?? {};
-  const derivedCatalogTypes = {};
-  if (baseCatalogTypes[LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID] === void 0) {
-    derivedCatalogTypes[LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID] = createLeadGenStageCatalog(model);
-  }
-  if (Object.keys(derivedCatalogTypes).length === 0) return model;
-  return {
-    ...model,
-    ontology: {
-      ...model.ontology ?? {},
-      catalogTypes: {
-        ...baseCatalogTypes,
-        ...derivedCatalogTypes
-      }
-    }
-  };
-}
-function compileBusinessOntology(model, contractId) {
-  const compilation = compileOrganizationOntology(mergeLeadGenDerivedCatalogs(model));
-  if (compilation.diagnostics.length > 0) {
-    const summary = compilation.diagnostics.map((diagnostic) => diagnostic.message).join("; ");
-    throw new Error(`${contractId} ontology validation index failed to compile: ${summary}`);
-  }
-  return {
-    ontology: compilation.ontology,
-    actionTypesByLegacyId: indexActionTypesByLegacyId(compilation.ontology.actionTypes)
-  };
-}
-function tryCompileBusinessOntology(model, readinessProfile, issues) {
-  try {
-    return compileBusinessOntology(model, readinessProfile);
-  } catch (error) {
-    addReadinessIssue(
-      issues,
-      "SYSTEM_INTERFACE_INVALID",
-      "ontology-compile-failed",
-      error instanceof Error ? error.message : String(error)
-    );
-    return void 0;
-  }
-}
-function requireContractReadiness(issues, index, resources, contract, context) {
-  const reads = resourceBindingIds(resources, "reads");
-  const catalogs = resourceBindingIds(resources, "usesCatalogs");
-  for (const objectId of contract.requiredObjects) {
-    requireObjectReadiness(issues, index, objectId, context);
-    requireScopedBinding(issues, reads, "reads", objectId, context);
-  }
-  for (const catalogId of contract.requiredCatalogs) {
-    requireCatalogReadiness(issues, index, catalogId, context);
-    requireScopedBinding(issues, catalogs, "usesCatalogs", catalogId, context);
-  }
-}
-function computeInterfaceReadiness(model, request) {
-  const issues = [];
-  const system = getSystem(model, request.systemPath);
-  const systemInterface = getSystemInterfaceReadinessMarker(model, request);
-  const readinessProfile = systemInterface === void 0 ? void 0 : profileForInterface(request.systemPath, request.interfaceKey, systemInterface.readinessProfile);
-  const scopedResourceIds = systemInterface?.resourceIds ?? [];
-  if (system === void 0) {
-    addReadinessIssue(
-      issues,
-      "SYSTEM_INTERFACE_MISSING",
-      "missing-system",
-      `System "${request.systemPath}" is missing.`,
-      { ref: request.systemPath }
-    );
-    return {
-      ready: false,
-      systemPath: request.systemPath,
-      interfaceKey: request.interfaceKey,
-      scopedResourceIds,
-      issues
-    };
-  }
-  if (systemInterface === void 0) {
-    addReadinessIssue(
-      issues,
-      "SYSTEM_INTERFACE_MISSING",
-      "missing-interface",
-      `System "${request.systemPath}" does not declare interface "${request.interfaceKey}".`,
-      { path: readinessMarkerPath(request) }
-    );
-    return {
-      ready: false,
-      systemPath: request.systemPath,
-      interfaceKey: request.interfaceKey,
-      scopedResourceIds,
-      issues
-    };
-  }
-  if (systemInterface.lifecycle !== "active") {
-    addReadinessIssue(
-      issues,
-      "SYSTEM_INTERFACE_DISABLED",
-      "inactive-interface",
-      `System Interface "${formatInterfaceIdentity(request.systemPath, request.interfaceKey)}" lifecycle is "${systemInterface.lifecycle}".`,
-      { path: `${readinessMarkerPath(request)}.lifecycle` }
-    );
-  }
-  const checkedReadinessProfile = readinessProfile ?? profileForInterface(request.systemPath, request.interfaceKey);
-  const isBuiltIn = isBuiltInReadinessProfile(checkedReadinessProfile);
-  const readinessContract = systemInterface.readinessContract;
-  if (!isBuiltIn && readinessContract === void 0) {
-    addReadinessIssue(
-      issues,
-      "SYSTEM_INTERFACE_INVALID",
-      "missing-readiness-contract",
-      `System Interface "${formatInterfaceIdentity(request.systemPath, request.interfaceKey)}" uses custom readiness profile "${checkedReadinessProfile}" but declares no readinessContract. Built-in profiles: ${formatSupportedReadinessProfiles()}.`,
-      { path: `${readinessMarkerPath(request)}.readinessContract`, ref: checkedReadinessProfile }
-    );
-    return {
-      ready: false,
-      systemPath: request.systemPath,
-      interfaceKey: request.interfaceKey,
-      readinessProfile: checkedReadinessProfile,
-      scopedResourceIds,
-      issues
-    };
-  }
-  if (scopedResourceIds.length === 0) {
-    addReadinessIssue(
-      issues,
-      "SYSTEM_INTERFACE_NOT_READY",
-      "missing-scoped-resources",
-      `System Interface "${formatInterfaceIdentity(request.systemPath, request.interfaceKey)}" must scope at least one active resource.`,
-      { path: `${readinessMarkerPath(request)}.resourceIds` }
-    );
-  }
-  const resources = getActiveScopedResources(model, scopedResourceIds, issues, request);
-  const index = tryCompileBusinessOntology(model, checkedReadinessProfile, issues);
-  if (index !== void 0) {
-    if (checkedReadinessProfile === LEAD_GEN_API_INTERFACE.readinessProfile) {
-      requireLeadGenInterfaceReadiness(issues, index, resources, request);
-    } else if (checkedReadinessProfile === CRM_API_INTERFACE.readinessProfile) {
-      requireCrmInterfaceReadiness(issues, index, resources, request);
-    } else if (checkedReadinessProfile === LEAD_GEN_CRM_HANDOFF_INTERFACE.readinessProfile) {
-      requireLeadGenInterfaceReadiness(issues, index, resources, request);
-      requireCrmInterfaceReadiness(issues, index, resources, { ...request, allowForeignOwner: true });
-      requireHandoffBridgeReadiness(issues, model, request);
-    } else if (readinessContract !== void 0) {
-      requireContractReadiness(issues, index, resources, readinessContract, request);
-    }
-  }
-  return {
-    ready: issues.length === 0,
-    systemPath: request.systemPath,
-    interfaceKey: request.interfaceKey,
-    readinessProfile: checkedReadinessProfile,
-    scopedResourceIds,
-    issues
-  };
-}
-function requireObjectType(index, objectId, contractId) {
-  if (index.ontology.objectTypes[objectId] === void 0) {
-    throw new Error(`${contractId} is missing required object type: ${objectId}`);
-  }
-}
-function requireCatalog(index, catalogId, contractId) {
-  const catalog = index.ontology.catalogTypes[catalogId];
-  if (catalog === void 0) {
-    throw new Error(`${contractId} is missing required catalog: ${catalogId}`);
-  }
-  return catalog;
-}
-function requireCatalogEntries(catalog, contractId) {
-  if (Object.keys(getCatalogEntries(catalog)).length === 0) {
-    throw new Error(`${contractId} requires catalog entries for ${catalog.id}`);
-  }
-}
-function findLeadGenTemplateStepCatalog(index) {
-  return Object.values(index.ontology.catalogTypes).find(
-    (catalog) => catalog.ownerSystemId === "sales.lead-gen" && catalog.kind === "template-step" && catalog.appliesTo === LEAD_GEN_LIST_OBJECT_ONTOLOGY_ID
-  );
-}
-function requireLeadGenApiReadiness(index) {
-  requireObjectType(index, LEAD_GEN_LIST_OBJECT_ONTOLOGY_ID, LEAD_GEN_API_READINESS_LABEL);
-  requireObjectType(index, LEAD_GEN_COMPANY_OBJECT_ONTOLOGY_ID, LEAD_GEN_API_READINESS_LABEL);
-  requireObjectType(index, LEAD_GEN_CONTACT_OBJECT_ONTOLOGY_ID, LEAD_GEN_API_READINESS_LABEL);
-  requireCatalogEntries(
-    requireCatalog(index, LEAD_GEN_BUILD_TEMPLATE_CATALOG_ONTOLOGY_ID, LEAD_GEN_API_READINESS_LABEL),
-    LEAD_GEN_API_READINESS_LABEL
-  );
-  requireCatalogEntries(
-    requireCatalog(index, LEAD_GEN_COMPANY_STAGE_CATALOG_ONTOLOGY_ID, LEAD_GEN_API_READINESS_LABEL),
-    LEAD_GEN_API_READINESS_LABEL
-  );
-  requireCatalogEntries(
-    requireCatalog(index, LEAD_GEN_CONTACT_STAGE_CATALOG_ONTOLOGY_ID, LEAD_GEN_API_READINESS_LABEL),
-    LEAD_GEN_API_READINESS_LABEL
-  );
-  const templateStepCatalog = findLeadGenTemplateStepCatalog(index);
-  if (templateStepCatalog === void 0) {
-    throw new Error(`${LEAD_GEN_API_READINESS_LABEL} is missing a lead-gen template-step catalog`);
-  }
-  requireCatalogEntries(templateStepCatalog, LEAD_GEN_API_READINESS_LABEL);
-  const leadGenStageCatalog = requireCatalog(index, LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID, LEAD_GEN_API_READINESS_LABEL);
-  requireCatalogEntries(leadGenStageCatalog, LEAD_GEN_API_READINESS_LABEL);
-  return leadGenStageCatalog;
-}
-function requireCrmApiReadiness(index) {
-  const crmPipelineCatalog = requireCatalog(index, CRM_PIPELINE_CATALOG_ONTOLOGY_ID, CRM_API_READINESS_LABEL);
-  requireCatalogEntries(crmPipelineCatalog, CRM_API_READINESS_LABEL);
-  return crmPipelineCatalog;
-}
-function compileBusinessOntologyValidationIndex(model) {
-  throwIfInterfaceNotReady(computeInterfaceReadiness(model, LEAD_GEN_API_INTERFACE));
-  throwIfInterfaceNotReady(computeInterfaceReadiness(model, CRM_API_INTERFACE));
-  const index = compileBusinessOntology(model, "legacy acquisition business ontology");
-  return {
-    ...index,
-    leadGenStageCatalog: requireLeadGenApiReadiness(index),
-    crmPipelineCatalog: requireCrmApiReadiness(index)
-  };
-}
-function indexActionTypesByLegacyId(actionTypes) {
-  const byLegacyId = {};
-  for (const actionType of Object.values(actionTypes)) {
-    const legacyActionId = actionType["legacyActionId"];
-    if (typeof legacyActionId === "string") {
-      byLegacyId[legacyActionId] = actionType;
-    }
-  }
-  return byLegacyId;
-}
-function getCatalogEntries(catalog) {
-  return isPlainRecord(catalog.entries) ? catalog.entries : {};
-}
-function asLeadGenStageEntry(key, value) {
-  const record = isPlainRecord(value) ? value : {};
-  const entity = record.entity === "contact" ? "contact" : "company";
-  const additionalEntities = Array.isArray(record.additionalEntities) ? record.additionalEntities.filter(
-    (item) => item === "company" || item === "contact"
-  ) : void 0;
-  const recordEntity = record.recordEntity === "company" || record.recordEntity === "contact" ? record.recordEntity : void 0;
-  const recordStageKey = typeof record.recordStageKey === "string" ? record.recordStageKey : void 0;
-  return {
-    key: typeof record.key === "string" ? record.key : key,
-    label: typeof record.label === "string" ? record.label : key,
-    description: typeof record.description === "string" ? record.description : "",
-    order: typeof record.order === "number" ? record.order : 0,
-    entity,
-    ...additionalEntities !== void 0 ? { additionalEntities } : {},
-    ...recordEntity !== void 0 ? { recordEntity } : {},
-    ...recordStageKey !== void 0 ? { recordStageKey } : {}
-  };
-}
-function createLeadGenStageValidators(index) {
-  const getCatalog = () => Object.fromEntries(
-    Object.entries(getCatalogEntries(index.leadGenStageCatalog)).map(([key, value]) => [
-      key,
-      asLeadGenStageEntry(key, value)
-    ])
-  );
-  const getEntry = (stageKey) => getCatalog()[stageKey];
-  return {
-    getLeadGenStageCatalog: getCatalog,
-    getLeadGenStageEntry: getEntry,
-    isLeadGenStageKey: (stageKey) => getEntry(stageKey) !== void 0,
-    isLeadGenStageValidForEntity: (stageKey, entity) => {
-      const stage = getEntry(stageKey);
-      return stage !== void 0 && (stage.entity === entity || stage.additionalEntities?.includes(entity) === true);
-    },
-    isLeadGenRecordStageValidForEntity: (stageKey, entity) => {
-      const stage = getEntry(stageKey);
-      return stage !== void 0 && (stage.entity === entity || stage.additionalEntities?.includes(entity) === true || stage.recordEntity === entity);
-    },
-    resolveLeadGenRecordStageKey: (stageKey, entity) => {
-      const stage = getEntry(stageKey);
-      return stage?.recordEntity === entity && stage.recordStageKey ? stage.recordStageKey : stageKey;
-    }
+    type: "object",
+    properties,
+    required: capabilities.message === "required" ? ["nextActions", "message", "reasoning"] : ["nextActions", "reasoning"],
+    additionalProperties: false
   };
 }
 
@@ -5023,7 +4783,6 @@ function validateDeclaredSystemInterfaceReadiness(orgName, organizationModel) {
           message: `System Interface "${path}/${interfaceKey}" references unknown readiness profile "${readinessProfile}".`
         });
       }
-      continue;
     }
     const result = computeInterfaceReadiness(model, { systemPath: path, interfaceKey });
     for (const issue of result.issues) {
@@ -7380,6 +7139,297 @@ function deriveActions(deal, actions = []) {
   return actions.filter((a) => a.isAvailableFor(deal)).map(({ key, label, payloadSchema }) => ({ key, label, payloadSchema }));
 }
 
+// ../core/src/business/acquisition/ontology-validation.ts
+var LEAD_GEN_API_INTERFACE = SYSTEM_INTERFACE_PROFILES[0];
+var CRM_API_INTERFACE = SYSTEM_INTERFACE_PROFILES[1];
+var LEAD_GEN_CRM_HANDOFF_INTERFACE = SYSTEM_INTERFACE_PROFILES[2];
+LEAD_GEN_API_INTERFACE.readinessProfile;
+CRM_API_INTERFACE.readinessProfile;
+LEAD_GEN_CRM_HANDOFF_INTERFACE.readinessProfile;
+var LEAD_GEN_LIST_OBJECT_ONTOLOGY_ID = formatOntologyId({
+  scope: "sales.lead-gen",
+  kind: "object",
+  localId: "list"
+});
+var LEAD_GEN_COMPANY_OBJECT_ONTOLOGY_ID = formatOntologyId({
+  scope: "sales.lead-gen",
+  kind: "object",
+  localId: "company"
+});
+var LEAD_GEN_CONTACT_OBJECT_ONTOLOGY_ID = formatOntologyId({
+  scope: "sales.lead-gen",
+  kind: "object",
+  localId: "contact"
+});
+var LEAD_GEN_BUILD_TEMPLATE_CATALOG_ONTOLOGY_ID = formatOntologyId({
+  scope: "sales.lead-gen",
+  kind: "catalog",
+  localId: "build-template"
+});
+var LEAD_GEN_COMPANY_STAGE_CATALOG_ONTOLOGY_ID = formatOntologyId({
+  scope: "sales.lead-gen",
+  kind: "catalog",
+  localId: "company-stage"
+});
+var LEAD_GEN_CONTACT_STAGE_CATALOG_ONTOLOGY_ID = formatOntologyId({
+  scope: "sales.lead-gen",
+  kind: "catalog",
+  localId: "contact-stage"
+});
+var CRM_PIPELINE_CATALOG_ONTOLOGY_ID = formatOntologyId({
+  scope: "sales.crm",
+  kind: "catalog",
+  localId: "crm.pipeline"
+});
+var LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID = formatOntologyId({
+  scope: "sales.lead-gen",
+  kind: "catalog",
+  localId: "lead-gen.stage-catalog"
+});
+var LEAD_GEN_API_READINESS_CONTRACT = {
+  requiredObjects: [
+    LEAD_GEN_LIST_OBJECT_ONTOLOGY_ID,
+    LEAD_GEN_COMPANY_OBJECT_ONTOLOGY_ID,
+    LEAD_GEN_CONTACT_OBJECT_ONTOLOGY_ID
+  ],
+  requiredCatalogs: [
+    LEAD_GEN_BUILD_TEMPLATE_CATALOG_ONTOLOGY_ID,
+    LEAD_GEN_COMPANY_STAGE_CATALOG_ONTOLOGY_ID,
+    LEAD_GEN_CONTACT_STAGE_CATALOG_ONTOLOGY_ID
+  ]
+};
+var CRM_API_READINESS_CONTRACT = {
+  requiredObjects: [],
+  requiredCatalogs: [CRM_PIPELINE_CATALOG_ONTOLOGY_ID]
+};
+function isPlainRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function createLeadGenStageCatalog(model) {
+  return {
+    id: LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID,
+    label: "Lead Gen Processing Stages",
+    ownerSystemId: "sales.lead-gen",
+    kind: "processing-stage-catalog",
+    entries: Object.fromEntries(
+      Object.entries(getLeadGenStageCatalog(model)).map(([key, entry]) => [
+        key,
+        {
+          ...entry
+        }
+      ])
+    ),
+    legacyCatalogKey: "LEAD_GEN_STAGE_CATALOG"
+  };
+}
+function throwIfInterfaceNotReady(result) {
+  if (result.ready) return;
+  throw new SystemInterfaceReadinessError(result);
+}
+function requireLeadGenSupplementalReadiness(issues, index, resources, context) {
+  const catalogs = resourceBindingIds(resources, "usesCatalogs");
+  const templateStepCatalog = findLeadGenTemplateStepCatalog(index);
+  if (templateStepCatalog === void 0) {
+    addReadinessIssue(
+      issues,
+      "SYSTEM_INTERFACE_NOT_READY",
+      "missing-template-step-catalog",
+      `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" is missing a lead-gen template-step catalog.`
+    );
+  } else {
+    requireCatalogReadiness(issues, index, templateStepCatalog.id, context);
+    requireScopedBinding(issues, catalogs, "usesCatalogs", templateStepCatalog.id, context);
+  }
+  requireCatalogReadiness(issues, index, LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID, context);
+}
+function requireLeadGenInterfaceReadiness(issues, index, resources, context) {
+  requireContractReadiness(issues, index, resources, LEAD_GEN_API_READINESS_CONTRACT, context);
+  requireLeadGenSupplementalReadiness(issues, index, resources, context);
+}
+function requireCrmInterfaceReadiness(issues, index, resources, context) {
+  requireContractReadiness(issues, index, resources, CRM_API_READINESS_CONTRACT, context);
+}
+function findSystemInterfaceGrant(model, consumer, provider) {
+  return Object.values(model.topology?.relationships ?? {}).find((relationship) => {
+    const grant = relationship.metadata?.["systemInterfaceGrant"];
+    if (!isPlainRecord2(grant) || !isPlainRecord2(grant.consumer) || !isPlainRecord2(grant.provider)) return false;
+    return grant.consumer.systemPath === consumer.systemPath && grant.consumer.interfaceKey === consumer.interfaceKey && grant.provider.systemPath === provider.systemPath && grant.provider.interfaceKey === provider.interfaceKey;
+  });
+}
+function requireHandoffBridgeReadiness(issues, model, context) {
+  const crmResult = computeInterfaceReadiness(model, CRM_API_INTERFACE);
+  if (!crmResult.ready) {
+    for (const issue of crmResult.issues) {
+      addReadinessIssue(
+        issues,
+        "SYSTEM_BRIDGE_NOT_READY",
+        issue.code,
+        `Provider interface ${formatInterfaceIdentity(CRM_API_INTERFACE.systemPath, CRM_API_INTERFACE.interfaceKey)} is not ready: ${issue.message}`,
+        { path: issue.path, ref: issue.ref }
+      );
+    }
+  }
+  const bridgeGrant = findSystemInterfaceGrant(model, context, CRM_API_INTERFACE);
+  if (bridgeGrant === void 0) {
+    addReadinessIssue(
+      issues,
+      "SYSTEM_BRIDGE_NOT_READY",
+      "missing-topology-grant",
+      `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" requires a scoped topology grant to "${formatInterfaceIdentity(CRM_API_INTERFACE.systemPath, CRM_API_INTERFACE.interfaceKey)}".`
+    );
+  }
+  return bridgeGrant;
+}
+function getLeadGenCrmHandoffResourceIds(model) {
+  return Object.values(model.resources ?? {}).filter(
+    (resource) => resource.systemPath === LEAD_GEN_CRM_HANDOFF_INTERFACE.systemPath && resource.ontology?.usesCatalogs?.includes(CRM_PIPELINE_CATALOG_ONTOLOGY_ID) === true
+  ).map((resource) => resource.id);
+}
+function mergeLeadGenDerivedCatalogs(model) {
+  const baseCatalogTypes = model.ontology?.catalogTypes ?? {};
+  const derivedCatalogTypes = {};
+  if (baseCatalogTypes[LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID] === void 0) {
+    derivedCatalogTypes[LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID] = createLeadGenStageCatalog(model);
+  }
+  if (Object.keys(derivedCatalogTypes).length === 0) return model;
+  return {
+    ...model,
+    ontology: {
+      ...model.ontology ?? {},
+      catalogTypes: {
+        ...baseCatalogTypes,
+        ...derivedCatalogTypes
+      }
+    }
+  };
+}
+function compileBusinessOntology(model, contractId, includeLeadGenDerivedCatalogs) {
+  const preparedModel = mergeLeadGenDerivedCatalogs(model) ;
+  const compilation = compileOrganizationOntology(preparedModel);
+  if (compilation.diagnostics.length > 0) {
+    const summary = compilation.diagnostics.map((diagnostic) => diagnostic.message).join("; ");
+    throw new Error(`${contractId} ontology validation index failed to compile: ${summary}`);
+  }
+  return {
+    ontology: compilation.ontology,
+    actionTypesByLegacyId: indexActionTypesByLegacyId(compilation.ontology.actionTypes)
+  };
+}
+registerBuiltInReadinessProfile(LEAD_GEN_API_INTERFACE.readinessProfile, {
+  validate: (issues, index, resources, _model, context) => requireLeadGenInterfaceReadiness(issues, index, resources, context),
+  prepareModel: mergeLeadGenDerivedCatalogs
+});
+registerBuiltInReadinessProfile(CRM_API_INTERFACE.readinessProfile, {
+  validate: (issues, index, resources, _model, context) => requireCrmInterfaceReadiness(issues, index, resources, context)
+});
+registerBuiltInReadinessProfile(LEAD_GEN_CRM_HANDOFF_INTERFACE.readinessProfile, {
+  validate: (issues, index, resources, model, context) => {
+    requireLeadGenInterfaceReadiness(issues, index, resources, context);
+    requireCrmInterfaceReadiness(issues, index, resources, { ...context, allowForeignOwner: true });
+    requireHandoffBridgeReadiness(issues, model, context);
+  },
+  prepareModel: mergeLeadGenDerivedCatalogs
+});
+registerReadinessInterfaceMarker(
+  LEAD_GEN_CRM_HANDOFF_INTERFACE.systemPath,
+  LEAD_GEN_CRM_HANDOFF_INTERFACE.interfaceKey,
+  (model) => ({
+    lifecycle: "active",
+    readinessProfile: LEAD_GEN_CRM_HANDOFF_INTERFACE.readinessProfile,
+    resourceIds: getLeadGenCrmHandoffResourceIds(model)
+  })
+);
+function findLeadGenTemplateStepCatalog(index) {
+  return Object.values(index.ontology.catalogTypes).find(
+    (catalog) => catalog.ownerSystemId === "sales.lead-gen" && catalog.kind === "template-step" && catalog.appliesTo === LEAD_GEN_LIST_OBJECT_ONTOLOGY_ID
+  );
+}
+function requireReadyCatalog(index, catalogId, readinessLabel) {
+  const catalog = index.ontology.catalogTypes[catalogId];
+  if (catalog === void 0) {
+    throw new Error(
+      `${readinessLabel} readiness passed but catalog "${catalogId}" is unexpectedly absent from the compiled ontology.`
+    );
+  }
+  return catalog;
+}
+function compileBusinessOntologyValidationIndex(model) {
+  throwIfInterfaceNotReady(computeInterfaceReadiness(model, LEAD_GEN_API_INTERFACE));
+  throwIfInterfaceNotReady(computeInterfaceReadiness(model, CRM_API_INTERFACE));
+  const index = compileBusinessOntology(model, "legacy acquisition business ontology");
+  return {
+    ...index,
+    leadGenStageCatalog: requireReadyCatalog(
+      index,
+      LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID,
+      "legacy acquisition business ontology"
+    ),
+    crmPipelineCatalog: requireReadyCatalog(
+      index,
+      CRM_PIPELINE_CATALOG_ONTOLOGY_ID,
+      "legacy acquisition business ontology"
+    )
+  };
+}
+function indexActionTypesByLegacyId(actionTypes) {
+  const byLegacyId = {};
+  for (const actionType of Object.values(actionTypes)) {
+    const legacyActionId = actionType["legacyActionId"];
+    if (typeof legacyActionId === "string") {
+      byLegacyId[legacyActionId] = actionType;
+    }
+  }
+  return byLegacyId;
+}
+function getCatalogEntries2(catalog) {
+  return isPlainRecord2(catalog.entries) ? catalog.entries : {};
+}
+function asLeadGenStageEntry(key, value) {
+  const record = isPlainRecord2(value) ? value : {};
+  const entity = record.entity === "contact" ? "contact" : "company";
+  const additionalEntities = Array.isArray(record.additionalEntities) ? record.additionalEntities.filter(
+    (item) => item === "company" || item === "contact"
+  ) : void 0;
+  const recordEntity = record.recordEntity === "company" || record.recordEntity === "contact" ? record.recordEntity : void 0;
+  const recordStageKey = typeof record.recordStageKey === "string" ? record.recordStageKey : void 0;
+  return {
+    key: typeof record.key === "string" ? record.key : key,
+    label: typeof record.label === "string" ? record.label : key,
+    description: typeof record.description === "string" ? record.description : "",
+    order: typeof record.order === "number" ? record.order : 0,
+    entity,
+    ...additionalEntities !== void 0 ? { additionalEntities } : {},
+    ...recordEntity !== void 0 ? { recordEntity } : {},
+    ...recordStageKey !== void 0 ? { recordStageKey } : {}
+  };
+}
+function createLeadGenStageValidators(index) {
+  const getCatalog = () => Object.fromEntries(
+    Object.entries(getCatalogEntries2(index.leadGenStageCatalog)).map(([key, value]) => [
+      key,
+      asLeadGenStageEntry(key, value)
+    ])
+  );
+  const getEntry = (stageKey) => getCatalog()[stageKey];
+  return {
+    getLeadGenStageCatalog: getCatalog,
+    getLeadGenStageEntry: getEntry,
+    isLeadGenStageKey: (stageKey) => getEntry(stageKey) !== void 0,
+    isLeadGenStageValidForEntity: (stageKey, entity) => {
+      const stage = getEntry(stageKey);
+      return stage !== void 0 && (stage.entity === entity || stage.additionalEntities?.includes(entity) === true);
+    },
+    isLeadGenRecordStageValidForEntity: (stageKey, entity) => {
+      const stage = getEntry(stageKey);
+      return stage !== void 0 && (stage.entity === entity || stage.additionalEntities?.includes(entity) === true || stage.recordEntity === entity);
+    },
+    resolveLeadGenRecordStageKey: (stageKey, entity) => {
+      const stage = getEntry(stageKey);
+      return stage?.recordEntity === entity && stage.recordStageKey ? stage.recordStageKey : stageKey;
+    }
+  };
+}
+
 // src/project-deployment-spec.ts
 function toSdkResourceDescriptor(resource, getResourceOntologyBinding) {
   const ontologyBinding = getResourceOntologyBinding?.(resource.id);
@@ -7528,4 +7578,4 @@ function defineWorkflowConfig(resourceId, descriptors, actionRegistry = []) {
 }
 var ListBuilderStageKeySchema = z.string().min(1);
 
-export { ActivityEventSchema, BuildPlanSnapshotStepSchema, ProspectingBuildTemplateSchema as BuildTemplateSchema, ContractRefResolutionError, CrmStageKeySchema, CrmStateKeySchema, EmailSchema, ExecutionError, ListBuilderStageKeySchema, ProcessingStageStatusSchema, RegistryValidationError, ResourceRegistry, StepType, ToolingError, bindResourceDescriptor, compileBusinessOntologyValidationIndex, concurrentPool, createLeadGenStageValidators, defineContract, defineResource, defineResourceOntology, defineResources, defineStep, defineTopology, defineTopologyRelationship, defineWorkflow, defineWorkflowConfig, deriveActions, diagnosticOutput, integrationInput, isBuiltInReadinessProfile, isZodType, lookupReadinessProfile, parseTopologyNodeRef, profileForInterface, projectDeploymentSpec, projectTopologyRelationships, registerReadinessProfile, resolveContractRef, runDiagnostic, splitName, toSdkResourceDescriptor, topologyRef, topologyRelationship, validateDeclaredSystemInterfaceReadiness, validateResourceGovernance, withPlatformAgentResourceDescriptor, withPlatformAgentResourceDescriptors, withPlatformIntegrationResourceDescriptor, withPlatformIntegrationResourceDescriptors, withPlatformResourceDescriptor, withPlatformResourceDescriptors };
+export { ActivityEventSchema, BuildPlanSnapshotStepSchema, ProspectingBuildTemplateSchema as BuildTemplateSchema, ContractRefResolutionError, CrmStageKeySchema, CrmStateKeySchema, EmailSchema, ExecutionError, ListBuilderStageKeySchema, ProcessingStageStatusSchema, RegistryValidationError, ResourceRegistry, StepType, ToolingError, bindResourceDescriptor, compileBusinessOntologyValidationIndex, concurrentPool, createLeadGenStageValidators, defineContract, defineResource, defineResourceOntology, defineResources, defineStep, defineTopology, defineTopologyRelationship, defineWorkflow, defineWorkflowConfig, deriveActions, diagnosticOutput, integrationInput, isBuiltInReadinessProfile, isZodType, lookupReadinessProfile, parseTopologyNodeRef, projectDeploymentSpec, projectTopologyRelationships, registerReadinessProfile, resolveContractRef, runDiagnostic, splitName, toSdkResourceDescriptor, topologyRef, topologyRelationship, validateDeclaredSystemInterfaceReadiness, validateResourceGovernance, withPlatformAgentResourceDescriptor, withPlatformAgentResourceDescriptors, withPlatformIntegrationResourceDescriptor, withPlatformIntegrationResourceDescriptors, withPlatformResourceDescriptor, withPlatformResourceDescriptors };