onadit 0.0.1 → 0.1.0-beta.45

package/dist/src/config/schema.d.ts

@@ -0,0 +1,956 @@
+import { z } from "zod";
+export declare const ExtractionEnum: z.ZodEnum<["cloud", "local"]>;
+export declare const ModeEnum: z.ZodEnum<["watch", "scheduled_scan"]>;
+export declare const ScopeEnum: z.ZodEnum<["client", "project", "document"]>;
+export declare const SourceDirSchema: z.ZodEffects<z.ZodObject<{
+    path: z.ZodString;
+    extraction: z.ZodEnum<["cloud", "local"]>;
+    mode: z.ZodEnum<["watch", "scheduled_scan"]>;
+    scope: z.ZodEnum<["client", "project", "document"]>;
+    client_name: z.ZodOptional<z.ZodString>;
+    /**
+     * Paths relative to `path` that should be skipped by watcher/scanner/
+     * reconcile. Rejected at parse time: empty strings, absolute paths,
+     * and paths that escape the source root ("../x", "../../y"). The
+     * escape check is fail-closed on purpose — an operator typo like
+     * `../raw` should surface at config load, not degrade silently into
+     * an unprotected folder. Left optional so existing configs without
+     * an `exclude` field stay valid and `SourceDir`-shaped test
+     * fixtures remain assignable.
+     */
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    path: string;
+    extraction: "cloud" | "local";
+    mode: "watch" | "scheduled_scan";
+    scope: "client" | "project" | "document";
+    client_name?: string | undefined;
+    exclude?: string[] | undefined;
+}, {
+    path: string;
+    extraction: "cloud" | "local";
+    mode: "watch" | "scheduled_scan";
+    scope: "client" | "project" | "document";
+    client_name?: string | undefined;
+    exclude?: string[] | undefined;
+}>, {
+    path: string;
+    extraction: "cloud" | "local";
+    mode: "watch" | "scheduled_scan";
+    scope: "client" | "project" | "document";
+    client_name?: string | undefined;
+    exclude?: string[] | undefined;
+}, {
+    path: string;
+    extraction: "cloud" | "local";
+    mode: "watch" | "scheduled_scan";
+    scope: "client" | "project" | "document";
+    client_name?: string | undefined;
+    exclude?: string[] | undefined;
+}>;
+export declare const ServerSchema: z.ZodObject<{
+    port: z.ZodDefault<z.ZodNumber>;
+    host: z.ZodDefault<z.ZodLiteral<"127.0.0.1">>;
+}, "strict", z.ZodTypeAny, {
+    port: number;
+    host: "127.0.0.1";
+}, {
+    port?: number | undefined;
+    host?: "127.0.0.1" | undefined;
+}>;
+export declare const EmbeddingSchema: z.ZodObject<{
+    provider: z.ZodLiteral<"voyage">;
+    model: z.ZodDefault<z.ZodString>;
+    /**
+     * Embeddings API base, without `/embeddings`. Unset means Voyage's own
+     * `https://api.voyageai.com/v1`. Keys Onadit provisions are MongoDB Atlas
+     * model keys, which only work against `https://ai.mongodb.com/v1`.
+     */
+    base_url: z.ZodOptional<z.ZodString>;
+    /**
+     * Requested vector size, for models that can return several. Onadit's
+     * tables hold 512-dimension vectors (voyage-3-lite's native size), so a
+     * newer model must be asked for 512.
+     */
+    output_dimension: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    provider: "voyage";
+    model: string;
+    base_url?: string | undefined;
+    output_dimension?: number | undefined;
+}, {
+    provider: "voyage";
+    model?: string | undefined;
+    base_url?: string | undefined;
+    output_dimension?: number | undefined;
+}>;
+/**
+ * Operator-supplied display label for the Voyage project a friend's key
+ * is scoped to. Optional; rendered by `onadit status` for human reference
+ * only — never sent to the relay, never inferred from the key bytes.
+ */
+export declare const VoyageSchema: z.ZodObject<{
+    project_label: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    project_label?: string | undefined;
+}, {
+    project_label?: string | undefined;
+}>;
+export declare const DataPathsSchema: z.ZodObject<{
+    data_dir: z.ZodDefault<z.ZodString>;
+    jobs_dir: z.ZodDefault<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    data_dir: string;
+    jobs_dir: string;
+}, {
+    data_dir?: string | undefined;
+    jobs_dir?: string | undefined;
+}>;
+export declare const CompactionSchema: z.ZodObject<{
+    age_threshold_days: z.ZodDefault<z.ZodNumber>;
+    schedule: z.ZodDefault<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    age_threshold_days: number;
+    schedule: string;
+}, {
+    age_threshold_days?: number | undefined;
+    schedule?: string | undefined;
+}>;
+export declare const RateLimitSchema: z.ZodObject<{
+    window_ms: z.ZodNumber;
+    max_requests: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    window_ms: number;
+    max_requests: number;
+}, {
+    window_ms: number;
+    max_requests: number;
+}>;
+export declare const CronSchema: z.ZodObject<{
+    cron_enabled: z.ZodDefault<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    cron_enabled: boolean;
+}, {
+    cron_enabled?: boolean | undefined;
+}>;
+export declare const ScanSchema: z.ZodObject<{
+    /** Scan interval in seconds. Default: 604800 (7 days / weekly). */
+    interval_seconds: z.ZodDefault<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    interval_seconds: number;
+}, {
+    interval_seconds?: number | undefined;
+}>;
+export declare const CaptureSourceEnum: z.ZodEnum<["claude_code", "codex_cli", "cursor_composer", "claude_desktop_sessions", "grok_cli"]>;
+export declare const CaptureCodexCliSchema: z.ZodObject<{
+    /**
+     * Maximum Codex session size, in bytes, eligible for auto-capture triage.
+     * Sessions larger than this are quarantined to data/quarantine/ and skipped
+     * (no full read, no parse, no triage subprocess) so the Codex CLI prompt
+     * never receives an oversized stdin. Default lives in
+     * `DEFAULT_CODEX_MAX_SESSION_BYTES` (8 MB) — operators may raise it here.
+     */
+    max_session_bytes: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    max_session_bytes?: number | undefined;
+}, {
+    max_session_bytes?: number | undefined;
+}>;
+/**
+ * Triage worker selector. Triage (the auto-capture classifier) is the one AI
+ * task a fresh user is forced through to get capture working, so it is the
+ * first capability made provider-selectable. `codex_cli` (the default) keeps
+ * existing installs byte-for-byte unchanged; `claude_code` routes triage
+ * through the locally-authenticated `claude` CLI instead, so a Claude Code
+ * user can run capture without installing/authing Codex.
+ *
+ * Scope is deliberately triage-only: metadata extraction, digest, and
+ * embeddings still resolve via their own gates (enrichment.ai_metadata,
+ * local_generation, embedding.provider) and are unaffected by this field.
+ */
+export declare const TRIAGE_PROVIDER_VALUES: readonly ["codex_cli", "claude_code"];
+export type TriageProviderName = (typeof TRIAGE_PROVIDER_VALUES)[number];
+export declare const CaptureTriageSchema: z.ZodObject<{
+    /**
+     * Which local AI worker classifies captured conversations. Defaults to
+     * `codex_cli`; set to `claude_code` to triage via the `claude` CLI. Like
+     * Codex, the selected worker is an egress path (conversation content is sent
+     * to the worker on the operator's own subscription — no Onadit-held API key).
+     */
+    provider: z.ZodDefault<z.ZodEnum<["codex_cli", "claude_code"]>>;
+}, "strict", z.ZodTypeAny, {
+    provider: "claude_code" | "codex_cli";
+}, {
+    provider?: "claude_code" | "codex_cli" | undefined;
+}>;
+export declare const CaptureCursorSchema: z.ZodObject<{
+    /**
+     * Maximum native-Cursor session size, in bytes, eligible for auto-capture
+     * triage. Cursor sessions live in a shared `state.vscdb` (no file to stat),
+     * so the guard measures the PARSED transcript before triage; anything larger
+     * is parked as a TERMINAL oversized record (no triage, no save) and is not
+     * auto-recoverable — remediation is raise-this-limit or split the session.
+     * Default lives in `DEFAULT_CURSOR_MAX_SESSION_BYTES` (4 MB).
+     */
+    max_session_bytes: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    max_session_bytes?: number | undefined;
+}, {
+    max_session_bytes?: number | undefined;
+}>;
+export declare const CaptureSchema: z.ZodObject<{
+    /** Enable automatic capture of supported local CLI conversations. */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    /** Interval between capture runs, in seconds. Default: 3600 (1 hour). */
+    interval_seconds: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Sources enabled in the scheduled daemon loop.
+     * Defaults to both supported live CLI sources. First-run watermarking
+     * prevents historical backlog ingestion on enablement.
+     */
+    sources: z.ZodDefault<z.ZodArray<z.ZodEnum<["claude_code", "codex_cli", "cursor_composer", "claude_desktop_sessions", "grok_cli"]>, "atleastone">>;
+    /** Per-source overrides for the codex_cli auto-capture path. */
+    codex_cli: z.ZodOptional<z.ZodObject<{
+        /**
+         * Maximum Codex session size, in bytes, eligible for auto-capture triage.
+         * Sessions larger than this are quarantined to data/quarantine/ and skipped
+         * (no full read, no parse, no triage subprocess) so the Codex CLI prompt
+         * never receives an oversized stdin. Default lives in
+         * `DEFAULT_CODEX_MAX_SESSION_BYTES` (8 MB) — operators may raise it here.
+         */
+        max_session_bytes: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        max_session_bytes?: number | undefined;
+    }, {
+        max_session_bytes?: number | undefined;
+    }>>;
+    /** Per-source overrides for the native Cursor auto-capture path. */
+    cursor: z.ZodOptional<z.ZodObject<{
+        /**
+         * Maximum native-Cursor session size, in bytes, eligible for auto-capture
+         * triage. Cursor sessions live in a shared `state.vscdb` (no file to stat),
+         * so the guard measures the PARSED transcript before triage; anything larger
+         * is parked as a TERMINAL oversized record (no triage, no save) and is not
+         * auto-recoverable — remediation is raise-this-limit or split the session.
+         * Default lives in `DEFAULT_CURSOR_MAX_SESSION_BYTES` (4 MB).
+         */
+        max_session_bytes: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        max_session_bytes?: number | undefined;
+    }, {
+        max_session_bytes?: number | undefined;
+    }>>;
+    /**
+     * Which AI worker backs triage. Optional (not defaulted) so a config that
+     * predates this field still loads; absent reads as `codex_cli` at the
+     * resolution site, preserving the prior hardcoded default.
+     */
+    triage: z.ZodOptional<z.ZodObject<{
+        /**
+         * Which local AI worker classifies captured conversations. Defaults to
+         * `codex_cli`; set to `claude_code` to triage via the `claude` CLI. Like
+         * Codex, the selected worker is an egress path (conversation content is sent
+         * to the worker on the operator's own subscription — no Onadit-held API key).
+         */
+        provider: z.ZodDefault<z.ZodEnum<["codex_cli", "claude_code"]>>;
+    }, "strict", z.ZodTypeAny, {
+        provider: "claude_code" | "codex_cli";
+    }, {
+        provider?: "claude_code" | "codex_cli" | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    interval_seconds: number;
+    enabled: boolean;
+    sources: ["claude_code" | "codex_cli" | "cursor_composer" | "claude_desktop_sessions" | "grok_cli", ...("claude_code" | "codex_cli" | "cursor_composer" | "claude_desktop_sessions" | "grok_cli")[]];
+    codex_cli?: {
+        max_session_bytes?: number | undefined;
+    } | undefined;
+    cursor?: {
+        max_session_bytes?: number | undefined;
+    } | undefined;
+    triage?: {
+        provider: "claude_code" | "codex_cli";
+    } | undefined;
+}, {
+    codex_cli?: {
+        max_session_bytes?: number | undefined;
+    } | undefined;
+    interval_seconds?: number | undefined;
+    enabled?: boolean | undefined;
+    sources?: ["claude_code" | "codex_cli" | "cursor_composer" | "claude_desktop_sessions" | "grok_cli", ...("claude_code" | "codex_cli" | "cursor_composer" | "claude_desktop_sessions" | "grok_cli")[]] | undefined;
+    cursor?: {
+        max_session_bytes?: number | undefined;
+    } | undefined;
+    triage?: {
+        provider?: "claude_code" | "codex_cli" | undefined;
+    } | undefined;
+}>;
+export declare const LocalGenerationSchema: z.ZodEffects<z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    runtime: z.ZodOptional<z.ZodLiteral<"ollama">>;
+    mode: z.ZodDefault<z.ZodLiteral<"strict_local_only">>;
+    base_url: z.ZodDefault<z.ZodString>;
+    metadata_model: z.ZodOptional<z.ZodString>;
+    digest_model: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    mode: "strict_local_only";
+    base_url: string;
+    enabled: boolean;
+    runtime?: "ollama" | undefined;
+    metadata_model?: string | undefined;
+    digest_model?: string | undefined;
+}, {
+    mode?: "strict_local_only" | undefined;
+    base_url?: string | undefined;
+    enabled?: boolean | undefined;
+    runtime?: "ollama" | undefined;
+    metadata_model?: string | undefined;
+    digest_model?: string | undefined;
+}>, {
+    mode: "strict_local_only";
+    base_url: string;
+    enabled: boolean;
+    runtime?: "ollama" | undefined;
+    metadata_model?: string | undefined;
+    digest_model?: string | undefined;
+}, {
+    mode?: "strict_local_only" | undefined;
+    base_url?: string | undefined;
+    enabled?: boolean | undefined;
+    runtime?: "ollama" | undefined;
+    metadata_model?: string | undefined;
+    digest_model?: string | undefined;
+}>;
+export declare const RequestLimitsSchema: z.ZodObject<{
+    json_body_limit_bytes: z.ZodDefault<z.ZodNumber>;
+    multipart_limit_bytes: z.ZodDefault<z.ZodNumber>;
+    read_timeout_ms: z.ZodDefault<z.ZodNumber>;
+    mutation_timeout_ms: z.ZodDefault<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    json_body_limit_bytes: number;
+    multipart_limit_bytes: number;
+    read_timeout_ms: number;
+    mutation_timeout_ms: number;
+}, {
+    json_body_limit_bytes?: number | undefined;
+    multipart_limit_bytes?: number | undefined;
+    read_timeout_ms?: number | undefined;
+    mutation_timeout_ms?: number | undefined;
+}>;
+export declare const AuthSchema: z.ZodObject<{
+    test_token: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    test_token?: string | undefined;
+}, {
+    test_token?: string | undefined;
+}>;
+/**
+ * OpenAI runtime policy.
+ *
+ * Live ingest no longer touches the OpenAI API — both metadata extraction
+ * and triage route through the locally-authenticated Codex CLI. The fields
+ * here remain only for the **historical-backfill batch path**, which still
+ * uses the OpenAI provider when explicitly invoked: `max_cost_per_batch_usd`
+ * is the per-batch fail-closed cost ceiling and `max_parallel_requests`
+ * caps in-flight concurrency.
+ */
+export declare const OpenAISchema: z.ZodObject<{
+    /** Per-batch cost ceiling in USD. Fail-closed when exceeded. */
+    max_cost_per_batch_usd: z.ZodDefault<z.ZodNumber>;
+    /** Maximum concurrent in-flight requests per batch. */
+    max_parallel_requests: z.ZodDefault<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    max_cost_per_batch_usd: number;
+    max_parallel_requests: number;
+}, {
+    max_cost_per_batch_usd?: number | undefined;
+    max_parallel_requests?: number | undefined;
+}>;
+/**
+ * Codex CLI runtime policy. Global (not under `capture`) because the Codex CLI
+ * backs ALL local generation — triage, metadata extraction, digest, and
+ * large-session recovery — not just auto-capture.
+ */
+export declare const CodexCliSchema: z.ZodObject<{
+    /**
+     * Model to pin on every `codex exec` via `--model`. Onadit runs codex with
+     * an isolated CODEX_HOME that drops the user's config.toml, so without this
+     * codex would fall back to its release-default model — which 0.125.0 moved
+     * to one ChatGPT-auth plans reject. When unset, Onadit resolves a model from
+     * the source `~/.codex/config.toml`, a persisted verified model, or a
+     * probed fallback. Set this to override that resolution.
+     */
+    model: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    model?: string | undefined;
+}, {
+    model?: string | undefined;
+}>;
+/**
+ * Conversation/document metadata enrichment policy.
+ *
+ * `ai_metadata` defaults to FALSE: import and capture use the deterministic,
+ * AI-free `BasicMetadataExtractor` even when the Codex CLI is installed on the
+ * machine. This is the trust-first default — the no-key fast-import path sends
+ * no conversation content off-device, runs no Voyage embedding, and makes ZERO
+ * Codex subprocess calls, so "import + keyword search work without Codex or
+ * embeddings" is literally true on a fresh box. (Independently of this path,
+ * the daemon makes a metadata-only npm version check — no content, no key, no
+ * machine info.)
+ *
+ * It flips to true only when the user explicitly opts into AI enrichment
+ * (`onadit onboard --enable-codex-enrichment` or `--enable-claude-enrichment`,
+ * which persist this flag). Local (Ollama) enrichment has its own explicit
+ * opt-in via `local_generation.enabled` and is unaffected by this gate. The
+ * `RIFT_DISABLE_AI_METADATA` env override still force-disables regardless, for
+ * the activation benchmark.
+ */
+/**
+ * Metadata-extraction worker selector — the metadata-capability analogue of
+ * `capture.triage.provider`. This is deliberately nested UNDER `metadata`
+ * (not a flat `enrichment.provider`) because `enrichment` is a namespace that
+ * spans more than one capability: a flat provider would conflate metadata with
+ * the future digest worker and re-create the global-worker ambiguity we avoid
+ * elsewhere. Capability-level routing (`enrichment.metadata.provider`, later
+ * `enrichment.digest.provider`) keeps each capability independently selectable.
+ *
+ * `codex_cli` (the default) preserves today's behavior byte-for-byte. It only
+ * takes effect when `ai_metadata` is true — the gate above makes ZERO AI calls
+ * regardless of this value when enrichment is off. `claude_code` routes
+ * metadata through the `claude` CLI on the operator's subscription; if that CLI
+ * is missing or a run fails, extraction falls back to deterministic basic
+ * metadata (never blocks import). NOTE: selecting `claude_code` leaves digests/
+ * compaction OFF — there is no Claude digest worker yet and we do NOT silently
+ * borrow Codex for it; that ships with a dedicated `enrichment.digest.provider`.
+ */
+export declare const ENRICHMENT_METADATA_PROVIDER_VALUES: readonly ["codex_cli", "claude_code"];
+export type EnrichmentMetadataProviderName = (typeof ENRICHMENT_METADATA_PROVIDER_VALUES)[number];
+export declare const EnrichmentMetadataSchema: z.ZodObject<{
+    provider: z.ZodDefault<z.ZodEnum<["codex_cli", "claude_code"]>>;
+}, "strict", z.ZodTypeAny, {
+    provider: "claude_code" | "codex_cli";
+}, {
+    provider?: "claude_code" | "codex_cli" | undefined;
+}>;
+export declare const EnrichmentSchema: z.ZodObject<{
+    ai_metadata: z.ZodDefault<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodDefault<z.ZodEnum<["codex_cli", "claude_code"]>>;
+    }, "strict", z.ZodTypeAny, {
+        provider: "claude_code" | "codex_cli";
+    }, {
+        provider?: "claude_code" | "codex_cli" | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    ai_metadata: boolean;
+    metadata?: {
+        provider: "claude_code" | "codex_cli";
+    } | undefined;
+}, {
+    ai_metadata?: boolean | undefined;
+    metadata?: {
+        provider?: "claude_code" | "codex_cli" | undefined;
+    } | undefined;
+}>;
+export declare const ConfigSchema: z.ZodObject<{
+    sources: z.ZodArray<z.ZodEffects<z.ZodObject<{
+        path: z.ZodString;
+        extraction: z.ZodEnum<["cloud", "local"]>;
+        mode: z.ZodEnum<["watch", "scheduled_scan"]>;
+        scope: z.ZodEnum<["client", "project", "document"]>;
+        client_name: z.ZodOptional<z.ZodString>;
+        /**
+         * Paths relative to `path` that should be skipped by watcher/scanner/
+         * reconcile. Rejected at parse time: empty strings, absolute paths,
+         * and paths that escape the source root ("../x", "../../y"). The
+         * escape check is fail-closed on purpose — an operator typo like
+         * `../raw` should surface at config load, not degrade silently into
+         * an unprotected folder. Left optional so existing configs without
+         * an `exclude` field stay valid and `SourceDir`-shaped test
+         * fixtures remain assignable.
+         */
+        exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        path: string;
+        extraction: "cloud" | "local";
+        mode: "watch" | "scheduled_scan";
+        scope: "client" | "project" | "document";
+        client_name?: string | undefined;
+        exclude?: string[] | undefined;
+    }, {
+        path: string;
+        extraction: "cloud" | "local";
+        mode: "watch" | "scheduled_scan";
+        scope: "client" | "project" | "document";
+        client_name?: string | undefined;
+        exclude?: string[] | undefined;
+    }>, {
+        path: string;
+        extraction: "cloud" | "local";
+        mode: "watch" | "scheduled_scan";
+        scope: "client" | "project" | "document";
+        client_name?: string | undefined;
+        exclude?: string[] | undefined;
+    }, {
+        path: string;
+        extraction: "cloud" | "local";
+        mode: "watch" | "scheduled_scan";
+        scope: "client" | "project" | "document";
+        client_name?: string | undefined;
+        exclude?: string[] | undefined;
+    }>, "many">;
+    server: z.ZodDefault<z.ZodObject<{
+        port: z.ZodDefault<z.ZodNumber>;
+        host: z.ZodDefault<z.ZodLiteral<"127.0.0.1">>;
+    }, "strict", z.ZodTypeAny, {
+        port: number;
+        host: "127.0.0.1";
+    }, {
+        port?: number | undefined;
+        host?: "127.0.0.1" | undefined;
+    }>>;
+    embedding: z.ZodObject<{
+        provider: z.ZodLiteral<"voyage">;
+        model: z.ZodDefault<z.ZodString>;
+        /**
+         * Embeddings API base, without `/embeddings`. Unset means Voyage's own
+         * `https://api.voyageai.com/v1`. Keys Onadit provisions are MongoDB Atlas
+         * model keys, which only work against `https://ai.mongodb.com/v1`.
+         */
+        base_url: z.ZodOptional<z.ZodString>;
+        /**
+         * Requested vector size, for models that can return several. Onadit's
+         * tables hold 512-dimension vectors (voyage-3-lite's native size), so a
+         * newer model must be asked for 512.
+         */
+        output_dimension: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        provider: "voyage";
+        model: string;
+        base_url?: string | undefined;
+        output_dimension?: number | undefined;
+    }, {
+        provider: "voyage";
+        model?: string | undefined;
+        base_url?: string | undefined;
+        output_dimension?: number | undefined;
+    }>;
+    voyage: z.ZodOptional<z.ZodObject<{
+        project_label: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        project_label?: string | undefined;
+    }, {
+        project_label?: string | undefined;
+    }>>;
+    data_paths: z.ZodDefault<z.ZodObject<{
+        data_dir: z.ZodDefault<z.ZodString>;
+        jobs_dir: z.ZodDefault<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        data_dir: string;
+        jobs_dir: string;
+    }, {
+        data_dir?: string | undefined;
+        jobs_dir?: string | undefined;
+    }>>;
+    compaction: z.ZodDefault<z.ZodObject<{
+        age_threshold_days: z.ZodDefault<z.ZodNumber>;
+        schedule: z.ZodDefault<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        age_threshold_days: number;
+        schedule: string;
+    }, {
+        age_threshold_days?: number | undefined;
+        schedule?: string | undefined;
+    }>>;
+    rate_limit: z.ZodObject<{
+        window_ms: z.ZodNumber;
+        max_requests: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        window_ms: number;
+        max_requests: number;
+    }, {
+        window_ms: number;
+        max_requests: number;
+    }>;
+    cron: z.ZodDefault<z.ZodObject<{
+        cron_enabled: z.ZodDefault<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        cron_enabled: boolean;
+    }, {
+        cron_enabled?: boolean | undefined;
+    }>>;
+    scan: z.ZodDefault<z.ZodObject<{
+        /** Scan interval in seconds. Default: 604800 (7 days / weekly). */
+        interval_seconds: z.ZodDefault<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        interval_seconds: number;
+    }, {
+        interval_seconds?: number | undefined;
+    }>>;
+    capture: z.ZodDefault<z.ZodObject<{
+        /** Enable automatic capture of supported local CLI conversations. */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /** Interval between capture runs, in seconds. Default: 3600 (1 hour). */
+        interval_seconds: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Sources enabled in the scheduled daemon loop.
+         * Defaults to both supported live CLI sources. First-run watermarking
+         * prevents historical backlog ingestion on enablement.
+         */
+        sources: z.ZodDefault<z.ZodArray<z.ZodEnum<["claude_code", "codex_cli", "cursor_composer", "claude_desktop_sessions", "grok_cli"]>, "atleastone">>;
+        /** Per-source overrides for the codex_cli auto-capture path. */
+        codex_cli: z.ZodOptional<z.ZodObject<{
+            /**
+             * Maximum Codex session size, in bytes, eligible for auto-capture triage.
+             * Sessions larger than this are quarantined to data/quarantine/ and skipped
+             * (no full read, no parse, no triage subprocess) so the Codex CLI prompt
+             * never receives an oversized stdin. Default lives in
+             * `DEFAULT_CODEX_MAX_SESSION_BYTES` (8 MB) — operators may raise it here.
+             */
+            max_session_bytes: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            max_session_bytes?: number | undefined;
+        }, {
+            max_session_bytes?: number | undefined;
+        }>>;
+        /** Per-source overrides for the native Cursor auto-capture path. */
+        cursor: z.ZodOptional<z.ZodObject<{
+            /**
+             * Maximum native-Cursor session size, in bytes, eligible for auto-capture
+             * triage. Cursor sessions live in a shared `state.vscdb` (no file to stat),
+             * so the guard measures the PARSED transcript before triage; anything larger
+             * is parked as a TERMINAL oversized record (no triage, no save) and is not
+             * auto-recoverable — remediation is raise-this-limit or split the session.
+             * Default lives in `DEFAULT_CURSOR_MAX_SESSION_BYTES` (4 MB).
+             */
+            max_session_bytes: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            max_session_bytes?: number | undefined;
+        }, {
+            max_session_bytes?: number | undefined;
+        }>>;
+        /**
+         * Which AI worker backs triage. Optional (not defaulted) so a config that
+         * predates this field still loads; absent reads as `codex_cli` at the
+         * resolution site, preserving the prior hardcoded default.
+         */
+        triage: z.ZodOptional<z.ZodObject<{
+            /**
+             * Which local AI worker classifies captured conversations. Defaults to
+             * `codex_cli`; set to `claude_code` to triage via the `claude` CLI. Like
+             * Codex, the selected worker is an egress path (conversation content is sent
+             * to the worker on the operator's own subscription — no Onadit-held API key).
+             */
+            provider: z.ZodDefault<z.ZodEnum<["codex_cli", "claude_code"]>>;
+        }, "strict", z.ZodTypeAny, {
+            provider: "claude_code" | "codex_cli";
+        }, {
+            provider?: "claude_code" | "codex_cli" | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        interval_seconds: number;
+        enabled: boolean;
+        sources: ["claude_code" | "codex_cli" | "cursor_composer" | "claude_desktop_sessions" | "grok_cli", ...("claude_code" | "codex_cli" | "cursor_composer" | "claude_desktop_sessions" | "grok_cli")[]];
+        codex_cli?: {
+            max_session_bytes?: number | undefined;
+        } | undefined;
+        cursor?: {
+            max_session_bytes?: number | undefined;
+        } | undefined;
+        triage?: {
+            provider: "claude_code" | "codex_cli";
+        } | undefined;
+    }, {
+        codex_cli?: {
+            max_session_bytes?: number | undefined;
+        } | undefined;
+        interval_seconds?: number | undefined;
+        enabled?: boolean | undefined;
+        sources?: ["claude_code" | "codex_cli" | "cursor_composer" | "claude_desktop_sessions" | "grok_cli", ...("claude_code" | "codex_cli" | "cursor_composer" | "claude_desktop_sessions" | "grok_cli")[]] | undefined;
+        cursor?: {
+            max_session_bytes?: number | undefined;
+        } | undefined;
+        triage?: {
+            provider?: "claude_code" | "codex_cli" | undefined;
+        } | undefined;
+    }>>;
+    codex_cli: z.ZodOptional<z.ZodObject<{
+        /**
+         * Model to pin on every `codex exec` via `--model`. Onadit runs codex with
+         * an isolated CODEX_HOME that drops the user's config.toml, so without this
+         * codex would fall back to its release-default model — which 0.125.0 moved
+         * to one ChatGPT-auth plans reject. When unset, Onadit resolves a model from
+         * the source `~/.codex/config.toml`, a persisted verified model, or a
+         * probed fallback. Set this to override that resolution.
+         */
+        model: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        model?: string | undefined;
+    }, {
+        model?: string | undefined;
+    }>>;
+    local_generation: z.ZodOptional<z.ZodEffects<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        runtime: z.ZodOptional<z.ZodLiteral<"ollama">>;
+        mode: z.ZodDefault<z.ZodLiteral<"strict_local_only">>;
+        base_url: z.ZodDefault<z.ZodString>;
+        metadata_model: z.ZodOptional<z.ZodString>;
+        digest_model: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        mode: "strict_local_only";
+        base_url: string;
+        enabled: boolean;
+        runtime?: "ollama" | undefined;
+        metadata_model?: string | undefined;
+        digest_model?: string | undefined;
+    }, {
+        mode?: "strict_local_only" | undefined;
+        base_url?: string | undefined;
+        enabled?: boolean | undefined;
+        runtime?: "ollama" | undefined;
+        metadata_model?: string | undefined;
+        digest_model?: string | undefined;
+    }>, {
+        mode: "strict_local_only";
+        base_url: string;
+        enabled: boolean;
+        runtime?: "ollama" | undefined;
+        metadata_model?: string | undefined;
+        digest_model?: string | undefined;
+    }, {
+        mode?: "strict_local_only" | undefined;
+        base_url?: string | undefined;
+        enabled?: boolean | undefined;
+        runtime?: "ollama" | undefined;
+        metadata_model?: string | undefined;
+        digest_model?: string | undefined;
+    }>>;
+    enrichment: z.ZodOptional<z.ZodObject<{
+        ai_metadata: z.ZodDefault<z.ZodBoolean>;
+        metadata: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodDefault<z.ZodEnum<["codex_cli", "claude_code"]>>;
+        }, "strict", z.ZodTypeAny, {
+            provider: "claude_code" | "codex_cli";
+        }, {
+            provider?: "claude_code" | "codex_cli" | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        ai_metadata: boolean;
+        metadata?: {
+            provider: "claude_code" | "codex_cli";
+        } | undefined;
+    }, {
+        ai_metadata?: boolean | undefined;
+        metadata?: {
+            provider?: "claude_code" | "codex_cli" | undefined;
+        } | undefined;
+    }>>;
+    request_limits: z.ZodDefault<z.ZodObject<{
+        json_body_limit_bytes: z.ZodDefault<z.ZodNumber>;
+        multipart_limit_bytes: z.ZodDefault<z.ZodNumber>;
+        read_timeout_ms: z.ZodDefault<z.ZodNumber>;
+        mutation_timeout_ms: z.ZodDefault<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        json_body_limit_bytes: number;
+        multipart_limit_bytes: number;
+        read_timeout_ms: number;
+        mutation_timeout_ms: number;
+    }, {
+        json_body_limit_bytes?: number | undefined;
+        multipart_limit_bytes?: number | undefined;
+        read_timeout_ms?: number | undefined;
+        mutation_timeout_ms?: number | undefined;
+    }>>;
+    auth: z.ZodDefault<z.ZodObject<{
+        test_token: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        test_token?: string | undefined;
+    }, {
+        test_token?: string | undefined;
+    }>>;
+    openai: z.ZodDefault<z.ZodObject<{
+        /** Per-batch cost ceiling in USD. Fail-closed when exceeded. */
+        max_cost_per_batch_usd: z.ZodDefault<z.ZodNumber>;
+        /** Maximum concurrent in-flight requests per batch. */
+        max_parallel_requests: z.ZodDefault<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        max_cost_per_batch_usd: number;
+        max_parallel_requests: number;
+    }, {
+        max_cost_per_batch_usd?: number | undefined;
+        max_parallel_requests?: number | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    sources: {
+        path: string;
+        extraction: "cloud" | "local";
+        mode: "watch" | "scheduled_scan";
+        scope: "client" | "project" | "document";
+        client_name?: string | undefined;
+        exclude?: string[] | undefined;
+    }[];
+    server: {
+        port: number;
+        host: "127.0.0.1";
+    };
+    embedding: {
+        provider: "voyage";
+        model: string;
+        base_url?: string | undefined;
+        output_dimension?: number | undefined;
+    };
+    data_paths: {
+        data_dir: string;
+        jobs_dir: string;
+    };
+    compaction: {
+        age_threshold_days: number;
+        schedule: string;
+    };
+    rate_limit: {
+        window_ms: number;
+        max_requests: number;
+    };
+    cron: {
+        cron_enabled: boolean;
+    };
+    scan: {
+        interval_seconds: number;
+    };
+    capture: {
+        interval_seconds: number;
+        enabled: boolean;
+        sources: ["claude_code" | "codex_cli" | "cursor_composer" | "claude_desktop_sessions" | "grok_cli", ...("claude_code" | "codex_cli" | "cursor_composer" | "claude_desktop_sessions" | "grok_cli")[]];
+        codex_cli?: {
+            max_session_bytes?: number | undefined;
+        } | undefined;
+        cursor?: {
+            max_session_bytes?: number | undefined;
+        } | undefined;
+        triage?: {
+            provider: "claude_code" | "codex_cli";
+        } | undefined;
+    };
+    request_limits: {
+        json_body_limit_bytes: number;
+        multipart_limit_bytes: number;
+        read_timeout_ms: number;
+        mutation_timeout_ms: number;
+    };
+    auth: {
+        test_token?: string | undefined;
+    };
+    openai: {
+        max_cost_per_batch_usd: number;
+        max_parallel_requests: number;
+    };
+    codex_cli?: {
+        model?: string | undefined;
+    } | undefined;
+    voyage?: {
+        project_label?: string | undefined;
+    } | undefined;
+    local_generation?: {
+        mode: "strict_local_only";
+        base_url: string;
+        enabled: boolean;
+        runtime?: "ollama" | undefined;
+        metadata_model?: string | undefined;
+        digest_model?: string | undefined;
+    } | undefined;
+    enrichment?: {
+        ai_metadata: boolean;
+        metadata?: {
+            provider: "claude_code" | "codex_cli";
+        } | undefined;
+    } | undefined;
+}, {
+    sources: {
+        path: string;
+        extraction: "cloud" | "local";
+        mode: "watch" | "scheduled_scan";
+        scope: "client" | "project" | "document";
+        client_name?: string | undefined;
+        exclude?: string[] | undefined;
+    }[];
+    embedding: {
+        provider: "voyage";
+        model?: string | undefined;
+        base_url?: string | undefined;
+        output_dimension?: number | undefined;
+    };
+    rate_limit: {
+        window_ms: number;
+        max_requests: number;
+    };
+    codex_cli?: {
+        model?: string | undefined;
+    } | undefined;
+    voyage?: {
+        project_label?: string | undefined;
+    } | undefined;
+    server?: {
+        port?: number | undefined;
+        host?: "127.0.0.1" | undefined;
+    } | undefined;
+    data_paths?: {
+        data_dir?: string | undefined;
+        jobs_dir?: string | undefined;
+    } | undefined;
+    compaction?: {
+        age_threshold_days?: number | undefined;
+        schedule?: string | undefined;
+    } | undefined;
+    cron?: {
+        cron_enabled?: boolean | undefined;
+    } | undefined;
+    scan?: {
+        interval_seconds?: number | undefined;
+    } | undefined;
+    capture?: {
+        codex_cli?: {
+            max_session_bytes?: number | undefined;
+        } | undefined;
+        interval_seconds?: number | undefined;
+        enabled?: boolean | undefined;
+        sources?: ["claude_code" | "codex_cli" | "cursor_composer" | "claude_desktop_sessions" | "grok_cli", ...("claude_code" | "codex_cli" | "cursor_composer" | "claude_desktop_sessions" | "grok_cli")[]] | undefined;
+        cursor?: {
+            max_session_bytes?: number | undefined;
+        } | undefined;
+        triage?: {
+            provider?: "claude_code" | "codex_cli" | undefined;
+        } | undefined;
+    } | undefined;
+    local_generation?: {
+        mode?: "strict_local_only" | undefined;
+        base_url?: string | undefined;
+        enabled?: boolean | undefined;
+        runtime?: "ollama" | undefined;
+        metadata_model?: string | undefined;
+        digest_model?: string | undefined;
+    } | undefined;
+    enrichment?: {
+        ai_metadata?: boolean | undefined;
+        metadata?: {
+            provider?: "claude_code" | "codex_cli" | undefined;
+        } | undefined;
+    } | undefined;
+    request_limits?: {
+        json_body_limit_bytes?: number | undefined;
+        multipart_limit_bytes?: number | undefined;
+        read_timeout_ms?: number | undefined;
+        mutation_timeout_ms?: number | undefined;
+    } | undefined;
+    auth?: {
+        test_token?: string | undefined;
+    } | undefined;
+    openai?: {
+        max_cost_per_batch_usd?: number | undefined;
+        max_parallel_requests?: number | undefined;
+    } | undefined;
+}>;
+export type Config = z.infer<typeof ConfigSchema>;
+export type SourceDir = z.infer<typeof SourceDirSchema>;
+export type LocalGenerationConfig = z.infer<typeof LocalGenerationSchema>;
+export type OpenAIConfig = z.infer<typeof OpenAISchema>;
+//# sourceMappingURL=schema.d.ts.map