@elevasis/sdk 1.44.3 → 1.46.0

package/dist/index.js

@@ -576,10 +576,28 @@ z.record(z.string(), ActionSchema).refine((record) => Object.entries(record).eve
   message: "Each action entry id must match its map key"
 }).default({});
 
+// ../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/domains/systems.ts
 var SystemKindSchema = z.enum(["product", "operational", "platform", "diagnostic"]).meta({ label: "System kind", color: "blue" });
 var SystemLifecycleSchema = z.enum(["draft", "beta", "active", "deprecated", "archived"]).meta({ label: "Lifecycle", color: "teal" });
-var SystemStatusSchema = z.enum(["active", "deprecated", "archived"]).meta({ label: "Status", color: "teal" });
 var SystemIdSchema = ModelIdSchema;
 var SystemPathSchema = z.string().trim().min(1).regex(
   /^[a-z0-9][a-z0-9-]*(?:\.[a-z0-9][a-z0-9-]*)*$/,
@@ -593,8 +611,7 @@ z.string().trim().min(1).max(200).regex(
 var SystemUiSchema = z.object({
   path: PathSchema,
   surfaces: ReferenceIdsSchema,
-  icon: IconNameSchema.optional(),
-  order: z.number().int().optional()
+  icon: IconNameSchema.optional()
 });
 var SystemInterfaceKeySchema = ModelIdSchema;
 var SystemInterfaceLifecycleSchema = z.enum(["draft", "active", "disabled", "deprecated", "archived"]).meta({ label: "System interface lifecycle", color: "teal" });
@@ -623,17 +640,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(),
   /**
@@ -648,27 +671,25 @@ var SystemApiInterfaceSchema = z.object({
    */
   readinessContract: SystemApiInterfaceReadinessContractSchema.optional()
 }).strict();
