@elevasis/sdk 1.44.2 → 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 = {
@@ -4479,6 +4490,11 @@ every response:
 and never continue the response envelope in the reasoning text -- nextActions is a separate field
 that you fill separately. A response carrying reasoning alone is discarded and retried.
 
+**Prose fields take real characters, never escape sequences.** A line break in ${includeMessage ? "message or reasoning" : "reasoning"} is
+a real line break -- not the two characters \\n. A quotation mark is the character ", not \\". The
+response is serialized for you; typing the escape yourself puts those literal characters into the
+stored text and in front of the reader.
+
 ## Rules
 
 - Batch independent tool calls in one iteration (faster execution)
@@ -5074,7 +5090,7 @@ function buildIterationResponseSchemaUncached(tools, capabilities) {
   if (capabilities.message !== "off") {
     properties.message = {
       type: "string",
-      description: "Your reply to the user, as plain prose. This is the ONLY field the user sees. Use an empty string only when this iteration just calls tools and you have nothing to say yet."
+      description: 'Your reply to the user, as plain prose. This is the ONLY field the user sees. Use an empty string only when this iteration just calls tools and you have nothing to say yet. Write real line breaks and real quotation marks -- the two characters \\n are not a line break, and \\" is not a quotation mark. Serialization is handled for you.'
     };
   }
   properties.reasoning = { type: "string", description: "Your reasoning process" };
@@ -5094,7 +5110,15 @@ function buildIterationResponseSchemaUncached(tools, capabilities) {
             type: "object",
             properties: {
               key: { type: "string" },
-              value: { type: "string" }
+              value: {
+                type: "string",
+                // `memoryOps` has NO framework prompt section -- a grep across `prompt-sections/`
+                // 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
@@ -5113,6 +5137,59 @@ function buildIterationResponseSchemaUncached(tools, capabilities) {
   };
 }
 
+// ../core/src/execution/engine/agent/reasoning/adapters/prose-escapes.ts
+var BACKSLASH = String.fromCharCode(92);
+function normalizeProseEscapes(text) {
+  if (!text.includes(BACKSLASH)) return text;
+  let out = "";
+  let i = 0;
+  while (i < text.length) {
+    const char = text[i];
+    if (char !== BACKSLASH || i + 1 >= text.length) {
+      out += char;
+      i += 1;
+      continue;
+    }
+    switch (text[i + 1]) {
+      case BACKSLASH:
+        out += BACKSLASH + BACKSLASH;
+        i += 2;
+        break;
+      case "n":
+        out += "\n";
+        i += 2;
+        break;
+      case "r":
+        if (text[i + 2] === BACKSLASH && text[i + 3] === "n") {
+          out += "\n";
+          i += 4;
+        } else {
+          out += "\n";
+          i += 2;
+        }
+        break;
+      case "t":
+        out += "	";
+        i += 2;
+        break;
+      case '"':
+        out += '"';
+        i += 2;
+        break;
+      default:
+        out += char;
+        i += 1;
+    }
+  }
+  return out;
+}
+function normalizeMemoryValue(value) {
+  if (typeof value !== "string") return value;
+  const trimmed = value.trim();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) return value;
+  return normalizeProseEscapes(value);
+}
+
 // ../core/src/execution/engine/agent/reasoning/adapters/agent-adapter-helpers.ts
 var MemoryKeyValuePairSchema = z.object({ key: z.string(), value: z.any() });
 var MemorySetSchema = z.union([z.record(z.string(), z.any()), z.array(MemoryKeyValuePairSchema)]).transform((value) => {
@@ -5124,13 +5201,33 @@ var MemoryOperationsSchema = z.object({
   // Accept any value type - framework will stringify
   delete: z.array(z.string()).optional()
 });
-var AgentIterationOutputSchema = z.object({
+var AgentIterationOutputObjectSchema = z.object({
   reasoning: z.string(),
   message: z.string().optional(),
   memoryOps: MemoryOperationsSchema.optional(),
   nextActions: z.array(AgentActionSchema)
 });
-var REQUIRED_ITERATION_KEYS = Object.entries(AgentIterationOutputSchema.shape).filter(([, fieldSchema]) => !fieldSchema.isOptional()).map(([key]) => key);
+function normalizeIterationProse(output) {
+  const normalized = { ...output };
+  normalized.reasoning = normalizeProseEscapes(output.reasoning);
+  if (typeof output.message === "string") {
+    normalized.message = normalizeProseEscapes(output.message);
+  }
+  if (output.memoryOps?.set) {
+    normalized.memoryOps = {
+      ...output.memoryOps,
+      set: Object.fromEntries(
+        Object.entries(output.memoryOps.set).map(([key, value]) => [key, normalizeMemoryValue(value)])
+      )
+    };
+  }
+  normalized.nextActions = output.nextActions.map(
+    (action) => action.type === "message" ? { ...action, text: normalizeProseEscapes(action.text) } : action
+  );
+  return normalized;
+}
+var AgentIterationOutputSchema = AgentIterationOutputObjectSchema.transform(normalizeIterationProse);
+var REQUIRED_ITERATION_KEYS = Object.entries(AgentIterationOutputObjectSchema.shape).filter(([, fieldSchema]) => !fieldSchema.isOptional()).map(([key]) => key);
 function withSynthesizedMessage(nextActions, message) {
   const text = message?.trim();
   if (!text) {
@@ -5265,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({
@@ -5348,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(),
@@ -5594,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);
@@ -5635,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()}`
     );
   }
 }
@@ -5895,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) {
@@ -5907,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}`
+      );
     }
   }
 }
@@ -6048,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
@@ -6337,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.
@@ -6483,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
@@ -6523,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();
@@ -6636,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,
@@ -6673,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: [] };
   }
@@ -6832,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,
@@ -7049,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,
@@ -8981,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(),
   /**
@@ -9012,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";
 }
@@ -9111,412 +9139,80 @@ 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 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"
-      );
-      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 } : {}
-      };
-    }
-  }
-  return Object.fromEntries(
-    Object.entries(results).sort(([, a3], [, b2]) => a3.order - b2.order || a3.key.localeCompare(b2.key))
-  );
+function isPlainRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-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 getCatalogEntries(catalog) {
+  return isPlainRecord(catalog.entries) ? catalog.entries : {};
 }
-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;
+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 }
+      );
       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;
+    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 (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 }
-      );
+    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);
@@ -9533,7 +9229,7 @@ function requireScopedBinding(issues, boundIds, bindingKey, ontologyId, context)
     "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 }
+    { path: readinessMarkerFieldPath(context, ".resourceIds"), ref: ontologyId }
   );
 }
 function ontologyOwnerMatches(ontologyId, expectedSystemPath, catalog) {
@@ -9595,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
-      }
-    }
-  };
-}
-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,
@@ -9728,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(
@@ -9784,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
     };
@@ -9813,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);
     }
@@ -9835,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) {
@@ -10226,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) {