@elevasis/sdk 1.54.0 → 1.55.0

package/dist/{chunk-ZAVFBZHM.js → chunk-72ZGICTR.js}

@@ -1,4 +1,4 @@
-import { ProcessingStageStatusSchema, ListBuilderStageKeySchema, LLMResponseParseError, errorToString, getErrorDetails, ExecutionError2, validateEntryPoint, validateTerminalSteps, validateStepReferences, WorkflowTimeoutError, WorkflowStalledError, WorkflowCancellationError, logWorkflowStart, detectCycle, WorkflowStepError, logStepStart, validateTerminalOutput, logStepSuccess, determineNextStep, logStepFailure, logExecutionPath, logWorkflowSuccess, logWorkflowFailure, estimateTokens, allSettledWithConcurrency, truncationCharBudget, buildIterationResponseSchema } from './chunk-OT4CHFQJ.js';
+import { ProcessingStageStatusSchema, ListBuilderStageKeySchema, LLMResponseParseError, errorToString, getErrorDetails, ExecutionError2, validateEntryPoint, validateTerminalSteps, validateStepReferences, WorkflowTimeoutError, WorkflowStalledError, WorkflowCancellationError, WorkflowStepTimeoutError, logWorkflowStart, detectCycle, WorkflowStepError, logStepStart, validateTerminalOutput, logStepSuccess, determineNextStep, logStepFailure, logExecutionPath, logWorkflowSuccess, logWorkflowFailure, estimateTokens, allSettledWithConcurrency, calculateCost, truncationCharBudget, buildIterationResponseSchema } from './chunk-R3J6BEPO.js';
 import { workerData, parentPort } from 'worker_threads';
 import { zodToJsonSchema } from '@alcyone-labs/zod-to-json-schema';
 import { z, ZodError } from 'zod';
@@ -65,6 +65,71 @@ var Workflow = class {
     }
     return new WorkflowCancellationError("Execution cancelled by user", { stepId, executionPath });
   }
