# @vauban-org/agent-sdk — Public API Contract

**Version:** 0.8.2 | **Status:** public-experimental | **Generated:** 2026-05-23

> Vauban agent primitives: loop, budget, routing, HITL, permissions, tracking, durable execution

> Breaking changes (removed exports, changed signatures, narrowed types) require a **major** semver bump
> and must be gated by `api-extractor run` baseline diff in CI (see `.github/workflows/api-contract.yml`).

> This file is auto-generated from `etc/<pkg>.api.md`. Do not edit manually.
> Regenerate with: `tsx scripts/regen-contract.ts agent-sdk`

---

## Exported Surface

### `ActionCompletion`

```typescript
export interface ActionCompletion {
    readonly action_id: string;
    readonly error?: string;
    readonly evidence?: Readonly<Record<string, unknown>>;
    readonly outcome: "success" | "failure" | "skipped";
    readonly worker_agent_id: string;
}

// Warning: (ae-missing-release-tag) "ActionFilter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ActionFilter`

```typescript
export interface ActionFilter {
    readonly action_type?: CampaignActionType;
    readonly campaign_slug?: string;
    readonly due_before?: string;
    readonly limit?: number;
    readonly offset?: number;
    readonly scheduled_before?: Date | string;
    readonly status?: CampaignActionStatus;
}

// Warning: (ae-missing-release-tag) "addIdempotencyHeader" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `addIdempotencyHeader`

```typescript
export function addIdempotencyHeader(headers: Record<string, string>, key: string): Record<string, string>;
```

### `Agent`

```typescript
export class Agent {
    constructor(cfg: AgentConfig);
    run(task: string): Promise<AgentRunResult>;
    get strategyKind(): AgentStrategyName;
}

// Warning: (ae-missing-release-tag) "AGENT_ID_NAMESPACE" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AGENT_ID_NAMESPACE`

```typescript
export const AGENT_ID_NAMESPACE = "a6f9c2e4-8b5d-4e3f-a1c7-9d2b6e8f1a3c";

// Warning: (ae-missing-release-tag) "AGENT_IDS" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AGENT_IDS`

```typescript
export const AGENT_IDS: Readonly<Record<AgentType, string>>;

// Warning: (ae-missing-release-tag) "AGENT_KINDS" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AGENT_KINDS`

```typescript
export const AGENT_KINDS: readonly ["ARCHITECT", "BUILDER", "SCRIBE", "TESTER", "SYNERGY", "OODA", "LLM_ROUTER", "PLUGIN", "MCP"];
```

### `AgentAction`

```typescript
export interface AgentAction {
    readonly escalationLevel: EscalationLevel;
    readonly estimatedCostCents?: number;
    readonly payload: Record<string, unknown>;
    readonly reversible: boolean;
    readonly type: string;
}
```

### `AgentBootContext`

```typescript
export interface AgentBootContext {
    domainContext: Array<{
        content: string;
        created_at?: string;
    }>;
    projectMdContent: string | null;
    recentDecisions: Array<{
        content: string;
        created_at?: string;
    }>;
}

// Warning: (ae-missing-release-tag) "AgentBudgetState" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AgentBudgetState`

```typescript
export interface AgentBudgetState {
    coherenceScore: number;
    compactionTrigger: number;
    contextWindow: {
        maxTokens: number;
        currentTokens: number;
    };
    maxSteps: number;
    stepCount: number;
    tokensBudget: {
        input: number;
        output: number;
        usedInput: number;
        usedOutput: number;
    };
}

// Warning: (ae-missing-release-tag) "AgentCapabilityCard" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AgentCapabilityCard`

```typescript
export interface AgentCapabilityCard {
    agentId: string;
    costTier: CostTier;
    createdAt: number;
    embeddingVector?: readonly number[];
    kind: AgentKind;
    latencyTier: LatencyTier;
    skills: readonly string[];
}
```

### `AgentConfig`

```typescript
export interface AgentConfig {
    readonly agentId: string;
    readonly agentVersion?: string;
    readonly allowedTools?: readonly string[];
    readonly hooks?: AgentHooks;
    readonly llm?: LLMProviderPort;
    readonly llmFn?: StrategyLLMCompletionFn;
    readonly logger?: LoggerPort;
    readonly maxSteps?: number;
    readonly oodaInvoker?: OODACycleInvoker;
    readonly outcomeMapping?: (result: AgentCycleResult) => OutcomeRecord | null;
    readonly signal?: AbortSignal;
    readonly skillCapture?: SkillCaptureOptions;
    readonly strategy?: AgentStrategyName | AgentStrategy;
    readonly systemPrompt: string;
    readonly tools: ToolRegistry;
}

// Warning: (ae-missing-release-tag) "AgentConfigLoader" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AgentConfigLoader`

```typescript
export interface AgentConfigLoader<T = Record<string, unknown>> {
    get(agentId: string): Promise<T>;
    invalidate(agentId: string): void;
}

// Warning: (ae-missing-release-tag) "AgentContext" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AgentContext`

```typescript
export interface AgentContext {
    runId: string;
    traceId?: string;
}

// Warning: (ae-missing-release-tag) "agentControlledPolicy" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `agentControlledPolicy`

```typescript
export function agentControlledPolicy(priorities: ReadonlyMap<string, number>): EvictionPolicy;
```

### `AgentCycleResult`

```typescript
export interface AgentCycleResult {
    readonly finalMessage: string;
    readonly model?: string;
    readonly outcome?: OutcomeRecord;
    readonly provider?: string;
    readonly stepCount: number;
    readonly stepsTrace?: readonly unknown[];
    readonly stopReason: "complete" | "max_steps" | "error" | "user_cancelled" | "skipped";
    readonly tokensUsed: {
        in: number;
        out: number;
    };
}
```

### `AgentDependencies`

```typescript
export interface AgentDependencies {
    readonly brain: BrainPort;
    readonly databaseUrl?: string;
    readonly db: DbClient;
    readonly eventBus?: EventBusPort;
    readonly executionMode: ExecutionMode;
    readonly litellmUrl?: string;
    readonly logger: LoggerPort;
    readonly redis: unknown;
    readonly skills: SkillRegistry;
}

// Warning: (ae-missing-release-tag) "AgentDescriptor" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AgentDescriptor`

```typescript
export interface AgentDescriptor {
    budget_monthly_usd: number;
    description: string;
    featureFlag?: string;
    handler: AgentHandler;
    id: string;
    loop: "minimal" | "sdk";
    schedule?: string;
    version: string;
}

// Warning: (ae-missing-release-tag) "AgentExecuteInput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AgentExecuteInput`

```typescript
export interface AgentExecuteInput {
    agentId: string;
    archiveToBrain?: boolean;
    description: string;
    taskType: string;
}

// Warning: (ae-missing-release-tag) "AgentExecuteResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AgentExecuteResult`

```typescript
export interface AgentExecuteResult {
    runId: string;
    runUrl: string;
    status: string;
}
```

### `AgentFactoryConfig`

```typescript
export interface AgentFactoryConfig<TConfig = unknown, TObs = unknown, TOrient = unknown, TDecision = unknown, TAction = unknown, TFeedback = unknown> {
    agentId: string;
    agentVersion: string;
    defaults?: TConfig;
    hitlEscalationLevel?: "L1" | "L2" | "L3";
    intervalMs: number;
    outcomeMapping?: (feedback: TFeedback) => OutcomeRecord | null;
    phases: OODAAgentConfig<TConfig, TObs, TOrient, TDecision, TAction, TFeedback>["phases"];
    registryDescriptor?: Omit<AgentRegistryDescriptor, "id"> & {
        product: string;
    };
    riskGuards?: RiskGuard[];
    sessionGuards?: SessionGuard[];
}
```

### `AgentFactoryDeps`

```typescript
export interface AgentFactoryDeps extends AgentDependencies {
    readonly messaging?: MessagingChannelPort;
    readonly registry?: AgentRegistryPort;
}

// Warning: (ae-missing-release-tag) "agentFromId" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `agentFromId`

```typescript
export function agentFromId(id: string): AgentType | undefined;

// Warning: (ae-missing-release-tag) "AgentHandler" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AgentHandler`

```typescript
export type AgentHandler = (ctx: AgentContext, input: string) => Promise<AgentResult>;

// Warning: (ae-missing-release-tag) "AgentHandoffClient" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AgentHandoffClient`

```typescript
export interface AgentHandoffClient {
    execute(agentId: string, input: {
        messages: Array<{
            role: string;
            content: string;
        }>;
        handoffChain: string[];
    }): Promise<{
        runId: string;
    }>;
}

// Warning: (ae-missing-release-tag) "AgentHealth" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AgentHealth`

```typescript
export interface AgentHealth {
    agent_id: string;
    error_rate: number;
    last_run_at: string | null;
    last_status: string | null;
    p50_latency_ms: number;
    p99_latency_ms: number;
    run_count: number;
    uptime_pct: number;
    window: "24h" | "7d" | "30d";
}
```

### `AgentHooks`

```typescript
export interface AgentHooks {
    readonly onPhaseComplete?: (phase: string, output: unknown) => void;
    readonly onStep?: (event: StrategyStepEvent) => void | Promise<void>;
}

// Warning: (ae-missing-release-tag) "AgentKind" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AgentKind`

```typescript
export type AgentKind = (typeof AGENT_KINDS)[number];

// Warning: (ae-missing-release-tag) "AgentLoopImpl" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AgentLoop`

```typescript
export class AgentLoop {
    // Warning: (ae-forgotten-export) The symbol "AgentLoopConfig" needs to be exported by the entry point index.d.ts
    constructor(config: AgentLoopConfig);
    run(userMessage: string): Promise<AgentLoopRunResult>;
}

// Warning: (ae-missing-release-tag) "AgentLoopRunResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AgentLoopRunResult`

```typescript
export interface AgentLoopRunResult {
    budgetFinal: AgentBudgetState;
    costUsd?: number;
    errorMessage?: string;
    finalMessage: string;
    loopDetail?: {
        toolName: string;
        hash: string;
        firstStep: number;
        repeatStep: number;
        reason?: "max_steps" | "max_time" | "max_cost" | "hash_collision" | "progress_plateau";
    };
    stopReason: "complete" | "budget_exhausted" | "incoherent" | "loop_definitive" | "tool_denied" | "user_cancelled" | "error";
    traceId: string;
}

// Warning: (ae-missing-release-tag) "AgentMeter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AgentMeter`

```typescript
export class AgentMeter {
    export(): MeterEntry[];
    getBalance(agentId: string, since?: number): MeterBalance;
    import(entries: MeterEntry[]): void;
    recordRun(runId: string, agentId: string, valueCents: number): MeterEntry;
    verifyChain(agentId?: string, since?: number): MeterVerifyResult;
}
```

### `AgentMetrics`

```typescript
export interface AgentMetrics {
    cycleCompleted: Counter<"agent_id" | "outcome">;
    // Warning: (ae-forgotten-export) The symbol "Histogram" needs to be exported by the entry point index.d.ts
    cycleDuration: Histogram<"agent_id" | "phase">;
    // Warning: (ae-forgotten-export) The symbol "Counter" needs to be exported by the entry point index.d.ts
    cycleStarted: Counter<"agent_id">;
    hitlRequested: Counter<"agent_id">;
    hitlResolved: Counter<"agent_id" | "decision">;
    llmCallCount: Counter<"agent_id" | "provider">;
    llmCostUsd: Counter<"agent_id" | "provider">;
    llmTokensUsed: Counter<"agent_id" | "provider" | "direction">;
}

// Warning: (ae-missing-release-tag) "AgentPersona" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AgentPersona`

```typescript
export type AgentPersona = z.infer<typeof PersonaSchema>;

// Warning: (ae-missing-release-tag) "AgentRef" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AgentRef`

```typescript
export interface AgentRef {
    readonly agent_card_url?: string;
    readonly agent_id: string;
    readonly tenant_id: string;
}

// Warning: (ae-missing-release-tag) "AgentRegistry" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AgentRegistry`

```typescript
export class AgentRegistry {
    discover(workspaceRoot: string): Promise<AgentDescriptor[]>;
    discoverByKind(kind: AgentKind): AgentCapabilityCard[];
    discoverBySkills(skills: readonly string[], opts?: {
        kind?: AgentKind;
        matchAll?: boolean;
    }): AgentCapabilityCard[];
    get(id: string): AgentDescriptor | undefined;
    list(): AgentDescriptor[];
    register(desc: AgentDescriptor): void;
    registerCapability(card: AgentCapabilityCard): void;
    get size(): number;
    unregister(id: string): boolean;
}

// Warning: (ae-missing-release-tag) "agentRegistry" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `agentRegistry`

```typescript
export const agentRegistry: AgentRegistry;

// Warning: (ae-missing-release-tag) "AgentDescriptor" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AgentRegistryDescriptor`

```typescript
export interface AgentRegistryDescriptor {
    capabilities: string[];
    id: string;
    inputSchema: object;
    llmRequirements?: {
        minContextWindow?: number;
        toolUse?: boolean;
    };
    product: string;
    tenantId?: string;
    trigger: "event" | "cron" | "hitl" | "webhook";
}

// Warning: (ae-missing-release-tag) "AgentRegistryEntry" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AgentRegistryEntry`

```typescript
export interface AgentRegistryEntry {
    agentId: string;
    status: string;
    type: string;
}

// Warning: (ae-missing-release-tag) "AgentRegistryPort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AgentRegistryPort`

```typescript
export interface AgentRegistryPort {
    list(filter?: Partial<AgentRegistryDescriptor>): Promise<AgentRegistryDescriptor[]>;
    register(descriptor: AgentRegistryDescriptor): Promise<void>;
    resolve(capability: string, opts?: {
        tenantId?: string;
    }): Promise<AgentRegistryDescriptor[]>;
    unregister(id: string): Promise<void>;
}

// Warning: (ae-missing-release-tag) "AgentResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AgentResult`

```typescript
export interface AgentResult {
    inputTokens: number;
    output: string;
    outputTokens: number;
    stopReason: "complete" | "budget_exhausted" | "error" | string;
}

// Warning: (ae-missing-release-tag) "AgentRunFinalStatus" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AgentRunFinalStatus`

```typescript
export type AgentRunFinalStatus = "success" | "failed" | "timeout" | "incoherent";

// Warning: (ae-missing-release-tag) "AgentRunFinish" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AgentRunFinish`

```typescript
export interface AgentRunFinish {
    errorMessage?: string;
    status: AgentRunFinalStatus;
    stopReason?: string;
}

// Warning: (ae-missing-release-tag) "AgentRunRef" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AgentRunRef`

```typescript
export interface AgentRunRef {
    agent_id: string;
    id: string;
    outcome_id?: string | null;
    run_id?: string;
}
```

### `AgentRunResult`

```typescript
export interface AgentRunResult {
    readonly agentId: string;
    readonly durationMs: number;
    readonly finalMessage: string;
    readonly model?: string;
    readonly outcome?: OutcomeRecord;
    readonly provider?: string;
    readonly runId: string;
    readonly skillCaptured?: boolean;
    readonly stepCount: number;
    readonly stepsTrace?: readonly unknown[];
    readonly stopReason: AgentCycleResult["stopReason"];
    readonly strategy: AgentStrategyName;
    readonly tokensUsed: {
        in: number;
        out: number;
    };
}

// Warning: (ae-missing-release-tag) "AgentRunStartInput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AgentRunStartInput`

```typescript
export interface AgentRunStartInput {
    agentId: string;
    agentVersion: string;
    model: string;
    provider: string;
    runId: string;
    tenantId?: string;
    traceId?: string;
}

// Warning: (ae-missing-release-tag) "AgentRunStepDelta" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AgentRunStepDelta`

```typescript
export interface AgentRunStepDelta {
    costUsd: number;
    inputTokens: number;
    outputTokens: number;
    toolCalls?: number;
}

// Warning: (ae-missing-release-tag) "AgentRunTracker" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AgentRunTracker`

```typescript
export interface AgentRunTracker {
    finish(uuid: string, result: AgentRunFinish): Promise<void>;
    recordStep(uuid: string, delta: AgentRunStepDelta): Promise<void>;
    start(input: AgentRunStartInput): Promise<string>;
}

// Warning: (ae-missing-release-tag) "AgentsClient" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AgentsClient`

```typescript
export interface AgentsClient {
    execute(input: AgentExecuteInput): Promise<AgentExecuteResult>;
    listRegistry(): Promise<{
        agents: AgentRegistryEntry[];
    }>;
}

// Warning: (ae-missing-release-tag) "AgentsClientOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AgentsClientOptions`

```typescript
export interface AgentsClientOptions {
    baseUrl: string;
    getToken: () => Promise<string>;
}

// Warning: (ae-missing-release-tag) "agentSpan" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `agentSpan`

```typescript
export function agentSpan(tracer: Tracer, opts: {
    agentId: string;
    agentVersion: string;
    runId: string;
}): Span;
```

### `AgentStrategy`

```typescript
export interface AgentStrategy {
    readonly name: AgentStrategyName;
    run(ctx: StrategyAgentContext): Promise<AgentCycleResult>;
}
```

### `AgentStrategyName`

```typescript
export type AgentStrategyName = "ooda" | "react" | "plan" | "one-shot";

// Warning: (ae-missing-release-tag) "AgentTier" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AgentTier`

```typescript
export type AgentTier = "T1" | "T2" | "T3" | "T4";

// Warning: (ae-missing-release-tag) "AgentTool" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AgentTool`

```typescript
export interface AgentTool<TParams extends z.ZodTypeAny = z.ZodTypeAny> {
    readonly capability?: SdkCapability;
    readonly dangerous?: boolean;
    readonly description: string;
    readonly execute: (params: z.infer<TParams>) => Promise<unknown>;
    readonly mcpScopes?: readonly string[];
    readonly name: string;
    readonly parameters: TParams;
    readonly risk?: RiskVector;
}

// Warning: (ae-missing-release-tag) "AgentType" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AgentType`

```typescript
export type AgentType = "ARCHITECT" | "BUILDER" | "TESTER" | "SCRIBE" | "SYNERGY";
```

### `AlertDigestOptions`

```typescript
export interface AlertDigestOptions {
    readonly detailsPointer?: string;
    readonly emojiMap?: Readonly<Record<string, string>>;
    readonly label?: string;
    readonly maxChars?: number;
    readonly severityOrder?: readonly string[];
    readonly threshold?: number;
}
```

### `AlertItem`

```typescript
export interface AlertItem {
    readonly component?: string;
    readonly ref?: string;
    readonly remediation?: string;
    readonly severity: "critical" | "high" | "medium" | "low" | (string & Record<never, never>);
    readonly title: string;
    readonly url?: string;
}

// Warning: (ae-missing-release-tag) "AlertLevel" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AlertLevel`

```typescript
export type AlertLevel = "info" | "warn" | "error" | "critical";

// Warning: (ae-missing-release-tag) "AllAdaptersFailedError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AllAdaptersFailedError`

```typescript
export class AllAdaptersFailedError extends AggregateError {
    constructor(errors: Error[], message?: string);
}

// Warning: (ae-missing-release-tag) "ALLOW_ALL_GATE" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ALLOW_ALL_GATE`

```typescript
export const ALLOW_ALL_GATE: CapabilityGate;

// Warning: (ae-forgotten-export) The symbol "AlpacaQuoteInput" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "alpacaQuote" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `alpacaQuote`

```typescript
export const alpacaQuote: Skill<AlpacaQuoteInput, AlpacaQuoteOutput>;

// Warning: (ae-missing-release-tag) "AlpacaQuoteOutput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AlpacaQuoteOutput`

```typescript
export interface AlpacaQuoteOutput {
    ask: number;
    bid: number;
    mode: "paper" | "live" | "replay";
    symbol: string;
    timestamp: string;
}

// Warning: (ae-missing-release-tag) "alwaysOn" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `alwaysOn`

```typescript
export function alwaysOn(): SessionGuard;

// Warning: (ae-missing-release-tag) "Anomaly" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `Anomaly`

```typescript
export interface Anomaly {
    agent_id: string;
    baseline_mean: number;
    baseline_stddev: number;
    cost_dimension: string;
    detected_at: string;
    observed: number;
    run_id: string | null;
    severity: "low" | "medium" | "high";
    z_score: number;
}

// Warning: (ae-missing-release-tag) "AnthropicContentBlock" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AnthropicContentBlock`

```typescript
export type AnthropicContentBlock = AnthropicTextBlock | AnthropicImageBlock | AnthropicDocumentBlock;

// Warning: (ae-missing-release-tag) "AnthropicDirectAdapter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AnthropicDirectAdapter`

```typescript
export class AnthropicDirectAdapter implements LLMProviderPort {
    constructor(config: AnthropicDirectAdapterConfig);
    complete(req: ChatRequest): Promise<ChatResponse>;
    estimateCost(req: ChatRequest): {
        usd: number;
    };
    stream(req: ChatRequest): AsyncIterable<StreamDelta>;
}

// Warning: (ae-missing-release-tag) "AnthropicDirectAdapterConfig" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AnthropicDirectAdapterConfig`

```typescript
export interface AnthropicDirectAdapterConfig {
    apiKey: string;
    _clientOverride?: Anthropic;
    defaultModel?: string;
}

// Warning: (ae-missing-release-tag) "AnthropicDocumentBlock" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AnthropicDocumentBlock`

```typescript
export interface AnthropicDocumentBlock {
    source: {
        type: "url";
        url: string;
    };
    type: "document";
}

// Warning: (ae-missing-release-tag) "AnthropicImageBlock" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AnthropicImageBlock`

```typescript
export interface AnthropicImageBlock {
    source: {
        type: "base64";
        media_type: ImageMediaType;
        data: string;
    };
    type: "image";
}

// Warning: (ae-missing-release-tag) "AnthropicTextBlock" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AnthropicTextBlock`

```typescript
export interface AnthropicTextBlock {
    text: string;
    type: "text";
}

// Warning: (ae-forgotten-export) The symbol "Axiom" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "ANTI_FRAGILE" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ANTI_FRAGILE`

```typescript
export const ANTI_FRAGILE: Axiom;

// Warning: (ae-missing-release-tag) "antiFragileScorer" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `antiFragileScorer`

```typescript
export const antiFragileScorer: ScoringFunction;

// Warning: (ae-missing-release-tag) "applyPolicy" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `applyPolicy`

```typescript
export function applyPolicy(result: FormalVerifyResult, policy: AxiomPolicy, mode: ConsumerMode, context: VerifyContext): PolicyDecision;

// Warning: (ae-missing-release-tag) "Approval" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `Approval`

```typescript
export interface Approval {
    approved: boolean;
    at: string;
    by: string;
    rationale?: string;
}

// Warning: (ae-missing-release-tag) "ApprovalChannel" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ApprovalChannel`

```typescript
export interface ApprovalChannel {
    cancel(id: string): Promise<void>;
    poll(id: string): Promise<Approval | null>;
    send(req: ApprovalRequest): Promise<string>;
}

// Warning: (ae-missing-release-tag) "ApprovalRequest" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ApprovalRequest`

```typescript
export interface ApprovalRequest {
    action: string;
    agentId: string;
    context: string;
    timeoutMs: number;
}

// Warning: (ae-missing-release-tag) "ApprovalStatus" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ApprovalStatus`

```typescript
export type ApprovalStatus = "pending" | "resolved" | "cancelled" | "timedout";

// Warning: (ae-missing-release-tag) "ApprovalStore" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ApprovalStore`

```typescript
export interface ApprovalStore {
    cancel(id: string): Promise<boolean>;
    create(entry: PendingApproval): Promise<void>;
    expireOverdue(now?: number): Promise<number>;
    get(id: string): Promise<PendingApproval | null>;
    resolve(id: string, verdict: Approval): Promise<boolean>;
}

// Warning: (ae-forgotten-export) The symbol "AgentDescriptor_2" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "asAgentTool" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `asAgentTool`

```typescript
export function asAgentTool(descriptor: AgentDescriptor_2, client: AgentHandoffClient): Promise<{
    name: string;
    description: string;
    inputSchema: Record<string, unknown>;
    handler: (input: {
        messages: Array<{
            role: string;
            content: string;
        }>;
        handoffChain?: string[];
    }) => Promise<{
        runId: string;
    }>;
}>;

// Warning: (ae-missing-release-tag) "assertExecutionMode" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `assertExecutionMode`

```typescript
export function assertExecutionMode(mode: unknown): asserts mode is ExecutionMode;

// Warning: (ae-missing-release-tag) "assertVerifierResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `assertVerifierResult`

```typescript
export function assertVerifierResult(r: VerifierResult): void;

// Warning: (ae-missing-release-tag) "AttenuatedToken" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AttenuatedToken`

```typescript
export interface AttenuatedToken {
    readonly budgetEur: number;
    readonly expiresAt?: string;
    readonly parentId: string;
    readonly scope: ReadonlyArray<string>;
}

// Warning: (ae-missing-release-tag) "attenuateScope" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `attenuateScope`

```typescript
export function attenuateScope(parent: MeshCapabilityScope, requested: MeshCapabilityScope): MeshCapabilityScope;

// Warning: (ae-missing-release-tag) "AudioMediaType" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AudioMediaType`

```typescript
export type AudioMediaType = "audio/ogg" | "audio/wav" | "audio/mp3" | "audio/mpeg" | "audio/webm";

// Warning: (ae-missing-release-tag) "AXIOM_SPECS" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AXIOM_SPECS`

```typescript
export const AXIOM_SPECS: Record<string, AxiomSpec>;

// Warning: (ae-missing-release-tag) "AxiomId" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AxiomId`

```typescript
export type AxiomId = "Institutionnel" | "SOTA" | "Robuste" | "AntiFragile" | "Profitable";

// Warning: (ae-missing-release-tag) "AxiomPolicy" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AxiomPolicy`

```typescript
export interface AxiomPolicy {
    onSafe: "proceed";
    onUnknown: OnUnknown;
    onUnsafe: OnUnsafe;
    skillLoopStrict: boolean;
    timeout_ms: number;
}

// Warning: (ae-missing-release-tag) "AxiomScoreEntry" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AxiomScoreEntry`

```typescript
export interface AxiomScoreEntry {
    axiomId: AxiomId;
    rationale: string;
    score: number;
}

// Warning: (ae-missing-release-tag) "AxiomSpec" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `AxiomSpec`

```typescript
export interface AxiomSpec {
    axiom: string;
    postconditions: Condition[];
    preconditions: Condition[];
    timeout_ms?: number;
}

// Warning: (ae-missing-release-tag) "BASE_SKILL_NAMES" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BASE_SKILL_NAMES`

```typescript
export const BASE_SKILL_NAMES: readonly ["brain-query", "brain-store", "slack-notify", "llm-complete"];

// Warning: (ae-missing-release-tag) "BaseSkillName" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BaseSkillName`

```typescript
export type BaseSkillName = (typeof BASE_SKILL_NAMES)[number];

// Warning: (ae-missing-release-tag) "BashMode" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BashMode`

```typescript
export type BashMode = false | "restricted";

// Warning: (ae-missing-release-tag) "ActionContext" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BastionActionContext`

```typescript
export interface BastionActionContext {
    readonly jurisdictionsContext?: string[];
    readonly legalBasis?: string;
    readonly manifestHash: string;
    readonly runId: string;
    readonly tenantId: BastionTenantId;
}

// Warning: (ae-missing-release-tag) "BastionActionPort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BastionActionPort`

```typescript
export interface BastionActionPort {
    deposit(params: DepositParams, ctx: BastionActionContext): Promise<DepositResult>;
    swap(params: SwapParams, ctx: BastionActionContext): Promise<SwapResult>;
    transfer(params: TransferParams, ctx: BastionActionContext): Promise<TransferResult>;
    validateAgainstClientPolicies(action: "swap" | "deposit" | "withdraw" | "transfer", tenantId: BastionTenantId, params?: Partial<SwapParams & DepositParams>): Promise<PolicyValidation>;
    withdraw(params: WithdrawParams, ctx: BastionActionContext): Promise<WithdrawResult>;
}

// Warning: (ae-missing-release-tag) "BastionContractError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BastionContractError`

```typescript
export class BastionContractError extends Error {
    constructor(contract_call: string, contract_error: string, cause?: unknown | undefined);
    readonly cause?: unknown | undefined;
    readonly contract_call: string;
    readonly contract_error: string;
}

// Warning: (ae-missing-release-tag) "BastionInsufficientFundsError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BastionInsufficientFundsError`

```typescript
export class BastionInsufficientFundsError extends Error {
    constructor(required: string, available: string, cause?: unknown | undefined);
    readonly available: string;
    readonly cause?: unknown | undefined;
    readonly required: string;
}

// Warning: (ae-missing-release-tag) "BastionPolicyViolationError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BastionPolicyViolationError`

```typescript
export class BastionPolicyViolationError extends Error {
    constructor(message: string, action: string, tenantId: BastionTenantId, cause?: unknown | undefined);
    readonly action: string;
    readonly cause?: unknown | undefined;
    readonly tenantId: BastionTenantId;
}

// Warning: (ae-missing-release-tag) "BastionSlippageExceededError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BastionSlippageExceededError`

```typescript
export class BastionSlippageExceededError extends Error {
    constructor(max_slippage_bps: number, actual_slippage_bps: number, cause?: unknown | undefined);
    readonly actual_slippage_bps: number;
    readonly cause?: unknown | undefined;
    readonly max_slippage_bps: number;
}

// Warning: (ae-missing-release-tag) "TenantId" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BastionTenantId`

```typescript
export type BastionTenantId = string;

// Warning: (ae-missing-release-tag) "BastionTransferUnauthorizedError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BastionTransferUnauthorizedError`

```typescript
export class BastionTransferUnauthorizedError extends Error {
    constructor(message: string, reason: "missing_legal_basis" | "jurisdiction_blocked", cause?: unknown | undefined);
    readonly cause?: unknown | undefined;
    readonly reason: "missing_legal_basis" | "jurisdiction_blocked";
}

// Warning: (ae-missing-release-tag) "BestOfNOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BestOfNOptions`

```typescript
export interface BestOfNOptions<_TInput, TOutput> {
    n: number;
    parallel?: boolean;
    rewardModel?: BestOfNRewardModel<TOutput>;
    verifier?: Verifier<TOutput>;
}

// Warning: (ae-missing-release-tag) "BestOfNRewardModel" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BestOfNRewardModel`

```typescript
export interface BestOfNRewardModel<TOutput> {
    score(output: TOutput): Promise<number> | number;
}

// Warning: (ae-missing-release-tag) "bestOfNStrategy" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `bestOfNStrategy`

```typescript
export function bestOfNStrategy<TInput, TOutput>(opts: BestOfNOptions<TInput, TOutput>): Strategy<TInput, TOutput>;
```

### `BinaryExecutionOptions`

```typescript
export interface BinaryExecutionOptions {
    cwd?: string;
    executionId?: string;
    extraEnv?: Record<string, string>;
    mode?: string;
    timeoutSeconds?: number;
}

// Warning: (ae-missing-release-tag) "BonMavOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BonMavOptions`

```typescript
export interface BonMavOptions<TOutput> {
    aggregation?: MAVAggregation;
    n: number;
    parallel?: boolean;
    verifiers: readonly Verifier<TOutput>[];
    voteThreshold?: number;
}

// Warning: (ae-missing-release-tag) "bonMavStrategy" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `bonMavStrategy`

```typescript
export function bonMavStrategy<TInput, TOutput>(opts: BonMavOptions<TOutput>): Strategy<TInput, TOutput>;

// Warning: (ae-missing-release-tag) "BoundedTtlCache" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BoundedTtlCache`

```typescript
export class BoundedTtlCache<T> implements IdempotencyCache<T> {
    constructor(maxEntries: number, ttlMs: number, now?: () => number);
    delete(key: string): void;
    get(key: string): T | undefined;
    set(key: string, value: T): void;
    get size(): number;
}

// Warning: (ae-missing-release-tag) "BrainAuthError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BrainAuthError`

```typescript
export class BrainAuthError extends PortError {
    constructor(message?: string, cause?: unknown);
    readonly port = "brain";
}

// Warning: (ae-missing-release-tag) "BrainCallResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BrainCallResult`

```typescript
export interface BrainCallResult<T> {
    readonly mcp_call_hash: string;
    readonly result: T;
    readonly retrieval_proof_hash: string;
}

// Warning: (ae-missing-release-tag) "BrainChunk" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BrainChunk`

```typescript
export interface BrainChunk {
    readonly content: string;
    readonly entry_id: string;
    readonly metadata?: Record<string, unknown>;
    readonly similarity: number;
}

// Warning: (ae-missing-release-tag) "BrainContextOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BrainContextOptions`

```typescript
export interface BrainContextOptions<TInput> {
    readonly enabled: boolean;
    readonly fetchBrainContext?: (query: string, topK: number) => Promise<BrainCallResult<BrainChunk[]> | DegradedResponse>;
    readonly minSimilarity?: number;
    readonly query: (input: TInput) => string;
    readonly replayChunks?: BrainChunk[];
    readonly topK?: number;
}

// Warning: (ae-missing-release-tag) "BrainEntry" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BrainEntry`

```typescript
export interface BrainEntry {
    category?: string;
    content: string;
    created_at?: string;
    id: string;
    metadata?: Record<string, unknown>;
    tags?: string[];
}

// Warning: (ae-missing-release-tag) "BrainEntryInput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BrainEntryInput`

```typescript
export interface BrainEntryInput {
    author?: string;
    brain_id?: string;
    category?: string;
    confidence?: number;
    content: string;
    content_type?: string;
    metadata?: Record<string, unknown>;
    tags?: string[];
}

// Warning: (ae-missing-release-tag) "BrainPort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BrainPort`

```typescript
export interface BrainPort {
    archiveKnowledge(entry: BrainEntryInput): Promise<BrainEntry | null>;
    archiveLesson?(input: LessonInput): Promise<void>;
    archivePostmortem?(input: PostmortemInput): Promise<void>;
    episodic?: EpisodicMemoryPort;
    procedural?: ProceduralMemoryPort;
    queryKnowledge?(query: string, filters?: BrainQueryFilters): Promise<BrainEntry[]>;
    semantic?: SemanticMemoryPort;
    working?: WorkingMemoryPort;
}

// Warning: (ae-forgotten-export) The symbol "BrainQueryInput" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "brainQuery" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `brainQuery`

```typescript
export const brainQuery: Skill<BrainQueryInput, BrainQueryOutput>;

// Warning: (ae-missing-release-tag) "BrainQueryFilters" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BrainQueryFilters`

```typescript
export interface BrainQueryFilters {
    [key: string]: unknown;
    category?: string;
    limit?: number;
    tags?: string[];
}

// Warning: (ae-missing-release-tag) "BrainQueryOutput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BrainQueryOutput`

```typescript
export interface BrainQueryOutput {
    entries: BrainEntry[];
}

// Warning: (ae-missing-release-tag) "BrainRateLimit" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BrainRateLimit`

```typescript
export class BrainRateLimit extends PortError {
    constructor(opts?: {
        message?: string;
        retryAfterMs?: number;
        cause?: unknown;
    });
    readonly port = "brain";
    readonly retryAfterMs?: number;
}

// Warning: (ae-missing-release-tag) "BrainRateLimitError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BrainRateLimitError`

```typescript
export class BrainRateLimitError extends Error {
    constructor(message: string, retryAfterMs: number, cause?: unknown | undefined);
    readonly cause?: unknown | undefined;
    readonly retryAfterMs: number;
}

// Warning: (ae-missing-release-tag) "BrainSkillNotConfiguredError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BrainSkillNotConfiguredError`

```typescript
export class BrainSkillNotConfiguredError extends Error {
    constructor();
}

// Warning: (ae-forgotten-export) The symbol "BrainStoreInput" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "brainStore" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `brainStore`

```typescript
export const brainStore: Skill<BrainStoreInput, BrainStoreOutput>;

// Warning: (ae-missing-release-tag) "BrainStoreOutput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BrainStoreOutput`

```typescript
export interface BrainStoreOutput {
    archived: boolean;
    id: string | null;
}

// Warning: (ae-missing-release-tag) "BrainUnavailable" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BrainUnavailable`

```typescript
export class BrainUnavailable extends PortError {
    constructor(message?: string, cause?: unknown);
    readonly port = "brain";
}

// Warning: (ae-missing-release-tag) "BrainUnavailableError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BrainUnavailableError`

```typescript
export class BrainUnavailableError extends Error {
    constructor(message: string, cause?: unknown | undefined);
    readonly cause?: unknown | undefined;
}

// Warning: (ae-missing-release-tag) "BrainValidationError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BrainValidationError`

```typescript
export class BrainValidationError extends PortError {
    constructor(message: string, cause?: unknown);
    readonly port = "brain";
}

// Warning: (ae-missing-release-tag) "BudgetExhaustedError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BudgetExhaustedError`

```typescript
export class BudgetExhaustedError extends Error {
    constructor(message?: string);
    readonly name = "BudgetExhaustedError";
}
```

### `buildAlertDigest`

```typescript
export function buildAlertDigest(items: readonly AlertItem[], opts?: AlertDigestOptions): string[];

// Warning: (ae-missing-release-tag) "buildToken" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `buildAttenuatedToken`

```typescript
export function buildAttenuatedToken(scope: MeshCapabilityScope, parentId: string): AttenuatedToken;

// Warning: (ae-forgotten-export) The symbol "BlockKitOpts" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "buildBlockKit" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `buildBlockKit`

```typescript
export function buildBlockKit(opts: BlockKitOpts): unknown[];

// Warning: (ae-missing-release-tag) "buildChain" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `buildChain`

```typescript
export function buildChain(trace: Trace): Promise<ProofChain>;

// Warning: (ae-missing-release-tag) "buildOrientPrompt" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `buildOrientPrompt`

```typescript
export function buildOrientPrompt(opts: BuildOrientPromptOpts): {
    system: string;
    user: string;
};
```

### `BuildOrientPromptOpts`

```typescript
export interface BuildOrientPromptOpts {
    jsonSchema?: object;
    maxContextChars?: number;
    recentMemory?: string[];
    systemPrompt: string;
    userContext: string;
}

// Warning: (ae-missing-release-tag) "buildPersonaPromptBlock" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `buildPersonaPromptBlock`

```typescript
export function buildPersonaPromptBlock(persona: AgentPersona): string;
```

### `buildProtocolEnv`

```typescript
export function buildProtocolEnv(args: {
    executionId: string;
    automationName: string;
    input: unknown;
    timeoutSeconds: number;
    mode?: string;
    extraEnv?: Readonly<Record<string, string>>;
}): Record<string, string>;

// Warning: (ae-missing-release-tag) "buildSkillRegistry" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `buildSkillRegistry`

```typescript
export function buildSkillRegistry(opts: BuildSkillsOptions): SkillRegistry;

// Warning: (ae-missing-release-tag) "buildSkills" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `buildSkills`

```typescript
export function buildSkills(opts: BuildSkillsOptions): SkillRegistryBundle;

// Warning: (ae-missing-release-tag) "BuildSkillsOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BuildSkillsOptions`

```typescript
export interface BuildSkillsOptions {
    readonly agentId: string;
    readonly deps: SkillBuilderDeps;
    readonly domain: string;
    readonly extras?: DomainSkillEntry[];
}

// Warning: (ae-forgotten-export) The symbol "TelegramTextOpts" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "buildTelegramText" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `buildTelegramText`

```typescript
export function buildTelegramText(opts: TelegramTextOpts): string;

// Warning: (ae-missing-release-tag) "BUILT_IN_AXIOMS" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BUILT_IN_AXIOMS`

```typescript
export const BUILT_IN_AXIOMS: ReadonlyArray<Axiom>;

// Warning: (ae-missing-release-tag) "Bulkhead" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `Bulkhead`

```typescript
export interface Bulkhead<TArgs extends unknown[], TResult> {
    (...args: TArgs): Promise<TResult>;
    readonly stats: BulkheadStats;
}

// Warning: (ae-missing-release-tag) "bulkhead" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `bulkhead`

```typescript
export function bulkhead<TArgs extends unknown[], TResult>(fn: (...args: TArgs) => Promise<TResult>, options: BulkheadOptions): Bulkhead<TArgs, TResult>;

// Warning: (ae-missing-release-tag) "BulkheadFullError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BulkheadFullError`

```typescript
export class BulkheadFullError extends Error {
    constructor(bulkheadName: string, queueDepth: number);
    readonly bulkheadName: string;
}

// Warning: (ae-missing-release-tag) "BulkheadMetrics" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BulkheadMetrics`

```typescript
export interface BulkheadMetrics {
    active: number;
    completed: number;
    queued: number;
    rejected: number;
}

// Warning: (ae-missing-release-tag) "BulkheadOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BulkheadOptions`

```typescript
export interface BulkheadOptions {
    maxConcurrent?: number;
    maxQueued?: number;
    name: string;
}

// Warning: (ae-missing-release-tag) "BulkheadPool" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BulkheadPool`

```typescript
export interface BulkheadPool<T> {
    metrics(): BulkheadMetrics;
    run(fn: () => Promise<T>): Promise<T>;
}

// Warning: (ae-missing-release-tag) "BulkheadQueueFullError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BulkheadQueueFullError`

```typescript
export class BulkheadQueueFullError extends Error {
    constructor(active: number, queued: number, maxConcurrent: number, maxQueue: number);
}

// Warning: (ae-missing-release-tag) "BulkheadStats" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BulkheadStats`

```typescript
export interface BulkheadStats {
    active: number;
    queued: number;
}

// Warning: (ae-missing-release-tag) "BullMQRunner" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BullMQRunner`

```typescript
export class BullMQRunner {
    constructor(config: BullMQRunnerConfig);
    close(): Promise<void>;
    createQueue(name: string, archetype: QueueArchetype): Queue;
    createWorker<T = unknown, R = unknown>(queueName: string, processor: (job: Job<T, R>) => Promise<R>, opts?: Partial<WorkerOptions_2>): Worker_2<T, R>;
    dlqQueue(): Queue<DlqJobPayload>;
    flowProducer(): FlowProducer;
    queueRetryFn<T>(queueName: string): (payload: T) => Promise<string>;
    runFlowReliable<Parent = unknown>(parent: {
        name: string;
        queueName: string;
        data?: Parent;
        opts?: JobsOptions;
    }, children: Array<{
        name: string;
        queueName: string;
        data?: unknown;
        opts?: JobsOptions;
    }>, waitOpts?: {
        pollIntervalMs?: number;
        maxWaitMs?: number;
    }): Promise<{
        parentStatus: "completed" | "failed";
        failedChildren: string[];
        parentJobId: string | undefined;
    }>;
}

// Warning: (ae-missing-release-tag) "BullMQRunnerConfig" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BullMQRunnerConfig`

```typescript
export interface BullMQRunnerConfig {
    defaultAttempts?: number;
    defaultBackoff?: {
        type: "exponential" | "fixed";
        delay: number;
    };
    dlqName?: string;
    jobTimeoutMs?: number;
    redisDb?: number;
    // Warning: (ae-forgotten-export) The symbol "IORedisLike" needs to be exported by the entry point index.d.ts
    redisFactory?: (url: string, db: number) => IORedisLike;
    redisUrl: string;
}

// Warning: (ae-missing-release-tag) "businessHours" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `businessHours`

```typescript
export function businessHours(opts: BusinessHoursOptions): SessionGuard;

// Warning: (ae-missing-release-tag) "BusinessHoursOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `BusinessHoursOptions`

```typescript
export interface BusinessHoursOptions {
    daysOfWeek: number[];
    tz?: string;
    windowEnd: string;
    windowStart: string;
}
```

### `calculateDelay`

```typescript
export function calculateDelay(config: RetryConfig, attempt: number): number;

// Warning: (ae-forgotten-export) The symbol "CalendarCheckInput" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "calendarCheck" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `calendarCheck`

```typescript
export const calendarCheck: Skill<CalendarCheckInput, CalendarCheckOutput>;

// Warning: (ae-missing-release-tag) "CalendarCheckOutput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CalendarCheckOutput`

```typescript
export interface CalendarCheckOutput {
    date: string;
    holiday_name: string | null;
    is_holiday: boolean;
    is_rth: boolean;
    is_weekend: boolean;
    market: "NYSE" | "CME" | "NASDAQ";
}

// Warning: (ae-missing-release-tag) "CampaignActionInput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CampaignActionInput`

```typescript
export interface CampaignActionInput {
    readonly action_type: CampaignActionType;
    readonly campaign_slug: string;
    readonly contact_id?: string;
    readonly due_date?: string;
    readonly idempotency_key: string;
    readonly payload: Readonly<Record<string, unknown>>;
    readonly priority?: number;
    readonly title: string;
}

// Warning: (ae-missing-release-tag) "CampaignActionPatch" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CampaignActionPatch`

```typescript
export interface CampaignActionPatch {
    readonly notes?: string;
    readonly payload?: Readonly<Record<string, unknown>>;
    readonly phase?: string;
    readonly publish_evidence?: Readonly<Record<string, unknown>>;
    readonly scheduled_at?: string;
    readonly status?: CampaignActionStatus;
}

// Warning: (ae-missing-release-tag) "CampaignActionRef" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CampaignActionRef`

```typescript
export interface CampaignActionRef {
    readonly action_id: string;
    readonly action_type: CampaignActionType;
    readonly campaign_slug: string;
    readonly contact_id?: string;
    readonly name?: string;
    readonly payload: Readonly<Record<string, unknown>>;
    readonly priority: number;
    readonly status: CampaignActionStatus;
}

// Warning: (ae-missing-release-tag) "CampaignActionStatus" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CampaignActionStatus`

```typescript
export type CampaignActionStatus = "todo" | "in_progress" | "done" | "blocked" | "skipped";

// Warning: (ae-missing-release-tag) "CampaignActionType" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CampaignActionType`

```typescript
export type CampaignActionType = "publish_article" | "publish_social_post" | "send_cold_mail" | "send_follow_up_mail" | "engage_target" | "manual_review";

// Warning: (ae-missing-release-tag) "CampaignInput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CampaignInput`

```typescript
export interface CampaignInput {
    readonly metadata?: Readonly<Record<string, unknown>>;
    readonly name: string;
    readonly objective: string;
    readonly product: string;
    readonly slug: string;
    readonly tags?: readonly string[];
}

// Warning: (ae-missing-release-tag) "CampaignPatch" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CampaignPatch`

```typescript
export interface CampaignPatch {
    readonly cadence_plan?: Readonly<Record<string, unknown>>;
    readonly description?: string;
    readonly metadata?: Readonly<Record<string, unknown>>;
    readonly name?: string;
    readonly status?: CampaignStatus;
    readonly tags?: readonly string[];
}

// Warning: (ae-missing-release-tag) "CampaignRef" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CampaignRef`

```typescript
export interface CampaignRef {
    readonly campaign_id: string;
    readonly created_at: Date;
    readonly slug: string;
    readonly status: CampaignStatus;
}

// Warning: (ae-missing-release-tag) "CampaignStatus" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CampaignStatus`

```typescript
export type CampaignStatus = "draft" | "active" | "paused" | "completed" | "archived";

// Warning: (ae-missing-release-tag) "canonicalEventString" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `canonicalEventString`

```typescript
export function canonicalEventString(event: Omit<DomainEvent, "signature">, payloadHash: string): string;

// Warning: (ae-missing-release-tag) "canonicalize" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `canonicalize`

```typescript
export function canonicalize(value: unknown): string;

// Warning: (ae-missing-release-tag) "canonicalStateHash" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `canonicalStateHash`

```typescript
export function canonicalStateHash(toolName: string, args: unknown, outputSummary: string): string;

// Warning: (ae-missing-release-tag) "CapabilityGate" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CapabilityGate`

```typescript
export interface CapabilityGate {
    getExpiresAt?(): number;
    getIssuedAt?(): number;
    rotateToken?(newTokenB64: string, newExpiresAt: number): void;
    verify(call: CapabilityGateCall): CapabilityGateVerdict | Promise<CapabilityGateVerdict>;
}

// Warning: (ae-missing-release-tag) "CapabilityGateCall" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CapabilityGateCall`

```typescript
export interface CapabilityGateCall {
    readonly budgetUsed: number;
    readonly mcpScopes?: readonly string[];
    readonly toolName: string;
}

// Warning: (ae-missing-release-tag) "CapabilityGateVerdict" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CapabilityGateVerdict`

```typescript
export type CapabilityGateVerdict = {
    readonly allowed: true;
} | {
    readonly allowed: false;
    readonly reason: string;
};

// Warning: (ae-missing-release-tag) "CapabilityInvocation" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CapabilityInvocation`

```typescript
export interface CapabilityInvocation {
    readonly action: string;
    readonly dataClass: DataClass;
    readonly jurisdiction?: Jurisdiction;
    readonly legalBasis?: LegalBasisRef;
    readonly requiresConsent?: boolean;
    readonly requiresVerifiedHuman?: boolean;
    readonly stepIndex?: number;
    readonly tenantId: string;
    readonly workflowRunId?: string;
}

// Warning: (ae-missing-release-tag) "CapabilityScope" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CapabilityScope`

```typescript
export interface CapabilityScope {
    readonly capabilities: ReadonlyArray<string>;
    // Warning: (ae-forgotten-export) The symbol "Constraint" needs to be exported by the entry point index.d.ts
    //
    readonly constraints: ReadonlyArray<Constraint>;
    readonly expires_at: string;
    readonly jurisdictions: ReadonlyArray<string>;
}

// Warning: (ae-missing-release-tag) "capabilityToSdkPermissions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `capabilityToSdkPermissions`

```typescript
export function capabilityToSdkPermissions(scope: CcScope, tools: readonly string[]): MappedSdkPermissions;
```

### `CaptureResult`

```typescript
export interface CaptureResult {
    readonly candidateId?: string;
    readonly captured: boolean;
    readonly reason?: string;
}

// Warning: (ae-missing-release-tag) "captureSkillFromCycle" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `captureSkillFromCycle`

```typescript
export function captureSkillFromCycle(agentId: string, runId: string, trigger: LearningTrigger, outcome: OutcomeRecord | null, traceSummary: string, opts: SkillCaptureOptions, logger: LoggerPort): Promise<CaptureResult>;

// Warning: (ae-missing-release-tag) "CascadeAdapter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CascadeAdapter`

```typescript
export class CascadeAdapter implements LLMProviderPort {
    constructor(config: CascadeAdapterConfig);
    complete(req: ChatRequest): Promise<ChatResponse>;
    estimateCost(req: ChatRequest): {
        usd: number;
    };
    stream(req: ChatRequest): AsyncIterable<StreamDelta>;
}

// Warning: (ae-missing-release-tag) "CascadeAdapterConfig" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CascadeAdapterConfig`

```typescript
export interface CascadeAdapterConfig {
    providers: LLMProviderPort[];
}

// Warning: (ae-forgotten-export) The symbol "CboeVixSpotInput" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "cboeVixSpot" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `cboeVixSpot`

```typescript
export const cboeVixSpot: Skill<CboeVixSpotInput, CboeVixSpotOutput>;

// Warning: (ae-missing-release-tag) "CboeVixSpotOutput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CboeVixSpotOutput`

```typescript
export interface CboeVixSpotOutput {
    cached: boolean;
    delayed_minutes: number;
    fetched_at: string;
    last: number;
    symbol: "VIX";
}

// Warning: (ae-missing-release-tag) "CcScope" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CcScope`

```typescript
export type CcScope = "cc:read" | "cc:execute" | "cc:admin";

// Warning: (ae-missing-release-tag) "CfoView" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CfoView`

```typescript
export interface CfoView {
    burn_rate_per_day_cents: number;
    by_initiative: Array<{
        initiative_id: string;
        spent_cents: number;
        budget_cents: number | null;
        pct: number | null;
    }>;
    pending_value_estimate_cents: number;
    period: {
        from: string;
        to: string;
    };
    projected_30d_cents: number;
}
```

### `ChatMessage`

```typescript
export interface ChatMessage {
    content: string;
    role: "system" | "user" | "assistant";
}

// Warning: (ae-missing-release-tag) "ChatRequest" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ChatRequest`

```typescript
export interface ChatRequest {
    abortSignal?: AbortSignal;
    maxTokens?: number;
    messages: ChatMessage[];
    metadata?: {
        tenantId?: string;
        agentId?: string;
        correlationId?: string;
    };
    model?: string;
    temperature?: number;
}

// Warning: (ae-missing-release-tag) "ChatResponse" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ChatResponse`

```typescript
export interface ChatResponse {
    content: string;
    finishReason: "stop" | "length" | "tool" | "error";
    model: string;
    usage: ChatUsage;
}

// Warning: (ae-missing-release-tag) "ChatUsage" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ChatUsage`

```typescript
export interface ChatUsage {
    readonly cacheCreationTokens?: number;
    readonly cacheReadTokens?: number;
    costUsd?: number;
    inputTokens: number;
    outputTokens: number;
}
```

### `ChildAgentOptions`

```typescript
export interface ChildAgentOptions {
    agentId: string;
    handoffChain?: string[];
    maxChainDepth?: number;
    task: Record<string, unknown>;
    timeoutMs?: number;
}

// Warning: (ae-missing-release-tag) "ChildAgentPort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ChildAgentPort`

```typescript
export interface ChildAgentPort {
    spawnAsync(opts: ChildAgentOptions): Promise<{
        workerId: string;
    }>;
    spawnSync(opts: ChildAgentOptions): Promise<ChildAgentResult>;
}

// Warning: (ae-missing-release-tag) "ChildAgentResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ChildAgentResult`

```typescript
export interface ChildAgentResult {
    error?: string;
    output?: unknown;
    status: "accepted" | "completed" | "failed" | "timeout";
    workerId: string;
}

// Warning: (ae-missing-release-tag) "ChildWorkflowOpts" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ChildWorkflowOpts`

```typescript
export interface ChildWorkflowOpts {
    readonly idempotencyKey?: string;
    readonly tenantId?: string;
    readonly version?: string;
}

// Warning: (ae-missing-release-tag) "CircuitBreaker" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CircuitBreaker`

```typescript
export interface CircuitBreaker<TArgs extends unknown[], TResult> {
    (...args: TArgs): Promise<TResult>;
    readonly failureCount: number;
    reset(): void;
    readonly state: CircuitState;
}

// Warning: (ae-missing-release-tag) "circuitBreaker" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `circuitBreaker`

```typescript
export function circuitBreaker<TArgs extends unknown[], TResult>(fn: (...args: TArgs) => Promise<TResult>, options: CircuitBreakerOptions): CircuitBreaker<TArgs, TResult>;

// Warning: (ae-missing-release-tag) "CircuitBreakerConfig" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CircuitBreakerConfig`

```typescript
export interface CircuitBreakerConfig {
    cooldownMs: number;
    thresholdUsd: number;
    windowMs: number;
}

// Warning: (ae-missing-release-tag) "CircuitBreakerOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CircuitBreakerOptions`

```typescript
export interface CircuitBreakerOptions {
    failureThreshold?: number;
    isFailure?: (err: unknown) => boolean;
    name: string;
    now?: () => number;
    resetAfterMs?: number;
}

// Warning: (ae-missing-release-tag) "CircuitBreakerResetMode" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CircuitBreakerResetMode`

```typescript
export type CircuitBreakerResetMode = "cron-rth" | "admin-endpoint" | "never";

// Warning: (ae-missing-release-tag) "CircuitBreakerSnapshot" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CircuitBreakerSnapshot`

```typescript
export interface CircuitBreakerSnapshot {
    failure_count: number;
    last_failure: string | null;
    last_success: string | null;
    provider: string;
    reset_after_ms: number | null;
    state: "closed" | "open" | "half-open";
}

// Warning: (ae-missing-release-tag) "CircuitOpenError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CircuitOpenError`

```typescript
export class CircuitOpenError extends Error {
    constructor(circuitName: string, retryAfterMs: number);
    readonly circuitName: string;
    readonly retryAfterMs: number;
}

// Warning: (ae-missing-release-tag) "CircuitState" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CircuitState`

```typescript
export type CircuitState = "closed" | "open" | "half-open";

// Warning: (ae-missing-release-tag) "ActionContext" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CitadelActionContext`

```typescript
export interface CitadelActionContext {
    readonly agentId: string;
    readonly agentTier: AgentTier;
    readonly runId: string;
    readonly tenantId?: string;
}

// Warning: (ae-missing-release-tag) "CitadelActionPort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CitadelActionPort`

```typescript
export interface CitadelActionPort {
    createSprint(input: SprintInput, ctx: CitadelActionContext): Promise<SprintRef>;
    recordDecision(decision: DecisionInput, ctx: CitadelActionContext): Promise<DecisionClaim>;
    sealSprint(sprintId: string, evidence: VerificationEvidence, ctx: CitadelActionContext): Promise<SealedSprintClaim>;
    updateTaskStatus(ref: TaskRef, status: TaskStatus, ctx: CitadelActionContext): Promise<void>;
}

// Warning: (ae-missing-release-tag) "CitadelCampaignMcpClient" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CitadelCampaignMcpClient`

```typescript
export interface CitadelCampaignMcpClient {
    callTool(name: string, args: Record<string, unknown>): Promise<unknown>;
}

// Warning: (ae-missing-release-tag) "CitadelCampaignPort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CitadelCampaignPort`

```typescript
export interface CitadelCampaignPort {
    blockAction(action_id: string, reason: string, ctx: CitadelActionContext): Promise<void>;
    bumpEngagementScore(contact_id: string, delta: number, reason: string, ctx: CitadelActionContext): Promise<ContactRef>;
    claimAction(action_id: string, ctx: CitadelActionContext): Promise<CampaignActionRef | null>;
    completeAction(completion: ActionCompletion, ctx: CitadelActionContext): Promise<void>;
    createAction(input: CampaignActionInput, ctx: CitadelActionContext): Promise<CampaignActionRef>;
    createCampaign(input: CampaignInput, ctx: CitadelActionContext): Promise<CampaignRef>;
    findContactByEmail(email: string, ctx: CitadelActionContext): Promise<ContactRef | null>;
    getCampaign(slug: string, ctx: CitadelActionContext): Promise<CampaignRef | null>;
    listActions(filter: ActionFilter, ctx: CitadelActionContext): Promise<readonly CampaignActionRef[]>;
    updateAction(ref: string, update: CampaignActionPatch, ctx: CitadelActionContext): Promise<void>;
    updateCampaignStatus(slug: string, status: CampaignStatus, ctx: CitadelActionContext): Promise<void>;
    updateContactStatus(contact_id: string, status: string, ctx: CitadelActionContext): Promise<void>;
    upsertContact(input: ContactInput, ctx: CitadelActionContext): Promise<ContactRef>;
}

// Warning: (ae-missing-release-tag) "CitadelInvalidStateTransitionError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CitadelInvalidStateTransitionError`

```typescript
export class CitadelInvalidStateTransitionError extends Error {
    constructor(current_status: TaskStatus, requested_status: TaskStatus, cause?: unknown | undefined);
    readonly cause?: unknown | undefined;
    readonly current_status: TaskStatus;
    readonly requested_status: TaskStatus;
}

// Warning: (ae-missing-release-tag) "CitadelSprintNotActiveError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CitadelSprintNotActiveError`

```typescript
export class CitadelSprintNotActiveError extends Error {
    constructor(sprint_id: string, current_status: string, cause?: unknown | undefined);
    readonly cause?: unknown | undefined;
    readonly current_status: string;
    readonly sprint_id: string;
}

// Warning: (ae-missing-release-tag) "CitadelTaskRefNotFoundError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CitadelTaskRefNotFoundError`

```typescript
export class CitadelTaskRefNotFoundError extends Error {
    constructor(task_ref: string, cause?: unknown | undefined);
    readonly cause?: unknown | undefined;
    readonly task_ref: string;
}

// Warning: (ae-missing-release-tag) "CitadelTierViolationError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CitadelTierViolationError`

```typescript
export class CitadelTierViolationError extends Error {
    constructor(message: string, required_tier: AgentTier, actual_tier: AgentTier, operation: string, cause?: unknown | undefined);
    readonly actual_tier: AgentTier;
    readonly cause?: unknown | undefined;
    readonly operation: string;
    readonly required_tier: AgentTier;
}

// Warning: (ae-missing-release-tag) "classifyReason" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `classifyReason`

```typescript
export function classifyReason(reason: string): string;

// Warning: (ae-missing-release-tag) "_clearCboeVixCache" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `_clearCboeVixCache`

```typescript
export function _clearCboeVixCache(): void;

// Warning: (ae-missing-release-tag) "ClientPolicy" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ClientPolicy`

```typescript
export interface ClientPolicy {
    readonly allowed_actions: readonly ("swap" | "deposit" | "withdraw" | "transfer")[];
    // Warning: (ae-forgotten-export) The symbol "TokenAddress" needs to be exported by the entry point index.d.ts
    //
    readonly allowed_pairs: readonly [TokenAddress, TokenAddress][];
    readonly cache_ttl_seconds: number;
    readonly daily_volume_cap: string;
    readonly deposit_cap: string;
    readonly max_slippage_bps: number;
}

// Warning: (ae-missing-release-tag) "ClockExhaustedError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ClockExhaustedError`

```typescript
export class ClockExhaustedError extends Error {
    constructor(recorded: number, requested: number);
}

// Warning: (ae-missing-release-tag) "ClockPort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ClockPort`

```typescript
export interface ClockPort {
    now(): number;
}

// Warning: (ae-missing-release-tag) "ClockSkewError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ClockSkewError`

```typescript
export class ClockSkewError extends Error {
    constructor(skewMs: number);
    readonly skewMs: number;
}
```

### `CloudEvent`

```typescript
export interface CloudEvent {
    correlationid?: string;
    data?: unknown;
    datacontenttype?: string;
    dataschemaversion?: number;
    id: string;
    partitionkey?: string;
    source: string;
    specversion: "1.0";
    time: string;
    traceparent?: string;
    type: string;
}

// Warning: (ae-missing-release-tag) "CoherenceDetector" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CoherenceDetector`

```typescript
export interface CoherenceDetector {
    check(recentToolCalls: Array<{
        name: string;
        args: unknown;
    }>, stepsWithoutTool: number): {
        isLoop: boolean;
        isStall: boolean;
        score: number;
    };
}

// Warning: (ae-missing-release-tag) "CoherenceEpisode" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CoherenceEpisode`

```typescript
export interface CoherenceEpisode {
    isFalsePositive: boolean;
    stepCount: number;
    stopReason: string;
}

// Warning: (ae-missing-release-tag) "CoherenceModel" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CoherenceModel`

```typescript
export interface CoherenceModel {
    episodes: number;
    falsePositiveRate: number;
    lastUpdated: number;
    loopDetectionWindow: number;
    stallThreshold: number;
}

// Warning: (ae-missing-release-tag) "CompactionLLMFn" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CompactionLLMFn`

```typescript
export type CompactionLLMFn = (prompt: string) => Promise<string>;

// Warning: (ae-missing-release-tag) "CompactionReport" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CompactionReport`

```typescript
export interface CompactionReport {
    readonly summariesAdded: number;
    readonly tokensEstimatedAfter: number;
    readonly tokensEstimatedBefore: number;
    readonly turnsAfter: number;
    readonly turnsBefore: number;
}

// Warning: (ae-missing-release-tag) "CompactionSummary" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CompactionSummary`

```typescript
export interface CompactionSummary {
    readonly createdAt: number;
    readonly originalTokens: number;
    readonly text: string;
    readonly turnCount: number;
}

// Warning: (ae-missing-release-tag) "CompactOpts" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CompactOpts`

```typescript
export interface CompactOpts {
    readonly keepLast?: number;
}

// Warning: (ae-missing-release-tag) "compactToolLog" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `compactToolLog`

```typescript
export function compactToolLog(log: LogMessage[], opts?: {
    keepFirst?: number;
    keepLast?: number;
}): LogMessage[];

// Warning: (ae-missing-release-tag) "compactToolLogDecay" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `compactToolLogDecay`

```typescript
export function compactToolLogDecay(log: LogMessage[], config?: DecayCompactionConfig): LogMessage[];

// Warning: (ae-missing-release-tag) "compactToolLogGist" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `compactToolLogGist`

```typescript
export function compactToolLogGist(log: Array<{
    role: string;
    content: string;
    toolName?: string;
}>, llmFn: GistLLMFn, keepRecentN?: number, config?: GistCompressionConfig): Promise<Array<{
    role: string;
    content: string;
    toolName?: string;
}>>;

// Warning: (ae-missing-release-tag) "compileToSmt" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `compileToSmt`

```typescript
export function compileToSmt(spec: AxiomSpec): string;

// Warning: (ae-missing-release-tag) "completeRunStep" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `completeRunStep`

```typescript
export function completeRunStep(db: DbClient, stepId: string, payload: Record<string, unknown>): Promise<{
    leafHash: string;
}>;
```

### `ComplexAgentOptions`

```typescript
export interface ComplexAgentOptions<TObs, TOrient, TDecision, TAction, TFeedback> {
    act: (decision: TDecision, ctx: OODAContext) => Promise<TAction>;
    agentId: string;
    agentVersion?: string;
    decide: (orient: TOrient, ctx: OODAContext) => Promise<TDecision>;
    feedback: (input: TAction & {
        decision?: TDecision;
    }, ctx: OODAContext) => Promise<TFeedback>;
    hitlEscalationLevel?: "L2" | "L3";
    intervalMs: number;
    observe: (_: void, ctx: OODAContext) => Promise<TObs>;
    orient: (obs: TObs, ctx: OODAContext) => Promise<TOrient>;
    outcomeMapping?: (feedback: TFeedback) => OutcomeRecord | null;
    reflect?: (input: TAction & {
        decision: TDecision;
    }, ctx: OODAContext) => Promise<TFeedback>;
    riskGuards?: RiskGuard[];
    sessionGuards?: SessionGuard[];
}

// Warning: (ae-missing-release-tag) "ComplianceAuditResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ComplianceAuditResult`

```typescript
export interface ComplianceAuditResult {
    readonly auditClaimEmitted: boolean;
    readonly decision: "proceed" | "block" | "warn";
    readonly evaluatedRules: number;
    readonly violations: ComplianceViolation[];
}

// Warning: (ae-missing-release-tag) "ComplianceContract" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ComplianceContract`

```typescript
export interface ComplianceContract {
    readonly audit_format?: "json" | "pdf";
    readonly data_class: DataClass;
    readonly jurisdictions: Jurisdiction[];
    readonly legal_bases: LegalBasisDecl[];
    readonly mode: ComplianceMode;
    readonly retention: string;
    readonly rules: ComplianceRule[];
    readonly tier: string;
}

// Warning: (ae-missing-release-tag) "ComplianceContractPort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ComplianceContractPort`

```typescript
export interface ComplianceContractPort {
    postStep(invocation: CapabilityInvocation, contract: ComplianceContract, ctx: TenantContext): Promise<ComplianceAuditResult>;
    preStep(invocation: CapabilityInvocation, contract: ComplianceContract, ctx: TenantContext): Promise<ComplianceGate>;
    validateManifest(contract: ComplianceContract, opts?: {
        timeoutMs?: number;
    }): Promise<ManifestValidationResult>;
}

// Warning: (ae-missing-release-tag) "ComplianceEvaluationTimeoutError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ComplianceEvaluationTimeoutError`

```typescript
export class ComplianceEvaluationTimeoutError extends Error {
    constructor(timeoutMs: number, cause?: unknown | undefined);
    readonly cause?: unknown | undefined;
    readonly timeoutMs: number;
}

// Warning: (ae-missing-release-tag) "ComplianceGate" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ComplianceGate`

```typescript
export type ComplianceGate = {
    readonly decision: "proceed";
    readonly warnings: ComplianceViolation[];
} | {
    readonly decision: "block";
    readonly violation: ComplianceViolation;
};

// Warning: (ae-missing-release-tag) "ComplianceMode" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ComplianceMode`

```typescript
export type ComplianceMode = "strict" | "audit_only";

// Warning: (ae-missing-release-tag) "CompliancePolicyError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CompliancePolicyError`

```typescript
export class CompliancePolicyError extends Error {
    constructor(message: string, ruleId: string, cause?: unknown | undefined);
    readonly cause?: unknown | undefined;
    readonly ruleId: string;
}

// Warning: (ae-missing-release-tag) "ComplianceRule" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ComplianceRule`

```typescript
export interface ComplianceRule {
    readonly authority?: string;
    readonly enforcement: EnforcementLevel;
    readonly id: string;
    readonly jurisdiction: Jurisdiction;
    readonly legal_ref: LegalBasisRef;
    readonly rationale: string;
    readonly source: RuleSource;
}

// Warning: (ae-missing-release-tag) "ComplianceViolation" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ComplianceViolation`

```typescript
export interface ComplianceViolation {
    readonly articleRef: string;
    readonly description: string;
    readonly remediationHint?: string;
    readonly ruleId: string;
    readonly severity: "block" | "warn";
}

// Warning: (ae-missing-release-tag) "ComputeContext" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ComputeContext`

```typescript
export interface ComputeContext {
    signal?: AbortSignal;
}

// Warning: (ae-missing-release-tag) "computeIdempotencyKey" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `computeIdempotencyKey`

```typescript
export function computeIdempotencyKey(payload: IdempotencyKeyPayload): string;

// Warning: (ae-missing-release-tag) "computeJwkThumbprint" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `computeJwkThumbprint`

```typescript
export function computeJwkThumbprint(jwk: EcP256Jwk): string;
```

### `computeKellyFraction`

```typescript
export function computeKellyFraction(historicalTradeCount: number, expectedReturn: number, variance: number, config: {
    kelly_cap: number;
    kelly_bootstrap_fraction: number;
    bootstrap_trade_threshold: number;
}): {
    fraction: number;
    mode: "bootstrap" | "kelly";
};
```

### `computeQuality`

```typescript
export function computeQuality(inputs: QualityInputs): number;
```

### `computeQualityOrNull`

```typescript
export function computeQualityOrNull(inputs: ProductiveQualityInputs): number | null;
```

### `computeQualityWithBreakdown`

```typescript
export function computeQualityWithBreakdown(inputs: QualityInputs): QualityBreakdown;

// Warning: (ae-missing-release-tag) "computeRoi" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `computeRoi`

```typescript
export function computeRoi(input: ComputeRoiInput): ComputeRoiResult;

// Warning: (ae-missing-release-tag) "ComputeRoiInput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ComputeRoiInput`

```typescript
export interface ComputeRoiInput {
    costsCentsByOutcomeId?: Map<string, number>;
    outcomes: Outcome[];
}

// Warning: (ae-missing-release-tag) "ComputeRoiResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ComputeRoiResult`

```typescript
export interface ComputeRoiResult {
    netRoiPct: number | null;
    outcomeCount: number;
    pendingCount: number;
    totalCostCents: number;
    totalValueCents: number;
    valueToCostRatio: number | null;
}

// Warning: (ae-missing-release-tag) "computeStepHash" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `computeStepHash`

```typescript
export function computeStepHash(step: TraceStep, runId: string): Promise<string>;

// Warning: (ae-missing-release-tag) "Condition" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `Condition`

```typescript
export type Condition = {
    type: "budget_constraint";
    child_max_fraction: number;
} | {
    type: "scope_subset";
    parent_scope: string[];
    child_scope: string[];
} | {
    type: "no_pii_in_output";
    pii_count_var?: string;
} | {
    type: "cost_positive_roi";
    min_roi_ratio: number;
} | {
    type: "response_time";
    max_ms: number;
} | {
    type: "custom_smt";
    smt_fragment: string;
};

// Warning: (ae-forgotten-export) The symbol "ConnectRelayOptions" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "connectRelay" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `connectRelay`

```typescript
export function connectRelay(opts: ConnectRelayOptions): Promise<RelayConnection>;

// Warning: (ae-missing-release-tag) "ConsoleChannel" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ConsoleChannel`

```typescript
export class ConsoleChannel implements MessagingChannelPort {
    constructor(config?: ConsoleChannelConfig);
    sendAlert(level: AlertLevel, title: string, body: string): Promise<void>;
    sendMessage(target: string, text: string): Promise<void>;
}

// Warning: (ae-missing-release-tag) "ConsoleChannelConfig" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ConsoleChannelConfig`

```typescript
export interface ConsoleChannelConfig {
    stream?: NodeJS.WriteStream;
}

// Warning: (ae-missing-release-tag) "ConsumerMode" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ConsumerMode`

```typescript
export type ConsumerMode = "strict" | "permissive" | "audit_only";

// Warning: (ae-missing-release-tag) "ContactDirection" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ContactDirection`

```typescript
export type ContactDirection = "inbound" | "outbound";

// Warning: (ae-missing-release-tag) "ContactInput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ContactInput`

```typescript
export interface ContactInput {
    readonly campaign_slug: string;
    readonly direction: ContactDirection;
    readonly email?: string;
    readonly handle: string;
    readonly metadata?: Readonly<Record<string, unknown>>;
    readonly platform: string;
    readonly source?: string;
}

// Warning: (ae-missing-release-tag) "ContactRef" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ContactRef`

```typescript
export interface ContactRef {
    readonly campaign_slug: string;
    readonly contact_id: string;
    readonly email?: string;
    readonly engagement_score: number;
    readonly handle: string;
    readonly status: string;
}
```

### `ContainerExecutionOptions`

```typescript
export interface ContainerExecutionOptions {
    cpuQuota?: number;
    executionId?: string;
    extraEnv?: Record<string, string>;
    memoryMb?: number;
    mode?: string;
    networkMode?: "none" | "outbound" | "bridge";
    readOnlyRoot?: boolean;
    timeoutSeconds?: number;
}
```

### `ContainerRuntime`

```typescript
export class ContainerRuntime {
    constructor(opts?: ContainerRuntimeOptions);
    executeBinary<T = unknown>(command: string[], automationName: string, input: unknown, options?: BinaryExecutionOptions): Promise<ExecutionResult<T>>;
    executeContainer<T = unknown>(image: string, automationName: string, input: unknown, options?: ContainerExecutionOptions): Promise<ExecutionResult<T>>;
}
```

### `ContainerRuntimeOptions`

```typescript
export interface ContainerRuntimeOptions {
    defaultTimeoutSeconds?: number;
    sandbox?: SandboxExecutor;
    spawnFn?: ContainerSpawnFn;
}
```

### `ContainerSpawnFn`

```typescript
export type ContainerSpawnFn = (cmd: string, args: string[], opts: {
    env?: NodeJS.ProcessEnv;
    cwd?: string;
    stdio: ["pipe", "pipe", "pipe"];
    signal?: AbortSignal;
}) => ChildProcess;

// Warning: (ae-missing-release-tag) "ContentClaim" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ContentClaim`

```typescript
export interface ContentClaim {
    readonly anchor: ReadonlyArray<{
        readonly chain: "StarknetMainnet" | "StarknetL3Glacis";
        readonly tx_hash?: string;
    }>;
    readonly evidence: {
        readonly proof: string;
        readonly public_inputs: Record<string, unknown>;
    };
    readonly predicate: {
        readonly domain: "vauban.federation.message.v1";
        readonly body: Record<string, unknown>;
    };
    readonly revelation_mask: {
        readonly disclosed: string[];
        readonly committed: string[];
    };
    readonly subject: string;
    readonly temporal_frame: {
        readonly not_before: string;
        readonly not_after: string;
        readonly revoked_at?: string | null;
    };
}

// Warning: (ae-missing-release-tag) "ConversationContext" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ConversationContext`

```typescript
export class ConversationContext {
    constructor(opts?: ConversationContextOpts);
    addTurn(role: "user" | "assistant", content: string, meta?: Turn["meta"]): void;
    compact(llmFn: CompactionLLMFn, opts?: CompactOpts): Promise<CompactionReport>;
    estimatedTokens(): number;
    static fromJSON(snapshot: ConversationContextSnapshot): ConversationContext;
    maybeCompact(model: string, llmFn: CompactionLLMFn, threshold?: number): Promise<boolean>;
    get summaries(): readonly CompactionSummary[];
    toJSON(): ConversationContextSnapshot;
    toMessages(strategy: AgentStrategyName, systemPrompt?: string): string | LLMMessage[];
    get turnCount(): number;
    get turns(): readonly Turn[];
    get workingMemorySize(): number;
}

// Warning: (ae-missing-release-tag) "ConversationContextOpts" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ConversationContextOpts`

```typescript
export interface ConversationContextOpts {
    readonly workingMemorySize?: number;
}

// Warning: (ae-missing-release-tag) "ConversationContextSnapshot" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ConversationContextSnapshot`

```typescript
export interface ConversationContextSnapshot {
    readonly summaries: readonly CompactionSummary[];
    readonly turns: readonly Turn[];
    readonly version: 1;
    readonly workingMemorySize: number;
}

// Warning: (ae-missing-release-tag) "cosineSimilarity" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `cosineSimilarity`

```typescript
export function cosineSimilarity(a: number[], b: number[]): number;

// Warning: (ae-missing-release-tag) "CostEntry" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CostEntry`

```typescript
export interface CostEntry {
    agentId: string;
    costUsd: number;
    inputTokens: number;
    outputTokens: number;
    ts: number;
}

// Warning: (ae-missing-release-tag) "CostTier" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CostTier`

```typescript
export type CostTier = "low" | "medium" | "high";
```

### `createAgent`

```typescript
export function createAgent(cfg: AgentConfig): Agent;

// Warning: (ae-missing-release-tag) "createAgentConfigLoader" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `createAgentConfigLoader`

```typescript
export function createAgentConfigLoader<T = Record<string, unknown>>(opts: {
    db: DbClient;
    ttlMs?: number;
    defaultConfig?: T;
    columnName?: "config" | "extra";
}): AgentConfigLoader<T>;
```

### `createAgentFromConfig`

```typescript
export function createAgentFromConfig<TConfig = unknown, TObs = unknown, TOrient = unknown, TDecision = unknown, TAction = unknown, TFeedback = unknown>(deps: AgentFactoryDeps, config: AgentFactoryConfig<TConfig, TObs, TOrient, TDecision, TAction, TFeedback>): Promise<OODAAgent>;
```

### `createAgentMetrics`

```typescript
export function createAgentMetrics(opts?: CreateAgentMetricsOptions): AgentMetrics;
```

### `CreateAgentMetricsOptions`

```typescript
export interface CreateAgentMetricsOptions {
    prefix?: string;
    // Warning: (ae-forgotten-export) The symbol "Registry" needs to be exported by the entry point index.d.ts
    registry?: Registry;
}

// Warning: (ae-missing-release-tag) "createAgentRunTracker" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `createAgentRunTracker`

```typescript
export function createAgentRunTracker(db: DbClient): AgentRunTracker;

// Warning: (ae-missing-release-tag) "createAgentsClient" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `createAgentsClient`

```typescript
export function createAgentsClient(opts: AgentsClientOptions): AgentsClient;

// Warning: (ae-missing-release-tag) "createBrainCompactionLlmFn" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `createBrainCompactionLlmFn`

```typescript
export function createBrainCompactionLlmFn(semanticMemory: SemanticMemoryPort, localLlmFn: CompactionLLMFn, sessionTag: string): CompactionLLMFn;

// Warning: (ae-missing-release-tag) "createBudgetState" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `createBudgetState`

```typescript
export function createBudgetState(overrides?: Partial<AgentBudgetState>): AgentBudgetState;

// Warning: (ae-missing-release-tag) "createBulkhead" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `createBulkhead`

```typescript
export function createBulkhead<T>(opts: OrchestrationBulkheadOptions): BulkheadPool<T>;

// Warning: (ae-missing-release-tag) "createBullMQRunner" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `createBullMQRunner`

```typescript
export function createBullMQRunner(config: BullMQRunnerConfig): BullMQRunner;

// Warning: (ae-missing-release-tag) "createCitadelCampaignMcpAdapter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `createCitadelCampaignMcpAdapter`

```typescript
export function createCitadelCampaignMcpAdapter(client: CitadelCampaignMcpClient): CitadelCampaignPort;

// Warning: (ae-missing-release-tag) "createCoherenceDetector" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `createCoherenceDetector`

```typescript
export function createCoherenceDetector(config?: {
    loopDetectionWindow?: number;
    stallThreshold?: number;
}): CoherenceDetector;
```

### `createComplexAgent`

```typescript
export function createComplexAgent<TObs, TOrient, TDecision, TAction, TFeedback>(deps: AgentFactoryDeps, opts: ComplexAgentOptions<TObs, TOrient, TDecision, TAction, TFeedback>): Promise<OODAAgent>;

// Warning: (ae-forgotten-export) The symbol "DiscordAdapterOptions" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "createDiscordAdapter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `createDiscordAdapter`

```typescript
export function createDiscordAdapter(opts: DiscordAdapterOptions): GatewayAdapter;

// Warning: (ae-missing-release-tag) "createEd25519Signer" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `createEd25519Signer`

```typescript
export function createEd25519Signer(privateKey: KeyObject): SignFn;

// Warning: (ae-missing-release-tag) "createEd25519Verifier" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `createEd25519Verifier`

```typescript
export function createEd25519Verifier(publicKey: KeyObject): VerifyFn;

// Warning: (ae-missing-release-tag) "createGateway" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `createGateway`

```typescript
export function createGateway(opts: GatewayOptions): GatewayHandle;

// Warning: (ae-missing-release-tag) "createHttpBrainAdapter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `createHttpBrainAdapter`

```typescript
export function createHttpBrainAdapter(opts: HttpBrainAdapterOptions): BrainPort;

// Warning: (ae-missing-release-tag) "createMaxInputLengthGuard" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `createMaxInputLengthGuard`

```typescript
export function createMaxInputLengthGuard(maxChars: number): GuardrailDef<string>;

// Warning: (ae-missing-release-tag) "createMeshDelegate" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `createMeshDelegate`

```typescript
export function createMeshDelegate(dispatcher: MeshDispatcher): <T = string>(options: DelegateOptions) => Promise<DelegateResult<T>>;

// Warning: (ae-forgotten-export) The symbol "SlackCallbackHandlerOpts" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "createNodeSlackCallbackHandler" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `createNodeSlackCallbackHandler`

```typescript
export function createNodeSlackCallbackHandler(opts: SlackCallbackHandlerOpts): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
```

### `createOneShotStrategy`

```typescript
export function createOneShotStrategy(): AgentStrategy;

// Warning: (ae-missing-release-tag) "createOODAAgent" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `createOODAAgent`

```typescript
export function createOODAAgent<TConfig = unknown, TObs = unknown, TOrient = unknown, TDecision = unknown, TAction = unknown, TFeedback = unknown>(config: OODAAgentConfig<TConfig, TObs, TOrient, TDecision, TAction, TFeedback>): OODAAgent;
```

### `createOODAStrategy`

```typescript
export function createOODAStrategy(invoker: OODACycleInvoker): AgentStrategy;

// Warning: (ae-forgotten-export) The symbol "OtelClientOptions" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "createOtelClient" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `createOtelClient`

```typescript
export function createOtelClient(opts: OtelClientOptions): OtelClient;

// Warning: (ae-missing-release-tag) "createOutcomesClient" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `createOutcomesClient`

```typescript
export function createOutcomesClient(opts: OutcomesClientOptions): OutcomesClient;

// Warning: (ae-missing-release-tag) "createPipelinesClient" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `createPipelinesClient`

```typescript
export function createPipelinesClient(opts: PipelinesClientOptions): PipelinesClient;
```

### `createPlanStrategy`

```typescript
export function createPlanStrategy(): AgentStrategy;

// Warning: (ae-forgotten-export) The symbol "ProviderRouterOptions" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "createProviderRouter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `createProviderRouter`

```typescript
export function createProviderRouter(opts?: ProviderRouterOptions): ProviderRouter;

// Warning: (ae-missing-release-tag) "createPublisherRegistry" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `createPublisherRegistry`

```typescript
export function createPublisherRegistry(input: PublisherRegistryInput): PublisherRegistry;
```

### `createReactStrategy`

```typescript
export function createReactStrategy(): AgentStrategy;

// Warning: (ae-forgotten-export) The symbol "ReasoningAgentOptions" needs to be exported by the entry point index.d.ts
//
```

### `createReasoningAgent`

```typescript
export function createReasoningAgent<TObs, TOrient, TDecision, TAction, TFeedback>(deps: AgentFactoryDeps, opts: ReasoningAgentOptions<TObs, TOrient, TDecision, TAction, TFeedback>): Promise<OODAAgent>;

// Warning: (ae-forgotten-export) The symbol "RemoteApprovalOptions" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "createRemoteApprovalChannel" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `createRemoteApprovalChannel`

```typescript
export function createRemoteApprovalChannel(opts: RemoteApprovalOptions): RemoteApprovalChannel;

// Warning: (ae-forgotten-export) The symbol "RemoteControlHubOptions" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "createRemoteControlHub" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `createRemoteControlHub`

```typescript
export function createRemoteControlHub(opts?: RemoteControlHubOptions): RemoteControlPort;

// Warning: (ae-forgotten-export) The symbol "RemoteControlServerOptions" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "createRemoteControlServer" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `createRemoteControlServer`

```typescript
export function createRemoteControlServer(port: RemoteControlPort, opts?: RemoteControlServerOptions): Promise<RemoteControlServerHandle>;

// Warning: (ae-missing-release-tag) "createRunsClient" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `createRunsClient`

```typescript
export function createRunsClient(opts: RunsClientOptions): RunsClient;

// Warning: (ae-forgotten-export) The symbol "SimpleAgentOptions" needs to be exported by the entry point index.d.ts
//
```

### `createSimpleAgent`

```typescript
export function createSimpleAgent<TContext, TOrient, TFeedback>(deps: AgentFactoryDeps, opts: SimpleAgentOptions<TContext, TOrient, TFeedback>): Promise<OODAAgent>;
```

### `createSkillContext`

```typescript
export function createSkillContext(opts: CreateSkillContextOptions): SkillContext;
```

### `CreateSkillContextOptions`

```typescript
export interface CreateSkillContextOptions {
    db: DbClient;
    dryRunMocks?: Record<string, (input: unknown) => unknown>;
    executionId?: string;
    isReplay?: boolean;
    logger: LoggerPort;
    progress?: ProgressCallback;
    secrets?: SecretsAccessor;
    startedAt?: Date;
    timeoutSeconds?: number;
}

// Warning: (ae-forgotten-export) The symbol "SlackAdapterOptions" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "createSlackAdapter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `createSlackAdapter`

```typescript
export function createSlackAdapter(opts: SlackAdapterOptions): GatewayAdapter;

// Warning: (ae-forgotten-export) The symbol "TelegramAdapterOptions" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "createTelegramAdapter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `createTelegramAdapter`

```typescript
export function createTelegramAdapter(opts: TelegramAdapterOptions): GatewayAdapter;

// Warning: (ae-missing-release-tag) "createTelemetryBus" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `createTelemetryBus`

```typescript
export function createTelemetryBus(opts: TelemetryBusOptions): TelemetrySink & {
    counters: TelemetryCounters;
    flush(): Promise<void>;
};
```

### `createUnconfiguredOODAInvoker`

```typescript
export function createUnconfiguredOODAInvoker(): OODACycleInvoker;

// Warning: (ae-missing-release-tag) "CriticHistoryEntry" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CriticHistoryEntry`

```typescript
export interface CriticHistoryEntry {
    discrepancy: string;
    round: number;
}

// Warning: (ae-missing-release-tag) "criticLoop" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `criticLoop`

```typescript
export function criticLoop<T>(initial: T, verify: CriticVerifier<T>, revise: (current: T, discrepancy: string) => Promise<T>, maxRounds?: number): Promise<CriticResult<T>>;

// Warning: (ae-missing-release-tag) "CriticResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CriticResult`

```typescript
export interface CriticResult<T> {
    history: CriticHistoryEntry[];
    output: T;
    rounds: number;
    verified: boolean;
}

// Warning: (ae-missing-release-tag) "CriticVerifier" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CriticVerifier`

```typescript
export type CriticVerifier<T> = (output: T) => Promise<{
    ok: true;
} | {
    ok: false;
    discrepancy: string;
}>;

// Warning: (ae-missing-release-tag) "cronSessionGuard" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `cronSessionGuard`

```typescript
export function cronSessionGuard(expr: string): SessionGuard;

// Warning: (ae-missing-release-tag) "CryptoRandomDuringReplayError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CryptoRandomDuringReplayError`

```typescript
export class CryptoRandomDuringReplayError extends Error {
    constructor();
}

// Warning: (ae-missing-release-tag) "CycleCost" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CycleCost`

```typescript
export interface CycleCost {
    category?: string;
    costUsd: number;
    durationMs: number;
    inputTokens: number;
    modelTier: string;
    outcomeValue?: number;
    outputTokens: number;
    runId: string;
    skillId?: string;
}
```

### `CycleEvent`

```typescript
export type CycleEvent = CycleEventV010 | CycleEventV011;
```

### `CycleEventV010`

```typescript
export type CycleEventV010 = {
    type: "phase_start";
    runId: string;
    cycleIndex: number;
    phase: string;
    ts: number;
} | {
    type: "phase_complete";
    runId: string;
    cycleIndex: number;
    phase: string;
    durationMs: number;
    ts: number;
} | {
    type: "phase_error";
    runId: string;
    cycleIndex: number;
    phase: string;
    error: {
        message: string;
    };
    ts: number;
} | {
    type: "guard_tripped";
    runId: string;
    cycleIndex: number;
    guard: string;
    reason: string;
    ts: number;
} | {
    type: "hitl_waiting";
    runId: string;
    cycleIndex: number;
    stepId: string;
    payloadHash: string;
    ts: number;
} | {
    type: "hitl_approved";
    runId: string;
    cycleIndex: number;
    stepId: string;
    ts: number;
} | {
    type: "cycle_complete";
    runId: string;
    cycleIndex: number;
    status: CycleStatus;
    durationMs: number;
    ts: number;
} | {
    type: "cycle_skipped";
    runId: string;
    cycleIndex: number;
    reason: string;
    ts: number;
} | {
    type: "cycle_error";
    runId: string;
    cycleIndex: number;
    error: {
        message: string;
    };
    ts: number;
} | {
    type: "timestamp_pending";
    runId: string;
    cycleIndex: number;
    rootHash: string;
    ts: number;
};
```

### `CycleEventV011`

```typescript
export type CycleEventV011 = {
    type: "guardrail_violated";
    runId: string;
    cycleIndex: number;
    phase: string;
    timing: "pre-phase" | "post-phase";
    proofHash: string;
    reason: string;
    ts: number;
} | {
    type: "handoff_initiated";
    runId: string;
    cycleIndex: number;
    targetAgentId: string;
    childRunId: string;
    handoffChain: string[];
    ts: number;
} | {
    type: "cycle_proven";
    runId: string;
    cycleIndex: number;
    rootHash: string;
    entriesCount: number;
    proofChainRef: string;
    ts: number;
};

// Warning: (ae-missing-release-tag) "CycleMetadata" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CycleMetadata`

```typescript
export interface CycleMetadata {
    [key: string]: unknown;
    audit_trail_complete?: boolean;
    error_paths_explicit?: boolean;
    has_fallback?: boolean;
    hash_primitive?: string;
    is_idempotent?: boolean;
    model_name?: string;
    model_provider?: string;
    pii_redacted?: boolean;
    regulatory_scope?: string;
    rso_veto?: boolean;
    slsa_level?: number;
    source_count?: number;
    timeouts_configured?: boolean;
}

// Warning: (ae-missing-release-tag) "CycleSnapshot" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CycleSnapshot`

```typescript
export interface CycleSnapshot {
    budgetUsdMax: number;
    budgetUsdSpent: number;
    metadata?: CycleMetadata;
    parentRunId?: string;
    rootHash: string;
    runId: string;
    scope_id?: string;
    steps: CycleStep[];
}

// Warning: (ae-missing-release-tag) "cycleSnapshotSchema" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `cycleSnapshotSchema`

```typescript
export const cycleSnapshotSchema: z.ZodObject<{
    runId: z.ZodString;
    parentRunId: z.ZodOptional<z.ZodString>;
    steps: z.ZodArray<z.ZodObject<{
        index: z.ZodNumber;
        phase: z.ZodString;
        type: z.ZodString;
        output: z.ZodOptional<z.ZodUnknown>;
        storedInput: z.ZodOptional<z.ZodUnknown>;
        model: z.ZodOptional<z.ZodObject<{
            provider: z.ZodString;
            name: z.ZodString;
            version: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            provider: string;
            name: string;
            version: string;
        }, {
            provider: string;
            name: string;
            version: string;
        }>>;
        toolName: z.ZodOptional<z.ZodString>;
        costUsd: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        type: string;
        phase: string;
        index: number;
        model?: {
            provider: string;
            name: string;
            version: string;
        } | undefined;
        costUsd?: number | undefined;
        toolName?: string | undefined;
        output?: unknown;
        storedInput?: unknown;
    }, {
        type: string;
        phase: string;
        index: number;
        model?: {
            provider: string;
            name: string;
            version: string;
        } | undefined;
        costUsd?: number | undefined;
        toolName?: string | undefined;
        output?: unknown;
        storedInput?: unknown;
    }>, "many">;
    budgetUsdMax: z.ZodNumber;
    budgetUsdSpent: z.ZodNumber;
    scope_id: z.ZodOptional<z.ZodString>;
    metadata: z.ZodOptional<z.ZodObject<{
        rso_veto: z.ZodOptional<z.ZodBoolean>;
        hash_primitive: z.ZodOptional<z.ZodString>;
        has_fallback: z.ZodOptional<z.ZodBoolean>;
        is_idempotent: z.ZodOptional<z.ZodBoolean>;
        source_count: z.ZodOptional<z.ZodNumber>;
        model_provider: z.ZodOptional<z.ZodString>;
        model_name: z.ZodOptional<z.ZodString>;
        slsa_level: z.ZodOptional<z.ZodNumber>;
        timeouts_configured: z.ZodOptional<z.ZodBoolean>;
        error_paths_explicit: z.ZodOptional<z.ZodBoolean>;
        pii_redacted: z.ZodOptional<z.ZodBoolean>;
        audit_trail_complete: z.ZodOptional<z.ZodBoolean>;
        regulatory_scope: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        rso_veto: z.ZodOptional<z.ZodBoolean>;
        hash_primitive: z.ZodOptional<z.ZodString>;
        has_fallback: z.ZodOptional<z.ZodBoolean>;
        is_idempotent: z.ZodOptional<z.ZodBoolean>;
        source_count: z.ZodOptional<z.ZodNumber>;
        model_provider: z.ZodOptional<z.ZodString>;
        model_name: z.ZodOptional<z.ZodString>;
        slsa_level: z.ZodOptional<z.ZodNumber>;
        timeouts_configured: z.ZodOptional<z.ZodBoolean>;
        error_paths_explicit: z.ZodOptional<z.ZodBoolean>;
        pii_redacted: z.ZodOptional<z.ZodBoolean>;
        audit_trail_complete: z.ZodOptional<z.ZodBoolean>;
        regulatory_scope: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        rso_veto: z.ZodOptional<z.ZodBoolean>;
        hash_primitive: z.ZodOptional<z.ZodString>;
        has_fallback: z.ZodOptional<z.ZodBoolean>;
        is_idempotent: z.ZodOptional<z.ZodBoolean>;
        source_count: z.ZodOptional<z.ZodNumber>;
        model_provider: z.ZodOptional<z.ZodString>;
        model_name: z.ZodOptional<z.ZodString>;
        slsa_level: z.ZodOptional<z.ZodNumber>;
        timeouts_configured: z.ZodOptional<z.ZodBoolean>;
        error_paths_explicit: z.ZodOptional<z.ZodBoolean>;
        pii_redacted: z.ZodOptional<z.ZodBoolean>;
        audit_trail_complete: z.ZodOptional<z.ZodBoolean>;
        regulatory_scope: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    rootHash: z.ZodString;
}, "strict", z.ZodTypeAny, {
    runId: string;
    rootHash: string;
    steps: {
        type: string;
        phase: string;
        index: number;
        model?: {
            provider: string;
            name: string;
            version: string;
        } | undefined;
        costUsd?: number | undefined;
        toolName?: string | undefined;
        output?: unknown;
        storedInput?: unknown;
    }[];
    budgetUsdMax: number;
    budgetUsdSpent: number;
    metadata?: z.objectOutputType<{
        rso_veto: z.ZodOptional<z.ZodBoolean>;
        hash_primitive: z.ZodOptional<z.ZodString>;
        has_fallback: z.ZodOptional<z.ZodBoolean>;
        is_idempotent: z.ZodOptional<z.ZodBoolean>;
        source_count: z.ZodOptional<z.ZodNumber>;
        model_provider: z.ZodOptional<z.ZodString>;
        model_name: z.ZodOptional<z.ZodString>;
        slsa_level: z.ZodOptional<z.ZodNumber>;
        timeouts_configured: z.ZodOptional<z.ZodBoolean>;
        error_paths_explicit: z.ZodOptional<z.ZodBoolean>;
        pii_redacted: z.ZodOptional<z.ZodBoolean>;
        audit_trail_complete: z.ZodOptional<z.ZodBoolean>;
        regulatory_scope: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough"> | undefined;
    parentRunId?: string | undefined;
    scope_id?: string | undefined;
}, {
    runId: string;
    rootHash: string;
    steps: {
        type: string;
        phase: string;
        index: number;
        model?: {
            provider: string;
            name: string;
            version: string;
        } | undefined;
        costUsd?: number | undefined;
        toolName?: string | undefined;
        output?: unknown;
        storedInput?: unknown;
    }[];
    budgetUsdMax: number;
    budgetUsdSpent: number;
    metadata?: z.objectInputType<{
        rso_veto: z.ZodOptional<z.ZodBoolean>;
        hash_primitive: z.ZodOptional<z.ZodString>;
        has_fallback: z.ZodOptional<z.ZodBoolean>;
        is_idempotent: z.ZodOptional<z.ZodBoolean>;
        source_count: z.ZodOptional<z.ZodNumber>;
        model_provider: z.ZodOptional<z.ZodString>;
        model_name: z.ZodOptional<z.ZodString>;
        slsa_level: z.ZodOptional<z.ZodNumber>;
        timeouts_configured: z.ZodOptional<z.ZodBoolean>;
        error_paths_explicit: z.ZodOptional<z.ZodBoolean>;
        pii_redacted: z.ZodOptional<z.ZodBoolean>;
        audit_trail_complete: z.ZodOptional<z.ZodBoolean>;
        regulatory_scope: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough"> | undefined;
    parentRunId?: string | undefined;
    scope_id?: string | undefined;
}>;

// Warning: (ae-missing-release-tag) "CycleStatus" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CycleStatus`

```typescript
export type CycleStatus = "succeeded" | "failed" | "skipped";

// Warning: (ae-missing-release-tag) "CycleStep" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `CycleStep`

```typescript
export interface CycleStep {
    costUsd?: number;
    index: number;
    model?: {
        provider: string;
        name: string;
        version: string;
    };
    output?: unknown;
    phase: string;
    storedInput?: unknown;
    toolName?: string;
    type: string;
}

// Warning: (ae-missing-release-tag) "dangerousToRiskVector" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `dangerousToRiskVector`

```typescript
export function dangerousToRiskVector(dangerous?: boolean): RiskVector;

// Warning: (ae-missing-release-tag) "DataClass" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DataClass`

```typescript
export type DataClass = "public" | "internal" | "confidential" | "secret";

// Warning: (ae-missing-release-tag) "DbClient" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `__unknown`

```typescript
interface DbClient {
    query<T extends object>(sql: string, params?: unknown[]): Promise<{
        rows: T[];
        rowCount?: number;
    }>;
}
export { DbClient }
export { DbClient as DbPort }

// Warning: (ae-missing-release-tag) "DbConnectionLost" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DbConnectionLost`

```typescript
export class DbConnectionLost extends PortError {
    constructor(message?: string, cause?: unknown);
    readonly port = "db";
}

// Warning: (ae-missing-release-tag) "DbConnectionLostError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DbConnectionLostError`

```typescript
export class DbConnectionLostError extends Error {
    constructor(message: string, cause?: unknown | undefined);
    readonly cause?: unknown | undefined;
}

// Warning: (ae-missing-release-tag) "DbQueryError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DbQueryError`

```typescript
export class DbQueryError extends PortError {
    constructor(opts: {
        message: string;
        cause?: unknown;
        sqlPreview?: string;
    });
    readonly port = "db";
    readonly sqlPreview?: string;
}

// Warning: (ae-missing-release-tag) "DbQueryTimeoutError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DbQueryTimeoutError`

```typescript
export class DbQueryTimeoutError extends Error {
    constructor(message: string, queryPreview: string, timeoutMs: number, cause?: unknown | undefined);
    readonly cause?: unknown | undefined;
    readonly queryPreview: string;
    readonly timeoutMs: number;
}

// Warning: (ae-missing-release-tag) "DeadlineExceededError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DeadlineExceededError`

```typescript
export class DeadlineExceededError extends Error {
    constructor(message?: string);
    readonly name = "DeadlineExceededError";
}

// Warning: (ae-missing-release-tag) "DebateConfig" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DebateConfig`

```typescript
export interface DebateConfig {
    context?: string;
    maxRounds?: number;
    question: string;
    skeptic: (question: string, thesis: DebateStance, context?: string) => Promise<DebateStance>;
    strategist: (question: string, context?: string) => Promise<DebateStance>;
    synthesizer: (question: string, thesis: DebateStance, antithesis: DebateStance, context?: string) => Promise<DebateSynthesis>;
}

// Warning: (ae-missing-release-tag) "DebateResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DebateResult`

```typescript
export interface DebateResult {
    antithesis: DebateStance;
    rounds: number;
    synthesis: DebateSynthesis;
    thesis: DebateStance;
}
```

### `DebateStance`

```typescript
export interface DebateStance {
    confidence: number;
    content: string;
    keyPoints: string[];
    risks: string[];
}

// Warning: (ae-missing-release-tag) "DebateSynthesis" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DebateSynthesis`

```typescript
export interface DebateSynthesis {
    conclusion: string;
    consensusScore: number;
    hitlRecommended: boolean;
    recommendation: string;
    tradeoffs: string[];
}

// Warning: (ae-missing-release-tag) "DecayCompactionConfig" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DecayCompactionConfig`

```typescript
export interface DecayCompactionConfig {
    errorBonus?: number;
    halfLifeTurns?: number;
    keepTopK?: number;
}

// Warning: (ae-missing-release-tag) "DecisionClaim" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DecisionClaim`

```typescript
export interface DecisionClaim {
    readonly archived_to_brain: boolean;
    readonly cascade_triggered?: boolean;
    readonly created_at: Date;
    readonly decision_id: string;
}

// Warning: (ae-missing-release-tag) "DecisionInput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DecisionInput`

```typescript
export interface DecisionInput {
    readonly chosen: string;
    readonly context: string;
    readonly decision: string;
    readonly options: readonly string[];
    readonly rationale: string;
    readonly tags?: readonly string[];
}

// Warning: (ae-missing-release-tag) "decodePairingPayload" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `decodePairingPayload`

```typescript
export function decodePairingPayload(uri: string): PairingPayload;

// Warning: (ae-missing-release-tag) "decomposeTask" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `decomposeTask`

```typescript
export function decomposeTask(task: string, decomposer: (task: string) => Promise<Plan>): Promise<Plan>;

// Warning: (ae-missing-release-tag) "DEFAULT_BACKOFF_MS" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DEFAULT_BACKOFF_MS`

```typescript
export const DEFAULT_BACKOFF_MS: readonly [30000, number, number, number, number];

// Warning: (ae-missing-release-tag) "DEFAULT_INSTRUCTION_PATTERNS" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DEFAULT_INSTRUCTION_PATTERNS`

```typescript
export const DEFAULT_INSTRUCTION_PATTERNS: RegExp[];

// Warning: (ae-missing-release-tag) "DEFAULT_PERSONA" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DEFAULT_PERSONA`

```typescript
export const DEFAULT_PERSONA: AgentPersona;

// Warning: (ae-missing-release-tag) "DEFAULT_POLICIES" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DEFAULT_POLICIES`

```typescript
export const DEFAULT_POLICIES: Record<string, AxiomPolicy>;
```

### `DEFAULT_PROTOCOL_MODE`

```typescript
export const DEFAULT_PROTOCOL_MODE = "execute";

// Warning: (ae-missing-release-tag) "DEFAULT_RECENCY_HALFLIFE_MS" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DEFAULT_RECENCY_HALFLIFE_MS`

```typescript
export const DEFAULT_RECENCY_HALFLIFE_MS: number;

// Warning: (ae-missing-release-tag) "DEFAULT_RESOURCE_LIMITS" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DEFAULT_RESOURCE_LIMITS`

```typescript
export const DEFAULT_RESOURCE_LIMITS: Required<ResourceLimits>;

// Warning: (ae-missing-release-tag) "DEFAULT_RRF_WEIGHTS" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DEFAULT_RRF_WEIGHTS`

```typescript
export const DEFAULT_RRF_WEIGHTS: {
    readonly cosine: 0.5;
    readonly recency: 0.3;
    readonly importance: 0.2;
};

// Warning: (ae-missing-release-tag) "defaultCoherenceModel" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `defaultCoherenceModel`

```typescript
export function defaultCoherenceModel(): CoherenceModel;

// Warning: (ae-missing-release-tag) "DefaultMeshDispatcher" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DefaultMeshDispatcher`

```typescript
export class DefaultMeshDispatcher implements MeshDispatcher {
    constructor(config?: DispatcherConfig);
    classify(need: string): MeshAgentKind;
    dispatch(intent: DispatchIntent): Promise<DispatchResult>;
}

// Warning: (ae-missing-release-tag) "defaultPolicy" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `defaultPolicy`

```typescript
export function defaultPolicy(env: "dev" | "prod", piiFields?: readonly string[]): PayloadPolicy;

// Warning: (ae-missing-release-tag) "defaultScorerRegistry" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `defaultScorerRegistry`

```typescript
export const defaultScorerRegistry: ScorerRegistry;

// Warning: (ae-missing-release-tag) "DefaultTierPolicy" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DefaultTierPolicy`

```typescript
export class DefaultTierPolicy implements TierPolicy {
    tiersFor(category: string, _mode: "degraded" | "full"): ModelTier[];
}

// Warning: (ae-missing-release-tag) "DegradedMetrics" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DegradedMetrics`

```typescript
export interface DegradedMetrics {
    readonly episodes_count: number;
    readonly pct_time_degraded: number;
    readonly total_degraded_last_90d: number;
}

// Warning: (ae-missing-release-tag) "DegradedModeExhaustedError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DegradedModeExhaustedError`

```typescript
export class DegradedModeExhaustedError extends Error {
    constructor(tenantId: string, totalDegradedSeconds: number, capSeconds: number);
    readonly capSeconds: number;
    readonly tenantId: string;
    readonly totalDegradedSeconds: number;
}

// Warning: (ae-missing-release-tag) "DegradedResponse" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DegradedResponse`

```typescript
export interface DegradedResponse {
    readonly fallback: "UNGROUNDED";
    readonly reason: string;
    readonly stale_since: string;
    readonly status: "degraded";
}

// Warning: (ae-missing-release-tag) "DelegateAttenuationError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DelegateAttenuationError`

```typescript
export class DelegateAttenuationError extends Error {
    readonly name = "DelegateAttenuationError";
}

// Warning: (ae-missing-release-tag) "DelegateChunk" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DelegateChunk`

```typescript
export interface DelegateChunk {
    readonly agentKind?: MeshAgentKind;
    readonly done: boolean;
    readonly text: string;
}

// Warning: (ae-missing-release-tag) "DelegateOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DelegateOptions`

```typescript
export interface DelegateOptions {
    readonly capabilities?: ReadonlyArray<string>;
    readonly childId?: string;
    readonly context?: string | Record<string, unknown>;
    readonly deadline_ms?: number;
    readonly kind?: MeshAgentKind;
    readonly max_cost_eur?: number;
    readonly need: string;
    readonly onChunk?: (chunk: DelegateChunk) => void;
    readonly parentToken?: AttenuatedToken;
    readonly toolArgs?: unknown;
    readonly toolName?: string;
}

// Warning: (ae-missing-release-tag) "DelegateResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DelegateResult`

```typescript
export interface DelegateResult<T = string> {
    readonly agentKind: MeshAgentKind;
    readonly childToken?: AttenuatedToken;
    readonly costEur: number;
    readonly delegationChain: ReadonlyArray<MeshDelegationLink>;
    readonly durationMs: number;
    readonly output: T;
    readonly truncated: boolean;
}

// Warning: (ae-missing-release-tag) "DelegationChainTooDeepError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DelegationChainTooDeepError`

```typescript
export class DelegationChainTooDeepError extends Error {
    constructor(claimId: string, depth: number, maxDepth: number);
    readonly claimId: string;
    readonly depth: number;
    readonly maxDepth: number;
}

// Warning: (ae-missing-release-tag) "DelegationClaim" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DelegationClaim`

```typescript
export interface DelegationClaim {
    readonly created_at: string;
    readonly ed25519_sig: string;
    readonly holder: string;
    readonly id: string;
    readonly issuer: string;
    readonly parent_id?: string;
    readonly revoked_at?: string | null;
    readonly scope: CapabilityScope;
    readonly ttl: number;
}

// Warning: (ae-missing-release-tag) "DelegationExpiredError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DelegationExpiredError`

```typescript
export class DelegationExpiredError extends Error {
    constructor(claimId: string, expiresAt: string);
    readonly claimId: string;
    readonly expiresAt: string;
}

// Warning: (ae-missing-release-tag) "DelegationNotNarrowingError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DelegationNotNarrowingError`

```typescript
export class DelegationNotNarrowingError extends Error {
    constructor(parentId: string, childId: string, violationType: string);
    readonly childId: string;
    readonly parentId: string;
    readonly violationType: string;
}

// Warning: (ae-missing-release-tag) "DelegationPort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DelegationPort`

```typescript
export interface DelegationPort {
    getChain(claimId: string): Promise<DelegationClaim[]>;
    getClaim(claimId: string): Promise<DelegationClaim | null>;
    getDescendants(claimId: string): Promise<DelegationClaim[]>;
    isRevoked(claimId: string): Promise<boolean>;
    // Warning: (ae-forgotten-export) The symbol "RootCapability" needs to be exported by the entry point index.d.ts
    mintDelegation(parent: DelegationClaim | RootCapability, narrowed: CapabilityScope, opts?: {
        ttl?: number;
        issuerId?: string;
        holderId?: string;
    }): Promise<DelegationClaim>;
    // Warning: (ae-forgotten-export) The symbol "RevocationOpts" needs to be exported by the entry point index.d.ts
    revoke(claimId: string, opts?: RevocationOpts): Promise<number>;
    // Warning: (ae-forgotten-export) The symbol "VerifyChainResult_2" needs to be exported by the entry point index.d.ts
    verifyChain(claim: DelegationClaim): Promise<VerifyChainResult_2>;
}

// Warning: (ae-missing-release-tag) "DelegationRevokedError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DelegationRevokedError`

```typescript
export class DelegationRevokedError extends Error {
    constructor(claimId: string, revokedAt: string, reason?: string | undefined);
    readonly claimId: string;
    readonly reason?: string | undefined;
    readonly revokedAt: string;
}

// Warning: (ae-missing-release-tag) "DepositParams" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DepositParams`

```typescript
export interface DepositParams {
    readonly amount: string;
    readonly token: TokenAddress;
    // Warning: (ae-forgotten-export) The symbol "VaultAddress" needs to be exported by the entry point index.d.ts
    //
    readonly vault_address: VaultAddress;
}

// Warning: (ae-missing-release-tag) "DepositResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DepositResult`

```typescript
export interface DepositResult {
    readonly deposit_amount: string;
    readonly shares_minted: string;
    readonly tx_hash: string;
}

// Warning: (ae-missing-release-tag) "deprecated" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `deprecated`

```typescript
export function deprecated(apiName: string, options?: DeprecationOptions): void;

// Warning: (ae-missing-release-tag) "DeprecationOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DeprecationOptions`

```typescript
export interface DeprecationOptions {
    emit?: (message: string) => void;
    note?: string;
    removeIn?: string;
    replacement?: string;
    since?: string;
}

// Warning: (ae-missing-release-tag) "DepsValidationError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DepsValidationError`

```typescript
export class DepsValidationError extends Error {
    constructor(message: string);
}

// Warning: (ae-missing-release-tag) "DifficultyClass" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DifficultyClass`

```typescript
export type DifficultyClass = "simple" | "standard" | "complex" | "reasoning";

// Warning: (ae-missing-release-tag) "DiscordChannel" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DiscordChannel`

```typescript
export class DiscordChannel implements MessagingChannelPort {
    constructor(config: DiscordChannelConfig);
    sendAlert(level: AlertLevel, title: string, body: string): Promise<void>;
    sendMessage(target: string, text: string): Promise<void>;
}

// Warning: (ae-missing-release-tag) "DiscordChannelConfig" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DiscordChannelConfig`

```typescript
export interface DiscordChannelConfig {
    webhookUrl: string;
}

// Warning: (ae-missing-release-tag) "DiscordPublisher" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DiscordPublisher`

```typescript
export class DiscordPublisher implements PublisherPort {
    constructor(cfg: DiscordPublisherConfig);
    readonly channel: "discord";
    isConfigured(): Promise<boolean>;
    publish(input: PublishInput): Promise<PublishResult>;
}

// Warning: (ae-missing-release-tag) "DiscordPublisherConfig" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DiscordPublisherConfig`

```typescript
export interface DiscordPublisherConfig {
    readonly webhookUrl: string;
}

// Warning: (ae-missing-release-tag) "DispatcherConfig" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DispatcherConfig`

```typescript
export interface DispatcherConfig {
    readonly classifier?: (need: string) => MeshAgentKind;
    readonly costPerMs?: number;
    readonly fallbackExecutor?: (intent: DispatchIntent) => Promise<string>;
    readonly llmExecutor?: (prompt: string, deadlineMs: number) => Promise<string>;
    readonly mcpTools?: Readonly<Record<string, (args: unknown) => Promise<string>>>;
    readonly oodaExecutor?: (need: string, context: string | undefined, deadlineMs: number) => Promise<string>;
    readonly pluginExecutor?: (need: string, context: string | undefined) => Promise<string>;
}

// Warning: (ae-missing-release-tag) "DispatchIntent" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DispatchIntent`

```typescript
export interface DispatchIntent {
    readonly context?: string;
    readonly deadline_ms?: number;
    readonly kind: MeshAgentKind;
    readonly max_cost_eur?: number;
    readonly need: string;
    readonly toolArgs?: unknown;
    readonly toolName?: string;
}

// Warning: (ae-missing-release-tag) "DispatchResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DispatchResult`

```typescript
export interface DispatchResult {
    readonly costEur: number;
    readonly durationMs: number;
    readonly output: string;
    readonly truncated: boolean;
}

// Warning: (ae-missing-release-tag) "DlqJobPayload" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DlqJobPayload`

```typescript
export interface DlqJobPayload {
    attemptsMade: number;
    data?: unknown;
    failureReason: string;
    jobId: string | undefined;
    movedAt: string;
    originalQueue: string;
}

// Warning: (ae-missing-release-tag) "DomainEvent" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DomainEvent`

```typescript
export interface DomainEvent<T = unknown> {
    causationId?: string;
    correlationId: string;
    idempotencyKey: string;
    payload: T;
    schemaVersion: string;
    signature: string;
    source: EventSource_2;
    timestamp: string;
    type: string;
}

// Warning: (ae-missing-release-tag) "DomainSkillEntry" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DomainSkillEntry`

```typescript
export interface DomainSkillEntry {
    readonly name: string;
    readonly skill: Skill;
}

// Warning: (ae-missing-release-tag) "DpopClaims" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DpopClaims`

```typescript
export interface DpopClaims {
    ath?: string;
    htm: string;
    htu: string;
    iat: number;
    jti: string;
}

// Warning: (ae-missing-release-tag) "DpopReplayStore" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DpopReplayStore`

```typescript
export class DpopReplayStore {
    constructor(opts?: {
        maxSize?: number;
    });
    isReplayed(jti: string, nowMs?: number): boolean;
    record(jti: string, expiresAtMs: number): void;
    reset(): void;
    get size(): number;
}

// Warning: (ae-missing-release-tag) "DpopValidationFailure" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DpopValidationFailure`

```typescript
export interface DpopValidationFailure {
    reason: string;
    valid: false;
}

// Warning: (ae-missing-release-tag) "DpopValidationResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `DpopValidationResult`

```typescript
export type DpopValidationResult = ValidatedDpop | DpopValidationFailure;

// Warning: (ae-missing-release-tag) "EconomicObserver" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `EconomicObserver`

```typescript
export interface EconomicObserver {
    getStats(agentId: string): Promise<{
        cost7d: number;
        value7d: number;
        roi: number;
        cycles: number;
    }>;
    recordCycle(agentId: string, tokenCostUsd: number, outcomeValueCents: number, confidence: number): Promise<void>;
    shouldThrottle(agentId: string): Promise<boolean>;
}

// Warning: (ae-missing-release-tag) "economicObserverGuard" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `economicObserverGuard`

```typescript
export function economicObserverGuard(observer: EconomicObserver, agentId: string): RiskGuard;

// Warning: (ae-missing-release-tag) "EconomyMode" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `EconomyMode`

```typescript
export type EconomyMode = "degraded" | "full";

// Warning: (ae-missing-release-tag) "EconomyRouter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `EconomyRouter`

```typescript
export class EconomyRouter {
    constructor(config: EconomyRouterConfig);
    recordOutcome(runId: string, tier: ModelTier, inputTokens: number, outputTokens: number, durationMs: number, opts?: {
        skillId?: string;
        outcomeValue?: number;
        category?: string;
    }): void;
    route(category: string, opts?: {
        skillId?: string;
        budgetRemainingUsd?: number;
    }): RouteDecision;
    get routingRate(): number;
}

// Warning: (ae-missing-release-tag) "EconomyRouterConfig" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `EconomyRouterConfig`

```typescript
export interface EconomyRouterConfig {
    breaker: FleetCircuitBreaker;
    budgetBuffer?: number;
    mode: EconomyMode;
    policy: TierPolicy;
    tracker: OutcomeTracker;
}

// Warning: (ae-missing-release-tag) "EconomyRouterOpts" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `EconomyRouterOpts`

```typescript
export interface EconomyRouterOpts {
    defaultTier: ProviderTier["name"];
    eventBus?: EventBusPort;
    hourlyBudgetUsd: number;
    monthlyBudgetUsd: number;
    monthlyWindowMs?: number;
    _now?: () => number;
    onCircuitBreak?: (reason: string) => void;
    _tenantId?: string;
    tiers: ProviderTier[];
    windowMs?: number;
}

// Warning: (ae-missing-release-tag) "EcP256Jwk" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `EcP256Jwk`

```typescript
export interface EcP256Jwk {
    alg?: "ES256";
    crv: "P-256";
    d?: never;
    kty: "EC";
    use?: "sig";
    x: string;
    y: string;
}

// Warning: (ae-missing-release-tag) "EmailPublisher" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `EmailPublisher`

```typescript
export class EmailPublisher implements PublisherPort {
    constructor(cfg: EmailPublisherConfig);
    readonly channel: "email";
    isConfigured(): Promise<boolean>;
    publish(input: PublishInput): Promise<PublishResult>;
}

// Warning: (ae-missing-release-tag) "EmailPublisherConfig" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `EmailPublisherConfig`

```typescript
export interface EmailPublisherConfig {
    readonly apiKey: string;
    readonly defaultFrom: string;
}

// Warning: (ae-missing-release-tag) "EmbedFn" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `EmbedFn`

```typescript
export type EmbedFn = (text: string) => Promise<number[]>;

// Warning: (ae-missing-release-tag) "emergencyContextSummary" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `emergencyContextSummary`

```typescript
export function emergencyContextSummary(log: LogMessage[], summarize: (prompt: string) => Promise<string>, opts: {
    recursion: false;
}): Promise<string>;

// Warning: (ae-missing-release-tag) "EMPTY_SKILL_REGISTRY" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `EMPTY_SKILL_REGISTRY`

```typescript
export const EMPTY_SKILL_REGISTRY: SkillRegistry;

// Warning: (ae-missing-release-tag) "encodePairingPayload" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `encodePairingPayload`

```typescript
export function encodePairingPayload(p: PairingPayload): string;

// Warning: (ae-missing-release-tag) "EnforcementLevel" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `EnforcementLevel`

```typescript
export type EnforcementLevel = "block" | "warn" | "log";

// Warning: (ae-missing-release-tag) "EnvKeyProvider" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `EnvKeyProvider`

```typescript
export class EnvKeyProvider implements KeyProvider {
    constructor();
    getKey(keyId: string): Promise<Uint8Array>;
    hasColocationRisk(): boolean;
}

// Warning: (ae-missing-release-tag) "EpisodicCosineFn" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `EpisodicCosineFn`

```typescript
export type EpisodicCosineFn = (entry: EpisodicMemoryEntry) => number;

// Warning: (ae-missing-release-tag) "EpisodicMemoryEntry" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `EpisodicMemoryEntry`

```typescript
export interface EpisodicMemoryEntry {
    agentId: string;
    event: string;
    metadata?: Record<string, unknown>;
    runId: string;
    timestamp: number;
    traceId?: string;
}

// Warning: (ae-missing-release-tag) "EpisodicMemoryPort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `EpisodicMemoryPort`

```typescript
export interface EpisodicMemoryPort {
    queryByTrace(traceId: string, opts?: {
        limit?: number;
    }): Promise<EpisodicMemoryEntry[]>;
    record(agentId: string, runId: string, event: string, metadata?: Record<string, unknown>, opts?: {
        traceId?: string;
    }): Promise<void>;
    since(agentId: string, sinceMs: number, opts?: {
        limit?: number;
    }): Promise<EpisodicMemoryEntry[]>;
}

// Warning: (ae-missing-release-tag) "errorRunStep" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `errorRunStep`

```typescript
export function errorRunStep(db: DbClient, stepId: string, error: Error): Promise<void>;

// Warning: (ae-missing-release-tag) "EscalationLevel" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `EscalationLevel`

```typescript
export type EscalationLevel = "L0" | "L1" | "L2" | "L3";

// Warning: (ae-missing-release-tag) "estimateDifficulty" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `estimateDifficulty`

```typescript
export function estimateDifficulty(features: TaskFeatures): DifficultyClass;

// Warning: (ae-missing-release-tag) "evaluateQualityGate" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `evaluateQualityGate`

```typescript
export function evaluateQualityGate(input: MarketingGateInput): MarketingGateResult;

// Warning: (ae-missing-release-tag) "EventBusPort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `EventBusPort`

```typescript
export interface EventBusPort {
    dlq(): {
        depth(): Promise<number>;
        replay(eventId: string): Promise<void>;
    };
    pendingCount(stream: string, consumerGroup: string): Promise<number>;
    publish(event: CloudEvent, stream: string): Promise<void>;
    publishWithIdempotency<T>(event: Omit<DomainEvent<T>, "signature">, key: string): Promise<void>;
    replayFrom(streamKey: string, fromId: string): AsyncIterable<DomainEvent>;
    subscribeDomain<T>(eventType: string, handler: (event: DomainEvent<T>) => Promise<void>, opts?: {
        groupId?: string;
        dlq?: string;
    }): Subscription;
}

// Warning: (ae-missing-release-tag) "EventFilter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `EventFilter`

```typescript
export interface EventFilter {
    readonly [key: string]: unknown;
    readonly source?: string;
    readonly tenantId?: string;
    readonly type?: string;
}

// Warning: (ae-missing-release-tag) "EventPublishError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `EventPublishError`

```typescript
export class EventPublishError extends Error {
    constructor(message: string, stream: string, eventId: string, cause?: unknown | undefined);
    readonly cause?: unknown | undefined;
    readonly eventId: string;
    readonly stream: string;
}

// Warning: (ae-missing-release-tag) "EventSchemas" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `EventSchemas`

```typescript
export const EventSchemas: {
    readonly "agent.started": z.ZodObject<{
        agentName: z.ZodString;
        runId: z.ZodString;
        inputs: z.ZodUnknown;
        tenantId: z.ZodOptional<z.ZodString>;
    }, "strict", z.ZodTypeAny, {
        runId: string;
        agentName: string;
        tenantId?: string | undefined;
        inputs?: unknown;
    }, {
        runId: string;
        agentName: string;
        tenantId?: string | undefined;
        inputs?: unknown;
    }>;
    readonly "agent.completed": z.ZodObject<{
        agentName: z.ZodString;
        runId: z.ZodString;
        outputs: z.ZodUnknown;
        durationMs: z.ZodNumber;
        costUsd: z.ZodNumber;
    }, "strict", z.ZodTypeAny, {
        runId: string;
        costUsd: number;
        durationMs: number;
        agentName: string;
        outputs?: unknown;
    }, {
        runId: string;
        costUsd: number;
        durationMs: number;
        agentName: string;
        outputs?: unknown;
    }>;
    readonly "agent.failed": z.ZodObject<{
        agentName: z.ZodString;
        runId: z.ZodString;
        error: z.ZodString;
        retryCount: z.ZodNumber;
    }, "strict", z.ZodTypeAny, {
        error: string;
        runId: string;
        agentName: string;
        retryCount: number;
    }, {
        error: string;
        runId: string;
        agentName: string;
        retryCount: number;
    }>;
    readonly "agent.hitl_requested": z.ZodObject<{
        approvalId: z.ZodString;
        question: z.ZodString;
        deadline: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        approvalId: string;
        question: string;
        deadline: string;
    }, {
        approvalId: string;
        question: string;
        deadline: string;
    }>;
    readonly "agent.hitl_resolved": z.ZodObject<{
        approvalId: z.ZodString;
        decision: z.ZodEnum<["approved", "rejected"]>;
        by: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        decision: "rejected" | "approved";
        by: string;
        approvalId: string;
    }, {
        decision: "rejected" | "approved";
        by: string;
        approvalId: string;
    }>;
    readonly "incident.slo_burn": z.ZodObject<{
        slo: z.ZodString;
        burnRate: z.ZodNumber;
        severity: z.ZodEnum<["low", "medium", "high", "critical"]>;
    }, "strict", z.ZodTypeAny, {
        slo: string;
        burnRate: number;
        severity: "critical" | "low" | "medium" | "high";
    }, {
        slo: string;
        burnRate: number;
        severity: "critical" | "low" | "medium" | "high";
    }>;
    readonly "incident.detected": z.ZodObject<{
        source: z.ZodString;
        severity: z.ZodEnum<["low", "medium", "high", "critical"]>;
        summary: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        source: string;
        severity: "critical" | "low" | "medium" | "high";
        summary: string;
    }, {
        source: string;
        severity: "critical" | "low" | "medium" | "high";
        summary: string;
    }>;
    readonly "forge.inbox.reply_classified": z.ZodObject<{
        uid: z.ZodString;
        from: z.ZodString;
        subject: z.ZodString;
        type: z.ZodEnum<["INTERESTED", "NOT_INTERESTED", "BOUNCE", "SPAM", "OTHER"]>;
        priority: z.ZodEnum<["HIGH", "MEDIUM", "LOW"]>;
        signal: z.ZodString;
        nextAction: z.ZodString;
        timestamp: z.ZodString;
        schemaVersion: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        type: "INTERESTED" | "NOT_INTERESTED" | "BOUNCE" | "SPAM" | "OTHER";
        timestamp: string;
        schemaVersion: string;
        signal: string;
        priority: "HIGH" | "MEDIUM" | "LOW";
        from: string;
        subject: string;
        uid: string;
        nextAction: string;
    }, {
        type: "INTERESTED" | "NOT_INTERESTED" | "BOUNCE" | "SPAM" | "OTHER";
        timestamp: string;
        schemaVersion: string;
        signal: string;
        priority: "HIGH" | "MEDIUM" | "LOW";
        from: string;
        subject: string;
        uid: string;
        nextAction: string;
    }>;
    readonly "forge.lead.qualified": z.ZodObject<{
        leadId: z.ZodString;
        score: z.ZodNumber;
        source: z.ZodEnum<["inbound", "outbound", "referral"]>;
    }, "strict", z.ZodTypeAny, {
        source: "inbound" | "outbound" | "referral";
        score: number;
        leadId: string;
    }, {
        source: "inbound" | "outbound" | "referral";
        score: number;
        leadId: string;
    }>;
    readonly "forge.outreach.sent": z.ZodObject<{
        leadId: z.ZodString;
        channel: z.ZodEnum<["email", "linkedin", "x", "telegram"]>;
        content: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        content: string;
        channel: "telegram" | "email" | "linkedin" | "x";
        leadId: string;
    }, {
        content: string;
        channel: "telegram" | "email" | "linkedin" | "x";
        leadId: string;
    }>;
    readonly "forge.policy.triggered": z.ZodObject<{
        policyId: z.ZodString;
        context: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    }, "strict", z.ZodTypeAny, {
        context: Record<string, unknown>;
        policyId: string;
    }, {
        context: Record<string, unknown>;
        policyId: string;
    }>;
    readonly "vauban.vault.rebalance_proposed": z.ZodObject<{
        vaultId: z.ZodString;
        currentRatio: z.ZodNumber;
        targetRatio: z.ZodNumber;
    }, "strict", z.ZodTypeAny, {
        vaultId: string;
        currentRatio: number;
        targetRatio: number;
    }, {
        vaultId: string;
        currentRatio: number;
        targetRatio: number;
    }>;
    readonly "vauban.vault.rebalanced": z.ZodObject<{
        vaultId: z.ZodString;
        txHash: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        vaultId: string;
        txHash: string;
    }, {
        vaultId: string;
        txHash: string;
    }>;
    readonly "vauban.vault.analyzed": z.ZodObject<{
        vaultId: z.ZodString;
        tvlUsd: z.ZodNumber;
        anomalies: z.ZodArray<z.ZodObject<{
            type: z.ZodString;
            severity: z.ZodEnum<["info", "warning", "error", "critical"]>;
            metric: z.ZodString;
            current: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
            expected: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
            description: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            expected: string | number;
            type: string;
            description: string;
            severity: "info" | "error" | "critical" | "warning";
            metric: string;
            current: string | number;
        }, {
            expected: string | number;
            type: string;
            description: string;
            severity: "info" | "error" | "critical" | "warning";
            metric: string;
            current: string | number;
        }>, "many">;
        overallSeverity: z.ZodEnum<["info", "warning", "error", "critical"]>;
        timestamp: z.ZodString;
        schemaVersion: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        timestamp: string;
        schemaVersion: string;
        vaultId: string;
        overallSeverity: "info" | "error" | "critical" | "warning";
        tvlUsd: number;
        anomalies: {
            expected: string | number;
            type: string;
            description: string;
            severity: "info" | "error" | "critical" | "warning";
            metric: string;
            current: string | number;
        }[];
    }, {
        timestamp: string;
        schemaVersion: string;
        vaultId: string;
        overallSeverity: "info" | "error" | "critical" | "warning";
        tvlUsd: number;
        anomalies: {
            expected: string | number;
            type: string;
            description: string;
            severity: "info" | "error" | "critical" | "warning";
            metric: string;
            current: string | number;
        }[];
    }>;
    readonly "vauban.goal.checked": z.ZodObject<{
        goalId: z.ZodString;
        successRate: z.ZodNumber;
        alertLevel: z.ZodEnum<["none", "warning", "critical"]>;
        timestamp: z.ZodString;
        schemaVersion: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        timestamp: string;
        schemaVersion: string;
        goalId: string;
        successRate: number;
        alertLevel: "none" | "critical" | "warning";
    }, {
        timestamp: string;
        schemaVersion: string;
        goalId: string;
        successRate: number;
        alertLevel: "none" | "critical" | "warning";
    }>;
    readonly "vauban.rebalancing.checked": z.ZodObject<{
        portfolioId: z.ZodString;
        maxDrift: z.ZodNumber;
        alertLevel: z.ZodEnum<["none", "warning", "critical"]>;
        timestamp: z.ZodString;
        schemaVersion: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        timestamp: string;
        schemaVersion: string;
        alertLevel: "none" | "critical" | "warning";
        portfolioId: string;
        maxDrift: number;
    }, {
        timestamp: string;
        schemaVersion: string;
        alertLevel: "none" | "critical" | "warning";
        portfolioId: string;
        maxDrift: number;
    }>;
    readonly "vauban.tax.checked": z.ZodObject<{
        userId: z.ZodString;
        rulesTriggered: z.ZodArray<z.ZodString, "many">;
        alertLevel: z.ZodEnum<["none", "warning", "critical"]>;
        timestamp: z.ZodString;
        schemaVersion: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        timestamp: string;
        schemaVersion: string;
        userId: string;
        alertLevel: "none" | "critical" | "warning";
        rulesTriggered: string[];
    }, {
        timestamp: string;
        schemaVersion: string;
        userId: string;
        alertLevel: "none" | "critical" | "warning";
        rulesTriggered: string[];
    }>;
    readonly "vauban.vault.compounded": z.ZodObject<{
        vaultId: z.ZodString;
        compoundedAt: z.ZodString;
        rewardsUsd: z.ZodNumber;
        caller: z.ZodString;
        txHash: z.ZodOptional<z.ZodString>;
        schemaVersion: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        schemaVersion: string;
        vaultId: string;
        compoundedAt: string;
        rewardsUsd: number;
        caller: string;
        txHash?: string | undefined;
    }, {
        schemaVersion: string;
        vaultId: string;
        compoundedAt: string;
        rewardsUsd: number;
        caller: string;
        txHash?: string | undefined;
    }>;
    readonly "vauban-finance.forecast.generated": z.ZodObject<{
        scenarioId: z.ZodString;
        successRate: z.ZodNumber;
        paramVelocity: z.ZodNumber;
        timestamp: z.ZodString;
        schemaVersion: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        timestamp: string;
        schemaVersion: string;
        successRate: number;
        scenarioId: string;
        paramVelocity: number;
    }, {
        timestamp: string;
        schemaVersion: string;
        successRate: number;
        scenarioId: string;
        paramVelocity: number;
    }>;
    readonly "vauban-finance.trade.executed": z.ZodObject<{
        symbol: z.ZodString;
        direction: z.ZodEnum<["long", "short", "hold"]>;
        quantity: z.ZodNumber;
        conviction: z.ZodNumber;
        timestamp: z.ZodString;
        schemaVersion: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        symbol: string;
        timestamp: string;
        schemaVersion: string;
        direction: "long" | "short" | "hold";
        quantity: number;
        conviction: number;
    }, {
        symbol: string;
        timestamp: string;
        schemaVersion: string;
        direction: "long" | "short" | "hold";
        quantity: number;
        conviction: number;
    }>;
    readonly "glacis.identity.verified": z.ZodObject<{
        userId: z.ZodString;
        method: z.ZodEnum<["zk_passport", "zk_email", "world_id"]>;
    }, "strict", z.ZodTypeAny, {
        method: "zk_passport" | "zk_email" | "world_id";
        userId: string;
    }, {
        method: "zk_passport" | "zk_email" | "world_id";
        userId: string;
    }>;
    readonly "citadel.sprint.closed": z.ZodObject<{
        sprintId: z.ZodString;
        completed: z.ZodNumber;
        carryOver: z.ZodNumber;
    }, "strict", z.ZodTypeAny, {
        completed: number;
        sprintId: string;
        carryOver: number;
    }, {
        completed: number;
        sprintId: string;
        carryOver: number;
    }>;
    readonly "citadel.sprint.analyzed": z.ZodObject<{
        sprintId: z.ZodString;
        healthScore: z.ZodNumber;
        overallSeverity: z.ZodEnum<["info", "warning", "error", "critical"]>;
        insights: z.ZodArray<z.ZodObject<{
            type: z.ZodString;
            severity: z.ZodEnum<["info", "warning", "error", "critical"]>;
            metric: z.ZodString;
            description: z.ZodString;
        }, "strict", z.ZodTypeAny, {
            type: string;
            description: string;
            severity: "info" | "error" | "critical" | "warning";
            metric: string;
        }, {
            type: string;
            description: string;
            severity: "info" | "error" | "critical" | "warning";
            metric: string;
        }>, "many">;
        blockers: z.ZodArray<z.ZodString, "many">;
        recommendations: z.ZodArray<z.ZodString, "many">;
        timestamp: z.ZodString;
        schemaVersion: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        timestamp: string;
        schemaVersion: string;
        insights: {
            type: string;
            description: string;
            severity: "info" | "error" | "critical" | "warning";
            metric: string;
        }[];
        sprintId: string;
        healthScore: number;
        overallSeverity: "info" | "error" | "critical" | "warning";
        blockers: string[];
        recommendations: string[];
    }, {
        timestamp: string;
        schemaVersion: string;
        insights: {
            type: string;
            description: string;
            severity: "info" | "error" | "critical" | "warning";
            metric: string;
        }[];
        sprintId: string;
        healthScore: number;
        overallSeverity: "info" | "error" | "critical" | "warning";
        blockers: string[];
        recommendations: string[];
    }>;
    readonly "brain.skill.extracted": z.ZodObject<{
        skillId: z.ZodString;
        agentSource: z.ZodString;
        confidence: z.ZodNumber;
    }, "strict", z.ZodTypeAny, {
        confidence: number;
        agentSource: string;
        skillId: string;
    }, {
        confidence: number;
        agentSource: string;
        skillId: string;
    }>;
    readonly "cc.cost.recorded": z.ZodObject<{
        agent: z.ZodString;
        costUsd: z.ZodNumber;
        tokens: z.ZodNumber;
        model: z.ZodString;
        tenantId: z.ZodOptional<z.ZodString>;
    }, "strict", z.ZodTypeAny, {
        model: string;
        costUsd: number;
        agent: string;
        tokens: number;
        tenantId?: string | undefined;
    }, {
        model: string;
        costUsd: number;
        agent: string;
        tokens: number;
        tenantId?: string | undefined;
    }>;
    readonly "cc.cost.anomaly_detected": z.ZodObject<{
        agent: z.ZodString;
        expected: z.ZodNumber;
        actual: z.ZodNumber;
        period: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        expected: number;
        agent: string;
        actual: number;
        period: string;
    }, {
        expected: number;
        agent: string;
        actual: number;
        period: string;
    }>;
    readonly "tenant.provisioned": z.ZodObject<{
        tenantId: z.ZodString;
        plan: z.ZodEnum<["starter", "team", "pro", "enterprise"]>;
        virtualKey: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        plan: "starter" | "team" | "pro" | "enterprise";
        tenantId: string;
        virtualKey: string;
    }, {
        plan: "starter" | "team" | "pro" | "enterprise";
        tenantId: string;
        virtualKey: string;
    }>;
    readonly "tenant.budget.exceeded": z.ZodObject<{
        tenantId: z.ZodString;
        period: z.ZodString;
        amountUsd: z.ZodNumber;
        limitUsd: z.ZodNumber;
    }, "strict", z.ZodTypeAny, {
        tenantId: string;
        period: string;
        amountUsd: number;
        limitUsd: number;
    }, {
        tenantId: string;
        period: string;
        amountUsd: number;
        limitUsd: number;
    }>;
};

// Warning: (ae-missing-release-tag) "EventSource" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `__unknown`

```typescript
type EventSource_2 = "forge" | "vauban" | "vauban-finance" | "brain" | "citadel" | "glacis" | "cc" | "tenant";
export { EventSource_2 as EventSource }

// Warning: (ae-missing-release-tag) "EventType" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `EventType`

```typescript
export type EventType = {
    type: "agent.started";
    payload: z.infer<typeof AgentStartedV1>;
} | {
    type: "agent.completed";
    payload: z.infer<typeof AgentCompletedV1>;
} | {
    type: "agent.failed";
    payload: z.infer<typeof AgentFailedV1>;
} | {
    type: "agent.hitl_requested";
    payload: z.infer<typeof AgentHitlRequestedV1>;
} | {
    type: "agent.hitl_resolved";
    payload: z.infer<typeof AgentHitlResolvedV1>;
} | {
    type: "incident.slo_burn";
    payload: z.infer<typeof IncidentSloBurnV1>;
} | {
    type: "incident.detected";
    payload: z.infer<typeof IncidentDetectedV1>;
} | {
    type: "forge.inbox.reply_classified";
    payload: z.infer<typeof ForgeInboxReplyClassifiedV1>;
} | {
    type: "forge.lead.qualified";
    payload: z.infer<typeof ForgeLeadQualifiedV1>;
} | {
    type: "forge.outreach.sent";
    payload: z.infer<typeof ForgeOutreachSentV1>;
} | {
    type: "forge.policy.triggered";
    payload: z.infer<typeof ForgePolicyTriggeredV1>;
} | {
    type: "vauban.vault.rebalance_proposed";
    payload: z.infer<typeof VaubanVaultRebalanceProposedV1>;
} | {
    type: "vauban.vault.rebalanced";
    payload: z.infer<typeof VaubanVaultRebalancedV1>;
} | {
    type: "glacis.identity.verified";
    payload: z.infer<typeof GlacisIdentityVerifiedV1>;
} | {
    type: "citadel.sprint.closed";
    payload: z.infer<typeof CitadelSprintClosedV1>;
} | {
    type: "citadel.sprint.analyzed";
    payload: z.infer<typeof CitadelSprintAnalyzedV1>;
} | {
    type: "brain.skill.extracted";
    payload: z.infer<typeof BrainSkillExtractedV1>;
} | {
    type: "cc.cost.recorded";
    payload: z.infer<typeof CcCostRecordedV1>;
} | {
    type: "cc.cost.anomaly_detected";
    payload: z.infer<typeof CcCostAnomalyDetectedV1>;
} | {
    type: "tenant.provisioned";
    payload: z.infer<typeof TenantProvisionedV1>;
} | {
    type: "tenant.budget.exceeded";
    payload: z.infer<typeof TenantBudgetExceededV1>;
} | {
    type: "vauban.vault.analyzed";
    payload: z.infer<typeof VaubanVaultAnalyzedV1>;
} | {
    type: "vauban.goal.checked";
    payload: z.infer<typeof VaubanGoalCheckedV1>;
} | {
    type: "vauban.rebalancing.checked";
    payload: z.infer<typeof VaubanRebalancingCheckedV1>;
} | {
    type: "vauban.tax.checked";
    payload: z.infer<typeof VaubanTaxCheckedV1>;
} | {
    type: "vauban.vault.compounded";
    payload: z.infer<typeof VaubanVaultCompoundedV1>;
} | {
    type: "vauban-finance.forecast.generated";
    payload: z.infer<typeof VaubanFinanceForecastGeneratedV1>;
} | {
    type: "vauban-finance.trade.executed";
    payload: z.infer<typeof VaubanFinanceTradeExecutedV1>;
};

// Warning: (ae-missing-release-tag) "EventTypeName" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `EventTypeName`

```typescript
export type EventTypeName = keyof typeof EventSchemas;

// Warning: (ae-missing-release-tag) "EvictionPolicy" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `EvictionPolicy`

```typescript
export interface EvictionPolicy {
    readonly name: string;
    select(entries: readonly WorkingMemoryEntry[], targetSize: number): string[];
}

// Warning: (ae-missing-release-tag) "executeStep" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `executeStep`

```typescript
export function executeStep(step: PlanStep, executor: (step: PlanStep) => Promise<unknown>): Promise<StepResult>;

// Warning: (ae-missing-release-tag) "ExecutionMode" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ExecutionMode`

```typescript
export type ExecutionMode = "dry-run" | "live";
```

### `ExecutionResult`

```typescript
export interface ExecutionResult<T = unknown> {
    readonly automationName: string;
    readonly completedAt: Date;
    readonly durationMs: number;
    readonly error?: {
        code: string;
        message: string;
        details?: unknown;
    };
    readonly executionId: string;
    readonly input: unknown;
    readonly logs: ReadonlyArray<{
        readonly level: string;
        readonly message: string;
        readonly timestamp: string;
    }>;
    readonly output?: T;
    readonly startedAt: Date;
    readonly status: "completed" | "failed" | "timeout";
}

// Warning: (ae-missing-release-tag) "ExhaustResourcesOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ExhaustResourcesOptions`

```typescript
export interface ExhaustResourcesOptions {
    err?: () => Error;
    maxCalls: number;
}

// Warning: (ae-missing-release-tag) "exportProofClaim" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `exportProofClaim`

```typescript
export function exportProofClaim(trace: Trace, traceBytes: string, signClaim?: SignFn, opts?: ExportProofClaimOptions): ProofClaim;

// Warning: (ae-missing-release-tag) "ExportProofClaimOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ExportProofClaimOptions`

```typescript
export interface ExportProofClaimOptions {
    paymentReceipt?: SettlementReceipt;
}

// Warning: (ae-missing-release-tag) "exportTrajectory" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `exportTrajectory`

```typescript
export function exportTrajectory(runId: string, db: DbClient, opts?: TrajectoryOptions): Promise<TrajectoryExport>;

// Warning: (ae-missing-release-tag) "ExternalKMSKeyProvider" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ExternalKMSKeyProvider`

```typescript
export class ExternalKMSKeyProvider implements KeyProvider {
    constructor(options: ExternalKMSKeyProviderOptions);
    getKey(keyId: string): Promise<Uint8Array>;
    hasColocationRisk(): boolean;
}

// Warning: (ae-missing-release-tag) "ExternalKMSKeyProviderOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ExternalKMSKeyProviderOptions`

```typescript
export interface ExternalKMSKeyProviderOptions {
    authToken?: string;
    endpoint: string;
}

// Warning: (ae-missing-release-tag) "ExtractedSkill" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ExtractedSkill`

```typescript
export interface ExtractedSkill {
    chainOfThought: string;
    confidence: number;
    description: string;
    name: string;
    verified: boolean;
}

// Warning: (ae-missing-release-tag) "extractFeatures" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `extractFeatures`

```typescript
export function extractFeatures(input: string, context?: string): TaskFeatures;

// Warning: (ae-missing-release-tag) "extractSkillFromTrace" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `extractSkillFromTrace`

```typescript
export function extractSkillFromTrace(events: CycleEvent[], _ctx: OODAContext, opts: LearnOptions): Promise<ExtractedSkill | null>;

// Warning: (ae-missing-release-tag) "FallbackAdapter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `FallbackAdapter`

```typescript
export class FallbackAdapter implements TimestampPort {
    constructor(adapters: readonly TimestampPort[]);
    request(rootHash: string): Promise<SignedReceipt>;
    verify(receipt: SignedReceipt, rootHash: string): Promise<{
        valid: boolean;
        reason?: string;
    }>;
}

// Warning: (ae-missing-release-tag) "FederationDelegationChainError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `FederationDelegationChainError`

```typescript
export class FederationDelegationChainError extends Error {
    constructor(messageId: string, chainDepth: number, reason: string);
    readonly chainDepth: number;
    readonly messageId: string;
    readonly reason: string;
}

// Warning: (ae-missing-release-tag) "FederationMessage" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `FederationMessage`

```typescript
export interface FederationMessage {
    readonly content_claim: ContentClaim;
    readonly delegation_chain?: ReadonlyArray<{
        readonly id: string;
        readonly parent_id?: string;
        readonly scope: {
            readonly capabilities: ReadonlyArray<string>;
            readonly constraints: ReadonlyArray<unknown>;
            readonly jurisdictions: ReadonlyArray<string>;
            readonly expires_at: string;
        };
        readonly ed25519_sig: string;
    }>;
    readonly header: FederationMessageHeader;
    readonly id: string;
    readonly transport: TransportMeta;
}

// Warning: (ae-missing-release-tag) "FederationMessageHeader" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `FederationMessageHeader`

```typescript
export interface FederationMessageHeader {
    readonly causation_id?: string;
    readonly correlation_id: string;
    readonly from_agent: AgentRef;
    readonly message_id: string;
    readonly nonce: string;
    readonly timestamp: string;
    readonly to_agent: AgentRef;
}

// Warning: (ae-missing-release-tag) "MessageId" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `FederationMessageId`

```typescript
export type FederationMessageId = string;

// Warning: (ae-missing-release-tag) "FederationPort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `FederationPort`

```typescript
export interface FederationPort {
    ack(messageId: FederationMessageId): Promise<void>;
    nack(messageId: FederationMessageId, reason?: string): Promise<void>;
    receive(opts?: FederationReceiveOpts): Promise<FederationMessage[]>;
    send(message: FederationMessage, opts?: {
        timeoutMs?: number;
    }): Promise<FederationMessageId>;
    verifyMessage(msg: FederationMessage): Promise<FederationVerifyResult>;
}

// Warning: (ae-missing-release-tag) "ReceiveOpts" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `FederationReceiveOpts`

```typescript
export interface FederationReceiveOpts {
    readonly destinationTenantId?: string;
    readonly maxMessages?: number;
    readonly timeout?: number;
}

// Warning: (ae-missing-release-tag) "FederationRoutingError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `FederationRoutingError`

```typescript
export class FederationRoutingError extends Error {
    constructor(tenantId: string, reason: string);
    readonly reason: string;
    readonly tenantId: string;
}

// Warning: (ae-missing-release-tag) "FederationSignatureInvalidError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `FederationSignatureInvalidError`

```typescript
export class FederationSignatureInvalidError extends Error {
    constructor(messageId: string, reason: string);
    readonly messageId: string;
    readonly reason: string;
}

// Warning: (ae-missing-release-tag) "VerifyResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `FederationVerifyResult`

```typescript
export interface FederationVerifyResult {
    readonly chain_depth?: number;
    readonly errors: string[];
    readonly signer_agent_id?: string;
    readonly valid: boolean;
}

// Warning: (ae-missing-release-tag) "FileIOMode" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `FileIOMode`

```typescript
export type FileIOMode = "none" | "ro" | "sandboxed";

// Warning: (ae-missing-release-tag) "FileIoMode" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `FileIoMode`

```typescript
export type FileIoMode = "off" | "read-only" | "sandboxed-tmp";

// Warning: (ae-missing-release-tag) "FleetCircuitBreaker" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `FleetCircuitBreaker`

```typescript
export class FleetCircuitBreaker {
    constructor(config?: Partial<CircuitBreakerConfig>, _now?: () => number);
    canProceed(): boolean;
    recordCost(costUsd: number): void;
    reset(): void;
    // Warning: (ae-forgotten-export) The symbol "CircuitState_2" needs to be exported by the entry point index.d.ts
    get state(): CircuitState_2;
    get windowSpend(): number;
}

// Warning: (ae-missing-release-tag) "FormalSolver" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `FormalSolver`

```typescript
export type FormalSolver = "z3" | "none";

// Warning: (ae-missing-release-tag) "formalVerify" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `formalVerify`

```typescript
export function formalVerify(axiomSpecs: AxiomSpec[], mode: ConsumerMode, context: VerifyContext, customPolicies?: Partial<Record<string, AxiomPolicy>>): Promise<FormalVerifyDecision[]>;

// Warning: (ae-missing-release-tag) "FormalVerifyDecision" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `FormalVerifyDecision`

```typescript
export interface FormalVerifyDecision {
    decision: PolicyDecision;
    result: FormalVerifyResult;
}

// Warning: (ae-missing-release-tag) "FormalVerifyResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `FormalVerifyResult`

```typescript
export interface FormalVerifyResult {
    axiom: string;
    counterexample?: string;
    rationale: string;
    solver: FormalSolver;
    state: FormalVerifyState;
    time_ms: number;
    witness?: string;
}

// Warning: (ae-missing-release-tag) "FormalVerifyState" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `FormalVerifyState`

```typescript
export type FormalVerifyState = "SAFE" | "UNSAFE" | "UNKNOWN" | "SKIPPED";

// Warning: (ae-missing-release-tag) "GateResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `GateResult`

```typescript
export interface GateResult {
    pass: boolean;
    violations: GateViolation[];
}

// Warning: (ae-missing-release-tag) "GateSeverity" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `GateSeverity`

```typescript
export type GateSeverity = "block";

// Warning: (ae-missing-release-tag) "GateViolation" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `GateViolation`

```typescript
export interface GateViolation {
    axiom: AxiomId;
    rationale: string;
    rule: string;
    severity: GateSeverity;
}

// Warning: (ae-missing-release-tag) "GatewayAdapter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `GatewayAdapter`

```typescript
export interface GatewayAdapter {
    deliver(text: string): Promise<void>;
    readonly platform: string;
    start(onMessage: (msg: InboundMessage) => void): Promise<void>;
    stop(): Promise<void>;
}

// Warning: (ae-missing-release-tag) "GatewayHandle" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `GatewayHandle`

```typescript
export interface GatewayHandle {
    readonly platforms: string[];
    start(): Promise<void>;
    stop(): Promise<void>;
}

// Warning: (ae-missing-release-tag) "GatewayOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `GatewayOptions`

```typescript
export interface GatewayOptions {
    adapters: GatewayAdapter[];
    approvalChannel?: RemoteApprovalChannel;
    greeting?: string | false;
    hub: RemoteControlPort;
    // Warning: (ae-forgotten-export) The symbol "GatewayLogger" needs to be exported by the entry point index.d.ts
    log?: GatewayLogger;
    verbose?: boolean;
}

// Warning: (ae-missing-release-tag) "GENESIS_PREV_HASH" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `GENESIS_PREV_HASH`

```typescript
export const GENESIS_PREV_HASH = "0000000000000000000000000000000000000000000000000000000000000000";

// Warning: (ae-missing-release-tag) "getAgentId" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `getAgentId`

```typescript
export function getAgentId(agent: AgentType): string;

// Warning: (ae-missing-release-tag) "getFallbackChain" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `getFallbackChain`

```typescript
export function getFallbackChain(config: PhaseModelConfig, phase: OODAPhaseKind): ModelSpec[];

// Warning: (ae-missing-release-tag) "getSDKProvider" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `__unknown`

```typescript
function getSDKProvider(): BasicTracerProvider | null;
export { getSDKProvider as getSDKConfig }
export { getSDKProvider }

// Warning: (ae-missing-release-tag) "getTracer" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `getTracer`

```typescript
export function getTracer(name?: string): Tracer;

// Warning: (ae-missing-release-tag) "GistCompressionConfig" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `GistCompressionConfig`

```typescript
export interface GistCompressionConfig {
    maxGistTokens?: number;
    raw_threshold?: number;
}

// Warning: (ae-missing-release-tag) "GistedMessage" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `GistedMessage`

```typescript
export interface GistedMessage {
    content: string;
    originalLength: number;
    role: "tool";
    toolName?: string;
}

// Warning: (ae-missing-release-tag) "GistLLMFn" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `GistLLMFn`

```typescript
export type GistLLMFn = (prompt: string) => Promise<string>;

// Warning: (ae-missing-release-tag) "gistToolResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `gistToolResult`

```typescript
export function gistToolResult(rawContent: string, toolName: string | undefined, llmFn: GistLLMFn, config?: GistCompressionConfig): Promise<GistedMessage>;

// Warning: (ae-missing-release-tag) "GitHubPublisher" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `GitHubPublisher`

```typescript
export class GitHubPublisher implements PublisherPort {
    constructor(cfg: GitHubPublisherConfig);
    readonly channel: "github";
    isConfigured(): Promise<boolean>;
    publish(input: PublishInput): Promise<PublishResult>;
}

// Warning: (ae-missing-release-tag) "GitHubPublisherConfig" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `GitHubPublisherConfig`

```typescript
export interface GitHubPublisherConfig {
    readonly token: string;
}

// Warning: (ae-missing-release-tag) "GOLDEN_ATTACK_EMBEDDINGS" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `GOLDEN_ATTACK_EMBEDDINGS`

```typescript
export const GOLDEN_ATTACK_EMBEDDINGS: ReadonlyArray<{
    label: string;
    embedding: number[];
}>;

// Warning: (ae-missing-release-tag) "GOLDEN_FIXTURES" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `GOLDEN_FIXTURES`

```typescript
export const GOLDEN_FIXTURES: ReadonlyArray<{
    trace: string;
    expectedSkillName: string;
}>;

// Warning: (ae-missing-release-tag) "GuardrailDef" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `GuardrailDef`

```typescript
export interface GuardrailDef<TInput = unknown, TOutput = unknown> {
    check(input: TInput | TOutput, ctx: OODAContext): Promise<GuardrailResult>;
    readonly name: string;
    readonly timing: GuardrailTiming;
}

// Warning: (ae-missing-release-tag) "GuardrailResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `GuardrailResult`

```typescript
export interface GuardrailResult {
    pass: boolean;
    proofHash?: string;
    reason?: string;
}

// Warning: (ae-missing-release-tag) "GuardrailTiming" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `GuardrailTiming`

```typescript
export type GuardrailTiming = "pre-phase" | "post-phase";

// Warning: (ae-missing-release-tag) "GuardrailViolation" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `GuardrailViolation`

```typescript
export interface GuardrailViolation {
    name: string;
    phase: string;
    proofHash?: string;
    reason: string;
    timing: GuardrailTiming;
}

// Warning: (ae-missing-release-tag) "guardrailViolationToEvent" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `guardrailViolationToEvent`

```typescript
export function guardrailViolationToEvent(violation: GuardrailViolation, runId: string, cycleIndex: number): Extract<CycleEventV011, {
    type: "guardrail_violated";
}>;

// Warning: (ae-missing-release-tag) "handoff" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `handoff`

```typescript
export function handoff(opts: HandoffOptions, client: AgentHandoffClient): Promise<HandoffResult>;

// Warning: (ae-missing-release-tag) "HandoffCycleError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `HandoffCycleError`

```typescript
export class HandoffCycleError extends Error {
    constructor(agentId: string, chain: string[]);
}

// Warning: (ae-missing-release-tag) "HandoffOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `HandoffOptions`

```typescript
export interface HandoffOptions {
    ctx: OODAContext;
    handoffChain: string[];
    messages: Array<{
        role: string;
        content: string;
    }>;
    targetAgentId: string;
}

// Warning: (ae-missing-release-tag) "HandoffResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `HandoffResult`

```typescript
export interface HandoffResult {
    accepted: boolean;
    childRunId: string;
    nextChain: string[];
}

// Warning: (ae-missing-release-tag) "handoffToEvent" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `handoffToEvent`

```typescript
export function handoffToEvent(targetAgentId: string, childRunId: string, handoffChain: string[], runId: string, cycleIndex: number): Extract<CycleEventV011, {
    type: "handoff_initiated";
}>;

// Warning: (ae-missing-release-tag) "HardGate" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `HardGate`

```typescript
export class HardGate {
    evaluate(cycle: CycleSnapshot, parent?: ParentCycleContext): GateResult;
}

// Warning: (ae-missing-release-tag) "hardGate" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `hardGate`

```typescript
export const hardGate: HardGate;

// Warning: (ae-missing-release-tag) "hashJti" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `hashJti`

```typescript
export function hashJti(jti: string): string;

// Warning: (ae-missing-release-tag) "hashKey" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `hashKey`

```typescript
export function hashKey(...parts: unknown[]): string;

// Warning: (ae-missing-release-tag) "hashLLMCacheKey" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `hashLLMCacheKey`

```typescript
export function hashLLMCacheKey(key: LLMCacheKey): Promise<string>;

// Warning: (ae-missing-release-tag) "HITLCallbackData" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `HITLCallbackData`

```typescript
export interface HITLCallbackData {
    action: "approve" | "reject";
    approvalId: string;
}

// Warning: (ae-missing-release-tag) "HITLDecision" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `HITLDecision`

```typescript
export type HITLDecision = "approved" | "rejected";

// Warning: (ae-missing-release-tag) "HITLGateArgs" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `HITLGateArgs`

```typescript
export interface HITLGateArgs {
    agentId: string;
    decisionPayload: Record<string, unknown>;
    executionMode: ExecutionMode;
    runId: string;
}

// Warning: (ae-missing-release-tag) "HITLGateOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `HITLGateOptions`

```typescript
export interface HITLGateOptions {
    onTimeout?: HITLOnTimeoutPolicy;
    pollIntervalMs?: number;
    timeoutMs?: number;
}

// Warning: (ae-missing-release-tag) "HITLGateVerdict" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `HITLGateVerdict`

```typescript
export interface HITLGateVerdict {
    approved: boolean;
    rationale?: string;
    resolvedBy?: string;
    timedOut: boolean;
}

// Warning: (ae-missing-release-tag) "HITLHandlerResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `HITLHandlerResult`

```typescript
export interface HITLHandlerResult {
    body: unknown;
    status: number;
}

// Warning: (ae-missing-release-tag) "HITLNotFoundError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `HITLNotFoundError`

```typescript
export class HITLNotFoundError extends Error {
    constructor(id: string);
    readonly id: string;
}

// Warning: (ae-missing-release-tag) "HITLOnTimeoutPolicy" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `HITLOnTimeoutPolicy`

```typescript
export type HITLOnTimeoutPolicy = "reject" | "approve" | "continue-skip";

// Warning: (ae-missing-release-tag) "HITLPort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `HITLPort`

```typescript
export interface HITLPort {
    await(id: string, timeoutMs?: number): Promise<HITLState>;
    expire(id: string): Promise<void>;
    getState(id: string): Promise<HITLState>;
    request(req: HITLRequest): Promise<string>;
    resolve(id: string, decision: "approved" | "rejected", by: string): Promise<void>;
}

// Warning: (ae-missing-release-tag) "HITLRequest" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `HITLRequest`

```typescript
export interface HITLRequest {
    agentSource: string;
    channel: "telegram" | "slack" | "discord";
    context: Record<string, unknown>;
    deadline: string;
    id: string;
    options: string[];
    question: string;
    tenantId?: string;
}

// Warning: (ae-forgotten-export) The symbol "HitlRequestInput" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "hitlRequest" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `hitlRequest`

```typescript
export const hitlRequest: Skill<HitlRequestInput, HitlRequestOutput>;

// Warning: (ae-missing-release-tag) "HitlRequestOutput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `HitlRequestOutput`

```typescript
export interface HitlRequestOutput {
    expires_at: string;
    id: string;
    status: "pending" | "replay";
}
```

### `HITLState`

```typescript
export type HITLState = "pending" | "approved" | "rejected" | "expired" | "executed";

// Warning: (ae-missing-release-tag) "HmacInvalidError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `HmacInvalidError`

```typescript
export class HmacInvalidError extends Error {
    constructor(runId: string);
}

// Warning: (ae-missing-release-tag) "hmacSha256" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `hmacSha256`

```typescript
export function hmacSha256(key: Uint8Array, input: string | Uint8Array): Promise<string>;

// Warning: (ae-missing-release-tag) "HttpBrainAdapterOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `HttpBrainAdapterOptions`

```typescript
export interface HttpBrainAdapterOptions {
    apiKey?: string;
    baseUrl: string;
    brainId: string;
    timeoutMs?: number;
    token?: string;
}

// Warning: (ae-forgotten-export) The symbol "HttpFetchInput" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "httpFetch" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `httpFetch`

```typescript
export const httpFetch: Skill<HttpFetchInput, HttpFetchOutput>;

// Warning: (ae-missing-release-tag) "HttpFetchAllowlistError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `HttpFetchAllowlistError`

```typescript
export class HttpFetchAllowlistError extends Error {
    constructor(url: string, host: string);
    readonly host: string;
    readonly url: string;
}

// Warning: (ae-missing-release-tag) "HttpFetchOutput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `HttpFetchOutput`

```typescript
export interface HttpFetchOutput {
    body: string;
    headers: Record<string, string>;
    status: number;
    truncated: boolean;
}

// Warning: (ae-missing-release-tag) "HttpVCR" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `HttpVCR`

```typescript
export class HttpVCR {
    clear(): void;
    export(): VCRCassette[];
    intercept(url: string, method: string, body: string | null, realFetch: () => Promise<Response>): Promise<Response>;
    static key(url: string, method: string, body: string | null): string;
    load(cassettes: VCRCassette[]): void;
    mode: VCRMode;
    stats: VCRStats;
}

// Warning: (ae-missing-release-tag) "IdempotencyCache" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `IdempotencyCache`

```typescript
export interface IdempotencyCache<T> {
    delete(key: string): void;
    get(key: string): T | undefined;
    set(key: string, value: T): void;
}

// Warning: (ae-missing-release-tag) "IdempotencyKeyPayload" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `IdempotencyKeyPayload`

```typescript
export interface IdempotencyKeyPayload {
    author: string;
    category: string;
    content: string;
}

// Warning: (ae-missing-release-tag) "idempotent" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `idempotent`

```typescript
export function idempotent<TArgs extends unknown[], TResult>(fn: (...args: TArgs) => Promise<TResult>, options: IdempotentOptions<TArgs, TResult>): (...args: TArgs) => Promise<TResult>;

// Warning: (ae-missing-release-tag) "IdempotentOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `IdempotentOptions`

```typescript
export interface IdempotentOptions<TArgs extends unknown[], TResult> {
    cache?: IdempotencyCache<TResult>;
    keyFor: (...args: TArgs) => string;
    maxEntries?: number;
    ttlMs?: number;
}

// Warning: (ae-missing-release-tag) "ImageMediaType" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ImageMediaType`

```typescript
export type ImageMediaType = "image/jpeg" | "image/png" | "image/gif" | "image/webp";

// Warning: (ae-missing-release-tag) "ImmuneMatch" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ImmuneMatch`

```typescript
export interface ImmuneMatch {
    entry: ImmuneMemoryEntry;
    similarity: number;
    threshold: number;
}

// Warning: (ae-missing-release-tag) "ImmuneMemoryEntry" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ImmuneMemoryEntry`

```typescript
export interface ImmuneMemoryEntry {
    embedding: number[];
    label: string;
    proofHash?: string;
    timestamp: number;
}

// Warning: (ae-forgotten-export) The symbol "ImportanceWeightedOptions" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "importanceWeightedPolicy" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `importanceWeightedPolicy`

```typescript
export function importanceWeightedPolicy(opts?: ImportanceWeightedOptions): EvictionPolicy;

// Warning: (ae-missing-release-tag) "InboundMessage" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `InboundMessage`

```typescript
export interface InboundMessage {
    chatId: string;
    platform: string;
    text: string;
    ts: string;
    userId: string;
}

// Warning: (ae-missing-release-tag) "IngestSpansResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `IngestSpansResult`

```typescript
export interface IngestSpansResult {
    accepted: number;
    runs?: string[];
    skipped?: number;
    warnings?: string[];
}

// Warning: (ae-missing-release-tag) "initVaubanSDK" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `initVaubanSDK`

```typescript
export function initVaubanSDK(opts: VaubanSDKOptions): BasicTracerProvider;

// Warning: (ae-missing-release-tag) "InjectBrainFailureOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `InjectBrainFailureOptions`

```typescript
export interface InjectBrainFailureOptions {
    failureRate: number;
    random?: () => number;
    type?: "rate-limit" | "timeout" | "network" | "random";
}

// Warning: (ae-missing-release-tag) "InMemoryApprovalStore" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `InMemoryApprovalStore`

```typescript
export class InMemoryApprovalStore implements ApprovalStore {
    cancel(id: string): Promise<boolean>;
    create(entry: PendingApproval): Promise<void>;
    expireOverdue(now?: number): Promise<number>;
    get(id: string): Promise<PendingApproval | null>;
    listAll(): Promise<readonly PendingApproval[]>;
    resolve(id: string, verdict: Approval): Promise<boolean>;
}

// Warning: (ae-missing-release-tag) "InMemoryInstructionInbox" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `InMemoryInstructionInbox`

```typescript
export class InMemoryInstructionInbox implements InstructionInbox {
    drain(): Instruction[];
    enqueue(text: string, source: string, whisper?: boolean): void;
    size(): number;
}

// Warning: (ae-missing-release-tag) "InMemoryLLMResponseCache" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `InMemoryLLMResponseCache`

```typescript
export class InMemoryLLMResponseCache implements LLMResponseCache {
    clear(): void;
    get(key: LLMCacheKey): Promise<LLMCacheEntry | undefined>;
    put(key: LLMCacheKey, response: unknown): Promise<void>;
}

// Warning: (ae-missing-release-tag) "InMemoryNonceStore" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `InMemoryNonceStore`

```typescript
export class InMemoryNonceStore implements NonceStore {
    reset(): void;
    setNX(key: string, ttlMs: number): Promise<boolean>;
}

// Warning: (ae-missing-release-tag) "InMemoryPersistencePort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `InMemoryPersistencePort`

```typescript
export class InMemoryPersistencePort implements PersistencePort {
    clearAll(): Promise<void>;
    close(): Promise<void>;
    getMaxSeq(): Promise<number>;
    get isClosed(): boolean;
    loadEvents(sinceSeq?: number): Promise<SessionEvent[]>;
    loadRevocations(): Promise<string[]>;
    saveEvent(event: SessionEvent): Promise<void>;
    saveRevocation(jti: string): Promise<void>;
}

// Warning: (ae-missing-release-tag) "InMemoryReceiptQueue" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `InMemoryReceiptQueue`

```typescript
export class InMemoryReceiptQueue implements ReceiptQueue {
    enqueue(entry: Omit<ReceiptQueueEntry, "hmac" | "attempts">, keyProvider: KeyProvider, keyId: string): Promise<void>;
    pending(): Promise<ReceiptQueueEntry[]>;
    process(adapter: TimestampPort, keyProvider: KeyProvider, keyId: string, opts?: {
        batchSize?: number;
        backoffMs?: readonly number[];
    }): Promise<{
        processed: number;
        failed: number;
        rejected: number;
    }>;
    size(): Promise<number>;
}
```

### `InMemorySecretsAccessor`

```typescript
export class InMemorySecretsAccessor implements SecretsAccessor {
    constructor(secrets?: Readonly<Record<string, string>>);
    get accessedSecrets(): ReadonlySet<string>;
    get(name: string, defaultValue?: string): string;
    has(name: string): boolean;
}

// Warning: (ae-missing-release-tag) "InMemoryVetoChannel" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `InMemoryVetoChannel`

```typescript
export class InMemoryVetoChannel implements VetoChannel {
    await(callId: string, windowMs: number): Promise<VetoSignal | null>;
    pendingCount(): number;
    submit(signal: VetoSignal): void;
}

// Warning: (ae-missing-release-tag) "innerMonologue" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `innerMonologue`

```typescript
export function innerMonologue(input: InnerMonologueInput, reasoner: (input: InnerMonologueInput) => Promise<{
    reasoning: string;
    insights: string[];
    confidence: number;
}>): Promise<InnerMonologueOutput>;

// Warning: (ae-missing-release-tag) "InnerMonologueInput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `InnerMonologueInput`

```typescript
export interface InnerMonologueInput {
    config?: unknown;
    observation: unknown;
    previous?: string[];
}

// Warning: (ae-missing-release-tag) "InnerMonologueOutput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `InnerMonologueOutput`

```typescript
export interface InnerMonologueOutput {
    confidence: number;
    insights: string[];
    reasoning: SensitiveValue<string>;
}

// Warning: (ae-missing-release-tag) "insertRunStep" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `insertRunStep`

```typescript
export function insertRunStep(db: DbClient, runId: string, input: InsertRunStepInput): Promise<{
    stepId: string;
}>;

// Warning: (ae-missing-release-tag) "InsertRunStepInput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `InsertRunStepInput`

```typescript
export interface InsertRunStepInput {
    parentStepId?: string;
    payload?: Record<string, unknown>;
    phase: string;
    stepIndex: number;
    type: OODAPhaseKind;
}

// Warning: (ae-missing-release-tag) "INSTITUTIONNEL" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `INSTITUTIONNEL`

```typescript
export const INSTITUTIONNEL: Axiom;

// Warning: (ae-missing-release-tag) "institutionnelScorer" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `institutionnelScorer`

```typescript
export const institutionnelScorer: ScoringFunction;

// Warning: (ae-missing-release-tag) "Instruction" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `Instruction`

```typescript
export interface Instruction {
    at: string;
    source: string;
    text: string;
    whisper: boolean;
}

// Warning: (ae-missing-release-tag) "InstructionInbox" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `InstructionInbox`

```typescript
export interface InstructionInbox {
    drain(): Instruction[];
    enqueue(text: string, source: string, whisper?: boolean): void;
    size(): number;
}

// Warning: (ae-missing-release-tag) "InvalidGlacisAttestationError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `InvalidGlacisAttestationError`

```typescript
export class InvalidGlacisAttestationError extends Error {
    constructor(tenantId: string, reason: string);
    readonly reason: string;
    readonly tenantId: string;
}

// Warning: (ae-missing-release-tag) "InvalidSignatureError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `InvalidSignatureError`

```typescript
export class InvalidSignatureError extends Error {
    constructor(message?: string);
}

// Warning: (ae-missing-release-tag) "InvalidStateTransitionError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `InvalidStateTransitionError`

```typescript
export class InvalidStateTransitionError extends Error {
    constructor(from: HITLState, to: HITLState);
    readonly from: HITLState;
    readonly to: HITLState;
}

// Warning: (ae-missing-release-tag) "InvalidStrategyError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `InvalidStrategyError`

```typescript
export class InvalidStrategyError extends Error {
    constructor(message?: string);
    readonly name = "InvalidStrategyError";
}
```

### `InvalidTargetError`

```typescript
export class InvalidTargetError extends Error {
    constructor(message: string, target: string);
    readonly target: string;
}

// Warning: (ae-missing-release-tag) "isDegradedResponse" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `isDegradedResponse`

```typescript
export function isDegradedResponse(r: unknown): r is DegradedResponse;

// Warning: (ae-missing-release-tag) "isHostAllowed" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `isHostAllowed`

```typescript
export function isHostAllowed(host: string, allowlist: string[]): boolean;
```

### `isIdleCycle`

```typescript
export function isIdleCycle(inputs: ProductiveQualityInputs): boolean;

// Warning: (ae-missing-release-tag) "isMultiModal" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `isMultiModal`

```typescript
export function isMultiModal(obs: unknown): obs is MultiModalObservation;

// Warning: (ae-missing-release-tag) "isPortError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `isPortError`

```typescript
export function isPortError(err: unknown, port?: string): err is PortError;

// Warning: (ae-missing-release-tag) "isReadOnlySql" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `isReadOnlySql`

```typescript
export function isReadOnlySql(sql: string): boolean;

// Warning: (ae-missing-release-tag) "isRetryablePortError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `isRetryablePortError`

```typescript
export function isRetryablePortError(err: unknown): err is PortError;

// Warning: (ae-missing-release-tag) "isValidToolName" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `isValidToolName`

```typescript
export function isValidToolName(name: string): boolean;

// Warning: (ae-missing-release-tag) "JournalEntry" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `JournalEntry`

```typescript
export interface JournalEntry {
    readonly error?: {
        message: string;
        stack?: string;
    };
    readonly finished_at?: Date;
    readonly idempotency_key?: string;
    readonly input: unknown;
    readonly journal_id: bigint;
    readonly output?: unknown;
    readonly run_id: string;
    readonly started_at: Date;
    readonly status: StepStatus;
    readonly step_index: number;
    readonly step_kind: StepKind;
    readonly step_name: string;
}

// Warning: (ae-missing-release-tag) "JournalMigrator" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `JournalMigrator`

```typescript
export type JournalMigrator = (journal: JournalEntry[]) => JournalEntry[];

// Warning: (ae-missing-release-tag) "Jurisdiction" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `Jurisdiction`

```typescript
export type Jurisdiction = "FR.v1" | "EU.v1" | "CH.v1" | "UK.v1" | "SG.v1";

// Warning: (ae-forgotten-export) The symbol "SanitizeConfig" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "keepSafeOnly" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `keepSafeOnly`

```typescript
export function keepSafeOnly<T extends {
    content: string;
}>(items: T[], opts?: SanitizeConfig): T[];

// Warning: (ae-missing-release-tag) "KeyProvider" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `KeyProvider`

```typescript
export interface KeyProvider {
    getKey(keyId: string): Promise<Uint8Array>;
    hasColocationRisk(): boolean;
}

// Warning: (ae-missing-release-tag) "LatencyTier" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `LatencyTier`

```typescript
export type LatencyTier = "low" | "medium" | "high";

// Warning: (ae-missing-release-tag) "LearningTrigger" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `LearningTrigger`

```typescript
export interface LearningTrigger {
    durationMs: number;
    roi: number;
    toolCallCount: number;
    wasReplay: boolean;
}

// Warning: (ae-missing-release-tag) "LearnOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `LearnOptions`

```typescript
export interface LearnOptions {
    enabled: boolean;
    extractor?: (trace: string) => Promise<ExtractedSkill | null>;
    // Warning: (ae-forgotten-export) The symbol "SkillLedger" needs to be exported by the entry point index.d.ts
    ledger?: SkillLedger;
    minConfidence?: number;
}

// Warning: (ae-missing-release-tag) "LegalBasisDecl" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `LegalBasisDecl`

```typescript
export interface LegalBasisDecl {
    basis: LegalBasisRef;
    domain: LegalBasisDomain;
    scope?: Jurisdiction[];
}

// Warning: (ae-missing-release-tag) "LegalBasisDomain" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `LegalBasisDomain`

```typescript
export type LegalBasisDomain = "processing" | "retention" | "transfer" | "consent";

// Warning: (ae-missing-release-tag) "LegalBasisRef" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `LegalBasisRef`

```typescript
export type LegalBasisRef = "gdpr.art6_1_a" | "gdpr.art6_1_b" | "gdpr.art6_1_c" | "gdpr.art6_1_f" | "mica.art14" | "tfr.art4" | "cjeu.c520_21";

// Warning: (ae-missing-release-tag) "LessonInput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `LessonInput`

```typescript
export interface LessonInput {
    readonly applies_to: readonly string[];
    readonly context: string;
    readonly evidence: Readonly<Record<string, unknown>>;
    readonly insight: string;
    readonly title: string;
}

// Warning: (ae-missing-release-tag) "LiteLLMAdapter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `LiteLLMAdapter`

```typescript
export class LiteLLMAdapter implements LLMProviderPort {
    constructor(config: LiteLLMAdapterConfig);
    complete(req: ChatRequest): Promise<ChatResponse>;
    estimateCost(req: ChatRequest): {
        usd: number;
    };
    stream(req: ChatRequest): AsyncIterable<StreamDelta>;
}

// Warning: (ae-missing-release-tag) "LiteLLMAdapterConfig" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `LiteLLMAdapterConfig`

```typescript
export interface LiteLLMAdapterConfig {
    apiKey?: string;
    baseUrl: string;
    defaultModel?: string;
}

// Warning: (ae-missing-release-tag) "LLMCacheEntry" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `LLMCacheEntry`

```typescript
export interface LLMCacheEntry {
    key: string;
    recordedAt: number;
    response: unknown;
}

// Warning: (ae-missing-release-tag) "LLMCacheKey" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `LLMCacheKey`

```typescript
export interface LLMCacheKey {
    messages: unknown;
    model: string;
    provider: string;
    seed?: number;
    temperature: number;
}

// Warning: (ae-missing-release-tag) "LLMCompletionFn" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `LLMCompletionFn`

```typescript
export type LLMCompletionFn = (messages: ReactMessage[]) => Promise<LLMReactResponse>;

// Warning: (ae-missing-release-tag) "LLMMessage" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `LLMMessage`

```typescript
export interface LLMMessage {
    readonly content: string;
    readonly role: "system" | "user" | "assistant";
}

// Warning: (ae-missing-release-tag) "LLMProviderError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `LLMProviderError`

```typescript
export class LLMProviderError extends Error {
    constructor(message: string, provider: string, model: string, cause?: unknown | undefined);
    readonly cause?: unknown | undefined;
    readonly model: string;
    readonly provider: string;
}

// Warning: (ae-missing-release-tag) "LLMProviderPort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `LLMProviderPort`

```typescript
export interface LLMProviderPort {
    complete(req: ChatRequest): Promise<ChatResponse>;
    estimateCost?(req: ChatRequest): {
        usd: number;
    };
    stream?(req: ChatRequest): AsyncIterable<StreamDelta>;
}

// Warning: (ae-missing-release-tag) "LLMRateLimitError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `LLMRateLimitError`

```typescript
export class LLMRateLimitError extends LLMProviderError {
    constructor(message: string, provider: string, model: string, retryAfterMs: number, cause?: unknown);
    readonly retryAfterMs: number;
}

// Warning: (ae-missing-release-tag) "LLMReactResponse" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `LLMReactResponse`

```typescript
export interface LLMReactResponse {
    content: string;
    isFinal: boolean;
    toolCalls?: ToolCall[];
}

// Warning: (ae-missing-release-tag) "LLMResponseCache" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `LLMResponseCache`

```typescript
export interface LLMResponseCache {
    clear?(): void;
    get(key: LLMCacheKey): Promise<LLMCacheEntry | undefined>;
    put(key: LLMCacheKey, response: unknown): Promise<void>;
}

// Warning: (ae-missing-release-tag) "llmSpan" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `llmSpan`

```typescript
export function llmSpan(tracer: Tracer, request: {
    provider: string;
    model: string;
    maxTokens?: number;
    messageCount?: number;
    temperature?: number;
    topP?: number;
    seed?: number;
}): Span;
```

### `loadAgentContext`

```typescript
export function loadAgentContext(brain: BrainPort, agentId: string, domainTags: string[], logger: LoggerPort, opts?: LoadAgentContextOptions): Promise<AgentBootContext>;
```

### `LoadAgentContextOptions`

```typescript
export interface LoadAgentContextOptions {
    decisionsCategory?: string;
    domainCategories?: string[];
    domainContextLimit?: number;
    projectMd?: {
        query: string;
        category: string;
        tag: string;
    };
    recentDecisionsLimit?: number;
}
```

### `loadHubFromPersistence`

```typescript
export function loadHubFromPersistence(hub: RemoteControlPort, persistence: PersistencePort, opts?: {
    sinceSeq?: number;
}): Promise<{
    loaded: number;
    maxSeq: number;
}>;

// Warning: (ae-missing-release-tag) "loadPersonaFromBrain" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `loadPersonaFromBrain`

```typescript
export function loadPersonaFromBrain(brain: SemanticMemoryPort, agentId: string): Promise<AgentPersona | null>;

// Warning: (ae-missing-release-tag) "loadPersonaFromFile" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `loadPersonaFromFile`

```typescript
export function loadPersonaFromFile(path: string): Promise<AgentPersona | null>;
```

### `loadRecentMemory`

```typescript
export function loadRecentMemory(brain: BrainPort, agentId: string, opts?: LoadRecentMemoryOptions): Promise<string>;
```

### `LoadRecentMemoryOptions`

```typescript
export interface LoadRecentMemoryOptions {
    category?: string;
    limit?: number;
    maxChars?: number;
    maxEntryChars?: number;
    tags?: string[];
}

// Warning: (ae-missing-release-tag) "loadSkillMd" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `loadSkillMd`

```typescript
export function loadSkillMd(filePath: string): Promise<ParsedSkillFile>;

// Warning: (ae-missing-release-tag) "localSqliteTelemetrySink" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `localSqliteTelemetrySink`

```typescript
export function localSqliteTelemetrySink(opts?: LocalSqliteTelemetrySinkOptions): TelemetrySink;

// Warning: (ae-missing-release-tag) "LocalSqliteTelemetrySinkOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `LocalSqliteTelemetrySinkOptions`

```typescript
export interface LocalSqliteTelemetrySinkOptions {
    path?: string;
    readonly?: boolean;
}

// Warning: (ae-missing-release-tag) "LoggerFlushError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `LoggerFlushError`

```typescript
export class LoggerFlushError extends Error {
    constructor(message: string, pendingCount: number, cause?: unknown | undefined);
    readonly cause?: unknown | undefined;
    readonly pendingCount: number;
}

// Warning: (ae-missing-release-tag) "LoggerPort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `LoggerPort`

```typescript
export interface LoggerPort {
    child?(bindings: Record<string, unknown>): LoggerPort;
    debug(objOrMsg: object | string, msg?: string): void;
    error(objOrMsg: object | string, msg?: string): void;
    info(objOrMsg: object | string, msg?: string): void;
    warn(objOrMsg: object | string, msg?: string): void;
}

// Warning: (ae-missing-release-tag) "LogMessage" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `LogMessage`

```typescript
export type LogMessage = {
    role: "user" | "assistant" | "tool" | "system";
    content: string;
    toolName?: string;
};

// Warning: (ae-missing-release-tag) "lookupTier" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `lookupTier`

```typescript
export function lookupTier(provider: string, model: string): ModelTier | undefined;

// Warning: (ae-missing-release-tag) "lruPolicy" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `lruPolicy`

```typescript
export const lruPolicy: EvictionPolicy;

// Warning: (ae-missing-release-tag) "makeEvent" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `makeEvent`

```typescript
export function makeEvent<T extends SessionEvent["type"]>(type: T, data: Extract<SessionEvent, {
    type: T;
}>["data"]): SessionEvent;

// Warning: (ae-missing-release-tag) "Manifest" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `Manifest`

```typescript
export interface Manifest {
    readonly capabilities: readonly string[];
    readonly compliance: {
        readonly jurisdictions: readonly string[];
        readonly legal_bases: readonly string[];
        readonly data_classification: string;
    };
    // Warning: (ae-forgotten-export) The symbol "ComplianceMode_2" needs to be exported by the entry point index.d.ts
    //
    readonly compliance_mode: ComplianceMode_2;
    readonly ed25519_pubkey: string;
    readonly manifestHash: string;
    readonly name: string;
    readonly runtime: {
        readonly max_compute_seconds: number;
        readonly max_llm_tokens: number;
    };
    readonly signature: string;
    // Warning: (ae-forgotten-export) The symbol "Tier" needs to be exported by the entry point index.d.ts
    //
    readonly tier: Tier;
    readonly version: string;
}

// Warning: (ae-missing-release-tag) "ManifestComplianceConflictError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ManifestComplianceConflictError`

```typescript
export class ManifestComplianceConflictError extends Error {
    constructor(name: string, version: string, violation: string);
    readonly name: string;
    readonly version: string;
    readonly violation: string;
}

// Warning: (ae-missing-release-tag) "ManifestNotFoundError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ManifestNotFoundError`

```typescript
export class ManifestNotFoundError extends Error {
    constructor(name: string, version: string);
    readonly name: string;
    readonly version: string;
}

// Warning: (ae-missing-release-tag) "ManifestRegistryPort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ManifestRegistryPort`

```typescript
export interface ManifestRegistryPort {
    listVersions(name: string): Promise<readonly string[]>;
    lookup(name: string, version: string): Promise<Manifest | null>;
    // Warning: (ae-forgotten-export) The symbol "RegisterOptions" needs to be exported by the entry point index.d.ts
    register(manifest: Manifest, options?: RegisterOptions): Promise<RegistrationResult>;
    revoke(claim_id: string, reason: string): Promise<void>;
    verifySignature(manifest: Manifest): Promise<boolean>;
}

// Warning: (ae-missing-release-tag) "ManifestSignatureInvalidError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ManifestSignatureInvalidError`

```typescript
export class ManifestSignatureInvalidError extends Error {
    constructor(name: string, version: string, cause?: unknown | undefined);
    readonly cause?: unknown | undefined;
    readonly name: string;
    readonly version: string;
}

// Warning: (ae-missing-release-tag) "ManifestValidationError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ManifestValidationError`

```typescript
export class ManifestValidationError extends Error {
    constructor(violations: readonly ComplianceError[]);
    // Warning: (ae-forgotten-export) The symbol "ComplianceError" needs to be exported by the entry point index.d.ts
    //
    readonly violations: readonly ComplianceError[];
}

// Warning: (ae-missing-release-tag) "ManifestValidationResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ManifestValidationResult`

```typescript
export interface ManifestValidationResult {
    readonly conflicts: PolicyConflict[];
    readonly evaluationTimeMs: number;
    readonly jurisdictionWarnings: string[];
    readonly missingLegalBases: string[];
    readonly valid: boolean;
}

// Warning: (ae-missing-release-tag) "ManifestVersionConflictError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ManifestVersionConflictError`

```typescript
export class ManifestVersionConflictError extends Error {
    constructor(name: string, version: string, existingStatus: string);
    readonly existingStatus: string;
    readonly name: string;
    readonly version: string;
}

// Warning: (ae-missing-release-tag) "BashMode" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `MappedBashMode`

```typescript
export type MappedBashMode = "off" | "restricted";

// Warning: (ae-missing-release-tag) "SdkPermissions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `MappedSdkPermissions`

```typescript
export interface MappedSdkPermissions {
    bash: MappedBashMode;
    fileIo: FileIoMode;
    mcp: string[];
}

// Warning: (ae-missing-release-tag) "mapScopesToSdkPermissions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `mapScopesToSdkPermissions`

```typescript
export function mapScopesToSdkPermissions(scopes: readonly string[]): SdkPermissions;

// Warning: (ae-missing-release-tag) "MarketingGateInput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `MarketingGateInput`

```typescript
export interface MarketingGateInput {
    readonly action_type: string;
    readonly payload: Record<string, unknown> | null | undefined;
    readonly persona: AgentPersona;
    readonly platform?: string;
}

// Warning: (ae-missing-release-tag) "MarketingGateResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `MarketingGateResult`

```typescript
export interface MarketingGateResult {
    readonly passed: boolean;
    readonly violations: string[];
    readonly warnings: string[];
}

// Warning: (ae-missing-release-tag) "MarketSignal" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `MarketSignal`

```typescript
export interface MarketSignal {
    readonly divergence_bps: number;
    readonly oracle_count: number;
    readonly price: string;
    // Warning: (ae-forgotten-export) The symbol "Symbol_2" needs to be exported by the entry point index.d.ts
    //
    readonly symbol: Symbol_2;
    readonly timestamp: Date;
}

// Warning: (ae-missing-release-tag) "MAVAggregation" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `MAVAggregation`

```typescript
export type MAVAggregation = "mean" | "median" | "min" | "majority-vote";

// Warning: (ae-missing-release-tag) "MCPChannel" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `MCPChannel`

```typescript
export class MCPChannel implements MessagingChannelPort {
    constructor(config: MCPChannelConfig);
    sendAlert(level: AlertLevel, title: string, body: string): Promise<void>;
    sendMessage(target: string, text: string): Promise<void>;
}

// Warning: (ae-missing-release-tag) "MCPChannelConfig" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `MCPChannelConfig`

```typescript
export interface MCPChannelConfig {
    mcpClient: MCPClientLike;
    toolName: string;
}
```

### `MCPClientLike`

```typescript
export interface MCPClientLike {
    callTool(name: string, args: unknown): Promise<unknown>;
}

// Warning: (ae-missing-release-tag) "MCPToolDefinition" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `MCPToolDefinition`

```typescript
export interface MCPToolDefinition {
    description: string;
    inputSchema: {
        type: "object";
        properties: Record<string, unknown>;
        required?: string[];
    };
    name: string;
}

// Warning: (ae-missing-release-tag) "MemoryAgentRegistry" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `MemoryAgentRegistry`

```typescript
export class MemoryAgentRegistry implements AgentRegistryPort {
    list(filter?: Partial<AgentRegistryDescriptor>): Promise<AgentRegistryDescriptor[]>;
    register(descriptor: AgentRegistryDescriptor): Promise<void>;
    resolve(capability: string, opts?: {
        tenantId?: string;
    }): Promise<AgentRegistryDescriptor[]>;
    unregister(id: string): Promise<void>;
}

// Warning: (ae-missing-release-tag) "MemoryHITLStateStore" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `MemoryHITLStateStore`

```typescript
export class MemoryHITLStateStore implements HITLPort {
    await(id: string, timeoutMs?: number): Promise<HITLState>;
    expire(id: string): Promise<void>;
    _expireOverdue(): Promise<void>;
    getState(id: string): Promise<HITLState>;
    request(req: HITLRequest): Promise<string>;
    resolve(id: string, decision: "approved" | "rejected", by: string): Promise<void>;
}

// Warning: (ae-missing-release-tag) "mergePersona" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `mergePersona`

```typescript
export function mergePersona(base: AgentPersona, local: AgentPersona): AgentPersona;

// Warning: (ae-missing-release-tag) "MeshAgentKind" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `MeshAgentKind`

```typescript
export type MeshAgentKind = "ooda" | "llm-router" | "mcp-tool" | "plugin" | "fallback";

// Warning: (ae-missing-release-tag) "MeshCapabilityScope" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `MeshCapabilityScope`

```typescript
export interface MeshCapabilityScope {
    readonly actions: ReadonlyArray<string>;
    readonly budgetEur: number;
    readonly expiresAt?: Date;
}

// Warning: (ae-missing-release-tag) "DeadlineExceededError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `MeshDeadlineExceededError`

```typescript
export class MeshDeadlineExceededError extends Error {
    constructor(deadlineMs: number, partial?: string);
    readonly name = "MeshDeadlineExceededError";
    readonly partial?: string;
}

// Warning: (ae-missing-release-tag) "defaultClassifier" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `meshDefaultClassifier`

```typescript
export function meshDefaultClassifier(need: string): MeshAgentKind;

// Warning: (ae-missing-release-tag) "meshDelegate" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `meshDelegate`

```typescript
export function meshDelegate<T = string>(options: DelegateOptions, dispatcher: MeshDispatcher): Promise<DelegateResult<T>>;

// Warning: (ae-missing-release-tag) "DelegationLink" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `MeshDelegationLink`

```typescript
export interface MeshDelegationLink {
    readonly budget: number;
    readonly from: string;
    readonly scope: ReadonlyArray<string>;
    readonly to: string;
}

// Warning: (ae-missing-release-tag) "MeshDispatcher" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `MeshDispatcher`

```typescript
export interface MeshDispatcher {
    dispatch(intent: DispatchIntent): Promise<DispatchResult>;
}

// Warning: (ae-missing-release-tag) "MeshDispatchError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `MeshDispatchError`

```typescript
export class MeshDispatchError extends Error {
    constructor(message: string, code: string);
    readonly code: string;
    readonly name = "MeshDispatchError";
}
```

### `MessagingChannelPort`

```typescript
export interface MessagingChannelPort {
    sendAlert(level: AlertLevel, title: string, body: string): Promise<void>;
    sendMessage(target: string, text: string): Promise<void>;
}

// Warning: (ae-missing-release-tag) "MessagingTriggerResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `MessagingTriggerResult`

```typescript
export interface MessagingTriggerResult {
    replyText: string;
    runId?: string;
}

// Warning: (ae-missing-release-tag) "MeterBalance" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `MeterBalance`

```typescript
export interface MeterBalance {
    agentId: string;
    firstRunAt: number;
    lastRunAt: number;
    netValueCents: number;
    totalRuns: number;
    totalValueCents: number;
}

// Warning: (ae-missing-release-tag) "MeterEntry" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `MeterEntry`

```typescript
export interface MeterEntry {
    agentId: string;
    hash: string;
    prevHash: string;
    runId: string;
    timestamp: number;
    valueCents: number;
}

// Warning: (ae-missing-release-tag) "MeterVerifyResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `MeterVerifyResult`

```typescript
export interface MeterVerifyResult {
    firstInvalidAt?: number;
    reason?: string;
    totalEntries: number;
    valid: boolean;
}

// Warning: (ae-missing-release-tag) "MigrationResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `MigrationResult`

```typescript
export interface MigrationResult {
    readonly entries_migrated: number;
    readonly error?: string;
    readonly from_version: string;
    readonly ok: boolean;
    readonly run_id: string;
    readonly to_version: string;
}

// Warning: (ae-missing-release-tag) "MinimalRedisClient" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `MinimalRedisClient`

```typescript
export interface MinimalRedisClient {
    del(key: string): Promise<unknown>;
    get(key: string): Promise<string | null>;
    quit(): Promise<unknown>;
    set(key: string, value: string): Promise<unknown>;
}

// Warning: (ae-missing-release-tag) "mintSubToken" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `mintSubToken`

```typescript
export function mintSubToken(opts: MintSubTokenOptions): string;

// Warning: (ae-missing-release-tag) "mintSubTokenInstrumented" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `mintSubTokenInstrumented`

```typescript
export function mintSubTokenInstrumented(opts: MintSubTokenOptions): string;

// Warning: (ae-missing-release-tag) "MintSubTokenOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `MintSubTokenOptions`

```typescript
export interface MintSubTokenOptions {
    cnf?: {
        jkt: string;
    };
    now?: () => number;
    parentToken: string;
    scope: SubTokenScope;
    ttlSec: number;
}

// Warning: (ae-missing-release-tag) "MissingDependencyError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `MissingDependencyError`

```typescript
export class MissingDependencyError extends Error {
    constructor(port: string);
    readonly port: string;
}
```

### `MissingDryRunFlagError`

```typescript
export class MissingDryRunFlagError extends Error {
    constructor();
}

// Warning: (ae-missing-release-tag) "mixtureOfAgentsStrategy" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `mixtureOfAgentsStrategy`

```typescript
export function mixtureOfAgentsStrategy<TInput, TOutput>(config?: Partial<MoAConfig<TOutput>>): Strategy<TInput, TOutput>;

// Warning: (ae-missing-release-tag) "MoAConfig" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `MoAConfig`

```typescript
export interface MoAConfig<TOutput> {
    aggregate?: (outputs: TOutput[]) => TOutput;
    proposersPerRound: number;
    rounds: number;
}

// Warning: (ae-missing-release-tag) "ModelSpec" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ModelSpec`

```typescript
export interface ModelSpec {
    costTracking?: boolean;
    fallback?: ModelSpec[];
    model: string;
    provider: string;
    temperature?: number;
    topP?: number;
}

// Warning: (ae-missing-release-tag) "ModelTier" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ModelTier`

```typescript
export interface ModelTier {
    costPerMTokenIn: number;
    costPerMTokenOut: number;
    label: "free" | "cheap" | "mid" | "premium";
    model: string;
    provider: string;
}

// Warning: (ae-missing-release-tag) "MultiModalObservation" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `MultiModalObservation`

```typescript
export interface MultiModalObservation {
    audioBase64?: string;
    audioMediaType?: AudioMediaType;
    documentUrl?: string;
    imageBase64?: string;
    imageMediaType?: ImageMediaType;
    text?: string;
}

// Warning: (ae-missing-release-tag) "multiModalToAnthropicContent" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `multiModalToAnthropicContent`

```typescript
export function multiModalToAnthropicContent(obs: MultiModalObservation): AnthropicContentBlock[];
```

### `NO_RETRY`

```typescript
export const NO_RETRY: RetryConfig;
```

### `NonceStore`

```typescript
export interface NonceStore {
    setNX(key: string, ttlMs: number): Promise<boolean>;
}

// Warning: (ae-missing-release-tag) "NonDeterministicReplayError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `NonDeterministicReplayError`

```typescript
export class NonDeterministicReplayError extends Error {
    constructor(stepIndex: number, reason: string);
    readonly reason: string;
    readonly stepIndex: number;
}

// Warning: (ae-missing-release-tag) "NonSerializablePayloadError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `NonSerializablePayloadError`

```typescript
export class NonSerializablePayloadError extends Error {
    constructor(reason: string, path: string[]);
    readonly path: string[];
}
```

### `NOOP_SECRETS`

```typescript
export const NOOP_SECRETS: SecretsAccessor;

// Warning: (ae-missing-release-tag) "NOOP_SESSION_SINK" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `NOOP_SESSION_SINK`

```typescript
export const NOOP_SESSION_SINK: SessionEventSink;

// Warning: (ae-missing-release-tag) "NOOP_TELEMETRY_SINK" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `NOOP_TELEMETRY_SINK`

```typescript
export const NOOP_TELEMETRY_SINK: TelemetrySink;

// Warning: (ae-missing-release-tag) "noopLogger" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `noopLogger`

```typescript
export const noopLogger: LoggerPort;

// Warning: (ae-missing-release-tag) "NoopObservabilityPort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `NoopObservabilityPort`

```typescript
export class NoopObservabilityPort implements ObservabilityPort {
    flush(): Promise<void>;
    // Warning: (ae-forgotten-export) The symbol "ObservabilityEvent" needs to be exported by the entry point index.d.ts
    //
    recordEvent(_event: ObservabilityEvent): void;
    // Warning: (ae-forgotten-export) The symbol "MetricInput" needs to be exported by the entry point index.d.ts
    //
    recordMetric(_metric: MetricInput): void;
    // Warning: (ae-forgotten-export) The symbol "SpanAttributes" needs to be exported by the entry point index.d.ts
    // Warning: (ae-forgotten-export) The symbol "Span_2" needs to be exported by the entry point index.d.ts
    //
    startSpan(_name: string, _attrs?: SpanAttributes): Span_2;
}

// Warning: (ae-missing-release-tag) "NoopPrivacyAdapter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `NoopPrivacyAdapter`

```typescript
export class NoopPrivacyAdapter implements PrivacyPort {
    // Warning: (ae-forgotten-export) The symbol "RevelationMask" needs to be exported by the entry point index.d.ts
    // Warning: (ae-forgotten-export) The symbol "PrivacyContext" needs to be exported by the entry point index.d.ts
    //
    applyMask(payload: unknown, _mask: RevelationMask, _ctx: PrivacyContext): Promise<unknown>;
    // Warning: (ae-forgotten-export) The symbol "Commitment" needs to be exported by the entry point index.d.ts
    // Warning: (ae-forgotten-export) The symbol "SmtResult" needs to be exported by the entry point index.d.ts
    //
    commitToSmt(commitment: Commitment, _ctx: PrivacyContext): Promise<SmtResult>;
    // Warning: (ae-forgotten-export) The symbol "ZkProofInput" needs to be exported by the entry point index.d.ts
    // Warning: (ae-forgotten-export) The symbol "VerifyResult" needs to be exported by the entry point index.d.ts
    //
    verifyZkProof(_proof: ZkProofInput, _ctx: PrivacyContext): Promise<VerifyResult>;
}

// Warning: (ae-missing-release-tag) "NullTimestampPort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `NullTimestampPort`

```typescript
export class NullTimestampPort implements TimestampPort {
    request(_rootHash: string): Promise<SignedReceipt>;
    verify(_receipt: SignedReceipt, _rootHash: string): Promise<{
        valid: boolean;
        reason: string;
    }>;
}

// Warning: (ae-missing-release-tag) "ObservabilityPort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ObservabilityPort`

```typescript
export interface ObservabilityPort {
    flush(): Promise<void>;
    recordEvent(event: ObservabilityEvent): void;
    recordMetric(metric: MetricInput): void;
    startSpan(name: string, attrs?: SpanAttributes): Span_2;
}

// Warning: (ae-missing-release-tag) "OnUnknown" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `OnUnknown`

```typescript
export type OnUnknown = "escalate_human" | "proceed_with_log" | "proceed_with_audit_log";

// Warning: (ae-missing-release-tag) "OnUnsafe" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `OnUnsafe`

```typescript
export type OnUnsafe = "block" | "escalate_human";

// Warning: (ae-missing-release-tag) "OODAAgent" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `OODAAgent`

```typescript
export interface OODAAgent {
    getStatus(): {
        running: boolean;
        lastCycleAt?: string;
        nextCycleAt?: string;
        cyclesCompleted: number;
    };
    start(): Promise<void>;
    stop(): Promise<void>;
    streamCycle(opts: {
        dryRun: boolean;
        initialContext?: Record<string, unknown>;
    }): AsyncIterable<CycleEvent>;
    triggerCycle(opts: {
        dryRun: boolean;
        initialContext?: Record<string, unknown>;
    }): Promise<{
        runId: string;
        status: CycleStatus;
    }>;
}

// Warning: (ae-missing-release-tag) "OODAAgentConfig" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `OODAAgentConfig`

```typescript
export interface OODAAgentConfig<TConfig = unknown, TObs = unknown, TOrient = unknown, TDecision = unknown, TAction = unknown, TFeedback = unknown> {
    readonly agentId: string;
    readonly agentVersion?: string;
    readonly completeStepImpl?: OODAContext["completeStep"];
    readonly config?: TConfig;
    readonly configLoader?: AgentConfigLoader<TConfig>;
    readonly db: DbClient;
    readonly deps: OODAAgentDeps;
    readonly errorStepImpl?: OODAContext["errorStep"];
    readonly executionMode: ExecutionMode;
    readonly insertStepImpl?: OODAContext["insertStep"];
    readonly intervalMs: number;
    readonly logger: LoggerPort;
    readonly notifySlackImpl?: OODAContext["notifySlack"];
    readonly onStep?: (event: StepEvent) => void | Promise<void>;
    readonly outcomeMapping?: (feedback: TFeedback) => OutcomeRecord | null;
    readonly phases: {
        readonly observe: PhaseDef<void, TObs>;
        readonly orient: PhaseDef<TObs, TOrient>;
        readonly decide: PhaseDef<TOrient, TDecision>;
        readonly act: PhaseDef<TDecision, TAction>;
        readonly reflect?: PhaseDef<TAction & {
            decision: TDecision;
        }, TFeedback>;
        readonly feedback: PhaseDef<TAction, TFeedback>;
    };
    readonly resourceLimits?: ResourceLimits;
    readonly riskGuards?: readonly RiskGuard[];
    readonly sessionGuards?: readonly SessionGuard[];
    readonly skillCapture?: SkillCaptureOptions;
    readonly skills?: SkillRegistry;
    readonly telemetry?: TelemetrySink;
    readonly timestamping?: {
        readonly port: TimestampPort;
        readonly queue?: ReceiptQueue;
        readonly queueHmacKeyProvider?: KeyProvider;
        readonly queueHmacKeyId?: string;
        readonly when: "on-cycle-complete" | "on-demand" | "disabled";
    };
    readonly waitForHITL?: (ctx: {
        runId: string;
        stepId: string;
        payload: unknown;
    }) => Promise<void>;
}
```

### `OODAAgentDeps`

```typescript
export interface OODAAgentDeps {
    eventBus?: EventBusPort;
    hitl?: HITLPort;
    llm: LLMProviderPort;
    memory?: BrainPort;
    messaging?: MessagingChannelPort;
    registry?: AgentRegistryPort;
}

// Warning: (ae-missing-release-tag) "OODAAgentImpl" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `OODAAgentImpl`

```typescript
export class OODAAgentImpl<TConfig = unknown, TObs = unknown, TOrient = unknown, TDecision = unknown, TAction = unknown, TFeedback = unknown> implements OODAAgent {
    constructor(config: OODAAgentConfig<TConfig, TObs, TOrient, TDecision, TAction, TFeedback>);
    getStatus(): {
        running: boolean;
        lastCycleAt?: string;
        nextCycleAt?: string;
        cyclesCompleted: number;
    };
    start(): Promise<void>;
    stop(): Promise<void>;
    streamCycle(opts: {
        dryRun: boolean;
        initialContext?: Record<string, unknown>;
    }): AsyncGenerator<CycleEvent>;
    triggerCycle(opts: {
        dryRun: boolean;
        initialContext?: Record<string, unknown>;
    }): Promise<{
        runId: string;
        status: CycleStatus;
    }>;
}

// Warning: (ae-missing-release-tag) "OODAContext" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `OODAContext`

```typescript
export interface OODAContext<TConfig = unknown> {
    readonly agentId: string;
    readonly completeStep: (stepId: string, payload: Record<string, unknown>) => Promise<{
        leafHash: string;
    }>;
    readonly config: TConfig;
    readonly configLoader?: AgentConfigLoader<TConfig>;
    readonly cycleIndex: number;
    readonly db: DbClient;
    readonly deps: Partial<OODAAgentDeps>;
    readonly emitStep: (input: {
        type: OODAPhaseKind;
        phase: string;
        payload?: Record<string, unknown>;
        status?: "completed" | "failed" | "skipped";
        error?: Error | string;
    }) => void;
    readonly errorStep: (stepId: string, error: Error) => Promise<void>;
    readonly executionMode: ExecutionMode;
    readonly insertStep: (input: {
        type: OODAPhaseKind;
        phase: string;
        payload?: Record<string, unknown>;
    }) => Promise<{
        stepId: string;
    }>;
    readonly isReplay: boolean;
    readonly logger: LoggerPort;
    readonly notifySlack: (channel: string, text: string) => Promise<void>;
    readonly runId: string;
    readonly skills: SkillRegistry;
}
```

### `OODACycleInvoker`

```typescript
export interface OODACycleInvoker {
    invoke(ctx: StrategyAgentContext): Promise<AgentCycleResult>;
}

// Warning: (ae-missing-release-tag) "OODAPhaseKind" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `OODAPhaseKind`

```typescript
export type OODAPhaseKind = "retrieval" | "decision" | "execution" | "feedback" | "observation";

// Warning: (ae-missing-release-tag) "BulkheadOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `OrchestrationBulkheadOptions`

```typescript
export interface OrchestrationBulkheadOptions {
    maxConcurrent: number;
    maxQueue?: number;
    rejectOnFull?: boolean;
}

// Warning: (ae-missing-release-tag) "OrientationMemory" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `OrientationMemory`

```typescript
export interface OrientationMemory {
    content: string;
    entry_id: string;
    metadata: {
        kind: "orientation-memory";
        symbol: string;
        regime: string;
        observed_at: string;
    };
}

// Warning: (ae-missing-release-tag) "OrientInputWithBrain" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `OrientInputWithBrain`

```typescript
export interface OrientInputWithBrain<TObs> {
    readonly brainContext: BrainChunk[];
    readonly brainContextRefs: string[];
    readonly raw: TObs;
}

// Warning: (ae-missing-release-tag) "OtelClient" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `OtelClient`

```typescript
export interface OtelClient {
    // Warning: (ae-forgotten-export) The symbol "IngestSpansOptions" needs to be exported by the entry point index.d.ts
    //
    ingestSpans(spans: {
        resourceSpans: unknown[];
    }, opts?: IngestSpansOptions): Promise<IngestSpansResult>;
}

// Warning: (ae-missing-release-tag) "OtlpAttribute" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `OtlpAttribute`

```typescript
export interface OtlpAttribute {
    key: string;
    value: OtlpAttributeValue;
}

// Warning: (ae-missing-release-tag) "OtlpAttributeValue" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `OtlpAttributeValue`

```typescript
export interface OtlpAttributeValue {
    arrayValue?: {
        values: OtlpAttributeValue[];
    };
    boolValue?: boolean;
    doubleValue?: number;
    intValue?: string;
    stringValue?: string;
}

// Warning: (ae-missing-release-tag) "OtlpSpan" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `OtlpSpan`

```typescript
export interface OtlpSpan {
    attributes: OtlpAttribute[];
    endTimeUnixNano: string;
    kind?: number;
    name: string;
    parentSpanId?: string;
    spanId: string;
    startTimeUnixNano: string;
    status?: {
        code: number;
        message?: string;
    };
    traceId: string;
}

// Warning: (ae-missing-release-tag) "otlpTelemetrySink" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `otlpTelemetrySink`

```typescript
export function otlpTelemetrySink(opts: OtlpTelemetrySinkOptions): TelemetrySink;

// Warning: (ae-missing-release-tag) "OtlpTelemetrySinkOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `OtlpTelemetrySinkOptions`

```typescript
export interface OtlpTelemetrySinkOptions {
    fetchImpl?: typeof fetch;
    headers?: Record<string, string>;
    serviceName?: string;
    timeoutMs?: number;
    url: string;
}

// Warning: (ae-missing-release-tag) "Outcome" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `Outcome`

```typescript
export interface Outcome {
    agent_id: string;
    agent_run_id: string | null;
    currency: string;
    id: string;
    is_pending_backfill: boolean;
    metadata?: Record<string, unknown> | null;
    occurred_at: string;
    outcome_type: OutcomeType;
    value_cents: number;
}

// Warning: (ae-missing-release-tag) "OutcomeAttributionFailed" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `OutcomeAttributionFailed`

```typescript
export class OutcomeAttributionFailed extends PortError {
    constructor(runId: string, message: string, cause?: unknown);
    readonly port = "outcome";
    readonly runId: string;
}

// Warning: (ae-missing-release-tag) "OutcomeGateOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `OutcomeGateOptions`

```typescript
export interface OutcomeGateOptions {
    maxCumulativeCents?: number;
    maxValueCents?: number;
    minValueCents?: number;
}

// Warning: (ae-missing-release-tag) "OutcomeGateResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `OutcomeGateResult`

```typescript
export interface OutcomeGateResult {
    allowed: boolean;
    chargeableCents: number;
    reason?: string;
}

// Warning: (ae-missing-release-tag) "OutcomeHook" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `OutcomeHook`

```typescript
export interface OutcomeHook {
    onCycleEnd(runId: string, cost: CycleCost): Promise<void>;
}

// Warning: (ae-missing-release-tag) "OutcomePort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `OutcomePort`

```typescript
export interface OutcomePort {
    recordOutcomeAsync(run: AgentRunRef): void;
}

// Warning: (ae-missing-release-tag) "OutcomeRecord" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `OutcomeRecord`

```typescript
export interface OutcomeRecord {
    readonly confidence?: number;
    readonly is_pending_backfill?: boolean;
    readonly metadata?: Record<string, unknown>;
    readonly outcome_type: string;
    readonly quality?: number;
    readonly value_cents: number;
}

// Warning: (ae-missing-release-tag) "OutcomesApiError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `OutcomesApiError`

```typescript
export class OutcomesApiError extends Error {
    constructor(status: number, body: string, message?: string);
    readonly body: string;
    readonly status: number;
}

// Warning: (ae-missing-release-tag) "OutcomesClient" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `OutcomesClient`

```typescript
export interface OutcomesClient {
    cfo(period: {
        from: string;
        to: string;
    }): Promise<CfoView>;
    list(filter?: OutcomesListFilter): Promise<OutcomesListResponse>;
    roi(period: {
        from: string;
        to: string;
    }, opts?: {
        sortBy?: "net_roi_pct" | "value_cents";
        limit?: number;
    }): Promise<RoiPerAgent[]>;
    summary(period: {
        from: string;
        to: string;
    }): Promise<OutcomeSummary>;
}

// Warning: (ae-missing-release-tag) "OutcomesClientOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `OutcomesClientOptions`

```typescript
export interface OutcomesClientOptions {
    baseUrl: string;
    getToken: () => Promise<string>;
}

// Warning: (ae-missing-release-tag) "OutcomesListFilter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `OutcomesListFilter`

```typescript
export interface OutcomesListFilter {
    agentId?: string;
    cursor?: string;
    from?: string;
    limit?: number;
    to?: string;
    type?: OutcomeType;
}

// Warning: (ae-missing-release-tag) "OutcomesListResponse" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `OutcomesListResponse`

```typescript
export interface OutcomesListResponse {
    items: Outcome[];
    nextCursor?: string;
}

// Warning: (ae-missing-release-tag) "OutcomeSummary" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `OutcomeSummary`

```typescript
export interface OutcomeSummary {
    attributed_count: number;
    net_roi_pct: number | null;
    outcome_count: number;
    pending_attribution_count: number;
    period: {
        from: string;
        to: string;
    };
    total_cost_cents: number;
    total_value_cents: number;
    value_to_cost_ratio: number | null;
}

// Warning: (ae-missing-release-tag) "OutcomeTracker" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `OutcomeTracker`

```typescript
export class OutcomeTracker {
    constructor(policy: TierPolicy, hook?: OutcomeHook);
    flush(runId: string): Promise<void>;
    getCosts(windowMs?: number): CycleCost[];
    record(runId: string, model: string, inputTokens: number, outputTokens: number, durationMs: number, opts?: {
        skillId?: string;
        outcomeValue?: number;
        category?: string;
    }): CycleCost;
    totalCostInWindow(windowMs?: number): number;
}

// Warning: (ae-missing-release-tag) "OutcomeType" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `OutcomeType`

```typescript
export type OutcomeType = string;

// Warning: (ae-missing-release-tag) "OutcomeWriteError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `OutcomeWriteError`

```typescript
export class OutcomeWriteError extends Error {
    constructor(message: string, runId: string, cause?: unknown | undefined);
    readonly cause?: unknown | undefined;
    readonly runId: string;
}

// Warning: (ae-missing-release-tag) "PairingPayload" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PairingPayload`

```typescript
export interface PairingPayload {
    hostPubKey: string;
    pairingToken: string;
    relayUrl: string;
    sessionId: string;
    v: number;
}

// Warning: (ae-missing-release-tag) "ParentCycleContext" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ParentCycleContext`

```typescript
export interface ParentCycleContext {
    allowed_scope_ids?: string[];
    budgetUsdMax: number;
}

// Warning: (ae-missing-release-tag) "parseAllowedTools" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `parseAllowedTools`

```typescript
export function parseAllowedTools(manifest: SkillManifest): string[];

// Warning: (ae-missing-release-tag) "parseToken" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `parseAttenuatedToken`

```typescript
export function parseAttenuatedToken(token: AttenuatedToken): MeshCapabilityScope;

// Warning: (ae-missing-release-tag) "ParsedSkillFile" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ParsedSkillFile`

```typescript
export interface ParsedSkillFile {
    body: string;
    bodyTokens: number;
    manifest: SkillManifest;
    tier: VaubanSkillTier;
}

// Warning: (ae-forgotten-export) The symbol "PlanStep_2" needs to be exported by the entry point index.d.ts
//
```

### `parsePlanFromText`

```typescript
export function parsePlanFromText(text: string): PlanStep_2[] | null;
```

### `parseProtocolOutput`

```typescript
export function parseProtocolOutput<T = unknown>(stdout: string): ProtocolResult<T>;
```

### `parseReactToolCall`

```typescript
export function parseReactToolCall(content: string): StrategyToolCall | null;

// Warning: (ae-missing-release-tag) "parseSkillMd" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `parseSkillMd`

```typescript
export function parseSkillMd(raw: string, source?: string): ParsedSkillFile;
```

### `parseStderrLogs`

```typescript
export function parseStderrLogs(stderr: string): Array<{
    level: string;
    message: string;
    timestamp: string;
}>;

// Warning: (ae-missing-release-tag) "parseStructuredOutput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `parseStructuredOutput`

```typescript
export function parseStructuredOutput<T>(raw: string, opts?: ParseStructuredOutputOpts<T>): T;

// Warning: (ae-missing-release-tag) "ParseStructuredOutputError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ParseStructuredOutputError`

```typescript
export class ParseStructuredOutputError extends Error {
    constructor(message: string, raw: string, cause: unknown);
    readonly cause: unknown;
    readonly raw: string;
}

// Warning: (ae-missing-release-tag) "ParseStructuredOutputOpts" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ParseStructuredOutputOpts`

```typescript
export interface ParseStructuredOutputOpts<T> {
    fallback?: T;
    schema?: ZodSchema<T>;
}

// Warning: (ae-missing-release-tag) "payloadHash" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `payloadHash`

```typescript
export function payloadHash(value: unknown, policy: PayloadPolicy): Promise<PayloadHashResult>;

// Warning: (ae-missing-release-tag) "PayloadHashResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PayloadHashResult`

```typescript
export interface PayloadHashResult {
    hash: string;
    hmac?: string;
    policy: PayloadPolicy["kind"];
    storedValue?: unknown;
}

// Warning: (ae-forgotten-export) The symbol "IncludePolicy" needs to be exported by the entry point index.d.ts
// Warning: (ae-forgotten-export) The symbol "RedactPolicy" needs to be exported by the entry point index.d.ts
// Warning: (ae-forgotten-export) The symbol "HmacPolicy" needs to be exported by the entry point index.d.ts
// Warning: (ae-forgotten-export) The symbol "HashOnlyPolicy" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "PayloadPolicy" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PayloadPolicy`

```typescript
export type PayloadPolicy = IncludePolicy | RedactPolicy | HmacPolicy | HashOnlyPolicy;

// Warning: (ae-missing-release-tag) "PendingApproval" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PendingApproval`

```typescript
export interface PendingApproval {
    createdAt: number;
    expiresAt: number;
    id: string;
    req: ApprovalRequest;
    status: ApprovalStatus;
    verdict?: Approval;
}

// Warning: (ae-missing-release-tag) "permitsCapability" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `permitsCapability`

```typescript
export function permitsCapability(permissions: SdkPermissions, capability: SdkCapability): boolean;

// Warning: (ae-missing-release-tag) "permitsMcpScopes" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `permitsMcpScopes`

```typescript
export function permitsMcpScopes(permissions: SdkPermissions, required: readonly string[]): boolean;

// Warning: (ae-missing-release-tag) "PersistencePort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PersistencePort`

```typescript
export interface PersistencePort {
    clearAll(): Promise<void>;
    close(): Promise<void>;
    getMaxSeq(): Promise<number>;
    loadEvents(sinceSeq?: number): Promise<SessionEvent[]>;
    loadRevocations(): Promise<string[]>;
    saveEvent(event: SessionEvent): Promise<void>;
    saveRevocation(jti: string): Promise<void>;
}

// Warning: (ae-missing-release-tag) "PERSONA_BRAIN_CATEGORY" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PERSONA_BRAIN_CATEGORY`

```typescript
export const PERSONA_BRAIN_CATEGORY = "agent-persona";

// Warning: (ae-missing-release-tag) "PersonaAcknowledgmentStyle" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
// Warning: (ae-missing-release-tag) "PersonaAcknowledgmentStyle" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PersonaAcknowledgmentStyle`

```typescript
export const PersonaAcknowledgmentStyle: z.ZodEnum<["minimal", "detailed", "none"]>;
```

### `PersonaAcknowledgmentStyle`

```typescript
export type PersonaAcknowledgmentStyle = z.infer<typeof PersonaAcknowledgmentStyle>;

// Warning: (ae-missing-release-tag) "PersonaExplainReasoning" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
// Warning: (ae-missing-release-tag) "PersonaExplainReasoning" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PersonaExplainReasoning`

```typescript
export const PersonaExplainReasoning: z.ZodEnum<["always", "on_error", "never"]>;
```

### `PersonaExplainReasoning`

```typescript
export type PersonaExplainReasoning = z.infer<typeof PersonaExplainReasoning>;

// Warning: (ae-missing-release-tag) "PersonaFormality" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
// Warning: (ae-missing-release-tag) "PersonaFormality" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PersonaFormality`

```typescript
export const PersonaFormality: z.ZodEnum<["casual", "formal", "technical"]>;
```

### `PersonaFormality`

```typescript
export type PersonaFormality = z.infer<typeof PersonaFormality>;

// Warning: (ae-missing-release-tag) "PersonaSchema" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PersonaSchema`

```typescript
export const PersonaSchema: z.ZodObject<{
    identity: z.ZodOptional<z.ZodObject<{
        name: z.ZodOptional<z.ZodString>;
        role: z.ZodOptional<z.ZodString>;
        tone: z.ZodOptional<z.ZodEnum<["concise", "detailed", "pedagogical"]>>;
        formality: z.ZodOptional<z.ZodEnum<["casual", "formal", "technical"]>>;
        language: z.ZodOptional<z.ZodString>;
    }, "strict", z.ZodTypeAny, {
        name?: string | undefined;
        role?: string | undefined;
        tone?: "concise" | "detailed" | "pedagogical" | undefined;
        formality?: "casual" | "formal" | "technical" | undefined;
        language?: string | undefined;
    }, {
        name?: string | undefined;
        role?: string | undefined;
        tone?: "concise" | "detailed" | "pedagogical" | undefined;
        formality?: "casual" | "formal" | "technical" | undefined;
        language?: string | undefined;
    }>>;
    traits: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    domain_expertise: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    communication: z.ZodOptional<z.ZodObject<{
        max_response_length: z.ZodOptional<z.ZodNumber>;
        use_analogies: z.ZodOptional<z.ZodBoolean>;
        explain_reasoning: z.ZodOptional<z.ZodEnum<["always", "on_error", "never"]>>;
        acknowledgment_style: z.ZodOptional<z.ZodEnum<["minimal", "detailed", "none"]>>;
    }, "strict", z.ZodTypeAny, {
        max_response_length?: number | undefined;
        use_analogies?: boolean | undefined;
        explain_reasoning?: "never" | "always" | "on_error" | undefined;
        acknowledgment_style?: "none" | "minimal" | "detailed" | undefined;
    }, {
        max_response_length?: number | undefined;
        use_analogies?: boolean | undefined;
        explain_reasoning?: "never" | "always" | "on_error" | undefined;
        acknowledgment_style?: "none" | "minimal" | "detailed" | undefined;
    }>>;
    directives: z.ZodOptional<z.ZodObject<{
        must: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        must_not: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "strict", z.ZodTypeAny, {
        must?: string[] | undefined;
        must_not?: string[] | undefined;
    }, {
        must?: string[] | undefined;
        must_not?: string[] | undefined;
    }>>;
    forbidden_patterns: z.ZodOptional<z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        pattern: z.ZodString;
        scope: z.ZodOptional<z.ZodString>;
    }, "strict", z.ZodTypeAny, {
        name: string;
        pattern: string;
        scope?: string | undefined;
    }, {
        name: string;
        pattern: string;
        scope?: string | undefined;
    }>, "many">>;
    whitelist: z.ZodOptional<z.ZodObject<{
        hashtags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        mentions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "strict", z.ZodTypeAny, {
        hashtags?: string[] | undefined;
        mentions?: string[] | undefined;
    }, {
        hashtags?: string[] | undefined;
        mentions?: string[] | undefined;
    }>>;
    examples: z.ZodOptional<z.ZodArray<z.ZodObject<{
        situation: z.ZodString;
        bad: z.ZodOptional<z.ZodString>;
        good: z.ZodOptional<z.ZodString>;
    }, "strict", z.ZodTypeAny, {
        situation: string;
        good?: string | undefined;
        bad?: string | undefined;
    }, {
        situation: string;
        good?: string | undefined;
        bad?: string | undefined;
    }>, "many">>;
    output_contracts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        description: z.ZodOptional<z.ZodString>;
        schema_hint: z.ZodOptional<z.ZodString>;
    }, "strict", z.ZodTypeAny, {
        description?: string | undefined;
        schema_hint?: string | undefined;
    }, {
        description?: string | undefined;
        schema_hint?: string | undefined;
    }>>>;
    extra_instructions: z.ZodOptional<z.ZodString>;
}, "strict", z.ZodTypeAny, {
    identity?: {
        name?: string | undefined;
        role?: string | undefined;
        tone?: "concise" | "detailed" | "pedagogical" | undefined;
        formality?: "casual" | "formal" | "technical" | undefined;
        language?: string | undefined;
    } | undefined;
    traits?: string[] | undefined;
    domain_expertise?: string[] | undefined;
    communication?: {
        max_response_length?: number | undefined;
        use_analogies?: boolean | undefined;
        explain_reasoning?: "never" | "always" | "on_error" | undefined;
        acknowledgment_style?: "none" | "minimal" | "detailed" | undefined;
    } | undefined;
    directives?: {
        must?: string[] | undefined;
        must_not?: string[] | undefined;
    } | undefined;
    forbidden_patterns?: {
        name: string;
        pattern: string;
        scope?: string | undefined;
    }[] | undefined;
    whitelist?: {
        hashtags?: string[] | undefined;
        mentions?: string[] | undefined;
    } | undefined;
    examples?: {
        situation: string;
        good?: string | undefined;
        bad?: string | undefined;
    }[] | undefined;
    output_contracts?: Record<string, {
        description?: string | undefined;
        schema_hint?: string | undefined;
    }> | undefined;
    extra_instructions?: string | undefined;
}, {
    identity?: {
        name?: string | undefined;
        role?: string | undefined;
        tone?: "concise" | "detailed" | "pedagogical" | undefined;
        formality?: "casual" | "formal" | "technical" | undefined;
        language?: string | undefined;
    } | undefined;
    traits?: string[] | undefined;
    domain_expertise?: string[] | undefined;
    communication?: {
        max_response_length?: number | undefined;
        use_analogies?: boolean | undefined;
        explain_reasoning?: "never" | "always" | "on_error" | undefined;
        acknowledgment_style?: "none" | "minimal" | "detailed" | undefined;
    } | undefined;
    directives?: {
        must?: string[] | undefined;
        must_not?: string[] | undefined;
    } | undefined;
    forbidden_patterns?: {
        name: string;
        pattern: string;
        scope?: string | undefined;
    }[] | undefined;
    whitelist?: {
        hashtags?: string[] | undefined;
        mentions?: string[] | undefined;
    } | undefined;
    examples?: {
        situation: string;
        good?: string | undefined;
        bad?: string | undefined;
    }[] | undefined;
    output_contracts?: Record<string, {
        description?: string | undefined;
        schema_hint?: string | undefined;
    }> | undefined;
    extra_instructions?: string | undefined;
}>;

// Warning: (ae-missing-release-tag) "personaTags" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `personaTags`

```typescript
export function personaTags(agentId: string): string[];

// Warning: (ae-missing-release-tag) "PersonaTone" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
// Warning: (ae-missing-release-tag) "PersonaTone" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PersonaTone`

```typescript
export const PersonaTone: z.ZodEnum<["concise", "detailed", "pedagogical"]>;
```

### `PersonaTone`

```typescript
export type PersonaTone = z.infer<typeof PersonaTone>;

// Warning: (ae-missing-release-tag) "PhaseDef" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PhaseDef`

```typescript
export interface PhaseDef<TInput, TOutput> {
    readonly fn: (input: TInput, ctx: OODAContext) => Promise<TOutput>;
    readonly hitlGate?: boolean;
    readonly readOnly?: boolean;
    readonly type: OODAPhaseKind;
}

// Warning: (ae-missing-release-tag) "PhaseModelConfig" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PhaseModelConfig`

```typescript
export interface PhaseModelConfig {
    defaultModel: ModelSpec;
    phases: Partial<Record<OODAPhaseKind, ModelSpec>>;
}

// Warning: (ae-missing-release-tag) "PII_GUARD" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PII_GUARD`

```typescript
export const PII_GUARD: GuardrailDef<string>;

// Warning: (ae-missing-release-tag) "PIIDetector" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PIIDetector`

```typescript
export type PIIDetector = (value: unknown) => boolean;

// Warning: (ae-missing-release-tag) "PipelineListEntry" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PipelineListEntry`

```typescript
export interface PipelineListEntry {
    name: string;
    schedule?: string;
    tier: 1 | 2;
}

// Warning: (ae-missing-release-tag) "PipelineRunInput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PipelineRunInput`

```typescript
export interface PipelineRunInput {
    name: string;
    payload?: Record<string, unknown>;
}

// Warning: (ae-missing-release-tag) "PipelineRunResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PipelineRunResult`

```typescript
export interface PipelineRunResult {
    pipelineId: string;
    runId: string;
    statusUrl: string;
}

// Warning: (ae-missing-release-tag) "PipelinesClient" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PipelinesClient`

```typescript
export interface PipelinesClient {
    list(): Promise<{
        pipelines: PipelineListEntry[];
    }>;
    run(input: PipelineRunInput): Promise<PipelineRunResult>;
    status(pipelineId: string): Promise<{
        status: string;
        progress: number;
    }>;
}

// Warning: (ae-missing-release-tag) "PipelinesClientOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PipelinesClientOptions`

```typescript
export interface PipelinesClientOptions {
    baseUrl: string;
    getToken: () => Promise<string>;
}

// Warning: (ae-missing-release-tag) "Plan" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `Plan`

```typescript
export interface Plan {
    estimatedTokens?: number;
    goal: string;
    steps: PlanStep[];
}

// Warning: (ae-missing-release-tag) "PlanExecutionResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PlanExecutionResult`

```typescript
export interface PlanExecutionResult {
    completedSteps: number;
    failedSteps: number;
    plan: Plan;
    results: StepResult[];
    totalDurationMs: number;
}
```

### `PlanStep`

```typescript
export interface PlanStep {
    description: string;
    index: number;
    params?: Record<string, unknown>;
    tool?: string;
}

// Warning: (ae-missing-release-tag) "PolicyAction" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PolicyAction`

```typescript
export type PolicyAction = "proceed" | "block" | "escalate_human" | "log";

// Warning: (ae-missing-release-tag) "PolicyConflict" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PolicyConflict`

```typescript
export interface PolicyConflict {
    readonly description: string;
    readonly rule1Id: string;
    readonly rule2Id: string;
    readonly status: "CONFLICT" | "CONFLICT_UNDETERMINED";
}

// Warning: (ae-missing-release-tag) "PolicyDecision" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PolicyDecision`

```typescript
export interface PolicyDecision {
    action: PolicyAction;
    rationale: string;
}

// Warning: (ae-missing-release-tag) "PolicyValidation" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PolicyValidation`

```typescript
export interface PolicyValidation {
    readonly policy_hash?: string;
    readonly valid: boolean;
    readonly violations: readonly string[];
}

// Warning: (ae-missing-release-tag) "PortError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PortError`

```typescript
export abstract class PortError extends Error {
    constructor(message: string, options?: {
        cause?: unknown;
        retryable?: boolean;
    });
    abstract readonly port: string;
    readonly retryable: boolean;
}

// Warning: (ae-missing-release-tag) "PortfolioId" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PortfolioId`

```typescript
export type PortfolioId = string & {
    readonly __brand: "PortfolioId";
};

// Warning: (ae-missing-release-tag) "PostgresAgentRegistry" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PostgresAgentRegistry`

```typescript
export class PostgresAgentRegistry implements AgentRegistryPort {
    constructor(db: DbClient);
    list(filter?: Partial<AgentRegistryDescriptor>): Promise<AgentRegistryDescriptor[]>;
    register(descriptor: AgentRegistryDescriptor): Promise<void>;
    resolve(capability: string, opts?: {
        tenantId?: string;
    }): Promise<AgentRegistryDescriptor[]>;
    unregister(id: string): Promise<void>;
}

// Warning: (ae-missing-release-tag) "PostgresHITLStateStore" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PostgresHITLStateStore`

```typescript
export class PostgresHITLStateStore implements HITLPort {
    constructor(input: {
        db: DbClient;
    });
    await(id: string, timeoutMs?: number): Promise<HITLState>;
    expire(id: string): Promise<void>;
    _expireOverdue(): Promise<void>;
    getState(id: string): Promise<HITLState>;
    request(req: HITLRequest): Promise<string>;
    resolve(id: string, decision: "approved" | "rejected", by: string): Promise<void>;
}

// Warning: (ae-missing-release-tag) "PostmortemInput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PostmortemInput`

```typescript
export interface PostmortemInput {
    readonly campaign_slug: string;
    readonly lessons: readonly string[];
    readonly metrics: Readonly<Record<string, number>>;
    readonly outcome: "success" | "partial" | "failure";
    readonly what_failed: readonly string[];
    readonly what_worked: readonly string[];
}

// Warning: (ae-missing-release-tag) "PriceEntry" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PriceEntry`

```typescript
export interface PriceEntry {
    asset: string;
    fetchedAt: string;
    priceUsd: number;
    source: string;
}

// Warning: (ae-missing-release-tag) "PricePort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PricePort`

```typescript
export interface PricePort {
    getPrice(asset: string): Promise<number | null>;
    getPrices(assets: string[]): Promise<Record<string, number | null>>;
}

// Warning: (ae-missing-release-tag) "PrivacyNoopWarning" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PrivacyNoopWarning`

```typescript
export class PrivacyNoopWarning extends Error {
    constructor(message: string, operation: string);
    readonly operation: string;
}

// Warning: (ae-missing-release-tag) "PrivacyPort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PrivacyPort`

```typescript
export interface PrivacyPort {
    applyMask(payload: unknown, mask: RevelationMask, ctx: PrivacyContext): Promise<unknown>;
    commitToSmt(commitment: Commitment, ctx: PrivacyContext): Promise<SmtResult>;
    verifyZkProof(proof: ZkProofInput, ctx: PrivacyContext): Promise<VerifyResult>;
}

// Warning: (ae-missing-release-tag) "ProceduralMemoryPort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ProceduralMemoryPort`

```typescript
export interface ProceduralMemoryPort {
    registerSkill(agentId: string, skill: ProceduralSkill): Promise<void>;
    resolveSkills(agentId: string): Promise<ProceduralSkill[]>;
    shareSkill(skillName: string, fromAgentId: string, toAgentIds: string[]): Promise<void>;
}

// Warning: (ae-missing-release-tag) "ProceduralSkill" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ProceduralSkill`

```typescript
export interface ProceduralSkill {
    chainOfThought?: string;
    confidence: number;
    description: string;
    name: string;
    source: "learning-loop" | "manual" | "shared";
}
```

### `ProductiveQualityInputs`

```typescript
export interface ProductiveQualityInputs extends QualityInputs {
    readonly workUnits?: number;
}

// Warning: (ae-missing-release-tag) "PROFITABLE" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PROFITABLE`

```typescript
export const PROFITABLE: Axiom;

// Warning: (ae-missing-release-tag) "profitableScorer" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `profitableScorer`

```typescript
export const profitableScorer: ScoringFunction;
```

### `ProgressCallback`

```typescript
export type ProgressCallback = (value: number, message?: string) => void;

// Warning: (ae-missing-release-tag) "PromiseProgressConfig" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PromiseProgressConfig`

```typescript
export interface PromiseProgressConfig {
    plateauEpsilon?: number;
    plateauWindow?: number;
}

// Warning: (ae-missing-release-tag) "PromiseProgressSnapshot" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PromiseProgressSnapshot`

```typescript
export interface PromiseProgressSnapshot {
    isPlateau: boolean;
    observations: number;
    progress: number;
    promise: number;
}

// Warning: (ae-missing-release-tag) "PromiseProgressTracker" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PromiseProgressTracker`

```typescript
export class PromiseProgressTracker {
    constructor(goal: string, embedFn: EmbedFn, config?: PromiseProgressConfig);
    observe(output: string): Promise<PromiseProgressSnapshot>;
    reset(newGoal?: string): Promise<void>;
    snapshot(): PromiseProgressSnapshot;
}

// Warning: (ae-missing-release-tag) "ProofChain" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ProofChain`

```typescript
export interface ProofChain {
    algorithm: "sha-256";
    entries: ProofChainEntry[];
    rootHash: string;
}

// Warning: (ae-missing-release-tag) "ProofChainEntry" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ProofChainEntry`

```typescript
export interface ProofChainEntry {
    index: number;
    stepHash: string;
}

// Warning: (ae-missing-release-tag) "ProofClaim" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ProofClaim`

```typescript
export interface ProofClaim {
    agent: {
        id: string;
        version: string;
    };
    agentSignature?: string;
    claimSignature?: string;
    completedAt: string;
    exportedAt: string;
    paymentReceipt?: SettlementReceipt;
    // Warning: (ae-forgotten-export) The symbol "ProofReceipt" needs to be exported by the entry point index.d.ts
    receipt?: ProofReceipt;
    rootHash: string;
    runId: string;
    startedAt: string;
    status: Trace["status"];
    stepCount: number;
    task?: string;
    traceSha256: string;
    readonly type: "preste-proof-claim";
    // Warning: (ae-forgotten-export) The symbol "PROOF_CLAIM_VERSION" needs to be exported by the entry point index.d.ts
    //
    readonly version: typeof PROOF_CLAIM_VERSION;
}

// Warning: (ae-missing-release-tag) "ProofClaimVerification" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ProofClaimVerification`

```typescript
export interface ProofClaimVerification {
    reasons: string[];
    valid: boolean;
}

// Warning: (ae-missing-release-tag) "ProofGrade" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ProofGrade`

```typescript
export type ProofGrade = "attestation" | "attestation_custody_compatible" | "custody";
```

### `PROTOCOL_ENV`

```typescript
export const PROTOCOL_ENV: {
    readonly EXECUTION_ID: "VAUBAN_EXECUTION_ID";
    readonly AUTOMATION_NAME: "VAUBAN_AUTOMATION_NAME";
    readonly INPUT: "VAUBAN_INPUT";
    readonly TIMEOUT: "VAUBAN_TIMEOUT";
    readonly MODE: "VAUBAN_MODE";
};
```

### `ProtocolParseError`

```typescript
export class ProtocolParseError extends Error {
    constructor(reason: string, rawTail: string);
    readonly rawTail: string;
}
```

### `ProtocolResult`

```typescript
export type ProtocolResult<T = unknown> = {
    readonly status: "completed";
    readonly output: T;
} | {
    readonly status: "failed";
    readonly error: {
        readonly code: string;
        readonly message: string;
        readonly details?: unknown;
    };
};
```

### `ProtocolStatus`

```typescript
export type ProtocolStatus = "completed" | "failed";

// Warning: (ae-missing-release-tag) "ProviderRouter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ProviderRouter`

```typescript
export interface ProviderRouter {
    complete(request: ProviderRouterRequest): Promise<ProviderRouterResponse>;
}

// Warning: (ae-missing-release-tag) "ProviderRouterError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ProviderRouterError`

```typescript
export class ProviderRouterError extends Error {
    constructor(message: string, cause?: unknown | undefined);
    readonly cause?: unknown | undefined;
}

// Warning: (ae-missing-release-tag) "ProviderRouterRequest" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ProviderRouterRequest`

```typescript
export interface ProviderRouterRequest {
    maxTokens?: number;
    messages: Array<{
        role: string;
        content: string;
        toolName?: string;
    }>;
    tools?: unknown[];
}

// Warning: (ae-missing-release-tag) "ProviderRouterResponse" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ProviderRouterResponse`

```typescript
export interface ProviderRouterResponse {
    content: string;
    latencyMs: number;
    provider: string;
    toolCalls: Array<{
        name: string;
        args: unknown;
    }>;
    usage: {
        inputTokens: number;
        outputTokens: number;
    };
}

// Warning: (ae-missing-release-tag) "ProviderTier" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ProviderTier`

```typescript
export interface ProviderTier {
    costPerInputToken: number;
    costPerOutputToken: number;
    name: "free" | "cheap" | "mid" | "premium";
    qualityScore: number;
}

// Warning: (ae-missing-release-tag) "publishAllSignals" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `publishAllSignals`

```typescript
export function publishAllSignals(brainPort: SignalBrainPort, cycle: CycleSnapshot, scores: AxiomScoreEntry[]): Promise<void>;

// Warning: (ae-missing-release-tag) "PublishContext" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PublishContext`

```typescript
export interface PublishContext {
    readonly actionId: string;
    readonly campaignSlug: string;
}

// Warning: (ae-missing-release-tag) "PublisherChannel" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PublisherChannel`

```typescript
export type PublisherChannel = "x" | "linkedin" | "rempart" | "email" | "discord" | "github" | string;

// Warning: (ae-missing-release-tag) "PublisherPort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PublisherPort`

```typescript
export interface PublisherPort {
    readonly channel: PublisherChannel;
    isConfigured(): Promise<boolean>;
    publish(input: PublishInput): Promise<PublishResult>;
}

// Warning: (ae-missing-release-tag) "PublisherRegistry" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PublisherRegistry`

```typescript
export interface PublisherRegistry {
    channels(): readonly string[];
    get(channel: string): PublisherPort | null;
    pick(actionType: string, payload: Record<string, unknown> | null | undefined): PublisherPort | null;
}

// Warning: (ae-missing-release-tag) "PublisherRegistryInput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PublisherRegistryInput`

```typescript
export interface PublisherRegistryInput {
    readonly discord?: PublisherPort;
    readonly email?: PublisherPort;
    readonly extras?: Readonly<Record<string, PublisherPort>>;
    readonly github?: PublisherPort;
    readonly linkedin?: PublisherPort;
    readonly rempart?: PublisherPort;
    readonly x?: PublisherPort;
}

// Warning: (ae-missing-release-tag) "PublishInput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PublishInput`

```typescript
export interface PublishInput {
    readonly context: PublishContext;
    readonly payload: Record<string, unknown>;
    readonly persona?: AgentPersona;
}

// Warning: (ae-missing-release-tag) "PublishResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PublishResult`

```typescript
export interface PublishResult {
    readonly channel: string;
    readonly error?: string;
    readonly partial_failure_tweets?: number[];
    readonly posted_at?: string;
    readonly posted_id?: string;
    readonly posted_url?: string;
    readonly reason?: string;
    readonly status: PublishStatus;
}

// Warning: (ae-missing-release-tag) "publishSignal" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `publishSignal`

```typescript
export function publishSignal(brainPort: SignalBrainPort, cycle: CycleSnapshot, axiomId: AxiomId, score: number, rationale: string): Promise<void>;

// Warning: (ae-missing-release-tag) "PublishStatus" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `PublishStatus`

```typescript
export type PublishStatus = "published" | "dlq" | "failed" | "partial";
```

### `QualityBreakdown`

```typescript
export interface QualityBreakdown {
    readonly contributions: readonly QualityContribution[];
    readonly score: number;
}
```

### `QualityContribution`

```typescript
export interface QualityContribution {
    readonly delta: number;
    readonly reason: string;
    readonly signal: string;
}
```

### `QualityInputs`

```typescript
export interface QualityInputs {
    readonly alertsSent?: number;
    readonly customScore?: number;
    readonly errorsEncountered?: number;
    readonly invoicesProcessed?: number;
    readonly lessons?: readonly unknown[];
    readonly postsPublished?: number;
    readonly postsRejectedByHITL?: number;
    readonly threatsBlocked?: number;
}

// Warning: (ae-missing-release-tag) "queryReflexionMemory" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `queryReflexionMemory`

```typescript
export function queryReflexionMemory(query: ReflexionQuery, querier: (q: string, filters?: Record<string, unknown>) => Promise<ReflexionEntry[]>): Promise<ReflexionEntry[]>;

// Warning: (ae-missing-release-tag) "QueueArchetype" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `QueueArchetype`

```typescript
export type QueueArchetype = "cron" | "event" | "interactive" | "orchestration";

// Warning: (ae-missing-release-tag) "RandomPort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RandomPort`

```typescript
export interface RandomPort {
    crypto(bytes: number): Promise<Uint8Array>;
    cryptoUuid(): string;
    next(): number;
    uuid(): string;
}

// Warning: (ae-missing-release-tag) "reactLoop" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `reactLoop`

```typescript
export function reactLoop(opts: ReactLoopOptions): Promise<ReactResult>;
```

### `ReactLoopLogger`

```typescript
export interface ReactLoopLogger {
    warn: (msg: string, meta?: Record<string, unknown>) => void;
}

// Warning: (ae-missing-release-tag) "ReactLoopOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ReactLoopOptions`

```typescript
export interface ReactLoopOptions {
    allowedTools?: string[];
    executeTool: (call: ToolCall) => Promise<string>;
    finalizeAsTool?: boolean;
    finalizeToolName?: string;
    llm: LLMCompletionFn;
    logger?: ReactLoopLogger;
    loopId?: string;
    maxSteps?: number;
    maxToolCallSize?: number;
    onStep?: (step: ReactStep, meta: ReactStepMeta) => void | Promise<void>;
    signal?: AbortSignal;
    systemPrompt: string;
    task: string;
}

// Warning: (ae-missing-release-tag) "ReactMessage" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ReactMessage`

```typescript
export interface ReactMessage {
    content: string;
    name?: string;
    role: "system" | "user" | "assistant" | "tool";
    tool_call_id?: string;
}

// Warning: (ae-missing-release-tag) "ReactResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ReactResult`

```typescript
export interface ReactResult {
    answer: string;
    steps: ReactStep[];
    totalSteps: number;
    truncated: boolean;
}

// Warning: (ae-missing-release-tag) "ReactStep" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ReactStep`

```typescript
export interface ReactStep {
    action?: ToolCall;
    error?: string;
    index: number;
    observation?: string;
    thought: string;
}
```

### `ReactStepMeta`

```typescript
export interface ReactStepMeta {
    durationMs: number;
    iteration: number;
    loopId?: string;
}

// Warning: (ae-missing-release-tag) "readExecutionModeFromEnv" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `readExecutionModeFromEnv`

```typescript
export function readExecutionModeFromEnv(env: Record<string, string | undefined>, varName?: string): ExecutionMode;

// Warning: (ae-missing-release-tag) "RealClock" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RealClock`

```typescript
export class RealClock implements ClockPort {
    now(): number;
}

// Warning: (ae-missing-release-tag) "RealRandom" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RealRandom`

```typescript
export class RealRandom implements RandomPort {
    constructor(seed?: number);
    crypto(bytes: number): Promise<Uint8Array>;
    cryptoUuid(): string;
    next(): number;
    uuid(): string;
}

// Warning: (ae-missing-release-tag) "recallEpisodicRrf" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `recallEpisodicRrf`

```typescript
export function recallEpisodicRrf(entries: EpisodicMemoryEntry[], opts?: RecallRrfOptions): ScoredEntry<EpisodicMemoryEntry>[];

// Warning: (ae-missing-release-tag) "RecallRrfOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RecallRrfOptions`

```typescript
export interface RecallRrfOptions extends RrfOptions {
    cosine?: EpisodicCosineFn;
}

// Warning: (ae-missing-release-tag) "ReceiptQueue" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ReceiptQueue`

```typescript
export interface ReceiptQueue {
    enqueue(entry: Omit<ReceiptQueueEntry, "hmac" | "attempts">, keyProvider: KeyProvider, keyId: string): Promise<void>;
    pending(): Promise<ReceiptQueueEntry[]>;
    process(adapter: TimestampPort, keyProvider: KeyProvider, keyId: string, opts?: {
        batchSize?: number;
        backoffMs?: readonly number[];
    }): Promise<{
        processed: number;
        failed: number;
        rejected: number;
    }>;
    size?(): Promise<number>;
}

// Warning: (ae-missing-release-tag) "ReceiptQueueEntry" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ReceiptQueueEntry`

```typescript
export interface ReceiptQueueEntry {
    attempts: number;
    hmac: string;
    queuedAt: number;
    rootHash: string;
    runId: string;
}

// Warning: (ae-missing-release-tag) "ReceiptStatus" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ReceiptStatus`

```typescript
export type ReceiptStatus = "present" | "pending" | "failed";

// Warning: (ae-missing-release-tag) "recencyScore" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `recencyScore`

```typescript
export function recencyScore(nowMs: number, timestampMs: number, halflifeMs: number): number;

// Warning: (ae-missing-release-tag) "recommendStrategy" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `recommendStrategy`

```typescript
export function recommendStrategy(difficulty: DifficultyClass): string;

// Warning: (ae-missing-release-tag) "reconstructInitialMessages" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `reconstructInitialMessages`

```typescript
export function reconstructInitialMessages(trace: Trace, opts: ReconstructOptions): ReplayMessage[];

// Warning: (ae-missing-release-tag) "ReconstructOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ReconstructOptions`

```typescript
export interface ReconstructOptions {
    originalUserMessage?: string;
    toStep: number;
}

// Warning: (ae-missing-release-tag) "RecordedClock" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RecordedClock`

```typescript
export class RecordedClock implements ClockPort {
    constructor(recordedTs: readonly number[]);
    clone(): RecordedClock;
    getCursor(): number;
    now(): number;
    reset(): void;
}

// Warning: (ae-missing-release-tag) "RecordedRandom" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RecordedRandom`

```typescript
export class RecordedRandom implements RandomPort {
    constructor(recordedNext: readonly number[], recordedUuids: readonly string[], mode?: "strict" | "tolerant");
    clone(): RecordedRandom;
    crypto(bytes: number): Promise<Uint8Array>;
    cryptoUuid(): string;
    getNextCursor(): number;
    getUuidCursor(): number;
    next(): number;
    uuid(): string;
}

// Warning: (ae-missing-release-tag) "recordHITLDecision" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `recordHITLDecision`

```typescript
export function recordHITLDecision(db: DbClient, hitlId: string, decision: HITLDecision, resolverUserId: string, rationale?: string): Promise<void>;

// Warning: (ae-missing-release-tag) "recordLlmUsage" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `recordLlmUsage`

```typescript
export function recordLlmUsage(span: Span, usage: {
    inputTokens: number;
    outputTokens: number;
    latencyMs: number;
    finishReason?: string;
    responseId?: string;
}): void;

// Warning: (ae-missing-release-tag) "recordOutcome" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `recordOutcome`

```typescript
export function recordOutcome(span: Span, outcome: {
    stopReason: string;
    inputTokens: number;
    outputTokens: number;
    stepCount?: number;
}): void;

// Warning: (ae-missing-release-tag) "RecordOutcomeOutput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RecordOutcomeOutput`

```typescript
export interface RecordOutcomeOutput {
    id: string;
    is_pending_backfill: boolean;
}

// Warning: (ae-forgotten-export) The symbol "RecordOutcomeInput" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "recordOutcomeSkill" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `recordOutcomeSkill`

```typescript
export const recordOutcomeSkill: Skill<RecordOutcomeInput, RecordOutcomeOutput>;

// Warning: (ae-missing-release-tag) "recordRevocation" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `recordRevocation`

```typescript
export function recordRevocation(jti: string, alreadyRevoked: boolean): void;

// Warning: (ae-missing-release-tag) "recordToolResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `recordToolResult`

```typescript
export function recordToolResult(span: Span, result: {
    success: boolean;
    errorMessage?: string;
    outputSizeBytes?: number;
}): void;

// Warning: (ae-missing-release-tag) "redisCircuitBreaker" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `redisCircuitBreaker`

```typescript
export function redisCircuitBreaker(opts: RedisCircuitBreakerOptions): RiskGuard;

// Warning: (ae-missing-release-tag) "RedisCircuitBreakerOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RedisCircuitBreakerOptions`

```typescript
export interface RedisCircuitBreakerOptions {
    failureThreshold: number;
    name: string;
```

### `RedisClientLike`

```typescript
export interface RedisClientLike {
    set(key: string, value: string, options: {
        nx: true;
        px: number;
    }): Promise<string | null>;
}

// Warning: (ae-missing-release-tag) "RedisNonceStore" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RedisNonceStore`

```typescript
export class RedisNonceStore implements NonceStore {
    constructor(redis: RedisClientLike);
    setNX(key: string, ttlMs: number): Promise<boolean>;
}
```

### `ReflexionEntry`

```typescript
export interface ReflexionEntry {
    confidence: number;
    content: string;
    outcomeType: "succeeded" | "failed" | "partial";
    sourceCycleId: string;
    ttlMs?: number;
}

// Warning: (ae-missing-release-tag) "ReflexionQuery" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ReflexionQuery`

```typescript
export interface ReflexionQuery {
    agentId: string;
    limit?: number;
    outcomeType?: "succeeded" | "failed" | "partial";
}

// Warning: (ae-missing-release-tag) "RegisteredScorer" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RegisteredScorer`

```typescript
export interface RegisteredScorer {
    axiomId: AxiomId | string;
    scorer: ScoringFunction;
}

// Warning: (ae-missing-release-tag) "RegistrationResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RegistrationResult`

```typescript
export interface RegistrationResult {
    readonly claim_id: string;
    readonly errors?: readonly ComplianceError[];
    readonly manifest_id?: string;
    // Warning: (ae-forgotten-export) The symbol "RegistrationStatus" needs to be exported by the entry point index.d.ts
    //
    readonly status: RegistrationStatus;
}

// Warning: (ae-missing-release-tag) "RelayConnection" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RelayConnection`

```typescript
export interface RelayConnection {
    close(): Promise<void>;
    isPaired(): boolean;
    readonly pairing: PairingPayload;
}

// Warning: (ae-missing-release-tag) "RemoteApprovalChannel" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RemoteApprovalChannel`

```typescript
export interface RemoteApprovalChannel extends ApprovalChannel {
    dispose(): void;
    // Warning: (ae-forgotten-export) The symbol "RemoteHitlRecord" needs to be exported by the entry point index.d.ts
    history(): RemoteHitlRecord[];
    pending(): Array<{
        id: string;
        action: string;
        context: string;
    }>;
    resolve(id: string, approved: boolean, by: string, note?: string): boolean;
}

// Warning: (ae-missing-release-tag) "RemoteControlPort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RemoteControlPort`

```typescript
export interface RemoteControlPort extends SessionEventSink {
    backlog(sinceSeq?: number): SessionEvent[];
    readonly inbox: InstructionInbox;
    state(): SessionState;
    subscribe(fn: (event: SessionEvent) => void): () => void;
    readonly vetoChannel: VetoChannel;
}

// Warning: (ae-missing-release-tag) "RemoteControlServerHandle" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RemoteControlServerHandle`

```typescript
export interface RemoteControlServerHandle {
    close(): Promise<void>;
    readonly url: string;
}

// Warning: (ae-missing-release-tag) "RempartMcpCaller" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RempartMcpCaller`

```typescript
export type RempartMcpCaller = (tool: string, args: Record<string, unknown>) => Promise<Record<string, unknown>>;

// Warning: (ae-missing-release-tag) "RempartPublisher" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RempartPublisher`

```typescript
export class RempartPublisher implements PublisherPort {
    constructor(cfg: RempartPublisherConfig);
    readonly channel: "rempart";
    isConfigured(): Promise<boolean>;
    publish(input: PublishInput): Promise<PublishResult>;
}

// Warning: (ae-missing-release-tag) "RempartPublisherConfig" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RempartPublisherConfig`

```typescript
export interface RempartPublisherConfig {
    readonly mcpCaller: RempartMcpCaller;
}

// Warning: (ae-forgotten-export) The symbol "RenderOptions" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "renderEventForChat" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `renderEventForChat`

```typescript
export function renderEventForChat(event: SessionEvent, opts?: RenderOptions): string | null;

// Warning: (ae-missing-release-tag) "RenewalManager" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RenewalManager`

```typescript
export class RenewalManager {
    constructor(opts: RenewalManagerOptions);
    maybeRenew(): Promise<boolean>;
}

// Warning: (ae-missing-release-tag) "RenewalManagerOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RenewalManagerOptions`

```typescript
export interface RenewalManagerOptions {
    readonly gate: CapabilityGate;
    readonly now?: () => number;
    readonly reissue: (req: RenewalRequest) => Promise<RenewedToken>;
    readonly thresholdFraction?: number;
}

// Warning: (ae-missing-release-tag) "RenewalRequest" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RenewalRequest`

```typescript
export interface RenewalRequest {
    readonly currentToken?: string;
    readonly expiresAtEpochSeconds: number;
    readonly issuedAtEpochSeconds: number;
}

// Warning: (ae-missing-release-tag) "RenewedToken" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RenewedToken`

```typescript
export interface RenewedToken {
    readonly expiresAtEpochSeconds: number;
    readonly issuedAtEpochSeconds: number;
    readonly token: string;
}

// Warning: (ae-missing-release-tag) "repairCoherenceModel" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `repairCoherenceModel`

```typescript
export function repairCoherenceModel(raw: unknown): CoherenceModel;

// Warning: (ae-missing-release-tag) "ReplayContext" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ReplayContext`

```typescript
export interface ReplayContext {
    readonly cache: LLMResponseCache;
    readonly clock: ClockPort;
    readonly mode: ReplayMode;
    readonly originalRunId: string;
    readonly random: RandomPort;
    readonly replayRunId: string;
}

// Warning: (ae-missing-release-tag) "ReplayDetectedError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ReplayDetectedError`

```typescript
export class ReplayDetectedError extends Error {
    constructor(idempotencyKey: string);
    readonly idempotencyKey: string;
}

// Warning: (ae-missing-release-tag) "replayFrom" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `replayFrom`

```typescript
export function replayFrom(runId: string, loader: ReplayLoader, runner: ReplayRunner, opts?: {
    mode?: ReplayMode;
    fromStepIndex?: number;
}): Promise<ReplayResult>;

// Warning: (ae-missing-release-tag) "ReplayLoader" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ReplayLoader`

```typescript
export interface ReplayLoader {
    loadCacheEntries(runId: string): Promise<{
        recordedTs: number[];
        recordedNext: number[];
        recordedUuids: string[];
        cache: LLMResponseCache;
    }>;
    loadOriginalTrace(runId: string): Promise<Trace>;
}

// Warning: (ae-missing-release-tag) "ReplayMessage" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ReplayMessage`

```typescript
export interface ReplayMessage {
    content: string;
    role: "user" | "assistant" | "tool";
    toolName?: string;
}

// Warning: (ae-missing-release-tag) "ReplayMode" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ReplayMode`

```typescript
export type ReplayMode = "strict" | "tolerant";

// Warning: (ae-missing-release-tag) "ReplayResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ReplayResult`

```typescript
export interface ReplayResult {
    diff?: {
        stepIndex: number;
        field: keyof TraceStep;
        original: unknown;
        replayed: unknown;
    }[];
    match: boolean;
    replayRunId: string;
    trace: Trace;
}

// Warning: (ae-missing-release-tag) "ReplayRunner" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ReplayRunner`

```typescript
export interface ReplayRunner {
    run(ctx: ReplayContext, originalTrace: Trace): Promise<Trace>;
}

// Warning: (ae-missing-release-tag) "reportRunFinish" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `reportRunFinish`

```typescript
export function reportRunFinish(opts: {
    runId: string;
    status: "success" | "failed" | "completed";
    inputTokens?: number;
    outputTokens?: number;
    costUsd?: number;
    errorMessage?: string;
}): Promise<void>;

// Warning: (ae-missing-release-tag) "reportRunStart" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `reportRunStart`

```typescript
export function reportRunStart(opts: {
    agentId: string;
    runId?: string;
    model?: string;
    provider?: string;
}): Promise<{
    id: string;
} | null>;

// Warning: (ae-missing-release-tag) "_resetCalendarCache" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `_resetCalendarCache`

```typescript
export function _resetCalendarCache(): void;

// Warning: (ae-missing-release-tag) "resetCircuitBreaker" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `resetCircuitBreaker`

```typescript
export function resetCircuitBreaker(redisUrl: string, name: string, redisClientFactory?: (url: string) => MinimalRedisClient): Promise<void>;

// Warning: (ae-missing-release-tag) "_resetOutcomesIndex" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `_resetOutcomesIndex`

```typescript
export function _resetOutcomesIndex(): void;

// Warning: (ae-missing-release-tag) "resolveAuthScope" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `resolveAuthScope`

```typescript
export function resolveAuthScope(parentToken: string, presentedToken: string, now?: number, isRevoked?: (jti: string) => boolean): SubTokenScope | undefined;

// Warning: (ae-missing-release-tag) "resolveAuthScopeInstrumented" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `resolveAuthScopeInstrumented`

```typescript
export function resolveAuthScopeInstrumented(parentToken: string, presentedToken: string, now?: number, isRevoked?: (jti: string) => boolean): SubTokenScope | undefined;

// Warning: (ae-missing-release-tag) "ResolvedPersona" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ResolvedPersona`

```typescript
export interface ResolvedPersona {
    effective: AgentPersona;
    layers: Array<"defaults" | "brain" | "local">;
}

// Warning: (ae-missing-release-tag) "resolveForPhase" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `resolveForPhase`

```typescript
export function resolveForPhase(config: PhaseModelConfig, phase: OODAPhaseKind): ModelSpec;

// Warning: (ae-missing-release-tag) "resolvePersona" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `resolvePersona`

```typescript
export function resolvePersona(opts: ResolvePersonaOptions): Promise<ResolvedPersona>;

// Warning: (ae-missing-release-tag) "ResolvePersonaOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ResolvePersonaOptions`

```typescript
export interface ResolvePersonaOptions {
    agentId: string;
    brain?: SemanticMemoryPort;
    localPath?: string;
}

// Warning: (ae-missing-release-tag) "resolveSchema" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `resolveSchema`

```typescript
export function resolveSchema(type: string): z.ZodObject<z.ZodRawShape> | undefined;

// Warning: (ae-missing-release-tag) "resolveSkillsForAgent" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `resolveSkillsForAgent`

```typescript
export function resolveSkillsForAgent(skills: readonly SkillLedgerEntry[], opts: ResolveSkillsOptions): SkillLedgerEntry[];

// Warning: (ae-missing-release-tag) "ResolveSkillsOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ResolveSkillsOptions`

```typescript
export interface ResolveSkillsOptions {
    agentId: string;
    limit?: number;
    outcomeType: string;
}

// Warning: (ae-missing-release-tag) "resolveTier" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `resolveTier`

```typescript
export function resolveTier(manifest: SkillManifest): VaubanSkillTier;

// Warning: (ae-missing-release-tag) "ResourceLimits" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ResourceLimits`

```typescript
export interface ResourceLimits {
    readonly maxHeapMb?: number;
    readonly maxStepsPerCycle?: number;
    readonly phaseTimeoutMs?: number;
}
```

### `ResourceLimitsOpts`

```typescript
export interface ResourceLimitsOpts {
    maxHeapMb: number;
    maxStepsPerCycle: number;
    onHeapExceeded?: (info: {
        rssMb: number;
        heapMb: number;
        max: number;
    }) => void;
    phaseTimeoutMs: number;
}

// Warning: (ae-missing-release-tag) "ResourceLimitsRunner" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ResourceLimitsRunner`

```typescript
export class ResourceLimitsRunner {
    constructor(opts?: Partial<ResourceLimitsOpts>);
    checkHeap(): void;
    createPhaseAbortController(): AbortController;
    enforceStepCount(currentCount: number): void;
    readonly maxHeapMb: number;
    readonly maxStepsPerCycle: number;
    readonly phaseTimeoutMs: number;
}

// Warning: (ae-missing-release-tag) "restoreSessionContext" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `restoreSessionContext`

```typescript
export function restoreSessionContext(semanticMemory: SemanticMemoryPort, sessionTag: string, limit?: number): Promise<string | null>;

// Warning: (ae-missing-release-tag) "ResumeWorkflowOpts" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ResumeWorkflowOpts`

```typescript
export interface ResumeWorkflowOpts {
    readonly leaseTtlSeconds?: number;
    readonly workerId: string;
}
```

### `retry`

```typescript
export function retry<T>(fn: () => Promise<T>, opts?: RetryOptions): Promise<T>;
```

### `RETRY_AGGRESSIVE`

```typescript
export const RETRY_AGGRESSIVE: RetryConfig;
```

### `RETRY_PATIENT`

```typescript
export const RETRY_PATIENT: RetryConfig;
```

### `RETRY_TRANSIENT`

```typescript
export const RETRY_TRANSIENT: RetryConfig;
```

### `RetryConfig`

```typescript
export interface RetryConfig {
    readonly baseDelayMs: number;
    readonly exponentialBase: number;
    readonly jitter: boolean;
    readonly maxAttempts: number;
    readonly maxDelayMs: number;
    readonly retryIf?: (err: unknown) => boolean;
    readonly retryOn?: ReadonlyArray<new (...args: never[]) => Error>;
}
```

### `RetryContext`

```typescript
export class RetryContext {
    constructor(opts: RetryOptions & {
        config: RetryConfig;
    });
    get attempt(): number;
    handleError(err: unknown): Promise<void>;
    get shouldContinue(): boolean;
}
```

### `RetryExhaustedError`

```typescript
export class RetryExhaustedError extends Error {
    constructor(attempts: number, lastError: unknown);
    readonly attempts: number;
    readonly lastError: unknown;
}
```

### `RetryOptions`

```typescript
export interface RetryOptions {
    config?: RetryConfig;
    onRetry?: (err: unknown, attempt: number, delayMs: number) => void;
    sleepFn?: SleepFn;
}

// Warning: (ae-missing-release-tag) "RiskGuard" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RiskGuard`

```typescript
export interface RiskGuard {
    check(ctx: OODAContext): Promise<{
        proceed: boolean;
        reason?: string;
    }>;
    readonly name: string;
}

// Warning: (ae-missing-release-tag) "RiskGuardState" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RiskGuardState`

```typescript
export interface RiskGuardState {
    failure_count: number;
    last_failure: string | null;
    name: string;
    reset_after: string | null;
    state: "closed" | "open" | "half-open";
}

// Warning: (ae-missing-release-tag) "riskScore" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `riskScore`

```typescript
export function riskScore(v: RiskVector, weights?: Partial<RiskVector>): number;

// Warning: (ae-missing-release-tag) "RiskVector" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RiskVector`

```typescript
export interface RiskVector {
    blastRadius: number;
    confidence: number;
    dataSensitivity: number;
    externalSideEffect: number;
    reversibility: number;
}

// Warning: (ae-missing-release-tag) "ROBUSTE" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ROBUSTE`

```typescript
export const ROBUSTE: Axiom;

// Warning: (ae-missing-release-tag) "robusteScorer" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `robusteScorer`

```typescript
export const robusteScorer: ScoringFunction;

// Warning: (ae-missing-release-tag) "RoiPerAgent" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RoiPerAgent`

```typescript
export interface RoiPerAgent {
    agent_id: string;
    cost_cents: number;
    net_roi_pct: number | null;
    outcome_count: number;
    pending_ratio: number;
    period: {
        from: string;
        to: string;
    };
    value_cents: number;
    wow_delta_pct: number | null;
}

// Warning: (ae-missing-release-tag) "RouteDecision" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RouteDecision`

```typescript
export interface RouteDecision {
    blockedByBreaker: boolean;
    mode: EconomyMode;
    reason: string;
    tier: ModelTier;
}

// Warning: (ae-missing-release-tag) "RrfOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RrfOptions`

```typescript
export interface RrfOptions {
    now?: () => number;
    recencyHalflifeMs?: number;
    topK?: number;
    weights?: Partial<RrfWeights>;
}

// Warning: (ae-missing-release-tag) "RrfScorers" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RrfScorers`

```typescript
export interface RrfScorers<T> {
    cosine: (entry: T) => number;
    importance: (entry: T) => number;
    timestamp: (entry: T) => number;
}

// Warning: (ae-missing-release-tag) "RrfWeights" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RrfWeights`

```typescript
export interface RrfWeights {
    cosine: number;
    importance: number;
    recency: number;
}

// Warning: (ae-missing-release-tag) "rthSession" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `rthSession`

```typescript
export function rthSession(opts?: RTHSessionOptions): SessionGuard;

// Warning: (ae-missing-release-tag) "RTHSessionOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RTHSessionOptions`

```typescript
export interface RTHSessionOptions {
    tz?: string;
}

// Warning: (ae-missing-release-tag) "RuleSource" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RuleSource`

```typescript
export type RuleSource = "declared" | "normative";

// Warning: (ae-missing-release-tag) "runDebate" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `runDebate`

```typescript
export function runDebate(config: DebateConfig): Promise<DebateResult>;

// Warning: (ae-missing-release-tag) "runExpireJob" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `runExpireJob`

```typescript
export function runExpireJob(store: HITLPort & {
    _expireOverdue?: () => Promise<void>;
}, intervalMs?: number): NodeJS.Timeout;

// Warning: (ae-missing-release-tag) "runPostGuards" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `runPostGuards`

```typescript
export function runPostGuards<TOutput>(guards: readonly GuardrailDef<unknown, TOutput>[], output: TOutput, ctx: OODAContext): Promise<GuardrailViolation | null>;

// Warning: (ae-missing-release-tag) "runPreGuards" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `runPreGuards`

```typescript
export function runPreGuards<TInput>(guards: readonly GuardrailDef<TInput, unknown>[], input: TInput, ctx: OODAContext): Promise<GuardrailViolation | null>;

// Warning: (ae-missing-release-tag) "RunsClient" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RunsClient`

```typescript
export interface RunsClient {
    getAnomalies(agentId: string): Promise<Anomaly[]>;
    getCircuitBreakers(): Promise<CircuitBreakerSnapshot[]>;
    getHealth(agentId: string, window?: "24h" | "7d" | "30d"): Promise<AgentHealth>;
    subscribeToRun(runId: string, opts: Omit<SubscribeToRunOptions, "baseUrl" | "getToken">): Promise<SubscribeHandle>;
}

// Warning: (ae-missing-release-tag) "RunsClientOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RunsClientOptions`

```typescript
export interface RunsClientOptions {
    baseUrl: string;
    getToken?: () => Promise<string>;
}

// Warning: (ae-forgotten-export) The symbol "RunSqlQueryInput" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "runSqlQuery" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `runSqlQuery`

```typescript
export const runSqlQuery: Skill<RunSqlQueryInput, RunSqlQueryOutput>;

// Warning: (ae-missing-release-tag) "RunSqlQueryOutput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RunSqlQueryOutput`

```typescript
export interface RunSqlQueryOutput {
    rowCount: number;
    rows: object[];
}

// Warning: (ae-missing-release-tag) "RunStep" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RunStep`

```typescript
export interface RunStep {
    duration_ms?: number | null;
    error_message?: string | null;
    finished_at?: string | null;
    id: string;
    leaf_hash_poseidon?: string | null;
    mcp_call_hash?: string | null;
    otel_span_id?: string | null;
    otel_trace_id?: string | null;
    parent_step_id?: string | null;
    payload?: Record<string, unknown> | null;
    phase?: string | null;
    retrieval_proof_hash?: string | null;
    run_id: string;
    started_at: string;
    status: "pending" | "done" | "error" | "skipped";
    step_index: number;
    type: "retrieval" | "decision" | "execution" | "feedback" | "observation";
}

// Warning: (ae-missing-release-tag) "RunStreamEvent" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RunStreamEvent`

```typescript
export interface RunStreamEvent {
    data: RunStep | {
        status: string;
        duration_ms?: number;
    } | {
        error: string;
    } | undefined;
    id?: string;
    name: RunStreamEventName;
}

// Warning: (ae-missing-release-tag) "RunStreamEventName" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `RunStreamEventName`

```typescript
export type RunStreamEventName = "step_existing" | "step_new" | "run_complete" | "ping" | "error";

// Warning: (ae-missing-release-tag) "runTwoPhaseOrient" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `runTwoPhaseOrient`

```typescript
export function runTwoPhaseOrient<C, O, R>(config: TwoPhaseOrientConfig<C, O, R>, context: C): Promise<TwoPhaseOrientResult<O, R>>;
```

### `SandboxExecutor`

```typescript
export interface SandboxExecutor {
    run(job: SandboxJob): Promise<SandboxResult>;
}
```

### `SandboxJob`

```typescript
export interface SandboxJob {
    command: string[];
    cpuQuota?: number;
    cwd?: string;
    env?: Record<string, string>;
    image: string;
    memoryMb?: number;
    networkMode?: "none" | "outbound" | "bridge";
    readOnlyRoot?: boolean;
    stdin?: string;
    timeoutMs: number;
}
```

### `SandboxResult`

```typescript
export interface SandboxResult {
    durationMs: number;
    exitCode: number;
    stderr: string;
    stdout: string;
    timedOut: boolean;
}

// Warning: (ae-missing-release-tag) "SanitizedItem" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SanitizedItem`

```typescript
export interface SanitizedItem<T> {
    item: T;
    kept: boolean;
    reason?: string;
}

// Warning: (ae-missing-release-tag) "sanitizeExternalInput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `sanitizeExternalInput`

```typescript
export function sanitizeExternalInput<T extends {
    content: string;
}>(items: T[], opts?: SanitizeConfig): SanitizedItem<T>[];

// Warning: (ae-missing-release-tag) "savePersonaToBrain" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `savePersonaToBrain`

```typescript
export function savePersonaToBrain(brain: SemanticMemoryPort, agentId: string, persona: AgentPersona): Promise<string | null>;

// Warning: (ae-missing-release-tag) "savePersonaToFile" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `savePersonaToFile`

```typescript
export function savePersonaToFile(path: string, persona: AgentPersona): Promise<void>;

// Warning: (ae-missing-release-tag) "scopeAllows" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `scopeAllows`

```typescript
export function scopeAllows(scope: MeshCapabilityScope, action: string): boolean;

// Warning: (ae-missing-release-tag) "scopeCovers" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `scopeCovers`

```typescript
export function scopeCovers(granted: SubTokenScope, required: SubTokenScope): boolean;

// Warning: (ae-missing-release-tag) "scopeToSdkPermissions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `scopeToSdkPermissions`

```typescript
export function scopeToSdkPermissions(scope: CcScope): MappedSdkPermissions;

// Warning: (ae-missing-release-tag) "ScoreComponents" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ScoreComponents`

```typescript
export interface ScoreComponents {
    cosine: number;
    importance: number;
    recency: number;
}

// Warning: (ae-missing-release-tag) "ScoredEntry" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ScoredEntry`

```typescript
export interface ScoredEntry<T> {
    components: ScoreComponents;
    entry: T;
    score: number;
}

// Warning: (ae-missing-release-tag) "scoreEntries" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `scoreEntries`

```typescript
export function scoreEntries<T>(entries: T[], scorers: RrfScorers<T>, opts?: RrfOptions): ScoredEntry<T>[];

// Warning: (ae-missing-release-tag) "ScorerRegistry" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ScorerRegistry`

```typescript
export class ScorerRegistry {
    constructor();
    get(axiomId: AxiomId | string): ScoringFunction | undefined;
    list(): string[];
    register(axiomId: AxiomId | string, scorer: ScoringFunction): void;
    scoreAll(cycle: CycleSnapshot): Promise<Map<string, ScoringResult>>;
}

// Warning: (ae-missing-release-tag) "ScoringFunction" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ScoringFunction`

```typescript
export type ScoringFunction = (cycle: CycleSnapshot) => Promise<ScoringResult>;

// Warning: (ae-missing-release-tag) "ScoringResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ScoringResult`

```typescript
export interface ScoringResult {
    rationale: string;
    score: number;
    signals: SignalPoint[];
}

// Warning: (ae-missing-release-tag) "SdkAgentLoopImpl" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SdkAgentLoop`

```typescript
export class SdkAgentLoop {
    constructor(config: SdkAgentLoopConfig);
    get permissions(): SdkPermissions;
    run(userMessage: string): Promise<SdkAgentLoopRunResult>;
}

// Warning: (ae-missing-release-tag) "SdkAgentLoopConfig" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SdkAgentLoopConfig`

```typescript
export interface SdkAgentLoopConfig {
    agentId: string;
    agentVersion: string;
    approvalChannel?: ApprovalChannel;
    approvalPollIntervalMs?: number;
    approvalTimeoutMs?: number;
    capabilityGate?: CapabilityGate;
    client: Anthropic;
    costPerToolCallUsd?: number;
    maxSteps?: number;
    maxTokens?: number;
    model?: string;
    onToolDenied?: (event: {
        toolName: string;
        reason: string;
        budgetUsed: number;
    }) => void;
    permissions: SdkPermissions;
    renewalManager?: RenewalManager;
    systemPrompt: string;
    tools: SdkToolRegistry;
    tracer?: Tracer;
}

// Warning: (ae-missing-release-tag) "SdkAgentLoopRunResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SdkAgentLoopRunResult`

```typescript
export interface SdkAgentLoopRunResult {
    finalMessage: string;
    stopReason: "complete" | "budget_exhausted" | "tool_denied" | "user_cancelled" | "max_tokens" | "error";
    traceId: string;
    usage: {
        inputTokens: number;
        outputTokens: number;
    };
}

// Warning: (ae-missing-release-tag) "SdkCapability" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SdkCapability`

```typescript
export type SdkCapability = "bash" | "fileIO" | "web" | "mcp";

// Warning: (ae-missing-release-tag) "SdkEscalationLevel" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SdkEscalationLevel`

```typescript
export type SdkEscalationLevel = "L1_autonomous" | "L2_async_review" | "L3_hitl_required";

// Warning: (ae-missing-release-tag) "SdkPermissions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SdkPermissions`

```typescript
export interface SdkPermissions {
    readonly bash: BashMode;
    readonly fileIO: FileIOMode;
    readonly mcp: readonly string[];
    readonly web: boolean;
}

// Warning: (ae-missing-release-tag) "SdkToolRegistry" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SdkToolRegistry`

```typescript
export type SdkToolRegistry = ToolRegistry;

// Warning: (ae-missing-release-tag) "SealedSprintClaim" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SealedSprintClaim`

```typescript
export interface SealedSprintClaim {
    readonly anchor_id?: string;
    readonly sealed_at: Date;
    readonly sealed_by_agent: string;
    readonly sprint_id: string;
    readonly verification_evidence_hash: string;
}

// Warning: (ae-missing-release-tag) "SECRET_PATTERN" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SECRET_PATTERN`

```typescript
export const SECRET_PATTERN: RegExp;
```

### `SecretNotFoundError`

```typescript
export class SecretNotFoundError extends Error {
    constructor(secretName: string);
    readonly secretName: string;
}
```

### `SecretsAccessor`

```typescript
export interface SecretsAccessor {
    readonly accessedSecrets: ReadonlySet<string>;
    get(name: string, defaultValue?: string): string;
    has(name: string): boolean;
}

// Warning: (ae-missing-release-tag) "SemanticCoherenceConfig" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SemanticCoherenceConfig`

```typescript
export interface SemanticCoherenceConfig {
    similarityThreshold?: number;
    windowSize?: number;
}

// Warning: (ae-missing-release-tag) "SemanticCoherenceTracker" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SemanticCoherenceTracker`

```typescript
export class SemanticCoherenceTracker {
    constructor(embedFn: EmbedFn, config?: SemanticCoherenceConfig);
    observe(output: string): Promise<SemanticCoherenceVerdict>;
    reset(): void;
}

// Warning: (ae-missing-release-tag) "SemanticCoherenceVerdict" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SemanticCoherenceVerdict`

```typescript
export interface SemanticCoherenceVerdict {
    isSemanticStall: boolean;
    meanCosine: number;
    windowSize: number;
}

// Warning: (ae-missing-release-tag) "SemanticMemoryPort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SemanticMemoryPort`

```typescript
export interface SemanticMemoryPort {
    archive(entry: BrainEntryInput): Promise<BrainEntry | null>;
    query(q: string, filters?: BrainQueryFilters): Promise<BrainEntry[]>;
}

// Warning: (ae-forgotten-export) The symbol "SendEmailInput" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "sendEmail" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `sendEmail`

```typescript
export const sendEmail: Skill<SendEmailInput, SendEmailOutput>;

// Warning: (ae-missing-release-tag) "SendEmailOutput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SendEmailOutput`

```typescript
export interface SendEmailOutput {
    delivered: boolean;
    message_id: string | null;
    provider: "smtp" | "resend" | "replay";
}

// Warning: (ae-missing-release-tag) "sendHITLApprovalRequestSlack" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `sendHITLApprovalRequestSlack`

```typescript
export function sendHITLApprovalRequestSlack(opts: SendHITLSlackOpts): Promise<SlackApprovalResult>;

// Warning: (ae-missing-release-tag) "sendHITLApprovalRequestTelegram" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `sendHITLApprovalRequestTelegram`

```typescript
export function sendHITLApprovalRequestTelegram(opts: SendHITLTelegramOpts): Promise<TelegramApprovalResult>;

// Warning: (ae-missing-release-tag) "SendHITLSlackOpts" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SendHITLSlackOpts`

```typescript
export interface SendHITLSlackOpts {
    // Warning: (ae-forgotten-export) The symbol "SlackChannelConfig_2" needs to be exported by the entry point index.d.ts
    //
    channel: SlackChannelConfig_2;
    costDisplayUsd?: number;
    hitlPort: HITLPort;
    request: HITLRequest;
}

// Warning: (ae-missing-release-tag) "SendHITLTelegramOpts" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SendHITLTelegramOpts`

```typescript
export interface SendHITLTelegramOpts {
    // Warning: (ae-forgotten-export) The symbol "TelegramChannelConfig_2" needs to be exported by the entry point index.d.ts
    //
    channel: TelegramChannelConfig_2;
    hitlPort: HITLPort;
    request: HITLRequest;
}

// Warning: (ae-missing-release-tag) "SendSignalOpts" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SendSignalOpts`

```typescript
export interface SendSignalOpts {
    readonly payload?: unknown;
}

// Warning: (ae-missing-release-tag) "SensitiveValue" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SensitiveValue`

```typescript
export class SensitiveValue<T> {
    constructor(value: T, label?: string);
    get label(): string;
    reveal(): T;
    toJSON(): never;
    toString(): string;
}

// Warning: (ae-missing-release-tag) "serializeTrajectory" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `serializeTrajectory`

```typescript
export function serializeTrajectory(exp: TrajectoryExport): string;

// Warning: (ae-missing-release-tag) "SessionEvent" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SessionEvent`

```typescript
export type SessionEvent = z.infer<typeof SessionEventSchema>;

// Warning: (ae-missing-release-tag) "SessionEventSchema" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SessionEventSchema`

```typescript
export const SessionEventSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
    data: z.ZodObject<{
        runId: z.ZodString;
        agentId: z.ZodString;
        agentVersion: z.ZodOptional<z.ZodString>;
        task: z.ZodOptional<z.ZodString>;
        startedAt: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        agentId: string;
        runId: string;
        startedAt: string;
        agentVersion?: string | undefined;
        task?: string | undefined;
    }, {
        agentId: string;
        runId: string;
        startedAt: string;
        agentVersion?: string | undefined;
        task?: string | undefined;
    }>;
    id: z.ZodString;
    seq: z.ZodNumber;
    ts: z.ZodString;
    sig: z.ZodOptional<z.ZodString>;
    type: z.ZodLiteral<"run.start">;
}, "strip", z.ZodTypeAny, {
    type: "run.start";
    id: string;
    data: {
        agentId: string;
        runId: string;
        startedAt: string;
        agentVersion?: string | undefined;
        task?: string | undefined;
    };
    seq: number;
    ts: string;
    sig?: string | undefined;
}, {
    type: "run.start";
    id: string;
    data: {
        agentId: string;
        runId: string;
        startedAt: string;
        agentVersion?: string | undefined;
        task?: string | undefined;
    };
    seq: number;
    ts: string;
    sig?: string | undefined;
}>, z.ZodObject<{
    data: z.ZodObject<{
        stepIndex: z.ZodNumber;
        inputTokens: z.ZodNumber;
        outputTokens: z.ZodNumber;
        costUsd: z.ZodNumber;
    }, "strict", z.ZodTypeAny, {
        inputTokens: number;
        outputTokens: number;
        costUsd: number;
        stepIndex: number;
    }, {
        inputTokens: number;
        outputTokens: number;
        costUsd: number;
        stepIndex: number;
    }>;
    id: z.ZodString;
    seq: z.ZodNumber;
    ts: z.ZodString;
    sig: z.ZodOptional<z.ZodString>;
    type: z.ZodLiteral<"run.step">;
}, "strip", z.ZodTypeAny, {
    type: "run.step";
    id: string;
    data: {
        inputTokens: number;
        outputTokens: number;
        costUsd: number;
        stepIndex: number;
    };
    seq: number;
    ts: string;
    sig?: string | undefined;
}, {
    type: "run.step";
    id: string;
    data: {
        inputTokens: number;
        outputTokens: number;
        costUsd: number;
        stepIndex: number;
    };
    seq: number;
    ts: string;
    sig?: string | undefined;
}>, z.ZodObject<{
    data: z.ZodObject<{
        text: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        text: string;
    }, {
        text: string;
    }>;
    id: z.ZodString;
    seq: z.ZodNumber;
    ts: z.ZodString;
    sig: z.ZodOptional<z.ZodString>;
    type: z.ZodLiteral<"assistant.delta">;
}, "strip", z.ZodTypeAny, {
    type: "assistant.delta";
    id: string;
    data: {
        text: string;
    };
    seq: number;
    ts: string;
    sig?: string | undefined;
}, {
    type: "assistant.delta";
    id: string;
    data: {
        text: string;
    };
    seq: number;
    ts: string;
    sig?: string | undefined;
}>, z.ZodObject<{
    data: z.ZodObject<{
        content: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        content: string;
    }, {
        content: string;
    }>;
    id: z.ZodString;
    seq: z.ZodNumber;
    ts: z.ZodString;
    sig: z.ZodOptional<z.ZodString>;
    type: z.ZodLiteral<"assistant.message">;
}, "strip", z.ZodTypeAny, {
    type: "assistant.message";
    id: string;
    data: {
        content: string;
    };
    seq: number;
    ts: string;
    sig?: string | undefined;
}, {
    type: "assistant.message";
    id: string;
    data: {
        content: string;
    };
    seq: number;
    ts: string;
    sig?: string | undefined;
}>, z.ZodObject<{
    data: z.ZodObject<{
        callId: z.ZodString;
        toolName: z.ZodString;
        argsPreview: z.ZodString;
        rationale: z.ZodOptional<z.ZodString>;
        vetoWindowMs: z.ZodNumber;
    }, "strict", z.ZodTypeAny, {
        callId: string;
        toolName: string;
        argsPreview: string;
        vetoWindowMs: number;
        rationale?: string | undefined;
    }, {
        callId: string;
        toolName: string;
        argsPreview: string;
        vetoWindowMs: number;
        rationale?: string | undefined;
    }>;
    id: z.ZodString;
    seq: z.ZodNumber;
    ts: z.ZodString;
    sig: z.ZodOptional<z.ZodString>;
    type: z.ZodLiteral<"tool.intent">;
}, "strip", z.ZodTypeAny, {
    type: "tool.intent";
    id: string;
    data: {
        callId: string;
        toolName: string;
        argsPreview: string;
        vetoWindowMs: number;
        rationale?: string | undefined;
    };
    seq: number;
    ts: string;
    sig?: string | undefined;
}, {
    type: "tool.intent";
    id: string;
    data: {
        callId: string;
        toolName: string;
        argsPreview: string;
        vetoWindowMs: number;
        rationale?: string | undefined;
    };
    seq: number;
    ts: string;
    sig?: string | undefined;
}>, z.ZodObject<{
    data: z.ZodObject<{
        callId: z.ZodString;
        toolName: z.ZodString;
        argsPreview: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        callId: string;
        toolName: string;
        argsPreview: string;
    }, {
        callId: string;
        toolName: string;
        argsPreview: string;
    }>;
    id: z.ZodString;
    seq: z.ZodNumber;
    ts: z.ZodString;
    sig: z.ZodOptional<z.ZodString>;
    type: z.ZodLiteral<"tool.call.start">;
}, "strip", z.ZodTypeAny, {
    type: "tool.call.start";
    id: string;
    data: {
        callId: string;
        toolName: string;
        argsPreview: string;
    };
    seq: number;
    ts: string;
    sig?: string | undefined;
}, {
    type: "tool.call.start";
    id: string;
    data: {
        callId: string;
        toolName: string;
        argsPreview: string;
    };
    seq: number;
    ts: string;
    sig?: string | undefined;
}>, z.ZodObject<{
    data: z.ZodObject<{
        callId: z.ZodString;
        toolName: z.ZodString;
        ok: z.ZodBoolean;
        resultPreview: z.ZodString;
        durationMs: z.ZodOptional<z.ZodNumber>;
    }, "strict", z.ZodTypeAny, {
        callId: string;
        toolName: string;
        ok: boolean;
        resultPreview: string;
        durationMs?: number | undefined;
    }, {
        callId: string;
        toolName: string;
        ok: boolean;
        resultPreview: string;
        durationMs?: number | undefined;
    }>;
    id: z.ZodString;
    seq: z.ZodNumber;
    ts: z.ZodString;
    sig: z.ZodOptional<z.ZodString>;
    type: z.ZodLiteral<"tool.call.end">;
}, "strip", z.ZodTypeAny, {
    type: "tool.call.end";
    id: string;
    data: {
        callId: string;
        toolName: string;
        ok: boolean;
        resultPreview: string;
        durationMs?: number | undefined;
    };
    seq: number;
    ts: string;
    sig?: string | undefined;
}, {
    type: "tool.call.end";
    id: string;
    data: {
        callId: string;
        toolName: string;
        ok: boolean;
        resultPreview: string;
        durationMs?: number | undefined;
    };
    seq: number;
    ts: string;
    sig?: string | undefined;
}>, z.ZodObject<{
    data: z.ZodObject<{
        requestId: z.ZodString;
        action: z.ZodString;
        context: z.ZodString;
        expiresAt: z.ZodOptional<z.ZodString>;
    }, "strict", z.ZodTypeAny, {
        requestId: string;
        action: string;
        context: string;
        expiresAt?: string | undefined;
    }, {
        requestId: string;
        action: string;
        context: string;
        expiresAt?: string | undefined;
    }>;
    id: z.ZodString;
    seq: z.ZodNumber;
    ts: z.ZodString;
    sig: z.ZodOptional<z.ZodString>;
    type: z.ZodLiteral<"hitl.request">;
}, "strip", z.ZodTypeAny, {
    type: "hitl.request";
    id: string;
    data: {
        requestId: string;
        action: string;
        context: string;
        expiresAt?: string | undefined;
    };
    seq: number;
    ts: string;
    sig?: string | undefined;
}, {
    type: "hitl.request";
    id: string;
    data: {
        requestId: string;
        action: string;
        context: string;
        expiresAt?: string | undefined;
    };
    seq: number;
    ts: string;
    sig?: string | undefined;
}>, z.ZodObject<{
    data: z.ZodObject<{
        requestId: z.ZodString;
        approved: z.ZodBoolean;
        by: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        approved: boolean;
        requestId: string;
        by: string;
    }, {
        approved: boolean;
        requestId: string;
        by: string;
    }>;
    id: z.ZodString;
    seq: z.ZodNumber;
    ts: z.ZodString;
    sig: z.ZodOptional<z.ZodString>;
    type: z.ZodLiteral<"hitl.resolved">;
}, "strip", z.ZodTypeAny, {
    type: "hitl.resolved";
    id: string;
    data: {
        approved: boolean;
        requestId: string;
        by: string;
    };
    seq: number;
    ts: string;
    sig?: string | undefined;
}, {
    type: "hitl.resolved";
    id: string;
    data: {
        approved: boolean;
        requestId: string;
        by: string;
    };
    seq: number;
    ts: string;
    sig?: string | undefined;
}>, z.ZodObject<{
    data: z.ZodObject<{
        text: z.ZodString;
        source: z.ZodString;
        whisper: z.ZodDefault<z.ZodBoolean>;
    }, "strict", z.ZodTypeAny, {
        source: string;
        text: string;
        whisper: boolean;
    }, {
        source: string;
        text: string;
        whisper?: boolean | undefined;
    }>;
    id: z.ZodString;
    seq: z.ZodNumber;
    ts: z.ZodString;
    sig: z.ZodOptional<z.ZodString>;
    type: z.ZodLiteral<"instruction.injected">;
}, "strip", z.ZodTypeAny, {
    type: "instruction.injected";
    id: string;
    data: {
        source: string;
        text: string;
        whisper: boolean;
    };
    seq: number;
    ts: string;
    sig?: string | undefined;
}, {
    type: "instruction.injected";
    id: string;
    data: {
        source: string;
        text: string;
        whisper?: boolean | undefined;
    };
    seq: number;
    ts: string;
    sig?: string | undefined;
}>, z.ZodObject<{
    data: z.ZodObject<{
        runId: z.ZodString;
        stopReason: z.ZodString;
        stepCount: z.ZodNumber;
        costUsd: z.ZodNumber;
        finishedAt: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        runId: string;
        costUsd: number;
        stopReason: string;
        stepCount: number;
        finishedAt: string;
    }, {
        runId: string;
        costUsd: number;
        stopReason: string;
        stepCount: number;
        finishedAt: string;
    }>;
    id: z.ZodString;
    seq: z.ZodNumber;
    ts: z.ZodString;
    sig: z.ZodOptional<z.ZodString>;
    type: z.ZodLiteral<"run.finished">;
}, "strip", z.ZodTypeAny, {
    type: "run.finished";
    id: string;
    data: {
        runId: string;
        costUsd: number;
        stopReason: string;
        stepCount: number;
        finishedAt: string;
    };
    seq: number;
    ts: string;
    sig?: string | undefined;
}, {
    type: "run.finished";
    id: string;
    data: {
        runId: string;
        costUsd: number;
        stopReason: string;
        stepCount: number;
        finishedAt: string;
    };
    seq: number;
    ts: string;
    sig?: string | undefined;
}>, z.ZodObject<{
    data: z.ZodObject<{
        runId: z.ZodString;
        stepCount: z.ZodNumber;
        costUsd: z.ZodNumber;
        elapsedMs: z.ZodNumber;
        pendingHitl: z.ZodNumber;
    }, "strict", z.ZodTypeAny, {
        runId: string;
        costUsd: number;
        stepCount: number;
        elapsedMs: number;
        pendingHitl: number;
    }, {
        runId: string;
        costUsd: number;
        stepCount: number;
        elapsedMs: number;
        pendingHitl: number;
    }>;
    id: z.ZodString;
    seq: z.ZodNumber;
    ts: z.ZodString;
    sig: z.ZodOptional<z.ZodString>;
    type: z.ZodLiteral<"state">;
}, "strip", z.ZodTypeAny, {
    type: "state";
    id: string;
    data: {
        runId: string;
        costUsd: number;
        stepCount: number;
        elapsedMs: number;
        pendingHitl: number;
    };
    seq: number;
    ts: string;
    sig?: string | undefined;
}, {
    type: "state";
    id: string;
    data: {
        runId: string;
        costUsd: number;
        stepCount: number;
        elapsedMs: number;
        pendingHitl: number;
    };
    seq: number;
    ts: string;
    sig?: string | undefined;
}>]>;

// Warning: (ae-missing-release-tag) "SessionEventSink" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SessionEventSink`

```typescript
export interface SessionEventSink {
    emit(event: SessionEvent): void;
}

// Warning: (ae-missing-release-tag) "SessionEventType" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SessionEventType`

```typescript
export type SessionEventType = SessionEvent["type"];

// Warning: (ae-missing-release-tag) "SessionGuard" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SessionGuard`

```typescript
export interface SessionGuard {
    isActive(at: Date): Promise<boolean>;
    readonly name: string;
}

// Warning: (ae-missing-release-tag) "SessionState" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SessionState`

```typescript
export interface SessionState {
    agentId: string | null;
    costUsd: number;
    elapsedMs: number;
    pendingHitl: number;
    runId: string | null;
    status: "idle" | "running" | "finished";
    stepCount: number;
}
```

### `SettlementReceipt`

```typescript
export interface SettlementReceipt {
    amount: string;
    blockNumber: number;
    blockTime: string;
    decimals: number;
    from: string;
    network: string;
    proofCommitment?: string;
    proofUrl?: string;
    to: string;
    token: string;
    txHash: string;
}

// Warning: (ae-missing-release-tag) "sha256" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `sha256`

```typescript
export function sha256(input: string | Uint8Array): Promise<string>;

// Warning: (ae-missing-release-tag) "shouldLearn" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `shouldLearn`

```typescript
export function shouldLearn(trigger: LearningTrigger): boolean;
```

### `shouldRetry`

```typescript
export function shouldRetry(config: RetryConfig, err: unknown, attempt: number): boolean;

// Warning: (ae-missing-release-tag) "SignalBrainPort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SignalBrainPort`

```typescript
export interface SignalBrainPort {
    episodic?: EpisodicMemoryPort;
}

// Warning: (ae-missing-release-tag) "SignalPoint" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SignalPoint`

```typescript
export interface SignalPoint {
    evidence: string;
    label: string;
    weight: number;
}

// Warning: (ae-missing-release-tag) "SignedReceipt" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SignedReceipt`

```typescript
export interface SignedReceipt {
    algorithm: "sha-256";
    certChain?: string[];
    hashedMessage: string;
    signature: string;
    timestamp: string;
    tsa: string;
}

// Warning: (ae-missing-release-tag) "signEvent" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `signEvent`

```typescript
export function signEvent(event: Omit<DomainEvent, "signature">, secret: string): string;

// Warning: (ae-missing-release-tag) "SignFn" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SignFn`

```typescript
export type SignFn = (canonicalMessage: string) => string;

// Warning: (ae-missing-release-tag) "singleShotStrategy" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `singleShotStrategy`

```typescript
export function singleShotStrategy<TInput, TOutput>(): Strategy<TInput, TOutput>;

// Warning: (ae-missing-release-tag) "Skill" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `Skill`

```typescript
export interface Skill<I = unknown, O = unknown> {
    execute(input: I, ctx: SkillContext): Promise<O>;
    readonly inputSchema: {
        parse: (raw: unknown) => I;
    };
    readonly name: string;
}

// Warning: (ae-missing-release-tag) "SkillBuilderDeps" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SkillBuilderDeps`

```typescript
export interface SkillBuilderDeps {
    readonly brain?: BrainPort;
    readonly litellmApiKey?: string;
    readonly litellmUrl?: string;
    readonly logger: LoggerPort;
    readonly slackWebhookUrl?: string;
}
```

### `SkillCaptureOptions`

```typescript
export interface SkillCaptureOptions {
    readonly domain: string;
    readonly enabled: boolean;
    readonly markdownSink?: (path: string, content: string) => Promise<void>;
    readonly minQuality?: number;
    readonly procedural?: ProceduralMemoryPort;
    readonly synthesize?: (traceSummary: string) => string;
}

// Warning: (ae-missing-release-tag) "SkillContext" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SkillContext`

```typescript
export interface SkillContext {
    readonly db: DbClient;
    readonly dryRunMocks: Record<string, (input: unknown) => unknown>;
    readonly elapsedSeconds?: number;
    readonly executionId?: string;
    readonly isReplay: boolean;
    readonly logger: LoggerPort;
    readonly progress?: ProgressCallback;
    readonly remainingSeconds?: number;
    readonly secrets?: SecretsAccessor;
}

// Warning: (ae-missing-release-tag) "SkillExecutionError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SkillExecutionError`

```typescript
export class SkillExecutionError extends Error {
    constructor(skillName: string, message: string, opts?: {
        status?: number;
        cause?: unknown;
    });
    readonly cause?: unknown;
    readonly skillName: string;
    readonly status?: number;
}

// Warning: (ae-missing-release-tag) "SkillLedgerEntry" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SkillLedgerEntry`

```typescript
export interface SkillLedgerEntry {
    agent_id: string;
    brain_entry_id: string;
    created_at: string;
    id: string;
    lifecycle_state: SkillLifecycleState;
    metrics: Record<string, unknown>;
    outcome_type: string;
    skill_name: string;
    skill_sha256: string;
    source_run_ids: string[];
}
```

### `SkillLifecycleState`

```typescript
export type SkillLifecycleState = "active" | "archived" | "deprecated";

// Warning: (ae-missing-release-tag) "SkillManifest" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SkillManifest`

```typescript
export type SkillManifest = z.infer<typeof SkillManifestSchema>;

// Warning: (ae-missing-release-tag) "SkillManifestSchema" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SkillManifestSchema`

```typescript
export const SkillManifestSchema: z.ZodObject<{
    name: z.ZodString;
    description: z.ZodString;
    license: z.ZodOptional<z.ZodString>;
    compatibility: z.ZodOptional<z.ZodString>;
    "allowed-tools": z.ZodOptional<z.ZodString>;
    metadata: z.ZodOptional<z.ZodObject<{
        version: z.ZodOptional<z.ZodOptional<z.ZodString>>;
        category: z.ZodOptional<z.ZodOptional<z.ZodString>>;
        tags: z.ZodOptional<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>>;
        author: z.ZodOptional<z.ZodOptional<z.ZodString>>;
        "env-required": z.ZodOptional<z.ZodOptional<z.ZodString>>;
        "env-mode": z.ZodOptional<z.ZodOptional<z.ZodEnum<["all", "at-least-one"]>>>;
        vauban: z.ZodOptional<z.ZodOptional<z.ZodObject<{
            tier: z.ZodOptional<z.ZodOptional<z.ZodEnum<["official", "verified", "unverified"]>>>;
            subagent: z.ZodOptional<z.ZodOptional<z.ZodString>>;
            "model-hint": z.ZodOptional<z.ZodOptional<z.ZodString>>;
            proof: z.ZodOptional<z.ZodOptional<z.ZodObject<{
                poseidon_hash: z.ZodOptional<z.ZodOptional<z.ZodString>>;
                tsa_token: z.ZodOptional<z.ZodOptional<z.ZodString>>;
                starknet_tx: z.ZodOptional<z.ZodOptional<z.ZodString>>;
                anchored_at: z.ZodOptional<z.ZodOptional<z.ZodString>>;
            }, "strict", z.ZodTypeAny, {
                poseidon_hash?: string | undefined;
                tsa_token?: string | undefined;
                starknet_tx?: string | undefined;
                anchored_at?: string | undefined;
            }, {
                poseidon_hash?: string | undefined;
                tsa_token?: string | undefined;
                starknet_tx?: string | undefined;
                anchored_at?: string | undefined;
            }>>>;
            biscuit: z.ZodOptional<z.ZodOptional<z.ZodObject<{
                required_caps: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
                max_scope: z.ZodOptional<z.ZodOptional<z.ZodEnum<["project", "session", "global"]>>>;
            }, "strict", z.ZodTypeAny, {
                required_caps?: string[] | undefined;
                max_scope?: "session" | "project" | "global" | undefined;
            }, {
                required_caps?: string[] | undefined;
                max_scope?: "session" | "project" | "global" | undefined;
            }>>>;
            audit_status: z.ZodOptional<z.ZodOptional<z.ZodEnum<["approved", "review", "rejected"]>>>;
            observability_metric: z.ZodOptional<z.ZodOptional<z.ZodString>>;
        }, "strict", z.ZodTypeAny, {
            proof?: {
                poseidon_hash?: string | undefined;
                tsa_token?: string | undefined;
                starknet_tx?: string | undefined;
                anchored_at?: string | undefined;
            } | undefined;
            tier?: "verified" | "unverified" | "official" | undefined;
            subagent?: string | undefined;
            "model-hint"?: string | undefined;
            biscuit?: {
                required_caps?: string[] | undefined;
                max_scope?: "session" | "project" | "global" | undefined;
            } | undefined;
            audit_status?: "rejected" | "approved" | "review" | undefined;
            observability_metric?: string | undefined;
        }, {
            proof?: {
                poseidon_hash?: string | undefined;
                tsa_token?: string | undefined;
                starknet_tx?: string | undefined;
                anchored_at?: string | undefined;
            } | undefined;
            tier?: "verified" | "unverified" | "official" | undefined;
            subagent?: string | undefined;
            "model-hint"?: string | undefined;
            biscuit?: {
                required_caps?: string[] | undefined;
                max_scope?: "session" | "project" | "global" | undefined;
            } | undefined;
            audit_status?: "rejected" | "approved" | "review" | undefined;
            observability_metric?: string | undefined;
        }>>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        version: z.ZodOptional<z.ZodOptional<z.ZodString>>;
        category: z.ZodOptional<z.ZodOptional<z.ZodString>>;
        tags: z.ZodOptional<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>>;
        author: z.ZodOptional<z.ZodOptional<z.ZodString>>;
        "env-required": z.ZodOptional<z.ZodOptional<z.ZodString>>;
        "env-mode": z.ZodOptional<z.ZodOptional<z.ZodEnum<["all", "at-least-one"]>>>;
        vauban: z.ZodOptional<z.ZodOptional<z.ZodObject<{
            tier: z.ZodOptional<z.ZodOptional<z.ZodEnum<["official", "verified", "unverified"]>>>;
            subagent: z.ZodOptional<z.ZodOptional<z.ZodString>>;
            "model-hint": z.ZodOptional<z.ZodOptional<z.ZodString>>;
            proof: z.ZodOptional<z.ZodOptional<z.ZodObject<{
                poseidon_hash: z.ZodOptional<z.ZodOptional<z.ZodString>>;
                tsa_token: z.ZodOptional<z.ZodOptional<z.ZodString>>;
                starknet_tx: z.ZodOptional<z.ZodOptional<z.ZodString>>;
                anchored_at: z.ZodOptional<z.ZodOptional<z.ZodString>>;
            }, "strict", z.ZodTypeAny, {
                poseidon_hash?: string | undefined;
                tsa_token?: string | undefined;
                starknet_tx?: string | undefined;
                anchored_at?: string | undefined;
            }, {
                poseidon_hash?: string | undefined;
                tsa_token?: string | undefined;
                starknet_tx?: string | undefined;
                anchored_at?: string | undefined;
            }>>>;
            biscuit: z.ZodOptional<z.ZodOptional<z.ZodObject<{
                required_caps: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
                max_scope: z.ZodOptional<z.ZodOptional<z.ZodEnum<["project", "session", "global"]>>>;
            }, "strict", z.ZodTypeAny, {
                required_caps?: string[] | undefined;
                max_scope?: "session" | "project" | "global" | undefined;
            }, {
                required_caps?: string[] | undefined;
                max_scope?: "session" | "project" | "global" | undefined;
            }>>>;
            audit_status: z.ZodOptional<z.ZodOptional<z.ZodEnum<["approved", "review", "rejected"]>>>;
            observability_metric: z.ZodOptional<z.ZodOptional<z.ZodString>>;
        }, "strict", z.ZodTypeAny, {
            proof?: {
                poseidon_hash?: string | undefined;
                tsa_token?: string | undefined;
                starknet_tx?: string | undefined;
                anchored_at?: string | undefined;
            } | undefined;
            tier?: "verified" | "unverified" | "official" | undefined;
            subagent?: string | undefined;
            "model-hint"?: string | undefined;
            biscuit?: {
                required_caps?: string[] | undefined;
                max_scope?: "session" | "project" | "global" | undefined;
            } | undefined;
            audit_status?: "rejected" | "approved" | "review" | undefined;
            observability_metric?: string | undefined;
        }, {
            proof?: {
                poseidon_hash?: string | undefined;
                tsa_token?: string | undefined;
                starknet_tx?: string | undefined;
                anchored_at?: string | undefined;
            } | undefined;
            tier?: "verified" | "unverified" | "official" | undefined;
            subagent?: string | undefined;
            "model-hint"?: string | undefined;
            biscuit?: {
                required_caps?: string[] | undefined;
                max_scope?: "session" | "project" | "global" | undefined;
            } | undefined;
            audit_status?: "rejected" | "approved" | "review" | undefined;
            observability_metric?: string | undefined;
        }>>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        version: z.ZodOptional<z.ZodOptional<z.ZodString>>;
        category: z.ZodOptional<z.ZodOptional<z.ZodString>>;
        tags: z.ZodOptional<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>>;
        author: z.ZodOptional<z.ZodOptional<z.ZodString>>;
        "env-required": z.ZodOptional<z.ZodOptional<z.ZodString>>;
        "env-mode": z.ZodOptional<z.ZodOptional<z.ZodEnum<["all", "at-least-one"]>>>;
        vauban: z.ZodOptional<z.ZodOptional<z.ZodObject<{
            tier: z.ZodOptional<z.ZodOptional<z.ZodEnum<["official", "verified", "unverified"]>>>;
            subagent: z.ZodOptional<z.ZodOptional<z.ZodString>>;
            "model-hint": z.ZodOptional<z.ZodOptional<z.ZodString>>;
            proof: z.ZodOptional<z.ZodOptional<z.ZodObject<{
                poseidon_hash: z.ZodOptional<z.ZodOptional<z.ZodString>>;
                tsa_token: z.ZodOptional<z.ZodOptional<z.ZodString>>;
                starknet_tx: z.ZodOptional<z.ZodOptional<z.ZodString>>;
                anchored_at: z.ZodOptional<z.ZodOptional<z.ZodString>>;
            }, "strict", z.ZodTypeAny, {
                poseidon_hash?: string | undefined;
                tsa_token?: string | undefined;
                starknet_tx?: string | undefined;
                anchored_at?: string | undefined;
            }, {
                poseidon_hash?: string | undefined;
                tsa_token?: string | undefined;
                starknet_tx?: string | undefined;
                anchored_at?: string | undefined;
            }>>>;
            biscuit: z.ZodOptional<z.ZodOptional<z.ZodObject<{
                required_caps: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
                max_scope: z.ZodOptional<z.ZodOptional<z.ZodEnum<["project", "session", "global"]>>>;
            }, "strict", z.ZodTypeAny, {
                required_caps?: string[] | undefined;
                max_scope?: "session" | "project" | "global" | undefined;
            }, {
                required_caps?: string[] | undefined;
                max_scope?: "session" | "project" | "global" | undefined;
            }>>>;
            audit_status: z.ZodOptional<z.ZodOptional<z.ZodEnum<["approved", "review", "rejected"]>>>;
            observability_metric: z.ZodOptional<z.ZodOptional<z.ZodString>>;
        }, "strict", z.ZodTypeAny, {
            proof?: {
                poseidon_hash?: string | undefined;
                tsa_token?: string | undefined;
                starknet_tx?: string | undefined;
                anchored_at?: string | undefined;
            } | undefined;
            tier?: "verified" | "unverified" | "official" | undefined;
            subagent?: string | undefined;
            "model-hint"?: string | undefined;
            biscuit?: {
                required_caps?: string[] | undefined;
                max_scope?: "session" | "project" | "global" | undefined;
            } | undefined;
            audit_status?: "rejected" | "approved" | "review" | undefined;
            observability_metric?: string | undefined;
        }, {
            proof?: {
                poseidon_hash?: string | undefined;
                tsa_token?: string | undefined;
                starknet_tx?: string | undefined;
                anchored_at?: string | undefined;
            } | undefined;
            tier?: "verified" | "unverified" | "official" | undefined;
            subagent?: string | undefined;
            "model-hint"?: string | undefined;
            biscuit?: {
                required_caps?: string[] | undefined;
                max_scope?: "session" | "project" | "global" | undefined;
            } | undefined;
            audit_status?: "rejected" | "approved" | "review" | undefined;
            observability_metric?: string | undefined;
        }>>>;
    }, z.ZodTypeAny, "passthrough">>>;
}, "strict", z.ZodTypeAny, {
    name: string;
    description: string;
    metadata?: z.objectOutputType<{
        version: z.ZodOptional<z.ZodOptional<z.ZodString>>;
        category: z.ZodOptional<z.ZodOptional<z.ZodString>>;
        tags: z.ZodOptional<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>>;
        author: z.ZodOptional<z.ZodOptional<z.ZodString>>;
        "env-required": z.ZodOptional<z.ZodOptional<z.ZodString>>;
        "env-mode": z.ZodOptional<z.ZodOptional<z.ZodEnum<["all", "at-least-one"]>>>;
        vauban: z.ZodOptional<z.ZodOptional<z.ZodObject<{
            tier: z.ZodOptional<z.ZodOptional<z.ZodEnum<["official", "verified", "unverified"]>>>;
            subagent: z.ZodOptional<z.ZodOptional<z.ZodString>>;
            "model-hint": z.ZodOptional<z.ZodOptional<z.ZodString>>;
            proof: z.ZodOptional<z.ZodOptional<z.ZodObject<{
                poseidon_hash: z.ZodOptional<z.ZodOptional<z.ZodString>>;
                tsa_token: z.ZodOptional<z.ZodOptional<z.ZodString>>;
                starknet_tx: z.ZodOptional<z.ZodOptional<z.ZodString>>;
                anchored_at: z.ZodOptional<z.ZodOptional<z.ZodString>>;
            }, "strict", z.ZodTypeAny, {
                poseidon_hash?: string | undefined;
                tsa_token?: string | undefined;
                starknet_tx?: string | undefined;
                anchored_at?: string | undefined;
            }, {
                poseidon_hash?: string | undefined;
                tsa_token?: string | undefined;
                starknet_tx?: string | undefined;
                anchored_at?: string | undefined;
            }>>>;
            biscuit: z.ZodOptional<z.ZodOptional<z.ZodObject<{
                required_caps: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
                max_scope: z.ZodOptional<z.ZodOptional<z.ZodEnum<["project", "session", "global"]>>>;
            }, "strict", z.ZodTypeAny, {
                required_caps?: string[] | undefined;
                max_scope?: "session" | "project" | "global" | undefined;
            }, {
                required_caps?: string[] | undefined;
                max_scope?: "session" | "project" | "global" | undefined;
            }>>>;
            audit_status: z.ZodOptional<z.ZodOptional<z.ZodEnum<["approved", "review", "rejected"]>>>;
            observability_metric: z.ZodOptional<z.ZodOptional<z.ZodString>>;
        }, "strict", z.ZodTypeAny, {
            proof?: {
                poseidon_hash?: string | undefined;
                tsa_token?: string | undefined;
                starknet_tx?: string | undefined;
                anchored_at?: string | undefined;
            } | undefined;
            tier?: "verified" | "unverified" | "official" | undefined;
            subagent?: string | undefined;
            "model-hint"?: string | undefined;
            biscuit?: {
                required_caps?: string[] | undefined;
                max_scope?: "session" | "project" | "global" | undefined;
            } | undefined;
            audit_status?: "rejected" | "approved" | "review" | undefined;
            observability_metric?: string | undefined;
        }, {
            proof?: {
                poseidon_hash?: string | undefined;
                tsa_token?: string | undefined;
                starknet_tx?: string | undefined;
                anchored_at?: string | undefined;
            } | undefined;
            tier?: "verified" | "unverified" | "official" | undefined;
            subagent?: string | undefined;
            "model-hint"?: string | undefined;
            biscuit?: {
                required_caps?: string[] | undefined;
                max_scope?: "session" | "project" | "global" | undefined;
            } | undefined;
            audit_status?: "rejected" | "approved" | "review" | undefined;
            observability_metric?: string | undefined;
        }>>>;
    }, z.ZodTypeAny, "passthrough"> | undefined;
    license?: string | undefined;
    compatibility?: string | undefined;
    "allowed-tools"?: string | undefined;
}, {
    name: string;
    description: string;
    metadata?: z.objectInputType<{
        version: z.ZodOptional<z.ZodOptional<z.ZodString>>;
        category: z.ZodOptional<z.ZodOptional<z.ZodString>>;
        tags: z.ZodOptional<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>>;
        author: z.ZodOptional<z.ZodOptional<z.ZodString>>;
        "env-required": z.ZodOptional<z.ZodOptional<z.ZodString>>;
        "env-mode": z.ZodOptional<z.ZodOptional<z.ZodEnum<["all", "at-least-one"]>>>;
        vauban: z.ZodOptional<z.ZodOptional<z.ZodObject<{
            tier: z.ZodOptional<z.ZodOptional<z.ZodEnum<["official", "verified", "unverified"]>>>;
            subagent: z.ZodOptional<z.ZodOptional<z.ZodString>>;
            "model-hint": z.ZodOptional<z.ZodOptional<z.ZodString>>;
            proof: z.ZodOptional<z.ZodOptional<z.ZodObject<{
                poseidon_hash: z.ZodOptional<z.ZodOptional<z.ZodString>>;
                tsa_token: z.ZodOptional<z.ZodOptional<z.ZodString>>;
                starknet_tx: z.ZodOptional<z.ZodOptional<z.ZodString>>;
                anchored_at: z.ZodOptional<z.ZodOptional<z.ZodString>>;
            }, "strict", z.ZodTypeAny, {
                poseidon_hash?: string | undefined;
                tsa_token?: string | undefined;
                starknet_tx?: string | undefined;
                anchored_at?: string | undefined;
            }, {
                poseidon_hash?: string | undefined;
                tsa_token?: string | undefined;
                starknet_tx?: string | undefined;
                anchored_at?: string | undefined;
            }>>>;
            biscuit: z.ZodOptional<z.ZodOptional<z.ZodObject<{
                required_caps: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
                max_scope: z.ZodOptional<z.ZodOptional<z.ZodEnum<["project", "session", "global"]>>>;
            }, "strict", z.ZodTypeAny, {
                required_caps?: string[] | undefined;
                max_scope?: "session" | "project" | "global" | undefined;
            }, {
                required_caps?: string[] | undefined;
                max_scope?: "session" | "project" | "global" | undefined;
            }>>>;
            audit_status: z.ZodOptional<z.ZodOptional<z.ZodEnum<["approved", "review", "rejected"]>>>;
            observability_metric: z.ZodOptional<z.ZodOptional<z.ZodString>>;
        }, "strict", z.ZodTypeAny, {
            proof?: {
                poseidon_hash?: string | undefined;
                tsa_token?: string | undefined;
                starknet_tx?: string | undefined;
                anchored_at?: string | undefined;
            } | undefined;
            tier?: "verified" | "unverified" | "official" | undefined;
            subagent?: string | undefined;
            "model-hint"?: string | undefined;
            biscuit?: {
                required_caps?: string[] | undefined;
                max_scope?: "session" | "project" | "global" | undefined;
            } | undefined;
            audit_status?: "rejected" | "approved" | "review" | undefined;
            observability_metric?: string | undefined;
        }, {
            proof?: {
                poseidon_hash?: string | undefined;
                tsa_token?: string | undefined;
                starknet_tx?: string | undefined;
                anchored_at?: string | undefined;
            } | undefined;
            tier?: "verified" | "unverified" | "official" | undefined;
            subagent?: string | undefined;
            "model-hint"?: string | undefined;
            biscuit?: {
                required_caps?: string[] | undefined;
                max_scope?: "session" | "project" | "global" | undefined;
            } | undefined;
            audit_status?: "rejected" | "approved" | "review" | undefined;
            observability_metric?: string | undefined;
        }>>>;
    }, z.ZodTypeAny, "passthrough"> | undefined;
    license?: string | undefined;
    compatibility?: string | undefined;
    "allowed-tools"?: string | undefined;
}>;

// Warning: (ae-missing-release-tag) "SkillMdParseError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SkillMdParseError`

```typescript
export class SkillMdParseError extends Error {
    constructor(filePath: string, reason: string);
    readonly filePath: string;
}

// Warning: (ae-missing-release-tag) "SkillMdValidationError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SkillMdValidationError`

```typescript
export class SkillMdValidationError extends Error {
    constructor(filePath: string, issues: ReadonlyArray<{
        path: string;
        message: string;
    }>);
    readonly filePath: string;
    readonly issues: ReadonlyArray<{
        path: string;
        message: string;
    }>;
}
```

### `SkillNotConfiguredError`

```typescript
export class SkillNotConfiguredError extends Error {
    constructor(skillName: string, missingEnv: readonly string[]);
    readonly missingEnv: readonly string[];
    readonly skillName: string;
}

// Warning: (ae-missing-release-tag) "SkillRegistry" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SkillRegistry`

```typescript
export type SkillRegistry = Record<string, Skill>;

// Warning: (ae-missing-release-tag) "SkillRegistryBundle" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SkillRegistryBundle`

```typescript
export interface SkillRegistryBundle {
    baseNames: readonly string[];
    extraNames: readonly string[];
    registry: SkillRegistry;
}

// Warning: (ae-missing-release-tag) "SlackApprovalResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SlackApprovalResult`

```typescript
export interface SlackApprovalResult {
    approvalId: string;
    messageTs: string;
}

// Warning: (ae-missing-release-tag) "SlackChannel" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SlackChannel`

```typescript
export class SlackChannel implements MessagingChannelPort {
    constructor(config: SlackChannelConfig);
    sendAlert(level: AlertLevel, title: string, body: string): Promise<void>;
    sendMessage(target: string, text: string): Promise<void>;
}

// Warning: (ae-missing-release-tag) "SlackChannelConfig" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SlackChannelConfig`

```typescript
export interface SlackChannelConfig {
    webhookUrl: string;
}

// Warning: (ae-forgotten-export) The symbol "SlackNotifyInput" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "slackNotify" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `slackNotify`

```typescript
export const slackNotify: Skill<SlackNotifyInput, SlackNotifyOutput>;

// Warning: (ae-missing-release-tag) "SlackNotifyOutput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SlackNotifyOutput`

```typescript
export interface SlackNotifyOutput {
    delivered: boolean;
    ts: string | null;
}

// Warning: (ae-missing-release-tag) "SlackTriggerContext" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SlackTriggerContext`

```typescript
export interface SlackTriggerContext {
    channelId: string;
    userId: string;
}
```

### `SleepFn`

```typescript
export type SleepFn = (ms: number) => Promise<void>;

// Warning: (ae-missing-release-tag) "SolvencyClaim" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SolvencyClaim`

```typescript
export interface SolvencyClaim {
    readonly assets_ge_liabilities: boolean;
    readonly oracle_quorum?: number;
    readonly portfolio_id: PortfolioId;
    readonly proof_grade: ProofGrade;
    readonly stark_proof?: string;
    readonly timestamp: Date;
}

// Warning: (ae-missing-release-tag) "SOTA" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SOTA`

```typescript
export const SOTA: Axiom;

// Warning: (ae-missing-release-tag) "sotaScorer" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `sotaScorer`

```typescript
export const sotaScorer: ScoringFunction;

// Warning: (ae-missing-release-tag) "SprintInput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SprintInput`

```typescript
export interface SprintInput {
    readonly end_date?: string;
    readonly goal?: string;
    readonly name: string;
    readonly project_slug: string;
    readonly start_date?: string;
}

// Warning: (ae-missing-release-tag) "SprintRef" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SprintRef`

```typescript
export interface SprintRef {
    readonly created_at: Date;
    readonly name: string;
    readonly project_slug: string;
    readonly sprint_id: string;
}

// Warning: (ae-missing-release-tag) "SqlReadOnlyViolation" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SqlReadOnlyViolation`

```typescript
export class SqlReadOnlyViolation extends Error {
    constructor(query: string);
    readonly query: string;
}

// Warning: (ae-forgotten-export) The symbol "StarknetBalanceInput" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "starknetBalance" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `starknetBalance`

```typescript
export const starknetBalance: Skill<StarknetBalanceInput, StarknetBalanceOutput>;

// Warning: (ae-missing-release-tag) "StarknetBalanceOutput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `StarknetBalanceOutput`

```typescript
export interface StarknetBalanceOutput {
    address: string;
    balance_wei: string;
    token: "STRK" | "ETH" | "VAULT";
}

// Warning: (ae-missing-release-tag) "StartWorkflowOpts" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `StartWorkflowOpts`

```typescript
export interface StartWorkflowOpts {
    readonly idempotencyKey?: string;
    readonly input: unknown;
    readonly manifestHash?: string;
    readonly tenantId: string;
    readonly workflowName: string;
    readonly workflowVersion: string;
}

// Warning: (ae-missing-release-tag) "stdoutTelemetrySink" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `stdoutTelemetrySink`

```typescript
export function stdoutTelemetrySink(opts?: StdoutTelemetrySinkOptions): TelemetrySink;

// Warning: (ae-missing-release-tag) "StdoutTelemetrySinkOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `StdoutTelemetrySinkOptions`

```typescript
export interface StdoutTelemetrySinkOptions {
    json?: boolean;
    stream?: NodeJS.WritableStream;
}

// Warning: (ae-missing-release-tag) "StepCountExceededError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `StepCountExceededError`

```typescript
export class StepCountExceededError extends Error {
    constructor(currentCount: number, max: number);
    readonly code = "OODA_STEP_COUNT_EXCEEDED";
}
```

### `StepEvent`

```typescript
export interface StepEvent {
    readonly costUsd?: number;
    readonly cycleEventId?: string;
    readonly cycleIndex: number;
    readonly durationMs: number;
    readonly model?: string;
    readonly phase: OODAPhaseKind;
    readonly runId: string;
    readonly tokensIn?: number;
    readonly tokensOut?: number;
}

// Warning: (ae-missing-release-tag) "StepKind" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `StepKind`

```typescript
export type StepKind = "tool_call" | "sleep" | "wait_signal" | "await_block" | "await_event" | "submit_tx" | "human" | "ctx_now" | "ctx_random" | "ctx_uuid" | "child_workflow";

// Warning: (ae-missing-release-tag) "StepOpts" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `StepOpts`

```typescript
export interface StepOpts {
    readonly backoffMs?: number;
    readonly idempotencyKey?: string;
    readonly maxAttempts?: number;
    readonly timeoutMs?: number;
}

// Warning: (ae-missing-release-tag) "StepResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `StepResult`

```typescript
export interface StepResult {
    durationMs: number;
    error?: string;
    output?: unknown;
    status: "completed" | "failed" | "skipped";
    stepIndex: number;
}

// Warning: (ae-missing-release-tag) "StepStatus" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `StepStatus`

```typescript
export type StepStatus = "pending" | "running" | "done" | "failed";

// Warning: (ae-missing-release-tag) "storeReflexion" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `storeReflexion`

```typescript
export function storeReflexion(entry: ReflexionEntry, agentId: string, archiver: (input: {
    content: string;
    category?: string;
    tags?: string[];
    confidence?: number;
    metadata?: Record<string, unknown>;
}) => Promise<unknown>): Promise<void>;

// Warning: (ae-missing-release-tag) "Strategy" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `Strategy`

```typescript
export interface Strategy<TInput, TOutput> {
    readonly name: string;
    run(input: TInput, generator: (input: TInput, ctx: ComputeContext) => Promise<TOutput>, ctx?: ComputeContext): Promise<StrategyResult<TOutput>>;
}
```

### `StrategyAgentContext`

```typescript
export interface StrategyAgentContext {
    readonly agentId: string;
    readonly allowedTools?: readonly string[];
    readonly hooks?: AgentHooks;
    readonly llm?: LLMProviderPort;
    readonly llmFn?: StrategyLLMCompletionFn;
    readonly logger: LoggerPort;
    readonly maxSteps: number;
    readonly runId: string;
    readonly signal?: AbortSignal;
    readonly systemPrompt: string;
    readonly task: string;
    readonly tools: ToolRegistry;
}
```

### `StrategyLLMCompletionFn`

```typescript
export type StrategyLLMCompletionFn = (messages: readonly StrategyMessage[]) => Promise<StrategyLLMResponse>;
```

### `StrategyLLMResponse`

```typescript
export interface StrategyLLMResponse {
    readonly content: string;
    readonly model: string;
    readonly provider: string;
    readonly tokensIn: number;
    readonly tokensOut: number;
    readonly toolCalls?: readonly StrategyToolCall[];
}
```

### `StrategyMessage`

```typescript
export interface StrategyMessage {
    readonly content: string;
    readonly role: "system" | "user" | "assistant" | "tool";
    readonly toolCallId?: string;
    readonly toolName?: string;
}

// Warning: (ae-missing-release-tag) "StrategyResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `StrategyResult`

```typescript
export interface StrategyResult<T> {
    metadata: {
        strategy: string;
        candidates: number;
        verifier_scores: number[];
        cost: {
            calls: number;
        };
        latency_ms: number;
    };
    result: T;
}

// Warning: (ae-missing-release-tag) "StrategyRunClaim" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `StrategyRunClaim`

```typescript
export interface StrategyRunClaim {
    readonly integrity_proven: boolean;
    readonly proof_commitment: string;
    readonly sprint_id: string;
    readonly strategy_id: string;
    readonly timestamp: Date;
}

// Warning: (ae-missing-release-tag) "StrategyRunInput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `StrategyRunInput`

```typescript
export interface StrategyRunInput {
    readonly code_commit: string;
    readonly dataset_hash: string;
    readonly sprint_id: string;
    readonly strategy_id: string;
}
```

### `StrategyStepEvent`

```typescript
export interface StrategyStepEvent extends StepEvent {
    readonly strategy: AgentStrategyName;
}
```

### `StrategyToolCall`

```typescript
export interface StrategyToolCall {
    readonly arguments: Record<string, unknown>;
    readonly id: string;
    readonly name: string;
}

// Warning: (ae-missing-release-tag) "StreamDelta" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `StreamDelta`

```typescript
export interface StreamDelta {
    delta: string;
    usage?: ChatUsage;
}

// Warning: (ae-missing-release-tag) "StressLedger" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `StressLedger`

```typescript
export class StressLedger {
    clear(): void;
    export(): ImmuneMemoryEntry[];
    record(embedding: number[], label: string): ImmuneMemoryEntry;
    search(embedding: number[], threshold?: number): ImmuneMatch[];
    get size(): number;
}

// Warning: (ae-missing-release-tag) "STRICT_PII_DETECTOR" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `STRICT_PII_DETECTOR`

```typescript
export const STRICT_PII_DETECTOR: PIIDetector;

// Warning: (ae-missing-release-tag) "StructuredOutputError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `StructuredOutputError`

```typescript
export class StructuredOutputError extends Error {
    constructor(message: string, zodError: ZodError);
    readonly zodError: ZodError;
}

// Warning: (ae-missing-release-tag) "StructuredOutputOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `StructuredOutputOptions`

```typescript
export interface StructuredOutputOptions<T> {
    fn: (input: {
        messages: Array<{
            role: string;
            content: string;
        }>;
    }, ctx: OODAContext) => Promise<string>;
    maxRetries?: number;
    schema: ZodSchema<T>;
}

// Warning: (ae-missing-release-tag) "StructuredOutputResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `StructuredOutputResult`

```typescript
export interface StructuredOutputResult<T> {
    parsed: T;
    rawMessages: Array<{
        role: string;
        content: string;
    }>;
    retries: number;
}

// Warning: (ae-missing-release-tag) "SubscribeHandle" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SubscribeHandle`

```typescript
export interface SubscribeHandle {
    close: () => void;
}

// Warning: (ae-missing-release-tag) "subscribeToRun" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `subscribeToRun`

```typescript
export function subscribeToRun(runId: string, opts: SubscribeToRunOptions): Promise<SubscribeHandle>;

// Warning: (ae-missing-release-tag) "SubscribeToRunOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SubscribeToRunOptions`

```typescript
export interface SubscribeToRunOptions {
    baseUrl: string;
    getToken?: () => Promise<string>;
    lastEventId?: string;
    onComplete?: (data: {
        status: string;
        duration_ms?: number;
    }) => void;
    onError?: (err: Error) => void;
    onStep?: (step: RunStep, event: "step_existing" | "step_new") => void;
    signal?: AbortSignal;
}

// Warning: (ae-missing-release-tag) "Subscription" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `Subscription`

```typescript
export interface Subscription {
    unsubscribe(): Promise<void>;
}

// Warning: (ae-missing-release-tag) "SubTokenClaims" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SubTokenClaims`

```typescript
export interface SubTokenClaims {
    cnf?: {
        jkt: string;
    };
    exp: number;
    jti: string;
    scope: SubTokenScope;
    v: 1;
}

// Warning: (ae-missing-release-tag) "SubTokenScope" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SubTokenScope`

```typescript
export type SubTokenScope = "read-only" | "approve-only" | "full";

// Warning: (ae-missing-release-tag) "SUPPORTED_JURISDICTIONS_V0" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SUPPORTED_JURISDICTIONS_V0`

```typescript
export const SUPPORTED_JURISDICTIONS_V0: Jurisdiction[];

// Warning: (ae-missing-release-tag) "SwapParams" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SwapParams`

```typescript
export interface SwapParams {
    readonly amount: string;
    readonly deadline: number;
    readonly max_slippage_bps: number;
    readonly token_in: TokenAddress;
    readonly token_out: TokenAddress;
}

// Warning: (ae-missing-release-tag) "SwapResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `SwapResult`

```typescript
export interface SwapResult {
    readonly actual_slippage_bps: number;
    readonly amount_out: string;
    readonly executed_at: Date;
    readonly tx_hash: string;
}

// Warning: (ae-missing-release-tag) "TaskFeatures" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TaskFeatures`

```typescript
export interface TaskFeatures {
    contextLength: number;
    hasCrossReference: boolean;
    hasMultipleSteps: boolean;
    hasNumerics: boolean;
    inputLength: number;
    requiresCreativity: boolean;
    requiresReasoning: boolean;
}

// Warning: (ae-missing-release-tag) "TaskRef" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TaskRef`

```typescript
export interface TaskRef {
    readonly project: string;
    readonly ref: string;
    readonly sprint: string;
    readonly task_id: string;
}

// Warning: (ae-missing-release-tag) "TaskStatus" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TaskStatus`

```typescript
export type TaskStatus = "todo" | "in_progress" | "done" | "blocked" | "rejected";

// Warning: (ae-missing-release-tag) "teeSink" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `teeSink`

```typescript
export function teeSink(...sinks: SessionEventSink[]): SessionEventSink;

// Warning: (ae-missing-release-tag) "TelegramApprovalResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TelegramApprovalResult`

```typescript
export interface TelegramApprovalResult {
    approvalId: string;
    messageId: number;
}

// Warning: (ae-missing-release-tag) "TelegramChannel" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TelegramChannel`

```typescript
export class TelegramChannel implements MessagingChannelPort {
    constructor(config: TelegramChannelConfig);
    sendAlert(level: AlertLevel, title: string, body: string): Promise<void>;
    sendMessage(target: string, text: string): Promise<void>;
}

// Warning: (ae-missing-release-tag) "TelegramChannelConfig" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TelegramChannelConfig`

```typescript
export interface TelegramChannelConfig {
    botToken: string;
    defaultChatId?: string;
}

// Warning: (ae-forgotten-export) The symbol "TelegramNotifyInput" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "telegramNotify" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `telegramNotify`

```typescript
export const telegramNotify: Skill<TelegramNotifyInput, TelegramNotifyOutput>;

// Warning: (ae-missing-release-tag) "TelegramNotifyOutput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TelegramNotifyOutput`

```typescript
export interface TelegramNotifyOutput {
    delivered: boolean;
    message_id: number | null;
}
```

### `TelegramRateLimitError`

```typescript
export class TelegramRateLimitError extends Error {
    constructor(retryAfterSeconds?: number | undefined);
    readonly retryAfterSeconds?: number | undefined;
}

// Warning: (ae-missing-release-tag) "TelegramTriggerContext" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TelegramTriggerContext`

```typescript
export interface TelegramTriggerContext {
    chatId: string;
    from?: {
        username?: string;
    };
}

// Warning: (ae-missing-release-tag) "TelemetryBusOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TelemetryBusOptions`

```typescript
export interface TelemetryBusOptions {
    logger?: TelemetryLogger;
    maxQueueDepth?: number;
    nonBlocking?: boolean;
    sinks: readonly TelemetrySink[];
}

// Warning: (ae-missing-release-tag) "TelemetryCounters" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TelemetryCounters`

```typescript
export interface TelemetryCounters {
    readonly dispatched: number;
    readonly dropped: number;
    readonly sinkErrors: number;
}

// Warning: (ae-missing-release-tag) "TelemetryLogger" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TelemetryLogger`

```typescript
export interface TelemetryLogger {
    error(obj: Record<string, unknown>, msg?: string): void;
    warn(obj: Record<string, unknown>, msg?: string): void;
}

// Warning: (ae-missing-release-tag) "TelemetryRunFinish" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TelemetryRunFinish`

```typescript
export interface TelemetryRunFinish {
    errorMessage?: string;
    finishedAt: string;
    outcome?: {
        type: string;
        valueCents: number;
        quality?: number;
        confidence?: number;
        metadata?: Record<string, unknown>;
    };
    status: TelemetryRunStatus;
    stopReason?: string;
    totalCostUsd?: number;
    totalInputTokens?: number;
    totalOutputTokens?: number;
    totalToolCalls?: number;
}

// Warning: (ae-missing-release-tag) "TelemetryRunStart" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TelemetryRunStart`

```typescript
export interface TelemetryRunStart {
    agentId: string;
    agentVersion: string;
    model: string;
    provider: string;
    runId: string;
    startedAt: string;
    tenantId?: string;
    traceId?: string;
}

// Warning: (ae-missing-release-tag) "TelemetryRunStatus" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TelemetryRunStatus`

```typescript
export type TelemetryRunStatus = "success" | "failed" | "skipped" | "timeout" | "incoherent";

// Warning: (ae-missing-release-tag) "TelemetryRunStep" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TelemetryRunStep`

```typescript
export interface TelemetryRunStep {
    costUsd: number;
    durationMs?: number;
    inputTokens: number;
    kind: string;
    metadata?: Record<string, unknown>;
    outputTokens: number;
    status: "completed" | "failed" | "skipped";
    stepIndex: number;
    toolCalls?: number;
}

// Warning: (ae-missing-release-tag) "TelemetrySink" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TelemetrySink`

```typescript
export interface TelemetrySink {
    finish(runId: string, event: TelemetryRunFinish): Promise<void>;
    flush?(): Promise<void>;
    readonly name: string;
    start(event: TelemetryRunStart): Promise<string | void>;
    step(runId: string, delta: TelemetryRunStep): Promise<void>;
}

// Warning: (ae-missing-release-tag) "TelemetrySinkError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TelemetrySinkError`

```typescript
export class TelemetrySinkError extends Error {
    constructor(message: string, sinkName: string, cause?: unknown | undefined);
    readonly cause?: unknown | undefined;
    readonly sinkName: string;
}

// Warning: (ae-missing-release-tag) "TenantContext" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TenantContext`

```typescript
export interface TenantContext {
    readonly glacisMode: "verified" | "degraded_verified" | "unverified";
    readonly jurisdictions: Jurisdiction[];
    readonly tenantId: string;
    readonly verifiedHuman: boolean;
}

// Warning: (ae-missing-release-tag) "TenantContextPort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TenantContextPort`

```typescript
export interface TenantContextPort {
    enterDegradedMode(tenantId: string, reason: string): Promise<void>;
    getCumulativeDegradedTime(tenantId: string, windowDays?: number): Promise<number>;
    // Warning: (ae-forgotten-export) The symbol "TenantContext_2" needs to be exported by the entry point index.d.ts
    getCurrent(tenantId: string): Promise<TenantContext_2 | null>;
    getDegradedMetrics(tenantId: string): Promise<DegradedMetrics>;
    getKek(tenantId: string): Promise<string>;
    restoreVerified(tenantId: string, glacisAttestation: {
        txRef: string;
        nullifierRoot: string;
        blockNumber: number;
    }): Promise<void>;
}

// Warning: (ae-missing-release-tag) "TenantNotFoundError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TenantNotFoundError`

```typescript
export class TenantNotFoundError extends Error {
    constructor(tenantId: string);
    readonly tenantId: string;
}

// Warning: (ae-missing-release-tag) "TierPolicy" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TierPolicy`

```typescript
export interface TierPolicy {
    tiersFor(category: string, mode: "degraded" | "full"): ModelTier[];
}

// Warning: (ae-missing-release-tag) "TimestampPort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TimestampPort`

```typescript
export interface TimestampPort {
    request(rootHash: string): Promise<SignedReceipt>;
    verify(receipt: SignedReceipt, rootHash: string): Promise<{
        valid: boolean;
        reason?: string;
    }>;
}

// Warning: (ae-missing-release-tag) "toDiscoveryEntry" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `toDiscoveryEntry`

```typescript
export function toDiscoveryEntry(parsed: ParsedSkillFile): {
    name: string;
    description: string;
    tier: VaubanSkillTier;
};
```

### `ToolCall`

```typescript
export interface ToolCall {
    args: Record<string, unknown>;
    tool: string;
}

// Warning: (ae-missing-release-tag) "ToolError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ToolError`

```typescript
export interface ToolError {
    code: ToolErrorCode;
    message: string;
    toolName: string;
}

// Warning: (ae-missing-release-tag) "ToolErrorCode" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ToolErrorCode`

```typescript
export type ToolErrorCode = "not_found" | "validation_failed" | "execution_failed" | "duplicate_name";

// Warning: (ae-missing-release-tag) "ToolRegistry" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ToolRegistry`

```typescript
export interface ToolRegistry {
    clear(): void;
    execute(name: string, args: unknown): Promise<ToolResult>;
    get(name: string): AgentTool | undefined;
    has(name: string): boolean;
    listMCPDefinitions(): MCPToolDefinition[];
    listNames(): string[];
    register<T extends z.ZodTypeAny>(tool: AgentTool<T>): ToolResult<void>;
    readonly size: number;
    unregister(name: string): boolean;
}

// Warning: (ae-missing-release-tag) "ToolRegistryImpl" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ToolRegistryImpl`

```typescript
export class ToolRegistryImpl implements ToolRegistry {
    clear(): void;
    execute(name: string, args: unknown): Promise<ToolResult>;
    get(name: string): AgentTool | undefined;
    has(name: string): boolean;
    listMCPDefinitions(): MCPToolDefinition[];
    listNames(): string[];
    register<T extends z.ZodTypeAny>(tool: AgentTool<T>): ToolResult<void>;
    get size(): number;
    unregister(name: string): boolean;
}

// Warning: (ae-missing-release-tag) "ToolResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ToolResult`

```typescript
export type ToolResult<T = unknown> = {
    ok: true;
    data: T;
} | {
    ok: false;
    error: ToolError;
};

// Warning: (ae-missing-release-tag) "toolSpan" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `toolSpan`

```typescript
export function toolSpan(tracer: Tracer, toolName: string, args: unknown): Span;

// Warning: (ae-missing-release-tag) "toSdkEscalationLevel" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `toSdkEscalationLevel`

```typescript
export function toSdkEscalationLevel(level: EscalationLevel): SdkEscalationLevel;

// Warning: (ae-missing-release-tag) "ToTConfig" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ToTConfig`

```typescript
export interface ToTConfig {
    branchFactor: number;
    evaluateState?: (state: unknown) => number;
    maxCalls: number;
    maxDepth: number;
    pruneThreshold: number;
    searchPolicy: ToTSearchPolicy;
}

// Warning: (ae-missing-release-tag) "ToTSearchPolicy" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ToTSearchPolicy`

```typescript
export type ToTSearchPolicy = "bfs" | "dfs";

// Warning: (ae-missing-release-tag) "Trace" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `Trace`

```typescript
export interface Trace {
    agentId: string;
    agentSignature?: string;
    agentVersion: string;
    completedAt: number;
    config: Record<string, unknown>;
    configHash: string;
    receipt?: SignedReceipt;
    receiptRetryAt?: number;
    receiptStatus?: ReceiptStatus;
    rootHash: string;
    runId: string;
    schemaVersion: typeof TRACE_SCHEMA_VERSION;
    startedAt: number;
    status: "completed" | "failed" | "skipped";
    steps: TraceStep[];
    totalSteps: number;
}

// Warning: (ae-missing-release-tag) "TRACE_SCHEMA_VERSION" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TRACE_SCHEMA_VERSION`

```typescript
export const TRACE_SCHEMA_VERSION: "1.0.0";

// Warning: (ae-missing-release-tag) "tracedPort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `tracedPort`

```typescript
export function tracedPort<T extends object>(impl: T, options: TracedPortOptions): T;

// Warning: (ae-missing-release-tag) "TracedPortOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TracedPortOptions`

```typescript
export interface TracedPortOptions {
    attributeHook?: (ctx: {
        span: Span;
        method: string;
        args: readonly unknown[];
        result?: unknown;
    }) => void;
    portName: string;
    tracerName?: string;
}

// Warning: (ae-missing-release-tag) "TraceReplayError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TraceReplayError`

```typescript
export class TraceReplayError extends Error {
    constructor(msg: string);
}

// Warning: (ae-missing-release-tag) "TraceStep" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TraceStep`

```typescript
export interface TraceStep {
    costUsd?: number;
    durationMs: number;
    guardName?: string;
    index: number;
    inputHash: string;
    inputOriginalHmac?: string;
    model?: {
        provider: string;
        name: string;
        version: string;
    };
    outputHash: string;
    outputOriginalHmac?: string;
    phase: "observe" | "orient" | "decide" | "act" | "feedback" | "guard" | "hitl";
    policy: "include" | "redact" | "hmac" | "hash-only";
    prevStepHash: string;
    runId: string;
    stepHash: string;
    storedInput?: unknown;
    storedOutput?: unknown;
    timestamp: number;
    tokens?: {
        input: number;
        output: number;
        cacheRead?: number;
    };
    toolName?: string;
    type: "llm_call" | "tool_call" | "guard_check" | "phase_transition" | "hitl_gate";
}

// Warning: (ae-missing-release-tag) "Trade" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `Trade`

```typescript
export interface Trade {
    agent_run_id: string | null;
    alpaca_order_id: string;
    entry_at: string;
    entry_price_cents: number;
    exit_at: string | null;
    exit_price_cents: number | null;
    exit_reason: "stop" | "target" | "timeout" | "manual" | null;
    id: string;
    outcome_id: string;
    pnl_cents: number | null;
    quantity: number;
    side: "BUY" | "SELL";
    slippage_bps: number | null;
    symbol: string;
    trading_mode: "paper" | "live";
}

// Warning: (ae-missing-release-tag) "TradeClaim" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TradeClaim`

```typescript
export interface TradeClaim {
    readonly anchor_id?: string;
    readonly executed: boolean;
    readonly hmac_signature: string;
    readonly timestamp: Date;
    readonly trade_id: string;
}

// Warning: (ae-missing-release-tag) "TradeRecord" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TradeRecord`

```typescript
export interface TradeRecord {
    readonly id: string;
    readonly price: string;
    readonly qty: string;
    readonly side: "buy" | "sell";
    readonly ts: Date;
}

// Warning: (ae-missing-release-tag) "TradingNQConfig" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TradingNQConfig`

```typescript
export interface TradingNQConfig {
    thresholds: {
        conviction_min: number;
        kelly_cap: number;
        kelly_bootstrap_fraction: number;
        bootstrap_trade_threshold: number;
        hitl_timeout_ms: number;
        stop_loss_atr_multiple: number;
        target_atr_multiple: number;
        trade_timeout_minutes: number;
    };
}

// Warning: (ae-missing-release-tag) "TrajectoryConfidenceConfig" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TrajectoryConfidenceConfig`

```typescript
export interface TrajectoryConfidenceConfig {
    alpha?: number;
    initial?: number;
    tau?: number;
}

// Warning: (ae-missing-release-tag) "TrajectoryConfidenceState" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TrajectoryConfidenceState`

```typescript
export interface TrajectoryConfidenceState {
    observations: number;
    peak: number;
    trough: number;
    value: number;
}

// Warning: (ae-missing-release-tag) "TrajectoryConfidenceTracker" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TrajectoryConfidenceTracker`

```typescript
export class TrajectoryConfidenceTracker {
    constructor(config?: TrajectoryConfidenceConfig);
    isInterruptRecommended(): boolean;
    observe(stepConfidence: number): TrajectoryConfidenceState;
    reset(): void;
    snapshot(): TrajectoryConfidenceState;
}

// Warning: (ae-missing-release-tag) "TrajectoryExport" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TrajectoryExport`

```typescript
export interface TrajectoryExport {
    format: TrajectoryFormat;
    steps: TrajectoryStep[];
    totalCost: number;
    totalTokens: number;
}

// Warning: (ae-missing-release-tag) "TrajectoryFormat" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TrajectoryFormat`

```typescript
export type TrajectoryFormat = "jsonl" | "openai-dpo";

// Warning: (ae-missing-release-tag) "TrajectoryOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TrajectoryOptions`

```typescript
export interface TrajectoryOptions {
    format: TrajectoryFormat;
    maxSteps?: number;
    minTokens?: number;
}

// Warning: (ae-missing-release-tag) "TrajectoryStep" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TrajectoryStep`

```typescript
export interface TrajectoryStep {
    costUsd?: number;
    durationMs?: number;
    input?: unknown;
    inputTokens?: number;
    label: "positive" | "negative" | "neutral";
    model?: string;
    output?: unknown;
    outputTokens?: number;
    phase: string;
    provider?: string;
    runId: string;
    stepIndex: number;
    timestamp?: string;
    type: string;
}

// Warning: (ae-missing-release-tag) "TransferParams" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TransferParams`

```typescript
export interface TransferParams {
    readonly amount: string;
    readonly recipient: string;
    readonly token: TokenAddress;
}

// Warning: (ae-missing-release-tag) "TransferResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TransferResult`

```typescript
export interface TransferResult {
    readonly amount: string;
    readonly recipient: string;
    readonly tx_hash: string;
}

// Warning: (ae-missing-release-tag) "TransportMeta" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TransportMeta`

```typescript
export interface TransportMeta {
    readonly jws_signature: string;
    // Warning: (ae-forgotten-export) The symbol "Protocol" needs to be exported by the entry point index.d.ts
    //
    readonly protocol: Protocol;
    readonly version: string;
}

// Warning: (ae-missing-release-tag) "treeOfThoughtsStrategy" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `treeOfThoughtsStrategy`

```typescript
export function treeOfThoughtsStrategy<TInput, TOutput>(config?: Partial<ToTConfig>): Strategy<TInput, TOutput>;

// Warning: (ae-missing-release-tag) "triggerFromSlack" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `triggerFromSlack`

```typescript
export function triggerFromSlack(agents: AgentsClient, pipelines: PipelinesClient, ctx: SlackTriggerContext, command: string, args: string[]): Promise<MessagingTriggerResult>;

// Warning: (ae-missing-release-tag) "triggerFromTelegram" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `triggerFromTelegram`

```typescript
export function triggerFromTelegram(agents: AgentsClient, pipelines: PipelinesClient, ctx: TelegramTriggerContext, command: string, args: string[]): Promise<MessagingTriggerResult>;

// Warning: (ae-missing-release-tag) "tripCircuitBreaker" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `tripCircuitBreaker`

```typescript
export function tripCircuitBreaker(redisUrl: string, name: string, redisClientFactory?: (url: string) => MinimalRedisClient): Promise<void>;
```

### `tryParseJsonToolCallFallback`

```typescript
export function tryParseJsonToolCallFallback(content: string): {
    name: string;
    arguments: Record<string, unknown>;
} | null;

// Warning: (ae-missing-release-tag) "tryPersistEvent" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `tryPersistEvent`

```typescript
export function tryPersistEvent(persistence: PersistencePort | undefined, event: SessionEvent): Promise<void>;

// Warning: (ae-missing-release-tag) "Turn" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `Turn`

```typescript
export interface Turn {
    readonly content: string;
    readonly meta?: {
        readonly timestamp?: number;
        readonly tokensIn?: number;
        readonly tokensOut?: number;
        readonly model?: string;
        readonly provider?: string;
    };
    readonly role: "user" | "assistant";
}

// Warning: (ae-missing-release-tag) "TwoPhaseOrientConfig" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TwoPhaseOrientConfig`

```typescript
export interface TwoPhaseOrientConfig<C, O, R> {
    act: (orientation: O, context: C) => Promise<R>;
    maxActRetries?: number;
    orient: (context: C) => Promise<O>;
}

// Warning: (ae-missing-release-tag) "TwoPhaseOrientError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TwoPhaseOrientError`

```typescript
export class TwoPhaseOrientError extends Error {
    constructor(phase: "orient" | "act", cause: unknown, retriesUsed: number, message: string);
    readonly cause: unknown;
    readonly phase: "orient" | "act";
    readonly retriesUsed: number;
}

// Warning: (ae-missing-release-tag) "TwoPhaseOrientResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `TwoPhaseOrientResult`

```typescript
export interface TwoPhaseOrientResult<O, R> {
    orientation: O;
    result: R;
    retriesUsed: number;
}

// Warning: (ae-missing-release-tag) "UndeterministicSideEffectError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `UndeterministicSideEffectError`

```typescript
export class UndeterministicSideEffectError extends Error {
    constructor(url: string, method: string);
}

// Warning: (ae-missing-release-tag) "UnknownSourceError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `UnknownSourceError`

```typescript
export class UnknownSourceError extends Error {
    constructor(source: string);
    readonly source: string;
}

// Warning: (ae-missing-release-tag) "updateCoherenceModel" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `updateCoherenceModel`

```typescript
export function updateCoherenceModel(model: CoherenceModel, episode: CoherenceEpisode): CoherenceModel;

// Warning: (ae-missing-release-tag) "ValidatedDpop" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ValidatedDpop`

```typescript
export interface ValidatedDpop {
    claims: DpopClaims;
    jkt: string;
    valid: true;
}

// Warning: (ae-missing-release-tag) "ValidateDpopOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `ValidateDpopOptions`

```typescript
export interface ValidateDpopOptions {
    accessToken?: string;
    expectedHtm: string;
    expectedHtu: string;
    expectedJkt: string;
    isReplayed?: (jti: string) => boolean;
    maxAgeSec?: number;
    now?: () => number;
    recordJti?: (jti: string, expiresAtMs: number) => void;
}

// Warning: (ae-missing-release-tag) "validateDpopProof" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `validateDpopProof`

```typescript
export function validateDpopProof(dpopJwt: string, opts: ValidateDpopOptions): Promise<DpopValidationResult>;

// Warning: (ae-missing-release-tag) "validateEvent" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `validateEvent`

```typescript
export function validateEvent(type: string, payload: unknown): {
    valid: boolean;
    error?: string;
};

// Warning: (ae-missing-release-tag) "validateGoldenFixtures" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `validateGoldenFixtures`

```typescript
export function validateGoldenFixtures(ledger: StressLedger): {
    passed: boolean;
    results: Array<{
        label: string;
        matched: boolean;
        similarity: number;
    }>;
};

// Warning: (ae-missing-release-tag) "validateOutcome" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `validateOutcome`

```typescript
export function validateOutcome(outcome: {
    valueCents: number;
}, currentBalance: MeterBalance, opts?: OutcomeGateOptions): OutcomeGateResult;

// Warning: (ae-missing-release-tag) "validatePersona" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `validatePersona`

```typescript
export function validatePersona(input: unknown): AgentPersona;

// Warning: (ae-missing-release-tag) "validateTransition" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `validateTransition`

```typescript
export function validateTransition(from: HITLState, to: HITLState): void;

// Warning: (ae-missing-release-tag) "VaubanAuditStatus" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
// Warning: (ae-missing-release-tag) "VaubanAuditStatus" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `VaubanAuditStatus`

```typescript
export const VaubanAuditStatus: z.ZodEnum<["approved", "review", "rejected"]>;
```

### `VaubanAuditStatus`

```typescript
export type VaubanAuditStatus = z.infer<typeof VaubanAuditStatus>;

// Warning: (ae-missing-release-tag) "VaubanBiscuitScope" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
// Warning: (ae-missing-release-tag) "VaubanBiscuitScope" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `VaubanBiscuitScope`

```typescript
export const VaubanBiscuitScope: z.ZodEnum<["project", "session", "global"]>;
```

### `VaubanBiscuitScope`

```typescript
export type VaubanBiscuitScope = z.infer<typeof VaubanBiscuitScope>;

// Warning: (ae-missing-release-tag) "VaubanSDKOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `VaubanSDKOptions`

```typescript
export interface VaubanSDKOptions {
    agentId: string;
    agentName?: string;
    agentVersion: string;
    apiKey: string;
    capabilities?: string[];
    collectorUrl?: string;
    debug?: boolean;
    orgId: string;
    registryUrl?: string;
    repoUrl?: string;
}

// Warning: (ae-missing-release-tag) "VaubanSkillTier" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
// Warning: (ae-missing-release-tag) "VaubanSkillTier" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `VaubanSkillTier`

```typescript
export const VaubanSkillTier: z.ZodEnum<["official", "verified", "unverified"]>;
```

### `VaubanSkillTier`

```typescript
export type VaubanSkillTier = z.infer<typeof VaubanSkillTier>;

// Warning: (ae-missing-release-tag) "VCRCassette" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `VCRCassette`

```typescript
export interface VCRCassette {
    body: string;
    headers: Record<string, string>;
    method: string;
    requestBody: string | null;
    status: number;
    statusText: string;
    timestamp: number;
    url: string;
}

// Warning: (ae-missing-release-tag) "VCRMode" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `VCRMode`

```typescript
export type VCRMode = "record" | "replay";

// Warning: (ae-missing-release-tag) "VCRStats" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `VCRStats`

```typescript
export interface VCRStats {
    hits: number;
    misses: number;
    recorded: number;
}

// Warning: (ae-missing-release-tag) "VerificationEvidence" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `VerificationEvidence`

```typescript
export interface VerificationEvidence {
    readonly evidence_hash: string;
    readonly evidence_text: string;
    readonly passed: boolean;
}

// Warning: (ae-missing-release-tag) "Verifier" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `Verifier`

```typescript
export interface Verifier<TOutput = unknown> {
    evaluate(output: TOutput): Promise<VerifierResult> | VerifierResult;
    readonly name: string;
}

// Warning: (ae-missing-release-tag) "VerifierResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `VerifierResult`

```typescript
export interface VerifierResult {
    rationale: string;
    score: number;
}

// Warning: (ae-missing-release-tag) "verifyChain" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `verifyChain`

```typescript
export function verifyChain(trace: Trace, chain: ProofChain): Promise<VerifyChainResult>;

// Warning: (ae-missing-release-tag) "VerifyChainResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `VerifyChainResult`

```typescript
export type VerifyChainResult = {
    valid: true;
    receiptStatus?: "present" | "pending" | "failed";
} | {
    valid: false;
    tamperedAt: number;
    reason: string;
    receiptStatus?: "present" | "pending" | "failed";
};

// Warning: (ae-missing-release-tag) "VerifyContext" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `VerifyContext`

```typescript
export type VerifyContext = "runtime" | "skill_ingestion";

// Warning: (ae-missing-release-tag) "verifyEvent" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `verifyEvent`

```typescript
export function verifyEvent(event: DomainEvent, secret: string, opts?: VerifyEventOptions): Promise<true>;

// Warning: (ae-missing-release-tag) "VerifyEventOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `VerifyEventOptions`

```typescript
export interface VerifyEventOptions {
    maxClockSkewMs?: number;
    nonceStore?: NonceStore;
}

// Warning: (ae-missing-release-tag) "VerifyFn" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `VerifyFn`

```typescript
export type VerifyFn = (canonicalMessage: string, sigHex: string) => boolean;

// Warning: (ae-missing-release-tag) "verifyProofClaim" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `verifyProofClaim`

```typescript
export function verifyProofClaim(claim: ProofClaim, verifyClaim: VerifyFn, traceBytes?: string): ProofClaimVerification;

// Warning: (ae-missing-release-tag) "verifySubToken" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `verifySubToken`

```typescript
export function verifySubToken(parentToken: string, token: string, now?: number): VerifySubTokenResult;

// Warning: (ae-missing-release-tag) "verifySubTokenInstrumented" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `verifySubTokenInstrumented`

```typescript
export function verifySubTokenInstrumented(parentToken: string, token: string, now?: number): VerifySubTokenResult;

// Warning: (ae-missing-release-tag) "VerifySubTokenResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `VerifySubTokenResult`

```typescript
export interface VerifySubTokenResult {
    cnf?: {
        jkt: string;
    };
    jti?: string;
    reason?: string;
    scope?: SubTokenScope;
    valid: boolean;
}

// Warning: (ae-missing-release-tag) "VetoChannel" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `VetoChannel`

```typescript
export interface VetoChannel {
    await(callId: string, windowMs: number): Promise<VetoSignal | null>;
    pendingCount(): number;
    submit(signal: VetoSignal): void;
}

// Warning: (ae-missing-release-tag) "VetoSignal" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `VetoSignal`

```typescript
export interface VetoSignal {
    at: string;
    by: string;
    callId: string;
    reason?: string;
}

// Warning: (ae-missing-release-tag) "ActionContext" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `VFActionContext`

```typescript
export interface VFActionContext {
    readonly legalBasis?: string;
    readonly runId: string;
    readonly tenantId: string;
}

// Warning: (ae-missing-release-tag) "VFAnchoringForbiddenError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `VFAnchoringForbiddenError`

```typescript
export class VFAnchoringForbiddenError extends Error {
    constructor(message: string, reason: "per_trade_anchor_forbidden" | "batch_anchor_missing", cause?: unknown | undefined);
    readonly cause?: unknown | undefined;
    readonly reason: "per_trade_anchor_forbidden" | "batch_anchor_missing";
}

// Warning: (ae-missing-release-tag) "VFinanceActionPort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `VFinanceActionPort`

```typescript
export interface VFinanceActionPort {
    getMarketSignal(symbol: Symbol_2, ctx: VFActionContext): Promise<MarketSignal>;
    getSolvencyProof(portfolioId: PortfolioId, proofGrade: ProofGrade, ctx: VFActionContext): Promise<SolvencyClaim>;
    recordTrade(trade: TradeRecord, ctx: VFActionContext): Promise<TradeClaim>;
    submitStrategyRun(strategy: StrategyRunInput, ctx: VFActionContext): Promise<StrategyRunClaim>;
}

// Warning: (ae-missing-release-tag) "VFOracleQuorumError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `VFOracleQuorumError`

```typescript
export class VFOracleQuorumError extends Error {
    constructor(required_quorum: number, available_oracles: number, cause?: unknown | undefined);
    readonly available_oracles: number;
    readonly cause?: unknown | undefined;
    readonly required_quorum: number;
}

// Warning: (ae-missing-release-tag) "VFProofGenerationError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `VFProofGenerationError`

```typescript
export class VFProofGenerationError extends Error {
    constructor(portfolio_id: PortfolioId, proof_type: "stark_range" | "commitment", cause?: unknown | undefined);
    readonly cause?: unknown | undefined;
    readonly portfolio_id: PortfolioId;
    readonly proof_type: "stark_range" | "commitment";
}

// Warning: (ae-missing-release-tag) "VFProofGradeMismatchError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `VFProofGradeMismatchError`

```typescript
export class VFProofGradeMismatchError extends Error {
    constructor(message: string, expected_grade: ProofGrade, actual_grade: ProofGrade, cause?: unknown | undefined);
    readonly actual_grade: ProofGrade;
    readonly cause?: unknown | undefined;
    readonly expected_grade: ProofGrade;
}

// Warning: (ae-missing-release-tag) "waitForHITLApproval" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `waitForHITLApproval`

```typescript
export function waitForHITLApproval(db: DbClient, args: HITLGateArgs, options?: HITLGateOptions): Promise<HITLGateVerdict>;

// Warning: (ae-forgotten-export) The symbol "WebSearchInput" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "webSearch" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `webSearch`

```typescript
export const webSearch: Skill<WebSearchInput, WebSearchOutput>;

// Warning: (ae-missing-release-tag) "WebSearchOutput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `WebSearchOutput`

```typescript
export interface WebSearchOutput {
    provider: "brave" | "tavily" | "replay";
    results: WebSearchResult[];
}

// Warning: (ae-missing-release-tag) "WebSearchResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `WebSearchResult`

```typescript
export interface WebSearchResult {
    snippet: string;
    title: string;
    url: string;
}

// Warning: (ae-missing-release-tag) "withBrainContext" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `withBrainContext`

```typescript
export function withBrainContext<TObs, TOrient>(options: BrainContextOptions<TObs>, orientFn: (input: OrientInputWithBrain<TObs>, ctx: OODAContext) => Promise<TOrient>): (input: TObs, ctx: OODAContext) => Promise<TOrient>;

// Warning: (ae-missing-release-tag) "withCompute" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `withCompute`

```typescript
export function withCompute<TInput, TOutput>(input: TInput, options: WithComputeOptions<TInput, TOutput>): Promise<WithComputeResult<TOutput>>;

// Warning: (ae-missing-release-tag) "WithComputeOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `WithComputeOptions`

```typescript
export interface WithComputeOptions<TInput, TOutput> {
    // Warning: (ae-forgotten-export) The symbol "ComputeBudget" needs to be exported by the entry point index.d.ts
    budget?: ComputeBudget;
    deadline?: number;
    generator: (input: TInput, ctx: ComputeContext) => Promise<TOutput>;
    signal?: AbortSignal;
    strategy: Strategy<TInput, TOutput>;
}

// Warning: (ae-missing-release-tag) "WithComputeResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `WithComputeResult`

```typescript
export type WithComputeResult<TOutput> = StrategyResult<TOutput>;

// Warning: (ae-missing-release-tag) "WithdrawParams" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `WithdrawParams`

```typescript
export interface WithdrawParams {
    readonly shares: string;
    readonly vault_address: VaultAddress;
}

// Warning: (ae-missing-release-tag) "WithdrawResult" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `WithdrawResult`

```typescript
export interface WithdrawResult {
    readonly amount_withdrawn: string;
    readonly tx_hash: string;
}

// Warning: (ae-forgotten-export) The symbol "CacheEntry" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "withIdempotency" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `withIdempotency`

```typescript
export function withIdempotency<T>(call: () => Promise<T>, key: string, opts?: WithIdempotencyOptions, store?: Map<string, CacheEntry<unknown>>): Promise<T>;

// Warning: (ae-missing-release-tag) "WithIdempotencyOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `WithIdempotencyOptions`

```typescript
export interface WithIdempotencyOptions {
    ttlMs?: number;
}
```

### `withPaymentReceipt`

```typescript
export function withPaymentReceipt(claim: ProofClaim, receipt: SettlementReceipt, signClaim?: SignFn): ProofClaim;

// Warning: (ae-missing-release-tag) "withStructuredOutput" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `withStructuredOutput`

```typescript
export function withStructuredOutput<T>(opts: StructuredOutputOptions<T>): Promise<StructuredOutputResult<T>>;

// Warning: (ae-missing-release-tag) "WorkflowContext" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `WorkflowContext`

```typescript
export interface WorkflowContext {
    readonly abortSignal: AbortSignal;
    awaitEvent<T = unknown>(filter: EventFilter): Promise<T>;
    awaitStarknetBlock(blockHeight: number): Promise<void>;
    cancel(reason: string): Promise<void>;
    childWorkflow<TInput, TOutput>(name: string, input: TInput, opts?: ChildWorkflowOpts): Promise<TOutput>;
    now(): Promise<Date>;
    random(): Promise<number>;
    readonly runId: string;
    sleepFor(durationMs: number): Promise<void>;
    sleepUntil(t: Date): Promise<void>;
    step<T>(name: string, fn: () => Promise<T>, opts?: StepOpts): Promise<T>;
    readonly tenantId: string;
    uuid(): Promise<string>;
    waitForSignal<T = unknown>(name: string, timeoutMs?: number): Promise<T>;
    readonly workflowName: string;
    readonly workflowVersion: string;
}

// Warning: (ae-missing-release-tag) "WorkflowHandler" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `WorkflowHandler`

```typescript
export type WorkflowHandler<TInput = unknown, TOutput = unknown> = (ctx: WorkflowContext, input: TInput) => Promise<TOutput>;

// Warning: (ae-missing-release-tag) "WorkflowLeaseConflictError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `WorkflowLeaseConflictError`

```typescript
export class WorkflowLeaseConflictError extends Error {
    constructor(runId: string, currentOwner: string);
    readonly currentOwner: string;
    readonly runId: string;
}

// Warning: (ae-missing-release-tag) "WorkflowNonDeterminismError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `WorkflowNonDeterminismError`

```typescript
export class WorkflowNonDeterminismError extends Error {
    constructor(runId: string, stepIndex: number, expected: string, actual: string);
    readonly actual: string;
    readonly expected: string;
    readonly runId: string;
    readonly stepIndex: number;
}

// Warning: (ae-missing-release-tag) "WorkflowNotFoundError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `WorkflowNotFoundError`

```typescript
export class WorkflowNotFoundError extends Error {
    constructor(runId: string);
    readonly runId: string;
}

// Warning: (ae-missing-release-tag) "WorkflowRun" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `WorkflowRun`

```typescript
export interface WorkflowRun<TOutput = unknown> {
    readonly error?: string;
    readonly finished_at?: Date;
    readonly input: unknown;
    readonly lease_expires_at?: Date;
    readonly lease_owner?: string;
    readonly manifest_hash?: string;
    readonly output?: TOutput;
    readonly run_id: string;
    readonly started_at: Date;
    readonly status: WorkflowStatus;
    readonly tenant_id: string;
    readonly wake_at?: Date;
    readonly workflow_name: string;
    readonly workflow_version: string;
}

// Warning: (ae-missing-release-tag) "WorkflowRuntimePort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `WorkflowRuntimePort`

```typescript
export interface WorkflowRuntimePort {
    cancel(runId: string, reason: string): Promise<void>;
    executeNext(opts: ResumeWorkflowOpts): Promise<WorkflowRun | null>;
    getJournal(runId: string): Promise<JournalEntry[]>;
    getStatus(runId: string): Promise<WorkflowRun | null>;
    migrateRun(runId: string, fromVersion: string, toVersion: string, migrator: JournalMigrator): Promise<MigrationResult>;
    register<TInput, TOutput>(name: string, version: string, handler: WorkflowHandler<TInput, TOutput>): void;
    sendSignal(runId: string, signalName: string, opts?: SendSignalOpts): Promise<void>;
    start(opts: StartWorkflowOpts): Promise<string>;
    startWorker(opts?: {
        workerId?: string;
        pollIntervalMs?: number;
        maxConcurrent?: number;
    }): Promise<void>;
    stopWorker(): Promise<void>;
    waitForCompletion<TOutput>(runId: string, opts?: {
        timeoutMs?: number;
        pollIntervalMs?: number;
    }): Promise<WorkflowRun<TOutput>>;
}

// Warning: (ae-missing-release-tag) "WorkflowSignalTimeoutError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `WorkflowSignalTimeoutError`

```typescript
export class WorkflowSignalTimeoutError extends Error {
    constructor(runId: string, signalName: string, timeoutMs: number);
    readonly runId: string;
    readonly signalName: string;
    readonly timeoutMs: number;
}

// Warning: (ae-missing-release-tag) "WorkflowStatus" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `WorkflowStatus`

```typescript
export type WorkflowStatus = "PENDING" | "RUNNING" | "SLEEPING" | "WAITING_SIGNAL" | "AWAITING_BLOCK" | "AWAITING_EVENT" | "DONE" | "FAILED" | "CANCELLED";

// Warning: (ae-missing-release-tag) "WorkflowVersionMismatchError" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `WorkflowVersionMismatchError`

```typescript
export class WorkflowVersionMismatchError extends Error {
    constructor(runId: string, expected: string, actual: string);
    readonly actual: string;
    readonly expected: string;
    readonly runId: string;
}

// Warning: (ae-missing-release-tag) "WorkingMemoryEntry" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `WorkingMemoryEntry`

```typescript
export interface WorkingMemoryEntry {
    agentTag?: string;
    content: unknown;
    id: string;
    importance: number;
    lastAccessedAt: number;
    pinned?: boolean;
    size?: number;
}

// Warning: (ae-missing-release-tag) "WorkingMemoryPort" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `WorkingMemoryPort`

```typescript
export interface WorkingMemoryPort {
    delete(runId: string, key: string): Promise<void>;
    get(runId: string, key: string): Promise<unknown>;
    set(runId: string, key: string, value: unknown, opts?: {
        ttlMs?: number;
    }): Promise<void>;
}

// Warning: (ae-missing-release-tag) "WorldStateHashTracker" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `WorldStateHashTracker`

```typescript
export class WorldStateHashTracker {
    observe(toolName: string, args: unknown, outputSummary: string, stepIndex: number): {
        isCollision: boolean;
        hash: string;
        previousStep?: number;
    };
    recent(n?: number): ReadonlyArray<{
        step: number;
        tool: string;
        hash: string;
    }>;
    get size(): number;
}

// Warning: (ae-missing-release-tag) "XPublisher" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `XPublisher`

```typescript
export class XPublisher implements PublisherPort {
    constructor(cfg: XPublisherConfig, opts?: XPublisherOptions);
    readonly channel: "x";
    isConfigured(): Promise<boolean>;
    publish(input: PublishInput): Promise<PublishResult>;
}

// Warning: (ae-missing-release-tag) "XPublisherConfig" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `XPublisherConfig`

```typescript
export interface XPublisherConfig {
    readonly accessToken: string;
    readonly accessTokenSecret: string;
    readonly apiKey: string;
    readonly apiKeySecret: string;
    readonly bearerToken: string;
}

// Warning: (ae-missing-release-tag) "XPublisherOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `XPublisherOptions`

```typescript
export interface XPublisherOptions {
    readonly random?: () => number;
    readonly sleep?: (ms: number) => Promise<void>;
}

// Warning: (ae-missing-release-tag) "zodToJsonSchema" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
```

### `zodToJsonSchema`

```typescript
export function zodToJsonSchema(schema: z.ZodTypeAny): MCPToolDefinition["inputSchema"];

// Warnings were encountered during analysis:
//
// src/events/catalogue.ts:63:30 - (ae-forgotten-export) The symbol "AgentStartedV1" needs to be exported by the entry point index.d.ts
// src/events/catalogue.ts:64:32 - (ae-forgotten-export) The symbol "AgentCompletedV1" needs to be exported by the entry point index.d.ts
// src/events/catalogue.ts:65:29 - (ae-forgotten-export) The symbol "AgentFailedV1" needs to be exported by the entry point index.d.ts
// src/events/catalogue.ts:68:7 - (ae-forgotten-export) The symbol "AgentHitlRequestedV1" needs to be exported by the entry point index.d.ts
// src/events/catalogue.ts:72:7 - (ae-forgotten-export) The symbol "AgentHitlResolvedV1" needs to be exported by the entry point index.d.ts
// src/events/catalogue.ts:74:34 - (ae-forgotten-export) The symbol "IncidentSloBurnV1" needs to be exported by the entry point index.d.ts
// src/events/catalogue.ts:75:34 - (ae-forgotten-export) The symbol "IncidentDetectedV1" needs to be exported by the entry point index.d.ts
// src/events/catalogue.ts:78:7 - (ae-forgotten-export) The symbol "ForgeInboxReplyClassifiedV1" needs to be exported by the entry point index.d.ts
// src/events/catalogue.ts:82:7 - (ae-forgotten-export) The symbol "ForgeLeadQualifiedV1" needs to be exported by the entry point index.d.ts
// src/events/catalogue.ts:86:7 - (ae-forgotten-export) The symbol "ForgeOutreachSentV1" needs to be exported by the entry point index.d.ts
// src/events/catalogue.ts:90:7 - (ae-forgotten-export) The symbol "ForgePolicyTriggeredV1" needs to be exported by the entry point index.d.ts
// src/events/catalogue.ts:94:7 - (ae-forgotten-export) The symbol "VaubanVaultRebalanceProposedV1" needs to be exported by the entry point index.d.ts
// src/events/catalogue.ts:98:7 - (ae-forgotten-export) The symbol "VaubanVaultRebalancedV1" needs to be exported by the entry point index.d.ts
// src/events/catalogue.ts:102:7 - (ae-forgotten-export) The symbol "GlacisIdentityVerifiedV1" needs to be exported by the entry point index.d.ts
// src/events/catalogue.ts:106:7 - (ae-forgotten-export) The symbol "CitadelSprintClosedV1" needs to be exported by the entry point index.d.ts
// src/events/catalogue.ts:110:7 - (ae-forgotten-export) The symbol "CitadelSprintAnalyzedV1" needs to be exported by the entry point index.d.ts
// src/events/catalogue.ts:114:7 - (ae-forgotten-export) The symbol "BrainSkillExtractedV1" needs to be exported by the entry point index.d.ts
// src/events/catalogue.ts:116:33 - (ae-forgotten-export) The symbol "CcCostRecordedV1" needs to be exported by the entry point index.d.ts
// src/events/catalogue.ts:119:7 - (ae-forgotten-export) The symbol "CcCostAnomalyDetectedV1" needs to be exported by the entry point index.d.ts
// src/events/catalogue.ts:121:35 - (ae-forgotten-export) The symbol "TenantProvisionedV1" needs to be exported by the entry point index.d.ts
// src/events/catalogue.ts:124:7 - (ae-forgotten-export) The symbol "TenantBudgetExceededV1" needs to be exported by the entry point index.d.ts
// src/events/catalogue.ts:128:7 - (ae-forgotten-export) The symbol "VaubanVaultAnalyzedV1" needs to be exported by the entry point index.d.ts
// src/events/catalogue.ts:132:7 - (ae-forgotten-export) The symbol "VaubanGoalCheckedV1" needs to be exported by the entry point index.d.ts
// src/events/catalogue.ts:136:7 - (ae-forgotten-export) The symbol "VaubanRebalancingCheckedV1" needs to be exported by the entry point index.d.ts
// src/events/catalogue.ts:140:7 - (ae-forgotten-export) The symbol "VaubanTaxCheckedV1" needs to be exported by the entry point index.d.ts
// src/events/catalogue.ts:144:7 - (ae-forgotten-export) The symbol "VaubanVaultCompoundedV1" needs to be exported by the entry point index.d.ts
// src/events/catalogue.ts:148:7 - (ae-forgotten-export) The symbol "VaubanFinanceForecastGeneratedV1" needs to be exported by the entry point index.d.ts
// src/events/catalogue.ts:152:7 - (ae-forgotten-export) The symbol "VaubanFinanceTradeExecutedV1" needs to be exported by the entry point index.d.ts
```

---

## Breaking-Change Policy

- **Patch (x.y.Z)**: bug fixes, documentation, no API surface change.
- **Minor (x.Y.z)**: new optional exports or optional parameters added.
- **Major (X.y.z)**: removed exports, renamed exports, non-backward-compatible signature changes.

CI gate: `api-extractor run` (check mode) diffs the committed `etc/*.api.md` baseline on every PR.
Any drift without a committed baseline update FAILS the PR. Update via `pnpm api:extract` and commit.