-var _profileRegistry = new Map(
-  SYSTEM_INTERFACE_READINESS_PROFILES.map((profileId) => [
-    profileId,
-    { profileId, kind: "built-in" }
-  ])
-);
+var _customProfileIds = /* @__PURE__ */ new Set();
+function isReservedPlatformProfileId(profileId) {
+  return SYSTEM_INTERFACE_READINESS_PROFILES.includes(profileId);
+}
 function lookupReadinessProfile(profileId) {
-  return _profileRegistry.get(profileId);
+  if (isReservedPlatformProfileId(profileId) || getBuiltInReadinessProfile(profileId) !== void 0) {
+    return { profileId, kind: "built-in" };
+  }
+  if (_customProfileIds.has(profileId)) return { profileId, kind: "custom" };
+  return void 0;
 }
 function registerReadinessProfile(profileId) {
-  const existing = _profileRegistry.get(profileId);
+  const existing = lookupReadinessProfile(profileId);
   if (existing !== void 0) return existing;
-  const entry = { profileId, kind: "custom" };
-  _profileRegistry.set(profileId, entry);
-  return entry;
-}
-function profileForInterface(systemPath, interfaceKey, readinessProfile) {
-  return readinessProfile ?? `${systemPath}.${interfaceKey}`;
+  _customProfileIds.add(profileId);
+  return { profileId, kind: "custom" };
 }
 function isBuiltInReadinessProfile(profileId) {
-  return _profileRegistry.get(profileId)?.kind === "built-in";
+  return isReservedPlatformProfileId(profileId) || getBuiltInReadinessProfile(profileId) !== void 0;
 }
 var SystemInterfaceRefSchema = z.object({
   systemPath: SystemPathSchema,
@@ -700,7 +721,7 @@ var SystemEntrySchema = z.object({
   parentSystemId: SystemIdSchema.optional(),
   /** Optional UI presence. Systems without UI omit this. */
   ui: SystemUiSchema.optional(),
-  /** Canonical lifecycle state. Replaces Feature.enabled/devOnly and System.status. */
+  /** Canonical lifecycle state. `beta` is what gates a System to dev-mode viewers. */
   lifecycle: SystemLifecycleSchema.optional(),
   /** Optional role responsible for this system. */
   responsibleRoleId: ModelIdSchema.meta({ ref: "role" }).optional(),
@@ -708,14 +729,10 @@ var SystemEntrySchema = z.object({
   governedByKnowledge: z.array(ModelIdSchema.meta({ ref: "knowledge" })).default([]).optional(),
   /** Optional actions this system exposes or consumes. */
   actions: z.array(ActionRefSchema).optional(),
-  /** Optional operational policies that apply to this system. */
-  policies: z.array(ModelIdSchema.meta({ ref: "policy" })).default([]).optional(),
   /** Optional goals this system contributes to. */
   drivesGoals: z.array(ModelIdSchema.meta({ ref: "goal" })).default([]).optional(),
   /** Thin API runtime-boundary marker. Readiness is derived from scoped resources and topology. */
   apiInterface: SystemApiInterfaceSchema.optional(),
-  /** @deprecated Use lifecycle. Accepted for one publish cycle. */
-  status: SystemStatusSchema.optional(),
   /** @deprecated Use ui.path. Kept for one-cycle Feature compatibility. */
   path: PathSchema.optional(),
   /** @deprecated Use ui.icon. Kept for one-cycle Feature compatibility. */
@@ -724,9 +741,6 @@ var SystemEntrySchema = z.object({
   uiPosition: UiPositionSchema.optional(),
   /** @deprecated Use lifecycle. */
   enabled: z.boolean().optional(),
-  /** @deprecated Use lifecycle: "beta". */
-  devOnly: z.boolean().optional(),
-  requiresAdmin: z.boolean().optional(),
   /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
   order: z.number(),
   /**
@@ -753,12 +767,9 @@ var SystemEntrySchema = z.object({
 }).strict().refine((system) => system.label !== void 0 || system.title !== void 0, {
   path: ["label"],
   message: "System must provide label or title"
-}).transform((system) => {
-  const normalizedSystem = system.systems !== void 0 && system.subsystems === void 0 ? { ...system, subsystems: system.systems } : system;
-  if (normalizedSystem.status === void 0) return normalizedSystem;
-  console.warn("[organization-model] System.status is deprecated; use System.lifecycle instead.");
-  return normalizedSystem.lifecycle === void 0 ? { ...normalizedSystem, lifecycle: normalizedSystem.status } : normalizedSystem;
-});
+}).transform(
+  (system) => system.systems !== void 0 && system.subsystems === void 0 ? { ...system, subsystems: system.systems } : system
+);
 z.record(z.string(), SystemEntrySchema).refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
   message: "Each system entry id must match its map key"
 }).default({});
@@ -933,7 +944,6 @@ var OmTopologyNodeKindSchema = z.enum([
   "system",
   "resource",
   "ontology",
-  "policy",
   "role",
   "trigger",
   "humanCheckpoint",
@@ -944,7 +954,6 @@ 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 }),
@@ -1017,7 +1026,6 @@ var topologyRef = {
   system: (system) => parseRef("system", idFrom(system)),
   resource: (resource) => parseRef("resource", idFrom(resource)),
   ontology: (record) => parseRef("ontology", idFrom(record)),
-  policy: (policy) => parseRef("policy", idFrom(policy)),
   role: (role) => parseRef("role", idFrom(role)),
   trigger: (trigger) => parseRef("trigger", idFrom(trigger)),
   humanCheckpoint: (checkpoint) => parseRef("humanCheckpoint", idFrom(checkpoint)),
@@ -1093,7 +1101,9 @@ function defineTopology(relationships) {
   const entries = Array.isArray(relationships) ? relationships.map((relationship, index) => [`relationship-${index + 1}`, relationship]) : Object.entries(relationships);
   return OmTopologyDomainSchema.parse({
     version: 1,
-    relationships: Object.fromEntries(entries.map(([key, relationship]) => [key, defineTopologyRelationship(relationship)]))
+    relationships: Object.fromEntries(
+      entries.map(([key, relationship]) => [key, defineTopologyRelationship(relationship)])
+    )
   });
 }
 
@@ -1130,6 +1140,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,100 +1225,425 @@ 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/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);
   }
-  const exportValue = moduleNamespace[parsed.exportName];
-  if (exportValue === void 0) {
-    throw new ContractRefResolutionError(
-      "contract-ref-unknown-export",
-      `ContractRef "${ref}" references unknown export "${parsed.exportName}".`,
-      ref
+  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;
   }
-  if (!isZodType(exportValue)) {
-    throw new ContractRefResolutionError(
-      "contract-ref-not-zod-type",
-      `ContractRef "${ref}" resolves to "${parsed.exportName}" but it is not a ZodType.`,
-      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 }
     );
   }
-  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);
+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 { results, succeeded, failed };
+  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;
 }
-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 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 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;
+}
+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;
@@ -4047,612 +4383,24 @@ function buildIterationResponseSchemaUncached(tools, capabilities) {
                 // returns zero memory references -- so this description is the only framework-owned
                 // lever on how a memory value is written. It matters more here than in `message`:
                 // a session-memory value is re-sent on every iteration of every subsequent turn and
-                // never ages out, so one literal escape stored here is one the model re-reads forever.
-                description: "Stored verbatim and replayed to you on every later turn. Write real line breaks and real quotation marks -- the two characters \\n are not a line break."
-              }
-            },
-            required: ["key", "value"],
-            additionalProperties: false
-          }
-        },
-        delete: { type: "array", items: { type: "string" } }
-      },
-      additionalProperties: false
-    };
-  }
-  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;
-    }
+                // never ages out, so one literal escape stored here is one the model re-reads forever.
+                description: "Stored verbatim and replayed to you on every later turn. Write real line breaks and real quotation marks -- the two characters \\n are not a line break."
+              }
+            },
+            required: ["key", "value"],
+            additionalProperties: false
+          }
+        },
+        delete: { type: "array", items: { type: "string" } }
+      },
+      additionalProperties: false
+    };
+  }
+  return {
+    type: "object",
+    properties,
+    required: capabilities.message === "required" ? ["nextActions", "message", "reasoning"] : ["nextActions", "reasoning"],
+    additionalProperties: false
   };
 }
 
@@ -4833,14 +4581,12 @@ function addTopologyIssues(issues, orgName, deployment, organizationModel, syste
   const relationships = organizationModel.topology?.relationships;
   if (relationships === void 0) return;
   const rolesById = new Set(Object.keys(organizationModel.roles ?? {}));
-  const policiesById = new Set(Object.keys(organizationModel.policies ?? {}));
   const triggerIds = new Set(deployment.triggers?.map((trigger) => trigger.resourceId) ?? []);
   const humanCheckpointIds = new Set(deployment.humanCheckpoints?.map((checkpoint) => checkpoint.resourceId) ?? []);
   const externalResourceIds = new Set(deployment.externalResources?.map((external) => external.resourceId) ?? []);
   const topologyRefExists = (ref) => {
     if (ref.kind === "system") return systemsById.has(ref.id);
     if (ref.kind === "resource") return omResourcesById.has(ref.id);
-    if (ref.kind === "policy") return policiesById.has(ref.id);
     if (ref.kind === "role") return rolesById.has(ref.id);
     if (ref.kind === "trigger") return triggerIds.has(ref.id);
     if (ref.kind === "humanCheckpoint") return humanCheckpointIds.has(ref.id);
@@ -5023,7 +4769,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) {
@@ -7160,28 +6905,42 @@ z.object({
   limit: z.number().int(),
   offset: z.number().int()
 });
-var AcqArtifactOwnerKindSchema = z.enum(["company", "contact", "deal", "list", "list_member"]);
+var AcqArtifactOwnerKindSchema = z.enum(["company", "contact", "deal", "list", "list_member", "organization"]);
 z.object({
   ownerKind: AcqArtifactOwnerKindSchema,
-  ownerId: UuidSchema
+  ownerId: UuidSchema.optional()
 }).strict();
+var PipelineIdSchema = z.string().trim().min(1).max(255);
 z.object({
   ownerKind: AcqArtifactOwnerKindSchema,
-  ownerId: UuidSchema,
+  // Nullable + optional: an org-owned artifact (ownerKind: 'organization') has no
+  // single owning entity row. See the comment on AcqArtifactOwnerKindSchema above.
+  ownerId: UuidSchema.nullable().optional(),
   kind: z.string().trim().min(1).max(255),
   content: z.record(z.string(), z.unknown()),
-  sourceExecutionId: UuidSchema.optional()
+  sourceExecutionId: UuidSchema.optional(),
+  // Nullable + optional: acquisition's own artifacts (audits, proposals, ICP docs) predate the
+  // pipeline concept and have none. `getActiveArtifact` filters on it, so any artifact meant to
+  // be resolvable as "the active document for pipeline X" MUST supply it -- artifacts-platform-tool
+  // .mdx Step 3 defect 1.
+  pipelineId: PipelineIdSchema.nullable().optional()
 }).strict();
 var AcqArtifactResponseSchema = z.object({
   id: z.string(),
   organizationId: z.string(),
   ownerKind: z.string(),
-  ownerId: z.string(),
+  // Nullable as of content-pipeline-foundation D14: an org-owned artifact has no owning entity row.
+  // CreateArtifactRequestSchema already accepted a null ownerId; this response schema not doing so
+  // was Step 3 defect 2 -- an org-owned artifact inserted fine and then failed serialization.
+  ownerId: z.string().nullable(),
   kind: z.string(),
+  pipelineId: z.string().nullable(),
   content: z.record(z.string(), z.unknown()),
   sourceExecutionId: z.string().nullable(),
   createdBy: z.string().nullable(),
   createdAt: z.string(),
+  updatedAt: z.string(),
+  isActive: z.boolean(),
   version: z.number().int()
 });
 z.object({
@@ -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 };