@elevasis/sdk 1.22.1 → 1.24.0

package/dist/node/index.d.ts

@@ -1,3 +1,5 @@
+import { z } from 'zod';
+
 type KnowledgeKind = 'playbook' | 'strategy' | 'reference';
 interface KnowledgeCodegenNode {
     id: string;
@@ -35,6 +37,2980 @@ declare function generateKnowledgeNodesTs(options: {
 }): string;
 declare function generateKnowledgeNodes(options: GenerateKnowledgeNodesOptions): GenerateKnowledgeNodesResult;
 
+/**
+ * Workflow-specific logging types and utilities
+ */
+
+interface WorkflowExecutionContext {
+    type: 'workflow';
+    contextType: 'workflow-execution';
+    executionId: string;
+    workflowId: string;
+    workflowName?: string;
+    organizationId: string;
+    executionPath?: string[];
+}
+interface WorkflowFailureContext {
+    type: 'workflow';
+    contextType: 'workflow-failure';
+    executionId: string;
+    workflowId: string;
+    error: string;
+}
+interface StepStartedContext {
+    type: 'workflow';
+    contextType: 'step-started';
+    stepId: string;
+    stepStatus: 'started';
+    input: unknown;
+    startTime: number;
+}
+interface StepCompletedContext {
+    type: 'workflow';
+    contextType: 'step-completed';
+    stepId: string;
+    stepStatus: 'completed';
+    output: unknown;
+    duration: number;
+    isTerminal: boolean;
+    startTime: number;
+    endTime: number;
+}
+interface StepFailedContext {
+    type: 'workflow';
+    contextType: 'step-failed';
+    stepId: string;
+    stepStatus: 'failed';
+    error: string;
+    duration: number;
+    startTime: number;
+    endTime: number;
+}
+interface ConditionalRouteContext {
+    type: 'workflow';
+    contextType: 'conditional-route';
+    stepId: string;
+    target: string;
+    error?: string;
+}
+interface ExecutionPathContext {
+    type: 'workflow';
+    contextType: 'execution-path';
+    executionPath: string[];
+}
+type WorkflowLogContext = WorkflowExecutionContext | WorkflowFailureContext | StepStartedContext | StepCompletedContext | StepFailedContext | ConditionalRouteContext | ExecutionPathContext;
+
+/**
+ * Agent-specific logging types
+ * Simplified 2-event model: lifecycle, iteration
+ *
+ * Design Philosophy:
+ * - LIFECYCLE EVENTS: Structural checkpoints (initialization, iteration, completion)
+ * - ITERATION EVENTS: Execution activities (reasoning, actions during iterations)
+ */
+
+/**
+ * Agent lifecycle stages
+ * Universal checkpoints that apply to all agent executions
+ */
+type AgentLifecycle = 'initialization' | 'iteration' | 'completion';
+/**
+ * Iteration event types
+ * Activities that occur during agent iterations
+ */
+type IterationEventType = 'reasoning' | 'action' | 'tool-call';
+/**
+ * Base fields shared by all lifecycle events
+ */
+interface AgentLifecycleEventBase {
+    type: 'agent';
+    agentId: string;
+    lifecycle: AgentLifecycle;
+    sessionId?: string;
+}
+/**
+ * Lifecycle started event - emitted when a phase begins
+ * REQUIRED: startTime (phase has started, no end yet)
+ */
+interface AgentLifecycleStartedEvent extends AgentLifecycleEventBase {
+    stage: 'started';
+    startTime: number;
+    iteration?: number;
+}
+/**
+ * Lifecycle completed event - emitted when a phase succeeds
+ * REQUIRED: startTime, endTime, duration (phase has finished successfully)
+ */
+interface AgentLifecycleCompletedEvent extends AgentLifecycleEventBase {
+    stage: 'completed';
+    startTime: number;
+    endTime: number;
+    duration: number;
+    iteration?: number;
+    attempts?: number;
+    memorySize?: {
+        sessionMemoryKeys: number;
+        historyEntries: number;
+    };
+}
+/**
+ * Lifecycle failed event - emitted when a phase fails
+ * REQUIRED: startTime, endTime, duration, error (phase has finished with error)
+ */
+interface AgentLifecycleFailedEvent extends AgentLifecycleEventBase {
+    stage: 'failed';
+    startTime: number;
+    endTime: number;
+    duration: number;
+    error: string;
+    iteration?: number;
+}
+/**
+ * Union type for all lifecycle events
+ * Discriminated by 'stage' field for type narrowing
+ */
+type AgentLifecycleEvent = AgentLifecycleStartedEvent | AgentLifecycleCompletedEvent | AgentLifecycleFailedEvent;
+/**
+ * Placeholder data for MVP
+ * Will be typed per actionType in future
+ */
+interface ActionPlaceholderData {
+    message: string;
+}
+/**
+ * Iteration event - captures activities during agent iterations
+ * Consolidates reasoning (LLM thought process) and actions (tool use, memory ops, etc.)
+ */
+interface AgentIterationEvent {
+    type: 'agent';
+    agentId: string;
+    lifecycle: 'iteration';
+    eventType: IterationEventType;
+    iteration: number;
+    sessionId?: string;
+    startTime: number;
+    endTime: number;
+    duration: number;
+    output?: string;
+    actionType?: string;
+    data?: ActionPlaceholderData;
+}
+/**
+ * Tool call event - captures individual tool executions during iterations
+ * Provides granular timing for each tool invocation
+ */
+interface AgentToolCallEvent {
+    type: 'agent';
+    agentId: string;
+    lifecycle: 'iteration';
+    eventType: 'tool-call';
+    iteration: number;
+    sessionId?: string;
+    toolName: string;
+    startTime: number;
+    endTime: number;
+    duration: number;
+    success: boolean;
+    error?: string;
+    input?: Record<string, unknown>;
+    output?: unknown;
+}
+/**
+ * Union type for all agent log contexts
+ * 3 event types total (lifecycle, iteration, tool-call)
+ */
+type AgentLogContext = AgentLifecycleEvent | AgentIterationEvent | AgentToolCallEvent;
+/**
+ * Data for lifecycle 'started' events
+ */
+interface AgentLifecycleStartedData {
+    startTime: number;
+    iteration?: number;
+}
+/**
+ * Data for lifecycle 'completed' events
+ */
+interface AgentLifecycleCompletedData {
+    startTime: number;
+    endTime: number;
+    duration: number;
+    iteration?: number;
+    attempts?: number;
+    memorySize?: {
+        sessionMemoryKeys: number;
+        historyEntries: number;
+    };
+}
+/**
+ * Data for lifecycle 'failed' events
+ */
+interface AgentLifecycleFailedData {
+    startTime: number;
+    endTime: number;
+    duration: number;
+    error: string;
+    iteration?: number;
+}
+/**
+ * Scoped logger for agent execution
+ * Captures logger and agentId to eliminate repetitive parameter passing
+ *
+ * Type-safe lifecycle logging with stage-specific required fields
+ */
+interface AgentScopedLogger {
+    lifecycle(lifecycle: AgentLifecycle, stage: 'started', data: AgentLifecycleStartedData): void;
+    lifecycle(lifecycle: AgentLifecycle, stage: 'completed', data: AgentLifecycleCompletedData): void;
+    lifecycle(lifecycle: AgentLifecycle, stage: 'failed', data: AgentLifecycleFailedData): void;
+    reasoning(output: string, iteration: number, startTime: number, endTime: number, duration: number): void;
+    action(actionType: string, message: string, iteration: number, startTime: number, endTime: number, duration: number): void;
+    toolCall(toolName: string, iteration: number, startTime: number, endTime: number, duration: number, success: boolean, error?: string, input?: unknown, output?: unknown): void;
+}
+
+type LogContext = WorkflowLogContext | AgentLogContext;
+interface IExecutionLogger {
+    debug(message: string, context?: LogContext): void;
+    info(message: string, context?: LogContext): void;
+    warn(message: string, context?: LogContext): void;
+    error(message: string, context?: LogContext): void;
+}
+
+/**
+ * Model Configuration
+ * Centralized model information, configuration, options, constraints, and validation
+ * Single source of truth for all model-related definitions
+ * Update manually when pricing changes or new models are added
+ */
+
+/**
+ * Supported Open AI models (direct SDK access)
+ */
+type OpenAIModel = 'gpt-5' | 'gpt-5.4-mini' | 'gpt-5.4-nano';
+/**
+ * Supported OpenRouter models (explicit union for type safety)
+ */
+type OpenRouterModel = 'openrouter/z-ai/glm-5';
+/**
+ * Supported Google models (direct SDK access)
+ */
+type GoogleModel = 'gemini-3-flash-preview' | 'gemini-3.1-flash-lite-preview';
+/**
+ * Supported Anthropic models (direct SDK access via @anthropic-ai/sdk)
+ */
+type AnthropicModel = 'claude-sonnet-4-5';
+/** Supported LLM models */
+type LLMModel = OpenAIModel | OpenRouterModel | GoogleModel | AnthropicModel | 'mock';
+/**
+ * GPT-5 model options schema
+ */
+declare const GPT5OptionsSchema: z.ZodObject<{
+    reasoning_effort: z.ZodOptional<z.ZodEnum<{
+        minimal: "minimal";
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>>;
+    verbosity: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>>;
+}, z.core.$strip>;
+/**
+ * OpenRouter model options schema
+ * OpenRouter-specific options for routing and transforms
+ */
+declare const OpenRouterOptionsSchema: z.ZodObject<{
+    transforms: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    route: z.ZodOptional<z.ZodEnum<{
+        fallback: "fallback";
+    }>>;
+}, z.core.$strip>;
+/**
+ * Google model options schema
+ * Gemini 3 specific options for thinking depth control
+ */
+declare const GoogleOptionsSchema: z.ZodObject<{
+    thinkingLevel: z.ZodOptional<z.ZodEnum<{
+        minimal: "minimal";
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>>;
+}, z.core.$strip>;
+/**
+ * Anthropic model options schema
+ * Currently empty - future options: budget_tokens for extended thinking
+ */
+declare const AnthropicOptionsSchema: z.ZodObject<{}, z.core.$strip>;
+/**
+ * Infer TypeScript types from schemas
+ */
+type GPT5Options = z.infer<typeof GPT5OptionsSchema>;
+type MockOptions = Record<string, never>;
+type OpenRouterOptions = z.infer<typeof OpenRouterOptionsSchema>;
+type GoogleOptions = z.infer<typeof GoogleOptionsSchema>;
+type AnthropicOptions = z.infer<typeof AnthropicOptionsSchema>;
+type ModelSpecificOptions = GPT5Options | MockOptions | OpenRouterOptions | GoogleOptions | AnthropicOptions;
+/**
+ * Model configuration for LLM execution
+ * Belongs in resource definition (AgentDefinition, WorkflowDefinition, etc.)
+ */
+interface ModelConfig {
+    model: LLMModel;
+    provider: 'openai' | 'anthropic' | 'openrouter' | 'google' | 'mock';
+    apiKey: string;
+    temperature?: number;
+    /** Maximum output tokens per LLM call. NOT the model's context window — see ModelInfo.maxTokens for that. */
+    maxOutputTokens?: number;
+    topP?: number;
+    /**
+     * Model-specific options (flat structure)
+     * Options are model-specific, not vendor-specific
+     * Available options defined in MODEL_INFO per model
+     * Validated at build time via validateModelOptions()
+     */
+    modelOptions?: ModelSpecificOptions;
+}
+
+declare const ResourceGovernanceStatusSchema: z.ZodEnum<{
+    deprecated: "deprecated";
+    active: "active";
+    archived: "archived";
+}>;
+declare const WorkflowResourceEntrySchema$1: z.ZodObject<{
+    id: z.ZodString;
+    order: z.ZodDefault<z.ZodNumber>;
+    systemPath: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    ownerRoleId: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        deprecated: "deprecated";
+        active: "active";
+        archived: "archived";
+    }>;
+    ontology: z.ZodOptional<z.ZodObject<{
+        actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        primaryAction: z.ZodOptional<z.ZodString>;
+        reads: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        usesCatalogs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        emits: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        contract: z.ZodOptional<z.ZodObject<{
+            input: z.ZodOptional<z.ZodString>;
+            output: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    codeRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        role: z.ZodEnum<{
+            config: "config";
+            entrypoint: "entrypoint";
+            handler: "handler";
+            schema: "schema";
+            test: "test";
+            docs: "docs";
+        }>;
+        symbol: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    kind: z.ZodLiteral<"workflow">;
+    emits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        eventKey: z.ZodString;
+        label: z.ZodString;
+        payloadSchema: z.ZodOptional<z.ZodString>;
+        lifecycle: z.ZodOptional<z.ZodEnum<{
+            deprecated: "deprecated";
+            draft: "draft";
+            beta: "beta";
+            active: "active";
+            archived: "archived";
+        }>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+declare const AgentResourceEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    order: z.ZodDefault<z.ZodNumber>;
+    systemPath: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    ownerRoleId: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        deprecated: "deprecated";
+        active: "active";
+        archived: "archived";
+    }>;
+    ontology: z.ZodOptional<z.ZodObject<{
+        actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        primaryAction: z.ZodOptional<z.ZodString>;
+        reads: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        usesCatalogs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        emits: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        contract: z.ZodOptional<z.ZodObject<{
+            input: z.ZodOptional<z.ZodString>;
+            output: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    codeRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        role: z.ZodEnum<{
+            config: "config";
+            entrypoint: "entrypoint";
+            handler: "handler";
+            schema: "schema";
+            test: "test";
+            docs: "docs";
+        }>;
+        symbol: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    kind: z.ZodLiteral<"agent">;
+    agentKind: z.ZodEnum<{
+        platform: "platform";
+        orchestrator: "orchestrator";
+        specialist: "specialist";
+        utility: "utility";
+    }>;
+    actsAsRoleId: z.ZodOptional<z.ZodString>;
+    sessionCapable: z.ZodBoolean;
+    invocations: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"slash-command">;
+        command: z.ZodString;
+        toolFactory: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"mcp-tool">;
+        server: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"api-endpoint">;
+        method: z.ZodEnum<{
+            GET: "GET";
+            POST: "POST";
+            PATCH: "PATCH";
+            DELETE: "DELETE";
+        }>;
+        path: z.ZodString;
+        requestSchema: z.ZodOptional<z.ZodString>;
+        responseSchema: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"script-execution">;
+        resourceId: z.ZodString;
+    }, z.core.$strip>], "kind">>>;
+    emits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        eventKey: z.ZodString;
+        label: z.ZodString;
+        payloadSchema: z.ZodOptional<z.ZodString>;
+        lifecycle: z.ZodOptional<z.ZodEnum<{
+            deprecated: "deprecated";
+            draft: "draft";
+            beta: "beta";
+            active: "active";
+            archived: "archived";
+        }>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+declare const ResourceEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    order: z.ZodDefault<z.ZodNumber>;
+    systemPath: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    ownerRoleId: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        deprecated: "deprecated";
+        active: "active";
+        archived: "archived";
+    }>;
+    ontology: z.ZodOptional<z.ZodObject<{
+        actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        primaryAction: z.ZodOptional<z.ZodString>;
+        reads: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        usesCatalogs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        emits: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        contract: z.ZodOptional<z.ZodObject<{
+            input: z.ZodOptional<z.ZodString>;
+            output: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    codeRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        role: z.ZodEnum<{
+            config: "config";
+            entrypoint: "entrypoint";
+            handler: "handler";
+            schema: "schema";
+            test: "test";
+            docs: "docs";
+        }>;
+        symbol: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    kind: z.ZodLiteral<"workflow">;
+    emits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        eventKey: z.ZodString;
+        label: z.ZodString;
+        payloadSchema: z.ZodOptional<z.ZodString>;
+        lifecycle: z.ZodOptional<z.ZodEnum<{
+            deprecated: "deprecated";
+            draft: "draft";
+            beta: "beta";
+            active: "active";
+            archived: "archived";
+        }>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    order: z.ZodDefault<z.ZodNumber>;
+    systemPath: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    ownerRoleId: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        deprecated: "deprecated";
+        active: "active";
+        archived: "archived";
+    }>;
+    ontology: z.ZodOptional<z.ZodObject<{
+        actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        primaryAction: z.ZodOptional<z.ZodString>;
+        reads: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        usesCatalogs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        emits: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        contract: z.ZodOptional<z.ZodObject<{
+            input: z.ZodOptional<z.ZodString>;
+            output: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    codeRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        role: z.ZodEnum<{
+            config: "config";
+            entrypoint: "entrypoint";
+            handler: "handler";
+            schema: "schema";
+            test: "test";
+            docs: "docs";
+        }>;
+        symbol: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    kind: z.ZodLiteral<"agent">;
+    agentKind: z.ZodEnum<{
+        platform: "platform";
+        orchestrator: "orchestrator";
+        specialist: "specialist";
+        utility: "utility";
+    }>;
+    actsAsRoleId: z.ZodOptional<z.ZodString>;
+    sessionCapable: z.ZodBoolean;
+    invocations: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"slash-command">;
+        command: z.ZodString;
+        toolFactory: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"mcp-tool">;
+        server: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"api-endpoint">;
+        method: z.ZodEnum<{
+            GET: "GET";
+            POST: "POST";
+            PATCH: "PATCH";
+            DELETE: "DELETE";
+        }>;
+        path: z.ZodString;
+        requestSchema: z.ZodOptional<z.ZodString>;
+        responseSchema: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"script-execution">;
+        resourceId: z.ZodString;
+    }, z.core.$strip>], "kind">>>;
+    emits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        eventKey: z.ZodString;
+        label: z.ZodString;
+        payloadSchema: z.ZodOptional<z.ZodString>;
+        lifecycle: z.ZodOptional<z.ZodEnum<{
+            deprecated: "deprecated";
+            draft: "draft";
+            beta: "beta";
+            active: "active";
+            archived: "archived";
+        }>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    order: z.ZodDefault<z.ZodNumber>;
+    systemPath: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    ownerRoleId: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        deprecated: "deprecated";
+        active: "active";
+        archived: "archived";
+    }>;
+    ontology: z.ZodOptional<z.ZodObject<{
+        actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        primaryAction: z.ZodOptional<z.ZodString>;
+        reads: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        usesCatalogs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        emits: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        contract: z.ZodOptional<z.ZodObject<{
+            input: z.ZodOptional<z.ZodString>;
+            output: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    codeRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        role: z.ZodEnum<{
+            config: "config";
+            entrypoint: "entrypoint";
+            handler: "handler";
+            schema: "schema";
+            test: "test";
+            docs: "docs";
+        }>;
+        symbol: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    kind: z.ZodLiteral<"integration">;
+    provider: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    order: z.ZodDefault<z.ZodNumber>;
+    systemPath: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    ownerRoleId: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        deprecated: "deprecated";
+        active: "active";
+        archived: "archived";
+    }>;
+    ontology: z.ZodOptional<z.ZodObject<{
+        actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        primaryAction: z.ZodOptional<z.ZodString>;
+        reads: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        usesCatalogs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        emits: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        contract: z.ZodOptional<z.ZodObject<{
+            input: z.ZodOptional<z.ZodString>;
+            output: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    codeRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        role: z.ZodEnum<{
+            config: "config";
+            entrypoint: "entrypoint";
+            handler: "handler";
+            schema: "schema";
+            test: "test";
+            docs: "docs";
+        }>;
+        symbol: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    kind: z.ZodLiteral<"script">;
+    language: z.ZodEnum<{
+        shell: "shell";
+        sql: "sql";
+        typescript: "typescript";
+        python: "python";
+    }>;
+    source: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        file: z.ZodString;
+    }, z.core.$strip>]>;
+}, z.core.$strip>], "kind">;
+type ResourceGovernanceStatus = z.infer<typeof ResourceGovernanceStatusSchema>;
+type WorkflowResourceEntry = z.infer<typeof WorkflowResourceEntrySchema$1>;
+type AgentResourceEntry = z.infer<typeof AgentResourceEntrySchema>;
+type ResourceEntry = z.infer<typeof ResourceEntrySchema>;
+
+/**
+ * Shared form field types for dynamic form generation
+ * Used by: Command Queue, Execution Runner UI, future form-based features
+ */
+/**
+ * Supported form field types for action payloads
+ * Maps to Mantine form components
+ */
+type FormFieldType = 'text' | 'textarea' | 'number' | 'select' | 'checkbox' | 'radio' | 'richtext';
+/**
+ * Form field definition
+ */
+interface FormField {
+    /** Field key in payload object */
+    name: string;
+    /** Field label for UI */
+    label: string;
+    /** Field type (determines UI component) */
+    type: FormFieldType;
+    /** Default value */
+    defaultValue?: unknown;
+    /** Required field */
+    required?: boolean;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Help text */
+    description?: string;
+    /** Options for select/radio */
+    options?: Array<{
+        label: string;
+        value: string | number;
+    }>;
+    /** Min/max for number */
+    min?: number;
+    max?: number;
+    /** Path to context value for pre-filling (dot notation, e.g., 'proposal.summary') */
+    defaultValueFromContext?: string;
+}
+/**
+ * Form schema for action payload collection
+ */
+interface FormSchema {
+    /** Form title */
+    title?: string;
+    /** Form description */
+    description?: string;
+    /** Form fields */
+    fields: FormField[];
+}
+
+/**
+ * Execution interface configuration
+ * Defines how a resource is executed via the UI (forms, scheduling, webhooks)
+ * Applies to both agents and workflows
+ */
+interface ExecutionInterface {
+    /** Form configuration for execution inputs */
+    form: ExecutionFormSchema;
+    /** Optional: Schedule configuration */
+    schedule?: ScheduleConfig;
+    /** Optional: Webhook trigger configuration */
+    webhook?: WebhookConfig;
+}
+/**
+ * Execution form schema
+ * Extends FormSchema with execution-specific fields
+ */
+interface ExecutionFormSchema extends FormSchema {
+    /**
+     * Field mappings to resource input schema
+     * Maps form field names to contract input paths
+     * If omitted, field names must match contract input keys exactly
+     */
+    fieldMappings?: Record<string, string>;
+    /**
+     * Submit button configuration
+     * Default: { label: 'Run', loadingLabel: 'Running...' }
+     */
+    submitButton?: {
+        label?: string;
+        loadingLabel?: string;
+        confirmMessage?: string;
+    };
+}
+/**
+ * Schedule configuration for automated execution
+ */
+interface ScheduleConfig {
+    /** Whether scheduling is enabled for this resource */
+    enabled: boolean;
+    /** Default schedule (cron expression) */
+    defaultSchedule?: string;
+    /** Allowed schedule patterns (if restricted) */
+    allowedPatterns?: string[];
+}
+/**
+ * Webhook configuration for external triggers
+ */
+interface WebhookConfig {
+    /** Whether webhook trigger is enabled */
+    enabled: boolean;
+    /** Expected payload schema (for documentation) */
+    payloadSchema?: unknown;
+}
+
+interface WorkflowConfig extends ResourceDefinition {
+    type: 'workflow';
+    /** OM descriptor backing canonical identity and governance metadata. */
+    resource?: WorkflowResourceEntry;
+}
+interface WorkflowStepDefinition {
+    id: string;
+    name: string;
+    description: string;
+}
+type StepHandler = (input: unknown, context: ExecutionContext) => Promise<unknown>;
+interface LinearNext {
+    type: 'linear';
+    target: string;
+}
+interface ConditionalNext {
+    type: 'conditional';
+    routes: Array<{
+        condition: (data: unknown) => boolean;
+        target: string;
+    }>;
+    default: string;
+}
+type NextConfig = LinearNext | ConditionalNext | null;
+interface WorkflowStep extends WorkflowStepDefinition {
+    handler: StepHandler;
+    inputSchema: z.ZodSchema;
+    outputSchema: z.ZodSchema;
+    next: NextConfig;
+}
+interface WorkflowDefinition {
+    config: WorkflowConfig;
+    contract: Contract;
+    steps: Record<string, WorkflowStep>;
+    entryPoint: string;
+    /**
+     * Metrics configuration for ROI calculations
+     * Optional: Only needed if tracking automation savings
+     */
+    metricsConfig?: ResourceMetricsConfig;
+    /**
+     * Execution interface configuration (optional)
+     * If provided, workflow appears in Execution Runner UI
+     */
+    interface?: ExecutionInterface;
+    /**
+     * Lead-gen processing stage this workflow implements (optional).
+     * Must match a key in the platform lead-gen stage catalog.
+     * Used by org-os graph derivation to surface workflow→stage edges and
+     * by pipeline_config validation to confirm each catalog stage has an
+     * implementing workflow before a list is activated.
+     *
+     * Example: stageImplemented: 'verified' on the email-verification workflow.
+     */
+    stageImplemented?: string;
+}
+
+/**
+ * Generic LLM Types
+ * Universal interfaces for LLM interaction across all resource types
+ */
+/**
+ * Standard chat message format
+ * Compatible with OpenAI, Anthropic, and other providers
+ */
+interface LLMMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+/**
+ * Generic LLM generation request
+ * Usable by agents, workflows, tools, etc.
+ */
+interface LLMGenerateRequest {
+    messages: LLMMessage[];
+    responseSchema: unknown;
+    /** Maximum output tokens per LLM call. NOT the model's context window — see ModelInfo.maxTokens for that. */
+    maxOutputTokens?: number;
+    temperature?: number;
+    topP?: number;
+    signal?: AbortSignal;
+}
+/**
+ * Generic LLM generation response
+ * Usage field is internal-only (stripped by UniversalLLMAdapter wrapper)
+ */
+interface LLMGenerateResponse<T = unknown> {
+    output: T;
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    };
+    cost?: number;
+}
+/**
+ * LLM Adapter interface
+ * Generic primitive for all resource types (agents, workflows, tools)
+ *
+ * Design principles:
+ * - Single method: generate() - the core LLM primitive
+ * - Generic return type for type safety
+ * - Universal format (not agent-specific)
+ * - Standard message-based input (OpenAI-compatible)
+ */
+interface LLMAdapter {
+    /**
+     * Generate structured output from prompt using LLM
+     *
+     * @param request - Generation request with messages and response schema
+     * @returns Generated output (typed) with optional usage metadata
+     */
+    generate<T = unknown>(request: LLMGenerateRequest): Promise<LLMGenerateResponse<T>>;
+}
+
+/**
+ * Memory type definitions
+ * Types for agent memory management with semantic entry types
+ */
+/**
+ * Semantic memory entry types
+ * Use-case agnostic types that describe the purpose of each entry
+ * Memory types mirror action types for clarity and filtering
+ */
+type MemoryEntryType = 'context' | 'input' | 'reasoning' | 'tool-result' | 'delegation-result' | 'error';
+/**
+ * Memory entry - represents a single entry in agent memory
+ * Stored in agent memory, translated by adapters to vendor-specific formats
+ */
+interface MemoryEntry {
+    type: MemoryEntryType;
+    content: string;
+    timestamp: number;
+    turnNumber: number | null;
+    iterationNumber: number | null;
+}
+/**
+ * Agent memory - Self-orchestrated memory with session + working storage
+ * Agent has full control over what persists, framework handles auto-compaction
+ */
+interface AgentMemory {
+    /**
+     * Session memory - Persists for session/conversation duration
+     * Never auto-trimmed by framework
+     * Agent-managed key-value store for critical information
+     * Agent provides strings, framework wraps in MemoryEntry
+     */
+    sessionMemory: Record<string, MemoryEntry>;
+    /**
+     * Working memory - Execution history
+     * Automatically compacted by framework when needed
+     * Agent doesn't control compaction
+     */
+    history: MemoryEntry[];
+}
+/**
+ * Memory status for agent awareness
+ */
+interface MemoryStatus {
+    sessionMemoryKeys: number;
+    sessionMemoryLimit: number;
+    currentKeys: string[];
+    historyPercent: number;
+    historyTokens: number;
+    tokenBudget: number;
+}
+/**
+ * Memory constraints (optional limits)
+ */
+interface MemoryConstraints {
+    maxSessionMemoryKeys?: number;
+    maxMemoryTokens?: number;
+}
+
+/**
+ * Memory Manager
+ * Encapsulates all memory operations with ultra-simple agent API
+ * Agent provides strings, framework handles wrapping and auto-compaction
+ */
+
+/**
+ * Memory Manager - Agent memory orchestration
+ * Provides ultra-simple API for agents (strings only)
+ * Handles automatic compaction and token management
+ */
+declare class MemoryManager {
+    private memory;
+    private constraints;
+    private logger?;
+    private cachedSnapshot?;
+    constructor(memory: AgentMemory, constraints?: MemoryConstraints, logger?: AgentScopedLogger | undefined);
+    /**
+     * Set session memory entry (agent provides string, framework wraps it)
+     * @param key - Session memory key
+     * @param content - String content from agent
+     */
+    set(key: string, content: string): void;
+    /**
+     * Get session memory entry content
+     * @param key - Session memory key
+     * @returns String content if exists, undefined otherwise
+     */
+    get(key: string): string | undefined;
+    /**
+     * Delete session memory entry
+     * @param key - Key to delete
+     * @returns True if key existed and was deleted
+     */
+    delete(key: string): boolean;
+    /**
+     * Add entry to history (called by framework after tool results, reasoning, etc.)
+     * Automatically sets timestamp to current time
+     * @param entry - Memory entry to add (without timestamp - auto-generated)
+     */
+    addToHistory(entry: Omit<MemoryEntry, 'timestamp'>): void;
+    /**
+     * Auto-compact history if approaching token budget
+     * Uses preserve-anchors strategy: keep first + recent entries
+     */
+    autoCompact(): void;
+    /**
+     * Enforce hard limits (called before LLM request)
+     * Emergency fallback if agent exceeds limits
+     */
+    enforceHardLimits(): void;
+    /**
+     * Get history length (for logging and introspection)
+     * @returns Number of entries in history
+     */
+    getHistoryLength(): number;
+    /**
+     * Get memory status for agent awareness
+     * @returns Memory status with token usage and key counts
+     */
+    getStatus(): MemoryStatus;
+    /**
+     * Create memory snapshot for persistence
+     * Caches snapshot internally for later retrieval
+     * @returns Deep copy of current memory state
+     */
+    toSnapshot(): AgentMemory;
+    /**
+     * Get cached memory snapshot
+     * Returns snapshot created by toSnapshot()
+     * @returns Cached snapshot (undefined if toSnapshot() not called yet)
+     */
+    getSnapshot(): AgentMemory | undefined;
+    /**
+     * Build context string for LLM
+     * Serializes sessionmemory + history memory with clear sections
+     * Shows current iteration entries FIRST (reverse chronological) for LLM attention
+     * @param currentIteration - Current iteration number (0 = pre-iteration)
+     * @param currentTurn - Current turn number (optional, for session context filtering)
+     * @returns Formatted memory context for LLM prompt
+     */
+    toContext(currentIteration: number, currentTurn?: number): string;
+}
+
+/**
+ * Knowledge Map Types
+ *
+ * Enables agents to navigate organizational knowledge through a lightweight
+ * graph that lazy-loads capabilities on-demand.
+ *
+ * @module agent/knowledge-map
+ */
+
+/**
+ * Lightweight knowledge map (passed as agent property)
+ *
+ * Contains metadata about available knowledge nodes without loading
+ * the full content upfront. Total size: ~300-500 tokens.
+ *
+ * Multi-tenancy is enforced via:
+ * - File-scoped maps (organizations/{org-name}/knowledge/)
+ * - ExecutionContext.organizationId passed to node.load()
+ */
+interface KnowledgeMap {
+    /** Available knowledge nodes indexed by ID */
+    nodes: Record<string, KnowledgeNode>;
+}
+/**
+ * Single knowledge source
+ *
+ * Represents a domain knowledge area (CRM, brand guidelines, Excel tools)
+ * that can be lazy-loaded to provide instructions and tools to agents.
+ */
+interface KnowledgeNode {
+    /** Unique identifier for this node (e.g., "crm", "brand-guidelines") */
+    id: string;
+    /**
+     * Description of when to use this knowledge
+     * Used for semantic matching against user intent
+     */
+    description: string;
+    /**
+     * Load knowledge content on-demand
+     *
+     * @param context - Execution context with organizationId for multi-tenancy
+     * @returns Promise resolving to knowledge content (prompt + optional tools)
+     */
+    load(context: ExecutionContext): Promise<KnowledgeContent>;
+    /**
+     * Loaded state flag
+     * Set to true after load() is called
+     */
+    loaded?: boolean;
+    /**
+     * Cached prompt (for system prompt serialization)
+     * Only the prompt is cached - tools go to toolRegistry, children flattened to nodes
+     */
+    prompt?: string;
+}
+/**
+ * Content returned by knowledge node
+ *
+ * Separates instructions (prompt) from capabilities (tools).
+ * Tools are optional - some nodes only provide context.
+ *
+ * Supports recursive navigation - nodes can contain child nodes
+ * that are discovered when the parent node is loaded.
+ */
+interface KnowledgeContent {
+    /** Instructions and context (markdown format) */
+    prompt: string;
+    /** Tool implementations (optional) */
+    tools?: Tool[];
+    /**
+     * Child knowledge nodes (optional, recursive)
+     *
+     * Enables hierarchical navigation: base → specialized → deep expertise.
+     * Child nodes are flattened into the main knowledge map when parent loads,
+     * making them available for subsequent navigate-knowledge actions.
+     *
+     * Example: CRM base node returns crm-customers and crm-deals as children
+     */
+    nodes?: Record<string, KnowledgeNode>;
+}
+
+/**
+ * Agent-specific type definitions
+ * Types for autonomous agents with tools, memory, and constraints
+ */
+
+/**
+ * Factory function for creating LLM adapters.
+ * Injected into the Agent class to decouple the engine from server-only provider SDKs.
+ * - API process: provides createLLMAdapter (real SDKs + process.env API keys)
+ * - SDK worker: provides PostMessageLLMAdapter (proxies via platform.call)
+ *
+ * Uses `any` for optional params so both the real createLLMAdapter (with typed
+ * AIUsageCollector/AICallContext) and the worker proxy (which ignores them) satisfy the type.
+ */
+type LLMAdapterFactory = (config: ModelConfig, ...args: any[]) => LLMAdapter;
+type AgentKind = 'orchestrator' | 'specialist' | 'utility' | 'platform';
+interface AgentConfig extends ResourceDefinition {
+    type: 'agent';
+    /** OM descriptor backing canonical identity and governance metadata. */
+    resource?: AgentResourceEntry;
+    kind: AgentKind;
+    systemPrompt: string;
+    constraints?: AgentConstraints;
+    /**
+     * Session capability declaration (opt-in)
+     * If true, agent is designed for multi-turn session interactions
+     * Controls whether agent can use message action and appears in Sessions UI
+     *
+     * Use for:
+     * - Conversational agents with multi-turn interactions
+     * - Agents requiring persistent context across turns
+     * - Agents that need human-in-the-loop communication
+     */
+    sessionCapable?: boolean;
+    /**
+     * Security level for system prompt hardening (auto-derived if omitted)
+     *
+     * - 'standard': Lightweight defense (3 rules) - default for non-session agents
+     * - 'hardened': Comprehensive defense (6 rules) - default for session-capable agents
+     * - 'none': No security prompt - for pure internal agents with no external input
+     *
+     * If omitted, derived from sessionCapable:
+     *   sessionCapable: true  -> 'hardened'
+     *   sessionCapable: false -> 'standard'
+     */
+    securityLevel?: 'standard' | 'hardened' | 'none';
+    /**
+     * Memory management preferences (opt-in)
+     * If provided, agent can use memoryOps to manage session memory
+     * If omitted, agent has no memory management capabilities
+     *
+     * Agent-specific guidance on what to preserve, when to persist, and what to clean up.
+     * This guidance is injected into the system prompt when memory management is enabled.
+     *
+     * Use for:
+     * - Conversational agents needing cross-turn context
+     * - Agents managing complex user preferences
+     * - Agents tracking decisions over multiple iterations
+     */
+    memoryPreferences?: string;
+}
+interface AgentConstraints {
+    maxIterations?: number;
+    timeout?: number;
+    maxSessionMemoryKeys?: number;
+    maxMemoryTokens?: number;
+}
+interface AgentDefinition {
+    config: AgentConfig;
+    contract: Contract;
+    tools: Tool[];
+    /**
+     * Model configuration for LLM execution
+     * Specifies provider, API key, and model-specific options
+     */
+    modelConfig: ModelConfig;
+    /**
+     * Optional knowledge map for lazy-loading capabilities
+     * Enables agents to navigate organizational knowledge on-demand
+     */
+    knowledgeMap?: KnowledgeMap;
+    /**
+     * Preload memory before execution starts
+     * Handles BOTH context loading AND session restoration
+     *
+     * @param context - Execution context (includes sessionId if session turn)
+     * @returns Initial AgentMemory state (sessionMemory entries + optionally history)
+     */
+    preloadMemory?: (context: ExecutionContext) => Promise<AgentMemory> | AgentMemory;
+    /**
+     * Metrics configuration for ROI calculations
+     * Optional: Only needed if tracking automation savings
+     */
+    metricsConfig?: ResourceMetricsConfig;
+    /**
+     * Execution interface configuration (optional)
+     * If provided, agent appears in Execution Runner UI
+     */
+    interface?: ExecutionInterface;
+}
+/**
+ * Agent execution context
+ * Groups all state needed for agent execution phases
+ */
+interface IterationContext {
+    config: AgentConfig;
+    contract: Contract;
+    toolRegistry: Map<string, Tool>;
+    memoryManager: MemoryManager;
+    executionContext: ExecutionContext;
+    iteration: number;
+    logger: AgentScopedLogger;
+    modelConfig: ModelConfig;
+    adapterFactory: LLMAdapterFactory;
+    knowledgeMap?: KnowledgeMap;
+}
+
+declare const OntologyScopeSchema: z.ZodDefault<z.ZodObject<{
+    objectTypes: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        ownerSystemId: z.ZodOptional<z.ZodString>;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        storage: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$loose>>>>;
+    linkTypes: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        ownerSystemId: z.ZodOptional<z.ZodString>;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        from: z.ZodString;
+        to: z.ZodString;
+        cardinality: z.ZodOptional<z.ZodString>;
+        via: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>>;
+    actionTypes: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        ownerSystemId: z.ZodOptional<z.ZodString>;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        actsOn: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+        input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        effects: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    }, z.core.$loose>>>>;
+    catalogTypes: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        ownerSystemId: z.ZodOptional<z.ZodString>;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        kind: z.ZodOptional<z.ZodString>;
+        appliesTo: z.ZodOptional<z.ZodString>;
+        entries: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$loose>>>>;
+    eventTypes: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        ownerSystemId: z.ZodOptional<z.ZodString>;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$loose>>>>;
+    interfaceTypes: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        ownerSystemId: z.ZodOptional<z.ZodString>;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$loose>>>>;
+    valueTypes: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        ownerSystemId: z.ZodOptional<z.ZodString>;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        primitive: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>>;
+    sharedProperties: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        ownerSystemId: z.ZodOptional<z.ZodString>;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        valueType: z.ZodOptional<z.ZodString>;
+        searchable: z.ZodOptional<z.ZodBoolean>;
+        pii: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>>>;
+    groups: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        ownerSystemId: z.ZodOptional<z.ZodString>;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        members: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+    }, z.core.$loose>>>>;
+    surfaces: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        ownerSystemId: z.ZodOptional<z.ZodString>;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        route: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>>;
+}, z.core.$strip>>;
+type OntologyScope = z.infer<typeof OntologyScopeSchema>;
+
+/**
+ * MetricsCollector
+ * Tracks execution timing and ROI metrics
+ */
+declare class MetricsCollector {
+    private timings;
+    private durationMs?;
+    /**
+     * Start a timer with a label
+     */
+    startTimer(label: string): void;
+    /**
+     * End a timer and calculate duration
+     * If label is 'execution', stores duration for metrics summary
+     */
+    endTimer(label: string): number | null;
+    /**
+     * Build execution metrics summary with optional ROI calculation
+     */
+    buildExecutionMetrics(metricsConfig?: ResourceMetricsConfig): ExecutionMetricsSummary;
+}
+
+interface BaseAICall {
+    callSequence: number;
+    callType: 'agent-reasoning' | 'agent-completion' | 'workflow-step' | 'tool' | 'other';
+    model: LLMModel;
+    inputTokens: number;
+    outputTokens: number;
+    costUsd: number;
+    latencyMs: number;
+    context?: AICallContext;
+}
+type AICallContext = AgentReasoningContext | AgentCompletionContext | WorkflowStepContext | ToolCallContext | OtherCallContext;
+interface AgentReasoningContext {
+    type: 'agent-reasoning';
+    iteration: number;
+    actionsPlanned?: string[];
+    sessionId?: string;
+    turnNumber?: number;
+}
+interface AgentCompletionContext {
+    type: 'agent-completion';
+    attempt: 1 | 2;
+    validationFailed?: boolean;
+    sessionId?: string;
+    turnNumber?: number;
+}
+interface WorkflowStepContext {
+    type: 'workflow-step';
+    stepId: string;
+    stepName?: string;
+    stepSequence?: number;
+}
+interface ToolCallContext {
+    type: 'tool';
+    toolName: string;
+    parentIteration?: number;
+    parentStepId?: string;
+}
+interface OtherCallContext {
+    type: 'other';
+    description?: string;
+    metadata?: Record<string, unknown>;
+}
+type AICallRecord = BaseAICall;
+/**
+ * Raw LLM usage data returned by adapters
+ * Used as input to AIUsageCollector.record()
+ */
+interface LLMUsageData {
+    model: LLMModel;
+    inputTokens: number;
+    outputTokens: number;
+    latencyMs: number;
+    /** Actual cost from provider in USD (when available, e.g., OpenRouter) */
+    cost?: number;
+}
+interface AIUsageSummary {
+    model: LLMModel;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalTokens: number;
+    totalCostUsd: number;
+    callCount: number;
+    calls: AICallRecord[];
+}
+interface ExecutionMetricsSummary {
+    durationMs?: number;
+    automationSavingsUsd?: number;
+}
+interface ResourceMetricsConfig {
+    estimatedManualMinutes: number;
+    hourlyLaborRateUsd: number;
+    confidenceLevel?: 'low' | 'medium' | 'high';
+    notes?: string;
+}
+
+/**
+ * AIUsageCollector
+ * Centralized token tracking that aggregates usage across all LLM calls in an execution
+ */
+declare class AIUsageCollector {
+    private model;
+    private calls;
+    private callSequence;
+    /**
+     * 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: LLMUsageData, callType?: BaseAICall['callType'], context?: AICallContext): void;
+    /**
+     * Get aggregated summary of all AI calls
+     */
+    getSummary(): AIUsageSummary;
+    /**
+     * Check if any usage has been recorded
+     */
+    hasUsage(): boolean;
+}
+
+/**
+ * Base Execution Engine type definitions
+ * Core types shared across all Execution Engine resources
+ */
+
+/**
+ * Immutable execution metadata
+ * Represents complete execution identity (who, what, when, where)
+ * Shared across ExecutionContext and ExecutionLoggerContext to eliminate field duplication
+ */
+interface ExecutionMetadata {
+    executionId: string;
+    organizationId: string;
+    organizationName: string;
+    resourceId: string;
+    userId?: string;
+    sessionId?: string;
+    sessionTurnNumber?: number;
+}
+/**
+ * Unified message event type - covers all message types in sessions
+ * Replaces separate SessionTurnMessages and AgentActivityEvent mechanisms
+ */
+/**
+ * Structured action metadata attached to assistant messages.
+ * Frontend reads this instead of parsing text prefixes.
+ */
+type AssistantAction = {
+    kind: 'navigate';
+    path: string;
+    reason: string;
+} | {
+    kind: 'update_filters';
+    timeRange: string | null;
+    statusFilter: string | null;
+    searchQuery: string | null;
+};
+type MessageEvent = {
+    type: 'user_message';
+    text: string;
+} | {
+    type: 'assistant_message';
+    text: string;
+    _action?: AssistantAction;
+} | {
+    type: 'agent:started';
+} | {
+    type: 'agent:completed';
+} | {
+    type: 'agent:error';
+    error: string;
+} | {
+    type: 'agent:reasoning';
+    iteration: number;
+    reasoning: string;
+} | {
+    type: 'agent:tool_call';
+    toolName: string;
+    args: Record<string, unknown>;
+} | {
+    type: 'agent:tool_result';
+    toolName: string;
+    success: boolean;
+    result?: unknown;
+    error?: string;
+};
+/**
+ * Execution context for all resources
+ * Unified callback replaces SessionTurnMessages (removed)
+ */
+interface ExecutionContext extends ExecutionMetadata {
+    logger: IExecutionLogger;
+    signal?: AbortSignal;
+    onMessageEvent?: (event: MessageEvent) => Promise<void>;
+    /** Called per iteration to write heartbeat + check stall status. Non-fatal if it throws. */
+    onHeartbeat?: () => Promise<void>;
+    aiUsageCollector?: AIUsageCollector;
+    metricsCollector?: MetricsCollector;
+    parentExecutionId?: string;
+    executionDepth: number;
+    credentialName?: string;
+    store: Map<string, unknown>;
+}
+interface Contract {
+    inputSchema: z.ZodSchema;
+    outputSchema?: z.ZodSchema;
+}
+
+/**
+ * Tool definitions
+ *
+ * Tool interface used by agents and workflows.
+ * Provides a universal interface for AI systems to interact with tools.
+ */
+
+/**
+ * Options for tool execution
+ * Provides named parameters for better API clarity and extensibility
+ */
+interface ToolExecutionOptions {
+    /** Tool input (validated against inputSchema before execution) */
+    input: unknown;
+    /** Execution context with multi-tenant isolation and observability (optional for simple tools, required for platform/integration tools) */
+    executionContext?: ExecutionContext;
+    /** Full iteration context for advanced tools (provides access to memoryManager, toolRegistry, logger, etc.) */
+    iterationContext?: IterationContext;
+    /** Abort signal for timeout/cancellation -- forward to fetch() calls for clean cancellation */
+    signal?: AbortSignal;
+}
+/**
+ * Tool interface for AI systems
+ *
+ * Used by:
+ * - Agents: For agentic tool use (reasoning loop selects and executes tools)
+ * - Workflows: For workflow step tool invocation (future)
+ * - Platform tools: createApprovalTool(), createSchedulerTool()
+ * - Integration tools: External API calls (Gmail, Slack, etc.)
+ */
+interface Tool {
+    name: string;
+    description: string;
+    inputSchema: z.ZodSchema;
+    outputSchema: z.ZodSchema;
+    execute: (options: ToolExecutionOptions) => Promise<unknown>;
+    timeout?: number;
+}
+
+/**
+ * Supported integration types
+ *
+ * These represent the available integration adapters that can be used with tools.
+ * Each integration type corresponds to an adapter implementation.
+ *
+ * Note: Concrete adapter implementations are deferred until needed.
+ * This type provides compile-time safety and auto-completion for tool definitions.
+ */
+type IntegrationType = 'gmail' | 'google-sheets' | 'slack' | 'github' | 'linear' | 'attio' | 'airtable' | 'salesforce' | 'hubspot' | 'stripe' | 'twilio' | 'sendgrid' | 'mailgun' | 'zapier' | 'webhook' | 'apify' | 'instantly' | 'resend' | 'signature-api' | 'dropbox' | 'anymailfinder' | 'tomba' | 'millionverifier';
+
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+/** Explicit interface needed to annotate the recursive SystemEntrySchema. */
+interface SystemEntry {
+    id: string;
+    label?: string;
+    title?: string;
+    description?: string;
+    kind?: 'product' | 'operational' | 'platform' | 'diagnostic';
+    parentSystemId?: string;
+    ui?: {
+        path: string;
+        surfaces: string[];
+        icon?: string;
+        order?: number;
+    };
+    lifecycle?: 'draft' | 'beta' | 'active' | 'deprecated' | 'archived';
+    responsibleRoleId?: string;
+    governedByKnowledge?: string[];
+    actions?: {
+        actionId: string;
+        intent: 'exposes' | 'consumes';
+        invocation?: unknown;
+    }[];
+    policies?: string[];
+    drivesGoals?: string[];
+    /** @deprecated Use lifecycle. Accepted for one publish cycle. */
+    status?: 'active' | 'deprecated' | 'archived';
+    path?: string;
+    icon?: string;
+    color?: string;
+    uiPosition?: 'sidebar-primary' | 'sidebar-bottom';
+    enabled?: boolean;
+    devOnly?: boolean;
+    requiresAdmin?: boolean;
+    order: number;
+    config?: Record<string, JsonValue>;
+    ontology?: OntologyScope;
+    systems?: Record<string, SystemEntry>;
+    subsystems?: Record<string, SystemEntry>;
+}
+
+/**
+ * Resource Registry type definitions
+ */
+
+/**
+ * Environment/deployment status for resources
+ */
+type ResourceStatus = 'dev' | 'prod';
+/**
+ * All resource types in the platform
+ * Used as the discriminator field in ResourceDefinition
+ */
+type ResourceType = 'agent' | 'workflow' | 'trigger' | 'integration' | 'external' | 'human';
+type ResourceSystemSummary = Pick<SystemEntry, 'id' | 'title' | 'description' | 'kind' | 'lifecycle'>;
+/**
+ * Base interface for ALL platform resources
+ * Shared by both executable (agents, workflows) and non-executable (triggers, integrations, etc.) resources
+ */
+interface ResourceDefinition {
+    /** Unique resource identifier */
+    resourceId: string;
+    /** Display name */
+    name: string;
+    /** Purpose and functionality description */
+    description: string;
+    /** Version for change tracking and evolution */
+    version: string;
+    /** Resource type discriminator */
+    type: ResourceType;
+    /** Environment/deployment status */
+    status: ResourceStatus;
+    /** Graph links to Organization Model nodes */
+    links?: ResourceLink[];
+    /** Infrastructure category for filtering */
+    category?: ResourceCategory;
+    /** Whether the agent supports multi-turn sessions (agents only) */
+    sessionCapable?: boolean;
+    /** Whether the resource is local (monorepo) or remote (externally deployed) */
+    origin?: 'local' | 'remote';
+    /** OM System membership — dot-separated system path (e.g. "sys.lead-gen"), when backed by a Resource descriptor */
+    systemPath?: string;
+    /** Display metadata for the owning OM System */
+    system?: ResourceSystemSummary;
+    /** Governance lifecycle status from the OM Resource descriptor */
+    governanceStatus?: ResourceGovernanceStatus;
+    /** Whether this resource is archived and should be excluded from registration and deployment */
+    archived?: boolean;
+}
+/** Webhook provider identifiers */
+type WebhookProviderType = 'cal-com' | 'stripe' | 'signature-api' | 'instantly' | 'apify' | 'test';
+/** Webhook trigger configuration */
+interface WebhookTriggerConfig {
+    /** Provider identifier */
+    provider: WebhookProviderType;
+    /** Event type for documentation (not used for matching - workflow handles routing) */
+    event?: string;
+    /** Optional filtering (e.g., specific form ID for Fillout) */
+    filter?: Record<string, string>;
+    /** References credential in credentials table for per-org webhook secrets */
+    credentialName?: string;
+}
+/** Schedule trigger configuration */
+interface ScheduleTriggerConfig {
+    /** Cron expression (e.g., '0 6 * * *') */
+    cron: string;
+    /** Optional timezone (default: UTC) */
+    timezone?: string;
+}
+/** Event trigger configuration */
+interface EventTriggerConfig {
+    /** Internal event type */
+    eventType: string;
+    /** Event source */
+    source?: string;
+}
+/** Union of all trigger configs */
+type TriggerConfig = WebhookTriggerConfig | ScheduleTriggerConfig | EventTriggerConfig;
+/**
+ * Trigger metadata - entry points that initiate resource execution
+ *
+ * Triggers represent how executions start: webhooks from external services,
+ * scheduled cron jobs, platform events, or manual user actions.
+ *
+ * BREAKING CHANGES (2025-11-30):
+ * - Now extends ResourceDefinition (inherits: resourceId, name, description, version, type, status, links, category)
+ * - Field renames: `id` -> `resourceId` (inherited), `type` -> `triggerType`
+ * - Relationship rename: `invokes` -> `triggers` (unified vocabulary)
+ * - New required fields: `version` (inherited), `type: 'trigger'` (inherited)
+ * - triggers object now includes `externalResources` option
+ *
+ * @example
+ * // TriggerDefinition - metadata only
+ * {
+ *   resourceId: 'trigger-new-order',
+ *   type: 'trigger',
+ *   triggerType: 'webhook',
+ *   name: 'New Order',
+ *   description: 'Webhook from Shopify on new orders',
+ *   version: '1.0.0',
+ *   status: 'prod',
+ *   webhookPath: '/webhooks/shopify/orders'
+ * }
+ *
+ * // Relationships declared in ResourceRelationships (not on TriggerDefinition):
+ * // relationships: {
+ * //   'trigger-new-order': { triggers: { workflows: ['order-fulfillment-workflow'] } }
+ * // }
+ */
+interface TriggerDefinition extends ResourceDefinition {
+    /** Resource type discriminator (narrowed from base union) */
+    type: 'trigger';
+    /** Trigger mechanism type (renamed from 'type' to avoid collision with base type discriminator) */
+    triggerType: 'webhook' | 'schedule' | 'manual' | 'event';
+    /** Type-specific configuration */
+    config?: TriggerConfig;
+    /** For webhook triggers: path like '/webhooks/shopify/orders' */
+    webhookPath?: string;
+    /** For schedule triggers: cron expression like '0 6 * * *' */
+    schedule?: string;
+    /** For event triggers: event type like 'low-stock-alert' */
+    eventType?: string;
+}
+/**
+ * Integration metadata - external service connections
+ *
+ * References credentials table for actual connection. No connection status
+ * stored here (queried at runtime from credentials table).
+ *
+ * BREAKING CHANGES (2025-11-30):
+ * - Now extends ResourceDefinition (inherits: resourceId, name, description, version, type, status, links, category)
+ * - Field renames: `id` -> `resourceId` (inherited)
+ * - New required field: `status` (inherited) - organizations must add status to all integrations
+ * - New required field: `version` (inherited) - organizations must add version to all integrations
+ * - New required field: `type: 'integration'` (inherited) - resource type discriminator
+ *
+ * @example
+ * {
+ *   resourceId: 'integration-shopify-prod',
+ *   type: 'integration',
+ *   provider: 'shopify',
+ *   credentialName: 'shopify-prod',
+ *   name: 'Shopify Production',
+ *   description: 'E-commerce platform',
+ *   version: '1.0.0',
+ *   status: 'prod'
+ * }
+ */
+interface IntegrationDefinition extends ResourceDefinition {
+    /** Resource type discriminator (narrowed from base union) */
+    type: 'integration';
+    /** OM descriptor that owns canonical identity and governance metadata. */
+    resource?: Extract<ResourceEntry, {
+        kind: 'integration';
+    }>;
+    /** Integration provider type */
+    provider: IntegrationType;
+    /** References credentials table (e.g., 'shopify-prod', 'zendesk-api') */
+    credentialName: string;
+}
+/**
+ * Explicit resource relationship declaration
+ *
+ * Single-direction only - Command View derives reverse relationships.
+ * Agents/workflows declare what they trigger and use.
+ *
+ * @example
+ * {
+ *   triggers: { workflows: ['order-fulfillment-workflow'] },
+ *   uses: { integrations: ['integration-shopify-prod', 'integration-postgres'] }
+ * }
+ */
+interface RelationshipDeclaration {
+    /** Resources this resource triggers */
+    triggers?: {
+        /** Agent resourceIds this resource triggers */
+        agents?: string[];
+        /** Workflow resourceIds this resource triggers */
+        workflows?: string[];
+    };
+    /** Integrations this resource uses */
+    uses?: {
+        /** Integration IDs this resource uses */
+        integrations?: string[];
+    };
+}
+/**
+ * Resource relationships map
+ * Maps resourceId to its relationship declarations
+ *
+ * @example
+ * {
+ *   'order-processor-agent': {
+ *     triggers: { workflows: ['order-fulfillment-workflow'] },
+ *     uses: { integrations: ['integration-shopify-prod'] }
+ *   }
+ * }
+ */
+type ResourceRelationships = Record<string, RelationshipDeclaration>;
+/**
+ * External platform type
+ * Supported third-party automation platforms
+ */
+type ExternalPlatform = 'n8n' | 'make' | 'zapier' | 'other';
+/**
+ * External automation resource metadata
+ *
+ * Represents workflows/automations running on third-party platforms
+ * (n8n, Make, Zapier, etc.) for visualization in Command View.
+ *
+ * NOTE: This is metadata ONLY for visualization. No execution logic,
+ * no API integration with external platforms, no status syncing.
+ *
+ * BREAKING CHANGES (2025-11-30):
+ * - Now extends ResourceDefinition (inherits: resourceId, name, description, version, type, status, links, category)
+ * - Field renames: `id` -> `resourceId` (inherited)
+ * - New required field: `version` (inherited) - organizations must add version to all external resources
+ * - New required field: `type: 'external'` (inherited) - resource type discriminator
+ * - REMOVED FIELD: `triggeredBy` - per relationship-consolidation design, all relationships are forward-only declarations
+ *
+ * @example
+ * {
+ *   resourceId: 'external-n8n-order-sync',
+ *   type: 'external',
+ *   version: '1.0.0',
+ *   platform: 'n8n',
+ *   name: 'Shopify Order Sync',
+ *   description: 'Legacy n8n workflow for syncing Shopify orders',
+ *   status: 'prod',
+ *   platformUrl: 'https://n8n.client.com/workflow/123',
+ *   triggers: { workflows: ['order-fulfillment-workflow'] },
+ *   uses: { integrations: ['integration-shopify-prod'] }
+ * }
+ */
+interface ExternalResourceDefinition extends ResourceDefinition {
+    /** Resource type discriminator (narrowed from base union) */
+    type: 'external';
+    /** Platform type */
+    platform: ExternalPlatform;
+    /** Link to external platform (e.g., n8n workflow editor URL) */
+    platformUrl?: string;
+    /** Platform's internal ID/reference */
+    externalId?: string;
+    /** What this external resource triggers (external -> internal) */
+    triggers?: {
+        /** Elevasis workflow resourceIds this external automation triggers */
+        workflows?: string[];
+        /** Elevasis agent resourceIds this external automation triggers */
+        agents?: string[];
+    };
+    /** Integrations this external resource uses (shared credentials) */
+    uses?: {
+        /** Integration IDs this external automation uses */
+        integrations?: string[];
+    };
+}
+/**
+ * Human Checkpoint definition - human decision points in automation
+ *
+ * Represents where human judgment is deployed in the automation landscape.
+ * Tasks with matching command_queue_group are routed to this checkpoint.
+ *
+ * BREAKING CHANGES (2025-11-30):
+ * - Now extends ResourceDefinition (inherits: resourceId, name, description, version, type, status, links, category)
+ * - Field renames: `id` -> `resourceId` (inherited)
+ * - description is now REQUIRED (was optional) - organizations must add description to all human checkpoints
+ * - New required field: `version` (inherited) - organizations must add version to all human checkpoints
+ * - New required field: `type: 'human'` (inherited) - resource type discriminator
+ *
+ * @example
+ * {
+ *   resourceId: 'sales-approval',
+ *   type: 'human',
+ *   name: 'Sales Approval Queue',
+ *   description: 'High-value order approvals for sales team',
+ *   version: '1.0.0',
+ *   status: 'prod',
+ *   requestedBy: { agents: ['order-processor-agent'] },
+ *   routesTo: { agents: ['order-fulfillment-agent'] }
+ * }
+ */
+interface HumanCheckpointDefinition extends ResourceDefinition {
+    /** Resource type discriminator (narrowed from base union) */
+    type: 'human';
+    /** Resources that create tasks for this checkpoint */
+    requestedBy?: {
+        /** Agent resourceIds that request approval here */
+        agents?: string[];
+        /** Workflow resourceIds that request approval here */
+        workflows?: string[];
+    };
+    /** Resources that receive approved decisions */
+    routesTo?: {
+        /** Agent resourceIds that handle approved tasks */
+        agents?: string[];
+        /** Workflow resourceIds that handle approved tasks */
+        workflows?: string[];
+    };
+}
+
+declare const SurfaceTypeSchema: z.ZodEnum<{
+    dashboard: "dashboard";
+    settings: "settings";
+    graph: "graph";
+    list: "list";
+    page: "page";
+    detail: "detail";
+}>;
+interface SidebarSurfaceNode {
+    type: 'surface';
+    label: string;
+    path: string;
+    surfaceType: z.infer<typeof SurfaceTypeSchema>;
+    description?: string;
+    icon?: string;
+    order?: number;
+    targets?: {
+        systems?: string[];
+        entities?: string[];
+        resources?: string[];
+        actions?: string[];
+    };
+    devOnly?: boolean;
+    requiresAdmin?: boolean;
+}
+interface SidebarGroupNode {
+    type: 'group';
+    label: string;
+    description?: string;
+    icon?: string;
+    order?: number;
+    children: Record<string, SidebarNode>;
+}
+type SidebarNode = SidebarSurfaceNode | SidebarGroupNode;
+
+declare const LinkSchema: z.ZodObject<{
+    nodeId: z.ZodString;
+    kind: z.ZodEnum<{
+        links: "links";
+        affects: "affects";
+        effects: "effects";
+        actions: "actions";
+        reads: "reads";
+        writes: "writes";
+        emits: "emits";
+        triggers: "triggers";
+        uses: "uses";
+        approval: "approval";
+        contains: "contains";
+        references: "references";
+        maps_to: "maps_to";
+        governs: "governs";
+        originates_from: "originates_from";
+        applies_to: "applies_to";
+        uses_catalog: "uses_catalog";
+    }>;
+}, z.core.$strip>;
+type Link = z.infer<typeof LinkSchema>;
+
+declare const OrganizationModelSchema$1: z.ZodObject<{
+    version: z.ZodDefault<z.ZodLiteral<1>>;
+    domainMetadata: z.ZodPipe<z.ZodDefault<z.ZodObject<{
+        branding: z.ZodOptional<z.ZodObject<{
+            version: z.ZodDefault<z.ZodLiteral<1>>;
+            lastModified: z.ZodString;
+        }, z.core.$strip>>;
+        identity: z.ZodOptional<z.ZodObject<{
+            version: z.ZodDefault<z.ZodLiteral<1>>;
+            lastModified: z.ZodString;
+        }, z.core.$strip>>;
+        customers: z.ZodOptional<z.ZodObject<{
+            version: z.ZodDefault<z.ZodLiteral<1>>;
+            lastModified: z.ZodString;
+        }, z.core.$strip>>;
+        offerings: z.ZodOptional<z.ZodObject<{
+            version: z.ZodDefault<z.ZodLiteral<1>>;
+            lastModified: z.ZodString;
+        }, z.core.$strip>>;
+        roles: z.ZodOptional<z.ZodObject<{
+            version: z.ZodDefault<z.ZodLiteral<1>>;
+            lastModified: z.ZodString;
+        }, z.core.$strip>>;
+        goals: z.ZodOptional<z.ZodObject<{
+            version: z.ZodDefault<z.ZodLiteral<1>>;
+            lastModified: z.ZodString;
+        }, z.core.$strip>>;
+        systems: z.ZodOptional<z.ZodObject<{
+            version: z.ZodDefault<z.ZodLiteral<1>>;
+            lastModified: z.ZodString;
+        }, z.core.$strip>>;
+        ontology: z.ZodOptional<z.ZodObject<{
+            version: z.ZodDefault<z.ZodLiteral<1>>;
+            lastModified: z.ZodString;
+        }, z.core.$strip>>;
+        resources: z.ZodOptional<z.ZodObject<{
+            version: z.ZodDefault<z.ZodLiteral<1>>;
+            lastModified: z.ZodString;
+        }, z.core.$strip>>;
+        topology: z.ZodOptional<z.ZodObject<{
+            version: z.ZodDefault<z.ZodLiteral<1>>;
+            lastModified: z.ZodString;
+        }, z.core.$strip>>;
+        actions: z.ZodOptional<z.ZodObject<{
+            version: z.ZodDefault<z.ZodLiteral<1>>;
+            lastModified: z.ZodString;
+        }, z.core.$strip>>;
+        entities: z.ZodOptional<z.ZodObject<{
+            version: z.ZodDefault<z.ZodLiteral<1>>;
+            lastModified: z.ZodString;
+        }, z.core.$strip>>;
+        policies: z.ZodOptional<z.ZodObject<{
+            version: z.ZodDefault<z.ZodLiteral<1>>;
+            lastModified: z.ZodString;
+        }, z.core.$strip>>;
+        knowledge: z.ZodOptional<z.ZodObject<{
+            version: z.ZodDefault<z.ZodLiteral<1>>;
+            lastModified: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>, z.ZodTransform<{
+        branding: {
+            version: 1;
+            lastModified: string;
+        };
+        identity: {
+            version: 1;
+            lastModified: string;
+        };
+        customers: {
+            version: 1;
+            lastModified: string;
+        };
+        offerings: {
+            version: 1;
+            lastModified: string;
+        };
+        roles: {
+            version: 1;
+            lastModified: string;
+        };
+        goals: {
+            version: 1;
+            lastModified: string;
+        };
+        systems: {
+            version: 1;
+            lastModified: string;
+        };
+        ontology: {
+            version: 1;
+            lastModified: string;
+        };
+        resources: {
+            version: 1;
+            lastModified: string;
+        };
+        topology: {
+            version: 1;
+            lastModified: string;
+        };
+        actions: {
+            version: 1;
+            lastModified: string;
+        };
+        entities: {
+            version: 1;
+            lastModified: string;
+        };
+        policies: {
+            version: 1;
+            lastModified: string;
+        };
+        knowledge: {
+            version: 1;
+            lastModified: string;
+        };
+    }, {
+        branding?: {
+            version: 1;
+            lastModified: string;
+        } | undefined;
+        identity?: {
+            version: 1;
+            lastModified: string;
+        } | undefined;
+        customers?: {
+            version: 1;
+            lastModified: string;
+        } | undefined;
+        offerings?: {
+            version: 1;
+            lastModified: string;
+        } | undefined;
+        roles?: {
+            version: 1;
+            lastModified: string;
+        } | undefined;
+        goals?: {
+            version: 1;
+            lastModified: string;
+        } | undefined;
+        systems?: {
+            version: 1;
+            lastModified: string;
+        } | undefined;
+        ontology?: {
+            version: 1;
+            lastModified: string;
+        } | undefined;
+        resources?: {
+            version: 1;
+            lastModified: string;
+        } | undefined;
+        topology?: {
+            version: 1;
+            lastModified: string;
+        } | undefined;
+        actions?: {
+            version: 1;
+            lastModified: string;
+        } | undefined;
+        entities?: {
+            version: 1;
+            lastModified: string;
+        } | undefined;
+        policies?: {
+            version: 1;
+            lastModified: string;
+        } | undefined;
+        knowledge?: {
+            version: 1;
+            lastModified: string;
+        } | undefined;
+    }>>;
+    branding: z.ZodObject<{
+        organizationName: z.ZodString;
+        productName: z.ZodString;
+        shortName: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        logos: z.ZodDefault<z.ZodObject<{
+            light: z.ZodOptional<z.ZodString>;
+            dark: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    navigation: z.ZodDefault<z.ZodObject<{
+        sidebar: z.ZodDefault<z.ZodObject<{
+            primary: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<SidebarNode, unknown, z.core.$ZodTypeInternals<SidebarNode, unknown>>>>;
+            bottom: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<SidebarNode, unknown, z.core.$ZodTypeInternals<SidebarNode, unknown>>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    identity: z.ZodDefault<z.ZodObject<{
+        mission: z.ZodDefault<z.ZodString>;
+        vision: z.ZodDefault<z.ZodString>;
+        legalName: z.ZodDefault<z.ZodString>;
+        entityType: z.ZodDefault<z.ZodString>;
+        jurisdiction: z.ZodDefault<z.ZodString>;
+        industryCategory: z.ZodDefault<z.ZodString>;
+        geographicFocus: z.ZodDefault<z.ZodString>;
+        timeZone: z.ZodDefault<z.ZodString>;
+        businessHours: z.ZodDefault<z.ZodObject<{
+            monday: z.ZodOptional<z.ZodObject<{
+                open: z.ZodString;
+                close: z.ZodString;
+            }, z.core.$strip>>;
+            tuesday: z.ZodOptional<z.ZodObject<{
+                open: z.ZodString;
+                close: z.ZodString;
+            }, z.core.$strip>>;
+            wednesday: z.ZodOptional<z.ZodObject<{
+                open: z.ZodString;
+                close: z.ZodString;
+            }, z.core.$strip>>;
+            thursday: z.ZodOptional<z.ZodObject<{
+                open: z.ZodString;
+                close: z.ZodString;
+            }, z.core.$strip>>;
+            friday: z.ZodOptional<z.ZodObject<{
+                open: z.ZodString;
+                close: z.ZodString;
+            }, z.core.$strip>>;
+            saturday: z.ZodOptional<z.ZodObject<{
+                open: z.ZodString;
+                close: z.ZodString;
+            }, z.core.$strip>>;
+            sunday: z.ZodOptional<z.ZodObject<{
+                open: z.ZodString;
+                close: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        clientBrief: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+    customers: z.ZodDefault<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        order: z.ZodNumber;
+        name: z.ZodDefault<z.ZodString>;
+        description: z.ZodDefault<z.ZodString>;
+        jobsToBeDone: z.ZodDefault<z.ZodString>;
+        pains: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        gains: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        firmographics: z.ZodDefault<z.ZodObject<{
+            industry: z.ZodOptional<z.ZodString>;
+            companySize: z.ZodOptional<z.ZodString>;
+            region: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        valueProp: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>>>;
+    offerings: z.ZodDefault<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        order: z.ZodNumber;
+        name: z.ZodDefault<z.ZodString>;
+        description: z.ZodDefault<z.ZodString>;
+        pricingModel: z.ZodDefault<z.ZodEnum<{
+            custom: "custom";
+            "one-time": "one-time";
+            subscription: "subscription";
+            "usage-based": "usage-based";
+        }>>;
+        price: z.ZodDefault<z.ZodNumber>;
+        currency: z.ZodDefault<z.ZodString>;
+        targetSegmentIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        deliveryFeatureId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>>;
+    roles: z.ZodDefault<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        order: z.ZodNumber;
+        title: z.ZodString;
+        responsibilities: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        reportsToId: z.ZodOptional<z.ZodString>;
+        heldBy: z.ZodOptional<z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"human">;
+            userId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"agent">;
+            agentId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"team">;
+            memberIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>], "kind">, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"human">;
+            userId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"agent">;
+            agentId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"team">;
+            memberIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>], "kind">>]>>;
+        responsibleFor: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>>;
+    goals: z.ZodDefault<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        order: z.ZodNumber;
+        description: z.ZodString;
+        periodStart: z.ZodString;
+        periodEnd: z.ZodString;
+        keyResults: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+            targetMetric: z.ZodString;
+            currentValue: z.ZodDefault<z.ZodNumber>;
+            targetValue: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>>;
+    systems: z.ZodDefault<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<SystemEntry, unknown, z.core.$ZodTypeInternals<SystemEntry, unknown>>>>>;
+    ontology: z.ZodDefault<z.ZodDefault<z.ZodObject<{
+        objectTypes: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            ownerSystemId: z.ZodOptional<z.ZodString>;
+            aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            storage: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$loose>>>>;
+        linkTypes: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            ownerSystemId: z.ZodOptional<z.ZodString>;
+            aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            from: z.ZodString;
+            to: z.ZodString;
+            cardinality: z.ZodOptional<z.ZodString>;
+            via: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>>>;
+        actionTypes: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            ownerSystemId: z.ZodOptional<z.ZodString>;
+            aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            actsOn: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+            input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            effects: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        }, z.core.$loose>>>>;
+        catalogTypes: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            ownerSystemId: z.ZodOptional<z.ZodString>;
+            aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            kind: z.ZodOptional<z.ZodString>;
+            appliesTo: z.ZodOptional<z.ZodString>;
+            entries: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$loose>>>>;
+        eventTypes: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            ownerSystemId: z.ZodOptional<z.ZodString>;
+            aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$loose>>>>;
+        interfaceTypes: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            ownerSystemId: z.ZodOptional<z.ZodString>;
+            aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$loose>>>>;
+        valueTypes: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            ownerSystemId: z.ZodOptional<z.ZodString>;
+            aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            primitive: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>>>;
+        sharedProperties: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            ownerSystemId: z.ZodOptional<z.ZodString>;
+            aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            valueType: z.ZodOptional<z.ZodString>;
+            searchable: z.ZodOptional<z.ZodBoolean>;
+            pii: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$loose>>>>;
+        groups: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            ownerSystemId: z.ZodOptional<z.ZodString>;
+            aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            members: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+        }, z.core.$loose>>>>;
+        surfaces: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            ownerSystemId: z.ZodOptional<z.ZodString>;
+            aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            route: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>>>;
+    }, z.core.$strip>>>;
+    resources: z.ZodDefault<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodString;
+        order: z.ZodDefault<z.ZodNumber>;
+        systemPath: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        ownerRoleId: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            deprecated: "deprecated";
+            active: "active";
+            archived: "archived";
+        }>;
+        ontology: z.ZodOptional<z.ZodObject<{
+            actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            primaryAction: z.ZodOptional<z.ZodString>;
+            reads: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            usesCatalogs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            emits: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            contract: z.ZodOptional<z.ZodObject<{
+                input: z.ZodOptional<z.ZodString>;
+                output: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        codeRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            role: z.ZodEnum<{
+                config: "config";
+                entrypoint: "entrypoint";
+                handler: "handler";
+                schema: "schema";
+                test: "test";
+                docs: "docs";
+            }>;
+            symbol: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        kind: z.ZodLiteral<"workflow">;
+        emits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            eventKey: z.ZodString;
+            label: z.ZodString;
+            payloadSchema: z.ZodOptional<z.ZodString>;
+            lifecycle: z.ZodOptional<z.ZodEnum<{
+                deprecated: "deprecated";
+                draft: "draft";
+                beta: "beta";
+                active: "active";
+                archived: "archived";
+            }>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        order: z.ZodDefault<z.ZodNumber>;
+        systemPath: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        ownerRoleId: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            deprecated: "deprecated";
+            active: "active";
+            archived: "archived";
+        }>;
+        ontology: z.ZodOptional<z.ZodObject<{
+            actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            primaryAction: z.ZodOptional<z.ZodString>;
+            reads: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            usesCatalogs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            emits: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            contract: z.ZodOptional<z.ZodObject<{
+                input: z.ZodOptional<z.ZodString>;
+                output: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        codeRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            role: z.ZodEnum<{
+                config: "config";
+                entrypoint: "entrypoint";
+                handler: "handler";
+                schema: "schema";
+                test: "test";
+                docs: "docs";
+            }>;
+            symbol: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        kind: z.ZodLiteral<"agent">;
+        agentKind: z.ZodEnum<{
+            platform: "platform";
+            orchestrator: "orchestrator";
+            specialist: "specialist";
+            utility: "utility";
+        }>;
+        actsAsRoleId: z.ZodOptional<z.ZodString>;
+        sessionCapable: z.ZodBoolean;
+        invocations: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"slash-command">;
+            command: z.ZodString;
+            toolFactory: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"mcp-tool">;
+            server: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"api-endpoint">;
+            method: z.ZodEnum<{
+                GET: "GET";
+                POST: "POST";
+                PATCH: "PATCH";
+                DELETE: "DELETE";
+            }>;
+            path: z.ZodString;
+            requestSchema: z.ZodOptional<z.ZodString>;
+            responseSchema: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"script-execution">;
+            resourceId: z.ZodString;
+        }, z.core.$strip>], "kind">>>;
+        emits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            eventKey: z.ZodString;
+            label: z.ZodString;
+            payloadSchema: z.ZodOptional<z.ZodString>;
+            lifecycle: z.ZodOptional<z.ZodEnum<{
+                deprecated: "deprecated";
+                draft: "draft";
+                beta: "beta";
+                active: "active";
+                archived: "archived";
+            }>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        order: z.ZodDefault<z.ZodNumber>;
+        systemPath: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        ownerRoleId: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            deprecated: "deprecated";
+            active: "active";
+            archived: "archived";
+        }>;
+        ontology: z.ZodOptional<z.ZodObject<{
+            actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            primaryAction: z.ZodOptional<z.ZodString>;
+            reads: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            usesCatalogs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            emits: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            contract: z.ZodOptional<z.ZodObject<{
+                input: z.ZodOptional<z.ZodString>;
+                output: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        codeRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            role: z.ZodEnum<{
+                config: "config";
+                entrypoint: "entrypoint";
+                handler: "handler";
+                schema: "schema";
+                test: "test";
+                docs: "docs";
+            }>;
+            symbol: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        kind: z.ZodLiteral<"integration">;
+        provider: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        order: z.ZodDefault<z.ZodNumber>;
+        systemPath: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        ownerRoleId: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            deprecated: "deprecated";
+            active: "active";
+            archived: "archived";
+        }>;
+        ontology: z.ZodOptional<z.ZodObject<{
+            actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            primaryAction: z.ZodOptional<z.ZodString>;
+            reads: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            usesCatalogs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            emits: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            contract: z.ZodOptional<z.ZodObject<{
+                input: z.ZodOptional<z.ZodString>;
+                output: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        codeRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            role: z.ZodEnum<{
+                config: "config";
+                entrypoint: "entrypoint";
+                handler: "handler";
+                schema: "schema";
+                test: "test";
+                docs: "docs";
+            }>;
+            symbol: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        kind: z.ZodLiteral<"script">;
+        language: z.ZodEnum<{
+            shell: "shell";
+            sql: "sql";
+            typescript: "typescript";
+            python: "python";
+        }>;
+        source: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            file: z.ZodString;
+        }, z.core.$strip>]>;
+    }, z.core.$strip>], "kind">>>>;
+    topology: z.ZodDefault<z.ZodDefault<z.ZodObject<{
+        version: z.ZodDefault<z.ZodLiteral<1>>;
+        relationships: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            from: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"system">;
+                id: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"resource">;
+                id: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"ontology">;
+                id: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"policy">;
+                id: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"role">;
+                id: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"trigger">;
+                id: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"humanCheckpoint">;
+                id: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"externalResource">;
+                id: z.ZodString;
+            }, z.core.$strip>], "kind">;
+            kind: z.ZodEnum<{
+                triggers: "triggers";
+                uses: "uses";
+                approval: "approval";
+            }>;
+            to: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"system">;
+                id: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"resource">;
+                id: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"ontology">;
+                id: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"policy">;
+                id: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"role">;
+                id: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"trigger">;
+                id: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"humanCheckpoint">;
+                id: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"externalResource">;
+                id: z.ZodString;
+            }, z.core.$strip>], "kind">;
+            systemPath: z.ZodOptional<z.ZodString>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    actions: z.ZodDefault<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        order: z.ZodNumber;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        scope: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"global">, z.ZodObject<{
+            domain: z.ZodString;
+        }, z.core.$strip>]>>;
+        resourceId: z.ZodOptional<z.ZodString>;
+        affects: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        invocations: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"slash-command">;
+            command: z.ZodString;
+            toolFactory: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"mcp-tool">;
+            server: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"api-endpoint">;
+            method: z.ZodEnum<{
+                GET: "GET";
+                POST: "POST";
+                PATCH: "PATCH";
+                DELETE: "DELETE";
+            }>;
+            path: z.ZodString;
+            requestSchema: z.ZodOptional<z.ZodString>;
+            responseSchema: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"script-execution">;
+            resourceId: z.ZodString;
+        }, z.core.$strip>], "kind">>>;
+        knowledge: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+        lifecycle: z.ZodDefault<z.ZodEnum<{
+            deprecated: "deprecated";
+            draft: "draft";
+            beta: "beta";
+            active: "active";
+            archived: "archived";
+        }>>;
+    }, z.core.$strip>>>>;
+    entities: z.ZodDefault<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        order: z.ZodNumber;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        ownedBySystemId: z.ZodString;
+        table: z.ZodOptional<z.ZodString>;
+        rowSchema: z.ZodOptional<z.ZodString>;
+        stateCatalogId: z.ZodOptional<z.ZodString>;
+        links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            toEntity: z.ZodString;
+            kind: z.ZodEnum<{
+                "belongs-to": "belongs-to";
+                "has-many": "has-many";
+                "has-one": "has-one";
+                "many-to-many": "many-to-many";
+            }>;
+            via: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>>;
+    policies: z.ZodDefault<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        order: z.ZodNumber;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        trigger: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"event">;
+            eventId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"action-invocation">;
+            actionId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"schedule">;
+            cron: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"manual">;
+        }, z.core.$strip>], "kind">;
+        predicate: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"always">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"expression">;
+            expression: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"threshold">;
+            metric: z.ZodString;
+            operator: z.ZodEnum<{
+                lt: "lt";
+                lte: "lte";
+                eq: "eq";
+                gte: "gte";
+                gt: "gt";
+            }>;
+            value: z.ZodNumber;
+        }, z.core.$strip>], "kind">>;
+        actions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"require-approval">;
+            roleId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"invoke-action">;
+            actionId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"notify-role">;
+            roleId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"block">;
+        }, z.core.$strip>], "kind">>;
+        appliesTo: z.ZodDefault<z.ZodObject<{
+            systemIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            actionIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            resourceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            roleIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        lifecycle: z.ZodDefault<z.ZodEnum<{
+            deprecated: "deprecated";
+            draft: "draft";
+            beta: "beta";
+            active: "active";
+            archived: "archived";
+        }>>;
+    }, z.core.$strip>>>>;
+    knowledge: z.ZodDefault<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            playbook: "playbook";
+            strategy: "strategy";
+            reference: "reference";
+        }>;
+        title: z.ZodString;
+        summary: z.ZodString;
+        icon: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            message: "message";
+            error: "error";
+            agent: "agent";
+            workflow: "workflow";
+            "google-sheets": "google-sheets";
+            dashboard: "dashboard";
+            calendar: "calendar";
+            sales: "sales";
+            crm: "crm";
+            "lead-gen": "lead-gen";
+            projects: "projects";
+            clients: "clients";
+            operations: "operations";
+            monitoring: "monitoring";
+            knowledge: "knowledge";
+            settings: "settings";
+            admin: "admin";
+            archive: "archive";
+            business: "business";
+            finance: "finance";
+            platform: "platform";
+            seo: "seo";
+            playbook: "playbook";
+            strategy: "strategy";
+            reference: "reference";
+            integration: "integration";
+            database: "database";
+            user: "user";
+            team: "team";
+            gmail: "gmail";
+            attio: "attio";
+            overview: "overview";
+            "command-view": "command-view";
+            "command-queue": "command-queue";
+            pipeline: "pipeline";
+            lists: "lists";
+            resources: "resources";
+            approve: "approve";
+            reject: "reject";
+            retry: "retry";
+            edit: "edit";
+            view: "view";
+            launch: "launch";
+            escalate: "escalate";
+            promote: "promote";
+            submit: "submit";
+            email: "email";
+            success: "success";
+            warning: "warning";
+            info: "info";
+            pending: "pending";
+            bolt: "bolt";
+            building: "building";
+            briefcase: "briefcase";
+            apps: "apps";
+            graph: "graph";
+            shield: "shield";
+            users: "users";
+            "chart-bar": "chart-bar";
+            search: "search";
+        }>, z.ZodString]>>;
+        externalUrl: z.ZodOptional<z.ZodString>;
+        sourceFilePath: z.ZodOptional<z.ZodString>;
+        body: z.ZodString;
+        links: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodUnion<readonly [z.ZodObject<{
+            target: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    knowledge: "knowledge";
+                    system: "system";
+                    action: "action";
+                    ontology: "ontology";
+                    role: "role";
+                    goal: "goal";
+                    resource: "resource";
+                    stage: "stage";
+                    "customer-segment": "customer-segment";
+                    offering: "offering";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            nodeId: z.ZodUnion<readonly [z.ZodString, z.ZodTemplateLiteral<`ontology:${string}`>]>;
+        }, z.core.$strip>]>, z.ZodTransform<{
+            target: {
+                kind: "knowledge" | "system" | "action" | "ontology" | "role" | "goal" | "resource" | "stage" | "customer-segment" | "offering";
+                id: string;
+            };
+            nodeId: string;
+        }, {
+            nodeId: string;
+        } | {
+            target: {
+                kind: "knowledge" | "system" | "action" | "ontology" | "role" | "goal" | "resource" | "stage" | "customer-segment" | "offering";
+                id: string;
+            };
+        }>>>>;
+        ownerIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>>>>;
+}, z.core.$strip>;
+
+type OrganizationModel$1 = z.infer<typeof OrganizationModelSchema$1>;
+
+declare const ResourceCategorySchema: z.ZodEnum<{
+    diagnostic: "diagnostic";
+    production: "production";
+    internal: "internal";
+    testing: "testing";
+}>;
+type ResourceCategory = z.infer<typeof ResourceCategorySchema>;
+type ResourceLink = Link;
+
+/**
+ * ResourceRegistry - Resource discovery and lookup
+ * Handles resource definitions from OrganizationRegistry
+ *
+ * Features:
+ * - Resource discovery by organization
+ * - Startup validation (duplicate IDs, model configs, relationships, interface-schema alignment)
+ * - Pre-serialization cache for instant API responses
+ * - Command View data generation
+ */
+
+/**
+ * Organization-specific resource collection
+ *
+ * Complete manifest of all automation resources for an organization.
+ * Used by ResourceRegistry for discovery and Command View for visualization.
+ */
+interface DeploymentSpec {
+    /** Deployment version (semver) */
+    version: string;
+    /** Optional Organization Model governance catalog used for OM-code validation */
+    organizationModel?: Partial<Pick<OrganizationModel$1, 'systems' | 'resources' | 'ontology' | 'topology' | 'roles' | 'policies' | 'entities' | 'actions'>>;
+    /** Workflow definitions */
+    workflows?: WorkflowDefinition[];
+    /** Agent definitions */
+    agents?: AgentDefinition[];
+    /** Trigger definitions - entry points that initiate executions */
+    triggers?: TriggerDefinition[];
+    /** Integration definitions - external service connections */
+    integrations?: IntegrationDefinition[];
+    /** Explicit relationship declarations between resources */
+    relationships?: ResourceRelationships;
+    /** External automation resources (n8n, Make, Zapier, etc.) */
+    externalResources?: ExternalResourceDefinition[];
+    /** Human checkpoint definitions - human decision points in automation */
+    humanCheckpoints?: HumanCheckpointDefinition[];
+}
+
 interface KnowledgeNodeInput {
     id: string;
     kind: string;
@@ -68,5 +3044,749 @@ interface ResolvedKnowledgeLayout {
 }
 declare function runKnowledgeCodegen(layout: ResolvedKnowledgeLayout): Promise<void>;
 
-export { generateKnowledgeBodies, generateKnowledgeNodes, generateKnowledgeNodesTs, readKnowledgeNodeMdx, runKnowledgeCodegen };
-export type { CodegenResult, GenerateKnowledgeNodesOptions, GenerateKnowledgeNodesResult, KnowledgeCodegenNode, KnowledgeKind, KnowledgeNodeInput, KnowledgeSearchEntry, ResolvedKnowledgeLayout };
+declare const ResourceOntologyBindingSchema = z
+  .object({
+    actions: z.array(OntologyIdSchema).optional(),
+    primaryAction: OntologyIdSchema.optional(),
+    reads: z.array(OntologyIdSchema).optional(),
+    writes: z.array(OntologyIdSchema).optional(),
+    usesCatalogs: z.array(OntologyIdSchema).optional(),
+    emits: z.array(OntologyIdSchema).optional(),
+    /**
+     * Optional typed contract binding for this resource's workflow I/O.
+     * Each ref is a `package/subpath#ExportName` string that resolves to a
+     * Zod schema in `@repo/elevasis-core` (or the consumer's equivalent package).
+     *
+     * Absence of this field preserves all existing behavior — it is additive + optional.
+     * Tier-1 validation (schema.ts): ref-string shape only (browser-safe, no imports).
+     * Tier-2 validation (om:verify): intra-package typed-map resolution asserts ZodType.
+     */
+    contract: z
+      .object({
+        input: ContractRefSchema.optional(),
+        output: ContractRefSchema.optional()
+      })
+      .optional()
+  })
+  .superRefine((binding, ctx) => {
+    if (binding.primaryAction === undefined) return
+    if (binding.actions?.includes(binding.primaryAction)) return
+
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['primaryAction'],
+      message: 'Resource ontology primaryAction must be included in actions'
+    })
+  })
+
+declare const WorkflowResourceEntrySchema = ResourceEntryBaseSchema.extend({
+  kind: z.literal('workflow'),
+  emits: z.array(EventEmissionDescriptorSchema).optional()
+})
+
+declare const IntegrationResourceEntrySchema = ResourceEntryBaseSchema.extend({
+  kind: z.literal('integration'),
+  provider: z.string().trim().min(1).max(100)
+})
+
+declare const OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((model, ctx) => {
+  // Collect ALL system entries recursively — top-level systems plus any nested subsystems.
+  // Wave 2 canonical OM authors nested subsystems (e.g. sys → subsystems → 'lead-gen' with id
+  // 'sys.lead-gen'). Resource systemPath cross-refs must resolve against the full flattened set.
+  type SystemWithPath = { path: string; schemaPath: Array<string | number>; system: SystemEntry }
+
+  function collectAllSystems(
+    systems: Record<string, SystemEntry>,
+    prefix = '',
+    schemaPath: Array<string | number> = ['systems']
+  ): SystemWithPath[] {
+    const result: SystemWithPath[] = []
+    for (const [key, system] of Object.entries(systems)) {
+      const path = prefix ? `${prefix}.${key}` : key
+      const currentSchemaPath = [...schemaPath, key]
+      result.push({ path, schemaPath: currentSchemaPath, system })
+      const childSystems = system.systems ?? system.subsystems
+      if (childSystems !== undefined) {
+        result.push(
+          ...collectAllSystems(childSystems, path, [
+            ...currentSchemaPath,
+            system.systems !== undefined ? 'systems' : 'subsystems'
+          ])
+        )
+      }
+    }
+    return result
+  }
+
+  const allSystems = collectAllSystems(model.systems)
+  const systemsById = new Map<string, SystemEntry>()
+  for (const { path, system } of allSystems) {
+    systemsById.set(path, system)
+    systemsById.set(system.id, system)
+  }
+
+  const systemIdsByEffectivePath = new Map<string, string>()
+  allSystems.forEach(({ path, schemaPath, system }) => {
+    if (system.parentSystemId !== undefined && !systemsById.has(system.parentSystemId)) {
+      addIssue(
+        ctx,
+        [...schemaPath, 'parentSystemId'],
+        `System "${system.id}" references unknown parent "${system.parentSystemId}"`
+      )
+    }
+
+    const hasChildren =
+      Object.keys(system.systems ?? system.subsystems ?? {}).length > 0 ||
+      allSystems.some(
+        (candidate) => candidate.path.startsWith(`${path}.`) && !candidate.path.slice(path.length + 1).includes('.')
+      )
+    const contributesRoutePath = system.ui?.path !== undefined || system.path !== undefined || !hasChildren
+    if (contributesRoutePath) {
+      const effectivePath = system.ui?.path ?? system.path ?? defaultSystemPathFor(path)
+      const existingSystemId = systemIdsByEffectivePath.get(effectivePath)
+      if (existingSystemId !== undefined) {
+        addIssue(
+          ctx,
+          [...schemaPath, system.ui?.path !== undefined ? 'ui' : 'path'],
+          `System "${path}" effective path "${effectivePath}" duplicates system "${existingSystemId}"`
+        )
+      } else {
+        systemIdsByEffectivePath.set(effectivePath, path)
+      }
+    }
+
+    if (hasChildren && isLifecycleEnabled(system.lifecycle, system.enabled)) {
+      const hasEnabledDescendant =
+        Object.values(system.systems ?? system.subsystems ?? {}).some((candidate) =>
+          isLifecycleEnabled(candidate.lifecycle, candidate.enabled)
+        ) ||
+        allSystems.some(
+          (candidate) =>
+            candidate.path.startsWith(`${path}.`) &&
+            !candidate.path.slice(path.length + 1).includes('.') &&
+            isLifecycleEnabled(candidate.system.lifecycle, candidate.system.enabled)
+        )
+      if (!hasEnabledDescendant) {
+        addIssue(ctx, [...schemaPath, 'lifecycle'], `System "${path}" is active but has no active descendants`)
+      }
+    }
+  })
+
+  allSystems.forEach(({ schemaPath, system }) => {
+    const visited = new Set<string>()
+    let currentParentId = system.parentSystemId
+
+    while (currentParentId !== undefined) {
+      if (currentParentId === system.id || visited.has(currentParentId)) {
+        addIssue(ctx, [...schemaPath, 'parentSystemId'], `System "${system.id}" has a parent cycle`)
+        return
+      }
+
+      visited.add(currentParentId)
+      currentParentId = systemsById.get(currentParentId)?.parentSystemId
+    }
+  })
+
+  type CollectedSidebarSurface = {
+    id: string
+    node: Extract<SidebarNode, { type: 'surface' }>
+    path: Array<string | number>
+  }
+
+  function normalizeRoutePath(path: string): string {
+    return path.length > 1 ? path.replace(/\/+$/, '') : path
+  }
+
+  const sidebarNodeIds = new Map<string, Array<string | number>>()
+  const sidebarSurfacePaths = new Map<string, string>()
+  const sidebarSurfaces: CollectedSidebarSurface[] = []
+
+  function collectSidebarNodes(nodes: Record<string, SidebarNode>, schemaPath: Array<string | number>): void {
+    Object.entries(nodes).forEach(([nodeId, node]) => {
+      const nodePath = [...schemaPath, nodeId]
+      const existingNodePath = sidebarNodeIds.get(nodeId)
+      if (existingNodePath !== undefined) {
+        addIssue(ctx, nodePath, `Sidebar node id "${nodeId}" duplicates another sidebar node`)
+      } else {
+        sidebarNodeIds.set(nodeId, nodePath)
+      }
+
+      if (node.type === 'group') {
+        collectSidebarNodes(node.children, [...nodePath, 'children'])
+        return
+      }
+
+      sidebarSurfaces.push({ id: nodeId, node, path: nodePath })
+      const normalizedPath = normalizeRoutePath(node.path)
+      const existingSurfaceId = sidebarSurfacePaths.get(normalizedPath)
+      if (existingSurfaceId !== undefined) {
+        addIssue(
+          ctx,
+          [...nodePath, 'path'],
+          `Sidebar surface path "${node.path}" duplicates surface "${existingSurfaceId}"`
+        )
+      } else {
+        sidebarSurfacePaths.set(normalizedPath, nodeId)
+      }
+
+      node.targets?.systems?.forEach((systemId, systemIndex) => {
+        if (!systemsById.has(systemId)) {
+          addIssue(
+            ctx,
+            [...nodePath, 'targets', 'systems', systemIndex],
+            `Sidebar surface "${nodeId}" references unknown system "${systemId}"`
+          )
+        }
+      })
+    })
+  }
+
+  collectSidebarNodes(model.navigation.sidebar.primary, ['navigation', 'sidebar', 'primary'])
+  collectSidebarNodes(model.navigation.sidebar.bottom, ['navigation', 'sidebar', 'bottom'])
+
+  // Offerings -> CustomerSegment cross-ref: targetSegmentIds must resolve
+  const segmentsById = new Map(Object.entries(model.customers))
+  Object.values(model.offerings).forEach((product) => {
+    product.targetSegmentIds.forEach((segmentId, segmentIndex) => {
+      if (!segmentsById.has(segmentId)) {
+        addIssue(
+          ctx,
+          ['offerings', product.id, 'targetSegmentIds', segmentIndex],
+          `Product "${product.id}" references unknown customer segment "${segmentId}"`
+        )
+      }
+    })
+
+    // Offerings -> System cross-ref: deliveryFeatureId must resolve (when present)
+    if (product.deliveryFeatureId !== undefined && !systemsById.has(product.deliveryFeatureId)) {
+      addIssue(
+        ctx,
+        ['offerings', product.id, 'deliveryFeatureId'],
+        `Product "${product.id}" references unknown delivery system "${product.deliveryFeatureId}"`
+      )
+    }
+  })
+
+  // Goals -> period-range validation: periodEnd must be strictly after periodStart
+  Object.values(model.goals).forEach((objective) => {
+    if (objective.periodEnd <= objective.periodStart) {
+      addIssue(
+        ctx,
+        ['goals', objective.id, 'periodEnd'],
+        `Goal "${objective.id}" has periodEnd "${objective.periodEnd}" which must be strictly after periodStart "${objective.periodStart}"`
+      )
+    }
+  })
+
+  const goalsById = new Map(Object.entries(model.goals))
+  // Phase 4: knowledge is now a flat Record<id, OrgKnowledgeNode> — no .nodes array
+  const knowledgeById = new Map(Object.entries(model.knowledge))
+  const actionsById = new Map(Object.entries(model.actions))
+  const entitiesById = new Map(Object.entries(model.entities))
+  const policiesById = new Map(Object.entries(model.policies))
+
+  sidebarSurfaces.forEach(({ id, node, path }) => {
+    node.targets?.entities?.forEach((entityId, entityIndex) => {
+      if (!entitiesById.has(entityId)) {
+        addIssue(
+          ctx,
+          [...path, 'targets', 'entities', entityIndex],
+          `Sidebar surface "${id}" references unknown entity "${entityId}"`
+        )
+      }
+    })
+
+    node.targets?.actions?.forEach((actionId, actionIndex) => {
+      if (!actionsById.has(actionId)) {
+        addIssue(
+          ctx,
+          [...path, 'targets', 'actions', actionIndex],
+          `Sidebar surface "${id}" references unknown action "${actionId}"`
+        )
+      }
+    })
+  })
+
+  Object.values(model.entities).forEach((entity) => {
+    if (!systemsById.has(entity.ownedBySystemId)) {
+      addIssue(
+        ctx,
+        ['entities', entity.id, 'ownedBySystemId'],
+        `Entity "${entity.id}" references unknown ownedBySystemId "${entity.ownedBySystemId}"`
+      )
+    }
+
+    entity.links?.forEach((link, linkIndex) => {
+      if (!entitiesById.has(link.toEntity)) {
+        addIssue(
+          ctx,
+          ['entities', entity.id, 'links', linkIndex, 'toEntity'],
+          `Entity "${entity.id}" links to unknown entity "${link.toEntity}"`
+        )
+      }
+    })
+  })
+
+  // Roles -> reportsToId cross-ref: each reportsToId must resolve to another role in the same collection
+  const rolesById = new Map(Object.entries(model.roles))
+  Object.values(model.roles).forEach((role) => {
+    if (role.reportsToId !== undefined && !rolesById.has(role.reportsToId)) {
+      addIssue(
+        ctx,
+        ['roles', role.id, 'reportsToId'],
+        `Role "${role.id}" references unknown reportsToId "${role.reportsToId}"`
+      )
+    }
+  })
+
+  Object.values(model.roles).forEach((role) => {
+    const visited = new Set<string>()
+    let currentReportsToId = role.reportsToId
+
+    while (currentReportsToId !== undefined) {
+      if (currentReportsToId === role.id || visited.has(currentReportsToId)) {
+        addIssue(ctx, ['roles', role.id, 'reportsToId'], `Role "${role.id}" has a reportsToId cycle`)
+        return
+      }
+
+      visited.add(currentReportsToId)
+      currentReportsToId = rolesById.get(currentReportsToId)?.reportsToId
+    }
+  })
+
+  Object.values(model.roles).forEach((role) => {
+    role.responsibleFor?.forEach((systemId, systemIndex) => {
+      if (!systemsById.has(systemId)) {
+        addIssue(
+          ctx,
+          ['roles', role.id, 'responsibleFor', systemIndex],
+          `Role "${role.id}" references unknown responsibleFor system "${systemId}"`
+        )
+      }
+    })
+  })
+
+  allSystems.forEach(({ schemaPath, system }) => {
+    if (system.responsibleRoleId !== undefined && !rolesById.has(system.responsibleRoleId)) {
+      addIssue(
+        ctx,
+        [...schemaPath, 'responsibleRoleId'],
+        `System "${system.id}" references unknown responsibleRoleId "${system.responsibleRoleId}"`
+      )
+    }
+
+    system.governedByKnowledge?.forEach((nodeId, nodeIndex) => {
+      if (!knowledgeById.has(nodeId)) {
+        addIssue(
+          ctx,
+          [...schemaPath, 'governedByKnowledge', nodeIndex],
+          `System "${system.id}" references unknown knowledge node "${nodeId}"`
+        )
+      }
+    })
+
+    system.drivesGoals?.forEach((goalId, goalIndex) => {
+      if (!goalsById.has(goalId)) {
+        addIssue(
+          ctx,
+          [...schemaPath, 'drivesGoals', goalIndex],
+          `System "${system.id}" references unknown goal "${goalId}"`
+        )
+      }
+    })
+
+    system.actions?.forEach((actionRef, actionIndex) => {
+      if (!actionsById.has(actionRef.actionId)) {
+        addIssue(
+          ctx,
+          [...schemaPath, 'actions', actionIndex, 'actionId'],
+          `System "${system.id}" references unknown action "${actionRef.actionId}"`
+        )
+      }
+    })
+
+    system.policies?.forEach((policyId, policyIndex) => {
+      if (!policiesById.has(policyId)) {
+        addIssue(
+          ctx,
+          [...schemaPath, 'policies', policyIndex],
+          `System "${system.id}" references unknown policy "${policyId}"`
+        )
+      }
+    })
+  })
+
+  Object.values(model.actions).forEach((action) => {
+    action.affects?.forEach((entityId, entityIndex) => {
+      if (!entitiesById.has(entityId)) {
+        addIssue(
+          ctx,
+          ['actions', action.id, 'affects', entityIndex],
+          `Action "${action.id}" affects unknown entity "${entityId}"`
+        )
+      }
+    })
+  })
+
+  // Phase 4: sales / prospecting / projects compound-domain entity cross-ref checks removed.
+  // Those entity bindings now live in System.ontology catalog scopes.
+
+  const resourcesById = new Map(Object.entries(model.resources))
+  sidebarSurfaces.forEach(({ id, node, path }) => {
+    node.targets?.resources?.forEach((resourceId, resourceIndex) => {
+      if (!resourcesById.has(resourceId)) {
+        addIssue(
+          ctx,
+          [...path, 'targets', 'resources', resourceIndex],
+          `Sidebar surface "${id}" references unknown resource "${resourceId}"`
+        )
+      }
+    })
+  })
+  const actionIds = new Set(Object.keys(model.actions))
+  const offeringsById = new Map(Object.entries(model.offerings))
+  const ontologyCompilation = compileOrganizationOntology(model)
+  const stageIds = new Set<string>()
+  for (const catalog of Object.values(ontologyCompilation.ontology.catalogTypes)) {
+    if (catalog.kind !== 'stage') continue
+    for (const stageId of Object.keys(catalog.entries ?? {})) {
+      stageIds.add(stageId)
+    }
+  }
+  const ontologyIndexByKind = {
+    object: ontologyCompilation.ontology.objectTypes,
+    link: ontologyCompilation.ontology.linkTypes,
+    action: ontologyCompilation.ontology.actionTypes,
+    catalog: ontologyCompilation.ontology.catalogTypes,
+    event: ontologyCompilation.ontology.eventTypes,
+    interface: ontologyCompilation.ontology.interfaceTypes,
+    'value-type': ontologyCompilation.ontology.valueTypes,
+    property: ontologyCompilation.ontology.sharedProperties,
+    group: ontologyCompilation.ontology.groups,
+    surface: ontologyCompilation.ontology.surfaces
+  } satisfies Record<OntologyKind, Record<string, unknown>>
+  const ontologyIds = new Set(Object.values(ontologyIndexByKind).flatMap((index) => Object.keys(index)))
+
+  function topologyTargetExists(ref: OmTopologyNodeRef): boolean {
+    if (ref.kind === 'system') return systemsById.has(ref.id)
+    if (ref.kind === 'resource') return resourcesById.has(ref.id)
+    if (ref.kind === 'ontology') return ontologyIds.has(ref.id)
+    if (ref.kind === 'policy') return policiesById.has(ref.id)
+    if (ref.kind === 'role') return rolesById.has(ref.id)
+
+    // Trigger, human checkpoint, and external resource refs are projected
+    // topology nodes during the bridge period; their owning runtime indexes are
+    // validated by deployment projection in later waves.
+    return true
+  }
+
+  Object.entries(model.topology.relationships).forEach(([relationshipId, relationship]) => {
+    ;(['from', 'to'] as const).forEach((side) => {
+      const ref = relationship[side]
+      if (topologyTargetExists(ref)) return
+
+      addIssue(
+        ctx,
+        ['topology', 'relationships', relationshipId, side],
+        `Topology relationship "${relationshipId}" ${side} references unknown ${ref.kind} "${ref.id}"`
+      )
+    })
+  })
+
+  const ontologyReferenceKeyKinds = {
+    valueType: 'value-type',
+    catalogType: 'catalog',
+    objectType: 'object',
+    eventType: 'event',
+    actionType: 'action',
+    linkType: 'link',
+    interfaceType: 'interface',
+    propertyType: 'property',
+    groupType: 'group',
+    surfaceType: 'surface',
+    stepCatalog: 'catalog'
+  } satisfies Record<string, OntologyKind>
+
+  function validateKnownOntologyReferences(
+    ownerId: string,
+    value: unknown,
+    path: Array<string | number>,
+    seen = new WeakSet<object>()
+  ): void {
+    if (Array.isArray(value)) {
+      value.forEach((entry, index) => validateKnownOntologyReferences(ownerId, entry, [...path, index], seen))
+      return
+    }
+
+    if (!isRecord(value)) return
+    if (seen.has(value)) return
+    seen.add(value)
+
+    Object.entries(value).forEach(([key, entry]) => {
+      const expectedKind = ontologyReferenceKeyKinds[key as keyof typeof ontologyReferenceKeyKinds]
+      if (expectedKind !== undefined) {
+        if (typeof entry !== 'string') {
+          addIssue(ctx, [...path, key], `Ontology record "${ownerId}" ${key} must be an ontology ID string`)
+        } else if (ontologyIndexByKind[expectedKind][entry] === undefined) {
+          addIssue(
+            ctx,
+            [...path, key],
+            `Ontology record "${ownerId}" ${key} references unknown ${expectedKind} ontology ID "${entry}"`
+          )
+        }
+      }
+
+      validateKnownOntologyReferences(ownerId, entry, [...path, key], seen)
+    })
+  }
+
+  for (const { id, record } of listResolvedOntologyRecords(ontologyCompilation.ontology)) {
+    validateKnownOntologyReferences(id, record, record.origin.path)
+  }
+
+  Object.values(model.policies).forEach((policy) => {
+    policy.appliesTo.systemIds.forEach((systemId, systemIndex) => {
+      if (!systemsById.has(systemId)) {
+        addIssue(
+          ctx,
+          ['policies', policy.id, 'appliesTo', 'systemIds', systemIndex],
+          `Policy "${policy.id}" applies to unknown system "${systemId}"`
+        )
+      }
+    })
+
+    policy.appliesTo.actionIds.forEach((actionId, actionIndex) => {
+      if (!actionsById.has(actionId)) {
+        addIssue(
+          ctx,
+          ['policies', policy.id, 'appliesTo', 'actionIds', actionIndex],
+          `Policy "${policy.id}" applies to unknown action "${actionId}"`
+        )
+      }
+    })
+
+    policy.actions.forEach((action, actionIndex) => {
+      if (action.kind === 'invoke-action' && !actionsById.has(action.actionId)) {
+        addIssue(
+          ctx,
+          ['policies', policy.id, 'actions', actionIndex, 'actionId'],
+          `Policy "${policy.id}" invokes unknown action "${action.actionId}"`
+        )
+      }
+      if (
+        (action.kind === 'notify-role' || action.kind === 'require-approval') &&
+        action.roleId !== undefined &&
+        !rolesById.has(action.roleId)
+      ) {
+        addIssue(
+          ctx,
+          ['policies', policy.id, 'actions', actionIndex, 'roleId'],
+          `Policy "${policy.id}" references unknown role "${action.roleId}"`
+        )
+      }
+    })
+
+    if (policy.trigger.kind === 'action-invocation' && !actionsById.has(policy.trigger.actionId)) {
+      addIssue(
+        ctx,
+        ['policies', policy.id, 'trigger', 'actionId'],
+        `Policy "${policy.id}" references unknown trigger action "${policy.trigger.actionId}"`
+      )
+    }
+  })
+
+  function knowledgeTargetExists(kind: string, id: string): boolean {
+    if (kind === 'system') return systemsById.has(id)
+    if (kind === 'resource') return resourcesById.has(id)
+    if (kind === 'knowledge') return knowledgeById.has(id)
+    if (kind === 'stage') return stageIds.has(id)
+    if (kind === 'action') return actionIds.has(id)
+    if (kind === 'role') return rolesById.has(id)
+    if (kind === 'goal') return goalsById.has(id)
+    if (kind === 'customer-segment') return segmentsById.has(id)
+    if (kind === 'offering') return offeringsById.has(id)
+    if (kind === 'ontology') return ontologyIds.has(id)
+    return false
+  }
+
+  // Phase 4: model.knowledge is now Record<id, OrgKnowledgeNode> — iterate Object.values
+  Object.entries(model.knowledge).forEach(([nodeId, node]) => {
+    node.links.forEach((link, linkIndex) => {
+      if (!knowledgeTargetExists(link.target.kind, link.target.id)) {
+        addIssue(
+          ctx,
+          ['knowledge', nodeId, 'links', linkIndex, 'target'],
+          `Knowledge node "${node.id}" references unknown ${link.target.kind} target "${link.target.id}"`
+        )
+      }
+
+      if (!isKnowledgeKindCompatibleWithTarget(node.kind, link.target.kind)) {
+        addIssue(
+          ctx,
+          ['knowledge', nodeId, 'links', linkIndex, 'target', 'kind'],
+          `Knowledge node "${node.id}" kind "${node.kind}" cannot govern ${link.target.kind} targets`
+        )
+      }
+
+      // `governedByKnowledge` is validated one-way on target nodes above. Knowledge
+      // links may be authored first and remain valid as forward references.
+    })
+  })
+
+  Object.values(model.resources).forEach((resource) => {
+    if (!systemsById.has(resource.systemPath)) {
+      addIssue(
+        ctx,
+        ['resources', resource.id, 'systemPath'],
+        `Resource "${resource.id}" references unknown system path "${resource.systemPath}"`
+      )
+    }
+
+    if (resource.ownerRoleId !== undefined && !rolesById.has(resource.ownerRoleId)) {
+      addIssue(
+        ctx,
+        ['resources', resource.id, 'ownerRoleId'],
+        `Resource "${resource.id}" references unknown ownerRoleId "${resource.ownerRoleId}"`
+      )
+    }
+
+    if (resource.kind === 'agent' && resource.actsAsRoleId !== undefined && !rolesById.has(resource.actsAsRoleId)) {
+      addIssue(
+        ctx,
+        ['resources', resource.id, 'actsAsRoleId'],
+        `Agent resource "${resource.id}" references unknown actsAsRoleId "${resource.actsAsRoleId}"`
+      )
+    }
+  })
+
+  function validateResourceOntologyBinding(
+    resourceId: string,
+    bindingKey: 'actions' | 'primaryAction' | 'reads' | 'writes' | 'usesCatalogs' | 'emits',
+    expectedKind: OntologyKind,
+    ids: string[] | string | undefined
+  ): void {
+    const ontologyIds = ids === undefined ? [] : Array.isArray(ids) ? ids : [ids]
+
+    ontologyIds.forEach((ontologyId, ontologyIndex) => {
+      if (ontologyIndexByKind[expectedKind][ontologyId] === undefined) {
+        addIssue(
+          ctx,
+          ['resources', resourceId, 'ontology', bindingKey, ...(Array.isArray(ids) ? [ontologyIndex] : [])],
+          `Resource "${resourceId}" ontology binding "${bindingKey}" references unknown ${expectedKind} ontology ID "${ontologyId}"`
+        )
+      }
+    })
+  }
+
+  Object.values(model.resources).forEach((resource) => {
+    const binding = resource.ontology
+    if (binding === undefined) return
+
+    validateResourceOntologyBinding(resource.id, 'actions', 'action', binding.actions)
+    validateResourceOntologyBinding(resource.id, 'primaryAction', 'action', binding.primaryAction)
+    validateResourceOntologyBinding(resource.id, 'reads', 'object', binding.reads)
+    validateResourceOntologyBinding(resource.id, 'writes', 'object', binding.writes)
+    validateResourceOntologyBinding(resource.id, 'usesCatalogs', 'catalog', binding.usesCatalogs)
+    validateResourceOntologyBinding(resource.id, 'emits', 'event', binding.emits)
+
+    // Tier-1: validate contract ref SHAPE only — no module resolution (browser-safe).
+    // Tier-2 intra-package resolution runs in om:verify (packages/cli/src/knowledge/verify.ts).
+    if (binding.contract !== undefined) {
+      const contractEntries = [
+        ['input', binding.contract.input],
+        ['output', binding.contract.output]
+      ] as const
+      for (const [side, ref] of contractEntries) {
+        if (ref === undefined) continue
+        const result = ContractRefSchema.safeParse(ref)
+        if (!result.success) {
+          addIssue(
+            ctx,
+            ['resources', resource.id, 'ontology', 'contract', side],
+            `Resource "${resource.id}" contract.${side} "${ref}" is not a valid ContractRef (expected "package/subpath#ExportName")`
+          )
+        }
+      }
+    }
+  })
+
+  Object.values(model.roles).forEach((role) => {
+    if (role.heldBy === undefined) return
+
+    asRoleHolderArray(role.heldBy).forEach((holder, holderIndex) => {
+      if (holder.kind !== 'agent') return
+
+      const resource = resourcesById.get(holder.agentId)
+      if (resource === undefined) {
+        addIssue(
+          ctx,
+          ['roles', role.id, 'heldBy', Array.isArray(role.heldBy) ? holderIndex : 'agentId'],
+          `Role "${role.id}" references unknown agent holder resource "${holder.agentId}"`
+        )
+        return
+      }
+
+      if (resource.kind !== 'agent') {
+        addIssue(
+          ctx,
+          ['roles', role.id, 'heldBy', Array.isArray(role.heldBy) ? holderIndex : 'agentId'],
+          `Role "${role.id}" agent holder "${holder.agentId}" must reference an agent resource`
+        )
+      }
+    })
+  })
+
+  // Phase 4: model.knowledge is now Record<id, OrgKnowledgeNode>
+  Object.entries(model.knowledge).forEach(([nodeId, node]) => {
+    node.ownerIds.forEach((roleId, ownerIndex) => {
+      if (!rolesById.has(roleId)) {
+        addIssue(
+          ctx,
+          ['knowledge', nodeId, 'ownerIds', ownerIndex],
+          `Knowledge node "${node.id}" references unknown owner role "${roleId}"`
+        )
+      }
+    })
+  })
+
+  for (const diagnostic of ontologyCompilation.diagnostics) {
+    addIssue(ctx, diagnostic.path, diagnostic.message)
+  }
+})
+
+type OrganizationModel = z.infer<typeof OrganizationModelSchema>
+type OrganizationModelResourceOntologyBinding = z.infer<typeof ResourceOntologyBindingSchema>
+type OrganizationModelWorkflowResourceEntry = z.infer<typeof WorkflowResourceEntrySchema>
+type OrganizationModelIntegrationResourceEntry = z.infer<typeof IntegrationResourceEntrySchema>
+
+type ResourceOntologyBindingResolver = (resourceId: string) => OrganizationModelResourceOntologyBinding | undefined;
+type WorkflowResourceDescriptorResolver = (resourceId: string) => OrganizationModelWorkflowResourceEntry;
+type IntegrationResourceDescriptorResolver = (resourceId: string) => OrganizationModelIntegrationResourceEntry;
+interface ProjectDeploymentSpecOptions {
+    version: string;
+    organizationModel: OrganizationModel;
+    workflows: WorkflowDefinition[];
+    integrations?: IntegrationDefinition[];
+    agents?: DeploymentSpec['agents'];
+    triggers?: DeploymentSpec['triggers'];
+    externalResources?: DeploymentSpec['externalResources'];
+    humanCheckpoints?: DeploymentSpec['humanCheckpoints'];
+    getWorkflowResourceDescriptor: WorkflowResourceDescriptorResolver;
+    getIntegrationResourceDescriptor: IntegrationResourceDescriptorResolver;
+    getResourceOntologyBinding?: ResourceOntologyBindingResolver;
+}
+declare function toSdkResourceDescriptor<TResource extends {
+    id: string;
+    systemPath: string;
+}>(resource: TResource, getResourceOntologyBinding?: ResourceOntologyBindingResolver): TResource & Partial<OrganizationModelResourceOntologyBinding> & {
+    systemId: string;
+};
+declare function withPlatformResourceDescriptor(workflow: WorkflowDefinition, getWorkflowResourceDescriptor: WorkflowResourceDescriptorResolver, getResourceOntologyBinding?: ResourceOntologyBindingResolver): WorkflowDefinition;
+declare function withPlatformResourceDescriptors(workflows: WorkflowDefinition[], getWorkflowResourceDescriptor: WorkflowResourceDescriptorResolver, getResourceOntologyBinding?: ResourceOntologyBindingResolver): WorkflowDefinition[];
+declare function withPlatformIntegrationResourceDescriptor(integration: IntegrationDefinition, getIntegrationResourceDescriptor: IntegrationResourceDescriptorResolver, getResourceOntologyBinding?: ResourceOntologyBindingResolver): IntegrationDefinition;
+declare function withPlatformIntegrationResourceDescriptors(integrations: IntegrationDefinition[], getIntegrationResourceDescriptor: IntegrationResourceDescriptorResolver, getResourceOntologyBinding?: ResourceOntologyBindingResolver): IntegrationDefinition[];
+declare function projectTopologyRelationships(model: Pick<OrganizationModel, 'resources' | 'topology'>): ResourceRelationships;
+declare function projectDeploymentSpec(options: ProjectDeploymentSpecOptions): DeploymentSpec;
+
+export { generateKnowledgeBodies, generateKnowledgeNodes, generateKnowledgeNodesTs, projectDeploymentSpec, projectTopologyRelationships, readKnowledgeNodeMdx, runKnowledgeCodegen, toSdkResourceDescriptor, withPlatformIntegrationResourceDescriptor, withPlatformIntegrationResourceDescriptors, withPlatformResourceDescriptor, withPlatformResourceDescriptors };
+export type { CodegenResult, DeploymentSpec, GenerateKnowledgeNodesOptions, GenerateKnowledgeNodesResult, IntegrationDefinition, IntegrationResourceDescriptorResolver, KnowledgeCodegenNode, KnowledgeKind, KnowledgeNodeInput, KnowledgeSearchEntry, ProjectDeploymentSpecOptions, ResolvedKnowledgeLayout, ResourceOntologyBindingResolver, ResourceRelationships, WorkflowDefinition, WorkflowResourceDescriptorResolver };