@fenixforce/kernel 0.1.0

package/dist/channels/teams.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Microsoft Teams Channel Adapter
+ *
+ * Integrates with Azure Bot Service via the Bot Framework webhook
+ * pattern. Handles incoming activities on /api/messages, validates
+ * JWT tokens, and sends responses using Adaptive Cards for rich
+ * formatting and approval gates.
+ */
+import type { MessageHandler } from "./types.js";
+import type { STTProvider, TTSProvider, TaskInfo, JobInfo } from "./telegram.js";
+export interface TeamsConfig {
+    /** Azure AD app registration ID. */
+    appId: string;
+    /** Azure AD client secret. */
+    appPassword: string;
+    /** Restrict to specific Azure AD tenant. */
+    tenantId?: string;
+    /** Webhook endpoint path. Default: "/api/messages". */
+    webhookPath?: string;
+    /** Restrict to specific team IDs. */
+    allowedTeamIds?: string[];
+    onMessage: MessageHandler;
+    onReset?: (conversationId: string) => Promise<string>;
+    onTasks?: (conversationId: string) => Promise<TaskInfo[]>;
+    onJobs?: (conversationId: string) => Promise<JobInfo[]>;
+    stt?: STTProvider;
+    tts?: TTSProvider;
+    /** Override fetch for testing. */
+    fetchFn?: typeof globalThis.fetch;
+}
+/** Bot Framework Activity (subset). */
+export interface TeamsActivity {
+    type: "message" | "conversationUpdate" | "invoke" | "event";
+    id: string;
+    timestamp: string;
+    channelId: string;
+    from: {
+        id: string;
+        name?: string;
+        aadObjectId?: string;
+    };
+    conversation: {
+        id: string;
+        conversationType?: "personal" | "channel" | "groupChat";
+        tenantId?: string;
+        isGroup?: boolean;
+    };
+    recipient?: {
+        id: string;
+        name?: string;
+    };
+    text?: string;
+    attachments?: TeamsActivityAttachment[];
+    entities?: TeamsEntity[];
+    channelData?: Record<string, unknown>;
+    replyToId?: string;
+    serviceUrl: string;
+    value?: Record<string, unknown>;
+}
+export interface TeamsActivityAttachment {
+    contentType: string;
+    contentUrl?: string;
+    content?: unknown;
+    name?: string;
+}
+export interface TeamsEntity {
+    type: string;
+    mentioned?: {
+        id: string;
+        name: string;
+    };
+    text?: string;
+}
+/** Conversation reference for proactive messaging. */
+export interface ConversationReference {
+    activityId: string;
+    conversationId: string;
+    serviceUrl: string;
+    userId: string;
+    tenantId?: string;
+}
+export interface PendingTeamsApproval {
+    id: string;
+    conversationId: string;
+    replyToId: string;
+    resolve: (choice: string) => void;
+}
+export interface TeamsChannelAdapter {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    sendMessage(conversationId: string, text: string): Promise<void>;
+    /** Handle incoming Bot Framework activity. */
+    handleActivity(activity: TeamsActivity): Promise<TeamsActivityResponse | null>;
+    /** Handle Adaptive Card action (invoke activity). */
+    handleCardAction(activity: TeamsActivity): Promise<TeamsActivityResponse | null>;
+    /** Send proactive message to a stored conversation reference. */
+    sendProactive(ref: ConversationReference, text: string): Promise<void>;
+    /** Get stored conversation reference for a user. */
+    getConversationRef(userId: string): ConversationReference | undefined;
+    readonly isRunning: boolean;
+}
+export interface TeamsActivityResponse {
+    status: number;
+    body?: Record<string, unknown>;
+}
+export declare function createTeamsAdapter(config: TeamsConfig): TeamsChannelAdapter;

package/dist/channels/telegram.d.ts

