@tenphi/akno-core 0.1.0

package/dist/config/schema.d.ts

@@ -0,0 +1,698 @@
+import { z } from 'zod';
+/**
+ * The config document as it appears on disk. Every field is optional here —
+ * `config/default.jsonc` supplies the values and this schema only says what a
+ * key is allowed to be. The resolved, fully-populated shape is `AknoConfig`.
+ */
+/** A credential is named, never inlined. This is the only way to reference one. */
+export declare const SecretRef: z.ZodObject<{
+    env: z.ZodString;
+}, z.core.$strip>;
+export type SecretRef = z.infer<typeof SecretRef>;
+export declare const ProviderTransport: z.ZodEnum<{
+    chat_completions: "chat_completions";
+    responses: "responses";
+}>;
+export type ProviderTransport = z.infer<typeof ProviderTransport>;
+export declare const ProviderApi: z.ZodEnum<{
+    chat_completions: "chat_completions";
+    responses: "responses";
+    auto: "auto";
+}>;
+export type ProviderApi = z.infer<typeof ProviderApi>;
+export declare const ProviderDoc: z.ZodObject<{
+    base_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    api_key: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        env: z.ZodString;
+    }, z.core.$strip>>>;
+    api: z.ZodOptional<z.ZodEnum<{
+        chat_completions: "chat_completions";
+        responses: "responses";
+        auto: "auto";
+    }>>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        env: z.ZodString;
+    }, z.core.$strip>]>>>;
+    max_retries: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ProviderDoc = z.infer<typeof ProviderDoc>;
+export declare const ReasoningEffort: z.ZodEnum<{
+    none: "none";
+    low: "low";
+    medium: "medium";
+    high: "high";
+    xhigh: "xhigh";
+    max: "max";
+}>;
+export type ReasoningEffort = z.infer<typeof ReasoningEffort>;
+/** One rule per glob. Most specific wins; `akno rules <path>` explains why. */
+export declare const FolderRuleDoc: z.ZodObject<{
+    description: z.ZodOptional<z.ZodString>;
+    role: z.ZodOptional<z.ZodEnum<{
+        knowledge: "knowledge";
+        source: "source";
+        inference: "inference";
+        ignored: "ignored";
+    }>>;
+    remember: z.ZodOptional<z.ZodEnum<{
+        deny: "deny";
+        integrate: "integrate";
+    }>>;
+    about: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    type: z.ZodOptional<z.ZodString>;
+    ingest: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        file: "file";
+        page: "page";
+        document: "document";
+        ignore: "ignore";
+    }>>;
+    rank: z.ZodOptional<z.ZodNumber>;
+    route: z.ZodOptional<z.ZodBoolean>;
+    max_depth: z.ZodOptional<z.ZodNumber>;
+    relocate_to: z.ZodOptional<z.ZodString>;
+    slug_pattern: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type FolderRuleDoc = z.infer<typeof FolderRuleDoc>;
+declare const MAINTENANCE_PROFILES: readonly ["audit", "review", "autonomous"];
+export type MaintenanceProfile = (typeof MAINTENANCE_PROFILES)[number];
+export declare const MAINTENANCE_TRANSFORMS: readonly ["observe", "reflect", "hygiene", "managed_item", "synthesis", "split", "extract", "merge", "contradiction", "broken_link", "rule_drift", "adopt"];
+export type MaintenanceTransform = (typeof MAINTENANCE_TRANSFORMS)[number];
+declare const MAINTENANCE_POLICIES: readonly ["off", "audit", "review", "auto"];
+export type MaintenancePolicy = (typeof MAINTENANCE_POLICIES)[number];
+export interface MaintenanceLimits {
+    maxItems: number;
+    maxFilesChanged: number;
+    maxBytesWritten: number;
+    maxHighRiskItems: number;
+}
+declare const MAINTENANCE_NOTIFICATION_MODES: readonly ["off", "actionable", "all"];
+export type MaintenanceNotificationMode = (typeof MAINTENANCE_NOTIFICATION_MODES)[number];
+export declare const ConfigDoc: z.ZodObject<{
+    akno_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    state_dir: z.ZodOptional<z.ZodString>;
+    paths: z.ZodOptional<z.ZodObject<{
+        timeline: z.ZodOptional<z.ZodString>;
+        inbox: z.ZodOptional<z.ZodString>;
+        observations: z.ZodOptional<z.ZodString>;
+        journal: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    create_reserved_paths: z.ZodOptional<z.ZodBoolean>;
+    write_ids: z.ZodOptional<z.ZodBoolean>;
+    ignore: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    page_extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    max_page_bytes: z.ZodOptional<z.ZodNumber>;
+    gate: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        all: "all";
+        "top-level": "top-level";
+    }>>;
+    route_threshold: z.ZodOptional<z.ZodNumber>;
+    loose_events: z.ZodOptional<z.ZodEnum<{
+        ledger: "ledger";
+        daily: "daily";
+    }>>;
+    derived_in_frontmatter: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        all: "all";
+        summary: "summary";
+    }>>;
+    providers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        base_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        api_key: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            env: z.ZodString;
+        }, z.core.$strip>>>;
+        api: z.ZodOptional<z.ZodEnum<{
+            chat_completions: "chat_completions";
+            responses: "responses";
+            auto: "auto";
+        }>>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            env: z.ZodString;
+        }, z.core.$strip>]>>>;
+        max_retries: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    models: z.ZodOptional<z.ZodObject<{
+        embedding: z.ZodOptional<z.ZodObject<{
+            dimensions: z.ZodOptional<z.ZodNumber>;
+            batch: z.ZodOptional<z.ZodNumber>;
+            provider: z.ZodOptional<z.ZodString>;
+            id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            timeout_ms: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        reranker: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodOptional<z.ZodEnum<{
+                endpoint: "endpoint";
+                llm: "llm";
+            }>>;
+            exclude_irrelevant: z.ZodOptional<z.ZodBoolean>;
+            top_k: z.ZodOptional<z.ZodNumber>;
+            max_chars: z.ZodOptional<z.ZodNumber>;
+            max_output_tokens: z.ZodOptional<z.ZodNumber>;
+            reasoning_effort: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                none: "none";
+                low: "low";
+                medium: "medium";
+                high: "high";
+                xhigh: "xhigh";
+                max: "max";
+            }>>>;
+            score_offset: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"auto">]>>;
+            provider: z.ZodOptional<z.ZodString>;
+            id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            timeout_ms: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        derive: z.ZodOptional<z.ZodObject<{
+            max_output_tokens: z.ZodOptional<z.ZodNumber>;
+            concurrency: z.ZodOptional<z.ZodNumber>;
+            reasoning_effort: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                none: "none";
+                low: "low";
+                medium: "medium";
+                high: "high";
+                xhigh: "xhigh";
+                max: "max";
+            }>>>;
+            provider: z.ZodOptional<z.ZodString>;
+            id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            timeout_ms: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        expansion: z.ZodOptional<z.ZodObject<{
+            max_output_tokens: z.ZodOptional<z.ZodNumber>;
+            concurrency: z.ZodOptional<z.ZodNumber>;
+            reasoning_effort: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                none: "none";
+                low: "low";
+                medium: "medium";
+                high: "high";
+                xhigh: "xhigh";
+                max: "max";
+            }>>>;
+            provider: z.ZodOptional<z.ZodString>;
+            id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            timeout_ms: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        answer: z.ZodOptional<z.ZodObject<{
+            max_output_tokens: z.ZodOptional<z.ZodNumber>;
+            concurrency: z.ZodOptional<z.ZodNumber>;
+            reasoning_effort: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                none: "none";
+                low: "low";
+                medium: "medium";
+                high: "high";
+                xhigh: "xhigh";
+                max: "max";
+            }>>>;
+            provider: z.ZodOptional<z.ZodString>;
+            id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            timeout_ms: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        vision: z.ZodOptional<z.ZodObject<{
+            reasoning_effort: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                none: "none";
+                low: "low";
+                medium: "medium";
+                high: "high";
+                xhigh: "xhigh";
+                max: "max";
+            }>>>;
+            provider: z.ZodOptional<z.ZodString>;
+            id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            timeout_ms: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    index: z.ZodOptional<z.ZodObject<{
+        chunk_target_chars: z.ZodOptional<z.ZodNumber>;
+        chunk_max_chars: z.ZodOptional<z.ZodNumber>;
+        chunk_overlap_chars: z.ZodOptional<z.ZodNumber>;
+        summaries: z.ZodOptional<z.ZodBoolean>;
+        facts: z.ZodOptional<z.ZodBoolean>;
+        hash_concurrency: z.ZodOptional<z.ZodNumber>;
+        ann_threshold_chunks: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    recall: z.ZodOptional<z.ZodObject<{
+        default_budget: z.ZodOptional<z.ZodNumber>;
+        default_limit: z.ZodOptional<z.ZodNumber>;
+        candidates_per_arm: z.ZodOptional<z.ZodNumber>;
+        line_window: z.ZodOptional<z.ZodNumber>;
+        source_quote_lines: z.ZodOptional<z.ZodNumber>;
+        expansion: z.ZodOptional<z.ZodBoolean>;
+        expansion_timeout_ms: z.ZodOptional<z.ZodNumber>;
+        graph: z.ZodOptional<z.ZodBoolean>;
+        rank: z.ZodOptional<z.ZodObject<{
+            knowledge: z.ZodOptional<z.ZodNumber>;
+            source: z.ZodOptional<z.ZodNumber>;
+            inference: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    graph: z.ZodOptional<z.ZodObject<{
+        contextual_resolution: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            max_candidates: z.ZodOptional<z.ZodNumber>;
+            max_mentions_per_index: z.ZodOptional<z.ZodNumber>;
+            reasoning_effort: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                none: "none";
+                low: "low";
+                medium: "medium";
+                high: "high";
+                xhigh: "xhigh";
+                max: "max";
+            }>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    watch: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        debounce_ms: z.ZodOptional<z.ZodNumber>;
+        sweep_interval_ms: z.ZodOptional<z.ZodNumber>;
+        verify_interval_ms: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    server: z.ZodOptional<z.ZodObject<{
+        socket: z.ZodOptional<z.ZodString>;
+        http: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        mcp_allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    ingest: z.ZodOptional<z.ZodObject<{
+        max_file_mb: z.ZodOptional<z.ZodNumber>;
+        max_ocr_pages: z.ZodOptional<z.ZodNumber>;
+        name_confidence: z.ZodOptional<z.ZodNumber>;
+        blocked_extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        text_rendition: z.ZodOptional<z.ZodBoolean>;
+        text_rendition_min_chars: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    maintenance: z.ZodOptional<z.ZodObject<{
+        profile: z.ZodOptional<z.ZodEnum<{
+            audit: "audit";
+            review: "review";
+            autonomous: "autonomous";
+        }>>;
+        policies: z.ZodOptional<z.ZodObject<{
+            observe: z.ZodOptional<z.ZodEnum<{
+                auto: "auto";
+                audit: "audit";
+                review: "review";
+                off: "off";
+            }>>;
+            reflect: z.ZodOptional<z.ZodEnum<{
+                auto: "auto";
+                audit: "audit";
+                review: "review";
+                off: "off";
+            }>>;
+            hygiene: z.ZodOptional<z.ZodEnum<{
+                auto: "auto";
+                audit: "audit";
+                review: "review";
+                off: "off";
+            }>>;
+            managed_item: z.ZodOptional<z.ZodEnum<{
+                auto: "auto";
+                audit: "audit";
+                review: "review";
+                off: "off";
+            }>>;
+            synthesis: z.ZodOptional<z.ZodEnum<{
+                auto: "auto";
+                audit: "audit";
+                review: "review";
+                off: "off";
+            }>>;
+            split: z.ZodOptional<z.ZodEnum<{
+                auto: "auto";
+                audit: "audit";
+                review: "review";
+                off: "off";
+            }>>;
+            extract: z.ZodOptional<z.ZodEnum<{
+                auto: "auto";
+                audit: "audit";
+                review: "review";
+                off: "off";
+            }>>;
+            merge: z.ZodOptional<z.ZodEnum<{
+                auto: "auto";
+                audit: "audit";
+                review: "review";
+                off: "off";
+            }>>;
+            contradiction: z.ZodOptional<z.ZodEnum<{
+                auto: "auto";
+                audit: "audit";
+                review: "review";
+                off: "off";
+            }>>;
+            broken_link: z.ZodOptional<z.ZodEnum<{
+                auto: "auto";
+                audit: "audit";
+                review: "review";
+                off: "off";
+            }>>;
+            rule_drift: z.ZodOptional<z.ZodEnum<{
+                auto: "auto";
+                audit: "audit";
+                review: "review";
+                off: "off";
+            }>>;
+            adopt: z.ZodOptional<z.ZodEnum<{
+                auto: "auto";
+                audit: "audit";
+                review: "review";
+                off: "off";
+            }>>;
+        }, z.core.$strip>>;
+        limits: z.ZodOptional<z.ZodObject<{
+            max_items: z.ZodOptional<z.ZodNumber>;
+            max_files_changed: z.ZodOptional<z.ZodNumber>;
+            max_bytes_written: z.ZodOptional<z.ZodNumber>;
+            max_high_risk_items: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        plan_retention: z.ZodOptional<z.ZodObject<{
+            payload_days: z.ZodOptional<z.ZodNumber>;
+            receipt_days: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        max_revision_attempts: z.ZodOptional<z.ZodNumber>;
+        model: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            max_output_tokens: z.ZodOptional<z.ZodNumber>;
+            concurrency: z.ZodOptional<z.ZodNumber>;
+            reasoning_effort: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                none: "none";
+                low: "low";
+                medium: "medium";
+                high: "high";
+                xhigh: "xhigh";
+                max: "max";
+            }>>>;
+            provider: z.ZodOptional<z.ZodString>;
+            id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            timeout_ms: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        notifications: z.ZodOptional<z.ZodEnum<{
+            off: "off";
+            actionable: "actionable";
+            all: "all";
+        }>>;
+        log_changes: z.ZodOptional<z.ZodBoolean>;
+        retain: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            mission: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            fallback_page: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+        observe: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            mission: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            min_evidence: z.ZodOptional<z.ZodNumber>;
+            max_subjects: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        reflect: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            mission: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+        curate: z.ZodOptional<z.ZodObject<{
+            verify: z.ZodOptional<z.ZodBoolean>;
+            max_pages: z.ZodOptional<z.ZodNumber>;
+            max_splits: z.ZodOptional<z.ZodNumber>;
+            max_extracts: z.ZodOptional<z.ZodNumber>;
+            max_merges: z.ZodOptional<z.ZodNumber>;
+            max_rule_drifts: z.ZodOptional<z.ZodNumber>;
+            merge_folders: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            merge_discovery: z.ZodOptional<z.ZodEnum<{
+                exact: "exact";
+                semantic: "semantic";
+            }>>;
+            max_children_per_page: z.ZodOptional<z.ZodNumber>;
+            split_after_bytes: z.ZodOptional<z.ZodNumber>;
+            split_section_bytes: z.ZodOptional<z.ZodNumber>;
+            extract_after_bytes: z.ZodOptional<z.ZodNumber>;
+            extract_section_bytes: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        adopt: z.ZodOptional<z.ZodObject<{
+            max_pages: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        repair: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            links: z.ZodOptional<z.ZodBoolean>;
+            conflicts: z.ZodOptional<z.ZodBoolean>;
+            max_changes: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        conflicts: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            verify: z.ZodOptional<z.ZodBoolean>;
+            resolve: z.ZodOptional<z.ZodBoolean>;
+            max_pairs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    trash_retention_days: z.ZodOptional<z.ZodNumber>;
+    folders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        role: z.ZodOptional<z.ZodEnum<{
+            knowledge: "knowledge";
+            source: "source";
+            inference: "inference";
+            ignored: "ignored";
+        }>>;
+        remember: z.ZodOptional<z.ZodEnum<{
+            deny: "deny";
+            integrate: "integrate";
+        }>>;
+        about: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        type: z.ZodOptional<z.ZodString>;
+        ingest: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            file: "file";
+            page: "page";
+            document: "document";
+            ignore: "ignore";
+        }>>;
+        rank: z.ZodOptional<z.ZodNumber>;
+        route: z.ZodOptional<z.ZodBoolean>;
+        max_depth: z.ZodOptional<z.ZodNumber>;
+        relocate_to: z.ZodOptional<z.ZodString>;
+        slug_pattern: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ConfigDoc = z.infer<typeof ConfigDoc>;
+export interface ResolvedProvider {
+    name: string;
+    baseUrl: string;
+    apiKey: string | null;
+    headers: Record<string, string>;
+    /** Resolved generative transport, or `auto` while a content-safe capability probe is still owed. */
+    api: ProviderApi;
+    /** The user's setting, retained after `auto` resolves to a concrete transport. */
+    configuredApi: ProviderApi;
+    /** Where the concrete transport came from. */
+    apiResolution: 'explicit' | 'cached' | 'probed' | 'unresolved' | 'deferred' | 'not_needed';
+    /** Content-safe resolution failure or cache warning, when one exists. */
+    apiResolutionError: string | null;
+    /** Retries after a rate limit or transient server error, within the role's existing deadline. */
+    maxRetries: number;
+}
+export interface ResolvedModelRole {
+    /**
+     * `maintenance` is the same capability as `derive`, named apart only so that a failure at
+     * 03:00 says which model failed — "derive endpoint returned 401" sends someone to look at
+     * the local model that was working fine.
+     */
+    role: 'embedding' | 'reranker' | 'derive' | 'expansion' | 'answer' | 'vision' | 'maintenance';
+    provider: ResolvedProvider | null;
+    id: string | null;
+    /** True once the role resolved to something usable. */
+    enabled: boolean;
+    /**
+     * What the user asked for, kept separate from what resolved. `enabled` is
+     * forced false whenever a role is unusable, so it cannot answer "was this
+     * wanted?" — and without that, a misconfigured role degrades in silence.
+     */
+    requested: boolean;
+    timeoutMs: number;
+    /** Present only on the embedding role. */
+    dimensions?: number;
+    batch?: number;
+    topK?: number;
+    /** How the reranker role is called. Absent outside that role. */
+    rerankerMode?: 'endpoint' | 'llm';
+    /** Whether a successful reranker may qualify candidates out of the response. */
+    excludeIrrelevant?: boolean;
+    /** Characters of each candidate sent to the reranker. Cost scales with tokens. */
+    maxChars?: number;
+    /** Logit subtracted before the sigmoid, so this model's relevant/irrelevant boundary lands on 0.5. */
+    scoreOffset?: number | 'auto';
+    maxOutputTokens?: number;
+    concurrency?: number;
+    /** Explicit provider reasoning level. Omitted means use the provider default. */
+    reasoningEffort?: ReasoningEffort;
+    /** Why the role is unusable, when it is. Reported verbatim by `doctor`. */
+    unavailableReason: string | null;
+}
+export interface FolderRule extends FolderRuleDoc {
+    glob: string;
+    /** Which file the rule came from, for `akno rules <path>`. */
+    source: string;
+    /** Higher wins. Derived from glob shape, not declaration order. */
+    specificity: number;
+}
+export interface AknoConfig {
+    aknoPath: string;
+    stateDir: string;
+    dbPath: string;
+    socketPath: string;
+    lockPath: string;
+    trashDir: string;
+    logDir: string;
+    paths: {
+        timeline: string;
+        inbox: string;
+        observations: string;
+        journal: string;
+    };
+    createReservedPaths: boolean;
+    writeIds: boolean;
+    ignore: string[];
+    pageExtensions: string[];
+    maxPageBytes: number;
+    gate: 'top-level' | 'all' | 'none';
+    routeThreshold: number;
+    looseEvents: 'ledger' | 'daily';
+    derivedInFrontmatter: 'none' | 'summary' | 'all';
+    providers: Record<string, ResolvedProvider>;
+    models: {
+        embedding: ResolvedModelRole;
+        reranker: ResolvedModelRole;
+        derive: ResolvedModelRole;
+        expansion: ResolvedModelRole;
+        answer: ResolvedModelRole;
+        vision: ResolvedModelRole;
+    };
+    index: {
+        chunkTargetChars: number;
+        chunkMaxChars: number;
+        chunkOverlapChars: number;
+        summaries: boolean;
+        facts: boolean;
+        hashConcurrency: number;
+        annThresholdChunks: number;
+    };
+    recall: {
+        defaultBudget: number;
+        defaultLimit: number;
+        candidatesPerArm: number;
+        lineWindow: number;
+        sourceQuoteLines: number;
+        expansion: boolean;
+        expansionTimeoutMs: number;
+        graph: boolean;
+        rank: {
+            knowledge: number;
+            source: number;
+            inference: number;
+        };
+    };
+    graph: {
+        contextualResolution: {
+            enabled: boolean;
+            maxCandidates: number;
+            maxMentionsPerIndex: number;
+            reasoningEffort?: ReasoningEffort;
+        };
+    };
+    watch: {
+        enabled: boolean;
+        debounceMs: number;
+        sweepIntervalMs: number;
+        verifyIntervalMs: number;
+    };
+    server: {
+        socket: string;
+        http: string | null;
+        mcpAllow: string[];
+    };
+    ingest: {
+        maxFileBytes: number;
+        maxOcrPages: number;
+        /** Below this, a document keeps its name and gets no page. */
+        nameConfidence: number;
+        blockedExtensions: string[];
+        /** Keep `<file>.txt` beside each document whose text is its own. Off: the folder is the user's. */
+        textRendition: boolean;
+        /** Under this many characters, the page already says everything the file does. */
+        textRenditionMinChars: number;
+    };
+    maintenance: {
+        /** Named authority policy for the complete cycle. */
+        profile: MaintenanceProfile;
+        /** Every transformation has one policy after profile inheritance and ceiling enforcement. */
+        policies: Record<MaintenanceTransform, MaintenancePolicy>;
+        /** Cumulative apply ceilings for one maintenance invocation. */
+        limits: MaintenanceLimits;
+        /** Exact private payloads expire before compact terminal receipts. */
+        planRetention: {
+            payloadDays: number;
+            receiptDays: number;
+        };
+        /** Model-authored correction attempts allowed for one automatically curated item. */
+        maxRevisionAttempts: number;
+        /** Null when the cycle uses the `derive` role, which is the default. */
+        model: ResolvedModelRole | null;
+        /** Append a full record of every run to `<state_dir>/logs/dream.jsonl`. */
+        logChanges: boolean;
+        /** Local notification policy for scheduled maintenance; never includes knowledge-base content. */
+        notifications: MaintenanceNotificationMode;
+        retain: {
+            enabled: boolean;
+            mission: string | null;
+            fallbackPage: string | null;
+        };
+        observe: {
+            enabled: boolean;
+            mission: string | null;
+            minEvidence: number;
+            maxSubjects: number;
+        };
+        /** Ships as an extension point, off by default. */
+        reflect: {
+            enabled: boolean;
+            mission: string | null;
+        };
+        curate: {
+            verify: boolean;
+            maxPages: number;
+            maxSplits: number;
+            maxExtracts: number;
+            maxMerges: number;
+            maxRuleDrifts: number;
+            mergeFolders: string[];
+            mergeDiscovery: 'exact' | 'semantic';
+            maxChildrenPerPage: number;
+            splitAfterBytes: number;
+            splitSectionBytes: number;
+            extractAfterBytes: number;
+            extractSectionBytes: number;
+        };
+        adopt: {
+            maxPages: number;
+        };
+        conflicts: {
+            enabled: boolean;
+            verify: boolean;
+            resolve: boolean;
+            maxPairs: number;
+        };
+        repair: {
+            enabled: boolean;
+            links: boolean;
+            maxChanges: number;
+        };
+    };
+    trashRetentionDays: number;
+    rules: FolderRule[];
+    /** Files the config was assembled from, lowest precedence first. */
+    sources: string[];
+}
+export {};
+//# sourceMappingURL=schema.d.ts.map