@elevasis/sdk 1.44.3 → 1.45.0

package/dist/test-utils/index.js

@@ -4343,6 +4343,23 @@ var Workflow = class {
 
 // ../core/src/execution/engine/agent/observability/logging.ts
 function createAgentLogger(logger, agentId, sessionId) {
+  function emitAction(actionType, message, iteration, startTime, endTime, duration) {
+    const event = {
+      type: "agent",
+      agentId,
+      lifecycle: "iteration",
+      eventType: "action",
+      iteration,
+      actionType,
+      startTime,
+      endTime,
+      duration,
+      data: { message },
+      ...sessionId && { sessionId }
+      // Include sessionId if present
+    };
+    logger.info("action", event);
+  }
   return {
     lifecycle(lifecycle, stage, data) {
       let event;
@@ -4409,21 +4426,15 @@ function createAgentLogger(logger, agentId, sessionId) {
       logger.info("reasoning", event);
     },
     action(actionType, message, iteration, startTime, endTime, duration) {
-      const event = {
-        type: "agent",
-        agentId,
-        lifecycle: "iteration",
-        eventType: "action",
-        iteration,
-        actionType,
-        startTime,
-        endTime,
-        duration,
-        data: { message },
-        ...sessionId && { sessionId }
-        // Include sessionId if present
-      };
-      logger.info("action", event);
+      emitAction(actionType, message, iteration, startTime, endTime, duration);
+    },
+    async timed(actionType, iteration, work, message) {
+      const startTime = Date.now();
+      const result = await work();
+      const endTime = Date.now();
+      const resolvedActionType = typeof actionType === "function" ? actionType(result) : actionType;
+      emitAction(resolvedActionType, message(result), iteration, startTime, endTime, endTime - startTime);
+      return result;
     },
     toolCall(toolName, iteration, startTime, endTime, duration, success, error, input, output) {
       const event = {
@@ -5351,66 +5362,21 @@ async function processReasoning(iterationContext) {
     reasoning: response.reasoning
   });
   iterationContext.logger.reasoning(response.reasoning, iterationContext.iteration, startTime, endTime, duration);
-  const memoryStartTime = Date.now();
-  iterationContext.memoryManager.addToHistory({
-    type: "reasoning",
-    content: response.reasoning,
-    turnNumber: iterationContext.executionContext.sessionTurnNumber ?? null,
-    iterationNumber: iterationContext.iteration,
-    source: "model"
-  });
-  const memoryEndTime = Date.now();
-  const memoryDuration = memoryEndTime - memoryStartTime;
-  iterationContext.logger.action(
+  await iterationContext.logger.timed(
     "memory-reasoning",
-    `Stored reasoning (${response.reasoning.length} chars), history size: ${iterationContext.memoryManager.getHistoryLength()}, actions: ${response.nextActions.map((a3) => a3.type).join(", ")}`,
     iterationContext.iteration,
-    memoryStartTime,
-    memoryEndTime,
-    memoryDuration
+    () => iterationContext.memoryManager.addToHistory({
+      type: "reasoning",
+      content: response.reasoning,
+      turnNumber: iterationContext.executionContext.sessionTurnNumber ?? null,
+      iterationNumber: iterationContext.iteration,
+      source: "model"
+    }),
+    () => `Stored reasoning (${response.reasoning.length} chars), history size: ${iterationContext.memoryManager.getHistoryLength()}, actions: ${response.nextActions.map((a3) => a3.type).join(", ")}`
   );
   return response;
 }
 
-// ../core/src/execution/engine/agent/memory/domains.ts
-var MEMORY_DOMAINS = {
-  /**
-   * Tool-owned keys
-   * Updated automatically by tools as side effects
-   * LLM cannot modify these via memoryOps
-   *
-   * Tools manage complex structured data (caches, indexes, etc.)
-   * that would be error-prone for LLM to update via JSON strings.
-   *
-   * No tool currently writes these three keys, so in practice the guard reserves the names
-   * against the LLM rather than arbitrating a live conflict. That is still enforcement --
-   * see `validateMemoryKeyOwnership` in `./utils` -- not dead code.
-   */
-  TOOL_OWNED: [
-    "notion-pages-cache",
-    // Notion tools manage page hierarchy
-    "github-repo-cache",
-    // GitHub tools manage repository structure
-    "slack-channel-cache"
-    // Slack tools manage channel data
-  ]
-  /**
-   * LLM-owned keys
-   * All keys NOT in TOOL_OWNED
-   * Managed via memoryOps by agent reasoning
-   *
-   * LLM manages semantic memory (business context, decisions, etc.)
-   * that requires understanding and judgment.
-   */
-};
-function isToolOwnedKey(key) {
-  return MEMORY_DOMAINS.TOOL_OWNED.includes(key);
-}
-function getKeyOwner(key) {
-  if (isToolOwnedKey(key)) return "tool";
-  return "llm";
-}
-
 // ../core/src/execution/engine/agent/memory/utils.ts
 function addToolError(memoryManager, action, errorMessage, iteration, turnNumber = null, metadata) {
   memoryManager.addToHistory({
@@ -5434,11 +5400,10 @@ function addToolError(memoryManager, action, errorMessage, iteration, turnNumber
   });
 }
 function validateMemoryKeyOwnership(key, logger, iteration) {
-  if (isToolOwnedKey(key)) {
-    const owner = getKeyOwner(key);
+  if (key.startsWith("_")) {
     logger.action(
       "memory-set-rejected",
-      `Rejected LLM update to ${owner}-managed key: ${key}`,
+      `Rejected LLM update to framework-reserved key: ${key}`,
       iteration,
       Date.now(),
       Date.now(),
@@ -5680,25 +5645,19 @@ async function executeToolCall(iterationContext, action) {
       action.input,
       boundedResult
     );
-    const memoryStartTime = Date.now();
     const memoryContent = typeof boundedResult === "string" ? boundedResult : JSON.stringify(boundedResult);
-    iterationContext.memoryManager.addToHistory({
-      type: "tool-result",
-      content: memoryContent,
-      toolName: action.name,
-      turnNumber: iterationContext.executionContext.sessionTurnNumber ?? null,
-      iterationNumber: iterationContext.iteration,
-      source: "tool"
-    });
-    const memoryEndTime = Date.now();
-    const memoryDuration = memoryEndTime - memoryStartTime;
-    iterationContext.logger.action(
+    await iterationContext.logger.timed(
       "memory-tool-result",
-      `Stored tool-result for ${action.name} (${memoryContent.length} chars), history size: ${iterationContext.memoryManager.getHistoryLength()}`,
       iterationContext.iteration,
-      memoryStartTime,
-      memoryEndTime,
-      memoryDuration
+      () => iterationContext.memoryManager.addToHistory({
+        type: "tool-result",
+        content: memoryContent,
+        toolName: action.name,
+        turnNumber: iterationContext.executionContext.sessionTurnNumber ?? null,
+        iterationNumber: iterationContext.iteration,
+        source: "tool"
+      }),
+      () => `Stored tool-result for ${action.name} (${memoryContent.length} chars), history size: ${iterationContext.memoryManager.getHistoryLength()}`
     );
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -5721,29 +5680,25 @@ async function executeToolCall(iterationContext, action) {
       action.input,
       void 0
     );
-    const memoryStartTime = Date.now();
-    const metadata = error instanceof ToolingError ? {
-      errorType: error.errorType,
-      severity: error.severity,
-      isRetryable: error.isRetryable()
-    } : void 0;
-    addToolError(
-      iterationContext.memoryManager,
-      action,
-      errorMessage,
-      iterationContext.iteration,
-      iterationContext.executionContext.sessionTurnNumber ?? null,
-      metadata
-    );
-    const memoryEndTime = Date.now();
-    const memoryDuration = memoryEndTime - memoryStartTime;
-    iterationContext.logger.action(
+    await iterationContext.logger.timed(
       "memory-tool-error",
-      `Stored error for ${action.name}: ${errorMessage}, history size: ${iterationContext.memoryManager.getHistoryLength()}`,
       iterationContext.iteration,
-      memoryStartTime,
-      memoryEndTime,
-      memoryDuration
+      () => {
+        const metadata = error instanceof ToolingError ? {
+          errorType: error.errorType,
+          severity: error.severity,
+          isRetryable: error.isRetryable()
+        } : void 0;
+        addToolError(
+          iterationContext.memoryManager,
+          action,
+          errorMessage,
+          iterationContext.iteration,
+          iterationContext.executionContext.sessionTurnNumber ?? null,
+          metadata
+        );
+      },
+      () => `Stored error for ${action.name}: ${errorMessage}, history size: ${iterationContext.memoryManager.getHistoryLength()}`
     );
   }
 }
@@ -5981,11 +5936,13 @@ async function processMemory(memoryManager, response, logger, iteration) {
       if (!validateMemoryKeyOwnership(key, logger, iteration)) {
         continue;
       }
-      const startTime = Date.now();
-      const stringValue2 = typeof content === "string" ? content : JSON.stringify(content);
-      memoryManager.set(key, stringValue2);
-      const endTime = Date.now();
-      logger.action("memory-set", `Set: ${key}`, iteration, startTime, endTime, endTime - startTime);
+      await logger.timed(
+        "memory-set",
+        iteration,
+        // Auto-stringify non-string values (arrays, objects, etc.)
+        () => memoryManager.set(key, typeof content === "string" ? content : JSON.stringify(content)),
+        () => `Set: ${key}`
+      );
     }
   }
   if (memoryOps.delete) {
@@ -5993,21 +5950,12 @@ async function processMemory(memoryManager, response, logger, iteration) {
       if (!validateMemoryKeyOwnership(key, logger, iteration)) {
         continue;
       }
-      const startTime = Date.now();
-      const deleted = memoryManager.delete(key);
-      const endTime = Date.now();
-      if (deleted) {
-        logger.action("memory-delete", `Deleted: ${key}`, iteration, startTime, endTime, endTime - startTime);
-      } else {
-        logger.action(
-          "memory-delete-missing",
-          `Attempted to delete non-existent key: ${key}`,
-          iteration,
-          startTime,
-          endTime,
-          endTime - startTime
-        );
-      }
+      await logger.timed(
+        (deleted) => deleted ? "memory-delete" : "memory-delete-missing",
+        iteration,
+        () => memoryManager.delete(key),
+        (deleted) => deleted ? `Deleted: ${key}` : `Attempted to delete non-existent key: ${key}`
+      );
     }
   }
 }
@@ -6134,7 +6082,6 @@ var MemoryManager = class {
     this.constraints = constraints;
     this.logger = logger;
   }
-  cachedSnapshot;
   /**
    * Rolling correction for `estimateTokens`'s bias, learned from real provider usage.
    * `undefined` until the first `recordActualUsage` call -- the cold-start state, where
@@ -6423,21 +6370,15 @@ var MemoryManager = class {
     };
   }
   /**
-   * Create memory snapshot for persistence
-   * Caches snapshot internally for later retrieval
+   * Create a memory snapshot for persistence.
+   *
+   * Stateless: every call returns a fresh `structuredClone` of the current memory, so the caller
+   * owns caching if it needs to hold onto the result across calls (see `Agent.memorySnapshot`).
+   *
    * @returns Deep copy of current memory state
    */
-  toSnapshot() {
-    this.cachedSnapshot = structuredClone(this.memory);
-    return this.cachedSnapshot;
-  }
-  /**
-   * Get cached memory snapshot
-   * Returns snapshot created by toSnapshot()
-   * @returns Cached snapshot (undefined if toSnapshot() not called yet)
-   */
-  getSnapshot() {
-    return this.cachedSnapshot;
+  snapshot() {
+    return structuredClone(this.memory);
   }
   /**
    * Build the framework framing and the untrusted data envelope for an LLM call.
@@ -6569,6 +6510,12 @@ var Agent = class {
    * reading memory history after the fact, because the emit is the user-visible event and memory
    * can be compacted or restructured without changing whether the turn spoke. */
   spokeThisTurn = false;
+  /** Cached result of `memoryManager.snapshot()` -- `MemoryManager.snapshot()` itself is stateless
+   * (a fresh `structuredClone` every call), so caching the LAST one taken is this class's job. Set
+   * once, in the `finally` around `iterate()` and again in `complete()` -- see `getMemorySnapshot()`
+   * for why `undefined`-before-first-iteration is a contract other callers (`session.ts`, the SDK
+   * worker) depend on. */
+  memorySnapshot;
   /**
    * Create a new agent instance from definition
    * Memory will be initialized during execution
@@ -6609,7 +6556,7 @@ var Agent = class {
         try {
           await this.iterate(this.executionContext);
         } finally {
-          this.memoryManager.toSnapshot();
+          this.memorySnapshot = this.memoryManager.snapshot();
         }
       }
       const output = await this.complete();
@@ -6722,22 +6669,21 @@ var Agent = class {
   async initializeMemoryManager(context) {
     const memory = await this.resolveInitialMemory(context);
     const memoryManager = new MemoryManager(memory, this.config.constraints, this.logger);
-    const inputStartTime = Date.now();
-    memoryManager.addToHistory({
-      type: "input",
-      content: this.currentInput,
-      turnNumber: context.sessionTurnNumber ?? null,
-      iterationNumber: 0,
-      source: "user"
-    });
-    const inputEndTime = Date.now();
-    this.logger.action(
+    await this.logger.timed(
       "memory-input",
-      `Added input entry to history`,
       0,
-      inputStartTime,
-      inputEndTime,
-      inputEndTime - inputStartTime
+      // Kept in history even though the input also travels as its own message: history is what
+      // later iterations and later turns read, and `autoCompact` anchors on `history[0]` as the
+      // original input. `toContextParts` excludes this entry from the current turn's envelope so
+      // the model does not see the same text twice.
+      () => memoryManager.addToHistory({
+        type: "input",
+        content: this.currentInput,
+        turnNumber: context.sessionTurnNumber ?? null,
+        iterationNumber: 0,
+        source: "user"
+      }),
+      () => `Added input entry to history`
     );
     flowLog("agent.initialize", {
       resourceId: this.config.resourceId,
@@ -6759,32 +6705,20 @@ var Agent = class {
    */
   async resolveInitialMemory(context) {
     if (this.initialMemory) {
-      const restoreStartTime = Date.now();
-      const memory = structuredClone(this.initialMemory);
-      const restoreEndTime = Date.now();
-      this.logger.action(
+      return this.logger.timed(
         "memory-restore",
-        `Restored ${Object.keys(memory.sessionMemory).length} session memory entries`,
         0,
-        restoreStartTime,
-        restoreEndTime,
-        restoreEndTime - restoreStartTime
+        () => structuredClone(this.initialMemory),
+        (memory) => `Restored ${Object.keys(memory.sessionMemory).length} session memory entries`
       );
-      return memory;
     }
     if (this.definition.preloadMemory) {
-      const preloadStartTime = Date.now();
-      const memory = await this.definition.preloadMemory(context);
-      const preloadEndTime = Date.now();
-      this.logger.action(
+      return this.logger.timed(
         "memory-preload",
-        `Preloaded ${Object.keys(memory.sessionMemory).length} session memory entries`,
         0,
-        preloadStartTime,
-        preloadEndTime,
-        preloadEndTime - preloadStartTime
+        () => this.definition.preloadMemory(context),
+        (memory) => `Preloaded ${Object.keys(memory.sessionMemory).length} session memory entries`
       );
-      return memory;
     }
     return { sessionMemory: {}, history: [] };
   }
@@ -6918,8 +6852,8 @@ var Agent = class {
           0
         );
       }
-      this.memoryManager.toSnapshot();
-      const snapshot = this.memoryManager.getSnapshot();
+      const snapshot = this.memoryManager.snapshot();
+      this.memorySnapshot = snapshot;
       const completionEndTime = Date.now();
       this.logger.lifecycle("completion", "completed", {
         startTime: completionStartTime,
@@ -7135,12 +7069,17 @@ Fix the errors and generate a valid output.
 `.trim();
   }
   /**
-   * Get memory snapshot after execution
-   * Delegates to MemoryManager.getSnapshot()
-   * @returns Memory snapshot (only available after execute() completes)
+   * Get memory snapshot after execution.
+   *
+   * `undefined` until the `finally` around `iterate()` (or `complete()`) takes the first snapshot --
+   * `session.ts` and the SDK worker both rely on this to distinguish "no memory produced yet" (a
+   * throw during `initialize()`, before any iteration ran) from "memory exists".
+   *
+   * @returns Memory snapshot (only available after execute() completes, or after a mid-turn throw
+   *   past the point `iterate()` began)
    */
   getMemorySnapshot() {
-    return this.memoryManager.getSnapshot();
+    return this.memorySnapshot;
   }
   /**
    * How the just-finished turn ended -- see `AgentStopReason`. Set once `iterate()` returns,
@@ -9067,17 +9006,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(),
   /**
@@ -9098,9 +9043,6 @@ var _profileRegistry = new Map(
     { profileId, kind: "built-in" }
   ])
 );
-function profileForInterface(systemPath, interfaceKey, readinessProfile) {
-  return readinessProfile ?? `${systemPath}.${interfaceKey}`;
-}
 function isBuiltInReadinessProfile(profileId) {
   return _profileRegistry.get(profileId)?.kind === "built-in";
 }
@@ -9197,469 +9139,137 @@ z.record(z.string(), SystemEntrySchema).refine((record) => Object.entries(record
   message: "Each system entry id must match its map key"
 }).default({});
 
-// ../core/src/organization-model/migration-helpers.ts
-function catalogRecords(model) {
-  return Object.values(compileOrganizationOntology(model).ontology.catalogTypes);
+// ../core/src/organization-model/readiness/profile-registry.ts
+var _builtInProfileValidators = /* @__PURE__ */ new Map();
+function getBuiltInReadinessProfile(profileId) {
+  return _builtInProfileValidators.get(profileId);
 }
-function systemScope(id, fallback) {
-  return parseOntologyId(id).scope || fallback || "";
+var _interfaceMarkerResolvers = /* @__PURE__ */ new Map();
+function interfaceMarkerKey(systemPath, interfaceKey) {
+  return `${systemPath}::${interfaceKey}`;
 }
-function entriesOf(catalog) {
-  return Object.entries(catalog.entries ?? {}).map(([id, value]) => [
-    id,
-    value && typeof value === "object" && !Array.isArray(value) ? value : {}
-  ]);
+function resolveReadinessInterfaceMarker(model, systemPath, interfaceKey) {
+  return _interfaceMarkerResolvers.get(interfaceMarkerKey(systemPath, interfaceKey))?.(model);
 }
-function stringValue(value) {
-  return typeof value === "string" ? value : void 0;
+
+// ../core/src/organization-model/readiness/engine.ts
+function addReadinessIssue(issues, family, code, message, details = {}) {
+  issues.push({
+    family,
+    code,
+    message,
+    ...details
+  });
 }
-function stringArray(value) {
-  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+function formatInterfaceIdentity(systemPath, interfaceKey) {
+  return `${systemPath}/${interfaceKey}`;
 }
-function numberValue(value, fallback = 0) {
-  return typeof value === "number" ? value : fallback;
+function readinessMarkerPath(context) {
+  return context.interfaceKey === "api" ? `systems.${context.systemPath}.apiInterface` : void 0;
 }
-function appliesToLocalId(catalog) {
-  const appliesTo = catalog.appliesTo;
-  if (appliesTo === void 0) return void 0;
-  return parseOntologyId(appliesTo).localId;
+function readinessMarkerFieldPath(context, suffix) {
+  const base = readinessMarkerPath(context);
+  return base === void 0 ? void 0 : `${base}${suffix}`;
 }
-function appliesToEntityKind(catalog) {
-  const id = appliesToLocalId(catalog);
-  if (id === "company" || id === "contact" || id === "project" || id === "milestone" || id === "task") return id;
-  if (id === "deal") return void 0;
-  return void 0;
+function formatSupportedReadinessProfiles() {
+  return SYSTEM_INTERFACE_PROFILES.map((p3) => `"${p3.readinessProfile}"`).join(", ");
+}
+function isPlainRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-function getLeadGenStageCatalog(model) {
-  const results = {};
-  for (const catalog of catalogRecords(model).filter(
-    (record) => record.kind === "stage" && (record.ownerSystemId ?? systemScope(record.id)) === "sales.lead-gen"
-  )) {
-    const catalogEntity = appliesToEntityKind(catalog);
-    if (catalogEntity !== "company" && catalogEntity !== "contact") continue;
-    for (const [entryId, entry] of entriesOf(catalog)) {
-      const entity = entry.entity === "contact" ? "contact" : entry.entity === "company" ? "company" : catalogEntity;
-      const additionalEntities = stringArray(entry.additionalEntities).filter(
-        (item) => item === "company" || item === "contact"
+function getCatalogEntries(catalog) {
+  return isPlainRecord(catalog.entries) ? catalog.entries : {};
+}
+function getActiveScopedResources(model, resourceIds, issues, context) {
+  const resources = [];
+  for (const [index2, resourceId] of resourceIds.entries()) {
+    const resource = model.resources?.[resourceId];
+    const path = readinessMarkerFieldPath(context, `.resourceIds.${index2}`);
+    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 }
       );
-      const recordEntity = entry.recordEntity === "company" || entry.recordEntity === "contact" ? entry.recordEntity : void 0;
-      const recordStageKey = stringValue(entry.recordStageKey);
-      const readinessTarget = entry.readinessTarget === true ? true : void 0;
-      results[entryId] = {
-        key: entryId,
-        label: stringValue(entry.label) ?? entryId,
-        description: stringValue(entry.description) ?? "",
-        order: numberValue(entry.order),
-        entity,
-        ...additionalEntities.length > 0 ? { additionalEntities } : {},
-        ...recordEntity ? { recordEntity } : {},
-        ...recordStageKey ? { recordStageKey } : {},
-        ...readinessTarget ? { readinessTarget } : {}
-      };
+      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 Object.fromEntries(
-    Object.entries(results).sort(([, a3], [, b2]) => a3.order - b2.order || a3.key.localeCompare(b2.key))
+  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 }
   );
 }
-z.object({
-  success: z.boolean(),
-  tool: z.string(),
-  method: z.string(),
-  result: z.unknown().optional(),
-  error: z.string().optional(),
-  durationMs: z.number().optional()
-});
-z.object({
-  credential: z.string().describe("Credential name registered for this integration")
-});
-
-// ../core/src/execution/engine/llm/schema/compile.ts
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function ontologyOwnerMatches(ontologyId, expectedSystemPath, catalog) {
+  if (catalog?.ownerSystemId !== void 0) return catalog.ownerSystemId === expectedSystemPath;
+  return parseOntologyId(ontologyId).scope === expectedSystemPath;
 }
-var UNSUPPORTED_KEYWORDS = /* @__PURE__ */ new Set([
-  "minimum",
-  "maximum",
-  "exclusiveMinimum",
-  "exclusiveMaximum",
-  "multipleOf",
-  "minLength",
-  "maxLength",
-  "pattern",
-  "maxItems",
-  "uniqueItems",
-  "minProperties",
-  "maxProperties",
-  "patternProperties",
-  "propertyNames",
-  "contains",
-  "minContains",
-  "maxContains",
-  "dependentRequired",
-  "dependentSchemas",
-  "if",
-  "then",
-  "else",
-  "not",
-  "$id",
-  "$anchor"
-]);
-var SUPPORTED_FORMATS = /* @__PURE__ */ new Set([
-  "date-time",
-  "time",
-  "date",
-  "duration",
-  "email",
-  "hostname",
-  "uri",
-  "ipv4",
-  "ipv6",
-  "uuid"
-]);
-var MAX_SCHEMA_DEPTH = 32;
-function convertNode(node, state, depth) {
-  if (depth > MAX_SCHEMA_DEPTH && state.dialect.strict !== "unsupported") {
-    state.blockers.push("depth>32");
-    return node;
+function requireObjectReadiness(issues, index2, objectId, context) {
+  const object2 = index2.ontology.objectTypes[objectId];
+  if (object2 === 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 (Array.isArray(node)) {
-    return node.map((item) => convertNode(item, state, depth + 1));
+  const ownerSystemId = object2.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 (!isPlainObject(node)) {
-    return node;
-  }
-  const strictEngaged = state.dialect.strict !== "unsupported";
-  const out = {};
-  for (const [key, value] of Object.entries(node)) {
-    if (key === "$ref" || key === "$defs" || key === "definitions") {
-      if (state.dialect.refs === "refuse") {
-        state.blockers.push(`unsupported:${key}`);
-        out[key] = value;
-        continue;
-      }
-      out[key] = value;
-      continue;
-    }
-    if (key === "$schema") {
-      if (!state.dialect.allowsSchemaKeyword) {
-        continue;
-      }
-      out.$schema = value;
-      continue;
-    }
-    if (key === "properties") {
-      if (!isPlainObject(value)) {
-        out.properties = value;
-        continue;
-      }
-      const properties = {};
-      for (const [propertyName, propertySchema] of Object.entries(value)) {
-        properties[propertyName] = convertNode(propertySchema, state, depth + 1);
-      }
-      out.properties = properties;
-      continue;
-    }
-    if (key === "items") {
-      out.items = convertNode(value, state, depth + 1);
-      continue;
-    }
-    if (strictEngaged) {
-      if (UNSUPPORTED_KEYWORDS.has(key)) {
-        continue;
-      }
-      if (key === "oneOf") {
-        out.anyOf = convertNode(value, state, depth + 1);
-        continue;
-      }
-      if (key === "format") {
-        if (typeof value === "string" && SUPPORTED_FORMATS.has(value)) {
-          out.format = value;
-        }
-        continue;
-      }
-      if (key === "minItems") {
-        const n2 = typeof value === "number" ? value : 0;
-        out.minItems = n2 > 1 ? 1 : n2;
-        continue;
-      }
-      if (key === "type" && Array.isArray(value)) {
-        out.anyOf = value.map((t) => ({ type: t }));
-        continue;
-      }
-      if (key === "additionalProperties") {
-        continue;
-      }
-    }
-    out[key] = convertNode(value, state, depth + 1);
-  }
-  const isObjectNode = out.type === "object" || isPlainObject(out.properties);
-  if (isObjectNode) {
-    const properties = isPlainObject(out.properties) ? out.properties : void 0;
-    const originalAdditionalProperties = node.additionalProperties;
-    if (strictEngaged) {
-      if (properties) {
-        const declared = Object.keys(properties);
-        const required = Array.isArray(out.required) ? out.required : [];
-        const optional = declared.filter((k2) => !required.includes(k2));
-        if (state.dialect.strict === "allRequired" && optional.length > 0) {
-          state.blockers.push(`optionalProperty:${optional[0]}`);
-        }
-        state.optionalProperties += optional.length;
-      }
-      if (originalAdditionalProperties !== void 0 && originalAdditionalProperties !== false && (!properties || Object.keys(properties).length === 0)) {
-        state.blockers.push("freeFormObject");
-      }
-      out.additionalProperties = false;
-    }
-    if (strictEngaged && (!properties || Object.keys(properties).length === 0)) {
-      out.properties = {};
-    }
-  }
-  return out;
-}
-function dedupe(values) {
-  return [...new Set(values)];
-}
-function compileSchema(schema, dialect) {
-  if (!isPlainObject(schema)) {
-    const strictEngaged = dialect.strict !== "unsupported";
-    return {
-      schema,
-      sendStrict: false,
-      status: strictEngaged ? "refused" : "notAttempted",
-      refusalReasons: strictEngaged ? ["notAnObject"] : []
-    };
-  }
-  const state = { dialect, blockers: [], optionalProperties: 0 };
-  const compiled = convertNode(schema, state, 0);
-  if (state.blockers.length === 0 && dialect.maxOptionalProperties !== void 0 && state.optionalProperties > dialect.maxOptionalProperties) {
-    state.blockers.push(`optionalPropertyLimit:${state.optionalProperties}>${dialect.maxOptionalProperties}`);
-  }
-  if (dialect.strict === "unsupported") {
-    return {
-      schema: compiled,
-      sendStrict: false,
-      status: "notAttempted",
-      refusalReasons: []
-    };
-  }
-  if (state.blockers.length > 0) {
-    return {
-      schema,
-      sendStrict: false,
-      status: "refused",
-      refusalReasons: dedupe(state.blockers)
-    };
-  }
-  return { schema: compiled, sendStrict: true, status: "applied", refusalReasons: [] };
-}
-
-// ../core/src/execution/engine/llm/schema/dialect.ts
-var ANTHROPIC_DIALECT = {
-  strict: "optionalAllowed",
-  // No placeholder of its own: an empty or absent `properties` becomes a bare `properties: {}`,
-  // synthesized directly by the walk for any dialect engaging strict.
-  // Refuses rather than inlining: detecting recursion through `$defs` is more machinery than the
-  // payoff justifies for a tool-input schema.
-  refs: "refuse",
-  allowsSchemaKeyword: false,
-  // Anthropic's published ceiling. Measured live before this was added: the Command Center
-  // assistant's iteration schema declares 33, so 8 of 8 iterations across a 3-turn session were
-  // 400'd and retried unstrict. `optionalAllowed` is still correct -- an optional property is
-  // representable in this grammar, there is just a cap on how many.
-  maxOptionalProperties: 24
-};
-var OPENAI_DIALECT = {
-  strict: "allRequired",
-  refs: "passthrough",
-  allowsSchemaKeyword: false
-};
-var OPENROUTER_DIALECT = {
-  strict: "allRequired",
-  refs: "refuse",
-  allowsSchemaKeyword: false
-};
-var PROVIDER_DIALECTS = {
-  anthropic: ANTHROPIC_DIALECT,
-  openai: OPENAI_DIALECT,
-  openrouter: OPENROUTER_DIALECT
-};
-
-// ../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"
-});
-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 formatSupportedReadinessProfiles() {
-  return SYSTEM_INTERFACE_PROFILES.map((p3) => `"${p3.readinessProfile}"`).join(", ");
-}
-function getActiveScopedResources(model, resourceIds, issues, context) {
-  const resources = [];
-  for (const [index2, resourceId] of resourceIds.entries()) {
-    const resource = model.resources?.[resourceId];
-    const path = `${readinessMarkerPath(context)}.resourceIds.${index2}`;
-    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, index2, objectId, context) {
-  const object2 = index2.ontology.objectTypes[objectId];
-  if (object2 === 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 = object2.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, index2, catalogId, context) {
-  const catalog = index2.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;
+}
+function requireCatalogReadiness(issues, index2, catalogId, context) {
+  const catalog = index2.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(
@@ -9681,129 +9291,40 @@ function requireCatalogReadiness(issues, index2, catalogId, context) {
   }
   return catalog;
 }
-function requireLeadGenInterfaceReadiness(issues, index2, resources, context) {
+function requireContractReadiness(issues, index2, resources, contract, 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
-  ]) {
+  for (const objectId of contract.requiredObjects) {
     requireObjectReadiness(issues, index2, 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
-  ]) {
+  for (const catalogId of contract.requiredCatalogs) {
     requireCatalogReadiness(issues, index2, catalogId, context);
     requireScopedBinding(issues, catalogs, "usesCatalogs", catalogId, context);
   }
-  const templateStepCatalog = findLeadGenTemplateStepCatalog(index2);
-  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, index2, templateStepCatalog.id, context);
-    requireScopedBinding(issues, catalogs, "usesCatalogs", templateStepCatalog.id, context);
-  }
-  const leadGenStageCatalog = requireCatalogReadiness(issues, index2, LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID, context);
-  return leadGenStageCatalog;
-}
-function requireCrmInterfaceReadiness(issues, index2, resources, context) {
-  const catalogs = resourceBindingIds(resources, "usesCatalogs");
-  const crmPipelineCatalog = requireCatalogReadiness(issues, index2, 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)
-    };
-  }
+  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 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
-      }
-    }
-  };
+  return void 0;
 }
-function compileBusinessOntology(model, contractId) {
-  const compilation = compileOrganizationOntology(mergeLeadGenDerivedCatalogs(model));
+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(`${contractId} ontology validation index failed to compile: ${summary}`);
+    throw new Error(`${readinessProfile} ontology validation index failed to compile: ${summary}`);
   }
-  return {
-    ontology: compilation.ontology,
-    actionTypesByLegacyId: indexActionTypesByLegacyId(compilation.ontology.actionTypes)
-  };
+  return { ontology: compilation.ontology };
 }
-function tryCompileBusinessOntology(model, readinessProfile, issues) {
+function tryCompileReadinessOntology(model, readinessProfile, prepareModel, issues) {
   try {
-    return compileBusinessOntology(model, readinessProfile);
+    return compileReadinessOntology(model, readinessProfile, prepareModel);
   } catch (error) {
     addReadinessIssue(
       issues,
@@ -9814,23 +9335,11 @@ function tryCompileBusinessOntology(model, readinessProfile, issues) {
     return void 0;
   }
 }
-function requireContractReadiness(issues, index2, resources, contract, context) {
-  const reads = resourceBindingIds(resources, "reads");
-  const catalogs = resourceBindingIds(resources, "usesCatalogs");
-  for (const objectId of contract.requiredObjects) {
-    requireObjectReadiness(issues, index2, objectId, context);
-    requireScopedBinding(issues, reads, "reads", objectId, context);
-  }
-  for (const catalogId of contract.requiredCatalogs) {
-    requireCatalogReadiness(issues, index2, 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 readinessProfile = systemInterface?.readinessProfile;
   const scopedResourceIds = systemInterface?.resourceIds ?? [];
   if (system === void 0) {
     addReadinessIssue(
@@ -9870,25 +9379,48 @@ function computeInterfaceReadiness(model, request) {
       "SYSTEM_INTERFACE_DISABLED",
       "inactive-interface",
       `System Interface "${formatInterfaceIdentity(request.systemPath, request.interfaceKey)}" lifecycle is "${systemInterface.lifecycle}".`,
-      { path: `${readinessMarkerPath(request)}.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 checkedReadinessProfile = readinessProfile ?? profileForInterface(request.systemPath, request.interfaceKey);
-  const isBuiltIn = isBuiltInReadinessProfile(checkedReadinessProfile);
+  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 "${checkedReadinessProfile}" but declares no readinessContract. Built-in profiles: ${formatSupportedReadinessProfiles()}.`,
-      { path: `${readinessMarkerPath(request)}.readinessContract`, ref: checkedReadinessProfile }
+      `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: checkedReadinessProfile,
+      readinessProfile,
       scopedResourceIds,
       issues
     };
@@ -9899,20 +9431,15 @@ function computeInterfaceReadiness(model, request) {
       "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` }
+      { path: readinessMarkerFieldPath(request, ".resourceIds") }
     );
   }
   const resources = getActiveScopedResources(model, scopedResourceIds, issues, request);
-  const index2 = tryCompileBusinessOntology(model, checkedReadinessProfile, issues);
+  const registration = getBuiltInReadinessProfile(readinessProfile);
+  const index2 = tryCompileReadinessOntology(model, readinessProfile, registration?.prepareModel, issues);
   if (index2 !== void 0) {
-    if (checkedReadinessProfile === LEAD_GEN_API_INTERFACE.readinessProfile) {
-      requireLeadGenInterfaceReadiness(issues, index2, resources, request);
-    } else if (checkedReadinessProfile === CRM_API_INTERFACE.readinessProfile) {
-      requireCrmInterfaceReadiness(issues, index2, resources, request);
-    } else if (checkedReadinessProfile === LEAD_GEN_CRM_HANDOFF_INTERFACE.readinessProfile) {
-      requireLeadGenInterfaceReadiness(issues, index2, resources, request);
-      requireCrmInterfaceReadiness(issues, index2, resources, { ...request, allowForeignOwner: true });
-      requireHandoffBridgeReadiness(issues, model, request);
+    if (registration !== void 0) {
+      registration.validate(issues, index2, resources, model, request);
     } else if (readinessContract !== void 0) {
       requireContractReadiness(issues, index2, resources, readinessContract, request);
     }
@@ -9921,30 +9448,235 @@ function computeInterfaceReadiness(model, request) {
     ready: issues.length === 0,
     systemPath: request.systemPath,
     interfaceKey: request.interfaceKey,
-    readinessProfile: checkedReadinessProfile,
+    readinessProfile,
     scopedResourceIds,
     issues
   };
 }
-function findLeadGenTemplateStepCatalog(index2) {
-  return Object.values(index2.ontology.catalogTypes).find(
-    (catalog) => catalog.ownerSystemId === "sales.lead-gen" && catalog.kind === "template-step" && catalog.appliesTo === LEAD_GEN_LIST_OBJECT_ONTOLOGY_ID
-  );
+z.object({
+  success: z.boolean(),
+  tool: z.string(),
+  method: z.string(),
+  result: z.unknown().optional(),
+  error: z.string().optional(),
+  durationMs: z.number().optional()
+});
+z.object({
+  credential: z.string().describe("Credential name registered for this integration")
+});
+
+// ../core/src/execution/engine/llm/schema/compile.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function indexActionTypesByLegacyId(actionTypes) {
-  const byLegacyId = {};
-  for (const actionType of Object.values(actionTypes)) {
-    const legacyActionId = actionType["legacyActionId"];
-    if (typeof legacyActionId === "string") {
-      byLegacyId[legacyActionId] = actionType;
+var UNSUPPORTED_KEYWORDS = /* @__PURE__ */ new Set([
+  "minimum",
+  "maximum",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "multipleOf",
+  "minLength",
+  "maxLength",
+  "pattern",
+  "maxItems",
+  "uniqueItems",
+  "minProperties",
+  "maxProperties",
+  "patternProperties",
+  "propertyNames",
+  "contains",
+  "minContains",
+  "maxContains",
+  "dependentRequired",
+  "dependentSchemas",
+  "if",
+  "then",
+  "else",
+  "not",
+  "$id",
+  "$anchor"
+]);
+var SUPPORTED_FORMATS = /* @__PURE__ */ new Set([
+  "date-time",
+  "time",
+  "date",
+  "duration",
+  "email",
+  "hostname",
+  "uri",
+  "ipv4",
+  "ipv6",
+  "uuid"
+]);
+var MAX_SCHEMA_DEPTH = 32;
+function convertNode(node, state, depth) {
+  if (depth > MAX_SCHEMA_DEPTH && state.dialect.strict !== "unsupported") {
+    state.blockers.push("depth>32");
+    return node;
+  }
+  if (Array.isArray(node)) {
+    return node.map((item) => convertNode(item, state, depth + 1));
+  }
+  if (!isPlainObject(node)) {
+    return node;
+  }
+  const strictEngaged = state.dialect.strict !== "unsupported";
+  const out = {};
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "$ref" || key === "$defs" || key === "definitions") {
+      if (state.dialect.refs === "refuse") {
+        state.blockers.push(`unsupported:${key}`);
+        out[key] = value;
+        continue;
+      }
+      out[key] = value;
+      continue;
+    }
+    if (key === "$schema") {
+      if (!state.dialect.allowsSchemaKeyword) {
+        continue;
+      }
+      out.$schema = value;
+      continue;
+    }
+    if (key === "properties") {
+      if (!isPlainObject(value)) {
+        out.properties = value;
+        continue;
+      }
+      const properties = {};
+      for (const [propertyName, propertySchema] of Object.entries(value)) {
+        properties[propertyName] = convertNode(propertySchema, state, depth + 1);
+      }
+      out.properties = properties;
+      continue;
+    }
+    if (key === "items") {
+      out.items = convertNode(value, state, depth + 1);
+      continue;
+    }
+    if (strictEngaged) {
+      if (UNSUPPORTED_KEYWORDS.has(key)) {
+        continue;
+      }
+      if (key === "oneOf") {
+        out.anyOf = convertNode(value, state, depth + 1);
+        continue;
+      }
+      if (key === "format") {
+        if (typeof value === "string" && SUPPORTED_FORMATS.has(value)) {
+          out.format = value;
+        }
+        continue;
+      }
+      if (key === "minItems") {
+        const n2 = typeof value === "number" ? value : 0;
+        out.minItems = n2 > 1 ? 1 : n2;
+        continue;
+      }
+      if (key === "type" && Array.isArray(value)) {
+        out.anyOf = value.map((t) => ({ type: t }));
+        continue;
+      }
+      if (key === "additionalProperties") {
+        continue;
+      }
+    }
+    out[key] = convertNode(value, state, depth + 1);
+  }
+  const isObjectNode = out.type === "object" || isPlainObject(out.properties);
+  if (isObjectNode) {
+    const properties = isPlainObject(out.properties) ? out.properties : void 0;
+    const originalAdditionalProperties = node.additionalProperties;
+    if (strictEngaged) {
+      if (properties) {
+        const declared = Object.keys(properties);
+        const required = Array.isArray(out.required) ? out.required : [];
+        const optional = declared.filter((k2) => !required.includes(k2));
+        if (state.dialect.strict === "allRequired" && optional.length > 0) {
+          state.blockers.push(`optionalProperty:${optional[0]}`);
+        }
+        state.optionalProperties += optional.length;
+      }
+      if (originalAdditionalProperties !== void 0 && originalAdditionalProperties !== false && (!properties || Object.keys(properties).length === 0)) {
+        state.blockers.push("freeFormObject");
+      }
+      out.additionalProperties = false;
+    }
+    if (strictEngaged && (!properties || Object.keys(properties).length === 0)) {
+      out.properties = {};
     }
   }
-  return byLegacyId;
+  return out;
 }
-function getCatalogEntries(catalog) {
-  return isPlainRecord(catalog.entries) ? catalog.entries : {};
+function dedupe(values) {
+  return [...new Set(values)];
+}
+function compileSchema(schema, dialect) {
+  if (!isPlainObject(schema)) {
+    const strictEngaged = dialect.strict !== "unsupported";
+    return {
+      schema,
+      sendStrict: false,
+      status: strictEngaged ? "refused" : "notAttempted",
+      refusalReasons: strictEngaged ? ["notAnObject"] : []
+    };
+  }
+  const state = { dialect, blockers: [], optionalProperties: 0 };
+  const compiled = convertNode(schema, state, 0);
+  if (state.blockers.length === 0 && dialect.maxOptionalProperties !== void 0 && state.optionalProperties > dialect.maxOptionalProperties) {
+    state.blockers.push(`optionalPropertyLimit:${state.optionalProperties}>${dialect.maxOptionalProperties}`);
+  }
+  if (dialect.strict === "unsupported") {
+    return {
+      schema: compiled,
+      sendStrict: false,
+      status: "notAttempted",
+      refusalReasons: []
+    };
+  }
+  if (state.blockers.length > 0) {
+    return {
+      schema,
+      sendStrict: false,
+      status: "refused",
+      refusalReasons: dedupe(state.blockers)
+    };
+  }
+  return { schema: compiled, sendStrict: true, status: "applied", refusalReasons: [] };
 }
 
+// ../core/src/execution/engine/llm/schema/dialect.ts
+var ANTHROPIC_DIALECT = {
+  strict: "optionalAllowed",
+  // No placeholder of its own: an empty or absent `properties` becomes a bare `properties: {}`,
+  // synthesized directly by the walk for any dialect engaging strict.
+  // Refuses rather than inlining: detecting recursion through `$defs` is more machinery than the
+  // payoff justifies for a tool-input schema.
+  refs: "refuse",
+  allowsSchemaKeyword: false,
+  // Anthropic's published ceiling. Measured live before this was added: the Command Center
+  // assistant's iteration schema declares 33, so 8 of 8 iterations across a 3-turn session were
+  // 400'd and retried unstrict. `optionalAllowed` is still correct -- an optional property is
+  // representable in this grammar, there is just a cap on how many.
+  maxOptionalProperties: 24
+};
+var OPENAI_DIALECT = {
+  strict: "allRequired",
+  refs: "passthrough",
+  allowsSchemaKeyword: false
+};
+var OPENROUTER_DIALECT = {
+  strict: "allRequired",
+  refs: "refuse",
+  allowsSchemaKeyword: false
+};
+var PROVIDER_DIALECTS = {
+  anthropic: ANTHROPIC_DIALECT,
+  openai: OPENAI_DIALECT,
+  openrouter: OPENROUTER_DIALECT
+};
+
 // ../core/src/platform/registry/validation.ts
 var RegistryValidationError = class extends Error {
   constructor(orgName, resourceId, field, message) {
@@ -10312,7 +10044,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) {