@@ -0,0 +1,164 @@
+/**
+ * Telegram Channel Adapter — long-polling based.
+ *
+ * Converts Telegram Bot API updates into MessageEnvelopes,
+ * handles slash-commands (/reset, /tasks, /jobs), and sends
+ * inline-keyboard approval prompts for tool confirmations.
+ */
+export interface Attachment {
+    type: "image" | "audio" | "video" | "document";
+    url?: string;
+    base64?: string;
+    mimeType: string;
+    fileName?: string;
+}
+export interface MessageEnvelope {
+    channel: "telegram" | "whatsapp" | "discord" | "slack" | "voice" | "web" | "sms";
+    userId: string;
+    userName?: string;
+    conversationId: string;
+    messageType: "text" | "voice" | "image" | "file";
+    content: string;
+    attachments?: Attachment[];
+    metadata: Record<string, unknown>;
+    timestamp: Date;
+}
+export type MessageHandler = (envelope: MessageEnvelope) => Promise<string>;
+export interface TaskInfo {
+    id: string;
+    description: string;
+    status: "pending" | "running" | "done" | "failed";
+}
+export interface JobInfo {
+    id: string;
+    description: string;
+    status: "pending" | "running" | "done" | "failed";
+    startedAt?: Date;
+}
+/** Speech-to-text provider for voice messages. */
+export interface STTProvider {
+    transcribe(audioUrl: string): Promise<{
+        text: string;
+        confidence: number;
+    }>;
+}
+/** Text-to-speech provider for voice responses. */
+export interface TTSProvider {
+    synthesize(text: string): Promise<{
+        audioUrl: string;
+        durationMs: number;
+    }>;
+}
+export type AdapterMode = "polling" | "webhook";
+export interface TelegramAdapterConfig {
+    botToken: string;
+    onMessage: MessageHandler;
+    /** Called when user presses /reset. Return the message to send back. */
+    onReset?: (chatId: string) => Promise<string>;
+    /** Return current tasks for /tasks command. */
+    onTasks?: (chatId: string) => Promise<TaskInfo[]>;
+    /** Return current async jobs for /jobs command. */
+    onJobs?: (chatId: string) => Promise<JobInfo[]>;
+    /** "polling" (development) or "webhook" (production). Default: "polling". */
+    mode?: AdapterMode;
+    /** Webhook URL for production mode (required when mode is "webhook"). */
+    webhookUrl?: string;
+    /** Secret token for webhook verification. */
+    webhookSecret?: string;
+    /** Polling interval in ms (default 1000). */
+    pollingInterval?: number;
+    /** Polling timeout for long-poll in seconds (default 30). */
+    pollingTimeout?: number;
+    /** STT provider for voice message transcription. */
+    stt?: STTProvider;
+    /** TTS provider for voice responses. */
+    tts?: TTSProvider;
+    /** Override fetch for testing. */
+    fetchFn?: typeof globalThis.fetch;
+}
+export interface TelegramUser {
+    id: number;
+    is_bot: boolean;
+    first_name: string;
+    last_name?: string;
+    username?: string;
+}
+export interface TelegramChat {
+    id: number;
+    type: "private" | "group" | "supergroup" | "channel";
+}
+export interface TelegramVoice {
+    file_id: string;
+    file_unique_id: string;
+    duration: number;
+    mime_type?: string;
+    file_size?: number;
+}
+export interface TelegramMessage {
+    message_id: number;
+    from?: TelegramUser;
+    chat: TelegramChat;
+    date: number;
+    text?: string;
+    photo?: TelegramPhotoSize[];
+    document?: TelegramDocument;
+    voice?: TelegramVoice;
+    caption?: string;
+}
+export interface TelegramPhotoSize {
+    file_id: string;
+    file_unique_id: string;
+    width: number;
+    height: number;
+    file_size?: number;
+}
+export interface TelegramDocument {
+    file_id: string;
+    file_unique_id: string;
+    file_name?: string;
+    mime_type?: string;
+    file_size?: number;
+}
+export interface TelegramCallbackQuery {
+    id: string;
+    from: TelegramUser;
+    message?: TelegramMessage;
+    data?: string;
+}
+export interface TelegramUpdate {
+    update_id: number;
+    message?: TelegramMessage;
+    callback_query?: TelegramCallbackQuery;
+}
+export interface InlineKeyboardButton {
+    text: string;
+    callback_data?: string;
+}
+export interface InlineKeyboardMarkup {
+    inline_keyboard: InlineKeyboardButton[][];
+}
+export interface PendingApproval {
+    id: string;
+    chatId: string;
+    toolName: string;
+    args: Record<string, unknown>;
+    resolve: (approved: boolean) => void;
+}
+export type ModeIndicator = "typing" | "planning" | "executing";
+export interface TelegramChannelAdapter {
+    start(): Promise<void>;
+    stop(): void;
+    sendMessage(chatId: string, text: string): Promise<void>;
+    sendApprovalKeyboard(chatId: string, approvalId: string, toolName: string, args: Record<string, unknown>): Promise<boolean>;
+    /** Send a mode indicator (typing, planning, executing) to a chat. */
+    sendModeIndicator(chatId: string, mode: ModeIndicator): Promise<void>;
+    /** Handle an inbound webhook update (production mode). */
+    handleWebhookUpdate(update: TelegramUpdate, secret?: string): Promise<void>;
+    readonly isRunning: boolean;
+    readonly adapterMode: AdapterMode;
+}
+export declare function createTelegramChannelAdapter(config: TelegramAdapterConfig): TelegramChannelAdapter;
+declare function splitMessage(text: string, maxLength: number): string[];
+declare function statusIcon(status: string): string;
+declare function formatElapsed(ms: number): string;
+export { splitMessage, statusIcon, formatElapsed };