+  /**
+   * Run one step's handler, bounded by the step's own `timeout` when it declares one.
+   *
+   * Two things have to happen for a step deadline to mean anything, and doing only one of them is
+   * why this is not a bare `Promise.race`:
+   *
+   * 1. The handler is handed a context whose `signal` is the step's, chained off the execution's, so
+   *    a handler that already honours `context.signal` (every `fetch`-based one does) aborts its own
+   *    work at the step deadline instead of running on unattended.
+   * 2. The race rejects regardless, because a handler that ignores its signal would otherwise hold
+   *    the graph open until the 2-hour execution ceiling -- which is the whole thing being fixed.
+   *
+   * The chaining direction matches `startExecutionDeadline` in the API's `lifecycle.ts`: the parent's
+   * abort reason is propagated verbatim into the child controller, so an execution-level cancel or
+   * timeout still classifies as itself rather than as a step deadline.
+   *
+   * A step with no `timeout` takes the untouched path and is handed `context` itself -- no derived
+   * controller, no listener, no race.
+   */
+  async runStepHandler(step, input, context, executionPath) {
+    if (step.timeout === void 0) return step.handler(input, context);
+    const controller = new AbortController();
+    let deadlineFired = false;
+    const timer = setTimeout(() => {
+      deadlineFired = true;
+      controller.abort("timeout");
+    }, step.timeout);
+    let onParentAbort;
+    if (context.signal) {
+      if (context.signal.aborted) {
+        controller.abort(context.signal.reason);
+      } else {
+        onParentAbort = () => controller.abort(context.signal?.reason);
+        context.signal.addEventListener("abort", onParentAbort, { once: true });
+      }
+    }
+    const aborted = new Promise((_, reject) => {
+      controller.signal.addEventListener(
+        "abort",
+        () => {
+          if (deadlineFired) {
+            reject(
+              new WorkflowStepTimeoutError(`Step exceeded its timeout (${step.timeout}ms) [${step.id}:${step.name}]`, {
+                timeout: step.timeout,
+                stepId: step.id,
+                stepName: step.name,
+                executionPath
+              })
+            );
+            return;
+          }
+          reject(
+            this.abortErrorFor(context.signal, step.id, executionPath) ?? new WorkflowCancellationError("Execution cancelled by user", { stepId: step.id, executionPath })
+          );
+        },
+        { once: true }
+      );
+    });
+    try {
+      return await Promise.race([step.handler(input, { ...context, signal: controller.signal }), aborted]);
+    } finally {
+      clearTimeout(timer);
+      if (onParentAbort) context.signal?.removeEventListener("abort", onParentAbort);
+    }
+  }
   /**
    * Execute the workflow with graph-based flow control
    * Context is required for execution tracking, logging, and organization isolation
@@ -98,7 +163,7 @@ var Workflow = class {
         logStepStart(context, step.id, step.name, currentData, stepStartTime);
         try {
           const validatedInput = step.inputSchema.parse(currentData);
-          const rawOutput = await step.handler(validatedInput, context);
+          const rawOutput = await this.runStepHandler(step, validatedInput, context, executionPath);
           currentData = step.outputSchema.parse(rawOutput);
           if (step.next === null && this.shouldGenerateOutput) {
             validateTerminalOutput(step.id, currentData, this.contract.outputSchema);
@@ -120,6 +185,9 @@ var Workflow = class {
           const stepEndTime = Date.now();
           const duration = stepEndTime - stepStartTime;
           logStepFailure(context, step.id, step.name, error, duration, stepStartTime, stepEndTime);
+          if (error instanceof WorkflowStepTimeoutError || error instanceof WorkflowTimeoutError || error instanceof WorkflowStalledError || error instanceof WorkflowCancellationError) {
+            throw error;
+          }
           const cause = error instanceof ExecutionError2 ? error : void 0;
           throw new WorkflowStepError(
             `Step failed [${step.id}:${step.name}]: ${errorToString(error)}`,
@@ -1255,6 +1323,12 @@ function normalizeSessionMessages(actions, sessionCapable) {
 }
 var NO_PROGRESS_STREAK_KEY = "agent.actions.noProgressStreak";
 var MAX_CONSECUTIVE_NO_PROGRESS_ITERATIONS = 2;
+var LAST_PLAN_SIGNATURE_KEY = "agent.actions.lastPlanSignature";
+var REPEATED_PLAN_STREAK_KEY = "agent.actions.repeatedPlanStreak";
+var DEFAULT_MAX_IDENTICAL_ITERATIONS = 3;
+function planSignature(actions) {
+  return JSON.stringify(actions);
+}
 async function processActions(iterationContext, response) {
   const normalizedActions = normalizeSessionMessages(response.nextActions, !!iterationContext.config.sessionCapable);
   if (normalizedActions.length === 0) {
@@ -1278,6 +1352,31 @@ async function processActions(iterationContext, response) {
     }
   } else {
     iterationContext.executionContext.store.delete(NO_PROGRESS_STREAK_KEY);
+    const store = iterationContext.executionContext.store;
+    const signature = planSignature(normalizedActions);
+    const repeated = store.get(LAST_PLAN_SIGNATURE_KEY) === signature;
+    const streak = repeated ? (store.get(REPEATED_PLAN_STREAK_KEY) ?? 0) + 1 : 0;
+    store.set(LAST_PLAN_SIGNATURE_KEY, signature);
+    store.set(REPEATED_PLAN_STREAK_KEY, streak);
+    if (repeated) {
+      const ceiling = iterationContext.config.constraints?.maxIdenticalIterations ?? DEFAULT_MAX_IDENTICAL_ITERATIONS;
+      iterationContext.memoryManager.addToHistory({
+        type: "error",
+        content: JSON.stringify({
+          error: `This iteration's plan is identical to the previous one (repeated ${streak}x). Repeating it again will produce the same result. Either act on what the last result returned, or complete.`
+        }),
+        turnNumber: iterationContext.executionContext.sessionTurnNumber ?? null,
+        iterationNumber: iterationContext.iteration,
+        source: "framework"
+      });
+      if (streak >= ceiling) {
+        throw new AgentNoProgressError(`Agent repeated an identical plan for ${streak} consecutive iterations`, {
+          iteration: iterationContext.iteration,
+          streak,
+          ceiling
+        });
+      }
+    }
   }
   const completeRequested = normalizedActions.some((action) => action.type === "complete");
   const toolCalls = [];
@@ -2139,6 +2238,14 @@ var Agent = class {
     while (iteration <= maxIterations) {
       const abortError = this.abortErrorFor(context.signal, iteration);
       if (abortError) throw abortError;
+      const spendStop = this.spendCeilingReached(context);
+      if (spendStop) {
+        context.logger.warn(
+          `Agent stopped at iteration ${iteration}: ${spendStop.limit} ceiling of ${spendStop.ceiling} reached (${spendStop.actual})`
+        );
+        this.stopReason = "spend_exhausted";
+        return;
+      }
       try {
         await context.onHeartbeat?.();
       } catch {
@@ -2162,6 +2269,33 @@ var Agent = class {
     }
     this.stopReason = "budget_exhausted";
   }
+  /**
+   * Whether a declared spend ceiling has been reached, and which one.
+   *
+   * Reads `ExecutionContext.aiUsageCollector` -- the same collector `ObservabilityService` persists
+   * to `execution_metrics` -- so enforcement and the recorded figure can never disagree. The
+   * collector was already being written on every LLM call and read only after the fact; this is the
+   * first place its running total decides anything.
+   *
+   * Returns `null` when no ceiling is declared, or when no collector was injected. An execution
+   * without a collector is not silently capped at zero -- it is uncapped, which is what it was
+   * before any of this existed.
+   *
+   * @returns the breached ceiling, or `null` when none is.
+   */
+  spendCeilingReached(context) {
+    const { maxCostUsd, maxTotalTokens } = this.config.constraints ?? {};
+    if (maxCostUsd === void 0 && maxTotalTokens === void 0) return null;
+    const summary = context.aiUsageCollector?.getSummary();
+    if (!summary) return null;
+    if (maxCostUsd !== void 0 && summary.totalCostUsd >= maxCostUsd) {
+      return { limit: "maxCostUsd", ceiling: maxCostUsd, actual: summary.totalCostUsd };
+    }
+    if (maxTotalTokens !== void 0 && summary.totalTokens >= maxTotalTokens) {
+      return { limit: "maxTotalTokens", ceiling: maxTotalTokens, actual: summary.totalTokens };
+    }
+    return null;
+  }
   /**
    * Classify an aborted signal into the typed error the rest of the framework expects, regardless
    * of where the abort surfaced. An abort landing mid-`fetch` or mid-tool throws whatever the
@@ -2589,6 +2723,78 @@ Fix the errors and generate a valid output.
     }
   }
 };
+
+// ../core/src/operations/observability/ai-usage-collector.ts
+var AIUsageCollector = class {
+  model = "gpt-5";
+  // Default, will be overwritten on first record()
+  calls = [];
+  callSequence = 0;
+  /**
+   * Record a single AI call with usage metrics
+   *
+   * @param usage - Token usage and latency data from LLM adapter
+   * @param callType - Type discriminator (agent-reasoning, tool, etc.)
+   * @param context - Optional typed context specific to callType
+   */
+  record(usage, callType = "other", context) {
+    this.callSequence++;
+    this.model = usage.model;
+    const costUsd = usage.cost ?? calculateCost(
+      usage.model,
+      usage.inputTokens,
+      usage.outputTokens,
+      usage.cacheReadInputTokens,
+      usage.cacheCreationInputTokens
+    );
+    const inputTokens = usage.inputTokens + (usage.cacheReadInputTokens ?? 0) + (usage.cacheCreationInputTokens ?? 0);
+    this.calls.push({
+      callSequence: this.callSequence,
+      callType,
+      model: usage.model,
+      inputTokens,
+      outputTokens: usage.outputTokens,
+      costUsd,
+      latencyMs: usage.latencyMs,
+      context,
+      ...usage.cacheReadInputTokens !== void 0 ? { cacheReadInputTokens: usage.cacheReadInputTokens } : {},
+      ...usage.cacheCreationInputTokens !== void 0 ? { cacheCreationInputTokens: usage.cacheCreationInputTokens } : {},
+      ...usage.inputWarnings?.length ? { inputWarnings: usage.inputWarnings } : {},
+      ...usage.inputWarningsBySource?.length ? { inputWarningsBySource: usage.inputWarningsBySource } : {},
+      ...usage.inputBlocked ? { inputBlocked: true } : {},
+      ...usage.outputValidationError ? { outputValidationError: usage.outputValidationError } : {},
+      ...usage.unvalidatedOutput ? { unvalidatedOutput: usage.unvalidatedOutput } : {},
+      ...usage.strictStatus ? { strictStatus: usage.strictStatus } : {},
+      ...usage.strictRefusalReasons?.length ? { strictRefusalReasons: usage.strictRefusalReasons } : {},
+      ...usage.providerMs !== void 0 ? { providerMs: usage.providerMs } : {},
+      ...usage.validateMs !== void 0 ? { validateMs: usage.validateMs } : {},
+      ...usage.wallClockMs !== void 0 ? { wallClockMs: usage.wallClockMs } : {}
+    });
+  }
+  /**
+   * Get aggregated summary of all AI calls
+   */
+  getSummary() {
+    const totalInputTokens = this.calls.reduce((sum, c) => sum + c.inputTokens, 0);
+    const totalOutputTokens = this.calls.reduce((sum, c) => sum + c.outputTokens, 0);
+    const totalCostUsd = this.calls.reduce((sum, c) => sum + c.costUsd, 0);
+    return {
+      model: this.model,
+      totalInputTokens,
+      totalOutputTokens,
+      totalTokens: totalInputTokens + totalOutputTokens,
+      totalCostUsd,
+      callCount: this.calls.length,
+      calls: this.calls
+    };
+  }
+  /**
+   * Check if any usage has been recorded
+   */
+  hasUsage() {
+    return this.calls.length > 0;
+  }
+};
 var RETRYABLE_CODES = /* @__PURE__ */ new Set([
   "rate_limit_exceeded",
   "network_error",
@@ -2756,11 +2962,14 @@ var platform = {
 
 // src/worker/llm-adapter.ts
 var PostMessageLLMAdapter = class {
-  constructor(provider, model) {
+  constructor(provider, model, aiUsageCollector, callType) {
     this.provider = provider;
     this.model = model;
+    this.aiUsageCollector = aiUsageCollector;
+    this.callType = callType;
   }
   async generate(request) {
+    const startedAt = Date.now();
     const { result, usage } = await platform.callWithUsage({
       tool: "llm",
       method: "generate",
@@ -2777,6 +2986,22 @@ var PostMessageLLMAdapter = class {
         maxOutputTokens: request.maxOutputTokens
       }
     });
+    if (usage && this.aiUsageCollector) {
+      this.aiUsageCollector.record(
+        {
+          model: usage.model ?? this.model,
+          inputTokens: usage.inputTokens,
+          outputTokens: usage.outputTokens,
+          latencyMs: Date.now() - startedAt,
+          ...usage.cost !== void 0 && { cost: usage.cost },
+          ...usage.cacheReadInputTokens !== void 0 && { cacheReadInputTokens: usage.cacheReadInputTokens },
+          ...usage.cacheCreationInputTokens !== void 0 && {
+            cacheCreationInputTokens: usage.cacheCreationInputTokens
+          }
+        },
+        this.callType
+      );
+    }
     return {
       output: result,
       ...usage && {
@@ -2791,10 +3016,11 @@ var PostMessageLLMAdapter = class {
   }
 };
 function createPostMessageAdapterFactory() {
-  return (config) => new PostMessageLLMAdapter(config.provider, config.model);
+  return (config, aiUsageCollector, callType) => new PostMessageLLMAdapter(config.provider, config.model, aiUsageCollector, callType);
 }
+var FULL_TOKEN_HEX_LENGTH = 32;
 function generateHmacToken(secret, data) {
-  return createHmac("sha256", secret).update(data.toLowerCase().trim()).digest("hex").slice(0, 16);
+  return createHmac("sha256", secret).update(data.toLowerCase().trim()).digest("hex").slice(0, FULL_TOKEN_HEX_LENGTH);
 }
 function classifyPlatformToolError(err, options = {}) {
   const {
@@ -4244,6 +4470,12 @@ function buildWorkerExecutionContext(params) {
     organizationId: params.organizationId,
     organizationName: params.organizationName,
     resourceId: params.resourceId,
+    // Worker-side usage accounting. The parent keeps its own collector and remains the source of the
+    // persisted `execution_metrics` row; this one exists so the agent loop — which runs in this
+    // thread — can read what the turn has spent so far and stop at a declared ceiling. Without it
+    // `Agent.iterate` read `undefined` on every deployed execution and treated every agent as
+    // uncapped, which a local dogfood run on 2026-09-02 is what caught.
+    aiUsageCollector: new AIUsageCollector(),
     sessionId: params.sessionId,
     sessionTurnNumber: params.sessionTurnNumber,
     conversationHistory: params.conversationHistory,
@@ -4450,19 +4682,28 @@ function startWorker(org) {
           const durationMs = Date.now() - startTime;
           const stopReason = agentInstance.getStopReason();
           const budgetExhausted = stopReason === "budget_exhausted";
+          const spendExhausted = stopReason === "spend_exhausted";
+          const stoppedShort = budgetExhausted || spendExhausted;
           if (budgetExhausted) {
             console.warn(`[SDK-WORKER] Agent '${resourceId}' exhausted its iteration budget (${durationMs}ms)`);
+          } else if (spendExhausted) {
+            console.warn(`[SDK-WORKER] Agent '${resourceId}' reached its cost/token ceiling (${durationMs}ms)`);
           } else {
             console.log(`[SDK-WORKER] Agent '${resourceId}' completed (${durationMs}ms)`);
           }
           parentPort.postMessage({
             type: "result",
-            status: budgetExhausted ? "failed" : "completed",
+            status: stoppedShort ? "failed" : "completed",
             ...budgetExhausted ? {
               error: "Agent stopped without completing: iteration budget exhausted. Any output below was synthesized from partial work.",
               errorName: "AgentBudgetExhaustedError",
               errorCode: "agent_budget_exhausted"
             } : {},
+            ...spendExhausted ? {
+              error: "Agent stopped without completing: cost or token ceiling reached. Any output below was synthesized from partial work.",
+              errorName: "AgentSpendExhaustedError",
+              errorCode: "agent_spend_exhausted"
+            } : {},
             output,
             stopReason,
             // Whether the agent emitted an assistant message this turn. `Agent` has tracked this for

package/dist/{chunk-OT4CHFQJ.js → chunk-R3J6BEPO.js}

@@ -814,14 +814,25 @@ var SystemEntrySchema = z.object({
    * position-derived paths. Both still exist on this schema for backward compat.
    */
   systems: z.lazy(() => z.record(z.string().trim().min(1).max(100), SystemEntrySchema)).optional(),
-  /** @deprecated Use systems. Accepted as a compatibility alias during the ontology bridge. */
+  /**
+   * @deprecated Use systems. Accepted as a compatibility alias during the ontology bridge.
+   *
+   * Accepted on INPUT only. Parsing used to mirror `systems` into this key so that
+   * either spelling could be read off a parsed model, which meant every parsed System
+   * carried the same children twice. Readers that walked both keys then visited each
+   * nested System twice -- `getOrgOsRouteContractSystems` reported 11 checked paths
+   * against command-center's 7 real Systems and would have raised every nested-System
+   * failure as two failures -- and readers that walked this key alone looked correct
+   * while depending entirely on the mirror. Both defects were live. The mirror is gone:
+   * a parsed model now carries children under whichever key the author wrote, so read
+   * `system.systems ?? system.subsystems` (helpers.ts, validation.ts, ontology.ts,
+   * selectDeclaredSystems.ts, validateManifests.ts and SystemOpsView.tsx all do).
+   */
   subsystems: z.lazy(() => z.record(z.string().trim().min(1).max(100), SystemEntrySchema)).optional()
 }).strict().refine((system) => system.label !== void 0 || system.title !== void 0, {
   path: ["label"],
   message: "System must provide label or title"
-}).transform(
-  (system) => system.systems !== void 0 && system.subsystems === void 0 ? { ...system, subsystems: system.systems } : system
-);
+});
 z.record(z.string(), SystemEntrySchema).refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
   message: "Each system entry id must match its map key"
 }).default({});
@@ -1992,6 +2003,8 @@ var AnthropicConfigSchema = z.discriminatedUnion("model", [
   AnthropicClaude5ConfigSchema,
   AnthropicStandardConfigSchema
 ]);
+var ANTHROPIC_CACHE_READ_RATE_MULTIPLIER = 0.1;
+var OPENAI_CACHE_READ_RATE_MULTIPLIER = 0.5;
 var GPT56_CACHE_READ_RATE_MULTIPLIER = 0.1;
 var CACHE_CREATION_RATE_MULTIPLIER = 1.25;
 var MODEL_INFO = {
@@ -2188,6 +2201,30 @@ function getModelInfo(model) {
   }
   return void 0;
 }
+function cacheReadRateMultiplier(model, info) {
+  if (info?.cacheReadRateMultiplier !== void 0) return info.cacheReadRateMultiplier;
+  return model.startsWith("claude-") ? ANTHROPIC_CACHE_READ_RATE_MULTIPLIER : OPENAI_CACHE_READ_RATE_MULTIPLIER;
+}
+function cacheCreationRateMultiplier(info) {
+  return info?.cacheCreationRateMultiplier ?? CACHE_CREATION_RATE_MULTIPLIER;
+}
+function calculateCost(model, inputTokens, outputTokens, cacheReadInputTokens = 0, cacheCreationInputTokens = 0) {
+  const info = getModelInfo(model);
+  if (!info) {
+    console.warn(
+      `[CostCalculator] Unknown model '${model}' - cannot calculate cost. Available models:`,
+      Object.keys(MODEL_INFO)
+    );
+    return 0;
+  }
+  const baseInputRate = info.inputCostPer1M / 100;
+  const inputCostUsd = inputTokens / 1e6 * baseInputRate;
+  const cacheReadCostUsd = cacheReadInputTokens / 1e6 * baseInputRate * cacheReadRateMultiplier(model, info);
+  const cacheCreationCostUsd = cacheCreationInputTokens / 1e6 * baseInputRate * cacheCreationRateMultiplier(info);
+  const outputCostUsd = outputTokens / 1e6 * (info.outputCostPer1M / 100);
+  const totalCostUsd = inputCostUsd + cacheReadCostUsd + cacheCreationCostUsd + outputCostUsd;
+  return totalCostUsd;
+}
 function validateModelConfig(config) {
   const model = config.model;
   if (!model) {
@@ -2615,6 +2652,18 @@ var WorkflowTimeoutError = class extends ExecutionError2 {
     return false;
   }
 };
+var WorkflowStepTimeoutError = class extends ExecutionError2 {
+  type = "workflow_step_timeout_error";
+  severity = "critical";
+  category = "workflow";
+  constructor(message, context) {
+    super(message, context);
+  }
+  /** The run still had budget; a slow dependency is exactly the case a retry exists for. */
+  isRetryable() {
+    return true;
+  }
+};
 var WorkflowStalledError = class extends ExecutionError2 {
   type = "workflow_stalled_error";
   severity = "critical";
@@ -5962,4 +6011,4 @@ function defineWorkflowConfig(resourceId, descriptors, actionRegistry = []) {
 }
 var ListBuilderStageKeySchema = z.string().min(1);
 
-export { ActivityEventSchema, BuildPlanSnapshotStepSchema, ContractRefResolutionError, CrmStageKeySchema, CrmStateKeySchema, EmailSchema, ExecutionError, ExecutionError2, LLMResponseParseError, ListBuilderStageKeySchema, ProcessingStageStatusSchema, ProspectingBuildTemplateSchema, RegistryValidationError, ResourceRegistry, StepType, ToolingError, WorkflowCancellationError, WorkflowStalledError, WorkflowStepError, WorkflowTimeoutError, allSettledWithConcurrency, bindResourceDescriptor, buildIterationResponseSchema, compileBusinessOntologyValidationIndex, concurrentPool, createLeadGenStageValidators, defineContract, defineResource, defineResourceOntology, defineResources, defineSingleStepWorkflow, defineTopology, defineTopologyRelationship, defineWorkflowConfig, deriveActions, detectCycle, determineNextStep, diagnosticOutput, errorToString, estimateTokens, getErrorDetails, integrationInput, isBuiltInReadinessProfile, isZodType, logExecutionPath, logStepFailure, logStepStart, logStepSuccess, logWorkflowFailure, logWorkflowStart, logWorkflowSuccess, lookupReadinessProfile, parseTopologyNodeRef, registerReadinessProfile, resolveContractRef, runDiagnostic, splitName, topologyRef, topologyRelationship, truncationCharBudget, validateDeclaredSystemInterfaceReadiness, validateDeploymentSpec, validateEntryPoint, validateRelationships, validateResourceGovernance, validateStepReferences, validateTerminalOutput, validateTerminalSteps };
+export { ActivityEventSchema, BuildPlanSnapshotStepSchema, ContractRefResolutionError, CrmStageKeySchema, CrmStateKeySchema, EmailSchema, ExecutionError, ExecutionError2, LLMResponseParseError, ListBuilderStageKeySchema, ProcessingStageStatusSchema, ProspectingBuildTemplateSchema, RegistryValidationError, ResourceRegistry, StepType, ToolingError, WorkflowCancellationError, WorkflowStalledError, WorkflowStepError, WorkflowStepTimeoutError, WorkflowTimeoutError, allSettledWithConcurrency, bindResourceDescriptor, buildIterationResponseSchema, calculateCost, compileBusinessOntologyValidationIndex, concurrentPool, createLeadGenStageValidators, defineContract, defineResource, defineResourceOntology, defineResources, defineSingleStepWorkflow, defineTopology, defineTopologyRelationship, defineWorkflowConfig, deriveActions, detectCycle, determineNextStep, diagnosticOutput, errorToString, estimateTokens, getErrorDetails, integrationInput, isBuiltInReadinessProfile, isZodType, logExecutionPath, logStepFailure, logStepStart, logStepSuccess, logWorkflowFailure, logWorkflowStart, logWorkflowSuccess, lookupReadinessProfile, parseTopologyNodeRef, registerReadinessProfile, resolveContractRef, runDiagnostic, splitName, topologyRef, topologyRelationship, truncationCharBudget, validateDeclaredSystemInterfaceReadiness, validateDeploymentSpec, validateEntryPoint, validateRelationships, validateResourceGovernance, validateStepReferences, validateTerminalOutput, validateTerminalSteps };

package/dist/cli.cjs

@@ -23791,14 +23791,25 @@ var init_systems = __esm({
        * position-derived paths. Both still exist on this schema for backward compat.
        */
       systems: external_exports.lazy(() => external_exports.record(external_exports.string().trim().min(1).max(100), SystemEntrySchema)).optional(),
-      /** @deprecated Use systems. Accepted as a compatibility alias during the ontology bridge. */
+      /**
+       * @deprecated Use systems. Accepted as a compatibility alias during the ontology bridge.
+       *
+       * Accepted on INPUT only. Parsing used to mirror `systems` into this key so that
+       * either spelling could be read off a parsed model, which meant every parsed System
+       * carried the same children twice. Readers that walked both keys then visited each
+       * nested System twice -- `getOrgOsRouteContractSystems` reported 11 checked paths
+       * against command-center's 7 real Systems and would have raised every nested-System
+       * failure as two failures -- and readers that walked this key alone looked correct
+       * while depending entirely on the mirror. Both defects were live. The mirror is gone:
+       * a parsed model now carries children under whichever key the author wrote, so read
+       * `system.systems ?? system.subsystems` (helpers.ts, validation.ts, ontology.ts,
+       * selectDeclaredSystems.ts, validateManifests.ts and SystemOpsView.tsx all do).
+       */
       subsystems: external_exports.lazy(() => external_exports.record(external_exports.string().trim().min(1).max(100), SystemEntrySchema)).optional()
     }).strict().refine((system) => system.label !== void 0 || system.title !== void 0, {
       path: ["label"],
       message: "System must provide label or title"
-    }).transform(
-      (system) => system.systems !== void 0 && system.subsystems === void 0 ? { ...system, subsystems: system.systems } : system
-    );
+    });
     SystemsDomainSchema = external_exports.record(external_exports.string(), SystemEntrySchema).refine((record2) => Object.entries(record2).every(([key, entry]) => entry.id === key), {
       message: "Each system entry id must match its map key"
     }).default({});
@@ -47048,6 +47059,20 @@ var init_api2 = __esm({
   }
 });
 
+// ../core/src/platform/errors/index.ts
+var init_errors6 = __esm({
+  "../core/src/platform/errors/index.ts"() {
+    "use strict";
+  }
+});
+
+// ../core/src/platform/errors/disclosure.ts
+var init_disclosure = __esm({
+  "../core/src/platform/errors/disclosure.ts"() {
+    "use strict";
+  }
+});
+
 // ../core/src/platform/index.ts
 var init_platform = __esm({
   "../core/src/platform/index.ts"() {
@@ -47057,6 +47082,8 @@ var init_platform = __esm({
     init_registry();
     init_sse();
     init_api2();
+    init_errors6();
+    init_disclosure();
   }
 });
 
@@ -47424,7 +47451,7 @@ var init_sse_executions = __esm({
 });
 
 // ../core/src/execution/core/api-schemas.ts
-var PayloadSchema, OptionalPayloadSchema, ExecutionTargetSchema, OriginTrackingSchema, ExternalExecuteRequestSchema, ExternalExecuteResponseSchema, ExecutionEngineExecuteRequestSchema, ExecutionEngineExecuteResponseSchema, CreateCommandQueueTaskSchema, SubmitDecisionSchema, ListCommandQueueTasksSchema, ListExecutionsSchema, DeleteExecutionsSchema;
+var PayloadSchema, OptionalPayloadSchema, ExecutionTargetSchema, OriginTrackingSchema, ExternalExecuteRequestSchema, ExternalExecuteResponseSchema, ExecutionEngineExecuteRequestSchema, ExecutionEngineExecuteResponseSchema, CreateCommandQueueTaskSchema, SubmitDecisionSchema, ListCommandQueueTasksSchema, ExecutionStatusSchema, ResourceIdParamSchema, ResourceExecutionParamsSchema, ListExecutionsSchema, ListAllExecutionsSchema, DeleteExecutionsSchema, PatchExecutionBodySchema;
 var init_api_schemas = __esm({
   "../core/src/execution/core/api-schemas.ts"() {
     "use strict";
@@ -47506,12 +47533,35 @@ var init_api_schemas = __esm({
       status: external_exports.enum(["pending", "approved", "rejected", "expired"]).optional(),
       limit: PageLimitSchema.default(20)
     }).strict();
-    ListExecutionsSchema = external_exports.object({
-      resourceStatus: external_exports.enum(["dev", "prod", "all"]).default("all")
+    ExecutionStatusSchema = external_exports.enum(["pending", "running", "completed", "failed", "warning"]);
+    ResourceIdParamSchema = external_exports.object({
+      resourceId: NonEmptyStringSchema.max(255)
     }).strict();
+    ResourceExecutionParamsSchema = external_exports.object({
+      resourceId: NonEmptyStringSchema.max(255),
+      executionId: NonEmptyStringSchema.max(255)
+    }).strict();
+    ListExecutionsSchema = external_exports.object({
+      resourceStatus: external_exports.enum(["dev", "prod", "all"]).default("all"),
+      limit: PageLimitSchema.default(DEFAULT_PAGE_LIMIT),
+      offset: PageOffsetSchema
+    });
+    ListAllExecutionsSchema = external_exports.object({
+      resourceId: NonEmptyStringSchema.max(255).optional(),
+      status: external_exports.enum([...ExecutionStatusSchema.options, "all"]).optional(),
+      resourceStatus: external_exports.enum(["dev", "prod", "all"]).optional(),
+      startDate: external_exports.coerce.number().int().nonnegative().optional(),
+      endDate: external_exports.coerce.number().int().nonnegative().optional(),
+      limit: PageLimitSchema.default(DEFAULT_PAGE_LIMIT),
+      offset: PageOffsetSchema
+    });
     DeleteExecutionsSchema = external_exports.object({
       resourceStatus: external_exports.enum(["dev", "prod"]).optional()
     }).strict();
+    PatchExecutionBodySchema = external_exports.object({
+      status: external_exports.enum(["completed", "failed", "warning"]),
+      error: external_exports.string().max(5e3).optional()
+    }).strict();
   }
 });
 
@@ -48149,6 +48199,85 @@ var init_schemas6 = __esm({
   }
 });
 
+// ../core/src/operations/observability/api-schemas.ts
+var ErrorSeveritySchema, ExecutionIdParamSchema, ErrorIdParamSchema, ObservabilityDateRangeQuerySchema, ExecutionLogsQuerySchema, ErrorDetailsQuerySchema, ErrorDistributionQuerySchema, ErrorTrendsQuerySchema, TopFailingResourcesQuerySchema, RecentExecutionsByResourceQuerySchema, CostTrendsQuerySchema, ResourceHealthTargetSchema, ResourcesHealthBodySchema, SystemHealthResourceKindSchema, SystemHealthResourceDescriptorSchema, SystemHealthBodySchema;
+var init_api_schemas3 = __esm({
+  "../core/src/operations/observability/api-schemas.ts"() {
+    "use strict";
+    init_zod();
+    init_validation();
+    ErrorSeveritySchema = external_exports.enum(["critical", "warning", "info"]);
+    ExecutionIdParamSchema = external_exports.object({ executionId: NonEmptyStringSchema.max(255) }).strict();
+    ErrorIdParamSchema = external_exports.object({ errorId: external_exports.string().uuid() }).strict();
+    ObservabilityDateRangeQuerySchema = external_exports.object({
+      startDate: TimestampSchema.optional(),
+      endDate: TimestampSchema.optional()
+    });
+    ExecutionLogsQuerySchema = ObservabilityDateRangeQuerySchema.extend({
+      page: external_exports.coerce.number().int().min(1).default(1),
+      limit: PageLimitSchema.default(DEFAULT_PAGE_LIMIT),
+      // Left as bounded strings rather than enums. The service passes both straight into `.eq()`, and an
+      // unknown value returns an empty page rather than misbehaving — so an enum here would assert a
+      // catalog this schema has no way to keep in step with the column.
+      resourceType: external_exports.string().max(100).optional(),
+      status: external_exports.string().max(50).optional(),
+      search: external_exports.string().max(200).optional()
+    });
+    ErrorDetailsQuerySchema = ObservabilityDateRangeQuerySchema.extend({
+      page: external_exports.coerce.number().int().min(1).default(1),
+      limit: PageLimitSchema.default(DEFAULT_PAGE_LIMIT),
+      errorType: external_exports.string().max(100).optional(),
+      severity: ErrorSeveritySchema.optional(),
+      search: external_exports.string().max(200).optional(),
+      // Tri-state on the wire: 'true' and 'false' filter, anything else (including 'all', which the
+      // Command Center sends) means no filter. Coercing to a boolean here would make 'all' read as true.
+      resolved: external_exports.enum(["true", "false", "all"]).optional()
+    });
+    ErrorDistributionQuerySchema = ObservabilityDateRangeQuerySchema.extend({
+      groupBy: external_exports.enum(["type", "severity"]).default("type")
+    });
+    ErrorTrendsQuerySchema = ObservabilityDateRangeQuerySchema.extend({
+      granularity: external_exports.enum(["hour", "day"]).default("day")
+    });
+    TopFailingResourcesQuerySchema = ObservabilityDateRangeQuerySchema.extend({
+      limit: PageLimitSchema.default(10)
+    });
+    RecentExecutionsByResourceQuerySchema = ObservabilityDateRangeQuerySchema.extend({
+      limit: PageLimitSchema.optional()
+    });
+    CostTrendsQuerySchema = ObservabilityDateRangeQuerySchema.extend({
+      granularity: external_exports.enum(["hour", "day"]).default("hour")
+    });
+    ResourceHealthTargetSchema = external_exports.object({
+      entityType: NonEmptyStringSchema.max(100),
+      entityId: NonEmptyStringSchema.max(255)
+    }).strict();
+    ResourcesHealthBodySchema = external_exports.object({
+      resources: external_exports.array(ResourceHealthTargetSchema).min(1).max(20),
+      startDate: TimestampSchema,
+      endDate: TimestampSchema,
+      granularity: external_exports.enum(["hour", "day"])
+    }).strict();
+    SystemHealthResourceKindSchema = external_exports.enum(["workflow", "agent", "integration", "script"]);
+    SystemHealthResourceDescriptorSchema = external_exports.object({
+      id: NonEmptyStringSchema.max(255),
+      kind: SystemHealthResourceKindSchema,
+      systemPath: external_exports.string().max(500).optional(),
+      executable: external_exports.boolean().optional()
+    }).strict();
+    SystemHealthBodySchema = external_exports.object({
+      systemPath: NonEmptyStringSchema.max(500),
+      includeDescendants: external_exports.boolean().optional(),
+      startDate: TimestampSchema,
+      endDate: TimestampSchema,
+      granularity: external_exports.enum(["hour", "day"]).optional(),
+      directResources: external_exports.array(SystemHealthResourceDescriptorSchema).optional(),
+      descendantResources: external_exports.array(SystemHealthResourceDescriptorSchema).optional(),
+      resources: external_exports.array(SystemHealthResourceDescriptorSchema).optional()
+    }).strict();
+  }
+});
+
 // ../core/src/operations/observability/utils.ts
 var init_utils5 = __esm({
   "../core/src/operations/observability/utils.ts"() {
@@ -48162,6 +48291,7 @@ var init_observability = __esm({
     "use strict";
     init_types13();
     init_schemas6();
+    init_api_schemas3();
     init_utils5();
   }
 });
@@ -48192,7 +48322,7 @@ var init_types14 = __esm({
 
 // ../core/src/operations/activities/api-schemas.ts
 var ActivityTypeSchema, ActivityStatusSchema, MetadataSchema, CreateActivitySchema, ActivityTrendQuerySchema, ListActivitiesQuerySchema;
-var init_api_schemas3 = __esm({
+var init_api_schemas4 = __esm({
   "../core/src/operations/activities/api-schemas.ts"() {
     "use strict";
     init_zod();
@@ -48250,7 +48380,7 @@ var init_activities = __esm({
   "../core/src/operations/activities/index.ts"() {
     "use strict";
     init_types14();
-    init_api_schemas3();
+    init_api_schemas4();
     init_sse_events3();
   }
 });
@@ -48689,7 +48819,7 @@ var init_acquisition = __esm({
 
 // ../core/src/business/clients/api-schemas.ts
 var ClientStatusSchema, ClientSourceSchema, ClientIdParamsSchema, ListClientsQuerySchema, ClientRefSchema, ClientResponseSchema, ClientDealRefSchema, ClientProjectRefSchema, ClientCompanyRefSchema, ClientContactRefSchema, ClientLineageSchema, ClientDetailResponseSchema, ClientListResponseSchema, ClientStatusResponseSchema, CreateClientRequestSchema, UpdateClientRequestSchema;
-var init_api_schemas4 = __esm({
+var init_api_schemas5 = __esm({
   "../core/src/business/clients/api-schemas.ts"() {
     "use strict";
     init_zod();
@@ -48803,7 +48933,7 @@ var init_api_schemas4 = __esm({
 var init_clients = __esm({
   "../core/src/business/clients/index.ts"() {
     "use strict";
-    init_api_schemas4();
+    init_api_schemas5();
   }
 });
 
@@ -48951,18 +49081,26 @@ var init_provider_registry = __esm({
   }
 });
 
+// ../core/src/integrations/oauth/errors.ts
+var init_errors7 = __esm({
+  "../core/src/integrations/oauth/errors.ts"() {
+    "use strict";
+  }
+});
+
 // ../core/src/integrations/oauth/index.ts
 var init_oauth = __esm({
   "../core/src/integrations/oauth/index.ts"() {
     "use strict";
     init_types19();
     init_provider_registry();
+    init_errors7();
   }
 });
 
 // ../core/src/integrations/credentials/api-schemas.ts
 var CredentialTypeSchema, CredentialValueSchema, CreateCredentialRequestSchema, CreateCredentialResponseSchema, ListCredentialsResponseSchema, UpdateCredentialParamsSchema, UpdateCredentialRequestSchema, DeleteCredentialParamsSchema, VerifyCredentialParamsSchema, VerifyCredentialResponseSchema;
-var init_api_schemas5 = __esm({
+var init_api_schemas6 = __esm({
   "../core/src/integrations/credentials/api-schemas.ts"() {
     "use strict";
     init_zod();
@@ -49038,7 +49176,7 @@ var init_api_schemas5 = __esm({
 var init_credentials2 = __esm({
   "../core/src/integrations/credentials/index.ts"() {
     "use strict";
-    init_api_schemas5();
+    init_api_schemas6();
   }
 });
 
@@ -49439,7 +49577,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@elevasis/sdk",
-      version: "1.54.0",
+      version: "1.55.0",
       description: "SDK for building Elevasis organization resources",
       type: "module",
       bin: {
@@ -54633,7 +54771,7 @@ function formatText(results) {
   const divider = "-".repeat(header.length + 20);
   const rows = results.map((n) => {
     const summary = n.summary.length > 80 ? n.summary.slice(0, 77) + "..." : n.summary;
-    return `${n.kind.padEnd(kindWidth)}  ${n.id.padEnd(idWidth)}  ${n.title}  \xE2\u20AC\u201D  ${summary}`;
+    return `${n.kind.padEnd(kindWidth)}  ${n.id.padEnd(idWidth)}  ${n.title}  \u2014  ${summary}`;
   });
   return [header, divider, ...rows].join("\n");
 }

package/dist/index.d.ts

@@ -1591,6 +1591,16 @@ interface WorkflowStep extends WorkflowStepDefinition {
     inputSchema: z.ZodSchema;
     outputSchema: z.ZodSchema;
     next: NextConfig;
+    /**
+     * How long this one step may run, in milliseconds. Omitted, the step is bounded only by the
+     * execution ceiling (`DEFAULT_EXECUTION_TIMEOUT`, 2 hours), which is what every step used to get.
+     *
+     * `WorkflowConfig` deliberately still has no `constraints` field: a per-workflow override would
+     * only restate the execution ceiling the caller already sets when it arms the deadline, whereas
+     * "this HTTP step should never take more than 5 seconds" is a property of the step and has no
+     * other place to live.
+     */
+    timeout?: number;
 }
 interface WorkflowDefinition {
     config: WorkflowConfig;
@@ -4387,13 +4397,6 @@ type Database = {
                         referencedRelation: "users";
                         referencedColumns: ["id"];
                     },
-                    {
-                        foreignKeyName: "prj_notes_milestone_id_fkey";
-                        columns: ["milestone_id"];
-                        isOneToOne: false;
-                        referencedRelation: "prj_milestones";
-                        referencedColumns: ["id"];
-                    },
                     {
                         foreignKeyName: "prj_notes_organization_id_fkey";
                         columns: ["organization_id"];
@@ -4407,13 +4410,6 @@ type Database = {
                         isOneToOne: false;
                         referencedRelation: "prj_projects";
                         referencedColumns: ["id"];
-                    },
-                    {
-                        foreignKeyName: "prj_notes_task_id_fkey";
-                        columns: ["task_id"];
-                        isOneToOne: false;
-                        referencedRelation: "prj_tasks";
-                        referencedColumns: ["id"];
                     }
                 ];
             };
@@ -6337,8 +6333,20 @@ interface ProcessingStateEntry {
 type ProcessingState = Partial<Record<LeadGenStageKey, ProcessingStateEntry>>;
 type CompanyProcessingState = ProcessingState;
 type ContactProcessingState = ProcessingState;
-/** @deprecated Use `processingState`. Retained only as a compile-time/read-shape bridge for external tenants. */
-type LegacyPipelineStatus = unknown;
+/**
+ * @deprecated Use `processingState`. Retained only as a compile-time/read-shape bridge for
+ * external tenants.
+ *
+ * `null`, not `unknown`. The DB column is gone and every response returns null, so `unknown` was
+ * describing a value that cannot occur -- it forced a narrow on a field that is always null while
+ * still type-checking a comparison against a stage name that can never match. Narrowing it turns
+ * that dead comparison into a compile error pointing at `processingState`, which is the migration.
+ *
+ * The WRITE path stays permissive on purpose: the update request schemas keep
+ * `pipelineStatus: z.unknown().optional()` so a tenant still sending the old field gets a no-op
+ * rather than a rejected request.
+ */
+type LegacyPipelineStatus = null;
 /**
  * Enrichment data collected for a company from various sources.
  */
@@ -14266,6 +14274,28 @@ interface AgentConstraints {
     timeout?: number;
     maxSessionMemoryKeys?: number;
     maxMemoryTokens?: number;
+    /**
+     * Spend ceilings for the whole turn, checked between iterations against
+     * `ExecutionContext.aiUsageCollector`. Both are unset by default -- `maxIterations` and `timeout`
+     * bound how MANY calls and how LONG, but nothing bounded how much those calls cost, so an agent
+     * that picked an expensive model or a huge context could spend without limit inside a budget it
+     * was technically respecting.
+     *
+     * Enforced only where a collector is injected (every coordinator-run execution). An agent run
+     * without one is unbounded, the same as one that declares no ceiling.
+     *
+     * Note that **sync nested executions share the parent's collector**, so these ceilings cover the
+     * agent and everything it invokes synchronously. That is the behaviour a spend ceiling should
+     * have, but it does mean a parent's ceiling can be reached by a child's spend.
+     */
+    maxCostUsd?: number;
+    maxTotalTokens?: number;
+    /**
+     * How many times the agent may emit a byte-identical plan in a row before the turn is stopped
+     * (default 3, in `processActions`). Raise it for an agent whose job legitimately involves
+     * repeating itself -- polling one endpoint until it reports ready is the case this exists for.
+     */
+    maxIdenticalIterations?: number;
 }
 interface AgentDefinition {
     config: AgentConfig;

package/dist/index.js

@@ -1,2 +1,2 @@
-export { ActivityEventSchema, BuildPlanSnapshotStepSchema, ProspectingBuildTemplateSchema as BuildTemplateSchema, ContractRefResolutionError, CrmStageKeySchema, CrmStateKeySchema, EmailSchema, ExecutionError, ListBuilderStageKeySchema, ProcessingStageStatusSchema, RegistryValidationError, ResourceRegistry, StepType, ToolingError, bindResourceDescriptor, compileBusinessOntologyValidationIndex, concurrentPool, createLeadGenStageValidators, defineContract, defineResource, defineResourceOntology, defineResources, defineSingleStepWorkflow, defineTopology, defineTopologyRelationship, defineWorkflowConfig, deriveActions, diagnosticOutput, integrationInput, isBuiltInReadinessProfile, isZodType, lookupReadinessProfile, parseTopologyNodeRef, registerReadinessProfile, resolveContractRef, runDiagnostic, splitName, topologyRef, topologyRelationship, validateDeclaredSystemInterfaceReadiness, validateResourceGovernance } from './chunk-OT4CHFQJ.js';
+export { ActivityEventSchema, BuildPlanSnapshotStepSchema, ProspectingBuildTemplateSchema as BuildTemplateSchema, ContractRefResolutionError, CrmStageKeySchema, CrmStateKeySchema, EmailSchema, ExecutionError, ListBuilderStageKeySchema, ProcessingStageStatusSchema, RegistryValidationError, ResourceRegistry, StepType, ToolingError, bindResourceDescriptor, compileBusinessOntologyValidationIndex, concurrentPool, createLeadGenStageValidators, defineContract, defineResource, defineResourceOntology, defineResources, defineSingleStepWorkflow, defineTopology, defineTopologyRelationship, defineWorkflowConfig, deriveActions, diagnosticOutput, integrationInput, isBuiltInReadinessProfile, isZodType, lookupReadinessProfile, parseTopologyNodeRef, registerReadinessProfile, resolveContractRef, runDiagnostic, splitName, topologyRef, topologyRelationship, validateDeclaredSystemInterfaceReadiness, validateResourceGovernance } from './chunk-R3J6BEPO.js';
 export { projectDeploymentSpec, projectTopologyRelationships, toSdkResourceDescriptor, withPlatformAgentResourceDescriptor, withPlatformAgentResourceDescriptors, withPlatformIntegrationResourceDescriptor, withPlatformIntegrationResourceDescriptors, withPlatformResourceDescriptor, withPlatformResourceDescriptors } from './chunk-QF2RNYYX.js';

package/dist/test-utils/index.js

@@ -1,5 +1,5 @@
-import { executeWorkflow } from '../chunk-ZAVFBZHM.js';
-import { validateDeploymentSpec, validateRelationships } from '../chunk-OT4CHFQJ.js';
+import { executeWorkflow } from '../chunk-72ZGICTR.js';
+import { validateDeploymentSpec, validateRelationships } from '../chunk-R3J6BEPO.js';
 import '../chunk-QF2RNYYX.js';
 import { vi } from 'vitest';
 

package/dist/worker/index.d.ts

@@ -14,6 +14,15 @@ interface TokenUsage {
     outputTokens: number;
     cost?: number;
     model?: string;
+    /**
+     * Anthropic excludes cache reads and writes from the wire `input_tokens`, and `AIUsageCollector`
+     * adds them back when it records a call. They are forwarded here so the worker-side collector the
+     * spend ceiling reads folds them in exactly as the parent's does — without them the worker's token
+     * total silently runs below the figure `execution_metrics` persists, and a `maxTotalTokens` ceiling
+     * would be enforced against the smaller number.
+     */
+    cacheReadInputTokens?: number;
+    cacheCreationInputTokens?: number;
 }
 /** Resolved credential returned by platform.getCredential() */
 interface PlatformCredential {

package/dist/worker/index.js

@@ -1,3 +1,3 @@
-export { ListBuilderResultSchema, ListBuilderResultsSchema, PlatformToolError, acqDb, approval, artifacts, classifyPlatformToolError, content, createAdapter, createAnymailfinderAdapter, createApifyAdapter, createAttioAdapter, createCaptionGenerationWorkflow, createCaptureInstagramMetricsWorkflow, createClickUpAdapter, createDropboxAdapter, createGmailAdapter, createGoogleSheetsAdapter, createImageAnalysisWorkflow, createInstagramAdapter, createInstantlyAdapter, createMillionVerifierAdapter, createPublishInstagramWorkflow, createResendAdapter, createSignatureApiAdapter, createStripeAdapter, createTombaAdapter, crm, email, executeWorkflow, execution, generateHmacToken, list, listBuilderWorkflow, llm, notifications, pdf, platform, projects, scheduler, startWorker, storage, toContentMetrics } from '../chunk-ZAVFBZHM.js';
-import '../chunk-OT4CHFQJ.js';
+export { ListBuilderResultSchema, ListBuilderResultsSchema, PlatformToolError, acqDb, approval, artifacts, classifyPlatformToolError, content, createAdapter, createAnymailfinderAdapter, createApifyAdapter, createAttioAdapter, createCaptionGenerationWorkflow, createCaptureInstagramMetricsWorkflow, createClickUpAdapter, createDropboxAdapter, createGmailAdapter, createGoogleSheetsAdapter, createImageAnalysisWorkflow, createInstagramAdapter, createInstantlyAdapter, createMillionVerifierAdapter, createPublishInstagramWorkflow, createResendAdapter, createSignatureApiAdapter, createStripeAdapter, createTombaAdapter, crm, email, executeWorkflow, execution, generateHmacToken, list, listBuilderWorkflow, llm, notifications, pdf, platform, projects, scheduler, startWorker, storage, toContentMetrics } from '../chunk-72ZGICTR.js';
+import '../chunk-R3J6BEPO.js';
 import '../chunk-QF2RNYYX.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elevasis/sdk",
-  "version": "1.54.0",
+  "version": "1.55.0",
   "description": "SDK for building Elevasis organization resources",
   "type": "module",
   "bin": {
@@ -63,9 +63,9 @@
     "typescript": "5.9.2",
     "vitest": "^3.2.4",
     "zod": "^4.1.0",
-    "@repo/core": "0.70.0",
-    "@repo/typescript-config": "0.0.0",
-    "@repo/eslint-config": "0.0.0"
+    "@repo/core": "0.71.0",
+    "@repo/eslint-config": "0.0.0",
+    "@repo/typescript-config": "0.0.0"
   },
   "license": "MIT",
   "engines": {

package/reference/packages/core/src/knowledge/README.md

@@ -27,7 +27,7 @@ Pure query layer over the organization graph. Browser-safe (no Node APIs); share
 
 ## JSON envelope
 
-`formatJson` returns `{ path, mount, args, results }` — the same wrapped envelope used by `pnpm exec elevasis knowledge:ls --json` and `pnpm exec elevasis-sdk knowledge:ls --json`.
+`formatJson` returns `{ path, mount, args, results }` — the same wrapped envelope used by `pnpm exec elevasis knowledge:ls --json` and `pnpm exec elevasis-sdk knowledge:ls --json`.
 
 `governs` and `governedBy` accept either bare or graph-namespaced ids (`knowledge.foo` or `knowledge:knowledge.foo`).
 

package/reference/scaffold/core/organization-model.mdx

@@ -51,7 +51,7 @@ Resource identity is authored inside `OrganizationModel.resources`. Runtime work
 
 ## System Shape
 
-`OrganizationModel.systems` is the canonical semantic domain map. Hierarchy is authored with recursive `systems`; dotted paths such as `sales.crm` are derived from position in that tree. `subsystems` is a deprecated compatibility alias — it is still accepted and kept in sync with `systems` during parse, but new authoring should use `systems`. `parentSystemId` and `id` remain accepted compatibility fields during the migration.
+`OrganizationModel.systems` is the canonical semantic domain map. Hierarchy is authored with recursive `systems`; dotted paths such as `sales.crm` are derived from position in that tree. `subsystems` is a deprecated compatibility alias — it is still accepted on input, but new authoring should use `systems`. Parsing does **not** copy `systems` into it: children come back under whichever key the author wrote, so read `system.systems ?? system.subsystems` rather than assuming either key is populated. `parentSystemId` and `id` remain accepted compatibility fields during the migration.
 
 {/* doc-snippet:skip: illustrative excerpt, not a standalone compilable file */}
 

package/reference/scaffold/recipes/extend-lead-gen.md

@@ -51,6 +51,7 @@ Lead gen is a layered platform surface, not one component. Shared packages own s
 | `useLeadGenConfig`, `LeadGenBuildConfig`, build-state helpers                                                                                                | `@elevasis/ui/features/lead-gen`            | Provider-backed derivation of stage catalog, build templates, default build steps, default template id, and export workflow id          |
 | `ListActionsProvider`, `useListActions`, `ListBuilderWorkflow`, `ListBuilderRegistry`, `LeadGenActionKey`                                                    | `@elevasis/ui/features/lead-gen`            | List Builder workflow registry, slot-based field contracts, and project-owned action wiring                                             |
 | `LeadGenRouteShell`                                                                                                                                          | `@elevasis/ui/features/lead-gen`            | Route shell helper (contact/company detail surfaces are now `ContactDetailPage` / `CompanyDetailPage` from `@elevasis/ui/features/crm`) |
+| `EMPLOYEE_RANGES`, `EmployeeRange`                                                                                                                           | `@elevasis/ui/features/lead-gen`            | Apollo's own employee-count brackets for an Apollo import form. Wire values are Apollo's; relabel by mapping, never by redeclaring      |
 | `useLists`, `useList`, `useListsTelemetry`, `useListProgress`, `useListExecutions`, `useCreateList`, `useUpdateList`, `useUpdateListConfig`, `useDeleteList` | `@elevasis/ui/hooks`                        | Headless list and telemetry data access                                                                                                 |
 | `useWorkflowExecution`, `useExecutionSSE`, `useAddCompaniesToList`, `useRemoveCompaniesFromList`, `useAddContactsToList`                                     | `@elevasis/ui/hooks`                        | List Builder workflow triggering, live execution tailing, and list membership mutations                                                 |
 | `useCompanies`, `useCompany`, `useContacts`, `useContact`                                                                                                    | `@elevasis/ui/hooks`                        | Acquisition company/contact data access                                                                                                 |
@@ -208,7 +209,7 @@ function RootLayoutComponent() {
 
 Data sourcing mode is list-wide. Read `list.pipelineConfig.dataMode` or the workflow-side `list.getConfig()` result when a workflow must choose mock versus live sourcing. Do not add per-action `mock` / `live` controls for Apollo, crawl, enrichment, or scoring steps. Export mode is separate: `preview` versus `export` controls whether a destination write happens.
 
-Each registry entry declares a Zod `schema` and a `layout` of declarative field hints (`StepConfigLayout<Input>`). The shared `StepConfigForm` renders the layout, validates against the schema, and wires `value`/`onChange` for you — no per-action React components. The List Builder right column renders the form as `Configuration | Advanced | Runs` tabs with a sticky action footer. Omit the `advanced:` section when a step has none.
+Each registry entry declares a Zod `schema` and a `layout` of declarative field hints (`StepConfigLayout<Input>`). The shared `StepConfigForm` renders the layout, validates against the schema, and wires `value`/`onChange` for you — no per-action React components. The List Builder right column renders the form as `Configuration | Advanced | Runs` tabs with a sticky action footer. Omit the `advanced:` section when a step has none.
 
 Available field component variants: `textinput`, `textarea`, `numberinput`, `switch`, `segmented`, `select`, `multiselect`, `tags`, `json`. Field hints support `label`, `description`, `placeholder`, `min`/`max`/`step` (numbers), `options` (selects), and `when: (values) => boolean` for conditional visibility.
 

package/reference/scaffold/reference/contracts.md

@@ -3142,45 +3142,45 @@ export const AcqSubstrateSchemas = {
 ### `Stateful`
 
 ```typescript
-/**
- * Stateful trait — the (pipeline_key, stage_key, state_key, activity_log) quartet
- * applied to acq_deals (CRM HITL, shipped 2026-04-27) and being generalized to
- * acq_lists / acq_list_members / acq_list_companies via Track B.
- */
-export interface Stateful {
-  pipeline_key: string
-  stage_key: string
-  state_key: string
-  activity_log: ActivityEvent[]
+/**
+ * Stateful trait — the (pipeline_key, stage_key, state_key, activity_log) quartet
+ * applied to acq_deals (CRM HITL, shipped 2026-04-27) and being generalized to
+ * acq_lists / acq_list_members / acq_list_companies via Track B.
+ */
+export interface Stateful {
+  pipeline_key: string
+  stage_key: string
+  state_key: string
+  activity_log: ActivityEvent[]
 }
 ```
 
 ### `TransitionItem`
 
 ```typescript
-/** Generic transition shape — concrete per-entity transitionItem implementations satisfy this. */
-export type TransitionItem<T extends Stateful, TEvent extends ActivityEvent> = (
-  item: T,
-  transition: { stage_key?: string; state_key?: string; event: TEvent }
+/** Generic transition shape — concrete per-entity transitionItem implementations satisfy this. */
+export type TransitionItem<T extends Stateful, TEvent extends ActivityEvent> = (
+  item: T,
+  transition: { stage_key?: string; state_key?: string; event: TEvent }
 ) => T
 ```
 
 ### `DeriveActions`
 
 ```typescript
-/** Generic action-derivation shape — concrete per-entity deriveActions implementations satisfy this. */
+/** Generic action-derivation shape — concrete per-entity deriveActions implementations satisfy this. */
 export type DeriveActions<T extends Stateful, TAction> = (item: T) => TAction[]
 ```
 
 ### `StatefulSchema`
 
 ```typescript
-export const StatefulSchema = z.object({
-  pipeline_key: z.string(),
-  stage_key: z.string(),
-  state_key: z.string(),
-  activity_log: z.array(ActivityEventSchema)
-})
+export const StatefulSchema = z.object({
+  pipeline_key: z.string(),
+  stage_key: z.string(),
+  state_key: z.string(),
+  activity_log: z.array(ActivityEventSchema)
+}) satisfies z.ZodType<Stateful>
 ```
 
 ### `StatefulStateDefinition`