@xeno-corporation/xeno-agent-sdk 0.5.0

package/dist/index.d.ts

@@ -0,0 +1,4838 @@
+import { Readable, Writable } from "node:stream";
+import { ChildProcess } from "node:child_process";
+interface ToolDefinition {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+}
+interface ImageUrlBlock {
+    type: "image_url";
+    image_url: {
+        url: string;
+        detail?: "auto" | "low" | "high";
+    };
+}
+interface ResourceContentBlock {
+    type: "resource";
+    uri?: string;
+    mimeType?: string;
+    text?: string;
+    data?: string;
+}
+type ToolAssistantContentBlock = TextBlock | ImageUrlBlock | ResourceContentBlock;
+type ToolResultContent = string | ToolAssistantContentBlock[];
+interface ToolResult {
+    success: boolean;
+    output: string;
+    error?: string;
+    assistantContent?: ToolAssistantContentBlock[];
+    assistantOnlyContent?: ToolAssistantContentBlock[];
+}
+type ToolExecutor = (input: Record<string, unknown>) => Promise<ToolResult>;
+interface RegisteredTool {
+    definition: ToolDefinition;
+    execute: ToolExecutor;
+}
+interface TextBlock {
+    type: "text";
+    text: string;
+}
+interface ToolUseBlock {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}
+interface ToolResultBlock {
+    type: "tool_result";
+    tool_use_id: string;
+    content: string;
+    assistant_content?: ToolAssistantContentBlock[];
+    assistant_only_content?: ToolAssistantContentBlock[];
+    is_error?: boolean;
+}
+type ContentBlock = TextBlock | ToolUseBlock;
+interface Message {
+    role: "user" | "assistant";
+    content: string | ContentBlock[] | ToolResultBlock[];
+}
+type PermissionDecision = "allow" | "ask" | "deny";
+type ExecutionMode = "agent" | "chatOnly";
+interface PermissionRule {
+    tool: string;
+    pattern?: string;
+    decision: PermissionDecision;
+}
+interface PermissionConfig {
+    mode: "default" | "acceptEdits" | "bypassPermissions" | "plan";
+    rules: PermissionRule[];
+}
+interface XenoConfig {
+    apiKey?: string;
+    model: string;
+    maxTokens: number;
+    maxIterations: number;
+    permissions: PermissionConfig;
+}
+interface Session {
+    id: string;
+    messages: Message[];
+    startedAt: Date;
+    workingDirectory: string;
+    model: string;
+    totalTokensUsed: number;
+}
+type PromptFn = (question: string) => Promise<string>;
+type PermissionPromptOperation = "generic" | "filesystem" | "write" | "edit" | "bash";
+interface PermissionPromptPreviewLine {
+    kind: "meta" | "context" | "add" | "remove";
+    text: string;
+}
+interface PermissionPromptPreview {
+    title: string;
+    summary?: string;
+    lines: PermissionPromptPreviewLine[];
+    truncated?: boolean;
+}
+interface PermissionPromptInfo {
+    toolName: string;
+    detail: string;
+    description?: string;
+    operation?: PermissionPromptOperation;
+    preview?: PermissionPromptPreview;
+    commandPrefix?: string;
+    approvalKey?: string;
+    requesterLabel?: string;
+    requesterSummary?: string;
+    directory?: string;
+    filePath?: string;
+}
+type PermissionPromptFn = (info: PermissionPromptInfo) => Promise<"allow" | "always" | "deny">;
+type StopReason = "end_turn" | "tool_use" | "max_tokens" | "stop_sequence";
+interface AgentLoopOptions {
+    model: string;
+    maxTokens: number;
+    maxIterations: number;
+    systemPrompt: string;
+    tools: ToolDefinition[];
+    onText?: (text: string) => void;
+    onToolUse?: (name: string, input: Record<string, unknown>) => void;
+    onToolResult?: (name: string, result: ToolResult) => void;
+    onIteration?: (iteration: number) => void;
+}
+interface IdentityFrontmatter {
+    name?: string;
+    description?: string;
+    role?: string;
+    model?: string;
+    maxTokens?: number;
+    temperature?: number;
+    style?: "concise" | "detailed" | "technical";
+    traits?: string[];
+    expertise?: string[];
+    constraints?: string[];
+}
+type IdentitySource = "global" | "project" | "role" | "session";
+interface IdentityLayer {
+    source: IdentitySource;
+    path: string;
+    frontmatter: IdentityFrontmatter;
+    content: string;
+    tokenCount: number;
+}
+interface DescendantInstructionHint {
+    path: string;
+    relativePath: string;
+    directory: string;
+    fileName: string;
+}
+interface ResolvedIdentity {
+    layers: IdentityLayer[];
+    merged: IdentityFrontmatter;
+    systemPromptAddition: string;
+    totalTokens: number;
+    descendantInstructionHints?: DescendantInstructionHint[];
+}
+type MemoryLevel = "global" | "project" | "role" | "session";
+interface MemoryEntry {
+    id: string;
+    level: MemoryLevel;
+    content: string;
+    tags?: string[];
+    createdAt: Date;
+    updatedAt: Date;
+    tokenCount: number;
+    source: "user" | "auto";
+}
+interface MemoryBudget {
+    global: number;
+    project: number;
+    role: number;
+    session: number;
+    total: number;
+}
+type SessionStatus = "creating" | "active" | "paused" | "completed" | "abandoned" | "archived";
+declare const SESSION_FORMAT_VERSION = 1;
+interface SessionMeta {
+    id: string;
+    role: string;
+    name?: string;
+    status: SessionStatus;
+    createdAt: string;
+    updatedAt: string;
+    lastActivity: string;
+    workingDirectory: string;
+    model: string;
+    parentSession?: string;
+    checkpoints: string[];
+    messageCount: number;
+    tokenUsage: {
+        input: number;
+        output: number;
+        total: number;
+    };
+    formatVersion?: number;
+}
+type TranscriptEventType = "session_start" | "user_message" | "assistant_message" | "tool_call" | "tool_result" | "delegation_summary" | "checkpoint" | "context_compressed" | "session_end" | "error";
+interface SessionStartData {
+    sessionId: string;
+    role: string;
+    model: string;
+    workingDirectory: string;
+    formatVersion?: number;
+}
+interface ToolCallData {
+    toolName: string;
+    input: Record<string, unknown>;
+}
+interface ToolResultData {
+    toolName: string;
+    success: boolean;
+    output: string;
+    error?: string;
+    assistantContent?: ToolAssistantContentBlock[];
+    assistantOnlyContent?: ToolAssistantContentBlock[];
+}
+interface CheckpointData {
+    id?: string;
+    checkpointId?: string;
+    action?: "create" | "restore" | "delete";
+    name?: string;
+    trigger?: CheckpointTrigger;
+    messageCount: number;
+}
+interface DelegationSummaryData {
+    selectedRole?: string;
+    selectedTaskId?: string;
+    elapsedMs: number;
+    totalTokens: number;
+    okBranches: number;
+    errorBranches: number;
+    totalBranches: number;
+    roleSummaries: Record<string, {
+        status: "ok" | "error" | "timeout";
+        tokensUsed: number;
+        outputPreview?: string;
+        error?: string;
+    }>;
+}
+interface ContextCompressedData {
+    messagesRemoved: number;
+    tokensSaved: number;
+}
+interface SessionEndData {
+    reason: "user_exit" | "error" | "completed";
+    messageCount: number;
+    totalTokens: number;
+}
+interface ErrorData {
+    message: string;
+    code?: string;
+    stack?: string;
+}
+type TranscriptEventData = {
+    type: "session_start";
+    data: SessionStartData;
+} | {
+    type: "user_message";
+    data: Message;
+} | {
+    type: "assistant_message";
+    data: Message;
+} | {
+    type: "tool_call";
+    data: ToolCallData;
+} | {
+    type: "tool_result";
+    data: ToolResultData;
+} | {
+    type: "delegation_summary";
+    data: DelegationSummaryData;
+} | {
+    type: "checkpoint";
+    data: CheckpointData;
+} | {
+    type: "context_compressed";
+    data: ContextCompressedData;
+} | {
+    type: "session_end";
+    data: SessionEndData;
+} | {
+    type: "error";
+    data: ErrorData;
+};
+interface TranscriptEvent {
+    id: string;
+    type: TranscriptEventType;
+    timestamp: string;
+    sequence: number;
+    data: TranscriptEventData["data"];
+    tokenCount?: number;
+}
+type CheckpointTrigger = "auto" | "manual" | "pre_dangerous" | "milestone";
+interface CheckpointInfo {
+    id: string;
+    name?: string;
+    trigger: CheckpointTrigger;
+    createdAt: string;
+    messageCount: number;
+    tokenCount: number;
+}
+type AutoMemoryTrigger = "error_correction" | "pattern_learned" | "preference_stated" | "task_completed";
+interface PermissionRequestContext {
+    toolName: string;
+    path: string;
+    directory: string;
+    reason: string;
+}
+interface PermissionRequestResult {
+    granted: boolean;
+    allowedDirectory?: string;
+}
+interface AgentCapabilities {
+    terminal: boolean;
+    fileRead: boolean;
+    fileWrite: boolean;
+    appLaunch: boolean;
+}
+interface PlatformInfo {
+    os: "windows" | "macos" | "linux";
+    shell: "powershell" | "bash" | "zsh";
+    platform: string;
+    homeDir?: string;
+}
+interface AgentSandbox {
+    allowedDirectories: string[];
+    workingDirectory?: string;
+    capabilities: AgentCapabilities;
+    temporaryDirectories?: string[];
+    workspace?: {
+        id: string;
+        name: string;
+    };
+    team?: {
+        id: string;
+        name: string;
+    };
+}
+type AuditRiskLevel = "none" | "low" | "medium" | "high" | "critical";
+type AuditDecision = "allow" | "ask" | "deny";
+type AuditStatus = "ok" | "error";
+interface AuditEvent {
+    id: string;
+    sequence: number;
+    timestamp: string;
+    trace_id: string;
+    session_id?: string;
+    event_type: string;
+    actor: "user" | "assistant" | "system";
+    risk_level: AuditRiskLevel;
+    tool_name?: string;
+    decision?: AuditDecision;
+    status?: AuditStatus;
+    reason?: string;
+    metadata?: Record<string, unknown>;
+}
+interface AuditLoggerOptions {
+    filePath: string;
+    sessionId?: string;
+}
+declare class AuditLogger {
+    private filePath;
+    private sessionId?;
+    private sequence;
+    private writeQueue;
+    constructor(options: AuditLoggerOptions);
+    get path(): string;
+    append(event: Omit<AuditEvent, "id" | "sequence" | "timestamp" | "session_id"> & {
+        session_id?: string;
+    }): Promise<string>;
+    read(options?: {
+        limit?: number;
+        eventType?: string;
+        traceId?: string;
+    }): Promise<AuditEvent[]>;
+    tail(limit?: number): Promise<AuditEvent[]>;
+    exportJson(targetPath: string): Promise<number>;
+    flush(): Promise<void>;
+}
+interface AuditTraceSummary {
+    traceId: string;
+    eventCount: number;
+    startedAt: string;
+    endedAt: string;
+    durationMs: number;
+    toolEvents: number;
+    permissionEvents: number;
+    errorEvents: number;
+    lastEventType: string;
+}
+interface AuditTraceToolSummary {
+    toolName: string;
+    count: number;
+    ok: number;
+    error: number;
+    denied: number;
+}
+interface AuditTraceTimelineEntry {
+    sequence: number;
+    timestamp: string;
+    eventType: string;
+    actor: AuditEvent["actor"];
+    riskLevel: AuditEvent["risk_level"];
+    toolName?: string;
+    decision?: AuditEvent["decision"];
+    status?: AuditEvent["status"];
+    reason?: AuditEvent["reason"];
+}
+interface AuditTraceGapEntry {
+    fromSequence: number;
+    toSequence: number;
+    fromEventType: string;
+    toEventType: string;
+    gapMs: number;
+}
+interface AuditTraceReport {
+    traceId: string;
+    eventCount: number;
+    startedAt: string;
+    endedAt: string;
+    durationMs: number;
+    toolEvents: number;
+    permissionEvents: number;
+    deniedPermissions: number;
+    errorEvents: number;
+    eventTypes: Record<string, number>;
+    actorSummary: Record<string, number>;
+    riskSummary: Record<string, number>;
+    toolSummary: AuditTraceToolSummary[];
+    topLatencyGaps: AuditTraceGapEntry[];
+    timeline: AuditTraceTimelineEntry[];
+}
+interface AuditReplayStep {
+    sequence: number;
+    timestamp: string;
+    title: string;
+    detail?: string;
+    actor: AuditEvent["actor"];
+    riskLevel: AuditEvent["risk_level"];
+    status?: AuditEvent["status"];
+}
+interface AuditReplayReport {
+    traceId: string;
+    startedAt: string;
+    endedAt: string;
+    durationMs: number;
+    steps: AuditReplayStep[];
+}
+declare function summarizeAuditTraces(events: AuditEvent[]): AuditTraceSummary[];
+declare function buildAuditTraceReport(events: AuditEvent[], traceId?: string): AuditTraceReport | null;
+declare function buildAuditReplayReport(events: AuditEvent[], traceId?: string): AuditReplayReport | null;
+declare function renderAuditTraceSummaries(summaries: AuditTraceSummary[]): string;
+declare function renderAuditTraceReport(report: AuditTraceReport): string;
+declare function renderAuditTraceMarkdown(report: AuditTraceReport): string;
+declare function renderAuditReplayMarkdown(report: AuditReplayReport): string;
+declare function renderAuditReplayReport(report: AuditReplayReport): string;
+declare const CONFIG_VERSION = 2;
+declare const PROJECT_STATE_VERSION = 3;
+type ProjectMcpApprovalDecision = "approved" | "denied";
+interface ProjectTokenUsageSummary {
+    input: number;
+    output: number;
+    total: number;
+}
+interface ProjectSessionSummary {
+    sessionId?: string;
+    mode?: "chat" | "run" | "save";
+    status?: string;
+    role?: string;
+    model: string;
+    startedAt: string;
+    endedAt: string;
+    durationMs: number;
+    messageCount?: number;
+    tokenUsage: ProjectTokenUsageSummary;
+    estimatedCostUsd: number;
+}
+interface XenoUserConfig {
+    configVersion?: number;
+    apiKey?: string;
+    model?: string;
+    baseURL?: string;
+    maxTokens?: number;
+    maxIterations?: number;
+    permissionMode?: "default" | "acceptEdits" | "bypassPermissions";
+    executionMode?: "agent" | "chatOnly";
+    uiColor?: "blue" | "green" | "red" | "purple";
+    memoryContextSessions?: number;
+    memoryContextTokens?: number;
+    memoryContextChars?: number;
+    searchApiKey?: string;
+    searchProvider?: "brave" | "google" | "searxng" | "duckduckgo";
+    searxngUrl?: string;
+    googleCx?: string;
+    mcpEnabled?: boolean;
+    lastReleaseNotesSeen?: string;
+    terminalShiftEnterInstalled?: boolean;
+}
+interface XenoProjectState {
+    configVersion?: number;
+    trustedWorkspace?: boolean;
+    allowedTools?: string[];
+    allowedDirectories?: string[];
+    mcpApprovals?: Record<string, ProjectMcpApprovalDecision>;
+    lastSessionSummary?: ProjectSessionSummary;
+    hasCompletedProjectOnboarding?: boolean;
+}
+declare function getConfigDir(): string;
+declare function getProjectStatePath(cwd?: string): string;
+declare function ensureProjectStateDir(cwd?: string): void;
+declare function loadProjectState(cwd?: string): XenoProjectState;
+declare function saveProjectState(cwd: string, updates: Partial<XenoProjectState>): void;
+declare function updateProjectState(cwd: string, updater: (current: XenoProjectState) => XenoProjectState): XenoProjectState;
+declare function isWorkspaceTrusted(cwd?: string): boolean;
+declare function setWorkspaceTrusted(cwd?: string, trusted?: boolean): void;
+declare function hasProjectOnboardingCompleted(cwd?: string): boolean;
+declare function setProjectOnboardingCompleted(cwd?: string, completed?: boolean): void;
+declare function addProjectAllowedTool(cwd: string, approvalKey: string): XenoProjectState;
+declare function listProjectAllowedTools(cwd: string): string[];
+declare function removeProjectAllowedTool(cwd: string, approvalKey: string): XenoProjectState;
+declare function clearProjectAllowedTools(cwd: string): XenoProjectState;
+declare function addProjectAllowedDirectory(cwd: string, directory: string): XenoProjectState;
+declare function getProjectMcpApproval(cwd: string, approvalKey: string): ProjectMcpApprovalDecision | undefined;
+declare function setProjectMcpApproval(cwd: string, approvalKey: string, decision: ProjectMcpApprovalDecision): XenoProjectState;
+declare function clearProjectMcpApproval(cwd: string, approvalKey: string): XenoProjectState;
+declare function listProjectMcpApprovals(cwd: string, scope?: string): Record<string, ProjectMcpApprovalDecision>;
+declare function clearProjectMcpApprovals(cwd: string, scope?: string): XenoProjectState;
+declare function getProjectLastSessionSummary(cwd?: string): ProjectSessionSummary | undefined;
+declare function setProjectLastSessionSummary(cwd: string, summary: ProjectSessionSummary): XenoProjectState;
+declare function clearProjectLastSessionSummary(cwd: string): XenoProjectState;
+declare function ensureConfigDir(): void;
+declare function loadConfig(): XenoUserConfig;
+declare function saveConfig(updates: Partial<XenoUserConfig>): void;
+type XenoCredentialType = "api-key" | "jwt" | "empty";
+type XenoCredentialSource = "explicit" | "env" | "default" | "none";
+type XenoAuthErrorCode = "token_expired" | "token_not_active" | "token_malformed";
+interface XenoJwtPayload {
+    exp?: number;
+    iat?: number;
+    nbf?: number;
+    sub?: string;
+    userId?: string;
+    email?: string;
+    username?: string;
+    [key: string]: unknown;
+}
+interface XenoResolvedApiKey {
+    apiKey: string;
+    source: XenoCredentialSource;
+    credentialType: XenoCredentialType;
+    expiresAt?: string;
+    expiresInMs?: number;
+}
+interface ResolveXenoSdkApiKeyOptions {
+    explicitApiKey?: string;
+    env?: Record<string, string | undefined>;
+    envVar?: string;
+    defaultApiKey?: string;
+    nowMs?: number;
+    skewMs?: number;
+    allowExpired?: boolean;
+}
+interface ValidateXenoSdkApiKeyOptions {
+    apiKey: string;
+    apiBaseURL: string;
+    fetchImpl?: typeof fetch;
+}
+declare class XenoAuthError extends Error {
+    readonly code: XenoAuthErrorCode;
+    readonly expiresAt?: string;
+    constructor(message: string, code: XenoAuthErrorCode, context?: {
+        expiresAt?: string;
+    });
+}
+declare function isJwt(value: string | undefined): value is string;
+declare function decodeJwtPayload(token: string | undefined): XenoJwtPayload | undefined;
+declare function getJwtExpiry(token: string | undefined): Date | undefined;
+declare function isExpiredJwt(token: string | undefined, nowMs?: number, skewMs?: number): boolean;
+declare function isNotBeforeJwt(token: string | undefined, nowMs?: number, skewMs?: number): boolean;
+declare function assertUsableXenoApiKey(apiKey: string | undefined, options?: {
+    nowMs?: number;
+    skewMs?: number;
+    allowExpired?: boolean;
+}): string;
+declare function resolveXenoSdkApiKey(options?: ResolveXenoSdkApiKeyOptions): XenoResolvedApiKey;
+declare function validateXenoSdkApiKey(options: ValidateXenoSdkApiKeyOptions): Promise<{
+    valid: boolean;
+    error?: string;
+}>;
+declare const DEFAULT_API_KEY: string;
+declare const XENO_API_BASE: string;
+declare const XENO_RT_DEFAULT_URL: string;
+declare const DEFAULT_MODEL: string;
+declare const FALLBACK_MODELS: readonly string[];
+interface ModelInfo {
+    id: string;
+    name: string;
+    owned_by: string;
+    source: "xeno" | "local";
+}
+interface LocalRuntimePreflightResult {
+    ok: boolean;
+    model: string;
+    baseUrl: string;
+    endpoint?: "openai" | "native";
+    warning?: string;
+    error?: string;
+}
+declare function getAvailableModels(options?: {
+    apiKey?: string;
+    localRuntimeUrl?: string;
+    forceRefresh?: boolean;
+}): Promise<ModelInfo[]>;
+declare function isLocalModel(model: string): boolean;
+declare function getModelName(model: string): string;
+declare function preflightLocalModel(model: string, options?: {
+    localRuntimeUrl?: string;
+    timeoutMs?: number;
+}): Promise<LocalRuntimePreflightResult>;
+declare function isValidModel(model: string, apiKey?: string): Promise<boolean>;
+declare function isChatModel(model: ModelInfo): boolean;
+declare function getChatModels(apiKey?: string): Promise<ModelInfo[]>;
+declare function formatModelList(apiKey?: string, showAll?: boolean): Promise<string>;
+interface ProfileMCPServerConfig {
+    name: string;
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+}
+interface ConfigProfile {
+    name: string;
+    apiKey?: string;
+    baseURL?: string;
+    model?: string;
+    maxTokens?: number;
+    permissionMode?: "default" | "acceptEdits" | "bypassPermissions";
+    plugins?: string[];
+    mcpServers?: ProfileMCPServerConfig[];
+}
+declare class ProfileManager {
+    private data;
+    private filePath;
+    constructor();
+    listProfiles(): ConfigProfile[];
+    getActiveProfile(): ConfigProfile;
+    getActiveProfileName(): string;
+    switchProfile(name: string): void;
+    createProfile(profile: ConfigProfile): void;
+    deleteProfile(name: string): void;
+    updateProfile(name: string, updates: Partial<ConfigProfile>): void;
+    getProfile(name: string): ConfigProfile | undefined;
+    reload(): void;
+    private load;
+    private save;
+}
+interface ProjectConfig {
+    model?: string;
+    systemPrompt?: string;
+    permissions?: {
+        allowedCommands?: string[];
+        deniedCommands?: string[];
+    };
+    ignorePatterns?: string[];
+}
+declare function loadProjectConfig(cwd?: string): ProjectConfig | null;
+declare function mergeConfigs(base: ProjectConfig, override: ProjectConfig): ProjectConfig;
+interface SessionData {
+    id: string;
+    model: string;
+    workingDirectory: string;
+    createdAt: string;
+    updatedAt: string;
+    messages: Message[];
+    totalTokensUsed: number;
+}
+interface SessionSummary {
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    model: string;
+    workingDirectory: string;
+    preview: string;
+    messageCount: number;
+}
+declare function saveSession(id: string | null, messages: Message[], model: string, totalTokensUsed: number): string;
+declare function loadSession(id: string): SessionData | null;
+declare function listSessions(limit?: number): SessionSummary[];
+declare function deleteSession(id: string): boolean;
+interface ModelProvider {
+    id: string;
+    name: string;
+    baseURL: string;
+    apiKeyEnvVar: string;
+    defaultApiKey?: string;
+    modelPrefixes: string[];
+    models: string[];
+    supportsStreaming: boolean;
+    supportsToolUse: boolean;
+    maxContextTokens?: number;
+    headers?: Record<string, string>;
+    requestFormat?: "openai" | "google";
+}
+interface ResolvedProvider {
+    provider: ModelProvider;
+    model: string;
+    baseURL: string;
+    apiKey: string;
+    headers: Record<string, string>;
+}
+declare class ModelProviderRegistry {
+    private providers;
+    constructor();
+    addProvider(provider: ModelProvider): void;
+    removeProvider(id: string): boolean;
+    getProvider(id: string): ModelProvider | undefined;
+    listProviders(): ModelProvider[];
+    resolveProvider(model: string, overrides?: {
+        apiKey?: string;
+        baseURL?: string;
+    }): ResolvedProvider;
+}
+declare function getDefaultProviderRegistry(): ModelProviderRegistry;
+interface MemoryFile {
+    level: MemoryLevel;
+    path: string;
+    content: string;
+    tokenCount: number;
+    lastModified?: Date;
+}
+interface ResolvedMemory {
+    files: MemoryFile[];
+    byLevel: Record<MemoryLevel, string>;
+    totalTokens: number;
+    truncated: boolean;
+}
+interface ProjectSessionContextEntry {
+    sessionId: string;
+    model: string;
+    lastActivity: string;
+    messageCount: number;
+    excerpt: string;
+}
+interface ProjectSessionContext {
+    entries: ProjectSessionContextEntry[];
+    totalTokens: number;
+    truncated: boolean;
+    content: string;
+}
+declare const DEFAULT_MEMORY_BUDGETS: MemoryBudget;
+declare const MEMORY_FILES: Record<MemoryLevel, string>;
+interface MemoryManagerOptions {
+    cwd: string;
+    globalDir?: string;
+    role?: string;
+    sessionDir?: string;
+    budgets?: Partial<MemoryBudget>;
+    projectSessionContext?: {
+        limit?: number;
+        maxTokens?: number;
+        maxCharsPerSession?: number;
+    };
+}
+declare class MemoryManager {
+    private cwd;
+    private globalDir;
+    private role?;
+    private sessionDir?;
+    private budgets;
+    private projectSessionContextDefaults;
+    constructor(options: MemoryManagerOptions);
+    getProjectSessionContextDefaults(): {
+        limit: number;
+        maxTokens: number;
+        maxCharsPerSession: number;
+    };
+    getPath(level: MemoryLevel): string;
+    loadForPrompt(): Promise<ResolvedMemory>;
+    loadProjectSessionContext(options?: {
+        excludeSessionId?: string;
+        limit?: number;
+        maxTokens?: number;
+        maxCharsPerSession?: number;
+    }): Promise<ProjectSessionContext>;
+    private filterProjectSessions;
+    private normalizePath;
+    private extractRecentTranscriptExcerpt;
+    private formatProjectSessionEntry;
+    add(level: MemoryLevel, content: string, source: "user" | "auto"): Promise<void>;
+    set(level: MemoryLevel, content: string): Promise<void>;
+    formatForPrompt(memory: ResolvedMemory): string;
+    private truncateContent;
+}
+interface AutoMemoryContext {
+    error?: string;
+    correction?: string;
+    taskCompleted?: boolean;
+    userPreference?: string;
+}
+declare class AutoMemory {
+    private manager;
+    private recentErrors;
+    constructor(manager: MemoryManager);
+    shouldTrigger(context: AutoMemoryContext): AutoMemoryTrigger | null;
+    extract(trigger: AutoMemoryTrigger, messages: Message[]): Promise<string | null>;
+    private extractErrorCorrection;
+    private extractPattern;
+    private extractPreference;
+    private extractTaskSummary;
+    private messagesToText;
+    private normalizeError;
+}
+interface VectorDocument {
+    id: string;
+    content: string;
+    embedding: number[];
+    metadata: Record<string, unknown>;
+}
+interface VectorSearchResult {
+    id: string;
+    content: string;
+    score: number;
+    metadata: Record<string, unknown>;
+}
+interface VectorStoreOptions {
+    maxDocuments?: number;
+    embeddingDimension?: number;
+    embedFn?: (text: string) => Promise<number[]>;
+}
+interface VectorStoreAdapter {
+    add(id: string, embedding: number[], metadata: Record<string, unknown>): Promise<void>;
+    search(query: number[], topK: number): Promise<Array<{
+        id: string;
+        score: number;
+    }>>;
+    remove(id: string): Promise<void>;
+    readonly size: number;
+}
+declare class VectorMemoryStore {
+    private documents;
+    private insertionOrder;
+    private maxDocuments;
+    private embedder;
+    private customEmbedFn?;
+    constructor(options?: VectorStoreOptions);
+    addDocument(id: string, content: string, metadata?: Record<string, unknown>): Promise<void>;
+    search(query: string, topK?: number, minScore?: number): Promise<VectorSearchResult[]>;
+    removeDocument(id: string): boolean;
+    getDocument(id: string): VectorDocument | undefined;
+    get size(): number;
+    clear(): void;
+    exportDocuments(): VectorDocument[];
+    importDocuments(docs: VectorDocument[]): void;
+}
+interface AskUserRequest {
+    question: string;
+    options?: string[];
+    context?: string;
+}
+interface AskUserResponse {
+    answer: string;
+    selectedOption?: string;
+}
+type AskUserHandler = (request: AskUserRequest) => Promise<AskUserResponse>;
+interface DispatchAgentRequest {
+    prompt: string;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+interface DispatchAgentResponse {
+    output: string;
+}
+type DispatchAgentHandler = (request: DispatchAgentRequest) => Promise<DispatchAgentResponse>;
+interface FileObservation {
+    path: string;
+    mtimeMs: number;
+    size: number;
+    source: "read" | "write" | "edit" | "notebook" | "shell";
+    requiresRefresh?: boolean;
+    reason?: string;
+}
+interface ToolRuntimeContext {
+    getCwd(): string;
+    setCwd(nextCwd: string): void;
+    getMemoryManager(): MemoryManager | undefined;
+    noteFileObservation(filePath: string, observation: Omit<FileObservation, "path">): void;
+    getFileObservation(filePath: string): FileObservation | undefined;
+    invalidateFileObservation(filePath: string, reason: string): void;
+    listFileObservations(): FileObservation[];
+    askUser?(request: AskUserRequest): Promise<AskUserResponse>;
+    dispatchAgent?(request: DispatchAgentRequest): Promise<DispatchAgentResponse>;
+}
+declare function createToolRuntimeContext(initialCwd?: string, options?: {
+    askUser?: AskUserHandler;
+    dispatchAgent?: DispatchAgentHandler;
+    memoryManager?: MemoryManager;
+}): ToolRuntimeContext;
+declare const defaultToolRuntimeContext: ToolRuntimeContext;
+interface DefaultToolRegistryOptions {
+    cwd?: string;
+    askUser?: AskUserHandler;
+    dispatchAgent?: DispatchAgentHandler;
+    memoryManager?: MemoryManager;
+    webSearchApiKey?: string;
+    validateInputs?: boolean;
+}
+interface ToolRegistryOptions {
+    validateInputs?: boolean;
+}
+declare class ToolRegistry {
+    private tools;
+    private changeListeners;
+    private aliasNames;
+    private validateInputs;
+    constructor(options?: ToolRegistryOptions);
+    setValidateInputs(enabled: boolean): this;
+    get inputValidationEnabled(): boolean;
+    register(tool: RegisteredTool): void;
+    registerAlias(tool: RegisteredTool): void;
+    registerAll(tools: Iterable<RegisteredTool>): void;
+    unregister(name: string): boolean;
+    onChange(listener: () => void): () => void;
+    private emitChange;
+    get(name: string): RegisteredTool | undefined;
+    getDefinitions(): ToolDefinition[];
+    private static namespaceOf;
+    getDefinitionsByNamespace(namespace: string): ToolDefinition[];
+    listNamespaces(): string[];
+    execute(name: string, input: Record<string, unknown>): Promise<ToolResult>;
+    listNames(): string[];
+    has(name: string): boolean;
+    get size(): number;
+}
+declare function createDefaultToolRegistry(options?: DefaultToolRegistryOptions): ToolRegistry;
+declare const registry: ToolRegistry;
+interface PermissionDecisionEvent {
+    traceId?: string;
+    toolName: string;
+    input: Record<string, unknown>;
+    allowed: boolean;
+    reason: string;
+    mode: PermissionConfig["mode"];
+    requesterLabel?: string;
+}
+type PermissionDecisionHook = (event: PermissionDecisionEvent) => Promise<void> | void;
+interface PersistentPermissionState {
+    allowedTools?: string[];
+    allowedDirectories?: string[];
+}
+interface PermissionCheckContext {
+    traceId?: string;
+    requesterLabel?: string;
+}
+declare class PermissionEngine {
+    private config;
+    private workingDirectory;
+    private sessionAllowed;
+    private sessionAllowedDirectories;
+    private persistentAllowed;
+    private persistentAllowedDirectories;
+    private promptFn?;
+    private decisionHook?;
+    constructor(config?: Partial<PermissionConfig>, promptFn?: PermissionPromptFn, decisionHook?: PermissionDecisionHook);
+    get mode(): PermissionConfig["mode"];
+    setMode(mode: PermissionConfig["mode"]): void;
+    setWorkingDirectory(cwd: string): void;
+    loadPersistentState(state: PersistentPermissionState): void;
+    allowDirectory(directory: string): void;
+    isPathInAllowedDirectory(filePath: string): boolean;
+    check(toolName: string, input: Record<string, unknown>, context?: PermissionCheckContext): Promise<{
+        allowed: boolean;
+        reason: string;
+    }>;
+    private finalizeDecision;
+    private getCacheKey;
+    private isPathInPersistentAllowedDirectory;
+    private extractFilePath;
+    private extractDirectory;
+    private normalizeDirectory;
+    private promptUser;
+    private getToolDetail;
+    private getCommandPrefix;
+    private matchesRule;
+    private matchesBashPattern;
+    private hasBashApproval;
+    private extractBashCommandPrefix;
+    private normalizeCommandText;
+    private resolveTargetPath;
+}
+type XenoRuntimeEventType = "thread.started" | "turn.started" | "turn.completed" | "turn.failed" | "turn.interrupted" | "model.text.delta" | "tool.started" | "tool.permission" | "tool.completed" | "diff.completed";
+interface XenoRuntimeEventBase {
+    id: string;
+    sequence: number;
+    type: XenoRuntimeEventType;
+    timestamp: string;
+    threadId?: string;
+    turnId?: string;
+}
+type XenoRuntimeEvent = (XenoRuntimeEventBase & {
+    type: "thread.started";
+    cwd: string;
+    model: string;
+}) | (XenoRuntimeEventBase & {
+    type: "turn.started";
+    model: string;
+    promptPreview: string;
+}) | (XenoRuntimeEventBase & {
+    type: "turn.completed";
+    outputPreview: string;
+    tokenUsage: {
+        input: number;
+        output: number;
+        total: number;
+    };
+}) | (XenoRuntimeEventBase & {
+    type: "turn.failed" | "turn.interrupted";
+    error: string;
+}) | (XenoRuntimeEventBase & {
+    type: "model.text.delta";
+    text: string;
+    iteration?: number;
+}) | (XenoRuntimeEventBase & {
+    type: "tool.started";
+    toolName: string;
+    inputPreview: Record<string, unknown>;
+    iteration?: number;
+}) | (XenoRuntimeEventBase & {
+    type: "tool.permission";
+    toolName: string;
+    allowed: boolean;
+    reason: string;
+    layer: "sandbox" | "permission";
+    iteration?: number;
+}) | (XenoRuntimeEventBase & {
+    type: "tool.completed";
+    toolName: string;
+    success: boolean;
+    outputPreview: string;
+    error?: string;
+    elapsedMs: number;
+    iteration?: number;
+}) | (XenoRuntimeEventBase & {
+    type: "diff.completed";
+    filesChanged: number;
+    summary: string;
+});
+type XenoRuntimeEventSink = (event: XenoRuntimeEvent) => void | Promise<void>;
+type XenoRuntimeEventDraft = XenoRuntimeEvent extends infer Event ? Event extends XenoRuntimeEvent ? Omit<Event, "id" | "sequence" | "timestamp"> & Partial<Pick<XenoRuntimeEvent, "id" | "sequence" | "timestamp">> : never : never;
+declare class XenoRuntimeEventBus {
+    private readonly maxHistory;
+    private listeners;
+    private history;
+    private sequence;
+    constructor(maxHistory?: number);
+    subscribe(listener: XenoRuntimeEventSink): () => void;
+    nextSequence(): number;
+    emit(event: XenoRuntimeEventDraft): void;
+    snapshot(): XenoRuntimeEvent[];
+}
+declare function summarizeRuntimeInput(input: Record<string, unknown>, maxStringLength?: number): Record<string, unknown>;
+type ShutdownCleanup = () => void;
+declare function registerShutdownCleanup(cleanup: ShutdownCleanup): () => void;
+interface InstallSignalHandlersOptions {
+    signals?: Array<"SIGINT" | "SIGTERM" | "SIGBREAK">;
+    exitOnSignal?: boolean;
+}
+declare function installSignalHandlers(options?: InstallSignalHandlersOptions): boolean;
+declare function areSignalHandlersInstalled(): boolean;
+interface FileSnapshot {
+    path: string;
+    exists: boolean;
+    size: number;
+    mtimeMs: number;
+    text?: string;
+    binary?: boolean;
+    truncated?: boolean;
+}
+interface TurnFileDiff {
+    path: string;
+    status: "created" | "modified" | "deleted" | "unchanged";
+    before?: FileSnapshot;
+    after?: FileSnapshot;
+    patch?: string;
+}
+interface TurnDiffSummary {
+    turnId: string;
+    startedAt: string;
+    completedAt: string;
+    files: TurnFileDiff[];
+}
+interface TurnDiffTrackerOptions {
+    maxFileBytes?: number;
+    cwd?: string;
+}
+declare class TurnDiffTracker {
+    private active?;
+    private readonly maxFileBytes;
+    private readonly cwd;
+    constructor(options?: TurnDiffTrackerOptions);
+    beginTurn(turnId: string): void;
+    observeBefore(paths: Iterable<string | null | undefined>): void;
+    observeAfter(paths: Iterable<string | null | undefined>): void;
+    endTurn(): TurnDiffSummary | undefined;
+    inferToolPaths(toolName: string, input: Record<string, unknown>): string[];
+    private resolvePath;
+    private snapshot;
+}
+interface ToolOrchestratorCallbacks {
+    onToolStart?: (name: string, input: Record<string, unknown>) => void;
+    onToolWillExecute?: (name: string, input: Record<string, unknown>) => void | Promise<void>;
+    onToolEnd?: (name: string, result: ToolResult) => void;
+}
+interface ToolOrchestratorConfig {
+    toolRegistry: ToolRegistry;
+    permissionEngine: PermissionEngine;
+    requesterLabel?: string;
+    sandbox?: AgentSandbox;
+    onPermissionRequest?: (context: PermissionRequestContext) => Promise<PermissionRequestResult> | PermissionRequestResult;
+    callbacks?: ToolOrchestratorCallbacks;
+    auditLogger?: AuditLogger;
+    eventSink?: (event: XenoRuntimeEventDraft) => void | Promise<void>;
+    turnDiffTracker?: TurnDiffTracker;
+}
+interface ExecuteToolRequest {
+    toolCall: ToolUseBlock;
+    traceId: string;
+    iteration: number;
+    skipToolExecutionReason?: string | null;
+}
+interface ExecuteToolResult {
+    toolCall: ToolUseBlock;
+    toolResult: ToolResult;
+    executeTool: boolean;
+}
+declare class ToolOrchestrator {
+    private readonly config;
+    constructor(config: ToolOrchestratorConfig);
+    execute(request: ExecuteToolRequest): Promise<ExecuteToolResult>;
+    private checkSandboxAndPermission;
+    private appendAuditEvent;
+    private emit;
+}
+declare function getToolRiskLevel(toolName: string): "low" | "medium" | "high";
+interface TraceGraphNode {
+    id: string;
+    kind: "thread" | "turn" | "model" | "tool" | "diff" | "error";
+    label: string;
+    timestamp: string;
+    metadata?: Record<string, unknown>;
+}
+interface TraceGraphEdge {
+    from: string;
+    to: string;
+    kind: "contains" | "emits" | "calls" | "produces" | "fails";
+}
+interface TraceGraph {
+    traceId: string;
+    createdAt: string;
+    nodes: TraceGraphNode[];
+    edges: TraceGraphEdge[];
+    events: XenoRuntimeEvent[];
+}
+declare class XenoTraceGraphRecorder {
+    private readonly traceId;
+    private readonly createdAt;
+    private readonly events;
+    private readonly nodes;
+    private readonly edges;
+    private lastTurnId?;
+    private lastToolNodeId?;
+    constructor(traceId: string);
+    record(event: XenoRuntimeEvent): void;
+    toGraph(): TraceGraph;
+    private addNode;
+    private addEdge;
+}
+type UnifiedExecStatus = "running" | "exited" | "failed" | "terminated";
+type UnifiedExecStream = "stdout" | "stderr";
+interface UnifiedExecStartOptions {
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+    timeoutMs?: number;
+    maxOutputBytes?: number;
+}
+interface UnifiedExecProcess {
+    id: string;
+    command: string;
+    pid?: number;
+    cwd: string;
+    status: UnifiedExecStatus;
+    startedAt: string;
+    endedAt?: string;
+    exitCode?: number | null;
+    signal?: NodeJS.Signals | null;
+    outputBytes: number;
+}
+interface UnifiedExecOutput {
+    process: UnifiedExecProcess;
+    output: string;
+    totalBytes: number;
+    truncated: boolean;
+    omittedBytes: number;
+}
+interface UnifiedExecOutputChunk {
+    id: number;
+    stream: UnifiedExecStream;
+    text: string;
+    bytes: number;
+    timestamp: string;
+}
+interface UnifiedExecReadDeltaOptions {
+    maxChunks?: number;
+    maxBytes?: number;
+}
+interface UnifiedExecOutputDelta {
+    process: UnifiedExecProcess;
+    cursor: number;
+    nextCursor: number;
+    earliestCursor: number;
+    chunks: UnifiedExecOutputChunk[];
+    text: string;
+    bytes: number;
+    missedChunks: number;
+    hasMore: boolean;
+}
+declare class UnifiedExecManager {
+    private readonly processes;
+    start(command: string, options?: UnifiedExecStartOptions): UnifiedExecProcess;
+    writeStdin(processId: string, text: string): boolean;
+    readOutput(processId: string): UnifiedExecOutput | null;
+    readOutputDelta(processId: string, cursor?: number, options?: UnifiedExecReadDeltaOptions): UnifiedExecOutputDelta | null;
+    terminate(processId: string): boolean;
+    list(): UnifiedExecProcess[];
+    private pruneProcessIfNeeded;
+}
+declare const unifiedExecManager: UnifiedExecManager;
+declare class TranscriptWriter {
+    private sessionDir;
+    private sessionId;
+    private transcriptPath;
+    private markdownPath;
+    private workspaceMarkdownPath;
+    private markdownHeaderWritten;
+    private workspaceHeaderWritten;
+    private workspaceMirrorDisabled;
+    private sequence;
+    private writeQueue;
+    private pendingWrites;
+    constructor(sessionDir: string);
+    append(event: Omit<TranscriptEvent, "id" | "timestamp" | "sequence">): Promise<string>;
+    private stringify;
+    private formatMessageContent;
+    private formatEventMarkdown;
+    private ensureMarkdownHeader;
+    private resolveWorkspaceMarkdownPath;
+    private appendMarkdownEvent;
+    private buildMarkdownDocument;
+    read(options?: {
+        types?: TranscriptEventType[];
+        limit?: number;
+        offset?: number;
+    }): Promise<TranscriptEvent[]>;
+    private isMessageData;
+    getMessages(): Promise<Message[]>;
+    replaceMessages(messages: Message[]): Promise<void>;
+    truncateAfterMessageCount(messageCount: number): Promise<void>;
+    getSequence(): number;
+    initialize(): Promise<void>;
+    flush(): Promise<void>;
+}
+declare class CheckpointManager {
+    private sessionDir;
+    private checkpointsDir;
+    private autoInterval;
+    private lastCheckpointMessageCount;
+    constructor(sessionDir: string, options?: {
+        autoInterval?: number;
+    });
+    initialize(): Promise<void>;
+    create(options: {
+        trigger: CheckpointTrigger;
+        messages: Message[];
+        description?: string;
+    }): Promise<CheckpointInfo>;
+    list(): Promise<CheckpointInfo[]>;
+    restore(checkpointId: string): Promise<{
+        messages: Message[];
+        info: CheckpointInfo;
+    }>;
+    shouldAutoCheckpoint(currentMessageCount: number): boolean;
+    static isDangerousOperation(toolName: string, input: unknown): boolean;
+    delete(checkpointId: string): Promise<void>;
+    private estimateTokens;
+}
+interface SessionCreateOptions {
+    role?: string;
+    parentSession?: string;
+    workingDirectory: string;
+    model: string;
+}
+interface SessionResumeOptions {
+    sessionId: string;
+    fromCheckpoint?: string;
+}
+declare class SessionManager {
+    private sessionDir;
+    private _meta;
+    private _transcript;
+    private _checkpoints;
+    private _lock;
+    private constructor();
+    static create(options: SessionCreateOptions): Promise<SessionManager>;
+    static resume(options: SessionResumeOptions): Promise<SessionManager>;
+    get meta(): SessionMeta;
+    get transcript(): TranscriptWriter;
+    get checkpoints(): CheckpointManager;
+    updateMeta(partial: Partial<SessionMeta>): Promise<void>;
+    end(status?: "completed" | "abandoned"): Promise<void>;
+    recordUserMessage(content: string): Promise<void>;
+    recordAssistantMessage(content: string | ContentBlock[] | ToolResultBlock[], tokenCount?: number): Promise<void>;
+    recordTokenUsage(input: number, output: number): Promise<void>;
+    recordDelegationSummary(data: DelegationSummaryData): Promise<void>;
+    updateMessageCount(count: number): Promise<void>;
+}
+declare function readSessionFormatVersion(meta: {
+    formatVersion?: number;
+} | null | undefined): number;
+interface ApiTextContentBlock {
+    type: "text";
+    text: string;
+}
+interface ApiToolUseContentBlock {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}
+interface ApiToolResultContentBlock {
+    type: "tool_result";
+    tool_use_id: string;
+    content: ToolResultContent;
+    assistant_content?: ToolAssistantContentBlock[];
+    assistant_only_content?: ToolAssistantContentBlock[];
+    is_error?: boolean;
+}
+type ApiMessage = {
+    role: "user" | "assistant";
+    content: string | Array<ApiTextContentBlock | ApiToolUseContentBlock | ApiToolResultContentBlock>;
+};
+type XenoChatMessage = {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string | null | Array<{
+        type: "text";
+        text: string;
+    } | {
+        type: "image_url";
+        image_url: {
+            url: string;
+            detail?: "auto" | "low" | "high";
+        };
+    }>;
+    tool_call_id?: string;
+    tool_calls?: Array<{
+        id: string;
+        type: "function";
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+};
+interface StreamResult {
+    content: ContentBlock[];
+    stopReason: "end_turn" | "tool_use" | "max_tokens" | "stop_sequence";
+    inputTokens: number;
+    outputTokens: number;
+}
+interface ApiRequestFailureDiagnostics {
+    model: string;
+    requestUrl: string;
+    stream: boolean;
+    messageCount: number;
+    toolCount: number;
+    requestBytes: number;
+    promptTokenEstimate: number;
+    statusCode?: number;
+    requestId?: string;
+    cfRay?: string;
+    retryAfterMs?: number;
+    detailPreview?: string;
+    errorMessage?: string;
+}
+interface LlmClientDeps {
+    readonly baseURL: string;
+    readonly ollamaBaseUrl: string;
+    readonly apiKey?: string;
+    readonly maxTokens: number;
+    getApiRequestTimeoutMs(): number;
+    buildRuntimeSystemPrompt(): string;
+    reportFailure(diagnostics: ApiRequestFailureDiagnostics): Promise<void>;
+}
+declare class LlmClient {
+    private readonly deps;
+    private ollamaMode;
+    constructor(deps: LlmClientDeps);
+    readonly id = "xeno-llm-client";
+    complete(model: string, messages: ApiMessage[], tools: ToolDefinition[], onText?: (text: string) => void, signal?: AbortSignal): Promise<StreamResult>;
+    completeLocal(model: string, messages: ApiMessage[], tools: ToolDefinition[], onText?: (text: string) => void, signal?: AbortSignal): Promise<StreamResult>;
+    toOllamaMessages(apiMessages: ApiMessage[]): Array<{
+        role: "system" | "user" | "assistant" | "tool";
+        content: string;
+        tool_call_id?: string;
+        tool_calls?: Array<{
+            id: string;
+            type: "function";
+            function: {
+                name: string;
+                arguments: string;
+            };
+        }>;
+    }>;
+    toXenoMessages(apiMessages: ApiMessage[], options?: {
+        allowImages?: boolean;
+    }): XenoChatMessage[];
+    private buildStructuredToolContextMessage;
+    private modelSupportsImageInputs;
+    private describeSuppressedImageBlock;
+    getChatCompletionsBaseUrl(): string;
+    private condenseToolResultForModel;
+    buildXenoToolDefinitions(tools: ToolDefinition[]): Array<{
+        type: "function";
+        function: {
+            name: string;
+            description: string;
+            parameters: ToolDefinition["input_schema"];
+        };
+    }>;
+    private buildChatCompletionsRequestBody;
+    private parseXenoCompletion;
+    static parseRetryAfterSeconds(value: string | null): number | undefined;
+    private static getHeaderValue;
+    private static stripHtml;
+    private static summarizeErrorBody;
+    private createApiRequestSignal;
+    callChatCompletionsNonStream(model: string, apiMessages: ApiMessage[], tools: ToolDefinition[], onText?: (text: string) => void, signal?: AbortSignal): Promise<StreamResult>;
+    callChatCompletions(model: string, apiMessages: ApiMessage[], tools: ToolDefinition[], onText?: (text: string) => void, signal?: AbortSignal): Promise<StreamResult>;
+    callOllama(model: string, apiMessages: ApiMessage[], tools: ToolDefinition[], onText?: (text: string) => void, signal?: AbortSignal): Promise<StreamResult>;
+    private callOllamaOpenAI;
+    private callOllamaNative;
+}
+interface ToolMiddlewareContext {
+    readonly toolName: string;
+    readonly toolCallId: string;
+    input: Record<string, unknown>;
+    readonly iteration: number;
+    readonly traceId: string;
+    readonly signal: AbortSignal;
+    addGuidance(text: string): void;
+}
+type ToolMiddleware = (ctx: ToolMiddlewareContext, next: () => Promise<ToolResult>) => Promise<ToolResult>;
+declare class ToolMiddlewareRegistry {
+    private readonly middlewares;
+    use(middleware: ToolMiddleware): this;
+    useAll(middlewares: readonly ToolMiddleware[]): this;
+    get size(): number;
+    list(): readonly ToolMiddleware[];
+    run(base: Omit<ToolMiddlewareContext, "addGuidance">, core: () => Promise<ToolResult>): Promise<ToolResult>;
+}
+declare function appendGuidanceToResult(result: ToolResult, guidance: readonly string[]): ToolResult;
+interface PromptSectionContext {
+    readonly systemPrompt: string;
+    readonly taskPrompt?: string;
+    readonly iteration: number;
+    readonly model: string;
+}
+interface PromptSectionProvider {
+    name: string;
+    order?: number;
+    provide(ctx: PromptSectionContext): string | null | undefined;
+}
+declare const DEFAULT_PROMPT_SECTIONS_TOKEN_BUDGET = 4000;
+declare class PromptSectionRegistry {
+    private readonly sections;
+    private seqCounter;
+    private tokenBudget;
+    constructor(tokenBudget?: number);
+    register(provider: PromptSectionProvider): this;
+    unregister(name: string): boolean;
+    get size(): number;
+    setTokenBudget(tokens: number): void;
+    orderedNames(): string[];
+    private ordered;
+    build(ctx: PromptSectionContext): string;
+}
+type CompletionGuardStopReason = "end_turn" | "tool_use" | "max_tokens" | "stop_sequence" | "empty_response" | "progress_checkpoint";
+interface CompletionGuardTurnStats {
+    readonly iteration: number;
+    readonly maxIterations: number;
+    readonly toolCalls: number;
+    readonly toolFailures: number;
+    readonly failuresByTool: Readonly<Record<string, number>>;
+}
+interface CompletionGuardEvaluationContext {
+    readonly finalText: string;
+    readonly iteration: number;
+    readonly maxIterations: number;
+    readonly messages: Message[];
+    readonly stopReason: CompletionGuardStopReason;
+    readonly stats: CompletionGuardTurnStats;
+}
+type CompletionGuardDecision = {
+    allow: true;
+} | {
+    allow: false;
+    guidance: string;
+    stop?: boolean;
+};
+interface CompletionGuard {
+    name: string;
+    order?: number;
+    evaluate(ctx: CompletionGuardEvaluationContext): CompletionGuardDecision | null | undefined | Promise<CompletionGuardDecision | null | undefined>;
+}
+interface CompletionGuardVeto {
+    guidance: string;
+    stop: boolean;
+    guardName: string;
+}
+declare class CompletionGuardRegistry {
+    private readonly guards;
+    private seqCounter;
+    register(guard: CompletionGuard): this;
+    unregister(name: string): boolean;
+    get size(): number;
+    orderedNames(): string[];
+    private ordered;
+    evaluate(ctx: CompletionGuardEvaluationContext): Promise<CompletionGuardVeto | null>;
+}
+type LLMProviderMessage = ApiMessage;
+type LLMCompletionResult = StreamResult;
+interface LLMProviderCapabilities {
+    readonly streaming?: boolean;
+    readonly tools?: boolean;
+    readonly vision?: boolean;
+    readonly [capability: string]: boolean | undefined;
+}
+interface LLMProvider {
+    readonly id: string;
+    readonly model?: string;
+    readonly capabilities?: LLMProviderCapabilities;
+    complete(model: string, messages: LLMProviderMessage[], tools: ToolDefinition[], onText?: (text: string) => void, signal?: AbortSignal): Promise<LLMCompletionResult>;
+    completeLocal?(model: string, messages: LLMProviderMessage[], tools: ToolDefinition[], onText?: (text: string) => void, signal?: AbortSignal): Promise<LLMCompletionResult>;
+}
+declare function toLLMProvider(source: DualLLMProviderLike, options?: {
+    id?: string;
+    model?: string;
+}): LLMProvider;
+interface DualLLMProviderLike {
+    chat(params: {
+        messages: Array<{
+            role: "system" | "user" | "assistant";
+            content: string;
+        }>;
+        model?: string;
+    }): Promise<{
+        content: string;
+        usage?: {
+            promptTokens: number;
+            completionTokens: number;
+        };
+    }>;
+    chatStream(params: {
+        messages: Array<{
+            role: "system" | "user" | "assistant";
+            content: string;
+        }>;
+        model?: string;
+    }): AsyncIterable<string>;
+}
+declare class AgentInterruptedError extends Error {
+    constructor(message?: string);
+}
+interface ModeSwitchRequest {
+    from: ExecutionMode;
+    to: ExecutionMode;
+    requestedTools: string[];
+    reason: string;
+}
+interface AgentLoopConfig {
+    apiKey?: string;
+    baseURL: string;
+    ollamaBaseURL?: string;
+    model: string;
+    maxTokens: number;
+    maxIterations: number;
+    systemPrompt: string;
+    requesterLabel?: string;
+    executionMode?: ExecutionMode;
+    permissionEngine: PermissionEngine;
+    toolRegistry?: ToolRegistry;
+    onText?: (text: string) => void;
+    onToolStart?: (name: string, input: Record<string, unknown>) => void;
+    onToolWillExecute?: (name: string, input: Record<string, unknown>) => void | Promise<void>;
+    onToolEnd?: (name: string, result: ToolResult) => void;
+    onIteration?: (iteration: number, totalTokens: number) => void;
+    onError?: (error: Error, context: string) => void;
+    onTranscriptError?: (error: Error, context: string) => void;
+    onModeSwitchRequest?: (request: ModeSwitchRequest) => Promise<boolean>;
+    onExecutionModeChanged?: (mode: ExecutionMode, reason: string) => void;
+    onContextCompressed?: (messagesRemoved: number, tokensSaved: number) => void;
+    onRuntimeEvent?: XenoRuntimeEventSink;
+    runtimeEventBus?: XenoRuntimeEventBus;
+    turnDiffTracker?: TurnDiffTracker;
+    completionGuard?: (context: CompletionGuardContext) => Promise<CompletionGuardResult | null> | CompletionGuardResult | null;
+    maxCompletionGuardReminders?: number;
+    progressGuardEveryIterations?: number;
+    apiRequestTimeoutMs?: number;
+    runStartedAtMs?: number;
+    externalTimeoutMs?: number;
+    apiDeadlineFinalBufferMs?: number;
+    backgroundTaskDrainMaxWaitMs?: number;
+    backgroundTaskDrainPollIntervalMs?: number;
+    backgroundTaskDrainExtraIterations?: number;
+    sandbox?: AgentSandbox;
+    onPermissionRequest?: (context: PermissionRequestContext) => Promise<PermissionRequestResult> | PermissionRequestResult;
+    toolMiddleware?: ToolMiddleware[];
+    promptSections?: PromptSectionProvider[];
+    promptSectionsTokenBudget?: number;
+    completionGuards?: CompletionGuard[];
+    provider?: LLMProvider;
+    transcript?: TranscriptWriter;
+    checkpoints?: CheckpointManager;
+    sessionManager?: SessionManager;
+    autoCheckpointInterval?: number;
+    maxContextTokens?: number;
+    historyMarkdownPath?: string;
+    compressionKeepRecentMessages?: number;
+    auditLogger?: AuditLogger;
+}
+interface CompletionGuardContext {
+    finalText: string;
+    iteration: number;
+    messages: Message[];
+    stopReason: StreamResult["stopReason"] | "empty_response" | "progress_checkpoint";
+}
+interface RunStreamOptions {
+    signal?: AbortSignal;
+}
+interface CompletionGuardResultObject {
+    message: string;
+    blocking?: boolean;
+    stop?: boolean;
+    toolPolicy?: CompletionGuardToolPolicy;
+}
+type CompletionGuardResult = string | CompletionGuardResultObject;
+type CompletionGuardToolPolicyMode = "require_output_checkpoint";
+interface CompletionGuardToolPolicy {
+    mode: CompletionGuardToolPolicyMode;
+    requiredOutputPaths?: string[];
+    message?: string;
+}
+type AgentRunTerminationStatus = "completed" | "incomplete" | "interrupted" | "error";
+type AgentRunTerminationReason = "end_turn" | "empty_response" | "max_tokens" | "completion_guard_stop" | "max_iterations" | "interrupted" | "error";
+interface AgentRunTermination {
+    status: AgentRunTerminationStatus;
+    reason: AgentRunTerminationReason;
+    iteration: number;
+    maxIterations: number;
+    finalStateVerified: boolean;
+    message: string;
+}
+interface SessionIntegrationConfig {
+    transcript?: TranscriptWriter;
+    checkpoints?: CheckpointManager;
+    sessionManager?: SessionManager;
+    historyMarkdownPath?: string;
+    auditLogger?: AuditLogger;
+}
+declare class AgentLoop {
+    private config;
+    private toolRegistry;
+    private _messages;
+    private totalInputTokens;
+    private totalOutputTokens;
+    private lastCheckpointMessageCount;
+    private ollamaBaseUrl;
+    private activeAbortController;
+    private interruptionRequested;
+    private currentTraceId;
+    private lastRunTraceId;
+    private lastRunTerminationInfo;
+    private activeTaskPrompt;
+    private activeToolPolicy;
+    private apiFailureDiagnosticsLogged;
+    private readonly runtimeEventBus;
+    private readonly threadId;
+    private readonly turnDiffTracker?;
+    private readonly llm;
+    private readonly messageFlow;
+    private readonly middleware;
+    private readonly promptSections;
+    private readonly completionGuards;
+    private turnToolCalls;
+    private turnToolFailures;
+    private turnFailuresByTool;
+    private turnIteration;
+    constructor(config: AgentLoopConfig);
+    get tokenUsage(): {
+        input: number;
+        output: number;
+        total: number;
+    };
+    get lastTraceId(): string | null;
+    get lastRunTermination(): AgentRunTermination | null;
+    get model(): string;
+    set model(value: string);
+    get executionMode(): ExecutionMode;
+    set executionMode(value: ExecutionMode);
+    get systemPrompt(): string;
+    set systemPrompt(value: string);
+    use(middleware: ToolMiddleware): this;
+    registerPromptSection(provider: PromptSectionProvider): this;
+    registerCompletionGuard(guard: CompletionGuard): this;
+    attachSessionIntegration(config: SessionIntegrationConfig): void;
+    cancelCurrentTurn(): boolean;
+    private emitRuntimeEvent;
+    private handleTextDelta;
+    private handleContextCompressed;
+    private isAbortError;
+    private toolRiskLevel;
+    private isParallelSafeTool;
+    private pathAliasesForToolPolicy;
+    private toolPolicyMentionsRequiredPath;
+    private toolPolicyTargetsRequiredPath;
+    private bashCommandCanCreateRequiredOutput;
+    private toolCallSatisfiesToolPolicy;
+    private maybeBlockActiveToolPolicy;
+    private getCompressedSourceSizeLimit;
+    private isSourceLikePath;
+    private isBinaryReimplementationContractTask;
+    private getOriginalBinaryAliases;
+    private textMentionsOriginalBinary;
+    private sourceContainsOriginalBinaryBypass;
+    private sourceGenerationCommandContainsOriginalBinaryBypass;
+    private buildSourceIndependenceBlock;
+    private maybeBlockSourceIndependenceViolation;
+    private maybeBlockKnownInvalidWrite;
+    private maybeBlockKnownInvalidBashSourceGeneration;
+    private recordToolEventsToTranscript;
+    protected callChatCompletions(model: string, apiMessages: ApiMessage[], tools: ToolDefinition[], onText?: (text: string) => void, signal?: AbortSignal): Promise<StreamResult>;
+    protected callOllama(model: string, apiMessages: ApiMessage[], tools: ToolDefinition[], onText?: (text: string) => void, signal?: AbortSignal): Promise<StreamResult>;
+    protected toXenoMessages(apiMessages: ApiMessage[]): ReturnType<LlmClient["toXenoMessages"]>;
+    protected toOllamaMessages(apiMessages: ApiMessage[]): ReturnType<LlmClient["toOllamaMessages"]>;
+    private executeToolCall;
+    private recordTurnToolStats;
+    private currentTurnStats;
+    private appendAuditEvent;
+    private setExecutionModeInternal;
+    private maybeAppendApiRequestFailureAudit;
+    private static parsePositiveInteger;
+    private sleep;
+    private getApiDeadlineFinalBufferMs;
+    private getExternalDeadlineMs;
+    private getBackgroundTaskDrainMaxWaitMs;
+    private getBackgroundTaskDrainPollIntervalMs;
+    private getBackgroundTaskDrainExtraIterations;
+    private getBackgroundTaskDrainBudgetMs;
+    private getDrainableBackgroundTasks;
+    private summarizeBackgroundTaskSnapshot;
+    private maybeDrainBackgroundTasksAtIterationBudget;
+    private getApiRequestTimeoutMs;
+    private createApiRequestSignal;
+    private buildRuntimeSystemPrompt;
+    get messages(): Message[];
+    set messages(value: Message[]);
+    private shouldAutoCheckpoint;
+    private getApiMessagesForRequest;
+    private appendSyntheticUserMessage;
+    run(userMessage: string): Promise<string>;
+    runStream(prompt: string, options?: RunStreamOptions): AsyncIterable<XenoRuntimeEvent>;
+    private createRuntimeEventIterator;
+    private runInternal;
+    clearHistory(): void;
+}
+interface MessageFlowDeps {
+    getMessages(): Message[];
+    readonly model: string;
+    readonly maxContextTokens?: number;
+    readonly compressionKeepRecentMessages?: number;
+    readonly historyMarkdownPath?: string;
+    buildRuntimeSystemPrompt(): string;
+    onContextCompressed(messagesRemoved: number, tokensSaved: number): Promise<void>;
+}
+declare class MessageFlow {
+    private readonly deps;
+    private lastCompressionSignature;
+    constructor(deps: MessageFlowDeps);
+    reset(): void;
+    messageToPlainText(message: Message): string;
+    estimateConversationTokens(messages: Message[]): number;
+    toApiMessages(messages: Message[]): ApiMessage[];
+    estimateXenoRequestBytes(apiMessages: ApiMessage[]): number;
+    pruneExcessImageToolContexts(apiMessages: ApiMessage[]): ApiMessage[];
+    private buildCompressionSummary;
+    private adjustRemovedCountForToolBoundary;
+    getApiMessagesForRequest(): Promise<ApiMessage[]>;
+}
+interface CodingBenchmarkOptions {
+    cwd?: string;
+    iterations?: number;
+    fileCount?: number;
+    linesPerFile?: number;
+}
+interface CodingBenchmarkMeasurement {
+    name: string;
+    samplesMs: number[];
+    minMs: number;
+    avgMs: number;
+    p95Ms: number;
+    maxMs: number;
+}
+interface CodingBenchmarkThreshold {
+    avgMs: number;
+    p95Ms: number;
+}
+interface CodingBenchmarkAssessment {
+    name: string;
+    status: "pass" | "warn" | "fail";
+    avgMs: number;
+    p95Ms: number;
+    avgThresholdMs: number;
+    p95ThresholdMs: number;
+    reasons: string[];
+}
+interface CodingBenchmarkReport {
+    generatedAt: string;
+    cwd: string;
+    iterations: number;
+    fileCount: number;
+    linesPerFile: number;
+    measurements: CodingBenchmarkMeasurement[];
+    status: "pass" | "warn" | "fail";
+    assessments: CodingBenchmarkAssessment[];
+    warnings: string[];
+    failures: string[];
+}
+declare function benchmarkCodingTools(options?: CodingBenchmarkOptions): Promise<CodingBenchmarkReport>;
+declare function renderCodingBenchmarkReport(report: CodingBenchmarkReport): string;
+declare function renderCodingBenchmarkMarkdown(report: CodingBenchmarkReport): string;
+interface PromptContext {
+    cwd: string;
+    model: string;
+    date: string;
+    identity?: ResolvedIdentity;
+    memory?: string;
+    sessionId?: string;
+    executionMode?: ExecutionMode;
+}
+declare function buildSystemPrompt(ctx: PromptContext): string;
+type CompressionLLMFn = (systemPrompt: string, messages: Message[]) => Promise<string>;
+interface ContextManagerConfig {
+    maxContextTokens?: number;
+    compressionThreshold?: number;
+    keepRecentMessages?: number;
+    onCompressed?: (stats: CompressionStats) => void;
+}
+interface CompressionStats {
+    originalMessageCount: number;
+    compressedMessageCount: number;
+    originalTokens: number;
+    compressedTokens: number;
+    tokensSaved: number;
+}
+declare class ContextManager {
+    private maxContextTokens;
+    private compressionThreshold;
+    private keepRecentMessages;
+    private onCompressed?;
+    constructor(config?: ContextManagerConfig);
+    estimateTokens(messages: Message[]): number;
+    needsCompression(messages: Message[]): boolean;
+    compress(messages: Message[], llmCompress?: CompressionLLMFn): Promise<Message[]>;
+    private buildSimpleSummary;
+    private extractPlainText;
+}
+interface ScoredMemory {
+    memory: MemoryEntry;
+    score: number;
+}
+declare function scoreMemories(memories: MemoryEntry[], currentMessage: string, maxResults?: number): ScoredMemory[];
+interface BackgroundTask {
+    id: string;
+    command: string;
+    pid: number;
+    status: "running" | "completed" | "failed" | "killed";
+    exitCode: number | null;
+    startedAt: number;
+    endedAt: number | null;
+    cwd: string;
+    outputFile: string;
+    outputSize: number;
+    lastObservedAt: number;
+    lastOutputAt: number;
+    lastObservedOutputSize: number;
+    pollCount: number;
+    unchangedPollCount: number;
+}
+type TaskCompletionCallback = (task: BackgroundTask) => void;
+interface BackgroundTaskOutput {
+    output: string;
+    bytesRead: number;
+    totalSize: number;
+    status: BackgroundTask["status"];
+    exitCode: number | null;
+    command: string;
+    elapsedMs: number;
+    idleMs: number;
+    outputDeltaBytes: number;
+    pollCount: number;
+    unchangedPollCount: number;
+    nextOffset: number;
+    lastLines: string[];
+    progressState: "active" | "idle" | "stalled" | "finished";
+    suggestedNextAction: string;
+}
+declare class BackgroundProcessManager {
+    private tasks;
+    private processes;
+    private counter;
+    private taskDir;
+    private onComplete;
+    private cleanupRegistered;
+    constructor(taskDir?: string);
+    private ensureDir;
+    private registerCleanup;
+    onTaskComplete(cb: TaskCompletionCallback): void;
+    spawn(command: string, options?: {
+        cwd?: string;
+        env?: NodeJS.ProcessEnv;
+        timeout?: number;
+    }): string;
+    getOutput(taskId: string, offset?: number): BackgroundTaskOutput | null;
+    private buildOutputSnapshot;
+    private getProgressState;
+    private extractLastLines;
+    private getSuggestedNextAction;
+    stop(taskId: string): boolean;
+    list(): BackgroundTask[];
+    get(taskId: string): BackgroundTask | null;
+    shouldDrainAtIterationBudget(task: BackgroundTask): boolean;
+    killAll(): void;
+    private shouldPreserveForVerifier;
+    formatDuration(ms: number): string;
+}
+declare const backgroundProcessManager: BackgroundProcessManager;
+declare class AutoCheckpointHandler {
+    private checkpointManager;
+    private lastCheckpointAt;
+    constructor(checkpointManager: CheckpointManager);
+    checkInterval(messages: Message[]): Promise<boolean>;
+    checkBeforeDangerous(toolName: string, input: unknown, messages: Message[]): Promise<boolean>;
+}
+interface DelegationBudget {
+    maxTokens: number;
+    timeoutMs: number;
+}
+interface SubagentTask {
+    id: string;
+    role: string;
+    prompt: string;
+    budget: DelegationBudget;
+}
+interface SubagentResult {
+    id: string;
+    role: string;
+    status: "ok" | "error" | "timeout";
+    output: string;
+    tokensUsed: number;
+    error?: string;
+}
+interface DelegationLimits {
+    maxBranches: number;
+    maxTotalTokens: number;
+    maxWallClockMs: number;
+    maxConcurrentBranches?: number;
+}
+declare function resolveDelegatedExecutionMode(parentMode: ExecutionMode, _role: string): ExecutionMode;
+declare function validateDelegationPlan(tasks: SubagentTask[], limits: DelegationLimits): void;
+declare function runDelegationPlan(tasks: SubagentTask[], executeTask: (task: SubagentTask, signal: AbortSignal) => Promise<SubagentResult>, limits: DelegationLimits): Promise<SubagentResult[]>;
+interface ReducerOptions {
+    rolePrecedence?: string[];
+}
+interface ReducedResult {
+    finalAnswer: string;
+    selectedFrom: {
+        id: string;
+        role: string;
+    } | null;
+    confidence: "low" | "medium" | "high";
+    selectionReason?: string;
+    successful: Array<{
+        id: string;
+        role: string;
+        output: string;
+        score?: number;
+    }>;
+    errors: Array<{
+        id: string;
+        role: string;
+        error: string;
+    }>;
+}
+declare function deterministicReduce(results: SubagentResult[], options?: ReducerOptions): ReducedResult;
+type SubagentRole = "planner" | "explorer" | "executor" | "reviewer";
+type SubagentWorkflowMode = "parallel" | "staged";
+type SubagentRemoteMcpAccess = "none" | "prompts" | "resources" | "context" | "all";
+type SubagentTeamPreset = "balanced" | "explore" | "build" | "review";
+interface SubagentBranchPolicy {
+    mode: SubagentWorkflowMode;
+    roles: SubagentRole[];
+    stages: SubagentRole[][];
+    rolePrecedence: string[];
+    maxConcurrentBranches?: number;
+    includePriorStageContext: boolean;
+    tokenWeights?: Partial<Record<SubagentRole, number>>;
+    remoteMcpByRole?: Partial<Record<SubagentRole, SubagentRemoteMcpAccess>>;
+    teamPreset?: SubagentTeamPreset;
+}
+interface SubagentTeamPresetDefinition {
+    preset: SubagentTeamPreset;
+    label: string;
+    description: string;
+    branchPolicy: Omit<Partial<SubagentBranchPolicy>, "teamPreset">;
+}
+declare const DEFAULT_SUBAGENT_ROLES: SubagentRole[];
+declare const DEFAULT_SUBAGENT_ROLE_PRECEDENCE: string[];
+declare const DEFAULT_SUBAGENT_REMOTE_MCP_BY_ROLE: Record<SubagentRole, SubagentRemoteMcpAccess>;
+declare const DEFAULT_SUBAGENT_TEAM_PRESET: SubagentTeamPreset;
+declare const SUBAGENT_ROLE_ALIASES: Record<string, SubagentRole>;
+declare const SUBAGENT_TEAM_PRESETS: Record<SubagentTeamPreset, SubagentTeamPresetDefinition>;
+declare const DEFAULT_SUBAGENT_BRANCH_POLICY: SubagentBranchPolicy;
+interface SubagentExecutionRequest {
+    id: string;
+    role: SubagentRole;
+    prompt: string;
+    maxTokens: number;
+    maxIterations: number;
+    signal?: AbortSignal;
+}
+interface SubagentExecutionResponse {
+    output: string;
+    tokensUsed: number;
+}
+type SubagentExecuteFn = (request: SubagentExecutionRequest) => Promise<SubagentExecutionResponse>;
+interface SubagentWorkflowOptions {
+    userPrompt: string;
+    maxTokensPerBranch?: number;
+    maxTotalTokens?: number;
+    maxIterationsPerBranch: number;
+    limits: DelegationLimits;
+    rolePrecedence?: string[];
+    branchPolicy?: Partial<SubagentBranchPolicy>;
+}
+interface SubagentWorkflowResult {
+    tasks: SubagentTask[];
+    results: SubagentResult[];
+    reduced: ReducedResult;
+}
+interface ResolvedSubagentWorkflowAnswer {
+    answer: string;
+    failureReason?: string;
+    firstError?: string;
+}
+declare function coerceSubagentRole(value: string): SubagentRole | null;
+declare function parseSubagentRoleList(value: string): SubagentRole[] | undefined;
+declare function coerceSubagentTeamPreset(value: string): SubagentTeamPreset | null;
+declare function getSubagentTeamPresetDefinition(preset?: SubagentTeamPreset): SubagentTeamPresetDefinition;
+declare function parseSubagentRemoteMcpPolicy(value: string): Partial<Record<SubagentRole, SubagentRemoteMcpAccess>> | undefined | null;
+declare function normalizeSubagentBranchPolicy(policy?: Partial<SubagentBranchPolicy>): SubagentBranchPolicy;
+declare function resolveSubagentRemoteMcpAccess(policy: Pick<SubagentBranchPolicy, "roles" | "remoteMcpByRole">, role: SubagentRole): SubagentRemoteMcpAccess;
+declare function buildDelegatedRoleSystemPrompt(baseSystemPrompt: string, role: SubagentRole, workspacePath?: string): string;
+declare function buildDefaultSubagentTasks(userPrompt: string, maxTokensPerBranch: number, branchTimeoutMs: number, roles?: SubagentRole[]): SubagentTask[];
+declare function summarizeSubagentResults(results: SubagentResult[]): {
+    total: number;
+    ok: number;
+    errors: number;
+    by_role: Record<string, {
+        status: SubagentResult["status"];
+        tokens_used: number;
+    }>;
+};
+declare function resolveSubagentWorkflowAnswer(workflow: SubagentWorkflowResult): ResolvedSubagentWorkflowAnswer;
+declare function runSubagentWorkflow(options: SubagentWorkflowOptions, execute: SubagentExecuteFn): Promise<SubagentWorkflowResult>;
+interface IdentityLoadResult {
+    layer: IdentityLayer | null;
+    error?: string;
+}
+interface IdentityPaths {
+    global: string;
+    project: string;
+    projectLegacy: string;
+    projectInstructions: readonly string[];
+    role: string;
+}
+declare const IDENTITY_PATHS: IdentityPaths;
+interface IdentityLoaderOptions {
+    cwd: string;
+    globalDir?: string;
+}
+declare class IdentityLoader {
+    private cwd;
+    private globalDir;
+    private static readonly DESCENDANT_SCAN_IGNORES;
+    constructor(options: IdentityLoaderOptions);
+    loadGlobal(): Promise<IdentityLayer | null>;
+    private collectAncestorDirectories;
+    loadProjectLayers(): Promise<IdentityLayer[]>;
+    loadProject(): Promise<IdentityLayer | null>;
+    loadDescendantInstructionHints(options?: {
+        maxResults?: number;
+    }): Promise<DescendantInstructionHint[]>;
+    loadRole(roleName: string): Promise<IdentityLayer | null>;
+    loadAll(options?: {
+        role?: string;
+    }): Promise<IdentityLayer[]>;
+    private loadIdentityFile;
+    private walkDescendantInstructionHints;
+}
+declare class IdentityResolver {
+    private loader;
+    private cachedIdentity?;
+    private cacheKey?;
+    constructor(loader: IdentityLoader);
+    resolve(options?: {
+        role?: string;
+    }): Promise<ResolvedIdentity>;
+    buildPromptSection(identity: ResolvedIdentity): string;
+    private mergeFrontmatter;
+}
+interface SandboxCheckResult {
+    allowed: boolean;
+    reason: string;
+}
+declare function isPathWithinAllowed(resolvedPath: string, allowedDirectories: string[]): boolean;
+declare function extractToolPath(toolName: string, input: Record<string, unknown>, sandbox?: AgentSandbox): string | null;
+declare function checkSandbox(toolName: string, input: Record<string, unknown>, sandbox: AgentSandbox | undefined): SandboxCheckResult;
+declare function createReadTool(runtime?: ToolRuntimeContext): RegisteredTool;
+declare const readTool: RegisteredTool;
+declare function createWriteTool(runtime?: ToolRuntimeContext): RegisteredTool;
+declare const writeTool: RegisteredTool;
+declare function createEditTool(runtime?: ToolRuntimeContext): RegisteredTool;
+declare const editTool: RegisteredTool;
+declare function getGlobIgnores(searchPath: string): string[];
+declare function createGlobTool(runtime?: ToolRuntimeContext): RegisteredTool;
+declare const globTool: RegisteredTool;
+declare function getGrepIgnores(searchPath: string): string[];
+declare function createGrepTool(runtime?: ToolRuntimeContext): RegisteredTool;
+declare const grepTool: RegisteredTool;
+declare function sanitizeEnvironment(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+declare function isDangerousCommand(command: string): boolean;
+declare function getBenchmarkForegroundTimeoutForCommand(command: string, requestedTimeout: number, runInBackground: boolean): number;
+declare function getBenchmarkComputeBudgetHintForCommand(command: string, requestedTimeout: number, runInBackground: boolean): string | null;
+declare function resetBashBenchmarkGuards(): void;
+declare function shouldUseIsolatedStdinForCommand(command: string): boolean;
+declare function requestBackground(): void;
+declare function createBashTool(runtime?: ToolRuntimeContext): RegisteredTool;
+declare const bashTool: RegisteredTool;
+declare function createDispatchAgentTool(runtime?: ToolRuntimeContext): RegisteredTool;
+declare const dispatchAgentTool: RegisteredTool;
+declare function createThinkTool(): RegisteredTool;
+declare const thinkTool: RegisteredTool;
+interface ShellExecutionOptions {
+    timeout: number;
+    restartSession?: boolean;
+    onBackgroundRequested?: () => string | null;
+}
+interface PersistentShellResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    nextCwd?: string;
+    backgrounded?: string;
+}
+interface PersistentShellSpawnSpec {
+    shell: string;
+    args: string[];
+    bootstrap: string;
+}
+interface BoundedShellOutput {
+    text: string;
+    truncatedChars: number;
+}
+declare function appendBoundedShellOutput(current: string, chunk: string, truncatedChars: number, limit?: number): BoundedShellOutput;
+declare function formatBoundedShellOutput(value: string, truncatedChars: number, streamName: string): string;
+declare function shouldSourceShellProfile(env?: NodeJS.ProcessEnv): boolean;
+declare function getPersistentShellSpawnSpec(env?: NodeJS.ProcessEnv): PersistentShellSpawnSpec;
+declare class PersistentShellSession {
+    private readonly env;
+    private child;
+    private queue;
+    private processing;
+    private knownCwd;
+    constructor(initialCwd: string, env: NodeJS.ProcessEnv);
+    execute(command: string, options: ShellExecutionOptions): Promise<PersistentShellResult>;
+    reset(): void;
+    close(): void;
+    private ensureChild;
+    private destroyChild;
+    private processQueue;
+    private executeInternal;
+}
+declare function getPersistentShellSession(runtime: ToolRuntimeContext, env: NodeJS.ProcessEnv): PersistentShellSession;
+declare function resetPersistentShellSession(runtime: ToolRuntimeContext): void;
+declare function resetAllPersistentShellSessions(): void;
+declare function createAskUserTool(runtime?: ToolRuntimeContext): RegisteredTool;
+declare const askUserTool: RegisteredTool;
+declare function createMemoryReadTool(runtime?: ToolRuntimeContext): RegisteredTool;
+declare function createMemoryWriteTool(runtime?: ToolRuntimeContext): RegisteredTool;
+declare const memoryReadTool: RegisteredTool;
+declare const memoryWriteTool: RegisteredTool;
+interface WebSearchResult {
+    title: string;
+    url: string;
+    snippet: string;
+}
+type SearchProvider = "brave" | "google" | "searxng" | "duckduckgo";
+interface SearchConfig {
+    provider: SearchProvider;
+    apiKey?: string;
+    searxngUrl?: string;
+    googleCx?: string;
+}
+declare function configureSearch(config: SearchConfig): void;
+declare const webSearchTool: RegisteredTool;
+declare function createWebSearchTool(apiKey: string): RegisteredTool;
+declare const webFetchTool: RegisteredTool;
+declare function createReadImageTool(runtime?: ToolRuntimeContext): RegisteredTool;
+declare const readImageTool: RegisteredTool;
+declare function createSqliteAnalyzeTool(runtime?: ToolRuntimeContext): RegisteredTool;
+declare const sqliteAnalyzeTool: RegisteredTool;
+declare function createElfAnalyzeTool(runtime?: ToolRuntimeContext): RegisteredTool;
+declare const elfAnalyzeTool: RegisteredTool;
+declare function createGcodeAnalyzeTool(runtime?: ToolRuntimeContext): RegisteredTool;
+declare const gcodeAnalyzeTool: RegisteredTool;
+declare function createHtmlSanitizerAuditTool(runtime?: ToolRuntimeContext): RegisteredTool;
+declare const htmlSanitizerAuditTool: RegisteredTool;
+declare function createArtifactCompareTool(runtime?: ToolRuntimeContext): RegisteredTool;
+declare const artifactCompareTool: RegisteredTool;
+declare function createLsTool(runtime?: ToolRuntimeContext): RegisteredTool;
+declare const lsTool: RegisteredTool;
+declare function createNotebookReadTool(runtime?: ToolRuntimeContext): RegisteredTool;
+declare function createNotebookEditTool(runtime?: ToolRuntimeContext): RegisteredTool;
+declare const notebookReadTool: RegisteredTool;
+declare const notebookEditTool: RegisteredTool;
+declare const gitStatusTool: RegisteredTool;
+declare const gitDiffTool: RegisteredTool;
+declare const gitLogTool: RegisteredTool;
+declare const gitCommitTool: RegisteredTool;
+declare const gitBranchTool: RegisteredTool;
+declare const taskOutputTool: RegisteredTool;
+declare const taskStopTool: RegisteredTool;
+declare const COMPAT_TOOL_ALIASES: Record<string, string>;
+declare function canonicalizeToolName(toolName: string): string;
+declare function createToolAlias(alias: string, target: RegisteredTool, description?: string): RegisteredTool;
+declare const SDK_DEFAULT_MAX_TOKENS = 8192;
+declare const SDK_DEFAULT_MAX_ITERATIONS = 50;
+interface CreateXenoAgentOptions {
+    cwd?: string;
+    apiKey?: string;
+    baseURL?: string;
+    model?: string;
+    maxTokens?: number;
+    maxIterations?: number;
+    requesterLabel?: string;
+    executionMode?: ExecutionMode;
+    role?: string;
+    sessionId?: string;
+    date?: string;
+    systemPrompt?: string;
+    promptMemory?: string;
+    permissionConfig?: Partial<PermissionConfig>;
+    permissionEngine?: PermissionEngine;
+    toolRegistry?: ToolRegistry;
+    askUser?: AskUserHandler;
+    dispatchAgent?: DispatchAgentHandler;
+    webSearchApiKey?: string;
+    validateToolInputs?: boolean;
+    sandbox?: AgentSandbox;
+    onPermissionRequest?: (context: PermissionRequestContext) => Promise<PermissionRequestResult> | PermissionRequestResult;
+    session?: SessionIntegrationConfig;
+    identity?: false | {
+        globalDir?: string;
+        resolved?: ResolvedIdentity;
+    };
+    memory?: false | {
+        globalDir?: string;
+        sessionDir?: string;
+        budgets?: Partial<MemoryBudget>;
+        includeProjectSessionContext?: boolean;
+        excludeSessionId?: string;
+        projectSessionContext?: MemoryManagerOptions["projectSessionContext"];
+    };
+    onText?: AgentLoopConfig["onText"];
+    onToolStart?: AgentLoopConfig["onToolStart"];
+    onToolWillExecute?: AgentLoopConfig["onToolWillExecute"];
+    onToolEnd?: AgentLoopConfig["onToolEnd"];
+    onIteration?: AgentLoopConfig["onIteration"];
+    onError?: AgentLoopConfig["onError"];
+    onTranscriptError?: AgentLoopConfig["onTranscriptError"];
+    onRuntimeEvent?: XenoRuntimeEventSink;
+    runtimeEventBus?: XenoRuntimeEventBus;
+    turnDiffTracker?: TurnDiffTracker;
+    onModeSwitchRequest?: AgentLoopConfig["onModeSwitchRequest"];
+    onExecutionModeChanged?: AgentLoopConfig["onExecutionModeChanged"];
+    completionGuard?: AgentLoopConfig["completionGuard"];
+    maxCompletionGuardReminders?: AgentLoopConfig["maxCompletionGuardReminders"];
+    progressGuardEveryIterations?: AgentLoopConfig["progressGuardEveryIterations"];
+    toolMiddleware?: ToolMiddleware[];
+    promptSections?: PromptSectionProvider[];
+    promptSectionsTokenBudget?: number;
+    completionGuards?: CompletionGuard[];
+    provider?: LLMProvider;
+}
+interface CreateXenoAgentResult {
+    agent: AgentLoop;
+    systemPrompt: string;
+    permissionEngine: PermissionEngine;
+    toolRegistry: ToolRegistry;
+    identity?: ResolvedIdentity;
+    memory?: {
+        resolved: ResolvedMemory;
+        projectSessionContext?: ProjectSessionContext;
+        prompt: string;
+    };
+}
+declare function createXenoAgent(options?: CreateXenoAgentOptions): Promise<CreateXenoAgentResult>;
+interface XenoThreadRunOptions extends CreateXenoAgentOptions {
+    prompt: string;
+    captureTraceGraph?: boolean;
+}
+interface XenoThreadRunResult {
+    output: string;
+    events: XenoRuntimeEvent[];
+    traceGraph?: TraceGraph;
+    tokenUsage: {
+        input: number;
+        output: number;
+        total: number;
+    };
+}
+declare function runXenoThread(options: XenoThreadRunOptions): Promise<XenoThreadRunResult>;
+declare function runXenoThreadStreamed(options: XenoThreadRunOptions): AsyncGenerator<XenoRuntimeEvent, XenoThreadRunResult, void>;
+interface XenoAppServerOptions {
+    defaultAgentOptions?: Omit<XenoThreadRunOptions, "prompt">;
+}
+declare class XenoAppServer {
+    private readonly options;
+    private stopping;
+    constructor(options?: XenoAppServerOptions);
+    start(input?: Readable, output?: Writable): Promise<void>;
+    stop(): void;
+    private handleRequest;
+    private success;
+    private error;
+    private write;
+}
+declare function generateSessionId(role?: string): string;
+declare function parseSessionId(id: string): {
+    role: string;
+    timestamp: string;
+    random: string;
+} | null;
+declare function isValidSessionId(id: string): boolean;
+declare class SessionLock {
+    private sessionDir;
+    private lockPath;
+    private sessionId;
+    private heartbeatTimer?;
+    constructor(sessionDir: string);
+    acquire(): Promise<void>;
+    release(): Promise<void>;
+    isLocked(): Promise<boolean>;
+    isStale(): Promise<boolean>;
+    startHeartbeat(interval?: number): void;
+    stopHeartbeat(): void;
+    private updateHeartbeat;
+    private readLock;
+    static cleanStale(sessionsDir: string): Promise<string[]>;
+}
+declare class SessionRegistry {
+    static getSessionsDir(): string;
+    static list(options?: {
+        status?: SessionStatus[];
+        role?: string;
+        workingDirectory?: string;
+        limit?: number;
+    }): Promise<SessionMeta[]>;
+    static find(sessionId: string): Promise<SessionMeta | null>;
+    static findMostRecent(roleOrOptions?: string | {
+        role?: string;
+        workingDirectory?: string;
+    }): Promise<SessionMeta | null>;
+    static delete(sessionId: string): Promise<void>;
+    static purgeWorkingDirectory(workingDirectory: string, options?: {
+        excludeSessionIds?: string[];
+    }): Promise<{
+        deletedIds: string[];
+        skippedIds: string[];
+    }>;
+    static updateMeta(sessionId: string, partial: Partial<SessionMeta>): Promise<SessionMeta>;
+    private static loadMeta;
+    static getSessionDir(sessionId: string): string;
+    private static normalizeWorkingDirectory;
+    private static deleteWorkspaceMirror;
+}
+interface RecentSessionEntry {
+    sessionId: string;
+    role?: string;
+    endedAt: string;
+}
+interface RecentSessionsIndex {
+    version: 1;
+    entries: Record<string, RecentSessionEntry>;
+}
+declare function getRecentSessionsIndexPath(homeDir?: string): string;
+declare function normalizeWorkingDirectory(dir: string): string;
+declare function loadRecentSessionsIndex(homeDir?: string): Promise<RecentSessionsIndex>;
+declare function lookupRecentSession(cwd: string, options?: {
+    homeDir?: string;
+    role?: string;
+}): Promise<RecentSessionEntry | undefined>;
+declare function recordRecentSession(input: {
+    cwd: string;
+    sessionId: string;
+    role?: string;
+    endedAt?: string;
+}, options?: {
+    homeDir?: string;
+}): Promise<void>;
+declare function forgetRecentSession(cwd: string, options?: {
+    homeDir?: string;
+}): Promise<void>;
+declare function forgetRecentSessionById(sessionId: string, options?: {
+    homeDir?: string;
+}): Promise<void>;
+interface TurnRestoreCreateOptions {
+    id?: string;
+    restoreMessageCount: number;
+    userPrompt: string;
+}
+interface TurnRestoreMutation {
+    relativePath: string;
+    existedBefore: boolean;
+    backupFile?: string;
+}
+interface TurnRestorePoint {
+    id: string;
+    createdAt: string;
+    restoreMessageCount: number;
+    userPrompt: string;
+    mutations: TurnRestoreMutation[];
+    unsupportedTools: string[];
+}
+interface TurnRestoreAvailability {
+    points: TurnRestorePoint[];
+    hadRestorePoints: boolean;
+    exactWorkspaceRestore: boolean;
+    unsupportedTools: string[];
+}
+interface TurnRestoreResult extends TurnRestoreAvailability {
+    restoredFiles: number;
+    removedFiles: number;
+}
+declare class TurnRestoreManager {
+    private readonly sessionDir;
+    private readonly workspaceDir;
+    private readonly restoreRoot;
+    private operationQueue;
+    constructor(sessionDir: string, workspaceDir: string);
+    create(options: TurnRestoreCreateOptions): Promise<TurnRestorePoint>;
+    recordToolExecution(pointId: string, toolName: string, input: Record<string, unknown>): Promise<void>;
+    restoreAtOrAfter(restoreMessageCount: number): Promise<TurnRestoreResult>;
+    deleteAtOrAfter(restoreMessageCount: number): Promise<void>;
+    inspectAtOrAfter(restoreMessageCount: number): Promise<TurnRestoreAvailability>;
+    findByRestoreMessageCount(restoreMessageCount: number): Promise<TurnRestorePoint | null>;
+    private captureFileMutation;
+    private markUnsupportedTool;
+    private inspectAtOrAfterInternal;
+    private listPointsAtOrAfter;
+    private loadPoint;
+    private savePoint;
+    private pruneEmptyParentDirs;
+    private getRestoreDir;
+    private getBackupPath;
+    private enqueue;
+}
+type ImageLayerType = "raster" | "vector" | "adjustment";
+interface ImageLayerInfo {
+    id: string;
+    name: string;
+    visible: boolean;
+    type: ImageLayerType;
+}
+interface ActiveLayerInfo {
+    id: string;
+    name: string;
+    type: string;
+}
+interface ImageDocumentInfo {
+    width: number;
+    height: number;
+    layers: number;
+    colorSpace: string;
+}
+interface ImageToolAdapter {
+    createLayer(name: string, type: ImageLayerType): Promise<string>;
+    deleteLayer(layerId: string): Promise<void>;
+    setActiveLayer(layerId: string): Promise<void>;
+    getActiveLayer(): Promise<ActiveLayerInfo>;
+    getLayers(): Promise<ImageLayerInfo[]>;
+    applyFilter(name: string, params: Record<string, number>): Promise<void>;
+    setTool(toolName: string): Promise<void>;
+    setBrushSize(size: number): Promise<void>;
+    setColor(color: string): Promise<void>;
+    removeBackground(): Promise<void>;
+    upscale(factor: number): Promise<void>;
+    denoise(): Promise<void>;
+    exportImage(format: string, quality: number, path: string): Promise<void>;
+    getDocumentInfo(): Promise<ImageDocumentInfo>;
+}
+interface TranscriptionSegment {
+    start: number;
+    end: number;
+    text: string;
+}
+interface TranscriptionResult {
+    segments: TranscriptionSegment[];
+}
+interface StemSeparationResult {
+    trackIds: string[];
+}
+interface TimelineInfo {
+    duration: number;
+    tracks: number;
+    fps: number;
+}
+interface VideoToolAdapter {
+    addClip(trackId: string, mediaPath: string, startFrame: number): Promise<string>;
+    removeClip(clipId: string): Promise<void>;
+    setPlayhead(frame: number): Promise<void>;
+    play(): Promise<void>;
+    pause(): Promise<void>;
+    addEffect(clipId: string, effectType: string, params: Record<string, number>): Promise<void>;
+    transcribeClip(clipId: string): Promise<TranscriptionResult>;
+    separateStems(clipId: string): Promise<StemSeparationResult>;
+    exportVideo(config: Record<string, unknown>): Promise<void>;
+    getTimelineInfo(): Promise<TimelineInfo>;
+}
+type AudioTrackType = "audio" | "pattern";
+interface AudioTranscriptionSegment {
+    start: number;
+    end: number;
+    text: string;
+}
+interface AudioTranscriptionResult {
+    segments: AudioTranscriptionSegment[];
+}
+interface AudioStemSeparationResult {
+    trackIds: string[];
+}
+interface AudioProjectInfo {
+    bpm: number;
+    timeSignature: string;
+    tracks: number;
+    duration: number;
+}
+interface AudioToolAdapter {
+    addTrack(name: string, type: AudioTrackType): Promise<string>;
+    removeTrack(trackId: string): Promise<void>;
+    setVolume(trackId: string, volume: number): Promise<void>;
+    setPan(trackId: string, pan: number): Promise<void>;
+    muteTrack(trackId: string, muted: boolean): Promise<void>;
+    soloTrack(trackId: string, soloed: boolean): Promise<void>;
+    addEffect(trackId: string, effectType: string): Promise<void>;
+    setBPM(bpm: number): Promise<void>;
+    denoise(trackId: string): Promise<void>;
+    separateStems(trackId: string): Promise<AudioStemSeparationResult>;
+    transcribe(trackId: string): Promise<AudioTranscriptionResult>;
+    exportAudio(format: string, options: Record<string, unknown>): Promise<void>;
+    getProjectInfo(): Promise<AudioProjectInfo>;
+}
+declare function createImageTools(adapter: ImageToolAdapter): RegisteredTool[];
+declare function createVideoTools(adapter: VideoToolAdapter): RegisteredTool[];
+declare function createAudioTools(adapter: AudioToolAdapter): RegisteredTool[];
+type AppType = "pixel" | "motion" | "sound";
+interface DocumentContext {
+    name: string;
+    path?: string;
+    modified: boolean;
+}
+interface LayerContext {
+    id: string;
+    name: string;
+    type: string;
+}
+interface ClipContext {
+    id: string;
+    name: string;
+    type: string;
+}
+interface TrackContext {
+    id: string;
+    name: string;
+}
+interface CanvasSize {
+    width: number;
+    height: number;
+}
+interface AppContext {
+    app: AppType;
+    document?: DocumentContext;
+    activeLayer?: LayerContext;
+    selectedTool?: string;
+    canvasSize?: CanvasSize;
+    currentFrame?: number;
+    selectedClip?: ClipContext;
+    timelineLength?: number;
+    bpm?: number;
+    currentPosition?: number;
+    selectedTrack?: TrackContext;
+    isRecording?: boolean;
+}
+type AppContextProvider = () => AppContext;
+declare class AppContextManager {
+    private provider;
+    setProvider(provider: AppContextProvider): void;
+    getContext(): AppContext;
+    formatForPrompt(): string;
+}
+interface ScreenCaptureConfig {
+    maxWidth: number;
+    quality: number;
+    format: "jpeg" | "png";
+}
+interface ImageContentBlock {
+    type: "image";
+    source: {
+        type: "base64";
+        media_type: string;
+        data: string;
+    };
+}
+declare class ScreenCapture {
+    private config;
+    constructor(config?: Partial<ScreenCaptureConfig>);
+    captureWindow(): Promise<string>;
+    captureElement(element: unknown): Promise<string>;
+    formatForLLM(base64: string, mimeType: string): ImageContentBlock;
+    getMimeType(): string;
+    private getDesktopCapturer;
+    private encodeThumbnail;
+    private isCanvasElement;
+    private canvasToBase64;
+}
+declare function isScreenCaptureAvailable(): boolean;
+interface ProjectInfo {
+    name: string;
+    language: string;
+    framework?: string;
+    packageManager?: string;
+    fileCount: number;
+    dependencies: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    scripts?: Record<string, string>;
+    workspaces?: string[];
+    git?: {
+        branch: string;
+        remoteUrl?: string;
+    };
+    projectType?: "library" | "application" | "monorepo" | "cli" | "api";
+}
+interface FileEntry {
+    path: string;
+    extension: string;
+    size: number;
+    language: string;
+    modifiedAt?: number;
+}
+interface DependencyEdge {
+    from: string;
+    to: string;
+    type: "import" | "require" | "use";
+}
+interface WorkspaceScanOptions {
+    maxFiles?: number;
+    maxDepth?: number;
+    excludePatterns?: string[];
+    buildDependencyGraph?: boolean;
+}
+declare class WorkspaceIndex {
+    private cwd;
+    private files;
+    private dependencies;
+    private projectInfo;
+    private scanned;
+    constructor(cwd: string);
+    scan(options?: WorkspaceScanOptions): Promise<void>;
+    getProjectInfo(): ProjectInfo | null;
+    getFiles(): FileEntry[];
+    getFilesByLanguage(language: string): FileEntry[];
+    getFilesByExtension(ext: string): FileEntry[];
+    getDependencies(): DependencyEdge[];
+    getLanguageDistribution(): Record<string, number>;
+    getSummary(): string;
+    get isScanned(): boolean;
+    private walkDirectory;
+    private detectProjectInfo;
+    private buildDependencyGraph;
+    private resolveRelativeImport;
+}
+interface PermissionInfo {
+    toolName: string;
+    input: unknown;
+    riskLevel: "low" | "medium" | "high";
+}
+interface AgentStreamCallbacks {
+    onText: (text: string) => void;
+    onToolStart: (name: string, input: unknown) => void;
+    onToolEnd: (name: string, result: unknown) => void;
+    onComplete: () => void;
+    onError: (error: Error) => void;
+}
+interface ElectronAgentConfig {
+    apiKey: string;
+    baseURL: string;
+    model: string;
+    app: AppType;
+    tools: RegisteredTool[];
+    appContext: () => AppContext;
+    onPermissionRequest?: (info: PermissionInfo) => Promise<"allow" | "deny">;
+    maxTokens?: number;
+    maxIterations?: number;
+}
+declare class ElectronAgentBridge {
+    private agent;
+    private readonly contextManager;
+    private readonly config;
+    private readonly toolRegistry;
+    private readonly permissionEngine;
+    private pendingPermissions;
+    constructor(config: ElectronAgentConfig);
+    private buildSystemPrompt;
+    sendMessage(text: string, callbacks: AgentStreamCallbacks): Promise<void>;
+    cancel(): boolean;
+    getHistory(): Message[];
+    clearHistory(): void;
+    updateContext(): void;
+    respondToPermission(id: string, decision: "allow" | "deny"): void;
+    getAgentLoop(): AgentLoop;
+    getContextManager(): AppContextManager;
+    getToolRegistry(): ToolRegistry;
+}
+interface PermissionRequestInfo {
+    id: string;
+    toolName: string;
+    input: unknown;
+    riskLevel: "low" | "medium" | "high";
+    description?: string;
+}
+interface AgentToAppMessages {
+    "agent:text": {
+        text: string;
+    };
+    "agent:tool-start": {
+        name: string;
+        input: unknown;
+    };
+    "agent:tool-end": {
+        name: string;
+        result: unknown;
+        success: boolean;
+    };
+    "agent:complete": Record<string, never>;
+    "agent:error": {
+        message: string;
+        code?: string;
+    };
+    "agent:permission-request": PermissionRequestInfo;
+}
+interface AppToAgentMessages {
+    "agent:send-message": {
+        text: string;
+    };
+    "agent:cancel": Record<string, never>;
+    "agent:clear": Record<string, never>;
+    "agent:permission-response": {
+        id: string;
+        decision: "allow" | "deny";
+    };
+}
+type AgentToAppChannel = keyof AgentToAppMessages;
+type AppToAgentChannel = keyof AppToAgentMessages;
+type AgentIpcChannel = AgentToAppChannel | AppToAgentChannel;
+type IpcHandler<C extends string, M extends Record<string, unknown>> = C extends keyof M ? (payload: M[C]) => void : never;
+type DualLLMMode = "auto" | "local" | "cloud";
+interface ChatParams {
+    messages: Array<{
+        role: "system" | "user" | "assistant";
+        content: string;
+    }>;
+    model?: string;
+    maxTokens?: number;
+    temperature?: number;
+    systemPrompt?: string;
+    jsonMode?: boolean;
+    stop?: string[];
+}
+interface ChatResponse {
+    success: boolean;
+    content: string;
+    endpoint: "local" | "cloud";
+    model: string;
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    error?: string;
+}
+interface DualLLMStatus {
+    mode: DualLLMMode;
+    localAvailable: boolean;
+    activeEndpoint: "local" | "cloud";
+    localModel?: string;
+    localUrl: string;
+    cloudUrl: string;
+}
+interface DualLLMProviderConfig {
+    localUrl?: string;
+    cloudUrl?: string;
+    cloudApiKey?: string;
+    mode?: DualLLMMode;
+    localModel?: string;
+    cloudModel?: string;
+}
+declare class DualLLMProvider {
+    private localUrl;
+    private cloudUrl;
+    private cloudApiKey;
+    private mode;
+    private defaultLocalModel;
+    private defaultCloudModel;
+    private localAvailable;
+    private localModelName;
+    private lastHealthCheck;
+    constructor(config?: DualLLMProviderConfig);
+    chat(params: ChatParams): Promise<ChatResponse>;
+    chatStream(params: ChatParams): AsyncGenerator<string>;
+    isLocalAvailable(forceRefresh?: boolean): Promise<boolean>;
+    setMode(mode: DualLLMMode): void;
+    getMode(): DualLLMMode;
+    setLocalUrl(url: string): void;
+    setCloudApiKey(apiKey: string): void;
+    getStatus(): Promise<DualLLMStatus>;
+    asLLMProvider(options?: {
+        id?: string;
+        model?: string;
+    }): LLMProvider;
+    private shouldUseLocal;
+    private chatLocal;
+    private chatCloud;
+}
+type IpcHandleFunction = (channel: string, handler: (event: unknown, ...args: unknown[]) => unknown) => void;
+interface SetupAIHandlersOptions {
+    ipcHandle?: IpcHandleFunction;
+    config?: DualLLMProviderConfig;
+    provider?: DualLLMProvider;
+}
+declare function setupAIHandlers(options?: SetupAIHandlersOptions): DualLLMProvider;
+declare function readXenoApiKey(): string | undefined;
+interface CrossAppMessage {
+    id: string;
+    sourceApp: string;
+    targetApp: string;
+    action: string;
+    params: Record<string, unknown>;
+    timestamp: string;
+}
+type CrossAppHandler = (message: CrossAppMessage) => Promise<unknown>;
+interface CrossAppRouterOptions {
+    timeoutMs?: number;
+}
+declare class CrossAppRouterError extends Error {
+    readonly targetApp: string;
+    readonly action: string;
+    constructor(message: string, targetApp: string, action: string);
+}
+declare class CrossAppRouter {
+    private handlers;
+    private readonly timeoutMs;
+    constructor(options?: CrossAppRouterOptions);
+    register(app: string, handler: CrossAppHandler): void;
+    unregister(app: string): boolean;
+    isRegistered(app: string): boolean;
+    listApps(): string[];
+    sendToApp(targetApp: string, action: string, params: Record<string, unknown>, sourceApp?: string): Promise<unknown>;
+    broadcast(action: string, params: Record<string, unknown>, sourceApp?: string): Promise<Map<string, unknown>>;
+}
+type AgentSelectionStrategy = "first" | "least-loaded" | "round-robin";
+interface AgentCard {
+    id: string;
+    name: string;
+    description?: string;
+    capabilities: string[];
+    maxConcurrentTasks?: number;
+    handler: AgentTaskHandler;
+}
+interface AgentTeam {
+    id: string;
+    name: string;
+    description?: string;
+    agentIds: string[];
+    strategy?: AgentSelectionStrategy;
+}
+interface AgentLoadSnapshot {
+    agentId: string;
+    agentName: string;
+    activeTasks: number;
+    maxConcurrentTasks: number;
+    availableSlots: number;
+    isAvailable: boolean;
+}
+interface AgentTask {
+    id: string;
+    type: string;
+    description: string;
+    input: Record<string, unknown>;
+    priority?: "low" | "normal" | "high" | "critical";
+    createdAt: string;
+    status: AgentTaskStatus;
+    assignedTo?: string;
+    createdBy?: string;
+    parentTaskId?: string;
+    timeoutMs?: number;
+}
+type AgentTaskStatus = "pending" | "assigned" | "running" | "completed" | "failed" | "cancelled" | "timeout";
+interface AgentTaskResult {
+    taskId: string;
+    status: "completed" | "failed" | "cancelled";
+    result: unknown;
+    error?: string;
+    artifacts?: AgentArtifact[];
+    durationMs?: number;
+}
+interface AgentArtifact {
+    name: string;
+    mimeType?: string;
+    content: string;
+}
+type AgentTaskHandler = (task: AgentTask) => Promise<AgentTaskResult>;
+type A2AMessageType = "task-request" | "task-accepted" | "task-rejected" | "task-progress" | "task-completed" | "task-failed" | "capability-query" | "capability-response";
+interface A2AMessage {
+    id: string;
+    type: A2AMessageType;
+    from: string;
+    to: string;
+    payload: Record<string, unknown>;
+    timestamp: string;
+    correlationId?: string;
+}
+interface AgentDispatchOptions {
+    timeoutMs?: number;
+    priority?: AgentTask["priority"];
+    parentTaskId?: string;
+    createdBy?: string;
+    waitForCapacity?: boolean;
+    maxQueueWaitMs?: number;
+}
+interface AgentCapabilityDispatchOptions extends AgentDispatchOptions {
+    strategy?: AgentSelectionStrategy;
+    teamId?: string;
+}
+declare class AgentRegistry {
+    private agents;
+    private teams;
+    registerAgent(card: AgentCard): void;
+    unregisterAgent(id: string): boolean;
+    getAgent(id: string): AgentCard | undefined;
+    findByCapability(capability: string): AgentCard[];
+    listAgents(): AgentCard[];
+    registerTeam(team: AgentTeam): void;
+    unregisterTeam(id: string): boolean;
+    getTeam(id: string): AgentTeam | undefined;
+    listTeams(): AgentTeam[];
+    listAgentsForTeam(teamId: string): AgentCard[];
+    get size(): number;
+}
+declare class AgentProtocol {
+    private registry;
+    private messageLog;
+    private activeTasks;
+    private activeTasksByAgent;
+    private capabilityRoundRobinCursor;
+    constructor(registry: AgentRegistry);
+    private getAgentCapacity;
+    private getAgentActiveTaskCount;
+    private isAgentAvailable;
+    private reserveAgentTask;
+    private releaseAgentTask;
+    private waitForAgentCapacity;
+    private getCapabilityCandidates;
+    private compareAgentLoad;
+    private selectAgentForCapability;
+    getAgentLoad(agentId: string): AgentLoadSnapshot | undefined;
+    listAgentLoads(options?: {
+        capability?: string;
+        teamId?: string;
+    }): AgentLoadSnapshot[];
+    delegateTask(agentId: string, taskSpec: {
+        type: string;
+        description: string;
+        input: Record<string, unknown>;
+    }, options?: AgentDispatchOptions): Promise<AgentTaskResult>;
+    delegateByCapability(capability: string, taskSpec: {
+        description: string;
+        input: Record<string, unknown>;
+    }, options?: AgentCapabilityDispatchOptions): Promise<AgentTaskResult>;
+    delegateToTeam(teamId: string, taskSpec: {
+        type: string;
+        description: string;
+        input: Record<string, unknown>;
+    }, options?: Omit<AgentCapabilityDispatchOptions, "teamId">): Promise<AgentTaskResult>;
+    getMessageLog(limit?: number): A2AMessage[];
+    getActiveTasks(): AgentTask[];
+    private logMessage;
+}
+declare const PIXEL_SYSTEM_PROMPT = "You are an AI assistant embedded in XENO Pixel, a professional image editor.\n\nYou can manipulate layers, apply filters, run AI models (background removal, upscaling, denoising, style transfer), and control tools like the brush, eraser, selection, and transform tools.\n\nWhen the user asks you to edit their image, use the available tools to make precise changes. Always confirm destructive operations (deleting layers, flattening, resizing the canvas) before executing them.\n\nPrefer non-destructive workflows: use adjustment layers, masks, and smart objects when possible. Explain what you are doing in concise terms so the user understands the changes.\n\n{context}\n\nAvailable tools: {toolList}";
+interface PixelPromptParams {
+    context: string;
+    toolList: string;
+}
+declare function buildPixelSystemPrompt(params: PixelPromptParams): string;
+declare const MOTION_SYSTEM_PROMPT = "You are an AI assistant embedded in XENO Motion, a professional video editor.\n\nYou can manipulate the timeline, cut and arrange clips, apply effects and transitions, run AI models (transcription, stem separation, object tracking, scene detection), and control playback.\n\nWhen the user asks you to edit their video, use the available tools to make precise changes. Always confirm destructive operations (deleting clips, clearing tracks, removing effects) before executing them.\n\nPrefer non-destructive workflows: use adjustment layers and effect stacks that can be toggled or modified later. When working with audio, coordinate with XENO Sound if cross-app communication is available.\n\n{context}\n\nAvailable tools: {toolList}";
+interface MotionPromptParams {
+    context: string;
+    toolList: string;
+}
+declare function buildMotionSystemPrompt(params: MotionPromptParams): string;
+declare const SOUND_SYSTEM_PROMPT = "You are an AI assistant embedded in XENO Sound, a professional audio editor and digital audio workstation (DAW).\n\nYou can manipulate tracks, apply audio effects (EQ, compression, reverb, delay), run AI models (transcription, stem separation, noise reduction, mastering), control recording, and manage the mixer.\n\nWhen the user asks you to edit their audio, use the available tools to make precise changes. Always confirm destructive operations (deleting tracks, clearing regions, bouncing/flattening) before executing them.\n\nPrefer non-destructive workflows: use effect chains that can be bypassed or reordered, and region-based editing rather than destructive waveform modification. When exporting audio for use in XENO Motion, coordinate via cross-app communication if available.\n\n{context}\n\nAvailable tools: {toolList}";
+interface SoundPromptParams {
+    context: string;
+    toolList: string;
+}
+declare function buildSoundSystemPrompt(params: SoundPromptParams): string;
+declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3,
+    SILENT = 4
+}
+declare function setLogLevel(level: LogLevel): void;
+declare function getLogLevel(): LogLevel;
+declare function calculateCost(model: string, inputTokens: number, outputTokens: number): number;
+declare function formatCost(cost: number): string;
+declare function copyTextToClipboard(text: string): void;
+interface JsonSchemaValidationError {
+    path: string;
+    message: string;
+}
+interface JsonSchemaValidationResult {
+    valid: boolean;
+    errors: JsonSchemaValidationError[];
+}
+interface JsonSchemaSubset {
+    type?: JsonSchemaType | JsonSchemaType[];
+    enum?: unknown[];
+    required?: string[];
+    properties?: Record<string, unknown>;
+    items?: unknown;
+    additionalProperties?: boolean;
+    [keyword: string]: unknown;
+}
+type JsonSchemaType = "string" | "number" | "integer" | "boolean" | "array" | "object" | "null";
+declare function validateJsonSchema(value: unknown, schema: JsonSchemaSubset | null | undefined): JsonSchemaValidationResult;
+declare function formatJsonSchemaErrors(errors: JsonSchemaValidationError[]): string;
+interface CreateDelegatedXenoAgentOptions extends Omit<CreateXenoAgentOptions, "identity" | "memory" | "systemPrompt" | "requesterLabel" | "executionMode"> {
+    parentSystemPrompt: string;
+    parentExecutionMode: ExecutionMode;
+    subagentRole: SubagentRole;
+}
+declare function createDelegatedXenoAgent(options: CreateDelegatedXenoAgentOptions): Promise<CreateXenoAgentResult>;
+interface TokenUsageTotals {
+    input: number;
+    output: number;
+    total: number;
+}
+interface DelegatedBranchAgent {
+    lastTraceId: string | null;
+    tokenUsage: TokenUsageTotals;
+    run(prompt: string): Promise<string>;
+}
+interface DelegatedBranchAgentCallbacks {
+    onIteration?: (iteration: number, totalTokens: number) => void | Promise<void>;
+    onToolStart?: (name: string, input: Record<string, unknown>) => void | Promise<void>;
+    onToolWillExecute?: (name: string, input: Record<string, unknown>) => void | Promise<void>;
+    onToolEnd?: (name: string, result: ToolResult) => void | Promise<void>;
+}
+interface CreateDelegatedBranchAgentOptions extends DelegatedBranchAgentCallbacks {
+    task: SubagentExecutionRequest;
+}
+type CreateDelegatedBranchAgent = (options: CreateDelegatedBranchAgentOptions) => Promise<DelegatedBranchAgent>;
+interface RunDelegatedXenoTurnOptions extends DelegatedBranchAgentCallbacks {
+    userPrompt: string;
+    cwd: string;
+    apiKey?: string;
+    baseURL?: string;
+    model: string;
+    maxIterations: number;
+    maxTotalTokens: number;
+    timeoutMs: number;
+    rolePrecedence?: string[];
+    branchPolicy?: Partial<SubagentBranchPolicy>;
+    parentSystemPrompt: string;
+    parentExecutionMode: ExecutionMode;
+    permissionEngine?: PermissionEngine;
+    createToolRegistry?: () => ToolRegistry;
+    auditLogger?: AuditLogger;
+    rootTraceId?: string;
+    skipAuditCompletion?: boolean;
+    createBranchAgent?: CreateDelegatedBranchAgent;
+    onBranchStart?: (task: SubagentExecutionRequest) => void | Promise<void>;
+    onBranchComplete?: (task: SubagentExecutionRequest, result: {
+        output: string;
+        traceId: string | null;
+        tokenUsage: TokenUsageTotals;
+    }) => void | Promise<void>;
+    onBranchError?: (task: SubagentExecutionRequest, error: unknown, result: {
+        tokenUsage: TokenUsageTotals;
+    }) => void | Promise<void>;
+}
+interface DelegatedXenoTurnResult {
+    answer: string;
+    workflow: SubagentWorkflowResult;
+    summary: ReturnType<typeof summarizeSubagentResults>;
+    tokenUsage: TokenUsageTotals;
+    rootTraceId: string;
+    selectedTraceId: string;
+}
+declare function runDelegatedXenoTurn(options: RunDelegatedXenoTurnOptions): Promise<DelegatedXenoTurnResult>;
+interface ToolManifestEntry {
+    name: string;
+    description: string;
+    inputFields: string[];
+    requiredFields: string[];
+}
+interface RuntimePluginManifestEntry {
+    name: string;
+    version: string;
+    status: string;
+    path: string;
+    capabilities: string[];
+    permissions: string[];
+    entryPoint?: string;
+    error?: string;
+}
+interface RuntimeManifestFileEntry {
+    path: string;
+    exists: boolean;
+}
+interface RuntimeManifestInspectionResult {
+    cwd: string;
+    toolCount: number;
+    tools: ToolManifestEntry[];
+    pluginDir: string;
+    pluginRegistryPath: string;
+    pluginCount: number;
+    plugins: RuntimePluginManifestEntry[];
+    projectFiles: RuntimeManifestFileEntry[];
+}
+interface InspectSystemPromptOptions {
+    cwd?: string;
+    model?: string;
+    date?: string;
+    role?: string;
+    executionMode?: ExecutionMode;
+    sessionId?: string;
+    promptMemory?: string;
+    identity?: CreateXenoAgentOptions["identity"];
+    memory?: CreateXenoAgentOptions["memory"];
+}
+interface SystemPromptInspectionResult {
+    cwd: string;
+    model: string;
+    date: string;
+    executionMode: ExecutionMode;
+    role?: string;
+    systemPrompt: string;
+    toolNames: string[];
+    projectConfig: ReturnType<typeof loadProjectConfig>;
+    identity?: CreateXenoAgentResult["identity"];
+    memory?: CreateXenoAgentResult["memory"];
+}
+declare function inspectRuntimeManifests(options?: {
+    cwd?: string;
+    pluginDir?: string;
+}): RuntimeManifestInspectionResult;
+declare function inspectSystemPrompt(options?: InspectSystemPromptOptions): Promise<SystemPromptInspectionResult>;
+declare function auditRiskLevelForTool(toolName: string): "low" | "medium" | "high";
+declare function summarizeAuditInputRecord(input: Record<string, unknown>): Record<string, unknown>;
+interface CreateAuditBackedPermissionEngineOptions {
+    mode: PermissionConfig["mode"];
+    rules?: PermissionConfig["rules"];
+    promptFn?: PermissionPromptFn;
+    auditLogger?: AuditLogger;
+    fallbackTraceId?: string;
+    cwd?: string;
+}
+declare function createAuditBackedPermissionEngine(options: CreateAuditBackedPermissionEngineOptions): PermissionEngine;
+interface PromptMemoryContextInfo {
+    merged?: string;
+    memoryTokens: number;
+    sessionHistoryTokens: number;
+    sessionHistoryEntries: number;
+    totalTokens: number;
+}
+declare function formatPromptContextBreakdown(info: PromptMemoryContextInfo): string;
+declare function buildPromptMemoryContext(memoryManager: MemoryManager | undefined, currentSessionId?: string): Promise<PromptMemoryContextInfo>;
+interface SessionRuntimeState {
+    sessionManager?: SessionManager;
+    checkpointManager?: CheckpointManager;
+    memoryManager?: MemoryManager;
+    identityResolver?: IdentityResolver;
+    auditLogger?: AuditLogger;
+    restoredMessages?: Message[];
+    sessionDir?: string;
+    sessionHistoryPath?: string;
+    turnRestoreManager?: TurnRestoreManager | null;
+}
+interface SessionRuntimeBaseOptions {
+    cwd: string;
+    role?: string;
+    model: string;
+    projectSessionContext?: MemoryManagerOptions["projectSessionContext"];
+    identityGlobalDir?: string;
+    loadRestorableMessages?: (sessionId: string, checkpoint?: string) => Promise<Message[]>;
+}
+interface InitializeSessionRuntimeOptions extends SessionRuntimeBaseOptions {
+    resume?: string | boolean;
+    checkpoint?: string;
+}
+declare function initializeSessionRuntime(options: InitializeSessionRuntimeOptions): Promise<SessionRuntimeState>;
+declare function activateSessionRuntime(state: SessionRuntimeState, options: SessionRuntimeBaseOptions): Promise<SessionRuntimeState>;
+declare function cleanupSessionRuntime(state: SessionRuntimeState, status?: "completed" | "abandoned"): Promise<void>;
+type AppId = "pixel" | "motion" | "sound";
+interface StoredToolCall {
+    name: string;
+    input: unknown;
+    result: unknown;
+}
+interface StoredMessage {
+    role: "user" | "assistant";
+    content: string;
+    timestamp: string;
+    toolCalls?: StoredToolCall[];
+}
+interface StoredConversation {
+    id: string;
+    projectPath: string;
+    app: AppId;
+    messages: StoredMessage[];
+    created: string;
+    modified: string;
+    tokenCount: number;
+    model: string;
+}
+declare class ConversationStore {
+    getConversationDir(basePath: string, app: AppId): string;
+    getConversationPath(conversationId: string, basePath: string, app: AppId): string;
+    save(conversation: StoredConversation, basePath: string): void;
+    load(conversationId: string, basePath: string): StoredConversation | null;
+    list(basePath: string, app?: AppId): StoredConversation[];
+    delete(conversationId: string, basePath: string): void;
+    autoSave(conversation: StoredConversation, basePath: string, debounceMs?: number): void;
+    flushPending(): void;
+    search(basePath: string, query: string, app?: AppId): StoredConversation[];
+}
+interface SpeechRecognizerConfig {
+    language: string;
+    continuous: boolean;
+    interimResults: boolean;
+    maxDuration: number;
+}
+interface SpeechRecognizerCallbacks {
+    onInterim: (text: string) => void;
+    onFinal: (text: string) => void;
+    onError: (error: string) => void;
+    onStart: () => void;
+    onEnd: () => void;
+}
+interface SpeechRecognizer {
+    start(): void;
+    stop(): void;
+    abort(): void;
+    isListening(): boolean;
+}
+declare function createSpeechRecognizer(config: SpeechRecognizerConfig, callbacks: SpeechRecognizerCallbacks): SpeechRecognizer | null;
+declare function isSpeechRecognitionAvailable(): boolean;
+type MCPTransport = "stdio" | "sse";
+type MCPServerScope = "project" | "mcprc" | "user" | "session";
+type MCPApprovalDecision = "approved" | "denied";
+interface MCPServerConfig {
+    name: string;
+    transport?: MCPTransport;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+    url?: string;
+    headers?: Record<string, string>;
+    approvalRequired?: boolean;
+    scope?: MCPServerScope;
+    sourcePath?: string;
+    approvalKey?: string;
+    approvalState?: MCPApprovalDecision;
+    disabled?: boolean;
+}
+interface MCPServerState {
+    config: MCPServerConfig;
+    status: "connecting" | "ready" | "error" | "disconnected";
+    tools: MCPTool[];
+    prompts?: MCPPrompt[];
+    resources?: MCPResource[];
+    capabilities?: MCPInitializeResult["capabilities"];
+    error?: string;
+    approvalState?: MCPApprovalDecision;
+    subscribedResources?: string[];
+}
+interface MCPTool {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    server: string;
+}
+interface MCPPrompt {
+    name: string;
+    description: string;
+    arguments?: Array<{
+        name: string;
+        description?: string;
+        required?: boolean;
+    }>;
+    server: string;
+}
+interface MCPResource {
+    uri: string;
+    name?: string;
+    description?: string;
+    mimeType?: string;
+    server: string;
+}
+interface JsonRpcRequest {
+    jsonrpc: "2.0";
+    id: number | string;
+    method: string;
+    params?: Record<string, unknown>;
+}
+interface JsonRpcSuccessResponse {
+    jsonrpc: "2.0";
+    id: number | string;
+    result: unknown;
+}
+interface JsonRpcErrorResponse {
+    jsonrpc: "2.0";
+    id: number | string;
+    error: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+interface JsonRpcNotification {
+    jsonrpc: "2.0";
+    method: string;
+    params?: Record<string, unknown>;
+}
+type JsonRpcResponse = JsonRpcSuccessResponse | JsonRpcErrorResponse;
+type JsonRpcMessage = JsonRpcRequest | JsonRpcResponse | JsonRpcNotification;
+interface MCPInitializeParams {
+    protocolVersion: string;
+    capabilities: {
+        roots?: {
+            listChanged?: boolean;
+        };
+    };
+    clientInfo: {
+        name: string;
+        version: string;
+    };
+}
+interface MCPInitializeResult {
+    protocolVersion: string;
+    capabilities: {
+        tools?: {
+            listChanged?: boolean;
+        };
+        resources?: {
+            subscribe?: boolean;
+            listChanged?: boolean;
+        };
+        prompts?: {
+            listChanged?: boolean;
+        };
+    };
+    serverInfo: {
+        name: string;
+        version: string;
+    };
+}
+interface MCPToolsListResult {
+    tools: Array<{
+        name: string;
+        description?: string;
+        inputSchema: Record<string, unknown>;
+    }>;
+}
+interface MCPPromptsListResult {
+    prompts: Array<{
+        name: string;
+        description?: string;
+        arguments?: Array<{
+            name: string;
+            description?: string;
+            required?: boolean;
+        }>;
+    }>;
+}
+interface MCPPromptGetParams {
+    name: string;
+    arguments?: Record<string, string>;
+}
+interface MCPPromptGetResult {
+    description?: string;
+    messages: Array<{
+        role: "user" | "assistant" | "system";
+        content: string | {
+            type: "text" | "image" | "resource";
+            text?: string;
+            data?: string;
+            mimeType?: string;
+        };
+    }>;
+}
+interface MCPResourcesListResult {
+    resources: Array<{
+        uri: string;
+        name?: string;
+        description?: string;
+        mimeType?: string;
+    }>;
+}
+interface MCPResourceReadParams {
+    uri: string;
+}
+interface MCPResourceReadResult {
+    contents: Array<{
+        uri: string;
+        mimeType?: string;
+        text?: string;
+        blob?: string;
+    }>;
+}
+interface MCPResourceSubscribeParams {
+    uri: string;
+}
+interface MCPResourceUnsubscribeParams {
+    uri: string;
+}
+interface MCPToolCallParams {
+    name: string;
+    arguments?: Record<string, unknown>;
+}
+interface MCPToolCallResult {
+    content: Array<{
+        type: "text" | "image" | "resource";
+        text?: string;
+        data?: string;
+        mimeType?: string;
+    }>;
+    isError?: boolean;
+}
+interface MCPConfigFile {
+    mcpServers: Record<string, Omit<MCPServerConfig, "name" | "scope" | "sourcePath" | "approvalKey">>;
+}
+interface MCPConfiguredServer extends MCPServerConfig {
+    scope: Exclude<MCPServerScope, "session">;
+    sourcePath: string;
+    approvalKey: string;
+    approvalState?: MCPApprovalDecision;
+}
+interface ConnectConfiguredMCPServersOptions {
+    cwd: string;
+    promptForApproval?: (server: MCPConfiguredServer) => Promise<MCPApprovalDecision>;
+}
+interface ConnectConfiguredMCPServersResult {
+    connected: string[];
+    skipped: string[];
+    denied: string[];
+    errors: Array<{
+        name: string;
+        error: string;
+    }>;
+}
+interface MCPServerPromptRegistration {
+    name: string;
+    description?: string;
+    arguments?: Array<{
+        name: string;
+        description?: string;
+        required?: boolean;
+    }>;
+    get?: (args?: Record<string, string>) => Promise<MCPPromptGetResult> | MCPPromptGetResult;
+    result?: MCPPromptGetResult;
+}
+interface MCPServerResourceRegistration {
+    uri: string;
+    name?: string;
+    description?: string;
+    mimeType?: string;
+    read?: () => Promise<MCPResourceReadResult> | MCPResourceReadResult;
+    result?: MCPResourceReadResult;
+}
+interface MCPServerModeOptions {
+    name?: string;
+    version?: string;
+    toolListChanged?: boolean;
+    prompts?: MCPServerPromptRegistration[];
+    resources?: MCPServerResourceRegistration[];
+}
+type MCPServerChangeReason = "connected" | "disconnected" | "tools_changed" | "prompts_changed" | "resources_changed" | "resource_updated" | "error";
+interface MCPServerChangeEvent {
+    serverName: string;
+    reason: MCPServerChangeReason;
+    state: MCPServerState;
+    resourceUri?: string;
+}
+type MCPServerChangeListener = (event: MCPServerChangeEvent) => void | Promise<void>;
+declare class MCPManager {
+    private servers;
+    private nextRequestId;
+    private pendingRequests;
+    private disposed;
+    private changeListeners;
+    onServerStateChanged(listener: MCPServerChangeListener): () => void;
+    addServer(config: MCPServerConfig): Promise<void>;
+    connectConfiguredServers(options: ConnectConfiguredMCPServersOptions): Promise<ConnectConfiguredMCPServersResult>;
+    removeServer(name: string): void;
+    listTools(serverName?: string): MCPTool[];
+    listPrompts(serverName?: string): MCPPrompt[];
+    listResources(serverName?: string): MCPResource[];
+    listServers(): MCPServerState[];
+    loadConfiguredServers(cwd?: string): MCPConfiguredServer[];
+    callTool(serverName: string, toolName: string, input: Record<string, unknown>): Promise<MCPToolCallResult>;
+    getPrompt(serverName: string, promptName: string, input?: Record<string, string>): Promise<MCPPromptGetResult>;
+    readResource(serverName: string, uri: string): Promise<MCPResourceReadResult>;
+    subscribeResource(serverName: string, uri: string): Promise<void>;
+    unsubscribeResource(serverName: string, uri: string): Promise<void>;
+    dispose(): void;
+    static loadConfigFile(cwd?: string): MCPServerConfig[];
+    static loadConfiguredServers(cwd?: string): MCPConfiguredServer[];
+    private createTransport;
+    private discoverServerState;
+    private refreshTools;
+    private refreshPrompts;
+    private refreshResources;
+    private listFromServers;
+    private getReadyServer;
+    private sendRequest;
+    private sendNotification;
+    private handleMessage;
+    private handleNotification;
+    private resolveApprovalDecision;
+    private emitServerStateChanged;
+}
+declare class MCPServer {
+    private toolRegistry;
+    private name;
+    private version;
+    private initialized;
+    private buffer;
+    private running;
+    private prompts;
+    private resources;
+    private resourceSubscriptions;
+    private unsubscribeToolRegistryChange?;
+    constructor(toolRegistry: ToolRegistry, options?: MCPServerModeOptions);
+    start(): void;
+    stop(): void;
+    get isRunning(): boolean;
+    private processBuffer;
+    private handleMessage;
+    private handleNotification;
+    private handleInitialize;
+    private handleToolsList;
+    private handlePromptsList;
+    private handlePromptGet;
+    private handleResourcesList;
+    private handleResourceRead;
+    private handleResourceSubscribe;
+    private handleResourceUnsubscribe;
+    private handleToolCall;
+    private sendResponse;
+    private sendError;
+    private writeMessage;
+    setPrompts(prompts: MCPServerPromptRegistration[]): void;
+    setResources(resources: MCPServerResourceRegistration[]): void;
+    notifyResourceUpdated(uri: string): void;
+    private notifyListChanged;
+}
+type MessageHandler$1 = (message: JsonRpcResponse | JsonRpcNotification) => void;
+type ErrorHandler$1 = (error: Error) => void;
+type CloseHandler$1 = (code: number | null) => void;
+interface MCPTransportConnection {
+    setMessageHandler(handler: MessageHandler$1): void;
+    setErrorHandler(handler: ErrorHandler$1): void;
+    setCloseHandler(handler: CloseHandler$1): void;
+    send(message: JsonRpcRequest | JsonRpcNotification): void | Promise<void>;
+    close(): void;
+    readonly isAlive: boolean;
+}
+declare class StdioTransport implements MCPTransportConnection {
+    private process;
+    private buffer;
+    private onMessage;
+    private onError;
+    private onClose;
+    private closed;
+    constructor(process: ChildProcess);
+    setMessageHandler(handler: MessageHandler$1): void;
+    setErrorHandler(handler: ErrorHandler$1): void;
+    setCloseHandler(handler: CloseHandler$1): void;
+    send(message: JsonRpcRequest | JsonRpcNotification): void;
+    close(): void;
+    get isAlive(): boolean;
+    private setupListeners;
+    private processBuffer;
+}
+type MessageHandler = (message: JsonRpcResponse | JsonRpcNotification) => void;
+type ErrorHandler = (error: Error) => void;
+type CloseHandler = (code: number | null) => void;
+declare class SSETransport implements MCPTransportConnection {
+    private readonly url;
+    private readonly headers?;
+    private onMessage;
+    private onError;
+    private onClose;
+    private closed;
+    private buffer;
+    private eventName;
+    private dataLines;
+    private endpointUrl?;
+    private readonly streamAbortController;
+    private readonly readyPromise;
+    private endpointResolver;
+    private readonly endpointPromise;
+    constructor(url: string, headers?: Record<string, string> | undefined);
+    waitUntilReady(): Promise<void>;
+    setMessageHandler(handler: MessageHandler): void;
+    setErrorHandler(handler: ErrorHandler): void;
+    setCloseHandler(handler: CloseHandler): void;
+    send(message: JsonRpcRequest | JsonRpcNotification): Promise<void>;
+    close(): void;
+    get isAlive(): boolean;
+    private connect;
+    private consumeStream;
+    private processBuffer;
+    private dispatchEvent;
+    private resolvePostUrl;
+}
+type PersistentMcpScope = Exclude<MCPServerScope, "session">;
+declare function loadMcpConfigFile(configPath: string, scope?: PersistentMcpScope): MCPConfigFile;
+declare function saveMcpConfigFile(configPath: string, config: MCPConfigFile, scope?: PersistentMcpScope): void;
+declare function loadConfiguredMcpServers(cwd?: string): MCPConfiguredServer[];
+declare function upsertMcpServerConfig(scope: PersistentMcpScope, cwd: string | undefined, config: MCPServerConfig): string;
+declare function removeMcpServerConfig(scope: PersistentMcpScope, cwd: string | undefined, name: string): string;
+declare function approveMcpServer(cwd: string, approvalKey: string): void;
+declare function denyMcpServer(cwd: string, approvalKey: string): void;
+declare function clearMcpServerApproval(cwd: string, approvalKey: string): void;
+declare function getMcpApprovalDecision(cwd: string, approvalKey: string): MCPApprovalDecision | undefined;
+declare function resetMcpServerApprovals(cwd: string, scope?: PersistentMcpScope): number;
+type MCPRegistryEntryKind = "tool" | "prompt" | "resource";
+type MCPRegistryAccessPolicy = "none" | "prompts" | "resources" | "context" | "all";
+interface MCPRegistryEntryDescriptor {
+    kind: MCPRegistryEntryKind;
+    server: string;
+    name: string;
+    description?: string;
+    uri?: string;
+}
+type MCPRegistryFilter = (entry: MCPRegistryEntryDescriptor) => boolean;
+declare function matchesMcpRegistryEntryPolicy(entry: MCPRegistryEntryDescriptor, policy: MCPRegistryAccessPolicy): boolean;
+declare function getMcpToolName(serverName: string, toolName: string): string;
+declare function getMcpPromptToolName(serverName: string, promptName: string): string;
+declare function getMcpResourceToolName(serverName: string, resource: MCPResource): string;
+declare function createMcpRegisteredTool(manager: MCPManager, tool: MCPTool): RegisteredTool;
+declare function createMcpPromptRegisteredTool(manager: MCPManager, prompt: MCPPrompt): RegisteredTool;
+declare function createMcpResourceRegisteredTool(manager: MCPManager, resource: MCPResource): RegisteredTool;
+declare function syncMcpToolsToRegistry(manager: MCPManager, registry: ToolRegistry, previouslyRegistered?: string[], filter?: MCPRegistryFilter): string[];
+interface PluginManifest {
+    name: string;
+    version: string;
+    description: string;
+    author?: PluginAuthor | string;
+    license?: string;
+    engine?: PluginEngineConstraint;
+    permissions?: PluginPermission[];
+    capabilities: PluginCapability[];
+    tools?: string[];
+    entryPoint: string;
+    activationEvents?: PluginActivationEvent[];
+    contributes?: PluginContributions;
+    ui?: PluginUIPanel[];
+    homepage?: string;
+    repository?: string;
+    keywords?: string[];
+    icon?: string;
+    minSdkVersion?: string;
+}
+interface PluginAuthor {
+    name: string;
+    email?: string;
+    url?: string;
+}
+interface PluginEngineConstraint {
+    sdkVersion?: string;
+    nodeVersion?: string;
+}
+type PluginPermission = "tools:register" | "tools:execute" | "storage:read" | "storage:write" | "fs:read" | "fs:write" | "network:fetch" | "ui:panels" | "settings:read" | "settings:write" | "clipboard:read" | "clipboard:write" | "shell:execute" | "identity:read";
+type PluginCapability = "tools" | "prompts" | "memory" | "transport" | "ui";
+type PluginActivationEvent = "onStartup" | `onCommand:${string}` | `onLanguage:${string}` | `onFilePattern:${string}` | `onConfig:${string}`;
+interface PluginContributions {
+    tools?: PluginToolContribution[];
+    prompts?: PluginPromptContribution[];
+    settings?: PluginSettingContribution[];
+    commands?: PluginCommandContribution[];
+}
+interface PluginToolContribution {
+    name: string;
+    description: string;
+}
+interface PluginPromptContribution {
+    name: string;
+    description: string;
+    template?: string;
+}
+interface PluginSettingContribution {
+    key: string;
+    description: string;
+    type: "string" | "number" | "boolean" | "array" | "object";
+    default?: unknown;
+}
+interface PluginCommandContribution {
+    name: string;
+    description: string;
+}
+interface PluginUIPanel {
+    id: string;
+    title: string;
+    type: "sidebar" | "modal" | "statusbar";
+    entry?: string;
+}
+type PluginStatus = "installed" | "active" | "disabled" | "error" | "updating";
+interface PluginInfo {
+    manifest: PluginManifest;
+    status: PluginStatus;
+    installedAt: string;
+    path: string;
+    error?: string;
+    registeredTools?: RegisteredTool[];
+    integrityHash?: string;
+}
+interface PluginHook {
+    onActivate?: (context: PluginContext) => Promise<void>;
+    onDeactivate?: () => Promise<void>;
+    onSettingsChange?: (settings: Record<string, unknown>) => Promise<void>;
+}
+interface PluginContext {
+    registerTool: (tool: RegisteredTool) => void;
+    unregisterTool: (name: string) => void;
+    registerCommand?: (name: string, handler: PluginCommandHandler) => void;
+    pluginDir: string;
+    sdkVersion: string;
+    storage: PluginStorage;
+    log: PluginLogger;
+    manifest: Readonly<PluginManifest>;
+    host: PluginHostInfo;
+    grantedPermissions: ReadonlySet<PluginPermission>;
+}
+type PluginCommandHandler = (args: string[], output: (text: string) => void) => Promise<void>;
+interface PluginStorage {
+    get(key: string): Promise<unknown>;
+    set(key: string, value: unknown): Promise<void>;
+    delete(key: string): Promise<void>;
+    keys(): Promise<string[]>;
+    clear(): Promise<void>;
+}
+interface PluginLogger {
+    info(message: string, data?: unknown): void;
+    warn(message: string, data?: unknown): void;
+    error(message: string, data?: unknown): void;
+    debug(message: string, data?: unknown): void;
+}
+interface PluginHostInfo {
+    appName: string;
+    appVersion: string;
+    platform: string;
+}
+interface PluginHostOptions {
+    pluginDir: string;
+    autoActivate?: boolean;
+    registry?: string;
+    host?: PluginHostInfo;
+    defaultPermissions?: PluginPermission[];
+    sandbox?: PluginSandboxOptions;
+}
+interface PluginSandboxOptions {
+    enabled?: boolean;
+    executionTimeout?: number;
+    maxMemory?: number;
+    allowedHosts?: string[];
+    blockedPaths?: string[];
+}
+interface PluginListing {
+    name: string;
+    version: string;
+    description: string;
+    author?: PluginAuthor | string;
+    keywords?: string[];
+    downloads?: number;
+    rating?: number;
+    verified?: boolean;
+    publishedAt?: string;
+    repository?: string;
+    license?: string;
+    versions?: string[];
+}
+interface PluginSearchOptions {
+    query?: string;
+    keyword?: string;
+    capability?: PluginCapability;
+    sortBy?: "downloads" | "rating" | "newest" | "name";
+    limit?: number;
+    offset?: number;
+    verifiedOnly?: boolean;
+}
+interface PluginScaffoldOptions {
+    name: string;
+    description?: string;
+    template: "tools" | "ui" | "prompts" | "full";
+    author?: string;
+    outputDir?: string;
+    initGit?: boolean;
+    installDeps?: boolean;
+}
+interface PluginTestResult {
+    pluginName: string;
+    passed: boolean;
+    totalTests: number;
+    passedTests: number;
+    failedTests: number;
+    results: PluginTestCase[];
+    duration: number;
+}
+interface PluginTestCase {
+    name: string;
+    passed: boolean;
+    error?: string;
+    duration: number;
+}
+interface PluginPublishOptions {
+    registry?: string;
+    access?: "public" | "restricted";
+    tag?: string;
+    dryRun?: boolean;
+}
+type PluginManagerOptions = PluginHostOptions;
+declare class PluginToolBuilder {
+    private name;
+    private desc;
+    private params;
+    private requiredParams;
+    private handlerFn?;
+    constructor(name: string);
+    description(desc: string): this;
+    param(name: string, type: "string" | "number" | "boolean" | "array" | "object", description: string, required?: boolean): this;
+    handler(fn: (input: Record<string, unknown>) => Promise<ToolResult>): this;
+    build(): RegisteredTool;
+}
+declare class PluginSettingsManager {
+    private settings;
+    register(key: string, schema: {
+        type: string;
+        default?: unknown;
+        description?: string;
+    }): void;
+    get(key: string): unknown;
+    set(key: string, value: unknown): void;
+    getAll(): Array<{
+        key: string;
+        value: unknown;
+        type: string;
+        default: unknown;
+        description: string;
+    }>;
+    reset(key: string): void;
+    removeByPrefix(prefix: string): void;
+}
+type PluginEventType = "plugin:installed" | "plugin:activated" | "plugin:deactivated" | "plugin:uninstalled" | "plugin:error" | "plugin:updated" | "tool:registered" | "tool:unregistered" | "command:registered" | "settings:changed";
+interface PluginEvent {
+    type: PluginEventType;
+    pluginName: string;
+    timestamp: string;
+    data?: Record<string, unknown>;
+}
+type PluginEventListener = (event: PluginEvent) => void;
+declare class PluginEventBus {
+    private listeners;
+    private allListeners;
+    on(type: PluginEventType, listener: PluginEventListener): () => void;
+    onAny(listener: PluginEventListener): () => void;
+    emit(event: PluginEvent): void;
+    clear(): void;
+}
+declare class PluginHost {
+    private pluginDir;
+    private autoActivate;
+    private registry;
+    private activeHooks;
+    private activeTools;
+    private sandbox;
+    private hostInfo;
+    private defaultPermissions;
+    readonly events: PluginEventBus;
+    constructor(options: PluginHostOptions);
+    install(packageName: string, version?: string): Promise<PluginInfo>;
+    installLocal(pluginPath: string): Promise<PluginInfo>;
+    uninstall(packageName: string, removeFiles?: boolean): Promise<boolean>;
+    activate(packageName: string): Promise<void>;
+    deactivate(packageName: string): Promise<void>;
+    update(packageName: string, version?: string): Promise<PluginInfo>;
+    listInstalled(): PluginInfo[];
+    getActiveTools(): RegisteredTool[];
+    getPlugin(packageName: string): PluginInfo | undefined;
+    setStatus(packageName: string, status: PluginStatus): void;
+    getPluginCommands(): Map<string, PluginCommandHandler>;
+    activateAll(): Promise<void>;
+    deactivateAll(): Promise<void>;
+    get activeCount(): number;
+    private resolveEntryPoint;
+    private loadRegistry;
+    private saveRegistry;
+    private readManifestFallback;
+}
+declare const PluginManager: typeof PluginHost;
+declare const MANIFEST_FILENAME = "xeno-plugin.json";
+declare const HIGH_RISK_PERMISSIONS: ReadonlySet<PluginPermission>;
+interface ManifestValidationResult {
+    valid: boolean;
+    manifest?: PluginManifest;
+    errors: string[];
+    warnings: string[];
+}
+declare function validateManifest(data: unknown): ManifestValidationResult;
+declare function readManifestFromDisk(pluginDir: string): ManifestValidationResult;
+declare function getHighRiskPermissions(manifest: PluginManifest): PluginPermission[];
+declare class PluginSandbox {
+    private options;
+    private commandHandlers;
+    constructor(options?: PluginSandboxOptions);
+    createContext(manifest: PluginManifest, pluginDir: string, toolCollector: RegisteredTool[], grantedPermissions?: Set<PluginPermission>, hostInfo?: PluginHostInfo): PluginContext;
+    executeWithTimeout<T>(fn: () => Promise<T>, label: string): Promise<T>;
+    getCommandHandlers(pluginName: string): Map<string, PluginCommandHandler> | undefined;
+    getAllCommandHandlers(): Map<string, PluginCommandHandler>;
+    clearCommandHandlers(pluginName: string): void;
+    private requirePermission;
+    private createStorage;
+    private createLogger;
+}
+interface PluginMarketplaceOptions {
+    registry?: string;
+    timeout?: number;
+    verifiedScopes?: string[];
+}
+declare class PluginMarketplace {
+    private registry;
+    private timeout;
+    private verifiedScopes;
+    constructor(options?: PluginMarketplaceOptions);
+    search(options?: PluginSearchOptions): Promise<PluginListing[]>;
+    getPackageInfo(packageName: string): Promise<PluginListing | undefined>;
+    versionExists(packageName: string, version: string): Promise<boolean>;
+    getLatestVersion(packageName: string): Promise<string | undefined>;
+    private isVerified;
+    private sortListings;
+    private fetchWithTimeout;
+}
+declare function scaffoldPlugin(options: PluginScaffoldOptions): Promise<string>;
+declare function testPlugin(pluginDir: string): Promise<PluginTestResult>;
+declare function publishPlugin(pluginDir: string, options?: PluginPublishOptions): Promise<boolean>;
+type ExtendedAppType = "pixel" | "motion" | "sound" | "architect" | "3d" | "engine" | "workflow" | "docs" | "sheets" | "slides" | "notes" | "hub" | "code";
+interface ContextSource {
+    name: string;
+    priority: number;
+    provider: () => unknown;
+}
+interface ContextSection {
+    heading: string;
+    content: string;
+}
+declare class AppContextInjector {
+    private readonly contextManager;
+    private readonly sources;
+    private appType;
+    constructor();
+    setAppContext(provider: AppContextProvider): void;
+    setExtendedAppType(appType: ExtendedAppType): void;
+    registerSource(name: string, provider: () => unknown, priority?: number): void;
+    removeSource(name: string): boolean;
+    buildContextBlock(): string;
+    getContextManager(): AppContextManager;
+    getCurrentContext(): AppContext;
+    getAppDisplayName(): string;
+    private formatSourceData;
+}
+interface ChatMessage {
+    role: "system" | "user" | "assistant";
+    content: string;
+}
+interface LLMToolDefinition {
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    };
+}
+interface ChatCompletionRequest {
+    model: string;
+    messages: ChatMessage[];
+    maxTokens?: number;
+    temperature?: number;
+    stream?: boolean;
+    tools?: LLMToolDefinition[];
+    stop?: string[];
+}
+interface ChatCompletionResponse {
+    id: string;
+    object: string;
+    model: string;
+    choices: Array<{
+        index: number;
+        message: ChatMessage & {
+            tool_calls?: Array<{
+                id: string;
+                type: "function";
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+            }>;
+        };
+        finish_reason: string;
+    }>;
+    usage: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+}
+interface ChatCompletionChunk {
+    id: string;
+    object: string;
+    model: string;
+    choices: Array<{
+        index: number;
+        delta: {
+            role?: string;
+            content?: string;
+            tool_calls?: Array<{
+                index: number;
+                id?: string;
+                type?: "function";
+                function?: {
+                    name?: string;
+                    arguments?: string;
+                };
+            }>;
+        };
+        finish_reason: string | null;
+    }>;
+}
+interface ProviderStatus {
+    available: boolean;
+    endpoint: "local" | "cloud";
+    baseURL: string;
+    localModel?: string;
+    localError?: string;
+}
+type OnChunkCallback = (chunk: ChatCompletionChunk) => void;
+interface LocalLLMProviderConfig {
+    localURL?: string;
+    cloudURL?: string;
+    cloudApiKey?: string;
+    preferLocal?: boolean;
+}
+declare class LocalLLMProvider {
+    private readonly localURL;
+    private readonly cloudURL;
+    private readonly cloudApiKey;
+    private readonly preferLocal;
+    private cachedStatus;
+    private cacheTimestamp;
+    private static readonly CACHE_TTL;
+    constructor(config?: LocalLLMProviderConfig);
+    checkAvailability(forceRefresh?: boolean): Promise<ProviderStatus>;
+    chatCompletion(request: ChatCompletionRequest): Promise<ChatCompletionResponse>;
+    chatCompletionStream(request: ChatCompletionRequest, onChunk: OnChunkCallback): Promise<void>;
+    getActiveEndpoint(): string;
+    getMode(): "local" | "cloud" | "unknown";
+    forceEndpoint(endpoint: "local" | "cloud"): void;
+    private checkLocal;
+}
+interface AnalysisResult {
+    type: string;
+    passed: boolean;
+    summary: string;
+    metrics: Record<string, number>;
+}
+interface ClashResult {
+    count: number;
+    clashes: Array<{
+        element1: string;
+        element2: string;
+        description: string;
+    }>;
+}
+interface RoomInfo {
+    id: string;
+    name: string;
+    area: number;
+}
+interface ArchitectToolAdapter {
+    placeWall(startX: number, startY: number, endX: number, endY: number, thickness: number): Promise<string>;
+    createRoom(name: string, wallIds: string[]): Promise<RoomInfo>;
+    runAnalysis(analysisType: string): Promise<AnalysisResult>;
+    exportDesign(format: string, path: string): Promise<void>;
+    detectClashes(): Promise<ClashResult>;
+    addOpening(wallId: string, openingType: string, position: number, width: number, height: number): Promise<string>;
+    getFloorPlan(): Promise<{
+        rooms: RoomInfo[];
+        totalArea: number;
+    }>;
+}
+declare const ARCHITECT_TOOL_NAMES: readonly [
+    "architect.placeWall",
+    "architect.createRoom",
+    "architect.runAnalysis",
+    "architect.exportDesign",
+    "architect.detectClashes",
+    "architect.addOpening",
+    "architect.getFloorPlan"
+];
+declare const ARCHITECT_CAPABILITIES: readonly [
+    "Wall placement and editing",
+    "Room creation and management",
+    "Structural and energy analysis",
+    "Code compliance checking",
+    "Clash detection between building systems",
+    "Door and window placement",
+    "Export to PDF and DWG formats"
+];
+declare function createArchitectTools(adapter: ArchitectToolAdapter): RegisteredTool[];
+interface MaterialConfig {
+    name: string;
+    color?: string;
+    roughness?: number;
+    metalness?: number;
+    texturePath?: string;
+}
+interface RenderConfig {
+    width: number;
+    height: number;
+    samples?: number;
+    outputPath: string;
+}
+interface MeshInfo {
+    id: string;
+    name: string;
+    vertices: number;
+    faces: number;
+}
+interface ThreeDToolAdapter {
+    addMesh(meshType: string, name: string): Promise<MeshInfo>;
+    applyMaterial(meshId: string, material: MaterialConfig): Promise<void>;
+    renderScene(config: RenderConfig): Promise<string>;
+    importModel(filePath: string, format: string): Promise<string>;
+    exportMesh(meshId: string, format: string, path: string): Promise<void>;
+    transformMesh(meshId: string, transform: {
+        translateX?: number;
+        translateY?: number;
+        translateZ?: number;
+        rotateX?: number;
+        rotateY?: number;
+        rotateZ?: number;
+        scaleX?: number;
+        scaleY?: number;
+        scaleZ?: number;
+    }): Promise<void>;
+    getSceneInfo(): Promise<{
+        meshes: MeshInfo[];
+        totalVertices: number;
+    }>;
+}
+declare const THREE_D_TOOL_NAMES: readonly [
+    "3d.addMesh",
+    "3d.applyMaterial",
+    "3d.renderScene",
+    "3d.importModel",
+    "3d.exportMesh",
+    "3d.transformMesh",
+    "3d.getSceneInfo"
+];
+declare const THREE_D_CAPABILITIES: readonly [
+    "Mesh creation (cube, sphere, cylinder, plane, torus, custom)",
+    "Material assignment (PBR: color, roughness, metalness, textures)",
+    "Scene rendering (path tracing with configurable samples)",
+    "Model import (OBJ, FBX, GLTF, STL)",
+    "Model export (OBJ, FBX, GLTF, STL, USD)",
+    "Spatial transformations (translate, rotate, scale)",
+    "Scene hierarchy inspection"
+];
+declare function create3DTools(adapter: ThreeDToolAdapter): RegisteredTool[];
+interface ComponentData {
+    type: string;
+    properties: Record<string, unknown>;
+}
+interface EntityInfo {
+    id: string;
+    name: string;
+    components: string[];
+}
+interface BuildResult {
+    success: boolean;
+    outputPath: string;
+    warnings: string[];
+    errors: string[];
+}
+interface TestResult {
+    total: number;
+    passed: number;
+    failed: number;
+    failures: Array<{
+        test: string;
+        error: string;
+    }>;
+}
+interface EngineToolAdapter {
+    createEntity(name: string): Promise<EntityInfo>;
+    addComponent(entityId: string, component: ComponentData): Promise<void>;
+    removeComponent(entityId: string, componentType: string): Promise<void>;
+    buildGame(platform: string): Promise<BuildResult>;
+    runTest(testPattern?: string): Promise<TestResult>;
+    deployWeb(outputDir: string): Promise<string>;
+    getSceneEntities(): Promise<EntityInfo[]>;
+}
+declare const ENGINE_TOOL_NAMES: readonly [
+    "engine.createEntity",
+    "engine.addComponent",
+    "engine.removeComponent",
+    "engine.buildGame",
+    "engine.runTest",
+    "engine.deployWeb",
+    "engine.getSceneEntities"
+];
+declare const ENGINE_CAPABILITIES: readonly [
+    "Entity creation and management",
+    "Component system (transform, rigidbody, sprite, script, audio, camera)",
+    "Game building for multiple platforms",
+    "Automated test execution",
+    "Web deployment (HTML5 export)",
+    "Scene hierarchy inspection"
+];
+declare function createEngineTools(adapter: EngineToolAdapter): RegisteredTool[];
+interface WorkflowNodeConfig {
+    type: string;
+    name: string;
+    parameters: Record<string, unknown>;
+    inputs?: string[];
+}
+interface WorkflowExecutionResult {
+    success: boolean;
+    nodesExecuted: number;
+    durationMs: number;
+    output: unknown;
+    errors: Array<{
+        nodeId: string;
+        error: string;
+    }>;
+}
+interface WorkflowInfo {
+    id: string;
+    name: string;
+    nodeCount: number;
+    active: boolean;
+}
+interface WorkflowToolAdapter {
+    createWorkflow(name: string): Promise<WorkflowInfo>;
+    addNode(workflowId: string, config: WorkflowNodeConfig): Promise<string>;
+    removeNode(workflowId: string, nodeId: string): Promise<void>;
+    executeWorkflow(workflowId: string, inputData?: Record<string, unknown>): Promise<WorkflowExecutionResult>;
+    scheduleRun(workflowId: string, cron: string): Promise<void>;
+    deactivateWorkflow(workflowId: string): Promise<void>;
+    listWorkflows(): Promise<WorkflowInfo[]>;
+}
+declare const WORKFLOW_TOOL_NAMES: readonly [
+    "workflow.createWorkflow",
+    "workflow.addNode",
+    "workflow.removeNode",
+    "workflow.executeWorkflow",
+    "workflow.scheduleRun",
+    "workflow.deactivateWorkflow",
+    "workflow.listWorkflows"
+];
+declare const WORKFLOW_CAPABILITIES: readonly [
+    "Workflow creation and management",
+    "Node-based automation (HTTP, transform, filter, AI agent, code)",
+    "Workflow execution with input data",
+    "Cron-based scheduling",
+    "Error handling and retry logic",
+    "Workflow listing and inspection"
+];
+declare function createWorkflowTools(adapter: WorkflowToolAdapter): RegisteredTool[];
+type BlockType = "paragraph" | "heading" | "list" | "code" | "image" | "table" | "quote" | "divider";
+interface BlockContent {
+    type: BlockType;
+    text?: string;
+    level?: number;
+    language?: string;
+    imageUrl?: string;
+}
+interface DocComment {
+    id: string;
+    text: string;
+    blockId: string;
+    author: string;
+}
+interface DocsToolAdapter {
+    insertBlock(afterBlockId: string | null, content: BlockContent): Promise<string>;
+    deleteBlock(blockId: string): Promise<void>;
+    formatText(blockId: string, format: string, start: number, end: number): Promise<void>;
+    exportDocument(format: string, path: string): Promise<void>;
+    findReplace(find: string, replace: string, caseSensitive: boolean): Promise<number>;
+    addComment(blockId: string, text: string): Promise<string>;
+    getOutline(): Promise<Array<{
+        blockId: string;
+        text: string;
+        level: number;
+    }>>;
+}
+declare const DOCS_TOOL_NAMES: readonly [
+    "docs.insertBlock",
+    "docs.deleteBlock",
+    "docs.formatText",
+    "docs.exportDocument",
+    "docs.findReplace",
+    "docs.addComment",
+    "docs.getOutline"
+];
+declare const DOCS_CAPABILITIES: readonly [
+    "Block-based content insertion (paragraphs, headings, lists, code, images, tables)",
+    "Text formatting (bold, italic, underline, strikethrough, code)",
+    "Document export (PDF, Markdown)",
+    "Find and replace across the document",
+    "Comment management",
+    "Document outline/structure inspection"
+];
+declare function createDocsTools(adapter: DocsToolAdapter): RegisteredTool[];
+interface ChartConfig {
+    type: string;
+    dataRange: string;
+    title?: string;
+    xAxisLabel?: string;
+    yAxisLabel?: string;
+}
+interface CellRangeData {
+    startCell: string;
+    values: unknown[][];
+}
+interface SortConfig {
+    column: string;
+    ascending: boolean;
+}
+interface FilterConfig {
+    column: string;
+    operator: string;
+    value: unknown;
+}
+interface SheetsToolAdapter {
+    setCellValue(cell: string, value: unknown): Promise<void>;
+    setCellRange(data: CellRangeData): Promise<void>;
+    insertFormula(cell: string, formula: string): Promise<void>;
+    createChart(config: ChartConfig): Promise<string>;
+    sortRange(range: string, sort: SortConfig): Promise<void>;
+    filterData(range: string, filter: FilterConfig): Promise<void>;
+    clearFilters(range: string): Promise<void>;
+    getCellRange(range: string): Promise<CellRangeData>;
+}
+declare const SHEETS_TOOL_NAMES: readonly [
+    "sheets.setCellValue",
+    "sheets.setCellRange",
+    "sheets.insertFormula",
+    "sheets.createChart",
+    "sheets.sortRange",
+    "sheets.filterData",
+    "sheets.clearFilters",
+    "sheets.getCellRange"
+];
+declare const SHEETS_CAPABILITIES: readonly [
+    "Cell value editing (single cell and range)",
+    "Formula insertion and evaluation",
+    "Chart creation (bar, line, pie, scatter, area)",
+    "Data sorting by column",
+    "Data filtering (equals, contains, greater/less than, between)",
+    "Data analysis and summarization",
+    "Range inspection and data retrieval"
+];
+declare function createSheetsTools(adapter: SheetsToolAdapter): RegisteredTool[];
+interface ShapeConfig {
+    type: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    text?: string;
+    fill?: string;
+    imageUrl?: string;
+}
+interface TransitionConfig {
+    type: string;
+    durationMs: number;
+}
+interface SlideInfo {
+    id: string;
+    index: number;
+    shapeCount: number;
+    hasNotes: boolean;
+}
+interface SlidesToolAdapter {
+    addSlide(afterIndex: number): Promise<SlideInfo>;
+    deleteSlide(slideId: string): Promise<void>;
+    insertShape(slideId: string, shape: ShapeConfig): Promise<string>;
+    removeShape(slideId: string, shapeId: string): Promise<void>;
+    setTransition(slideId: string, transition: TransitionConfig): Promise<void>;
+    startPresentation(fromSlideIndex: number): Promise<void>;
+    setSpeakerNotes(slideId: string, notes: string): Promise<void>;
+    getSlides(): Promise<SlideInfo[]>;
+}
+declare const SLIDES_TOOL_NAMES: readonly [
+    "slides.addSlide",
+    "slides.deleteSlide",
+    "slides.insertShape",
+    "slides.removeShape",
+    "slides.setTransition",
+    "slides.startPresentation",
+    "slides.setSpeakerNotes",
+    "slides.getSlides"
+];
+declare const SLIDES_CAPABILITIES: readonly [
+    "Slide creation and deletion",
+    "Shape insertion (rectangles, circles, arrows, text boxes, images)",
+    "Slide transitions (fade, slide, zoom, dissolve)",
+    "Presentation mode control",
+    "Speaker notes management",
+    "Slide overview and inspection"
+];
+declare function createSlidesTools(adapter: SlidesToolAdapter): RegisteredTool[];
+interface NotePageInfo {
+    id: string;
+    title: string;
+    tags: string[];
+    createdAt: string;
+    updatedAt: string;
+    linkCount: number;
+}
+interface NoteSearchResult {
+    pageId: string;
+    title: string;
+    snippet: string;
+    score: number;
+}
+interface NotesToolAdapter {
+    createPage(title: string, content: string): Promise<NotePageInfo>;
+    updatePage(pageId: string, content: string): Promise<void>;
+    deletePage(pageId: string): Promise<void>;
+    searchNotes(query: string): Promise<NoteSearchResult[]>;
+    addTag(pageId: string, tag: string): Promise<void>;
+    removeTag(pageId: string, tag: string): Promise<void>;
+    linkPages(sourcePageId: string, targetPageId: string): Promise<void>;
+    exportMarkdown(pageId: string, path: string): Promise<void>;
+    listPages(): Promise<NotePageInfo[]>;
+}
+declare const NOTES_TOOL_NAMES: readonly [
+    "notes.createPage",
+    "notes.updatePage",
+    "notes.deletePage",
+    "notes.searchNotes",
+    "notes.addTag",
+    "notes.removeTag",
+    "notes.linkPages",
+    "notes.exportMarkdown",
+    "notes.listPages"
+];
+declare const NOTES_CAPABILITIES: readonly [
+    "Page creation and editing",
+    "Full-text search across all notes",
+    "Tag management for organization",
+    "Bidirectional page linking (wiki-style)",
+    "Markdown export",
+    "Page listing and inspection"
+];
+declare function createNotesTools(adapter: NotesToolAdapter): RegisteredTool[];
+interface AppAgentBaseOptions {
+    apiKey?: string;
+    baseURL?: string;
+    model?: string;
+    maxTokens?: number;
+    maxIterations?: number;
+    cwd?: string;
+    contextProvider?: AppContextProvider;
+    localLLM?: LocalLLMProviderConfig;
+    includeBuiltinTools?: boolean;
+    agentOptions?: Partial<CreateXenoAgentOptions>;
+}
+interface PixelAgentOptions extends AppAgentBaseOptions {
+    imageAdapter: ImageToolAdapter;
+}
+interface MotionAgentOptions extends AppAgentBaseOptions {
+    videoAdapter: VideoToolAdapter;
+}
+interface SoundAgentOptions extends AppAgentBaseOptions {
+    audioAdapter: AudioToolAdapter;
+}
+interface ArchitectAgentOptions extends AppAgentBaseOptions {
+    architectAdapter: ArchitectToolAdapter;
+}
+interface ThreeDAgentOptions extends AppAgentBaseOptions {
+    threeDAdapter: ThreeDToolAdapter;
+}
+interface EngineAgentOptions extends AppAgentBaseOptions {
+    engineAdapter: EngineToolAdapter;
+}
+interface WorkflowAgentOptions extends AppAgentBaseOptions {
+    workflowAdapter: WorkflowToolAdapter;
+}
+interface DocsAgentOptions extends AppAgentBaseOptions {
+    docsAdapter: DocsToolAdapter;
+}
+interface SheetsAgentOptions extends AppAgentBaseOptions {
+    sheetsAdapter: SheetsToolAdapter;
+}
+interface SlidesAgentOptions extends AppAgentBaseOptions {
+    slidesAdapter: SlidesToolAdapter;
+}
+interface NotesAgentOptions extends AppAgentBaseOptions {
+    notesAdapter: NotesToolAdapter;
+}
+interface AppAgentResult extends CreateXenoAgentResult {
+    contextInjector: AppContextInjector;
+    localLLMProvider: LocalLLMProvider;
+}
+declare class AppAgentFactory {
+    createPixelAgent(options: PixelAgentOptions): Promise<AppAgentResult>;
+    createMotionAgent(options: MotionAgentOptions): Promise<AppAgentResult>;
+    createSoundAgent(options: SoundAgentOptions): Promise<AppAgentResult>;
+    createArchitectAgent(options: ArchitectAgentOptions): Promise<AppAgentResult>;
+    create3DAgent(options: ThreeDAgentOptions): Promise<AppAgentResult>;
+    createEngineAgent(options: EngineAgentOptions): Promise<AppAgentResult>;
+    createWorkflowAgent(options: WorkflowAgentOptions): Promise<AppAgentResult>;
+    createDocsAgent(options: DocsAgentOptions): Promise<AppAgentResult>;
+    createSheetsAgent(options: SheetsAgentOptions): Promise<AppAgentResult>;
+    createSlidesAgent(options: SlidesAgentOptions): Promise<AppAgentResult>;
+    createNotesAgent(options: NotesAgentOptions): Promise<AppAgentResult>;
+    private createInjector;
+    private buildAgent;
+}
+declare const PIXEL_TOOL_NAMES: readonly [
+    "pixel.createLayer",
+    "pixel.deleteLayer",
+    "pixel.setActiveLayer",
+    "pixel.getActiveLayer",
+    "pixel.getLayers",
+    "pixel.applyFilter",
+    "pixel.setTool",
+    "pixel.setBrushSize",
+    "pixel.setColor",
+    "pixel.removeBackground",
+    "pixel.upscale",
+    "pixel.denoise",
+    "pixel.exportImage",
+    "pixel.getDocumentInfo"
+];
+declare const PIXEL_CAPABILITIES: readonly [
+    "Layer management (create, delete, reorder, rename)",
+    "Filter application (blur, sharpen, levels, curves, color balance)",
+    "AI background removal (xeno-lib RMBG)",
+    "AI upscaling (xeno-lib Real-ESRGAN)",
+    "AI denoising (xeno-lib NAFNet)",
+    "Tool control (brush, eraser, selection, transform)",
+    "Color management (foreground, background, swatches)",
+    "Export (PNG, JPEG, WebP, PSD, TIFF)"
+];
+declare const MOTION_TOOL_NAMES: readonly [
+    "motion.addClip",
+    "motion.removeClip",
+    "motion.setPlayhead",
+    "motion.play",
+    "motion.pause",
+    "motion.addEffect",
+    "motion.transcribeClip",
+    "motion.separateStems",
+    "motion.exportVideo",
+    "motion.getTimelineInfo"
+];
+declare const MOTION_CAPABILITIES: readonly [
+    "Timeline clip management (add, remove, trim, split)",
+    "Playback control (play, pause, seek)",
+    "Visual effects (blur, color correction, compositing)",
+    "AI transcription (xeno-lib Whisper)",
+    "AI stem separation (xeno-lib Demucs)",
+    "Transitions (cross-dissolve, wipe, fade)",
+    "Speed adjustment (slow-motion, time-remap)",
+    "Export (MP4, MOV, WebM, ProRes)"
+];
+declare const SOUND_TOOL_NAMES: readonly [
+    "sound.addTrack",
+    "sound.removeTrack",
+    "sound.setVolume",
+    "sound.setPan",
+    "sound.muteTrack",
+    "sound.soloTrack",
+    "sound.addEffect",
+    "sound.setBPM",
+    "sound.denoise",
+    "sound.separateStems",
+    "sound.transcribe",
+    "sound.exportAudio",
+    "sound.getProjectInfo"
+];
+declare const SOUND_CAPABILITIES: readonly [
+    "Track management (add, remove, reorder)",
+    "Mixer control (volume, pan, mute, solo)",
+    "Audio effects (EQ, compression, reverb, delay, chorus, distortion)",
+    "AI noise reduction (xeno-lib DeepFilterNet)",
+    "AI stem separation (xeno-lib Demucs)",
+    "AI transcription (xeno-lib Whisper)",
+    "BPM and time signature control",
+    "Export (WAV, MP3, FLAC, OGG, AIFF)"
+];
+interface CodeValidationResult {
+    valid: boolean;
+    errors: CodeValidationIssue[];
+    warnings: CodeValidationIssue[];
+    language: string;
+}
+interface CodeValidationIssue {
+    line: number;
+    column?: number;
+    message: string;
+    severity: "error" | "warning";
+}
+interface CodeApplyOptions {
+    dryRun?: boolean;
+    validateBefore?: boolean;
+    validateAfter?: boolean;
+}
+interface CodeApplyResult {
+    applied: boolean;
+    beforeValid: boolean;
+    afterValid: boolean;
+    content: string;
+    errors?: CodeValidationIssue[];
+}
+declare function detectLanguage(filePath: string): string;
+declare class CodeValidator {
+    validate(code: string, language: string): CodeValidationResult;
+    validateForFile(code: string, filePath: string): CodeValidationResult;
+    validateEdit(originalContent: string, oldString: string, newString: string, filePath: string): CodeApplyResult;
+}
+interface DebugStep {
+    index: number;
+    type: "tool-call" | "llm-request" | "llm-response" | "permission-check" | "error";
+    toolName?: string;
+    input?: Record<string, unknown>;
+    output?: ToolResult | string;
+    startTime: number;
+    endTime?: number;
+    durationMs?: number;
+    status: "pending" | "running" | "completed" | "failed" | "skipped";
+    error?: string;
+    iteration?: number;
+    messageSnapshot?: Message[];
+}
+interface DebugBreakpoint {
+    id: string;
+    type: "tool" | "iteration" | "error";
+    toolName?: string;
+    iteration?: number;
+    enabled: boolean;
+    condition?: string;
+}
+type DebugStepCallback = (step: DebugStep) => void;
+type BreakpointCallback = (step: DebugStep, breakpoint: DebugBreakpoint) => Promise<"continue" | "skip" | "abort">;
+interface DebugSnapshot {
+    steps: DebugStep[];
+    totalSteps: number;
+    toolCallCount: number;
+    llmRequestCount: number;
+    errorCount: number;
+    totalDurationMs: number;
+    toolSummary: Record<string, number>;
+    breakpoints: DebugBreakpoint[];
+    enabled: boolean;
+}
+declare class AgentDebugger {
+    private steps;
+    private breakpoints;
+    private stepCallbacks;
+    private breakpointCallback;
+    private _enabled;
+    private nextBreakpointId;
+    private maxSteps;
+    enable(): void;
+    disable(): void;
+    get enabled(): boolean;
+    recordStep(step: Omit<DebugStep, "index">): DebugStep;
+    checkBreakpoints(step: DebugStep): Promise<"continue" | "skip" | "abort">;
+    addBreakpoint(config: Omit<DebugBreakpoint, "id" | "enabled"> & {
+        id?: string;
+        enabled?: boolean;
+    }): string;
+    removeBreakpoint(id: string): boolean;
+    toggleBreakpoint(id: string): boolean | undefined;
+    onStep(callback: DebugStepCallback): void;
+    onBreakpoint(callback: BreakpointCallback): void;
+    getSteps(filter?: DebugStep["type"]): DebugStep[];
+    getStep(index: number): DebugStep | undefined;
+    takeSnapshot(): DebugSnapshot;
+    clear(): void;
+    reset(): void;
+}
+interface EvalTask {
+    id: string;
+    description: string;
+    category?: string;
+    input: string;
+    expectedOutput?: string;
+    validator: (output: string) => boolean;
+    maxDurationMs?: number;
+    maxCost?: number;
+    tags?: string[];
+}
+interface EvalResult {
+    taskId: string;
+    passed: boolean;
+    output: string;
+    durationMs: number;
+    tokensUsed: {
+        input: number;
+        output: number;
+    };
+    cost: number;
+    iterations: number;
+    toolCalls: number;
+    error?: string;
+    model?: string;
+    timestamp: string;
+}
+interface EvalReport {
+    totalTasks: number;
+    passed: number;
+    failed: number;
+    successRate: number;
+    avgDurationMs: number;
+    totalTokens: {
+        input: number;
+        output: number;
+    };
+    totalCost: number;
+    avgIterations: number;
+    avgToolCalls: number;
+    byCategory: Record<string, {
+        total: number;
+        passed: number;
+        failed: number;
+        avgDurationMs: number;
+    }>;
+    results: EvalResult[];
+    generatedAt: string;
+}
+interface EvalRunOptions {
+    maxConcurrent?: number;
+    timeout?: number;
+    categories?: string[];
+    tags?: string[];
+    model?: string;
+    onProgress?: (completed: number, total: number, result: EvalResult) => void;
+}
+declare class AgentEvaluator {
+    private tasks;
+    private results;
+    private maxResultHistory;
+    addTask(task: EvalTask): void;
+    removeTask(id: string): boolean;
+    getTask(id: string): EvalTask | undefined;
+    listTasks(category?: string): EvalTask[];
+    recordResult(result: EvalResult): void;
+    validate(taskId: string, output: string): boolean;
+    getReport(filter?: {
+        model?: string;
+        since?: string;
+    }): EvalReport;
+    formatReport(report: EvalReport): string;
+    clearResults(): void;
+    get resultCount(): number;
+}
+export { type A2AMessage, type A2AMessageType, ARCHITECT_CAPABILITIES, ARCHITECT_TOOL_NAMES, type ActiveLayerInfo, type AgentArtifact, type AgentCapabilities, type AgentCard, AgentDebugger, AgentEvaluator, AgentInterruptedError, type AgentIpcChannel, type AgentLoadSnapshot, AgentLoop, type AgentLoopConfig, type AgentLoopOptions, AgentProtocol, AgentRegistry, type AgentRunTermination, type AgentRunTerminationReason, type AgentRunTerminationStatus, type AgentSandbox, type AgentSelectionStrategy, type AgentStreamCallbacks, type AgentTask, type AgentTaskHandler, type AgentTaskResult, type AgentTaskStatus, type AgentTeam, type AgentToAppChannel, type AgentToAppMessages, type AnalysisResult, type ApiMessage, type AppAgentBaseOptions, AppAgentFactory, type AppAgentResult, type AppContext, AppContextInjector, AppContextManager, type AppContextProvider, type AppId, type AppToAgentChannel, type AppToAgentMessages, type AppType, type ArchitectAgentOptions, type ArchitectToolAdapter, type AskUserHandler, type AskUserRequest, type AskUserResponse, type AudioProjectInfo, type AudioStemSeparationResult, type AudioToolAdapter, type AudioTrackType, type AudioTranscriptionResult, type AudioTranscriptionSegment, type AuditDecision, type AuditEvent, AuditLogger, type AuditReplayReport, type AuditReplayStep, type AuditRiskLevel, type AuditStatus, type AuditTraceGapEntry, type AuditTraceReport, type AuditTraceSummary, type AuditTraceTimelineEntry, type AuditTraceToolSummary, AutoCheckpointHandler, AutoMemory, type AutoMemoryContext, type AutoMemoryTrigger, BackgroundProcessManager, type BackgroundTask, type BlockContent, type BlockType, type BoundedShellOutput, type BreakpointCallback, type BuildResult, COMPAT_TOOL_ALIASES, CONFIG_VERSION, type CanvasSize, type CellRangeData, type ChartConfig, type ChatCompletionChunk, type ChatCompletionRequest, type ChatCompletionResponse, type ChatMessage, type ChatParams, type ChatResponse, type CheckpointData, type CheckpointInfo, CheckpointManager, type CheckpointTrigger, type ClashResult, type ClipContext, type CodeApplyOptions, type CodeApplyResult, type CodeValidationIssue, type CodeValidationResult, CodeValidator, type CodingBenchmarkAssessment, type CodingBenchmarkMeasurement, type CodingBenchmarkOptions, type CodingBenchmarkReport, type CodingBenchmarkThreshold, type CompletionGuard, type CompletionGuardContext, type CompletionGuardDecision, type CompletionGuardEvaluationContext, CompletionGuardRegistry, type CompletionGuardResult, type CompletionGuardResultObject, type CompletionGuardStopReason, type CompletionGuardToolPolicy, type CompletionGuardToolPolicyMode, type CompletionGuardTurnStats, type CompletionGuardVeto, type ComponentData, type CompressionLLMFn, type CompressionStats, type ConfigProfile, type ConnectConfiguredMCPServersOptions, type ConnectConfiguredMCPServersResult, type ContentBlock, type ContextCompressedData, ContextManager, type ContextManagerConfig, type ContextSection, type ContextSource, ConversationStore, type CreateAuditBackedPermissionEngineOptions, type CreateDelegatedBranchAgent, type CreateDelegatedBranchAgentOptions, type CreateDelegatedXenoAgentOptions, type CreateXenoAgentOptions, type CreateXenoAgentResult, type CrossAppHandler, type CrossAppMessage, CrossAppRouter, CrossAppRouterError, type CrossAppRouterOptions, DEFAULT_API_KEY, DEFAULT_MEMORY_BUDGETS, DEFAULT_MODEL, DEFAULT_PROMPT_SECTIONS_TOKEN_BUDGET, DEFAULT_SUBAGENT_BRANCH_POLICY, DEFAULT_SUBAGENT_REMOTE_MCP_BY_ROLE, DEFAULT_SUBAGENT_ROLES, DEFAULT_SUBAGENT_ROLE_PRECEDENCE, DEFAULT_SUBAGENT_TEAM_PRESET, DOCS_CAPABILITIES, DOCS_TOOL_NAMES, type DebugBreakpoint, type DebugSnapshot, type DebugStep, type DebugStepCallback, type DefaultToolRegistryOptions, type DelegatedBranchAgent, type DelegatedBranchAgentCallbacks, type DelegatedXenoTurnResult, type DelegationBudget, type DelegationLimits, type DelegationSummaryData, type DependencyEdge, type DescendantInstructionHint, type DispatchAgentHandler, type DispatchAgentRequest, type DispatchAgentResponse, type DocComment, type DocsAgentOptions, type DocsToolAdapter, type DocumentContext, type DualLLMMode, DualLLMProvider, type DualLLMProviderConfig, type DualLLMProviderLike, type DualLLMStatus, ENGINE_CAPABILITIES, ENGINE_TOOL_NAMES, ElectronAgentBridge, type ElectronAgentConfig, type EngineAgentOptions, type EngineToolAdapter, type EntityInfo, type ErrorData, type EvalReport, type EvalResult, type EvalRunOptions, type EvalTask, type ExecuteToolRequest, type ExecuteToolResult, type ExecutionMode, type ExtendedAppType, FALLBACK_MODELS, type FileEntry, type FileSnapshot, type FilterConfig, HIGH_RISK_PERMISSIONS, IDENTITY_PATHS, type IdentityFrontmatter, type IdentityLayer, type IdentityLoadResult, IdentityLoader, type IdentityLoaderOptions, type IdentityPaths, IdentityResolver, type IdentitySource, type ImageContentBlock, type ImageDocumentInfo, type ImageLayerInfo, type ImageLayerType, type ImageToolAdapter, type ImageUrlBlock, type InitializeSessionRuntimeOptions, type InspectSystemPromptOptions, type InstallSignalHandlersOptions, type IpcHandler, type JsonRpcErrorResponse, type JsonRpcMessage, type JsonRpcNotification, type JsonRpcRequest, type JsonRpcResponse, type JsonRpcSuccessResponse, type JsonSchemaSubset, type JsonSchemaType, type JsonSchemaValidationError, type JsonSchemaValidationResult, type LLMCompletionResult, type LLMProvider, type LLMProviderCapabilities, type LLMProviderMessage, type ToolDefinition as LLMProviderToolDefinition, type LLMToolDefinition, type LayerContext, LlmClient, type LlmClientDeps, LocalLLMProvider, type LocalLLMProviderConfig, type LocalRuntimePreflightResult, LogLevel, MANIFEST_FILENAME, type MCPApprovalDecision, type MCPConfigFile, type MCPConfiguredServer, type MCPInitializeParams, type MCPInitializeResult, MCPManager, type MCPPrompt, type MCPPromptGetParams, type MCPPromptGetResult, type MCPPromptsListResult, type MCPRegistryAccessPolicy, type MCPRegistryEntryDescriptor, type MCPRegistryEntryKind, type MCPRegistryFilter, type MCPResource, type MCPResourceReadParams, type MCPResourceReadResult, type MCPResourceSubscribeParams, type MCPResourceUnsubscribeParams, type MCPResourcesListResult, MCPServer, type MCPServerConfig, type MCPServerModeOptions, type MCPServerPromptRegistration, type MCPServerResourceRegistration, type MCPServerScope, type MCPServerState, type MCPTool, type MCPToolCallParams, type MCPToolCallResult, type MCPToolsListResult, type MCPTransport, type MCPTransportConnection, MEMORY_FILES, MOTION_CAPABILITIES, MOTION_SYSTEM_PROMPT, MOTION_TOOL_NAMES, type ManifestValidationResult, type MaterialConfig, type MemoryBudget, type MemoryEntry, type MemoryFile, type MemoryLevel, MemoryManager, type MemoryManagerOptions, type MeshInfo, type Message, MessageFlow, type MessageFlowDeps, type ModeSwitchRequest, type ModelInfo, type ModelProvider, ModelProviderRegistry, type MotionAgentOptions, type MotionPromptParams, NOTES_CAPABILITIES, NOTES_TOOL_NAMES, type NotePageInfo, type NoteSearchResult, type NotesAgentOptions, type NotesToolAdapter, type OnChunkCallback, PIXEL_CAPABILITIES, PIXEL_SYSTEM_PROMPT, PIXEL_TOOL_NAMES, PROJECT_STATE_VERSION, type PermissionConfig, type PermissionDecision, type PermissionDecisionEvent, type PermissionDecisionHook, PermissionEngine, type PermissionInfo, type PermissionPromptFn, type PermissionPromptInfo, type PermissionPromptOperation, type PermissionPromptPreview, type PermissionPromptPreviewLine, type PermissionRequestContext, type PermissionRequestInfo, type PermissionRequestResult, type PermissionRule, type PersistentPermissionState, type PixelAgentOptions, type PixelPromptParams, type PlatformInfo, type PluginActivationEvent, type PluginAuthor, type PluginCapability, type PluginCommandContribution, type PluginCommandHandler, type PluginContext, type PluginContributions, type PluginEngineConstraint, type PluginEvent, PluginEventBus, type PluginEventListener, type PluginEventType, type PluginHook, PluginHost, type PluginHostInfo, type PluginHostOptions, type PluginInfo, type PluginListing, type PluginLogger, PluginManager, type PluginManagerOptions, type PluginManifest, PluginMarketplace, type PluginMarketplaceOptions, type PluginPermission, type PluginPromptContribution, type PluginPublishOptions, PluginSandbox, type PluginSandboxOptions, type PluginScaffoldOptions, type PluginSearchOptions, type PluginSettingContribution, PluginSettingsManager, type PluginStatus, type PluginStorage, type PluginTestCase, type PluginTestResult, PluginToolBuilder, type PluginToolContribution, type PluginUIPanel, type ProfileMCPServerConfig, ProfileManager, type ProjectConfig, type ProjectInfo, type ProjectMcpApprovalDecision, type ProjectSessionContext, type ProjectSessionContextEntry, type ProjectSessionSummary, type ProjectTokenUsageSummary, type PromptContext, type PromptFn, type PromptMemoryContextInfo, type PromptSectionContext, type PromptSectionProvider, PromptSectionRegistry, type ProviderStatus, type RecentSessionEntry, type RecentSessionsIndex, type ReducedResult, type ReducerOptions, type RegisteredTool, type RenderConfig, type ResolveXenoSdkApiKeyOptions, type ResolvedIdentity, type ResolvedMemory, type ResolvedProvider, type ResolvedSubagentWorkflowAnswer, type ResourceContentBlock, type RoomInfo, type RunDelegatedXenoTurnOptions, type RunStreamOptions, type RuntimeManifestFileEntry, type RuntimeManifestInspectionResult, type RuntimePluginManifestEntry, SDK_DEFAULT_MAX_ITERATIONS, SDK_DEFAULT_MAX_TOKENS, SESSION_FORMAT_VERSION, SHEETS_CAPABILITIES, SHEETS_TOOL_NAMES, SLIDES_CAPABILITIES, SLIDES_TOOL_NAMES, SOUND_CAPABILITIES, SOUND_SYSTEM_PROMPT, SOUND_TOOL_NAMES, SSETransport, SUBAGENT_ROLE_ALIASES, SUBAGENT_TEAM_PRESETS, type SandboxCheckResult, type ScoredMemory, ScreenCapture, type ScreenCaptureConfig, type SearchConfig, type SearchProvider, type Session, type SessionCreateOptions, type SessionData, type SessionEndData, type SessionIntegrationConfig, SessionLock, SessionLock as SessionLockManager, SessionManager, type SessionMeta, SessionRegistry, type SessionResumeOptions, type SessionRuntimeBaseOptions, type SessionRuntimeState, type SessionStartData, type SessionStatus, type SessionSummary, type SetupAIHandlersOptions, type ShapeConfig, type SheetsAgentOptions, type SheetsToolAdapter, type ShutdownCleanup, type SlideInfo, type SlidesAgentOptions, type SlidesToolAdapter, type SortConfig, type SoundAgentOptions, type SoundPromptParams, type SpeechRecognizer, type SpeechRecognizerCallbacks, type SpeechRecognizerConfig, StdioTransport, type StemSeparationResult, type StopReason, type StoredConversation, type StoredMessage, type StoredToolCall, type StreamResult, type SubagentBranchPolicy, type SubagentExecuteFn, type SubagentExecutionRequest, type SubagentExecutionResponse, type SubagentRemoteMcpAccess, type SubagentResult, type SubagentRole, type SubagentTask, type SubagentTeamPreset, type SubagentTeamPresetDefinition, type SubagentWorkflowMode, type SubagentWorkflowOptions, type SubagentWorkflowResult, type SystemPromptInspectionResult, THREE_D_CAPABILITIES, THREE_D_TOOL_NAMES, type TaskCompletionCallback, type TestResult, type TextBlock, type ThreeDAgentOptions, type ThreeDToolAdapter, type TimelineInfo, type TokenUsageTotals, type ToolAssistantContentBlock, type ToolCallData, type ToolDefinition, type ToolExecutor, type ToolManifestEntry, type ToolMiddleware, type ToolMiddlewareContext, ToolMiddlewareRegistry, ToolOrchestrator, type ToolOrchestratorCallbacks, type ToolOrchestratorConfig, ToolRegistry, type ToolRegistryOptions, type ToolResult, type ToolResultBlock, type ToolResultContent, type ToolResultData, type ToolRuntimeContext, type ToolUseBlock, type TraceGraph, type TraceGraphEdge, type TraceGraphNode, type TrackContext, type TranscriptEvent, type TranscriptEventData, type TranscriptEventType, TranscriptWriter, type TranscriptionResult, type TranscriptionSegment, type TransitionConfig, type TurnDiffSummary, TurnDiffTracker, type TurnDiffTrackerOptions, type TurnFileDiff, TurnRestoreManager, UnifiedExecManager, type UnifiedExecOutput, type UnifiedExecOutputChunk, type UnifiedExecOutputDelta, type UnifiedExecProcess, type UnifiedExecReadDeltaOptions, type UnifiedExecStartOptions, type UnifiedExecStatus, type UnifiedExecStream, type ValidateXenoSdkApiKeyOptions, type VectorDocument, VectorMemoryStore, type VectorSearchResult, type VectorStoreAdapter, type VectorStoreOptions, type VideoToolAdapter, WORKFLOW_CAPABILITIES, WORKFLOW_TOOL_NAMES, type WebSearchResult, type WorkflowAgentOptions, type WorkflowExecutionResult, type WorkflowInfo, type WorkflowNodeConfig, type WorkflowToolAdapter, WorkspaceIndex, type WorkspaceScanOptions, XENO_API_BASE, XENO_RT_DEFAULT_URL, XenoAppServer, type XenoAppServerOptions, XenoAuthError, type XenoAuthErrorCode, type XenoConfig, type XenoCredentialSource, type XenoCredentialType, type XenoJwtPayload, type XenoProjectState, type XenoResolvedApiKey, type XenoRuntimeEvent, type XenoRuntimeEventBase, XenoRuntimeEventBus, type XenoRuntimeEventDraft, type XenoRuntimeEventSink, type XenoRuntimeEventType, type XenoThreadRunOptions, type XenoThreadRunResult, XenoTraceGraphRecorder, type XenoUserConfig, activateSessionRuntime, addProjectAllowedDirectory, addProjectAllowedTool, appendBoundedShellOutput, appendGuidanceToResult, approveMcpServer, areSignalHandlersInstalled, artifactCompareTool, askUserTool, assertUsableXenoApiKey, auditRiskLevelForTool, backgroundProcessManager, bashTool, benchmarkCodingTools, buildAuditReplayReport, buildAuditTraceReport, buildDefaultSubagentTasks, buildDelegatedRoleSystemPrompt, buildMotionSystemPrompt, buildPixelSystemPrompt, buildPromptMemoryContext, buildSoundSystemPrompt, buildSystemPrompt, calculateCost, canonicalizeToolName, checkSandbox, cleanupSessionRuntime, clearMcpServerApproval, clearProjectAllowedTools, clearProjectLastSessionSummary, clearProjectMcpApproval, clearProjectMcpApprovals, coerceSubagentRole, coerceSubagentTeamPreset, configureSearch, copyTextToClipboard, create3DTools, createArchitectTools, createArtifactCompareTool, createAskUserTool, createAudioTools, createAuditBackedPermissionEngine, createBashTool, createDefaultToolRegistry, createDelegatedXenoAgent, createDispatchAgentTool, createDocsTools, createEditTool, createElfAnalyzeTool, createEngineTools, createGcodeAnalyzeTool, createGlobTool, createGrepTool, createHtmlSanitizerAuditTool, createImageTools, createLsTool, createMcpPromptRegisteredTool, createMcpRegisteredTool, createMcpResourceRegisteredTool, createMemoryReadTool, createMemoryWriteTool, createNotebookEditTool, createNotebookReadTool, createNotesTools, createReadImageTool, createReadTool, createSheetsTools, createSlidesTools, createSpeechRecognizer, createSqliteAnalyzeTool, createThinkTool, createToolAlias, createToolRuntimeContext, createVideoTools, createWebSearchTool, createWorkflowTools, createWriteTool, createXenoAgent, decodeJwtPayload, defaultToolRuntimeContext, deleteSession, denyMcpServer, detectLanguage, deterministicReduce, dispatchAgentTool, editTool, elfAnalyzeTool, ensureConfigDir, ensureProjectStateDir, extractToolPath, forgetRecentSession, forgetRecentSessionById, formatBoundedShellOutput, formatCost, formatJsonSchemaErrors, formatModelList, formatPromptContextBreakdown, gcodeAnalyzeTool, generateSessionId, getAvailableModels, getBenchmarkComputeBudgetHintForCommand, getBenchmarkForegroundTimeoutForCommand, getChatModels, getConfigDir, getDefaultProviderRegistry, getGlobIgnores, getGrepIgnores, getHighRiskPermissions, getJwtExpiry, getLogLevel, getMcpApprovalDecision, getMcpPromptToolName, getMcpResourceToolName, getMcpToolName, getModelName, getPersistentShellSession, getPersistentShellSpawnSpec, getProjectLastSessionSummary, getProjectMcpApproval, getProjectStatePath, getRecentSessionsIndexPath, getSubagentTeamPresetDefinition, getToolRiskLevel, gitBranchTool, gitCommitTool, gitDiffTool, gitLogTool, gitStatusTool, globTool, grepTool, hasProjectOnboardingCompleted, htmlSanitizerAuditTool, initializeSessionRuntime, inspectRuntimeManifests, inspectSystemPrompt, installSignalHandlers, isChatModel, isDangerousCommand, isExpiredJwt, isJwt, isLocalModel, isNotBeforeJwt, isPathWithinAllowed, isScreenCaptureAvailable, isSpeechRecognitionAvailable, isValidModel, isValidSessionId, isWorkspaceTrusted, listProjectAllowedTools, listProjectMcpApprovals, listSessions, loadConfig, loadConfiguredMcpServers, loadMcpConfigFile, loadProjectConfig, loadProjectState, loadRecentSessionsIndex, loadSession, lookupRecentSession, lsTool, matchesMcpRegistryEntryPolicy, memoryReadTool, memoryWriteTool, mergeConfigs, normalizeSubagentBranchPolicy, normalizeWorkingDirectory, notebookEditTool, notebookReadTool, parseSessionId, parseSubagentRemoteMcpPolicy, parseSubagentRoleList, preflightLocalModel, publishPlugin, readImageTool, readManifestFromDisk, readSessionFormatVersion, readTool, readXenoApiKey, recordRecentSession, registerShutdownCleanup, registry, removeMcpServerConfig, removeProjectAllowedTool, renderAuditReplayMarkdown, renderAuditReplayReport, renderAuditTraceMarkdown, renderAuditTraceReport, renderAuditTraceSummaries, renderCodingBenchmarkMarkdown, renderCodingBenchmarkReport, requestBackground, resetAllPersistentShellSessions, resetBashBenchmarkGuards, resetMcpServerApprovals, resetPersistentShellSession, resolveDelegatedExecutionMode, resolveSubagentRemoteMcpAccess, resolveSubagentWorkflowAnswer, resolveXenoSdkApiKey, runDelegatedXenoTurn, runDelegationPlan, runSubagentWorkflow, runXenoThread, runXenoThreadStreamed, sanitizeEnvironment, saveConfig, saveMcpConfigFile, saveProjectState, saveSession, scaffoldPlugin, scoreMemories, setLogLevel, setProjectLastSessionSummary, setProjectMcpApproval, setProjectOnboardingCompleted, setWorkspaceTrusted, setupAIHandlers, shouldSourceShellProfile, shouldUseIsolatedStdinForCommand, sqliteAnalyzeTool, summarizeAuditInputRecord, summarizeAuditTraces, summarizeRuntimeInput, summarizeSubagentResults, syncMcpToolsToRegistry, taskOutputTool, taskStopTool, testPlugin, thinkTool, toLLMProvider, unifiedExecManager, updateProjectState, upsertMcpServerConfig, validateDelegationPlan, validateJsonSchema, validateManifest, validateXenoSdkApiKey, webFetchTool, webSearchTool, writeTool };