package/dist/channels/types.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Channel adapter types for Fenix kernel.
+ */
+export interface Attachment {
+    type: "image" | "audio" | "video" | "document";
+    url?: string;
+    base64?: string;
+    mimeType: string;
+    fileName?: string;
+}
+export interface MessageEnvelope {
+    channel: "telegram" | "whatsapp" | "discord" | "slack" | "voice" | "web" | "sms";
+    userId: string;
+    userName?: string;
+    conversationId: string;
+    messageType: "text" | "voice" | "image" | "file";
+    content: string;
+    attachments?: Attachment[];
+    metadata: Record<string, unknown>;
+    timestamp: Date;
+}
+export type MessageHandler = (envelope: MessageEnvelope) => Promise<string>;
+export type AgentEvent = {
+    type: "text";
+    content: string;
+} | {
+    type: "thinking";
+    content: string;
+} | {
+    type: "tool_call";
+    name: string;
+    args: Record<string, unknown>;
+} | {
+    type: "tool_result";
+    name: string;
+    output: string;
+} | {
+    type: "approval_request";
+    id: string;
+    description: string;
+    options: string[];
+} | {
+    type: "mode_change";
+    mode: string;
+} | {
+    type: "task_update";
+    tasks: TaskStatus[];
+} | {
+    type: "done";
+    content: string;
+} | {
+    type: "error";
+    message: string;
+};
+export interface TaskStatus {
+    id: string;
+    title: string;
+    status: "pending" | "in_progress" | "completed" | "failed";
+}
+export interface ChannelAdapter {
+    /** Start listening for inbound messages. */
+    start(): Promise<void>;
+    /** Gracefully stop the adapter. */
+    stop(): Promise<void>;
+    /** Send a plain text reply to a conversation. */
+    sendText(conversationId: string, text: string): Promise<void>;
+    /** Stream agent events to the user (typing, tool calls, final answer). */
+    sendAgentEvents(conversationId: string, events: AsyncIterable<AgentEvent>): Promise<void>;
+    /** Send an approval gate (inline keyboard) and wait for the user's choice. */
+    sendApprovalGate(conversationId: string, description: string, options: string[]): Promise<string>;
+}

package/dist/channels/whatsapp.d.ts

