@elevasis/sdk 1.48.0 → 1.50.0

package/dist/node/index.d.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+export { AgentResourceDescriptorResolver, DeploymentSpec, IntegrationDefinition, IntegrationResourceDescriptorResolver, ProjectDeploymentSpecOptions, ResourceOntologyBindingResolver, ResourceRelationships, WorkflowDefinition, WorkflowResourceDescriptorResolver, projectDeploymentSpec, projectTopologyRelationships, toSdkResourceDescriptor, withPlatformAgentResourceDescriptor, withPlatformAgentResourceDescriptors, withPlatformIntegrationResourceDescriptor, withPlatformIntegrationResourceDescriptors, withPlatformResourceDescriptor, withPlatformResourceDescriptors } from '@elevasis/sdk';
 
 type KnowledgeKind = 'playbook' | 'strategy' | 'reference';
 interface KnowledgeCodegenNode {
@@ -37,3645 +37,6 @@ 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;
-    /**
-     * Time a unit of work and emit the single `action` event it produces.
-     *
-     * Captures `Date.now()` immediately before and after `work()`, then emits the same event
-     * `action()` would -- collapsing the repeated `startTime = Date.now(); ...work...; endTime =
-     * Date.now(); action(actionType, message, iteration, startTime, endTime, endTime - startTime)`
-     * boilerplate found at memory-write and tool-result call sites into a single call.
-     *
-     * `actionType` may be a function of the work's result for the rare call site where the emitted
-     * type itself depends on the outcome (e.g. "deleted" vs "delete of a missing key") -- most
-     * callers just pass a fixed string.
-     *
-     * **Throw behavior:** if `work` throws synchronously or its promise rejects, the error propagates
-     * to the caller UNCHANGED and NO `action` event is emitted -- there is no completed unit of work
-     * to describe, so this deliberately does not swallow the error or log a synthetic failure action.
-     * A call site that needs an error-path log keeps calling `action()` manually from its own
-     * `catch` block.
-     *
-     * @param actionType - Action type string, or a function deriving it from the result
-     * @param iteration - Current iteration number
-     * @param work - The unit of work to time (sync or async)
-     * @param message - Builds the human-readable message from the work's result
-     * @returns The value returned by `work`
-     */
-    timed<T>(actionType: string | ((result: T) => string), iteration: number, work: () => Promise<T> | T, message: (result: T) => string): Promise<T>;
-    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;
-}
-
-declare const ResourceGovernanceStatusSchema: z.ZodEnum<{
-    active: "active";
-    deprecated: "deprecated";
-    archived: "archived";
-}>;
-declare const ResourceOntologyBindingSchema: 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>;
-declare const WorkflowResourceEntrySchema: 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<{
-        active: "active";
-        deprecated: "deprecated";
-        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<{
-            entrypoint: "entrypoint";
-            handler: "handler";
-            schema: "schema";
-            test: "test";
-            docs: "docs";
-            config: "config";
-        }>;
-        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<{
-            active: "active";
-            deprecated: "deprecated";
-            draft: "draft";
-            beta: "beta";
-            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<{
-        active: "active";
-        deprecated: "deprecated";
-        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<{
-            entrypoint: "entrypoint";
-            handler: "handler";
-            schema: "schema";
-            test: "test";
-            docs: "docs";
-            config: "config";
-        }>;
-        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<{
-            active: "active";
-            deprecated: "deprecated";
-            draft: "draft";
-            beta: "beta";
-            archived: "archived";
-        }>>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
-declare const IntegrationResourceEntrySchema: 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<{
-        active: "active";
-        deprecated: "deprecated";
-        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<{
-            entrypoint: "entrypoint";
-            handler: "handler";
-            schema: "schema";
-            test: "test";
-            docs: "docs";
-            config: "config";
-        }>;
-        symbol: z.ZodOptional<z.ZodString>;
-        description: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-    kind: z.ZodLiteral<"integration">;
-    provider: z.ZodString;
-}, 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<{
-        active: "active";
-        deprecated: "deprecated";
-        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<{
-            entrypoint: "entrypoint";
-            handler: "handler";
-            schema: "schema";
-            test: "test";
-            docs: "docs";
-            config: "config";
-        }>;
-        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<{
-            active: "active";
-            deprecated: "deprecated";
-            draft: "draft";
-            beta: "beta";
-            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<{
-        active: "active";
-        deprecated: "deprecated";
-        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<{
-            entrypoint: "entrypoint";
-            handler: "handler";
-            schema: "schema";
-            test: "test";
-            docs: "docs";
-            config: "config";
-        }>;
-        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<{
-            active: "active";
-            deprecated: "deprecated";
-            draft: "draft";
-            beta: "beta";
-            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<{
-        active: "active";
-        deprecated: "deprecated";
-        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<{
-            entrypoint: "entrypoint";
-            handler: "handler";
-            schema: "schema";
-            test: "test";
-            docs: "docs";
-            config: "config";
-        }>;
-        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<{
-        active: "active";
-        deprecated: "deprecated";
-        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<{
-            entrypoint: "entrypoint";
-            handler: "handler";
-            schema: "schema";
-            test: "test";
-            docs: "docs";
-            config: "config";
-        }>;
-        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>;
-type AgentResourceEntry = z.infer<typeof AgentResourceEntrySchema>;
-type ResourceEntry = z.infer<typeof ResourceEntrySchema>;
-
-/**
- * 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' | 'error';
-/**
- * Who authored an entry's content.
- *
- * This is what lets the assembled prompt tell framework-authored text apart from text that
- * originated outside the trust boundary. `'framework'` content is ours; the other three are not
- * and are rendered inside the JSON data envelope (see `MemoryManager.toContextParts`).
- */
-type MemoryEntrySource = 'framework' | 'user' | 'tool' | 'model';
-/**
- * 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;
-    /**
-     * Provenance. **Optional on purpose** — `undefined` means unknown, which is what every
-     * pre-existing snapshot and every not-yet-redeployed tenant bundle produces. Read sites MUST
-     * test `== null`, never `=== undefined`: the `inTurnScope` predicate in `manager.ts` is the
-     * cautionary precedent, where a `=== undefined` check silently dropped every `null`-stamped
-     * entry. `isMemoryEntry` is deliberately NOT tightened to require this field; doing so would
-     * make every stored snapshot fail validation, and `restoreSessionMemory` fails open by
-     * starting the agent with empty memory rather than throwing.
-     */
-    source?: MemoryEntrySource;
-    /**
-     * Which tool produced this entry. Set on `tool-result` entries so the model can tell N parallel
-     * results apart -- the framework instructs batching independent tool calls in one iteration, and
-     * an anonymous result is unattributable the moment two land in the same iteration. `addToolError`
-     * already carries this (folded into its `content` JSON); this is the same fact for the success
-     * path, carried as a real field instead of prose the caller has to parse back out.
-     */
-    toolName?: string;
-    /**
-     * Present when `truncateContent` cut this entry's `content` to fit its token budget. A sibling
-     * field, never text appended into `content` -- the notice used to be spliced into the string
-     * itself, which could (and did) land inside a JSON string literal `truncateContent` had just cut
-     * open, breaking `JSON.parse` on the far end. Absent means never truncated.
-     */
-    truncated?: {
-        omittedTokens: number;
-    };
-    /**
-     * Prompt-injection warning types found in `content`, screened once here -- when the entry is
-     * written -- instead of by re-scanning the whole accumulated envelope on every iteration it gets
-     * re-sent for (`screenRequest`'s `data-envelope` slot used to do exactly that). Empty array means
-     * screened and clean; `undefined` means never screened (entries that bypass `addToHistory`/`set`,
-     * or pre-existing snapshots from before this field existed).
-     */
-    warnings?: string[];
-}
-/**
- * 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;
-    sessionMemoryTokens: number;
-    sessionMemoryTokenLimit: number;
-    /**
-     * History tokens as a percentage of `historyBudget` — history ALONE, not history plus session
-     * memory. It previously reported the combined total under this name, so session memory growth
-     * read as history pressure and triggered history compaction that could not relieve it.
-     */
-    historyPercent: number;
-    /**
-     * Tokens the history entries **in scope for the requested turn** occupy — the same set
-     * `toContextParts` puts in the envelope. Equal to `storedHistoryTokens` when `getStatus` is
-     * called without a turn.
-     *
-     * This is the number the model is shown, and it is scoped because the model is handed a scoped
-     * set. Counting the whole cross-turn array here meant the framing quoted the size of a store
-     * while the envelope beside it carried one turn's worth of it.
-     */
-    historyTokens: number;
-    /**
-     * Tokens the **entire** history array occupies, across every turn the session snapshot restored.
-     *
-     * This is what compaction measures, because compaction trims that array. Scoping it to a turn
-     * would let the store grow without bound whenever the current turn happened to be small.
-     */
-    storedHistoryTokens: number;
-    /** `storedHistoryTokens` as a percentage of `historyBudget`. The auto-compaction trigger. */
-    storedHistoryPercent: number;
-    historyBudget: number;
-}
-
-/**
- * Types for the schema compiler. `compile.ts` walks a `JsonSchema` once, driven entirely by a
- * `ProviderDialect`, and every server adapter compiles through it.
- */
-/**
- * What happened to `strict` on a request, recorded per call rather than inferred.
- *
- * `applied` and `notAttempted` are the two states that a refusal-only field cannot tell apart --
- * both leave `strictRefusalReasons` empty. Recording the verdict positively is what makes "was
- * this agent's output actually enforced?" answerable from an `ai_calls` row.
- */
-type StrictStatus = 'applied' | 'refused' | 'compileRejected' | 'notAttempted';
-/**
- * A JSON Schema node, typed enough to be useful without pretending to validate the spec.
- *
- * The compiler has to accept schemas that arrive OUTSIDE the strict subset (that is the whole
- * point of a dialect that can refuse or rewrite them) as well as the `$ref`/`$defs`/`const`/
- * `$schema` shapes the strict subset has no vocabulary for at all. The index signature exists
- * because tenant schemas carry keywords (`minLength`, `pattern`, `minimum`, ...) this compiler
- * drops or refuses on, and they still need somewhere to type-check while they pass through
- * `Object.entries`.
- */
-interface JsonSchema {
-    type?: string | string[];
-    /**
-     * The value is `JsonSchema | undefined`, not `JsonSchema`, because a property really can be
-     * declared with nothing describing it. `buildIterationResponseSchema` emits one per tool as
-     * `input: tool.inputSchema`, and `ToolDefinition.inputSchema` is typed `unknown` -- a tool
-     * deployed without one puts `undefined` under a key that exists.
-     *
-     * Both readers already handle it: `compileSchema` passes each value through `convertNode`, which
-     * takes `unknown`, and `collectErrors` opens with `if (!schema || typeof schema !== 'object')`
-     * above a comment naming this exact case. Declaring the value non-optional only hid that they
-     * were right to.
-     */
-    properties?: Record<string, JsonSchema | undefined>;
-    items?: JsonSchema;
-    anyOf?: JsonSchema[];
-    oneOf?: JsonSchema[];
-    allOf?: JsonSchema[];
-    required?: string[];
-    additionalProperties?: boolean | JsonSchema;
-    minItems?: number;
-    maxItems?: number;
-    format?: string;
-    enum?: unknown[];
-    const?: unknown;
-    description?: string;
-    default?: unknown;
-    $ref?: string;
-    $defs?: Record<string, JsonSchema>;
-    definitions?: Record<string, JsonSchema>;
-    $schema?: string;
-    $id?: string;
-    $anchor?: string;
-    /**
-     * OpenAPI's nullability spelling, which is not JSON Schema's. It is declared because
-     * `response-schema-validator.ts` READS it (`schemaPermitsNull`) -- Google's schema dialect is
-     * OpenAPI-derived, so a schema that reaches the validator can carry it. No dialect in `compile.ts`
-     * writes or rewrites it; the canonical spelling this compiler emits is `type: ['x', 'null']`.
-     */
-    nullable?: boolean;
-    [key: string]: unknown;
-}
-
-/**
- * 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;
-    /**
-     * Marks this message as the end of a byte-stable prefix worth an Anthropic cache breakpoint,
-     * beyond the one the system prompt already gets. Anthropic's rule is "everything up to and
-     * including the marked block is cached", so this only ever needs to sit on ONE message -- the
-     * last one before content that changes.
-     *
-     * `buildAgentMessages` sets it on the last replayed prior-turn message: conversation history is
-     * fixed for the whole turn (only the framing/envelope after it grow per iteration), so it is the
-     * only part of a session agent's messages, besides the system prompt, that is ever byte-identical
-     * call to call. A hint rather than a mechanism deliberately -- an adapter that does not read it
-     * (OpenAI, OpenRouter, any test stub) just ignores the extra property; only the Anthropic adapter
-     * turns it into a wire `cache_control` block.
-     */
-    cacheBreakpoint?: boolean;
-    /**
-     * Prompt-injection warning types already found in this message's content, when the caller has
-     * already screened it and wants `screenRequest` to use that verdict instead of re-scanning.
-     *
-     * Set only on the data-envelope message by `buildAgentMessages`, sourced from
-     * `MemoryContextParts.envelopeWarnings` -- itself an aggregate of `MemoryEntry.warnings` stamped
-     * once per fragment when it entered memory. `undefined` means "not pre-screened"; `screenRequest`
-     * falls back to scanning the content directly, which is what every other message role/slot still
-     * does and what a hand-built message (tests, other callers) gets by default.
-     */
-    envelopeWarnings?: string[];
-}
-/**
- * Generic LLM generation request
- * Usable by agents, workflows, tools, etc.
- */
-interface LLMGenerateRequest {
-    messages: LLMMessage[];
-    /**
-     * JSON Schema for structured output. Omit it for an unstructured call.
-     *
-     * Absence is what turns validation off: `runGeneratePipeline` skips `validateResponseSchema`
-     * entirely when this is missing, whatever `validationSchema` holds.
-     *
-     * This was declared `responseSchema: unknown` -- required, and typed as nothing. `unknown` admits
-     * `undefined`, so "required" only ever forced the KEY to be written, and `createLLMCallTool`
-     * writes it as `undefined` on every call where the model supplies no usable schema. There was no
-     * type error available for that, and three separate layers re-derived the same nullability at
-     * runtime under three different rules -- truthiness in the pipeline, an object check in the
-     * validator, and a `'type'`-key check in the tool. Because the pipeline's was truthiness, `null`,
-     * `0` and `''` all quietly meant "no structured output" while the type insisted a schema was
-     * mandatory. Optional-and-typed is what those three were compensating for.
-     */
-    responseSchema?: JsonSchema;
-    /** 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;
-    /**
-     * Caller-supplied acceptance step (Wave D2b / decision A15). A pipeline-aware adapter
-     * (`UniversalLLMAdapter`, via `runGeneratePipeline`) runs this once per retry attempt, right
-     * after the response has passed `responseSchema` validation. Throw to reject the attempt --
-     * rejection is classified exactly like a thrown `LLMResponseParseError` from
-     * `validateResponseSchema`: retryable, no circuit-breaker verdict, and the attempt is recorded as
-     * a failure (`ai_calls` validation-failure row) rather than a clean success. Returning normally
-     * (including `undefined`) accepts the response.
-     *
-     * Optional, and a HINT rather than a dependency -- an adapter that does not read this field
-     * simply ignores it, so a caller must not assume it ran:
-     * - A bare test-stub `LLMAdapter` (many exist in this codebase) does not invoke it.
-     * - `PostMessageLLMAdapter` (`packages/sdk/src/worker/llm-adapter.ts`) cannot forward it at all --
-     *   functions cannot be structured-cloned across the worker `postMessage` boundary, so its
-     *   `params` object is built from an explicit allowlist that omits `accept`. The field is dropped
-     *   before `postMessage` is ever called (no `DataCloneError`), and the parent-side handler that
-     *   fulfils the call (`tool-dispatcher.ts`'s `case 'llm'`) rebuilds its own `LLMGenerateRequest`
-     *   from that allowlisted payload, so there is nothing to forward even in principle. This is the
-     *   path every deployed org-bundle agent and the `command-center-assistant` static module run
-     *   through today -- `accept` does not reach their retry loop.
-     *
-     * This is not a validation mechanism on its own: it does not decide whether output is acceptable,
-     * the caller's function does, by throwing or not. `callLLMForAgentIteration`
-     * (`execution/engine/agent/reasoning/adapters/agent-adapter-helpers.ts`) passes its Zod parse of
-     * the iteration response as this field, so a malformed-but-schema-valid iteration is re-sampled
-     * inside the retry loop instead of losing the turn -- for the in-process callers that can see it.
-     */
-    accept?: (output: unknown) => void;
-    /**
-     * The schema the RESPONSE is validated against, when that must differ from the schema the
-     * provider was asked to sample against. Defaults to `responseSchema` when omitted.
-     *
-     * **This does not affect what is sent to the provider.** `responseSchema` remains the only schema
-     * an adapter puts on the wire; this one is read solely by `runGeneratePipeline`'s validation step.
-     * Whether validation happens at all is still decided by `responseSchema` -- a request with no
-     * `responseSchema` is unstructured and stays unvalidated, whatever this field holds.
-     *
-     * A caller may legitimately ACCEPT A SUPERSET of what it ASKS FOR -- a document that validates a
-     * response more leniently than the one the provider was asked to sample against. No caller in this
-     * codebase supplies one today (agent iterations validate with a single Zod parse instead, see
-     * `agent-adapter-helpers.ts`), but the mechanism stays: `validateResponseSchema` does not descend
-     * into `anyOf`/`oneOf` regardless of which document is supplied here, so this field only ever
-     * changes which top-level/required/type keywords are checked, never which acceptance contract a
-     * union is read as.
-     *
-     * Unlike `accept` above, this is DATA. It is structured-cloneable, so it survives the worker
-     * `postMessage` boundary that drops `accept`: `PostMessageLLMAdapter` forwards it in its params
-     * allowlist and `tool-dispatcher.ts`'s `case 'llm'` puts it back on the `LLMGenerateRequest` it
-     * rebuilds parent-side. That is why a divergence expressible as a schema belongs here rather than
-     * in a callback -- deployed org-bundle agents run on the far side of that boundary.
-     */
-    validationSchema?: JsonSchema;
-}
-/**
- * Generic LLM generation response
- * `usage`, `cost`, `strictStatus` and `strictRefusalReasons` are observability fields. They are
- * **read** by `UniversalLLMAdapter` and lifted onto the `ai_calls` row; they are **not removed**.
- * The wrapper returns the base adapter's response object as-is, so a caller can observe all four.
- * Earlier revisions of this file claimed they were stripped — they never were.
- */
-interface LLMGenerateResponse<T = unknown> {
-    output: T;
-    usage?: {
-        inputTokens: number;
-        outputTokens: number;
-        totalTokens: number;
-        /**
-         * Anthropic-only: input tokens served from the prompt cache (`cache_read_input_tokens`), billed
-         * at 0.1x the base input rate. Optional so OpenAI/OpenRouter usage objects, which never report
-         * this, stay valid -- absent means "this provider doesn't report it," not "zero were read."
-         */
-        cacheReadInputTokens?: number;
-        /**
-         * Anthropic-only: input tokens written to the prompt cache this call
-         * (`cache_creation_input_tokens`), billed at 1.25x the base input rate. Same optionality
-         * rationale as `cacheReadInputTokens`.
-         */
-        cacheCreationInputTokens?: number;
-    };
-    cost?: number;
-    /**
-     * What actually happened to `strict` on the request that produced this response.
-     *
-     * - `applied` — the request carried `strict: true` and the grammar was in effect
-     * - `refused` — `compileSchema` could not express the schema, so the request went out unstrict
-     * - `compileRejected` — the schema passed `compileSchema` but the provider's grammar compiler
-     *   rejected it at request time, and the call was retried unstrict
-     * - `notAttempted` — the adapter did not send `strict` on this call
-     *
-     * This exists because `strictRefusalReasons` alone cannot answer the question. Its absence means
-     * "strict held" OR "nothing ever tried", and a prod run that recorded zero refusals while
-     * returning an array-typed field as a string is exactly the case where the difference matters.
-     *
-     * **Do not read this as "provider X never sends strict."** It describes one call, not an adapter.
-     * A previous revision of this comment enumerated OpenAI, Google and OpenRouter as adapters that
-     * never send `strict`, which was false for OpenRouter — it sends `strict: true` whenever the
-     * schema compiles, and separately reports `notAttempted`. That producer bug is still live; the
-     * fix is to make the value a return of schema compilation rather than a per-adapter literal.
-     * `MockAdapter` sets no value at all, so absence does not imply `notAttempted` either.
-     *
-     * Observability only — `UniversalLLMAdapter` lifts it onto the `ai_calls` row. It is not removed
-     * from the response.
-     */
-    strictStatus?: StrictStatus;
-    /**
-     * Why this call went out WITHOUT `strict`, on an adapter that tried to send it with one.
-     *
-     * The detail behind a `refused` / `compileRejected` `strictStatus` — the short, stable reason
-     * strings `compileSchema` computes. Read `strictStatus` to answer "was it enforced"; read this
-     * to answer "why not".
-     *
-     * Observability only — `UniversalLLMAdapter` lifts it onto the `ai_calls` row. It is not removed
-     * from the response.
-     */
-    strictRefusalReasons?: string[];
-}
-/**
- * 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>>;
-}
-
-/**
- * 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 Anthropic models (direct SDK access via @anthropic-ai/sdk)
- */
-type AnthropicModel = 'claude-opus-5' | 'claude-sonnet-5' | 'claude-haiku-4-5-20251001' | 'claude-haiku-4-5';
-/** Supported LLM models */
-type LLMModel = OpenAIModel | OpenRouterModel | 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>;
-/**
- * Anthropic model options schema
- * Currently empty - future options must be added per supported model family
- */
-declare const AnthropicOptionsSchema: z.ZodObject<{}, z.core.$strict>;
-/**
- * Infer TypeScript types from schemas
- */
-type GPT5Options = z.infer<typeof GPT5OptionsSchema>;
-type MockOptions = Record<string, never>;
-type OpenRouterOptions = z.infer<typeof OpenRouterOptionsSchema>;
-type AnthropicOptions = z.infer<typeof AnthropicOptionsSchema>;
-type ModelSpecificOptions = GPT5Options | MockOptions | OpenRouterOptions | AnthropicOptions;
-/**
- * Model configuration for LLM execution
- * Belongs in resource definition (AgentDefinition, WorkflowDefinition, etc.)
- */
-interface ModelConfig {
-    model: LLMModel;
-    provider: 'openai' | 'anthropic' | 'openrouter' | '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;
-}
-
-/**
- * Memory Manager
- * Encapsulates all memory operations with ultra-simple agent API
- * Agent provides strings, framework handles wrapping and auto-compaction
- */
-
-/**
- * The framework's own framing message and the untrusted data envelope, as separate strings.
- *
- * They are separate because the model must be able to tell them apart, and so must the input
- * sanitizer: the framing is framework-authored and trusted, the envelope is not. Concatenating
- * them — which is what this replaced — made that distinction undecidable at the adapter and left
- * the framework's own section headers inside the region scanned for delimiter injection.
- */
-interface MemoryContextParts {
-    /** Framework-authored. Memory status and a description of the envelope. Carries NO stored content. */
-    framing: string;
-    /** Every stored fragment, JSON-encoded. Untrusted. */
-    dataEnvelope: string;
-    /**
-     * Union of prompt-injection warning types already found across every fragment `dataEnvelope`
-     * actually carries this call, aggregated from verdicts stamped once when each fragment entered
-     * memory (see `MemoryEntry.warnings`) rather than by re-scanning `dataEnvelope`'s text on every
-     * iteration it gets rebuilt for. Elided fragments (see `ENVELOPE_FULL_RESULT_WINDOW`) contribute
-     * nothing here — their original content isn't what gets sent once they're stubbed.
-     *
-     * This is metadata about the envelope, not part of it: folding a detector's own finding into the
-     * model-visible JSON would hand a would-be attacker — plausibly the same person on the other end
-     * of a session conversation — direct feedback on which pattern tripped. A caller wiring this up
-     * (`screenRequest`'s `data-envelope` slot is the one that currently re-scans instead of reading
-     * this) should treat it exactly the way `screenRequest` already treats cross-turn history: it
-     * warns, but whether it blocks is that caller's decision to make, not this one's.
-     *
-     * Optional (not just possibly-empty): the fixture literals in `agent/reasoning/**` tests build
-     * `MemoryContextParts` by hand without it, and requiring it would make this signature's landing
-     * a forced edit across files this change does not otherwise touch.
-     */
-    envelopeWarnings?: string[];
-}
-/**
- * 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?;
-    /**
-     * Rolling correction for `estimateTokens`'s bias, learned from real provider usage.
-     * `undefined` until the first `recordActualUsage` call -- the cold-start state, where
-     * `estimate()` returns the raw `estimateTokens` output unscaled. See `recordActualUsage`.
-     */
-    private tokenCorrectionFactor?;
-    constructor(memory: AgentMemory, constraints?: AgentConstraints, logger?: AgentScopedLogger | undefined);
-    /**
-     * Record how far `estimateTokens` was from reality on a real provider call, and roll it into a
-     * correction applied to every estimate this instance makes from here on -- `getStatus`'s three
-     * token fields and `enforceSessionMemoryTokenLimit`'s eviction check, which is what
-     * `autoCompact`/`enforceHardLimits` actually decide compaction from (C3 / Wave M3).
-     *
-     * `estimateTokens` is `chars / 3.5` -- a constant-ratio guess with no knowledge of JSON escaping,
-     * key overhead, or real tokenizer behaviour. Every provider call already returns an EXACT count
-     * (`usage.inputTokens`) that reaches `ai_calls` and is then dropped; this is where it stops being
-     * dropped, without replacing the estimator outright -- a cold session still needs SOME number
-     * before its first real call completes, so the estimator stays the prior and this only corrects
-     * it once real data exists.
-     *
-     * `estimatedRequestTokens` must be `estimateTokens` applied to the SAME text `actualInputTokens`
-     * was billed for -- the whole assembled request (system prompt, tools, conversation history, the
-     * envelope, everything), not just what this class itself emits. `estimateTokens`'s bias is a
-     * property of the heuristic, not of which slice of the request it is pointed at, so measuring it
-     * against the full request (visible to the caller, not to this class) and applying the result to
-     * this class's own estimates (which can only ever see its own slice) is a fair trade -- one ratio,
-     * calibrated on real data, standing in for a per-segment breakdown nothing needs.
-     *
-     * Exponential moving average, not a straight replace: a single call's ratio is noisy, and a
-     * straight replace lets one outlier swing every compaction decision made afterward. Each new
-     * observation gets 30% weight, converging within a handful of calls without chasing one spike.
-     */
-    recordActualUsage(estimatedRequestTokens: number, actualInputTokens: number): void;
-    /** `estimateTokens`, scaled by the learned correction once one exists. See `recordActualUsage`. */
-    private estimate;
-    /**
-     * 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, source?: MemoryEntrySource): 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;
-    /**
-     * Evict oldest session memory entries until the pool fits its token limit.
-     *
-     * Key count and token count are different constraints: 25 short keys are fine, 25 large ones
-     * are not. Eviction is oldest-first by timestamp, matching the key-count path, and always
-     * leaves at least one entry so a single oversized key degrades to "one key" rather than to
-     * "memory silently emptied".
-     *
-     * The running total is **recomputed** from the survivors rather than decremented per entry.
-     * `getStatus` estimates the pool as a ceiling of the joined sum, and a per-entry decrement is a
-     * sum of ceilings — the larger of the two by up to one token per key. The running total therefore
-     * fell faster than the pool did, and the loop could exit reporting a fit while the very next
-     * `getStatus` still read over the limit. Recomputing makes the loop's exit condition and the
-     * number it is judged by the same expression. The pool is capped at `MAX_SESSION_MEMORY_KEYS`
-     * entries, so the extra passes are bounded and cheap.
-     */
-    private enforceSessionMemoryTokenLimit;
-    /**
-     * Get history length (for logging and introspection)
-     * @returns Number of entries in history
-     */
-    getHistoryLength(): number;
-    /**
-     * Get memory status for agent awareness
-     *
-     * @param currentTurn - Turn to scope `historyTokens` / `historyPercent` to. Omit to measure the
-     *   whole store, which is what the compaction paths want. Callers building something the model
-     *   reads should pass it, so the count describes the set the model is actually handed.
-     * @returns Memory status with token usage and key counts
-     */
-    getStatus(currentTurn?: number): MemoryStatus;
-    /**
-     * Create a memory snapshot for persistence.
-     *
-     * Stateless: every call returns a fresh `structuredClone` of the current memory, so the caller
-     * owns caching if it needs to hold onto the result across calls (see `Agent.memorySnapshot`).
-     *
-     * @returns Deep copy of current memory state
-     */
-    snapshot(): AgentMemory;
-    /**
-     * Build the framework framing and the untrusted data envelope for an LLM call.
-     *
-     * These are two separate strings because they are two different trust levels, and they used to
-     * be one. Concatenated, the framework's own `=== ... ===` section headers sat in the same string
-     * as stored tool output and user text, so the input sanitizer matched its own scaffolding on
-     * every call and nothing downstream could tell which half a match came from. Splitting them
-     * makes that distinction structural: the framing is ours, the envelope is not.
-     *
-     * The envelope is JSON, which additionally neutralizes the anchored-delimiter attack class —
-     * `JSON.stringify` escapes newlines, so a stored fragment cannot produce a line that starts
-     * with `===` no matter what it contains.
-     *
-     * The current turn's own input is deliberately NOT in either string. It travels as its own
-     * `role:'user'` message (see `buildAgentMessages`), which is the whole point: a model asked to
-     * treat "everything in this block" as data was also being handed the live question inside that
-     * block.
-     *
-     * History entries stay chronological. They used to be split into a "current iteration" slot
-     * (reverse chronological, for LLM positional bias) and an "earlier" slot -- but the LLM call
-     * always happens BEFORE `addToHistory` writes that iteration's own entries, so the
-     * current-iteration slot held nothing on any call that mattered. One chronological list replaces
-     * both.
-     *
-     * Tool results (and tool errors) older than `ENVELOPE_FULL_RESULT_WINDOW` iterations are carried
-     * as a short stub instead of their full content -- see `ENVELOPE_FULL_RESULT_WINDOW`. The STORE
-     * (`this.memory.history`) is untouched; only what this call carries is capped.
-     *
-     * @param currentIteration - Current iteration number (0 = pre-iteration)
-     * @param currentTurn - Current turn number (optional, for session context filtering)
-     */
-    toContextParts(currentIteration: number, currentTurn?: number): MemoryContextParts;
-}
-
-/**
- * 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;
-}
-
-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>>>>;
-    endpoints: 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.$strict>>;
-type OntologyScope = z.infer<typeof OntologyScopeSchema>;
-
-declare const SystemApiInterfaceSchema: z.ZodObject<{
-    lifecycle: z.ZodDefault<z.ZodEnum<{
-        active: "active";
-        deprecated: "deprecated";
-        draft: "draft";
-        archived: "archived";
-        disabled: "disabled";
-    }>>;
-    readinessProfile: z.ZodOptional<z.ZodString>;
-    resourceIds: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
-    readinessContract: z.ZodOptional<z.ZodObject<{
-        requiredObjects: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        requiredCatalogs: z.ZodArray<z.ZodString>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-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;
-    };
-    lifecycle?: 'draft' | 'beta' | 'active' | 'deprecated' | 'archived';
-    responsibleRoleId?: string;
-    governedByKnowledge?: string[];
-    actions?: {
-        actionId: string;
-        intent: 'exposes' | 'consumes';
-        invocation?: unknown;
-    }[];
-    drivesGoals?: string[];
-    apiInterface?: z.infer<typeof SystemApiInterfaceSchema>;
-    path?: string;
-    icon?: string;
-    uiPosition?: 'sidebar-primary' | 'sidebar-bottom';
-    enabled?: boolean;
-    order: number;
-    config?: Record<string, JsonValue>;
-    ontology?: OntologyScope;
-    systems?: Record<string, SystemEntry>;
-    subsystems?: Record<string, SystemEntry>;
-}
-
-declare const SurfaceTypeSchema: z.ZodEnum<{
-    dashboard: "dashboard";
-    settings: "settings";
-    graph: "graph";
-    page: "page";
-    detail: "detail";
-    list: "list";
-}>;
-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<{
-        affects: "affects";
-        actions: "actions";
-        effects: "effects";
-        links: "links";
-        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: z.ZodObject<{
-    version: z.ZodDefault<z.ZodLiteral<1>>;
-    snapshotHash: z.ZodOptional<z.ZodString>;
-    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>>;
-        clients: 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>>;
-        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;
-        };
-        clients: {
-            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;
-        };
-        knowledge: {
-            version: 1;
-            lastModified: string;
-        };
-    }, {
-        branding?: {
-            version: 1;
-            lastModified: string;
-        } | undefined;
-        identity?: {
-            version: 1;
-            lastModified: string;
-        } | undefined;
-        clients?: {
-            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;
-        knowledge?: {
-            version: 1;
-            lastModified: string;
-        } | undefined;
-    }>>;
-    branding: z.ZodDefault<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>>;
-        voice: z.ZodOptional<z.ZodString>;
-        tagline: z.ZodOptional<z.ZodString>;
-        values: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        themePresetId: z.ZodOptional<z.ZodString>;
-    }, z.core.$loose>>;
-    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>>;
-        topbar: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
-            id: z.ZodString;
-            label: z.ZodString;
-            tooltip: z.ZodOptional<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";
-                "message-plus": "message-plus";
-                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]>>;
-            order: z.ZodOptional<z.ZodNumber>;
-            enabled: z.ZodDefault<z.ZodBoolean>;
-            devOnly: z.ZodOptional<z.ZodBoolean>;
-            requiresAdmin: z.ZodOptional<z.ZodBoolean>;
-            targets: z.ZodOptional<z.ZodDefault<z.ZodObject<{
-                systems: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
-                entities: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
-                resources: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
-                actions: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
-            }, z.core.$strip>>>;
-        }, 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>;
-        organizationName: z.ZodOptional<z.ZodString>;
-        productName: z.ZodOptional<z.ZodString>;
-        shortName: z.ZodOptional<z.ZodString>;
-        description: z.ZodOptional<z.ZodString>;
-    }, z.core.$loose>>;
-    clients: z.ZodDefault<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
-        id: z.ZodString;
-        slug: z.ZodString;
-        name: z.ZodString;
-        status: z.ZodDefault<z.ZodEnum<{
-            active: "active";
-            onboarding: "onboarding";
-            paused: "paused";
-            completed: "completed";
-            churned: "churned";
-        }>>;
-        source: z.ZodOptional<z.ZodString>;
-        identity: z.ZodDefault<z.ZodObject<{
-            organizationName: z.ZodOptional<z.ZodString>;
-            shortName: z.ZodOptional<z.ZodString>;
-            clientBrief: z.ZodDefault<z.ZodString>;
-            geographicFocus: z.ZodDefault<z.ZodArray<z.ZodString>>;
-            timeZone: z.ZodDefault<z.ZodString>;
-        }, z.core.$loose>>;
-        branding: z.ZodDefault<z.ZodObject<{
-            voice: z.ZodOptional<z.ZodString>;
-            tagline: z.ZodOptional<z.ZodString>;
-            values: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        }, z.core.$loose>>;
-        workspace: z.ZodDefault<z.ZodObject<{
-            kind: z.ZodOptional<z.ZodEnum<{
-                "external-project": "external-project";
-                "internal-project": "internal-project";
-                none: "none";
-            }>>;
-            owner: z.ZodOptional<z.ZodEnum<{
-                platform: "platform";
-                client: "client";
-                developer: "developer";
-            }>>;
-            projectId: z.ZodOptional<z.ZodString>;
-            workspacePath: z.ZodOptional<z.ZodString>;
-        }, z.core.$loose>>;
-        links: z.ZodDefault<z.ZodObject<{
-            projectIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
-            primaryCompanyId: z.ZodOptional<z.ZodString>;
-            primaryContactId: z.ZodOptional<z.ZodString>;
-            sourceDealId: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        prompts: z.ZodDefault<z.ZodObject<{
-            defaultContext: z.ZodDefault<z.ZodString>;
-        }, z.core.$loose>>;
-        config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
-        customValues: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
-    }, z.core.$strict>>>>;
-    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>>>>;
-        endpoints: 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.$strict>>>;
-    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<{
-            active: "active";
-            deprecated: "deprecated";
-            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<{
-                entrypoint: "entrypoint";
-                handler: "handler";
-                schema: "schema";
-                test: "test";
-                docs: "docs";
-                config: "config";
-            }>;
-            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<{
-                active: "active";
-                deprecated: "deprecated";
-                draft: "draft";
-                beta: "beta";
-                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<{
-            active: "active";
-            deprecated: "deprecated";
-            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<{
-                entrypoint: "entrypoint";
-                handler: "handler";
-                schema: "schema";
-                test: "test";
-                docs: "docs";
-                config: "config";
-            }>;
-            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<{
-                active: "active";
-                deprecated: "deprecated";
-                draft: "draft";
-                beta: "beta";
-                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<{
-            active: "active";
-            deprecated: "deprecated";
-            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<{
-                entrypoint: "entrypoint";
-                handler: "handler";
-                schema: "schema";
-                test: "test";
-                docs: "docs";
-                config: "config";
-            }>;
-            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<{
-            active: "active";
-            deprecated: "deprecated";
-            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<{
-                entrypoint: "entrypoint";
-                handler: "handler";
-                schema: "schema";
-                test: "test";
-                docs: "docs";
-                config: "config";
-            }>;
-            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<"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<"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<{
-            active: "active";
-            deprecated: "deprecated";
-            draft: "draft";
-            beta: "beta";
-            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>>>>;
-    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";
-            "message-plus": "message-plus";
-            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";
-                    resource: "resource";
-                    action: "action";
-                    ontology: "ontology";
-                    role: "role";
-                    client: "client";
-                    stage: "stage";
-                    goal: "goal";
-                    "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" | "resource" | "action" | "ontology" | "role" | "client" | "stage" | "goal" | "customer-segment" | "offering";
-                id: string;
-            };
-            nodeId: string;
-        }, {
-            nodeId: string;
-        } | {
-            target: {
-                kind: "knowledge" | "system" | "resource" | "action" | "ontology" | "role" | "client" | "stage" | "goal" | "customer-segment" | "offering";
-                id: string;
-            };
-        }>>>>;
-        ownerIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        updatedAt: z.ZodString;
-    }, z.core.$strip>>>>;
-}, z.core.$strip>;
-
-type OrganizationModel = z.infer<typeof OrganizationModelSchema>;
-type OrganizationModelResourceOntologyBinding = z.infer<typeof ResourceOntologyBindingSchema>;
-type OrganizationModelWorkflowResourceEntry = z.infer<typeof WorkflowResourceEntrySchema>;
-type OrganizationModelAgentResourceEntry = z.infer<typeof AgentResourceEntrySchema>;
-type OrganizationModelIntegrationResourceEntry = z.infer<typeof IntegrationResourceEntrySchema>;
-
-/**
- * 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;
-}
-
-/**
- * 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;
-}
-
-/**
- * Which `role:'user'` message slot a sanitizer warning came from, derived from the request's
- * message array (no new plumbing from callers):
- * - `'memory-context'` — the framework's framing message, identified by the `=== MEMORY STATUS ===`
- *   banner. Framework-authored and trusted; it is no longer scanned at all, so this source should
- *   not appear for agent calls. Retained because stale tenant bundles still emit the old combined
- *   block, and their rows must stay readable.
- * - `'data-envelope'` — the JSON envelope carrying every stored fragment. Untrusted, and the slot
- *   where a match is genuine signal.
- * - `'input'` — the turn's own input, on its own message. Also untrusted.
- * - `'history'` — replayed prior turns. Untrusted, but already screened at their own front door,
- *   so warnings here are recorded and never block (see `screenInput`).
- */
-type InputWarningSource = 'memory-context' | 'data-envelope' | 'history' | 'input';
-/** Per-source breakdown of sanitizer warnings, so a memory-context echo is distinguishable from a genuine hit. */
-interface SourcedInputWarnings {
-    source: InputWarningSource;
-    warnings: string[];
-}
-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;
-    /**
-     * Anthropic-only: input tokens served from the prompt cache this call (`cache_read_input_tokens`),
-     * billed at 0.1x the base input rate. Already folded into `inputTokens`/`totalInputTokens` so
-     * aggregate totals reflect real usage -- present here as the raw breakdown, not additive on top.
-     */
-    cacheReadInputTokens?: number;
-    /**
-     * Anthropic-only: input tokens written to the prompt cache this call (`cache_creation_input_tokens`),
-     * billed at 1.25x the base input rate. Same folding rationale as `cacheReadInputTokens`.
-     */
-    cacheCreationInputTokens?: number;
-    /**
-     * Distinct prompt-injection pattern types detected in the request's user-role messages.
-     * Present only when the input sanitizer matched something. Non-blocking matches ride along on
-     * the successful call's row; a blocked call records a row of its own (see `inputBlocked`).
-     *
-     * Flat union across all `role:'user'` messages — unchanged shape, kept for existing readers.
-     * See `inputWarningsBySource` for the per-slot breakdown.
-     */
-    inputWarnings?: string[];
-    /**
-     * Additive breakdown of `inputWarnings` by message slot (see `InputWarningSource`). Present only
-     * when at least one source produced a warning. Existing readers that only look at the flat
-     * `inputWarnings` array are unaffected.
-     */
-    inputWarningsBySource?: SourcedInputWarnings[];
-    /**
-     * True when the sanitizer blocked the request and no provider call was made.
-     * Such a row carries zero tokens, zero cost, and zero latency — it exists so a hard,
-     * user-visible failure is observable at all. Before this, a blocked call produced no row.
-     */
-    inputBlocked?: boolean;
-    /**
-     * The validator's message when the provider responded but its output failed `responseSchema`
-     * validation (e.g. `missing required field 'nextActions'`). Present only on such a row.
-     *
-     * This is NOT the blocked-input case: the provider DID respond and tokens WERE spent, so the row
-     * carries real `inputTokens`, `outputTokens`, cost and latency. It is a paid call that produced
-     * nothing usable, and before this it produced no row at all.
-     *
-     * One row per failed attempt — the adapter retries a validation failure up to `LLM_MAX_ATTEMPTS`,
-     * so a turn that exhausts its retries records three. Reading `inputTokens` across these rows is
-     * what measures malformed-output rate against context size rather than inferring it.
-     *
-     * Existing readers that only look at the fields above are unaffected.
-     */
-    outputValidationError?: string;
-    /**
-     * The raw model output that failed validation, JSON-stringified and truncated to a bounded
-     * length. Truncation is visible in the value itself (a trailing `…[truncated: N chars total]`),
-     * never silent. Present only alongside `outputValidationError`.
-     */
-    unvalidatedOutput?: string;
-    /**
-     * What happened to `strict` structured output on this call — `applied`, `refused`,
-     * `compileRejected`, or `notAttempted`. Every server adapter sets it, so this is the field that
-     * answers "is this agent's output actually being enforced?" without reading source.
-     *
-     * It replaces an inference that turned out to be unsound. `strictRefusalReasons` alone records
-     * only refusals, so an empty row meant "strict held" OR "this adapter never tries" — and a prod
-     * run recorded zero refusals while a call returned an array-typed field as a string, which a
-     * grammar makes impossible. The absence proved nothing, because the deployed API had no way to
-     * write the field at all.
-     *
-     * Absent on rows written before this field existed; that absence is itself diagnostic (the API
-     * predates the change). Existing readers that only look at the fields above are unaffected.
-     */
-    strictStatus?: StrictStatus;
-    /**
-     * Why this call went out without `strict`, when a strict-capable adapter refused the schema. The
-     * detail behind `strictStatus: 'refused' | 'compileRejected'` — read `strictStatus` for whether
-     * it was enforced, this for why not.
-     *
-     * Existing readers that only look at the fields above are unaffected.
-     */
-    strictRefusalReasons?: string[];
-    /**
-     * Time spent in the base adapter's `generate()` call alone, excluding `responseSchema`
-     * validation. On a success or validation-failure row, `providerMs + validateMs === latencyMs`
-     * (modulo rounding) -- `latencyMs` keeps its existing meaning unchanged; this and `validateMs`
-     * are the same window split into its two components.
-     *
-     * Present on success and validation-failure rows. Absent on a blocked row (no provider call was
-     * made) and on rows written before this field existed.
-     */
-    providerMs?: number;
-    /**
-     * Time spent in `validateResponseSchema` alone. Omitted when the call carried no `responseSchema`
-     * (nothing to validate); `0` is a legitimate value meaning a schema was supplied and validation
-     * was effectively instant. See `providerMs` for how the two relate to `latencyMs`.
-     *
-     * Present on success and validation-failure rows that supplied a `responseSchema`. Absent on a
-     * blocked row and on rows written before this field existed.
-     */
-    validateMs?: number;
-    /**
-     * Total elapsed time for the WHOLE `generate()` call -- every retry attempt plus every backoff
-     * sleep between them. Unlike `latencyMs` (which is per-attempt and never includes backoff, by
-     * design -- see `runWithRetry`), this is the one number that answers "how long did the caller
-     * actually wait". On a call that never retried, `wallClockMs === latencyMs`. On a retried call,
-     * `wallClockMs` is strictly greater than any individual row's `latencyMs` from that same call, by
-     * at least the backoff time actually slept.
-     *
-     * The same value is attached to every row produced by one `generate()` call (a validation-failure
-     * row from an earlier attempt included), because it describes the call, not the attempt.
-     *
-     * Present on success and validation-failure rows. Absent on a blocked row -- a blocked call never
-     * reaches the retry loop, so `wallClockMs` would just restate `latencyMs` (0). Absent on rows
-     * written before this field existed.
-     */
-    wallClockMs?: number;
-}
-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;
-    /**
-     * Anthropic-only: input tokens served from the prompt cache (`cache_read_input_tokens`), billed at
-     * 0.1x the base input rate. Absent for providers that never report it (OpenAI, OpenRouter).
-     */
-    cacheReadInputTokens?: number;
-    /**
-     * Anthropic-only: input tokens written to the prompt cache this call
-     * (`cache_creation_input_tokens`), billed at 1.25x the base input rate. Same absence rationale.
-     */
-    cacheCreationInputTokens?: number;
-    /** Distinct prompt-injection pattern types detected in the request's user-role messages */
-    inputWarnings?: string[];
-    /** Additive per-source breakdown of `inputWarnings` — see `SourcedInputWarnings` */
-    inputWarningsBySource?: SourcedInputWarnings[];
-    /** True when the sanitizer blocked the request and no provider call was made */
-    inputBlocked?: boolean;
-    /** Validator message when the provider responded but the output failed `responseSchema` validation */
-    outputValidationError?: string;
-    /** Raw model output that failed validation — JSON-stringified, truncated, truncation marked inline */
-    unvalidatedOutput?: string;
-    /** What happened to `strict` on this call — set by every server adapter, refusal or not */
-    strictStatus?: StrictStatus;
-    /** Why the call went out unstrict, when a strict-capable adapter refused the schema */
-    strictRefusalReasons?: string[];
-    /** Time in the base adapter's `generate()` alone, excluding `responseSchema` validation. See `BaseAICall.providerMs`. */
-    providerMs?: number;
-    /** Time in `validateResponseSchema` alone. Omitted when no `responseSchema` was supplied. See `BaseAICall.validateMs`. */
-    validateMs?: number;
-    /** Total elapsed for the whole `generate()` call, including every retry and every backoff sleep. See `BaseAICall.wallClockMs`. */
-    wallClockMs?: 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;
-}
-
-/**
- * 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)
- *
- * Signature mirrors `createLLMAdapter`'s real parameter list. `context` is narrowed to the two
- * shapes an agent ever actually builds (`processReasoning` passes `AgentReasoningContext`,
- * `Agent.callLLMForOutput` passes `AgentCompletionContext`) rather than the full `AICallContext`
- * union `createLLMAdapter` accepts -- a narrower optional param here is still assignable to the
- * wider one there. `createPostMessageAdapterFactory()`'s worker proxy ignores every param past
- * `config`; a shorter-arity function remains assignable to a longer optional-param function type,
- * so it still satisfies this type unchanged.
- */
-type LLMAdapterFactory = (config: ModelConfig, aiUsageCollector?: AIUsageCollector, callType?: BaseAICall['callType'], context?: AgentReasoningContext | AgentCompletionContext, organizationId?: string) => 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;
-    /**
-     * Overrides the default `message` requiredness for a session-capable agent (ignored for
-     * non-session agents, which always get `AgentCapabilities.message: 'off'`). Defaults to
-     * `'required'` -- see `AgentCapabilities.message`'s doc comment for why. Set `'optional'` only
-     * when the agent legitimately needs tool-only turns with no reply, and the deploy target can
-     * tolerate the blind-retry risk `validateResponseSchema` carries on any path where the schema is
-     * not compiled into a sampling grammar.
-     */
-    messagePolicy?: 'optional' | 'required';
-    /**
-     * Explicit opt-in to skip the iteration loop and produce `contract.outputSchema`-shaped output in
-     * a single LLM call (round 3 decision B6: explicit opt-in, never inferred from `kind`,
-     * `sessionCapable`, or tool count -- so no existing agent changes shape by default). Structurally
-     * the normal path pays two calls minimum: `iterate()` always runs at least one, and `complete()`
-     * runs a second whose prompt re-derives the answer from history rather than reading what the
-     * iteration already decided. A single-shot classifier -- one input in, one structured output out,
-     * no multi-step reasoning needed -- does not need that second derivation; `complete()` already
-     * makes exactly the one call it needs, from `currentInput` directly.
-     *
-     * Requires `sessionCapable` to be falsy and `contract.outputSchema` to be present. `Agent`
-     * validates both during initialization and throws `AgentInitializationError` if either is missing,
-     * rather than silently falling back to the normal two-call path on a misconfigured opt-in. Tools
-     * registered on the agent are never invoked in this path -- there is no iteration loop to call
-     * them from, so an agent that needs tool calls before it can answer is not eligible regardless of
-     * this flag.
-     */
-    singleShot?: boolean;
-    /**
-     * Security level for system prompt hardening (auto-derived if omitted)
-     *
-     * - 'standard': Lightweight defense (3 rules) - default for non-session agents
-     * - 'hardened': Comprehensive defense (5 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;
-    /**
-     * 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;
-    /**
-     * The validated input for this execution, serialized. It travels here because the model gets
-     * it as its own `role:'user'` message; nothing else in this context carried it, so the input
-     * had to be read back out of memory history and shipped inside the memory block.
-     */
-    currentInput: string;
-}
-
-/**
- * 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;
-};
-/**
- * A message from an earlier turn of this session.
- *
- * Deliberately lean (no ids, timestamps, or event metadata): this crosses the
- * parent -> worker payload boundary and is replayed verbatim into the model's message
- * array, so it carries only what the model needs to read the conversation.
- */
-interface ConversationMessage {
-    role: 'user' | 'assistant';
-    content: string;
-}
-/**
- * Execution context for all resources
- * Unified callback replaces SessionTurnMessages (removed)
- */
-interface ExecutionContext extends ExecutionMetadata {
-    logger: IExecutionLogger;
-    signal?: AbortSignal;
-    /**
-     * This session's earlier turns, oldest first, as actually said.
-     *
-     * A session agent is handed its own conversation: these are replayed into the model's
-     * message array as real user/assistant turns. Absent for one-off (non-session)
-     * executions. The session layer bounds this before it is sent -- see
-     * `selectConversationHistory`.
-     */
-    conversationHistory?: ConversationMessage[];
-    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;
-    /**
-     * Optional per-tool output size bound, in approximate tokens. Today the ONLY size bound on tool
-     * output is a 4,000-token truncation applied post-hoc at memory insert -- after the payload is
-     * already fully materialized, validated against `outputSchema`, emitted as a session message, and
-     * logged. This field exists so a tool can declare its own bound up front instead.
-     *
-     * Enforcement is NOT here. `executor.ts:executeToolCall` is the single call site that produces the
-     * value handed to all four sinks (memory, the `agent:tool_result` event, the session message, and
-     * the log line) -- enforcing there, before that value is emitted, is what makes the four sinks agree
-     * instead of three of them seeing the untruncated payload. See that file's own comment for the
-     * exact insertion point.
-     */
-    maxOutputTokens?: 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';
-
-/**
- * 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 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 full Organization Model snapshot used for OM-code validation and deployment persistence */
-    organizationModel?: OrganizationModel;
-    /** 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;
@@ -3709,38 +70,5 @@ interface ResolvedKnowledgeLayout {
 }
 declare function runKnowledgeCodegen(layout: ResolvedKnowledgeLayout): Promise<void>;
 
-type ResourceOntologyBindingResolver = (resourceId: string) => OrganizationModelResourceOntologyBinding | undefined;
-type WorkflowResourceDescriptorResolver = (resourceId: string) => OrganizationModelWorkflowResourceEntry;
-type AgentResourceDescriptorResolver = (resourceId: string) => OrganizationModelAgentResourceEntry;
-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;
-    getAgentResourceDescriptor?: AgentResourceDescriptorResolver;
-    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 withPlatformAgentResourceDescriptor(agent: AgentDefinition, getAgentResourceDescriptor: AgentResourceDescriptorResolver, getResourceOntologyBinding?: ResourceOntologyBindingResolver): AgentDefinition;
-declare function withPlatformAgentResourceDescriptors(agents: AgentDefinition[], getAgentResourceDescriptor: AgentResourceDescriptorResolver, getResourceOntologyBinding?: ResourceOntologyBindingResolver): AgentDefinition[];
-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, withPlatformAgentResourceDescriptor, withPlatformAgentResourceDescriptors, withPlatformIntegrationResourceDescriptor, withPlatformIntegrationResourceDescriptors, withPlatformResourceDescriptor, withPlatformResourceDescriptors };
-export type { AgentResourceDescriptorResolver, CodegenResult, DeploymentSpec, GenerateKnowledgeNodesOptions, GenerateKnowledgeNodesResult, IntegrationDefinition, IntegrationResourceDescriptorResolver, KnowledgeCodegenNode, KnowledgeKind, KnowledgeNodeInput, KnowledgeSearchEntry, ProjectDeploymentSpecOptions, ResolvedKnowledgeLayout, ResourceOntologyBindingResolver, ResourceRelationships, WorkflowDefinition, WorkflowResourceDescriptorResolver };
+export { generateKnowledgeBodies, generateKnowledgeNodes, generateKnowledgeNodesTs, readKnowledgeNodeMdx, runKnowledgeCodegen };
+export type { CodegenResult, GenerateKnowledgeNodesOptions, GenerateKnowledgeNodesResult, KnowledgeCodegenNode, KnowledgeKind, KnowledgeNodeInput, KnowledgeSearchEntry, ResolvedKnowledgeLayout };