@kvell007/embed-labs-cli 0.1.0-alpha.97 → 0.1.0-alpha.99

package/dist/agent-runtime.d.ts

@@ -0,0 +1,2137 @@
+import { type ApiResponse } from "@embed-labs/protocol";
+import { type OptimizationReportCategory, type OptimizationSeverity } from "@embed-labs/shared-schemas";
+import { type LocalCompileOptions, type LocalCompileResult, type LocalToolchainInstallOptions, type LocalToolchainInstallResult, type LocalToolchainListOptions, type LocalToolchainListResult, type LocalToolchainUninstallOptions, type LocalToolchainUninstallResult } from "./local-toolchain.js";
+export interface AgentCliArgs {
+    command: string[];
+    flags: Record<string, string | boolean | Array<string | boolean>>;
+    passthrough?: string[];
+}
+export interface AgentInstallationIdentityStatusSnapshot {
+    local_agent_ready: boolean;
+    identity_scope: "local_installation";
+    uses_local_installation_identity: true;
+    installation_id?: string;
+    installation_integrity?: string;
+    local_identity_profile?: string;
+}
+export interface AgentIdentitySetupGuidance {
+    required: true;
+    message: string;
+    identity_command: string;
+    status_command: string;
+    steps: string[];
+}
+interface AgentIdentityGateIssue {
+    code: "device_binding_required" | "tool_integrity_check_failed" | "installation_identity_required";
+    message: string;
+    remediation: string;
+}
+export interface AgentRuntimeDependencies {
+    installationIdentityStatus(): Promise<AgentInstallationIdentityStatusSnapshot>;
+    bridgeGet<T>(path: string): Promise<ApiResponse<T>>;
+    bridgePost<T>(path: string, body: unknown): Promise<ApiResponse<T>>;
+    cloudGet<T>(path: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<ApiResponse<T>>;
+    cloudPost<T>(path: string, body: unknown, options?: {
+        signal?: AbortSignal;
+        headers?: Record<string, string>;
+    }): Promise<ApiResponse<T>>;
+    listLocalToolchainEnvironments?(options: LocalToolchainListOptions): Promise<LocalToolchainListResult>;
+    installLocalToolchain?(options: LocalToolchainInstallOptions): Promise<LocalToolchainInstallResult>;
+    uninstallLocalToolchain?(options: LocalToolchainUninstallOptions): Promise<LocalToolchainUninstallResult>;
+    compileTaishanPiSingleFile?(options: LocalCompileOptions): Promise<LocalCompileResult>;
+    adminConsoleUrl: string;
+    bridgeUrl: string;
+    clientName: string;
+    clientVersion: string;
+}
+export interface LocalAgentRunResult {
+    runtime: "embedlabs-local-agent";
+    session_id: string;
+    prompt: string;
+    intent: AgentIntent;
+    answer: string;
+    prompt_assembly: AgentPromptAssembly;
+    model_invocation: AgentModelInvocationTrace;
+    session_adapter: AgentSessionAdapterTrace;
+    installation_identity: AgentInstallationIdentityAdapterTrace;
+    local_execution: AgentLocalExecutionTrace;
+    next_commands?: AgentNextCommand[];
+    installation_identity_status: AgentInstallationIdentityStatusSnapshot;
+    memory: AgentMemorySummary;
+    memory_context: AgentMemoryContext;
+    memory_suggestions?: AgentMemorySuggestion[];
+    response_preferences?: AgentResponsePreference[];
+    bridge?: AgentBridgeSnapshot;
+    report?: AgentReportUploadResult;
+    secondary_reports?: AgentReportUploadResult[];
+    advisories?: AgentRunAdvisory[];
+    public_experience: AgentPublicExperienceSummary;
+    maintainer?: AgentMaintainerResult;
+    auto_sync?: AgentSyncResult;
+    persistence_warnings?: AgentPersistenceWarning[];
+    identity_setup?: AgentIdentitySetupGuidance;
+    session_path: string;
+}
+export interface AgentRunAdvisory {
+    code: string;
+    source: "secondary_report" | "local_persistence" | "model_config";
+    severity: "info" | "warning";
+    affects_primary_action: false;
+    message: string;
+    remediation?: string;
+    report_id?: string;
+    report_status?: "uploaded" | "pending" | "failed";
+    target?: "memory" | "session" | "skill_candidate" | "report";
+    path_ref?: string;
+}
+interface AgentPersistenceWarning {
+    code: "local_persistence_unavailable";
+    message: string;
+    target: "memory" | "session" | "skill_candidate" | "report";
+    path_ref: string;
+    error_code?: string;
+    remediation: string;
+}
+interface AgentModelRuntimeInvalidToolCall {
+    requested_name: string;
+    requested_name_sha256: string;
+    arguments_sha256?: string;
+}
+interface AgentModelRuntimeResult {
+    enabled: boolean;
+    mode: "disabled_by_default" | "explicit_openai_compatible";
+    provider_kind: "embedlabs.local_openai_compatible_runtime_provider";
+    provider_contract: "embedlabs.model_runtime_provider.v1";
+    replacement_target: "upstream_model_runtime_provider";
+    request_endpoint_path: "/chat/completions";
+    streaming_requested: true;
+    model_request_count: number;
+    network_call_performed: boolean;
+    response_state: "not_enabled" | "missing_model_config" | "completed" | "failed";
+    response_source: "none" | "openai_compatible_response";
+    streaming_response?: AgentModelStreamingResponseSummary;
+    answer?: string;
+    assistant_message_sha256?: string;
+    tool_call_count: number;
+    dispatched_tool_call_count: number;
+    tool_call_dispatch_state: "not_enabled" | "no_tool_calls" | "first_high_level_action_dispatched" | "side_effect_approval_stripped" | "invalid_tool_call" | "failed";
+    dispatched_actions?: Array<{
+        action_id: AgentActionId;
+        ok: boolean;
+        summary_sha256: string;
+        approval_from_model_ignored: boolean;
+    }>;
+    invalid_tool_call?: AgentModelRuntimeInvalidToolCall;
+    tool_result_summary?: {
+        requested: boolean;
+        state: "not_requested" | "completed" | "failed";
+        message_count: number;
+        tool_result_sha256?: string;
+        final_answer_sha256?: string;
+        streaming_response?: AgentModelStreamingResponseSummary;
+    };
+    error?: {
+        code: string;
+        message: string;
+    };
+    privacy_boundary: {
+        local_provider_credentials_only: true;
+        request_body_not_persisted: true;
+        raw_model_response_not_persisted: true;
+        raw_prompt_trace_stored: false;
+        credential_material_exported: false;
+        no_platform_auth_gate: true;
+    };
+}
+interface AgentModelStreamingResponseSummary {
+    requested: true;
+    format: "sse" | "json";
+    incremental_reader: boolean;
+    chunk_count: number;
+    raw_response_persisted: false;
+}
+interface AgentSessionAdapterTrace {
+    kind: "embedlabs.upstream_session_adapter";
+    schema_version: 1;
+    provider_kind: "embedlabs.local_session_provider";
+    provider_contract: "embedlabs.session_provider.v1";
+    provider_replacement_target: "upstream_session_provider";
+    storage_home: "~/.embedlabs/agent/sessions";
+    storage_format: "json_session_files";
+    session_id: string;
+    session_ref: string;
+    session_path_hash: string;
+    index_source: "readUpstreamCompatibleSessionIndex";
+    index_contract: "upstream_compatible_session_index";
+    search_target: "upstream_session_search";
+    lifecycle: {
+        create: "persist_after_agent_turn";
+        update: "rewrite_after_memory_summary";
+        index_refresh: "readUpstreamCompatibleSessionIndex_on_demand";
+        search: "local_session_index_search";
+    };
+    search_strategy: {
+        kind: "safe_local_session_index";
+        source: "readUpstreamCompatibleSessionIndex";
+        target: "upstream_session_search";
+        prompt_material: "redacted_prompt_excerpt";
+        execution_summary: "compact_local_execution_trace";
+        max_index_entries: 200;
+    };
+    write_policy: {
+        prompt_storage: "redacted_prompt";
+        answer_storage: "local_agent_answer";
+        raw_model_response_storage: "disabled";
+        public_upload_path: "redacted_public_reports_only";
+    };
+    prompt_storage: "redacted_prompt";
+    privacy_boundary: {
+        local_only: true;
+        raw_prompt_exported_by_default: false;
+        raw_personal_memory_uploaded_by_default: false;
+        absolute_paths_exported: false;
+    };
+}
+interface AgentInstallationIdentityAdapterTrace {
+    kind: "embedlabs.upstream_installation_identity_adapter";
+    schema_version: 1;
+    provider_kind: "embedlabs.local_installation_identity_provider";
+    provider_contract: "embedlabs.installation_identity_provider.v1";
+    provider_replacement_target: "upstream_profile_identity_provider";
+    identity_kind: "embedlabs.local_installation_identity";
+    installation_id: string;
+    profile: "default";
+    storage_home: "~/.embedlabs/agent";
+    installation_ref: "installation.json";
+    installation_path_hash: string;
+    fingerprint_version: "v1";
+    fingerprint_integrity: "ok" | "failed" | "missing";
+    fingerprint_hash?: string;
+    current_fingerprint_hash?: string;
+    fingerprint_source?: string;
+    current_fingerprint_source?: string;
+    key_algorithm?: "ed25519";
+    public_key_sha256?: string;
+    public_key_configured: boolean;
+    local_keypair_configured: boolean;
+    platform: string;
+    arch: string;
+    hostname_hash?: string;
+    copied_installation_policy: "fingerprint_mismatch_requires_reinitialize";
+    memory_scope: "local_personal_memory_by_installation";
+    public_experience_scope: "redacted_reports_attributed_by_installation";
+    privacy_boundary: {
+        local_only: true;
+        raw_hardware_id_exported: false;
+        identity_key_material_exported: false;
+        user_model_key_uploaded: false;
+        uses_local_installation_identity: true;
+    };
+}
+interface AgentPromptAssemblyModelConfig {
+    adapter_kind: "embedlabs.upstream_model_provider_config_adapter";
+    schema_version: 1;
+    profile_source: "embedlabs_local_config";
+    provider_key_storage: "local_config_or_env";
+    upstream_concepts: ["provider", "profile", "base_url", "model", "local_key_reference"];
+    config_path: string;
+    default_profile: string;
+    selected_profile?: string;
+    configured: boolean;
+    provider?: string;
+    model?: string;
+    base_url?: string;
+    api_key: "set" | "env" | "missing";
+    api_key_env?: string;
+    agent_runtime: {
+        enabled: boolean;
+        activation_source: "local_model_config" | "env_override" | "disabled";
+        mode: "local_openai_compatible";
+    };
+    privacy: "local_only_no_key_exported";
+}
+interface AgentProfileProviderAdapterTrace {
+    kind: "embedlabs.upstream_profile_provider_adapter";
+    schema_version: 1;
+    provider_kind: "embedlabs.local_profile_provider";
+    provider_contract: "embedlabs.profile_provider.v1";
+    provider_replacement_target: "upstream_profile_provider";
+    storage_home: "~/.embedlabs/agent";
+    scope: "installation_local_profiles";
+    model_config_source: "embedlabs_local_config";
+    installation_profile_source: "embedlabs.local_installation_identity";
+    board_profile_source: "local_personal_memory_profiles";
+    selected_model_profile: string;
+    installation_profile: "default";
+    profile_context_entry_count: number;
+    board_profile_context_entries: number;
+    profile_types: [
+        "model_provider_profile",
+        "installation_profile",
+        "board_memory_profile"
+    ];
+    lifecycle: {
+        read: "prompt_assembly_profile_resolution";
+        write: "local_config_and_memory_profile_writes";
+        upstream_sync: "adapter_boundary_only_until_upstream_runtime";
+    };
+    write_policy: {
+        model_provider_profiles_local_config_only: true;
+        installation_profile_local_only: true;
+        board_profiles_personal_memory_only: true;
+        public_promotion_requires_owner_review: true;
+    };
+    privacy_boundary: {
+        local_only: true;
+        model_credentials_uploaded: false;
+        raw_hardware_id_exported: false;
+        raw_personal_memory_uploaded_by_default: false;
+        uses_local_installation_identity: true;
+    };
+}
+interface AgentModelInvocationTrace {
+    kind: "embedlabs.upstream_model_invocation_adapter";
+    schema_version: 1;
+    provider_kind: "embedlabs.local_model_invocation_provider";
+    provider_contract: "embedlabs.model_invocation_provider.v1";
+    provider_replacement_target: "upstream_model_runtime_provider";
+    config_adapter: "embedlabs.upstream_model_provider_config_adapter";
+    config_source: "embedlabs_local_config";
+    selected_profile: string;
+    configured: boolean;
+    provider?: string;
+    model?: string;
+    base_url?: string;
+    request_preflight_state: "ready" | "missing_model_config";
+    request_contract: "openai_chat_completions_compatible";
+    request_endpoint_path: "/chat/completions";
+    payload_contract: "embedlabs.messages_with_high_level_actions.v1";
+    tool_schema_source: "prompt_assembly.tool_registry";
+    local_credentials_source: "local_config_or_env";
+    streaming_supported: true;
+    request_preview: {
+        method: "POST";
+        message_source: "prompt_assembly";
+        message_count: 3;
+        memory_prompt_context: "sanitized_summary_only";
+        memory_prompt_context_entries: number;
+        memory_prompt_context_sha256: string;
+        chat_session_context: "bounded_sanitized_turn_summaries" | "none";
+        chat_session_context_entries: number;
+        chat_session_context_sha256?: string;
+        tool_count: number;
+        tool_schema_format: "openai_chat_completions_tools";
+        tool_schema_contract: "embedlabs.high_level_action_tools.v1";
+        tool_schema_sha256: string;
+        tool_choice: "auto";
+        stream: true;
+        redacted_body_contract: "model_tool_request_without_raw_prompt_or_credentials";
+        redacted_body_sha256: string;
+        includes_raw_prompt: false;
+        includes_credential_material: false;
+    };
+    dry_run_fixture: {
+        enabled: true;
+        response_contract: "openai_chat_completion_response_fixture";
+        response_source: "local_deterministic_fixture";
+        response_id_prefix: "chatcmpl_embedlabs_fixture";
+        choice_count: 1;
+        finish_reason: "stop";
+        assistant_message_source: "agent_answer";
+        assistant_message_sha256: string;
+        tool_call_count: 0;
+        parsed_output_kind: "assistant_message";
+        response_preview: {
+            object: "chat.completion";
+            message_role: "assistant";
+            choice_index: 0;
+            usage_policy: "not_recorded_for_fixture";
+            redacted_response_contract: "openai_chat_completion_without_raw_content";
+            redacted_response_sha256: string;
+        };
+        includes_raw_model_response: false;
+        network_required: false;
+    };
+    runtime_result: AgentModelRuntimeResult;
+    runtime_activation: {
+        current_state: "dry_run_preflight_only" | "explicit_runtime_enabled";
+        next_provider: "audited_upstream_model_runtime_provider";
+        activation_gate: "owner_review_plus_smoke_before_network_calls";
+        required_capabilities: [
+            "streaming_chat_completions",
+            "tool_call_dispatch_to_embedlabs_high_level_actions",
+            "local_provider_credentials_read_at_call_time",
+            "redacted_request_response_tracing"
+        ];
+        forbidden_behaviors: [
+            "remote_embedlabs_model_proxy_by_default",
+            "raw_prompt_or_credential_trace_storage",
+            "remote_service_gate_for_local_agent",
+            "low_level_mcp_tools_exposed_to_model"
+        ];
+    };
+    invocation_state: "skipped_deterministic_loop" | "completed_explicit_local_model_runtime" | "failed_explicit_local_model_runtime";
+    reason: "current_loop_uses_high_level_deterministic_actions" | "explicit_local_model_runtime_opt_in";
+    network_call_performed: boolean;
+    remote_embedlabs_model_used: false;
+    credential_material_exported: false;
+    privacy_boundary: {
+        local_provider_credentials_only: true;
+        raw_prompt_uploaded_by_default: false;
+        no_platform_auth_gate: true;
+        no_cloud_model_proxy: true;
+    };
+}
+interface AgentPromptAssembly {
+    kind: "embedlabs.upstream_prompt_assembly";
+    mode: "upstream_adapter";
+    generated_at: string;
+    local_only: true;
+    prompt_sha256: string;
+    intent_id: AgentIntent["id"];
+    model_config: AgentPromptAssemblyModelConfig;
+    profile_provider: AgentProfileProviderAdapterTrace;
+    tool_registry: AgentToolRegistryAdapterTrace;
+    context: {
+        memory_source: "local_personal_memory";
+        memory_context_entries: number;
+        memory_source_labels: string[];
+        memory_prompt_context: AgentPromptMemoryContext;
+        chat_session_context?: AgentChatSessionPromptContext;
+        available_action_count: number;
+        allowed_action_ids: AgentActionId[];
+        bridge?: {
+            runtime: "go-local-bridge";
+            endpoints: ["/healthz", "/v1/devices"];
+            ok: boolean;
+            board_count?: number;
+            device_count?: number;
+            error_code?: string;
+        };
+    };
+    upstream_adapter: {
+        upstream_reference: string;
+        audited_version: string;
+        audited_tag: string;
+        direct_upstream_source_imported: false;
+        next_step: "replace_deterministic_planner_with_upstream_backed_loop";
+    };
+    privacy_boundary: {
+        user_model_key_uploaded: false;
+        raw_personal_memory_uploaded: false;
+        raw_prompt_uploaded_by_default: false;
+        board_state_source: "go-local-bridge";
+    };
+}
+interface AgentPromptMemoryContext {
+    kind: "embedlabs.upstream_memory_prompt_context_adapter";
+    schema_version: 1;
+    provider_kind: "embedlabs.local_personal_memory_provider";
+    source: "local_personal_memory";
+    injection_mode: "sanitized_summary_only";
+    max_entries: 5;
+    included_entries: number;
+    entries: AgentPromptMemoryEntry[];
+    prompt_fragment_sha256: string;
+    privacy_boundary: {
+        raw_personal_memory_included: false;
+        absolute_paths_included: false;
+        user_model_key_included: false;
+        local_file_refs_are_symbolic: true;
+    };
+}
+interface AgentPromptMemoryEntry {
+    kind: AgentMemoryContextEntry["kind"];
+    title: string;
+    summary?: string;
+    source_label: string;
+    source_ref: string;
+    source_hash?: string;
+    relevance_score: number;
+    matched_terms: string[];
+    board_id?: string;
+    intent?: string;
+    privacy_scope: "local_personal_memory";
+}
+interface AgentToolRegistryAdapterTrace {
+    kind: "embedlabs.upstream_tool_registry_adapter";
+    schema_version: 1;
+    provider_kind: "embedlabs.high_level_action_registry_provider";
+    provider_contract: "embedlabs.tool_registry_provider.v1";
+    provider_replacement_target: "upstream_tool_registry_provider";
+    source_catalog: "AGENT_ACTION_CATALOG";
+    registry_contract: "embedlabs.high_level_action_registry.v1";
+    action_surface: "embedlabs_high_level_actions";
+    action_count: number;
+    allowed_action_ids: AgentActionId[];
+    tool_schema_format: "openai_chat_completions_tools";
+    tool_schema_contract: "embedlabs.high_level_action_tools.v1";
+    tool_schema_count: number;
+    tool_schema_sha256: string;
+    openai_tools: AgentOpenAIChatToolSchema[];
+    mcp_visibility: "internal_compatibility_only";
+    low_level_tool_policy: {
+        expose_low_level_mcp_tools_to_model: false;
+        hardware_state_source: "go-local-bridge";
+        board_facts_source: "boardpack";
+        side_effects_fail_closed: true;
+    };
+}
+interface AgentOpenAIChatToolSchema {
+    type: "function";
+    function: {
+        name: AgentActionId;
+        description: string;
+        parameters: {
+            type: "object";
+            additionalProperties: false;
+            required: string[];
+            properties: Record<string, AgentOpenAIChatToolProperty>;
+        };
+    };
+}
+interface AgentOpenAIChatToolProperty {
+    type: "string" | "boolean" | "number" | "array" | "object";
+    description: string;
+    enum?: string[];
+    default?: string | number | boolean;
+    items?: {
+        type: "string";
+    };
+    additionalProperties?: true;
+    "x-embedlabs-source": AgentActionInputSchema["source"];
+    "x-embedlabs-sensitive"?: true;
+    "x-embedlabs-aliases"?: string[];
+}
+export interface AgentStatusResult {
+    runtime: "embedlabs-local-agent";
+    client: {
+        name: string;
+        version: string;
+        platform: string;
+        arch: string;
+    };
+    model: AgentStatusModelSummary;
+    installation: AgentInstallationStatus;
+    memory: AgentMemorySummary;
+    persistence: AgentPersistenceStatus;
+    memory_provider_status: AgentMemoryProviderStatus;
+    action_registry_status: AgentActionRegistryStatus;
+    upstream_adapter: AgentUpstreamAdapterSummary;
+    plugin_integrations: AgentPluginIntegrationSummary;
+    closed_loop: AgentClosedLoopReadiness;
+    bridge: AgentBridgeSnapshot;
+    public_experience: AgentPublicExperienceSummary;
+    next_commands?: AgentNextCommand[];
+}
+interface AgentActionRegistryStatus {
+    kind: "embedlabs.agent_action_registry_status";
+    readiness: "ready";
+    provider_kind: AgentToolRegistryAdapterTrace["provider_kind"];
+    provider_contract: AgentToolRegistryAdapterTrace["provider_contract"];
+    provider_replacement_target: AgentToolRegistryAdapterTrace["provider_replacement_target"];
+    source_catalog: AgentToolRegistryAdapterTrace["source_catalog"];
+    registry_contract: AgentToolRegistryAdapterTrace["registry_contract"];
+    action_surface: AgentToolRegistryAdapterTrace["action_surface"];
+    action_count: number;
+    allowed_action_ids: AgentActionId[];
+    tool_schema_format: AgentToolRegistryAdapterTrace["tool_schema_format"];
+    tool_schema_contract: AgentToolRegistryAdapterTrace["tool_schema_contract"];
+    tool_schema_count: number;
+    tool_schema_sha256: string;
+    mcp_visibility: AgentToolRegistryAdapterTrace["mcp_visibility"];
+    low_level_tool_policy: AgentToolRegistryAdapterTrace["low_level_tool_policy"];
+    privacy_boundary: {
+        low_level_mcp_tools_exposed_to_model: false;
+        raw_tool_schema_body_exposed_in_status: false;
+        hardware_state_source: "go-local-bridge";
+        board_facts_source: "boardpack";
+    };
+}
+interface AgentClosedLoopReadiness {
+    kind: "embedlabs.agent_closed_loop_readiness";
+    local_identity_ready: boolean;
+    memory_ready: boolean;
+    agent_persistence_ready: boolean;
+    bridge_inventory_ready: boolean;
+    plugin_transport_ready: boolean;
+    plugin_installation_ready: boolean;
+    plugin_install_required: boolean;
+    plugin_update_required: boolean;
+    plugin_missing_targets: Array<"codex" | "opencode" | "trae">;
+    plugin_stale_targets: Array<"codex" | "opencode" | "trae">;
+    plugin_unwritable_targets: Array<"codex" | "opencode" | "trae">;
+    model_config_ready: boolean;
+    public_report_queue_ready: boolean;
+    admin_review_ready: boolean;
+    admin_review_state: "ready" | "sync_required" | "no_reports";
+    maintainer_handoff_ready: boolean;
+    maintainer_handoff_state: "ready" | "sync_required" | "no_reports";
+    board_count: number;
+    pending_report_count: number;
+    local_tool_loop_ready: boolean;
+    native_agent_runtime_ready: boolean;
+    minimum_loop_ready: boolean;
+    retained_plugin_targets: Array<"codex" | "opencode" | "trae">;
+    blocking_reasons: string[];
+    advisory_warnings: string[];
+    next_commands?: AgentNextCommand[];
+}
+interface AgentPersistenceStatus {
+    kind: "embedlabs.agent_persistence_status";
+    readiness: "ready" | "warning";
+    home: string;
+    writable: boolean;
+    directories: Array<{
+        key: "memory" | "sessions" | "skills" | "reports" | "maintainer_tasks";
+        status: "ready" | "warning";
+        reason: "writable" | "missing" | "not_directory" | "not_writable";
+        error_code?: string;
+    }>;
+    warning_count: number;
+    remediation?: string;
+    next_commands?: AgentNextCommand[];
+    privacy_boundary: {
+        raw_agent_home_exported: false;
+        write_probe_content_exported: false;
+    };
+}
+interface AgentPluginIntegrationSummary {
+    kind: "embedlabs.ide_plugin_integrations";
+    mode: "native_agent_compatibility_transport";
+    default_tool_surface: "agent_first_six_tools";
+    mcp_server_name: "embed-labs";
+    default_visible_tools: [
+        "embedlabs_agent_status",
+        "embedlabs_action_schema",
+        "embedlabs_action_run",
+        "embedlabs_chat",
+        "embedlabs_plugin_update_check",
+        "embedlabs_plugin_update"
+    ];
+    local_identity_only: true;
+    normal_user_entrypoint: "plugin_install_then_high_level_agent_actions";
+    retained_targets: AgentPluginIntegrationTarget[];
+    install_all_command: string;
+    update_all_command: string;
+    installation_health: AgentPluginInstallationHealth;
+    privacy_boundary: {
+        plugin_stores_provider_key: false;
+        plugin_uploads_raw_source: false;
+        plugin_routes_through_local_agent: true;
+        low_level_tools_hidden_by_default: true;
+    };
+}
+interface AgentPluginIntegrationTarget {
+    id: "codex" | "opencode" | "trae";
+    display_name: string;
+    role: "ide_agent_transport";
+    default_tool_profile: "agent";
+    routes_through_local_agent: true;
+    requires_platform_token: false;
+    install_command: string;
+    update_command: string;
+    installed?: boolean;
+    installed_version?: string;
+    local_integrity?: AgentPluginLocalIntegrity;
+    target_write_access?: AgentPluginTargetWriteAccess;
+    target_path?: string;
+}
+interface AgentPluginInstallationHealth {
+    ready: boolean;
+    install_required: boolean;
+    update_required: boolean;
+    missing_targets: Array<"codex" | "opencode" | "trae">;
+    stale_targets: Array<"codex" | "opencode" | "trae">;
+    unwritable_targets: Array<"codex" | "opencode" | "trae">;
+    install_command?: string;
+    repair_command?: string;
+}
+interface AgentPluginLocalIntegrity {
+    status: "ok" | "not_installed" | "source_missing" | "source_checkout_stale" | "not_checked";
+    update_required: boolean;
+    summary: string;
+}
+interface AgentPluginTargetWriteAccess {
+    writable: boolean;
+    checked_path: string;
+    error_code?: string;
+    remediation?: string;
+}
+interface AgentStatusModelSummary {
+    kind: "embedlabs.local_model_config";
+    config_source: "embedlabs_local_config";
+    configured: boolean;
+    default_profile: string;
+    selected_profile?: string;
+    provider?: string;
+    model?: string;
+    api_key: "set" | "missing";
+    base_url: "configured" | "default" | "missing";
+    agent_runtime: {
+        enabled: boolean;
+        activation_source: "local_model_config" | "env_override" | "disabled";
+        mode: "local_openai_compatible";
+    };
+    privacy_boundary: {
+        provider_key_storage: "local_config_or_env";
+        provider_key_exported: false;
+        config_path_exported: false;
+        upstream_adapter_details_exported: false;
+    };
+}
+interface AgentUpstreamAdapterSummary {
+    kind: "embedlabs.upstream_adapter_status";
+    mode: "compatible_export";
+    available: true;
+    local_only: true;
+    raw_personal_memory_uploaded_by_default: false;
+    export_command: string;
+    audit_command: string;
+    audited_reference: {
+        version: string;
+        tag: string;
+        release_label_date: string;
+        published_at: string;
+        main_sha: string;
+        main_committed_at: string;
+        main_message: string;
+        main_ahead_of_latest_release: boolean;
+        license: "MIT";
+        audit_scope: "latest_named_release";
+    };
+    compatible_concepts: string[];
+    forbidden_takeover: string[];
+    upgrade_gates: string[];
+}
+export interface AgentIdentityResult {
+    action: "status" | "init";
+    reset: boolean;
+    installation: AgentInstallationStatus;
+    quarantined_personal_memory?: AgentPersonalMemoryQuarantineResult;
+    next_commands?: AgentNextCommand[];
+}
+interface AgentPersonalMemoryQuarantineResult {
+    reason: "copied_installation_fingerprint_mismatch";
+    quarantine_dir: string;
+    moved_dirs: string[];
+}
+interface AgentInstallationStatus {
+    kind: "embedlabs.local_installation_identity";
+    installation_id: string;
+    profile: "default";
+    installation_file: string;
+    memory_home: string;
+    fingerprint_version: "v1";
+    fingerprint_hash?: string;
+    current_fingerprint_hash?: string;
+    fingerprint_source?: string;
+    current_fingerprint_source?: string;
+    key_algorithm?: "ed25519";
+    public_key_sha256?: string;
+    public_key_configured: boolean;
+    private_key_configured: boolean;
+    integrity: "ok" | "failed" | "missing";
+    platform: string;
+    arch: string;
+    hostname_hash?: string;
+    copied_installation_policy: "fingerprint_mismatch_requires_reinitialize";
+    remediation?: string;
+}
+interface AgentPublicExperienceSummary {
+    reports_dir: string;
+    total_reports: number;
+    pending_reports: number;
+    failed_reports: number;
+    uploaded_reports: number;
+    superseded_reports?: number;
+    sync_required: boolean;
+    pending_summary?: AgentPublicExperienceQueueSummary;
+    latest_report_id?: string;
+    latest_report_status?: string;
+    latest_report_category?: string;
+    latest_report_title?: string;
+    latest_optimization_item_id?: string;
+    latest_admin_review_url?: string;
+    latest_create_fix_candidate_command?: string;
+    current_report_id?: string;
+    current_report_status?: string;
+    current_report_category?: string;
+    current_report_title?: string;
+    current_report_optimization_item_id?: string;
+    current_report_admin_review_url?: string;
+    current_report_create_fix_candidate_command?: string;
+}
+interface AgentPublicExperienceQueueSummary {
+    pending_by_category: AgentPublicExperienceQueueBucket[];
+    pending_by_severity: AgentPublicExperienceQueueBucket[];
+    pending_by_component: AgentPublicExperienceQueueBucket[];
+    pending_by_board: AgentPublicExperienceQueueBucket[];
+    pending_by_variant: AgentPublicExperienceQueueBucket[];
+    pending_by_action: AgentPublicExperienceQueueBucket[];
+    pending_by_capability: AgentPublicExperienceQueueBucket[];
+    pending_error_codes: AgentPublicExperienceQueueBucket[];
+}
+interface AgentPublicExperienceQueueBucket {
+    value: string;
+    count: number;
+}
+export interface AgentMemoryResult {
+    action: "show" | "status" | "export" | "clear" | "search" | "refine";
+    memory: AgentMemorySummary;
+    detail?: AgentMemoryDetail;
+    detail_limit?: number;
+    status?: AgentMemoryProviderStatus;
+    search?: AgentMemorySearchResult;
+    skill_candidate?: AgentMemorySkillCandidateRefinementResult;
+    exported_path?: string;
+    cleared?: boolean;
+}
+interface AgentMemoryProviderStatus {
+    schema_version: 1;
+    kind: "embedlabs.agent_memory_provider_status";
+    readiness: "ready" | "identity_required" | "integrity_failed";
+    provider: AgentMemoryProviderAdapterTrace;
+    storage: {
+        home: "~/.embedlabs/agent";
+        memory_dir: "memory";
+        sessions_dir: "sessions";
+        skills_dir: "skills";
+        reports_dir: "reports";
+        maintainer_tasks_dir: "maintainer-tasks";
+    };
+    counts: {
+        profile_memory_count: number;
+        workflow_memory_count: number;
+        failure_memory_count: number;
+        session_count: number;
+        skill_count: number;
+        maintainer_task_count: number;
+        pending_report_count: number;
+        failed_report_count: number;
+    };
+    installation_identity?: AgentMemorySummary["installation_identity"];
+    issue?: {
+        code: AgentIdentityGateIssue["code"];
+        message: string;
+        remediation: string;
+    };
+    available_commands: string[];
+    upstream_compatible_concepts: [
+        "memory_provider",
+        "session_search",
+        "profile_memory",
+        "workflow_memory",
+        "failure_distillation",
+        "skill_refinement"
+    ];
+    privacy_boundary: {
+        local_only: true;
+        raw_personal_memory_uploaded_by_default: false;
+        raw_source_uploaded_by_default: false;
+        public_upload_uses_redacted_reports: true;
+        memory_status_exposes_raw_entries: false;
+    };
+    next_commands?: AgentNextCommand[];
+}
+interface AgentMemoryDetail {
+    profiles: AgentMemoryProfileSummary[];
+    workflows: AgentMemoryWorkflowSummary[];
+    failures: AgentMemoryFailureSummary[];
+    skill_candidates: AgentMemorySkillCandidateSummary[];
+    recent_sessions: Array<{
+        session_id: string;
+        prompt_excerpt?: string;
+        intent?: string;
+        created_at?: string;
+    }>;
+}
+interface AgentMemoryProfileSummary {
+    profile_type?: string;
+    title?: string;
+    board_id?: string;
+    build_profile?: string;
+    toolchain_mode?: string;
+    channel?: string;
+    version?: string;
+    source_basename?: string;
+    output_basename?: string;
+    usage_count?: number;
+    last_seen_at?: string;
+    summary?: string;
+    connection_transports?: string[];
+    connection_habit_count?: number;
+}
+interface AgentMemoryWorkflowSummary {
+    workflow_id?: string;
+    action_id?: string;
+    board_id?: string;
+    observed_at?: string;
+    summary?: string;
+}
+interface AgentMemoryFailureSummary {
+    failure_id?: string;
+    action_id?: string;
+    board_id?: string;
+    observed_at?: string;
+    summary?: string;
+    error?: string;
+}
+interface AgentMemorySkillCandidateSummary {
+    name: string;
+    title?: string;
+    kind?: string;
+    component?: string;
+    status?: "candidate" | "reviewed" | "rejected";
+    reviewed_at?: string;
+    updated_at?: string;
+    path: string;
+    path_hash?: string;
+}
+interface AgentMemorySkillCandidateRefinementResult extends AgentMemorySkillCandidateSummary {
+    action: "refine";
+    notes?: string;
+    privacy_boundary: {
+        local_only: true;
+        raw_skill_body_uploaded_by_default: false;
+        auto_activate_allowed: false;
+        requires_owner_review_for_product_promotion: true;
+    };
+}
+interface AgentMemorySearchResult {
+    schema_version: number;
+    kind: "embedlabs.agent_memory_search";
+    query: string;
+    terms: string[];
+    limit: number;
+    total_matches: number;
+    indexed_counts: {
+        memory_files: number;
+        skill_files: number;
+        session_files: number;
+    };
+    results: AgentMemorySearchEntry[];
+    privacy_boundary: {
+        local_only: true;
+        raw_personal_memory_uploaded_by_default: false;
+        public_upload_uses_redacted_reports: true;
+    };
+}
+interface AgentMemorySearchEntry {
+    kind: "profile" | "workflow" | "failure" | "skill_candidate" | "session";
+    title: string;
+    summary?: string;
+    source_ref: string;
+    score: number;
+    matched_terms: string[];
+    board_id?: string;
+    action_id?: string;
+    intent?: string;
+    observed_at?: string;
+    privacy_scope: "local_personal_memory";
+}
+interface AgentMemoryContextEntry {
+    kind: "profile" | "workflow" | "failure" | "skill_candidate" | "recent_session";
+    title: string;
+    summary?: string;
+    path: string;
+    path_hash?: string;
+    relevance_score: number;
+    matched_terms: string[];
+    board_id?: string;
+    intent?: string;
+    last_seen_at?: string;
+    metadata?: Record<string, unknown>;
+    privacy_scope: "local_personal_memory";
+}
+interface AgentMemorySuggestion {
+    kind: "build_project" | "install_toolchain" | "deploy_app" | "flash_image" | "capture_signal" | "query_board_knowledge" | "general";
+    title: string;
+    detail: string;
+    source_entry_title: string;
+    privacy_scope: "local_personal_memory";
+}
+interface AgentResponsePreference {
+    kind: "language" | "brevity" | "general";
+    value: "zh" | "concise" | string;
+    detail: string;
+    source_entry_title: string;
+    privacy_scope: "local_personal_memory";
+}
+interface AgentMemoryContext {
+    schema_version: number;
+    kind: "embedlabs.agent_memory_context";
+    adapter_kind: "embedlabs.upstream_memory_context_adapter";
+    adapter_schema_version: 1;
+    provider: AgentMemoryProviderAdapterTrace;
+    provider_source: "embedlabs_local_personal_memory";
+    storage_home: "~/.embedlabs/agent";
+    upstream_concepts: [
+        "memory_provider",
+        "session_search",
+        "profile_memory",
+        "workflow_memory",
+        "failure_distillation"
+    ];
+    generated_at: string;
+    source: "local_personal_memory";
+    query: {
+        intent_id: string;
+        prompt_terms: string[];
+        board_template_hint?: string;
+    };
+    entries: AgentMemoryContextEntry[];
+    counts: {
+        profiles_considered: number;
+        workflows_considered: number;
+        failures_considered: number;
+        skill_candidates_considered: number;
+        sessions_considered: number;
+    };
+    privacy_boundary: {
+        local_only: true;
+        raw_personal_memory_uploaded_by_default: false;
+        public_upload_uses_redacted_reports: true;
+    };
+}
+interface AgentMemoryProviderAdapterTrace {
+    kind: "embedlabs.upstream_memory_provider_adapter";
+    schema_version: 1;
+    provider_kind: "embedlabs.local_personal_memory_provider";
+    provider_contract: "embedlabs.memory_provider.v1";
+    provider_replacement_target: "upstream_memory_provider";
+    storage_home: "~/.embedlabs/agent";
+    scope: "installation_local_personal_memory";
+    lifecycle: {
+        prefetch: "synchronous_local_relevance_search";
+        turn_sync: "session_persist_after_turn";
+        extraction: "explicit_agent_memory_and_workflow_writes";
+        provider_tools: "disabled_until_upstream_runtime";
+    };
+    query_strategy: {
+        kind: "bounded_local_relevance_search";
+        max_entries: 12;
+        sources: ["profile_memory", "workflow_memory", "failure_memory", "skill_candidates", "session_index"];
+        ranking: "matched_terms_plus_intent_and_recency";
+    };
+    write_policy: {
+        automatic_public_promotion: false;
+        personal_memory_only: true;
+        public_reports_must_be_redacted: true;
+    };
+    privacy_boundary: {
+        local_only: true;
+        raw_personal_memory_uploaded_by_default: false;
+        raw_source_uploaded_by_default: false;
+        absolute_paths_exported: false;
+        user_model_key_uploaded: false;
+    };
+}
+export interface AgentReportResult {
+    action: "list" | "submit";
+    reports: AgentStoredReportSummary[];
+    pagination?: AgentReportPagination;
+    submitted?: AgentReportUploadResult;
+    installation_identity_status?: AgentInstallationIdentityStatusSnapshot;
+    identity_setup?: AgentIdentitySetupGuidance;
+    next_commands?: AgentNextCommand[];
+}
+interface AgentReportPagination {
+    total: number;
+    returned: number;
+    limit: number;
+    offset: number;
+    has_more: boolean;
+    all: boolean;
+    next_page_command?: string;
+    previous_page_command?: string;
+}
+export interface AgentSyncResult {
+    pending_before: number;
+    pending_after?: number;
+    selected: number;
+    selected_reports?: AgentSyncSelectedReportSummary[];
+    uploaded: number;
+    failed: number;
+    persistence_warning_count?: number;
+    uploaded_with_persistence_warning?: number;
+    local_state_update_failed?: boolean;
+    reports: AgentReportUploadResult[];
+    next_commands?: AgentNextCommand[];
+    trigger?: "manual" | "auto";
+    upload_mode?: "none" | "batch" | "single";
+    telemetry_events_generated: number;
+    telemetry_events_uploaded: number;
+    timed_out?: boolean;
+    timeout_ms?: number;
+    upload_diagnostics?: AgentSyncUploadDiagnostics;
+    error?: {
+        code: string;
+        message: string;
+        remediation?: string;
+    };
+}
+interface AgentSyncUploadDiagnostics {
+    cloud_upload_required: boolean;
+    local_agent_workflows_continue: boolean;
+    pending_reports_kept_local: boolean;
+    diagnostic_command: string;
+    retry_command?: string;
+    summary: string;
+}
+interface AgentSyncSelectedReportSummary {
+    report_id: string;
+    status: AgentEffectiveReportStatus;
+    title?: string;
+    category?: string;
+    severity?: string;
+    component?: string;
+    board_id?: string;
+    variant_id?: string;
+    action_id?: string;
+    capability_id?: string;
+    error_code?: string;
+}
+export interface AgentUpstreamAuditResult {
+    action: "audit";
+    ok: boolean;
+    checked_at: string;
+    repository: string;
+    docs: string;
+    latest_release: {
+        title?: string;
+        version?: string;
+        tag?: string;
+        release_label_date?: string;
+        published_at?: string;
+        html_url?: string;
+    };
+    main: {
+        sha?: string;
+        committed_at?: string;
+        message?: string;
+    };
+    main_ahead_of_latest_release: boolean;
+    license: {
+        spdx_id?: string;
+        name?: string;
+        html_url?: string;
+    };
+    self_evolution: {
+        repository: string;
+        plan: string;
+        reuse_boundary: "reference_only_owner_reviewed";
+        darwinian_code_license_boundary: "AGPL v3 external reference only";
+    };
+    checks: Array<{
+        name: string;
+        ok: boolean;
+        detail: string;
+    }>;
+    next_commands: AgentNextCommand[];
+}
+export interface AgentChatResult {
+    mode: "one_shot" | "interactive" | "session";
+    turns: LocalAgentRunResult[];
+    chat_session?: AgentChatSessionRecord;
+    next_commands?: AgentNextCommand[];
+}
+interface AgentChatSessionTurnRef {
+    turn_index: number;
+    turn_session_id: string;
+    turn_session_ref: string;
+    turn_session_path_hash: string;
+    prompt_sha256: string;
+    prompt_excerpt?: string;
+    intent_id: AgentIntent["id"];
+    answer_sha256: string;
+    model_invocation_state: AgentModelInvocationTrace["invocation_state"];
+    memory_context_entries: number;
+    created_at: string;
+}
+interface AgentChatSessionRecord {
+    kind: "embedlabs.agent_chat_session";
+    schema_version: 1;
+    adapter_kind: "embedlabs.upstream_session_adapter";
+    provider_kind: "embedlabs.local_session_provider";
+    provider_contract: "embedlabs.session_provider.v1";
+    provider_replacement_target: "upstream_session_provider";
+    chat_session_id: string;
+    session_ref: string;
+    session_path: string;
+    session_path_hash: string;
+    storage_home: "~/.embedlabs/agent/sessions";
+    mode: "local_persistent_chat";
+    created_at: string;
+    updated_at: string;
+    turn_count: number;
+    turns: AgentChatSessionTurnRef[];
+    privacy_boundary: {
+        local_only: true;
+        raw_prompt_exported_by_default: false;
+        raw_model_response_storage: false;
+        raw_personal_memory_uploaded_by_default: false;
+        public_upload_path: "redacted_public_reports_only";
+    };
+}
+interface AgentChatSessionPromptContext {
+    kind: "embedlabs.upstream_chat_session_prompt_context_adapter";
+    schema_version: 1;
+    provider_kind: "embedlabs.local_session_provider";
+    source: "local_chat_session";
+    injection_mode: "bounded_sanitized_turn_summaries";
+    max_turns: 6;
+    chat_session_id: string;
+    session_ref: string;
+    turn_count: number;
+    included_turns: number;
+    entries: AgentChatSessionPromptEntry[];
+    prompt_fragment_sha256: string;
+    privacy_boundary: {
+        local_only: true;
+        raw_prompt_included: false;
+        raw_model_response_included: false;
+        raw_personal_memory_included: false;
+        user_model_key_included: false;
+        public_upload_payload_included: false;
+    };
+}
+interface AgentChatSessionPromptEntry {
+    turn_index: number;
+    turn_session_ref: string;
+    prompt_sha256: string;
+    prompt_excerpt?: string;
+    intent_id: AgentIntent["id"];
+    answer_sha256: string;
+    model_invocation_state: AgentModelInvocationTrace["invocation_state"];
+    memory_context_entries: number;
+}
+export interface AgentActionResult {
+    action: "list" | "schema" | "describe" | "run";
+    actions?: AgentActionDefinition[];
+    action_id?: AgentActionId;
+    definition?: AgentActionDefinition;
+    execution?: AgentActionExecution;
+    report?: AgentReportUploadResult;
+    public_experience?: AgentPublicExperienceSummary;
+    next_commands?: AgentNextCommand[];
+}
+export interface AgentMaintainerResult {
+    action: "list" | "show" | "pull" | "plan" | "repair-start" | "repair-context" | "repair-draft" | "repair-generate-patch" | "repair-apply" | "repair-execute" | "repair-finish" | "submit-result" | "review-run" | "release-candidates" | "readiness" | "readiness-decision";
+    installation_identity_status: AgentInstallationIdentityStatusSnapshot;
+    total?: number;
+    limit?: number;
+    offset?: number;
+    tasks?: AgentMaintainerTaskSummary[];
+    task?: AgentMaintainerTaskSummary;
+    detail?: unknown;
+    reports?: unknown[];
+    run?: AgentMaintainerTaskRunSummary;
+    review?: Record<string, unknown>;
+    candidates?: Record<string, unknown>[];
+    candidate?: Record<string, unknown>;
+    readiness_bundle?: Record<string, unknown>;
+    decision?: Record<string, unknown>;
+    publication_boundary?: Record<string, unknown>;
+    maintainer_handoff?: Record<string, unknown>;
+    pulled_path?: string;
+    plan?: AgentMaintainerRepairPlan;
+    plan_path?: string;
+    submitted_run?: AgentMaintainerTaskRunSummary;
+    result_path?: string;
+    review_path?: string;
+    readiness_path?: string;
+    readiness_decision_path?: string;
+    repair_session?: AgentMaintainerRepairSession;
+    repair_session_path?: string;
+    repair_context?: AgentMaintainerRepairContextBundle;
+    repair_context_path?: string;
+    repair_draft?: AgentMaintainerPatchDraftBundle;
+    repair_draft_path?: string;
+    generated_patch?: AgentMaintainerGeneratedPatchBundle;
+    generated_patch_path?: string;
+    repair_apply?: AgentMaintainerPatchApplyBundle;
+    repair_apply_path?: string;
+    repair_execute?: AgentMaintainerRepairExecuteBundle;
+    repair_execute_path?: string;
+    release_candidate?: AgentMaintainerReleaseCandidate;
+    next_commands?: AgentNextCommand[];
+}
+type AgentActionId = "detect_board" | "query_board_knowledge" | "install_toolchain" | "build_project" | "flash_image" | "deploy_app" | "debug_board" | "capture_signal" | "manage_board_pack" | "submit_report" | "create_fix_candidate";
+interface AgentActionDefinition {
+    action_id: AgentActionId;
+    title: string;
+    status: "available" | "planned";
+    risk: "read_only" | "cloud_report" | "writes_local_files" | "hardware_mutation" | "maintainer_only";
+    description: string;
+    required_inputs: string[];
+    optional_inputs: string[];
+    input_schema: AgentActionInputSchema[];
+    safety: AgentActionSafetyContract;
+    routes_to: string[];
+}
+interface AgentActionInputSchema {
+    name: string;
+    type: "string" | "boolean" | "number" | "path" | "string[]" | "object";
+    required: boolean;
+    source: "prompt" | "cli_flag" | "local_bridge_inventory" | "local_memory_hint" | "board_pack" | "admin_review" | "execution_layer";
+    description: string;
+    aliases?: string[];
+    values?: string[];
+    default?: string | number | boolean;
+    sensitive?: boolean;
+}
+interface AgentActionSafetyContract {
+    approval_required: boolean;
+    target_selection: "not_applicable" | "single_or_explicit" | "explicit_for_side_effects" | "admin_confirmed_item";
+    side_effects: Array<"none" | "local_files" | "hardware_io" | "hardware_flash" | "cloud_report" | "maintainer_task">;
+    must_not_infer: string[];
+    report_on_failure: boolean;
+}
+interface AgentActionExecution {
+    action_id: AgentActionId;
+    ok: boolean;
+    summary: string;
+    installation_identity_status?: AgentInstallationIdentityStatusSnapshot;
+    selection?: AgentActionSelectionSummary;
+    bridge?: AgentBridgeSnapshot;
+    board?: AgentBridgeBoardSummary;
+    boards?: AgentBridgeBoardSummary[];
+    knowledge?: AgentKnowledgeSearchSummary;
+    knowledge_source?: "cloud_board_pack" | "local_board_pack_fallback";
+    cloud_error?: {
+        code: string;
+        message: string;
+        remediation?: string;
+    };
+    report?: AgentReportUploadResult;
+    toolchain?: AgentToolchainInstallSummary;
+    toolchain_operation?: AgentToolchainOperationSummary;
+    build?: AgentBuildSummary;
+    flash?: AgentFlashSummary;
+    deploy?: AgentDeploySummary;
+    fix_candidate?: AgentMaintainerTaskSummary;
+    board_pack?: AgentBoardPackSummary;
+    tool_results?: AgentToolResultSummary[];
+    next_actions?: AgentActionId[];
+    next_commands?: AgentNextCommand[];
+    error?: {
+        code: string;
+        message: string;
+        remediation?: string;
+    };
+}
+interface AgentActionSelectionSummary {
+    kind: "embedlabs.agent_action_selection";
+    action_id: AgentActionId;
+    template_id?: string;
+    template_source?: "explicit" | "prompt_text" | "bridge_inventory" | "local_profile";
+    memory_ref?: string;
+    memory_path_hash?: string;
+    privacy_scope?: "local_personal_memory";
+}
+export interface AgentNextCommand {
+    label: string;
+    command: string;
+    description?: string;
+}
+interface AgentMaintainerReleaseCandidate {
+    schema_version: 1;
+    kind: "embedlabs.maintainer_release_candidate";
+    generated_at: string;
+    maintainer_task_id: string;
+    optimization_item_id?: string;
+    maintainer_task_run_id?: string;
+    title?: string;
+    status: "candidate_ready" | "candidate_failed";
+    summary: string;
+    changed_files: Array<{
+        path: string;
+        source?: string;
+    }>;
+    test_evidence: Array<Record<string, unknown>>;
+    failure_report?: Record<string, unknown>;
+    risk_flags: string[];
+    owner_review: {
+        required: true;
+        next_actions: string[];
+        review_commands: AgentNextCommand[];
+    };
+    publication_boundary: {
+        auto_publish_allowed: false;
+        npm_publish_allowed: false;
+        server_deploy_allowed: false;
+        production_release_allowed: false;
+        owner_explicit_release_required: true;
+    };
+    release_gate: AgentMaintainerReleaseGate;
+}
+interface AgentToolchainInstallSummary {
+    board_id: string;
+    version: string;
+    channel: string;
+    host: string;
+    mode: string;
+    install_root: string;
+    release_root: string;
+    validation_ok: boolean;
+    summary_for_user?: string;
+}
+interface AgentToolchainOperationSummary {
+    operation: "list" | "install" | "update" | "uninstall";
+    board_id?: string;
+    channel?: string;
+    metadata_source?: "built_in" | "local_override";
+    metadata_root?: string;
+    install_root?: string;
+    environment_count?: number;
+    installed_count?: number;
+    update_count?: number;
+    environments?: Array<{
+        board_id: string;
+        display_name: string;
+        status: string;
+        local_version?: string;
+        server_version?: string;
+        version_source?: "server_manifest" | "built_in_manifest";
+        download_metadata_status?: "metadata_available" | "metadata_unavailable";
+        modes?: string[];
+        install_command?: string;
+        update_command?: string;
+        uninstall_command?: string;
+    }>;
+    removed?: boolean;
+    removed_paths?: string[];
+    removed_registry_entry?: boolean;
+    registry_path?: string;
+    observed_at?: string;
+}
+interface AgentBoardPackSummary {
+    operation: "list" | "show";
+    source?: "cloud_board_pack_catalog" | "local_board_pack_catalog_fallback";
+    observed_at?: string;
+    profile_count: number;
+    template_id?: string;
+    profiles?: AgentBoardPackProfileSummary[];
+    profile?: AgentBoardPackProfileSummary;
+}
+interface AgentBoardPackProfileSummary {
+    template_id: string;
+    board_id?: string;
+    variant_id?: string;
+    hardware_profile_id?: string;
+    display_name?: string;
+    support_level?: string;
+    method_count: number;
+    knowledge_file_count: number;
+    build_template_id?: string;
+    local_toolchain_status?: "installed" | "available" | "update_available" | "unsupported_host";
+    local_toolchain_version?: string;
+    server_toolchain_version?: string;
+    toolchain_version_source?: "server_manifest" | "built_in_manifest";
+    toolchain_metadata_status?: "metadata_available" | "metadata_unavailable";
+    install_modes?: string[];
+    toolchain_install_command?: string;
+    toolchain_update_command?: string;
+    toolchain_uninstall_command?: string;
+}
+interface AgentBuildSummary {
+    board_id: string;
+    operation: string;
+    source_path: string;
+    artifact_path: string;
+    artifact_size_bytes: number;
+    artifact_sha256: string;
+    manifest_path?: string;
+}
+interface AgentFlashSummary {
+    board_id: string;
+    profile_id?: string;
+    artifact_kind?: string;
+    artifact_source?: string;
+    plan_id?: string;
+    ready: boolean;
+    destructive?: boolean;
+    approval_required?: boolean;
+    summary?: string;
+    artifact_path?: string;
+    image_dir?: string;
+    partition?: string;
+    target_volume_path?: string;
+    missing_tools?: string[];
+    missing_files?: string[];
+    warnings?: unknown[];
+    errors?: unknown[];
+    job?: AgentBridgeJobSummary;
+}
+interface AgentBridgeJobSummary {
+    local_job_id: string;
+    state: string;
+    kind: string;
+    progress_stage?: string;
+    progress_text?: string;
+    progress_percent?: number;
+    output_tail?: string[];
+    error?: {
+        code: string;
+        message: string;
+        remediation?: string;
+    };
+}
+interface AgentDeploySummary {
+    board_id: string;
+    host: string;
+    user?: string;
+    artifact_path: string;
+    remote_path?: string;
+    remote_dir?: string;
+    remote_file?: string;
+    deployed?: boolean;
+    ran?: boolean;
+    run_status?: string;
+    run_command?: string;
+    wrapper_script?: string;
+    run_script?: string;
+    wrapper_remote_path?: string;
+    remote_pid?: string;
+    app_pid?: string;
+    wrapper_pid?: string;
+    log_path?: string;
+    output_tail?: string[];
+    observed_at?: string;
+}
+interface AgentMaintainerTaskSummary {
+    maintainer_task_id: string;
+    optimization_item_id: string;
+    status: string;
+    title: string;
+    branch_name?: string;
+    context_bundle_ref?: string;
+    reused_existing?: boolean;
+    item_status?: string;
+    created_at?: string;
+    updated_at?: string;
+}
+interface AgentMaintainerTaskRunSummary {
+    maintainer_task_run_id: string;
+    maintainer_task_id: string;
+    status: string;
+    summary: string;
+    changed_file_count: number;
+    test_result_count: number;
+    created_at?: string;
+}
+interface AgentMaintainerReleaseGate {
+    owner_release_required: boolean;
+    auto_release_allowed: boolean;
+    release_command_allowed: boolean;
+    publish_allowed: boolean;
+    deploy_allowed: boolean;
+    production_release_allowed: boolean;
+    owner_explicit_publish_instruction_required: boolean;
+    allowed_until_owner_release: string[];
+    prohibited_actions: string[];
+    next_owner_action: string;
+}
+interface AgentMaintainerRepairPlan {
+    schema_version: number;
+    kind: "embedlabs.maintainer_repair_plan";
+    maintainer_task_id: string;
+    optimization_item_id: string;
+    title: string;
+    generated_at: string;
+    source: {
+        bundle_path?: string;
+        fetched_from_cloud: boolean;
+    };
+    issue_summary: {
+        category?: string;
+        severity?: string;
+        board_id?: string;
+        affected_component?: string;
+        report_count?: number;
+        tags: string[];
+    };
+    candidate_areas: AgentMaintainerCandidateArea[];
+    context_evidence?: AgentMaintainerContextEvidence[];
+    test_plan: AgentMaintainerTestStep[];
+    execution_boundary: {
+        read_only_plan: boolean;
+        requires_owner_approved_task: boolean;
+        auto_release_allowed: boolean;
+        release_gate: AgentMaintainerReleaseGate;
+        next_step: string;
+    };
+}
+interface AgentMaintainerRepairSession {
+    schema_version: number;
+    kind: "embedlabs.maintainer_repair_session";
+    repair_session_id: string;
+    maintainer_task_id: string;
+    optimization_item_id: string;
+    title: string;
+    started_at: string;
+    plan_path: string;
+    git: {
+        cwd: string;
+        repo_root?: string;
+        head?: string;
+        status_short?: string;
+        available: boolean;
+        error?: string;
+    };
+    candidate_areas: AgentMaintainerCandidateArea[];
+    context_evidence?: AgentMaintainerContextEvidence[];
+    test_plan: AgentMaintainerTestStep[];
+    execution_boundary: {
+        task_id_required: boolean;
+        plan_required: boolean;
+        auto_release_allowed: boolean;
+        submit_result_required: boolean;
+        release_gate: AgentMaintainerReleaseGate;
+        next_step: string;
+    };
+}
+interface AgentMaintainerRepairContextBundle {
+    schema_version: number;
+    kind: "embedlabs.maintainer_repair_context_bundle";
+    generated_at: string;
+    maintainer_task_id: string;
+    optimization_item_id: string;
+    repair_session_id: string;
+    repair_session_path: string;
+    title: string;
+    git: AgentMaintainerRepairSession["git"];
+    candidate_areas: AgentMaintainerCandidateArea[];
+    context_evidence: AgentMaintainerContextEvidence[];
+    file_contexts: AgentMaintainerFileContext[];
+    test_plan: AgentMaintainerTestStep[];
+    limits: {
+        max_files: number;
+        max_file_bytes: number;
+        max_snippets_per_file: number;
+        max_snippet_chars: number;
+    };
+    execution_boundary: {
+        read_only_context: boolean;
+        task_id_required: boolean;
+        auto_edit_allowed: boolean;
+        auto_release_allowed: boolean;
+        release_gate: AgentMaintainerReleaseGate;
+        next_step: string;
+    };
+}
+interface AgentMaintainerPatchDraftBundle {
+    schema_version: number;
+    kind: "embedlabs.maintainer_patch_draft_bundle";
+    generated_at: string;
+    maintainer_task_id: string;
+    optimization_item_id: string;
+    repair_session_id: string;
+    repair_context_path: string;
+    title: string;
+    instructions: string;
+    allowed_targets: Array<{
+        path: string;
+        directory: boolean;
+    }>;
+    file_contexts: Array<{
+        path: string;
+        kind: AgentMaintainerFileContext["kind"];
+        exists: boolean;
+        snippet_count: number;
+        truncated?: boolean;
+    }>;
+    test_plan: AgentMaintainerTestStep[];
+    suggested_patch_path: string;
+    repair_prompt: string;
+    execution_boundary: {
+        task_id_required: boolean;
+        context_required: boolean;
+        read_only_draft: boolean;
+        auto_edit_allowed: boolean;
+        auto_commit_allowed: boolean;
+        auto_release_allowed: boolean;
+        generated_patch_requires_repair_apply: boolean;
+        release_gate: AgentMaintainerReleaseGate;
+        next_step: string;
+    };
+}
+interface AgentMaintainerGeneratedPatchBundle {
+    schema_version: number;
+    kind: "embedlabs.maintainer_generated_patch_bundle";
+    generated_at: string;
+    maintainer_task_id: string;
+    optimization_item_id: string;
+    repair_session_id: string;
+    repair_draft_path: string;
+    repair_context_path: string;
+    patch_path: string;
+    patch_sha256?: string;
+    patch_size_bytes?: number;
+    source: "patch_text" | "patch_file";
+    touched_files: AgentMaintainerPatchTouchedFile[];
+    violations: AgentMaintainerPatchViolation[];
+    execution_boundary: {
+        task_id_required: boolean;
+        draft_required: boolean;
+        allowed_paths_enforced: boolean;
+        writes_patch_file_only: boolean;
+        auto_apply_allowed: boolean;
+        auto_commit_allowed: boolean;
+        auto_release_allowed: boolean;
+        release_gate: AgentMaintainerReleaseGate;
+        next_step: string;
+    };
+}
+interface AgentMaintainerFileContext {
+    path: string;
+    kind: "file" | "directory" | "missing" | "skipped";
+    exists: boolean;
+    size_bytes?: number;
+    truncated?: boolean;
+    sha256?: string;
+    matched_terms: string[];
+    snippets?: Array<{
+        start_line: number;
+        end_line: number;
+        text: string;
+    }>;
+    entries?: string[];
+    reason?: string;
+}
+interface AgentMaintainerPatchApplyBundle {
+    schema_version: number;
+    kind: "embedlabs.maintainer_patch_apply_bundle";
+    generated_at: string;
+    maintainer_task_id: string;
+    optimization_item_id: string;
+    repair_session_id: string;
+    repair_context_path: string;
+    patch_path: string;
+    approved: boolean;
+    applied: boolean;
+    touched_files: AgentMaintainerPatchTouchedFile[];
+    violations: AgentMaintainerPatchViolation[];
+    git_check: AgentMaintainerGitApplyResult;
+    git_apply?: AgentMaintainerGitApplyResult;
+    execution_boundary: {
+        task_id_required: boolean;
+        context_required: boolean;
+        patch_required: boolean;
+        owner_approval_required_for_apply: boolean;
+        auto_commit_allowed: boolean;
+        auto_release_allowed: boolean;
+        release_gate: AgentMaintainerReleaseGate;
+        next_step: string;
+    };
+}
+interface AgentMaintainerRepairExecuteBundle {
+    schema_version: number;
+    kind: "embedlabs.maintainer_repair_execute_bundle";
+    generated_at: string;
+    maintainer_task_id: string;
+    optimization_item_id?: string;
+    approved: boolean;
+    dry_run: boolean;
+    repair_apply_path?: string;
+    repair_finish_path?: string;
+    submitted_run_id?: string;
+    status: "validated" | "applied_and_submitted" | "failed";
+    error?: {
+        code: string;
+        message: string;
+        remediation?: string;
+    };
+    execution_boundary: {
+        task_id_required: boolean;
+        approve_required_for_apply: boolean;
+        session_required_for_finish: boolean;
+        auto_commit_allowed: boolean;
+        auto_release_allowed: boolean;
+        release_gate: AgentMaintainerReleaseGate;
+        next_step: string;
+    };
+}
+interface AgentMaintainerPatchTouchedFile {
+    path: string;
+    allowed_by_context: boolean;
+    source: "patch_header";
+    matched_context_path?: string;
+}
+interface AgentMaintainerPatchViolation {
+    code: string;
+    message: string;
+    path?: string;
+}
+interface AgentMaintainerGitApplyResult {
+    ok: boolean;
+    command: string;
+    stdout_tail?: string;
+    stderr_tail?: string;
+    error?: string;
+}
+interface AgentMaintainerCandidateArea {
+    kind: "cli" | "cloud_api" | "database" | "local_bridge" | "board_pack" | "plugin" | "test" | "docs";
+    path: string;
+    exists: boolean;
+    reason: string;
+    confidence: "high" | "medium" | "low";
+}
+interface AgentMaintainerContextEvidence {
+    evidence_id: string;
+    kind: "optimization_item" | "cloud_agent_recommendation" | "report_sample" | "candidate_path" | "repo_search" | "test_gate";
+    title: string;
+    summary: string;
+    confidence: "high" | "medium" | "low";
+    path?: string;
+    paths?: string[];
+    matched_terms?: string[];
+    report_id?: string;
+    command?: string;
+    metadata?: Record<string, unknown>;
+}
+interface AgentMaintainerTestStep {
+    command: string;
+    reason: string;
+    required: boolean;
+}
+interface AgentToolResultSummary {
+    capability_id: string;
+    ok: boolean;
+    summary?: string;
+    result?: unknown;
+    error?: {
+        code: string;
+        message: string;
+        remediation?: string;
+    };
+}
+interface AgentKnowledgeSearchSummary {
+    template_id: string;
+    board_id?: string;
+    query: string;
+    match_count: number;
+    matches: AgentKnowledgeMatchSummary[];
+}
+interface AgentKnowledgeMatchSummary {
+    source?: string;
+    path?: string;
+    title?: string;
+    score?: number;
+    excerpt?: string;
+}
+type AgentIntentCategory = OptimizationReportCategory | "status_check";
+interface AgentIntent {
+    id: "detect_board" | "current_board_status" | "query_board_knowledge" | "install_toolchain" | "build_project" | "flash_image" | "deploy_app" | "debug_board" | "capture_signal" | "manage_board_pack" | "remember_preference" | "submit_report" | "create_fix_candidate" | "maintainer_pull" | "maintainer_plan" | "maintainer_repair_start" | "maintainer_repair_context" | "maintainer_repair_draft" | "maintainer_repair_generate_patch" | "maintainer_repair_apply" | "maintainer_repair_execute" | "maintainer_repair_finish" | "maintainer_submit_result" | "unsupported";
+    title: string;
+    category: AgentIntentCategory;
+    severity: OptimizationSeverity;
+}
+interface AgentBridgeSnapshot {
+    ok: boolean;
+    health?: Record<string, unknown>;
+    inventory?: AgentBridgeInventorySummary;
+    device_count?: number;
+    board_count?: number;
+    summary?: string;
+    error?: {
+        code: string;
+        message: string;
+        remediation?: string;
+    };
+}
+interface AgentLocalExecutionTrace {
+    kind: "embedlabs.agent_local_execution_trace";
+    loop_adapter: AgentLoopAdapterTrace;
+    planner_adapter: AgentPlannerAdapterTrace;
+    identity: {
+        source: "local_installation_identity";
+        identity_scope: "local_installation";
+        uses_local_installation_identity: true;
+    };
+    memory: {
+        source: "local_personal_memory";
+        context_entry_count: number;
+        source_labels: string[];
+    };
+    action: {
+        intent_id: AgentIntent["id"];
+        resolved_action_id: string;
+        state: "executed" | "planned";
+    };
+    bridge?: {
+        runtime: "go-local-bridge";
+        endpoints: ["/healthz", "/v1/devices"];
+        ok: boolean;
+        board_count?: number;
+        device_count?: number;
+        error_code?: string;
+    };
+    inventory?: {
+        board_count: number;
+        device_count: number;
+        board_ids: string[];
+        local_device_ids: string[];
+    };
+    public_report?: {
+        report_id: string;
+        status: "uploaded" | "pending";
+        optimization_item_id?: string;
+    };
+}
+interface AgentLoopAdapterTrace {
+    kind: "embedlabs.upstream_agent_loop_adapter";
+    schema_version: 1;
+    mode: "deterministic_local_agent_loop";
+    upstream_loop: "not_imported";
+    replacement_target: "upstream_agent_loop";
+    provider_kind: "embedlabs.deterministic_agent_loop_provider";
+    provider_contract: "embedlabs.agent_loop_provider.v1";
+    provider_replacement_target: "upstream_agent_loop_provider";
+    execution_owner: "embedlabs";
+    input_sources: [
+        "prompt_assembly",
+        "model_provider_config",
+        "local_profile_provider",
+        "local_installation_identity",
+        "local_memory_context",
+        "planner_decision",
+        "go_local_bridge_inventory",
+        "boardpack_action_catalog"
+    ];
+    model_provider_config_adapter: "embedlabs.upstream_model_provider_config_adapter";
+    memory_context_adapter: "embedlabs.upstream_memory_context_adapter";
+    memory_provider_adapter: "embedlabs.upstream_memory_provider_adapter";
+    profile_provider_adapter: "embedlabs.upstream_profile_provider_adapter";
+    planner_adapter: "embedlabs.upstream_planner_adapter";
+    action_state: "executed" | "planned";
+    side_effect_boundary: {
+        execution_layer: "embedlabs_high_level_actions";
+        hardware_runtime: "go-local-bridge";
+        board_facts_source: "boardpack";
+        cloud_use: "redacted_public_reports_only";
+        no_cloud_compile: true;
+        no_platform_auth_gate: true;
+        no_auto_publish: true;
+    };
+}
+interface AgentPlannerAdapterTrace {
+    kind: "embedlabs.upstream_planner_adapter";
+    schema_version: 1;
+    mode: "deterministic_router";
+    upstream_loop: "not_imported";
+    replacement_target: "upstream_agent_loop";
+    input_sources: ["prompt", "local_memory_context", "action_catalog", "go_local_bridge_inventory"];
+    allowed_action_ids: AgentActionId[];
+    decision: AgentPlannerDecisionTrace;
+    resolved_action_id: string;
+    routed_through_allowed_action: boolean;
+    safety_policy: {
+        high_level_actions_only: true;
+        hardware_state_source: "go-local-bridge";
+        board_facts_source: "boardpack";
+        fail_closed_side_effects: true;
+        no_web_board_facts: true;
+    };
+}
+interface AgentPlannerDecisionTrace {
+    kind: "embedlabs.upstream_planner_decision";
+    schema_version: 1;
+    mode: "deterministic_intent_adapter";
+    producer: AgentPlannerDecisionProducerTrace;
+    intent_id: AgentIntent["id"];
+    route_found: boolean;
+    action_id?: AgentActionId;
+    arguments: Record<string, unknown>;
+    argument_keys: string[];
+    argument_source: "flagsFromPrompt" | "none";
+    prompt_sha256: string;
+    privacy_boundary: {
+        prompt_text_included: false;
+        arguments_local_only: true;
+        secrets_redacted_for_trace: true;
+    };
+}
+interface AgentPlannerDecisionProducerTrace {
+    kind: "embedlabs.upstream_planner_decision_producer";
+    schema_version: 1;
+    mode: "deterministic_detect_intent";
+    upstream_loop: "not_imported";
+    replacement_target: "upstream_agent_loop";
+    output_contract: "embedlabs.upstream_planner_decision";
+    input_sources: ["prompt", "local_memory_context", "intent_rules", "action_route_table", "flagsFromPrompt"];
+    memory_context: {
+        source: "local_personal_memory";
+        entries: number;
+        entry_kinds: AgentMemoryContextEntry["kind"][];
+        available_to_producer: true;
+        used_for_rule_selection: false;
+        replacement_expectation: "upstream_agent_loop_can_use_memory_context";
+    };
+    privacy_boundary: {
+        prompt_text_included: false;
+        prompt_hash_only: true;
+        user_model_key_used: false;
+    };
+}
+interface AgentBridgeInventorySummary {
+    observed_at?: string;
+    inventory_seq?: number;
+    summary_for_user?: string;
+    summary_for_user_zh?: string;
+    status_text?: string;
+    status_text_zh?: string;
+    board_status?: unknown;
+    device_count: number;
+    board_count: number;
+    boards: AgentBridgeBoardSummary[];
+    warnings: string[];
+}
+interface AgentBridgeBoardSummary {
+    local_device_id?: string;
+    device_id?: string;
+    board_id?: string;
+    raw_board_id?: string;
+    template_id?: string;
+    variant_id?: string;
+    kind?: string;
+    display_name?: string;
+    status?: string;
+    connected?: boolean;
+    runtime_ready?: boolean;
+    reachable?: boolean;
+    host?: string;
+    ssh_host?: string;
+    tcp_endpoint?: string;
+    bridge_url?: string;
+    browser_url?: string;
+    ui_url?: string;
+    monitor?: Record<string, unknown>;
+    details?: Record<string, unknown>;
+    identity?: Record<string, unknown>;
+    locators?: Array<Record<string, unknown>>;
+    capabilities?: string[];
+    summary_for_user?: string;
+    summary_for_user_zh?: string;
+    state_summary?: string;
+    state_summary_zh?: string;
+}
+interface AgentMemorySummary {
+    home: string;
+    memory_dir: string;
+    sessions_dir: string;
+    skills_dir: string;
+    reports_dir: string;
+    maintainer_tasks_dir: string;
+    installation_id: string;
+    profile_memory_count: number;
+    workflow_memory_count: number;
+    failure_memory_count: number;
+    session_count: number;
+    skill_count: number;
+    maintainer_task_count: number;
+    maintainer_task_summary: AgentMaintainerTaskQueueSummary;
+    pending_report_count: number;
+    failed_report_count: number;
+    installation_identity?: {
+        kind: "embedlabs.local_installation_identity";
+        fingerprint_version: "v1";
+        fingerprint_hash?: string;
+        public_key_sha256?: string;
+        key_algorithm?: "ed25519";
+        integrity: "ok" | "failed" | "missing";
+    };
+}
+interface AgentMaintainerTaskQueueSummary {
+    total: number;
+    task_bundles: number;
+    unreadable: number;
+    by_status: AgentMaintainerTaskQueueBucket[];
+    latest_task_id?: string;
+    latest_status?: string;
+    latest_kind?: string;
+    latest_optimization_item_id?: string;
+    latest_file_ref?: string;
+    latest_created_at?: string;
+    latest_updated_at?: string;
+    latest_task_bundle_id?: string;
+    latest_task_bundle_status?: string;
+    latest_task_bundle_optimization_item_id?: string;
+    latest_task_bundle_file_ref?: string;
+    latest_task_bundle_created_at?: string;
+    latest_task_bundle_updated_at?: string;
+    latest_run_id?: string;
+    latest_run_status?: string;
+    latest_run_task_id?: string;
+    latest_run_file_ref?: string;
+    latest_run_observed_at?: string;
+}
+interface AgentMaintainerTaskQueueBucket {
+    value: string;
+    count: number;
+}
+interface AgentReportUploadResult {
+    ok: boolean;
+    report_id: string;
+    report_path: string;
+    uploaded_at?: string;
+    optimization_item_id?: string;
+    admin_review_url?: string;
+    create_fix_candidate_command?: string;
+    persistence_warning?: AgentPersistenceWarning;
+    error?: {
+        code: string;
+        message: string;
+        remediation?: string;
+    };
+}
+type AgentStoredReportStatus = "pending" | "uploaded" | "failed";
+type AgentEffectiveReportStatus = AgentStoredReportStatus | "superseded";
+interface AgentStoredReportSummary {
+    report_id: string;
+    status: AgentEffectiveReportStatus;
+    created_at: string;
+    updated_at: string;
+    title?: string;
+    category?: string;
+    severity?: string;
+    component?: string;
+    board_id?: string;
+    variant_id?: string;
+    action_id?: string;
+    capability_id?: string;
+    optimization_item_id?: string;
+    admin_review_url?: string;
+    create_fix_candidate_command?: string;
+    error_code?: string;
+    path: string;
+}
+export declare function runLocalAgent(deps: AgentRuntimeDependencies, args: AgentCliArgs): Promise<ApiResponse<LocalAgentRunResult>>;
+export declare function agentStatus(deps: AgentRuntimeDependencies, args: AgentCliArgs): Promise<ApiResponse<AgentStatusResult>>;
+export declare function agentLocalIdentitySnapshot(deps: AgentRuntimeDependencies): Promise<AgentInstallationIdentityStatusSnapshot>;
+export declare function agentLocalIdentitySnapshotReadOnly(): Promise<AgentInstallationIdentityStatusSnapshot>;
+export declare function agentIdentity(deps: AgentRuntimeDependencies, args: AgentCliArgs): Promise<ApiResponse<AgentIdentityResult>>;
+export declare function agentAction(deps: AgentRuntimeDependencies, args: AgentCliArgs): Promise<ApiResponse<AgentActionResult>>;
+export declare function agentMaintainer(deps: AgentRuntimeDependencies, args: AgentCliArgs): Promise<ApiResponse<AgentMaintainerResult>>;
+export declare function agentMemory(deps: AgentRuntimeDependencies, args: AgentCliArgs): Promise<ApiResponse<AgentMemoryResult>>;
+export declare function agentReport(deps: AgentRuntimeDependencies, args: AgentCliArgs): Promise<ApiResponse<AgentReportResult>>;
+export declare function agentSync(deps: AgentRuntimeDependencies, args: AgentCliArgs): Promise<ApiResponse<AgentSyncResult>>;
+export declare function agentUpstream(_deps: AgentRuntimeDependencies, args: AgentCliArgs): Promise<ApiResponse<AgentUpstreamAuditResult>>;
+export declare function agentChat(deps: AgentRuntimeDependencies, args: AgentCliArgs): Promise<ApiResponse<AgentChatResult>>;
+export declare function renderLocalAgentRunResult(result: LocalAgentRunResult): string;
+export declare function renderLocalAgentRunBriefResult(result: LocalAgentRunResult): string;
+export declare function renderAgentStatus(result: AgentStatusResult): string;
+export declare function renderAgentIdentity(result: AgentIdentityResult): string;
+export declare function renderAgentAction(result: AgentActionResult): string;
+export declare function renderAgentMaintainer(result: AgentMaintainerResult): string;
+export declare function renderAgentMemory(result: AgentMemoryResult): string;
+export declare function renderAgentReport(result: AgentReportResult): string;
+export declare function renderAgentSync(result: AgentSyncResult): string;
+export declare function renderAgentUpstream(result: AgentUpstreamAuditResult): string;
+export declare function renderAgentChat(result: AgentChatResult): string;
+export declare function renderAgentChatBrief(result: AgentChatResult): string;
+export declare function agentPublicExperienceUploadHeadersReadOnly(method: "POST", path: string, body: unknown): Promise<Record<string, string>>;
+export {};