@@ -0,0 +1,83 @@
+/**
+ * WhatsApp Channel Adapter
+ *
+ * Two integration paths selectable via config:
+ *   - Path A  "baileys"       → self-hosted via @whiskeysockets/baileys (WebSocket)
+ *   - Path B  "business-api"  → official Cloud API via HTTP webhooks
+ *
+ * Converts WhatsApp messages into MessageEnvelopes, supports text, images,
+ * voice notes, documents, reactions, and group chats.
+ */
+import type { MessageHandler } from "./types.js";
+import type { STTProvider, TTSProvider, TaskInfo, JobInfo } from "./telegram.js";
+export interface WhatsAppConfig {
+    /** "baileys" for self-hosted, "business-api" for Cloud API. */
+    mode: "baileys" | "business-api";
+    onMessage: MessageHandler;
+    onReset?: (conversationId: string) => Promise<string>;
+    onTasks?: (conversationId: string) => Promise<TaskInfo[]>;
+    onJobs?: (conversationId: string) => Promise<JobInfo[]>;
+    stt?: STTProvider;
+    tts?: TTSProvider;
+    /** Directory to persist session credentials (default: workspace/channels/whatsapp/auth/) */
+    authDir?: string;
+    /** Phone number ID from Meta Business dashboard. */
+    phoneNumberId?: string;
+    /** Permanent access token for Cloud API. */
+    accessToken?: string;
+    /** Verify token for webhook registration. */
+    verifyToken?: string;
+    /** Path for incoming webhooks (default: /webhook/whatsapp). */
+    webhookPath?: string;
+    /** JIDs allowed in group chats (empty = all). */
+    groupAllowList?: string[];
+    /** Override fetch for testing. */
+    fetchFn?: typeof globalThis.fetch;
+}
+/** Lightweight internal representation of inbound WhatsApp messages. */
+export interface WAInboundMessage {
+    id: string;
+    from: string;
+    pushName?: string;
+    timestamp: number;
+    type: "text" | "image" | "audio" | "document" | "reaction" | "sticker";
+    body?: string;
+    caption?: string;
+    mimetype?: string;
+    mediaUrl?: string;
+    mediaBase64?: string;
+    fileName?: string;
+    /** For group messages. */
+    groupId?: string;
+    groupSubject?: string;
+    /** Reaction target message id. */
+    reactionTarget?: string;
+}
+/** Events emitted by the adapter. */
+export type WhatsAppAdapterEvent = {
+    type: "qr";
+    qr: string;
+} | {
+    type: "authenticated";
+} | {
+    type: "disconnected";
+    reason: string;
+} | {
+    type: "error";
+    error: string;
+};
+export type WhatsAppEventHandler = (event: WhatsAppAdapterEvent) => void;
+export interface WhatsAppChannelAdapter {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    sendMessage(conversationId: string, text: string): Promise<void>;
+    /** Process inbound webhook payload (Business API mode). */
+    handleWebhook(payload: unknown, signatureHeader?: string): Promise<void>;
+    /** Verify webhook challenge (Business API mode). */
+    verifyWebhook(query: Record<string, string>): string | null;
+    /** Register event handler. */
+    onEvent(handler: WhatsAppEventHandler): void;
+    readonly isRunning: boolean;
+    readonly mode: "baileys" | "business-api";
+}
+export declare function createWhatsAppAdapter(config: WhatsAppConfig): WhatsAppChannelAdapter;

package/dist/checkpoint.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Checkpoint Durable Execution — save and restore execution state
+ * for crash recovery, time travel, and fork-from-any-point.
+ *
+ * Checkpoints are created after each tool execution. On crash,
+ * execution resumes from the most recent checkpoint. Pruning keeps
+ * the last N checkpoints (default 50) to bound memory.
+ */
+export interface CheckpointMessage {
+    role: string;
+    content: string;
+    timestamp?: string;
+}
+export interface Checkpoint {
+    /** Unique checkpoint ID. */
+    id: string;
+    /** Session this checkpoint belongs to. */
+    sessionId: string;
+    /** Step number (monotonically increasing within a session). */
+    step: number;
+    /** Conversation messages at this point. */
+    messages: CheckpointMessage[];
+    /** Serialized memory/context snapshot. */
+    memorySnapshot: Record<string, unknown>;
+    /** Tool state at checkpoint time. */
+    toolState: Record<string, unknown>;
+    /** Task tracker state (planned tasks, steps). */
+    taskTrackerState: Record<string, unknown>;
+    /** When this checkpoint was created. */
+    timestamp: Date;
+    /** Parent checkpoint ID (null for initial). */
+    parentId: string | null;
+}
+export type CheckpointEventType = "checkpoint_created" | "checkpoint_restored" | "checkpoint_pruned" | "checkpoint_forked" | "checkpoint_deleted";
+export interface CheckpointEvent {
+    type: CheckpointEventType;
+    timestamp: Date;
+    checkpointId: string;
+    sessionId: string;
+    detail: string;
+}
+export type CheckpointEventListener = (event: CheckpointEvent) => void;
+export interface CheckpointManagerConfig {
+    /** Maximum checkpoints to keep per session. Default 50. */
+    maxPerSession?: number;
+    /** Override Date.now() for testing. */
+    nowFn?: () => number;
+}
+export declare function _resetCheckpointIds(): void;
+export interface CheckpointManager {
+    /** Save a checkpoint after a tool execution step. Returns the checkpoint. */
+    save(opts: {
+        sessionId: string;
+        messages: CheckpointMessage[];
+        memorySnapshot?: Record<string, unknown>;
+        toolState?: Record<string, unknown>;
+        taskTrackerState?: Record<string, unknown>;
+    }): Checkpoint;
+    /** Restore execution state from a specific checkpoint. */
+    restore(checkpointId: string): Checkpoint | undefined;
+    /** Get the latest checkpoint for a session. */
+    latest(sessionId: string): Checkpoint | undefined;
+    /** List all checkpoints for a session, ordered by step. */
+    list(sessionId: string): Checkpoint[];
+    /** Fork a new session from any checkpoint. Returns the forked checkpoint. */
+    fork(checkpointId: string, newSessionId: string): Checkpoint | undefined;
+    /** Delete a specific checkpoint. */
+    delete(checkpointId: string): boolean;
+    /** Delete all checkpoints for a session. */
+    deleteSession(sessionId: string): number;
+    /** Get a checkpoint by ID. */
+    get(checkpointId: string): Checkpoint | undefined;
+    /** Events. */
+    on(listener: CheckpointEventListener): void;
+    off(listener: CheckpointEventListener): void;
+}
+export declare function createCheckpointManager(config?: CheckpointManagerConfig): CheckpointManager;

package/dist/config/canary.d.ts

@@ -0,0 +1,74 @@
+import type { SteeringRule } from "./steering-rules.js";
+export type PolicyStatus = "canary" | "stable" | "rolled-back";
+export interface PolicyMetrics {
+    errorRate: number;
+    loopWarningRate: number;
+    approvalEscalationRate: number;
+    costPerSession: number;
+}
+export interface PolicyVersion {
+    id: string;
+    rules: SteeringRule[];
+    createdAt: Date;
+    status: PolicyStatus;
+    trafficPercent: number;
+    metrics: PolicyMetrics;
+}
+export interface CanaryConfig {
+    /** Rollout stages as traffic percentages */
+    stages: number[];
+    /** Time each stage must hold before advancing (ms) */
+    stageDurationMs: number;
+    /** Metric thresholds — rollback if any exceeded */
+    thresholds: Partial<PolicyMetrics>;
+    /** Auto-promote to next stage when duration passes */
+    autoPromote: boolean;
+}
+export declare const DEFAULT_CANARY_CONFIG: CanaryConfig;
+export type CanaryEventEmitter = (event: string, payload: Record<string, unknown>) => void;
+export declare class CanaryManager {
+    private versions;
+    private stableVersion;
+    private config;
+    private emit;
+    private stageEnteredAt;
+    constructor(config?: Partial<CanaryConfig>, emit?: CanaryEventEmitter);
+    /**
+     * Register a new policy version and start canary at stage 0.
+     */
+    createCanary(id: string, rules: SteeringRule[]): PolicyVersion;
+    /**
+     * Assign a policy version to a new session via weighted random.
+     * Returns the canary version if selected, otherwise stable.
+     */
+    assignVersion(sessionId: string): PolicyVersion | null;
+    /**
+     * Update live metrics for a policy version.
+     */
+    updateMetrics(policyId: string, metrics: Partial<PolicyMetrics>): void;
+    /**
+     * Check metrics and auto-rollback if thresholds breached.
+     * Call this on a 5-minute interval.
+     */
+    monitorAndRollback(): {
+        rolledBack: boolean;
+        policyId?: string;
+        breachingMetric?: string;
+    };
+    /**
+     * Manually promote a canary to the next traffic stage.
+     */
+    promote(policyId: string): {
+        promoted: boolean;
+        newTraffic: number;
+    };
+    /**
+     * Set a version as the stable baseline.
+     */
+    setStable(version: PolicyVersion): void;
+    /** Get currently active canary, if any. */
+    getActiveCanary(): PolicyVersion | null;
+    /** Get a version by ID. */
+    getVersion(id: string): PolicyVersion | null;
+    private checkThresholds;
+}

package/dist/config/constitution.d.ts

@@ -0,0 +1,57 @@
+import type { SteeringRule } from "./steering-rules.js";
+export type ConstitutionChangeType = "major" | "minor" | "patch";
+export interface ConstitutionVersion {
+    semver: string;
+    rules: SteeringRule[];
+    /** HMAC-SHA256 of rule content + semver */
+    signature: string;
+    changeType: ConstitutionChangeType;
+    changeDescription: string;
+    authorId: string;
+    activatedAt?: Date;
+}
+export interface LintResult {
+    passed: boolean;
+    errors: LintDiagnostic[];
+    warnings: LintDiagnostic[];
+    requiresApproval: boolean;
+}
+export interface LintDiagnostic {
+    rule: string;
+    message: string;
+    severity: "error" | "warning";
+}
+export type ConstitutionEventEmitter = (event: string, payload: Record<string, unknown>) => void;
+export declare class ConstitutionManager {
+    private versions;
+    private signingKey;
+    private emit;
+    constructor(signingKey: string, emit?: ConstitutionEventEmitter);
+    /**
+     * Create a new constitution version. Does NOT activate it.
+     */
+    createVersion(rules: SteeringRule[], changeType: ConstitutionChangeType, changeDescription: string, authorId: string): ConstitutionVersion;
+    /**
+     * Lint a new version against the current active version.
+     * Must pass before activation.
+     */
+    lint(newVersion: ConstitutionVersion): LintResult;
+    /**
+     * Activate a version (only if lint passes).
+     */
+    activate(semver: string): boolean;
+    /**
+     * Rollback to a previous version.
+     * Creates a new PATCH version with rollback description.
+     */
+    rollback(targetSemver: string, authorId: string): ConstitutionVersion | null;
+    /** Get the currently active version. */
+    getActiveVersion(): ConstitutionVersion | null;
+    /** Get all versions. */
+    listVersions(): ConstitutionVersion[];
+    /** Get a specific version by semver. */
+    getVersion(semver: string): ConstitutionVersion | null;
+    private sign;
+    verifySignature(version: ConstitutionVersion): boolean;
+    private computeNextSemver;
+}

package/dist/config/defaults.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Sensible defaults for every optional field in WorkspaceProfile.
+ */
+import type { VoiceConfig, MemoryConfig, SecurityConfig, AgentLoopConfig, BudgetsConfig } from "./schema.js";
+export declare const DEFAULT_VOICE: VoiceConfig;
+export declare const DEFAULT_MEMORY: MemoryConfig;
+export declare const DEFAULT_SECURITY: SecurityConfig;
+export declare const DEFAULT_AGENT_LOOP: AgentLoopConfig;
+export declare const DEFAULT_BUDGETS: BudgetsConfig;
+export declare const DEFAULTS: {
+    readonly version: "1.0.0";
+    readonly voice: VoiceConfig;
+    readonly memory: MemoryConfig;
+    readonly security: SecurityConfig;
+    readonly agentLoop: AgentLoopConfig;
+    readonly budgets: BudgetsConfig;
+};

package/dist/config/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./schema.js";
+export * from "./defaults.js";
+export { loadProfile, loadProfileFromObject, interpolateEnv, ConfigError } from "./loader.js";
+export { loadSteeringRules, resolveRules, type SteeringRule, type SteeringRuleSet, type RuleKind, type ConversationContext } from "./steering-rules.js";
+export { CanaryManager, DEFAULT_CANARY_CONFIG } from "./canary.js";
+export type { PolicyStatus, PolicyMetrics, PolicyVersion, CanaryConfig, CanaryEventEmitter, } from "./canary.js";
+export { ConstitutionManager } from "./constitution.js";
+export type { ConstitutionChangeType, ConstitutionVersion, LintResult, LintDiagnostic, ConstitutionEventEmitter, } from "./constitution.js";

package/dist/config/loader.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Config loader — reads workspace.json, interpolates env vars,
+ * merges with defaults, and validates required fields.
+ */
+import type { WorkspaceProfile } from "./schema.js";
+export declare function interpolateEnv(value: string, env?: Record<string, string | undefined>): string;
+export declare class ConfigError extends Error {
+    constructor(message: string);
+}
+export declare function loadProfileFromObject(raw: Record<string, unknown>, env?: Record<string, string | undefined>): WorkspaceProfile;
+export declare function loadProfile(filePath: string, env?: Record<string, string | undefined>): Promise<WorkspaceProfile>;