/**
 * Configuration loading and always-include file management.
 *
 * Handles global and per-thread configuration, including reading
 * files that should always be included in the context window.
 */
import type { IsolatedVisitor } from './restricted-codex.js';
/** Override the cumulus root directory (used by tests to isolate from production). */
export declare function setConfigCumulusDir(dir: string): void;
/** Resolve the config file path for a thread */
export declare function resolveConfigPath(threadName: string): string;
/** Same effective profile-presence check as runtime dispatch, for synchronous lists. */
export declare function hasIsolatedVisitorConfig(threadName: string): boolean;
/**
 * Resolve the master whose content store `threadName` shares, or undefined if
 * it has none (task 143).
 *
 * Walks the same trailing-`-segment` prefix chain as `resolveConfigPathForRead`,
 * but reads each candidate's EXACT config and requires the thread to be listed
 * in its `coThreads`. The prefix chain only narrows which configs to consult —
 * membership is what decides, so a name that merely looks like a co-thread
 * (every `pursuit-<deviceId>` visitor) resolves to undefined.
 *
 * A master is never its own co-thread: it already owns the store.
 */
export declare function resolveCoThreadMaster(threadName: string): string | undefined;
/**
 * Does this thread's OWN config list any co-threads (task 185)?
 *
 * The other half of "is this store shared": `resolveCoThreadMaster` answers it
 * for a co-thread, this answers it for the master. Reads the EXACT config, not
 * the inherited one — through the fallback a co-thread would read its master's
 * list and claim to be a master itself.
 */
export declare function hasCoThreads(threadName: string): boolean;
/** Override the threads directory (used by tests to isolate from production). */
export declare function setConfigThreadsDir(dir: string): void;
export interface CumulusConfig {
    /** Explicit host-bound visitor profile; bypasses inherited context (ADR 0022). */
    isolatedVisitor?: IsolatedVisitor;
    /** File paths to always include in context */
    alwaysInclude?: string[];
    /**
     * Per-thread opt-out from the merged always-include list (task 163).
     *
     * Subtractive only — entries here REMOVE a path from the effective prompt,
     * they cannot widen what arrives. If an entry isn't currently in the merged
     * result, excluding it is a no-op; if a future operator re-adds the path to
     * the global config, the exclude survives and takes effect again.
     *
     * Stored on the thread config only. Never inherited from global.
     */
    alwaysIncludeExcludes?: string[];
    /** Project directory for this thread (used by callers like Janus to set cwd) */
    projectDir?: string;
    /** Scaffold template to use on lazy creation of the project folder */
    template?: string;
    /** LLM model for this thread: "claude" (default, CLI subprocess) or a HuggingFace model ID */
    model?: string;
    /**
     * How hard the model should think before answering: "low" | "medium" | "high" | "xhigh" | "max".
     * Claude CLI threads spend it on --effort; direct-provider threads fold it onto the
     * endpoint's 3-level scale via `resolveReasoningEffort` (task 155).
     */
    effort?: 'low' | 'medium' | 'high' | 'xhigh' | 'max';
    /** Claude CLI model id (only applied when model is "claude"), passed as --model. e.g. "claude-opus-5[1m]" | "claude-sonnet-5[1m]" */
    claudeModel?: string;
    /** Exact tool names denied on both Claude CLI and direct-provider paths. */
    disallowedTools?: string[];
    /**
     * Allowlist (task 137): the ONLY tools this thread may use. Compiled into
     * `--disallowedTools` as (full inventory − this list), because the CLI's
     * `--allowedTools` is an auto-approve list and does not restrict.
     *
     * Absent = unrestricted (today's behaviour). Present = deny-by-default, so a tool
     * added by a future cumulus or Claude CLI release is denied without editing this list.
     * Entries match a bare name (`read_file`) or a full one
     * (`mcp__cumulus-history__read_file`). `disallowedTools` still applies on top.
     */
    allowedTools?: string[];
    /** Prompt capture (task 088): serialize each constructed prompt to the .prompts/ sidecar. Default ON; set false to disable */
    promptCapture?: boolean;
    /**
     * Pin this thread's context limit in tokens (task 105), disabling the adaptive
     * TTFT feedback loop for this thread. Must be >= 10,000; anything else is ignored
     * and the thread stays adaptive. Packed RAG budget is 2/3 of this value.
     */
    contextLimit?: number;
    /**
     * Co-threads (task 143): threads that share THIS thread's content store while
     * keeping their own conversation history. Written on the master only, by the
     * co-thread creation endpoint.
     *
     * Membership is EXPLICIT and never inferred from the name. Deriving it from
     * the `<master>-<label>` prefix would silently hand every app's visitor
     * threads (`pursuit-v-<id>`, `kalendeer-v-<id>`) a store shared with the app's
     * own work thread and with each other — a privacy leak and a dilution
     * disaster. A thread shares a store iff its master lists it here.
     */
    coThreads?: string[];
    /**
     * Shell command run inside a newly created co-thread worktree (task 143 phase 4).
     *
     * A fresh git worktree has the tracked files and NOTHING else — no
     * `node_modules`, no `dist`, no `.env` — so builds and tests fail there until
     * something installs them. Set this to whatever makes the tree usable, e.g.
     * `npm install`. It runs through the job system, so it does not block creation
     * and the co-thread is woken with the result.
     *
     * Deliberately a command rather than an assumed `npm install`: not every
     * project is npm, and symlinking `node_modules` is both against standing
     * policy and broken for natively-built dependencies.
     */
    worktreeSetup?: string;
    /** Scheduled triggers for this thread */
    schedules?: Array<{
        id: string;
        occurrenceId?: string;
        trigger: 'once' | 'cron';
        at?: string;
        cron?: string;
        message: string;
        lastFired?: string;
    }>;
    /** Pipeline/CRM metadata for dashboard tracking */
    pipeline?: PipelineMetadata;
}
/** Pipeline metadata for prospect/client tracking */
export interface PipelineMetadata {
    /** Current pipeline stage (e.g. "prospect", "outreach", "warm-engagement", "proposal", "onboarding", "active-client", "archived") */
    stage?: string;
    /** Engagement score 0-100 */
    score?: number;
    /** ISO date of last contact */
    lastContact?: string;
    /** Description of next action to take */
    nextAction?: string;
    /** ISO date for next action */
    nextActionDate?: string;
}
/** Information about a single always-include file */
export interface AlwaysIncludeFile {
    /** Original path from config */
    path: string;
    /** Absolute resolved path */
    resolvedPath: string;
    /** File contents (may be truncated) */
    content: string;
    /** Token count of content */
    tokens: number;
    /** Whether content was truncated */
    truncated: boolean;
    /** Error message if file couldn't be read */
    error?: string;
    /** True when a schema `Tasks.md` was projected down for the prompt (task 176). */
    projected?: boolean;
}
/** Result of reading all always-include files */
export interface AlwaysIncludeResult {
    /** Information about each file */
    files: AlwaysIncludeFile[];
    /** Total tokens across all files */
    totalTokens: number;
    /** Formatted context string for system prompt */
    formattedContext: string;
}
/**
 * Load the global configuration from ~/.cumulus/config.json
 */
export declare function loadGlobalConfig(): Promise<CumulusConfig>;
/**
 * Load thread-specific configuration from ~/.cumulus/threads/{thread}.config.json,
 * with the base thread's fields inherited underneath it (see
 * {@link loadThreadConfigMerged}).
 */
export declare function loadThreadConfig(threadName: string): Promise<CumulusConfig>;
/**
 * Load a thread's OWN config file, with no prefix fallback.
 *
 * `loadThreadConfig` inherits a base thread's config (task 098), which is right
 * for behaviour but wrong for editing: reading `coThreads` through the fallback
 * would hand a thread its parent's list and then `saveThreadConfig` would write
 * that list onto the child, silently claiming the parent's co-threads.
 */
export declare function loadThreadConfigExact(threadName: string): Promise<CumulusConfig>;
/**
 * Save thread-specific configuration to ~/.cumulus/threads/{thread}.config.json
 * Merges the provided partial config with the existing config (shallow merge).
 */
export declare function saveThreadConfig(threadName: string, updates: Partial<CumulusConfig>): Promise<void>;
/**
 * Merge global and thread configs. Thread config adds to global (doesn't override).
 */
export declare function mergeConfigs(global: CumulusConfig, thread: CumulusConfig): CumulusConfig;
/**
 * Resolve a file path that may use ~ or be relative.
 * @param filePath - The path from config (may use ~, be relative, or absolute)
 * @param cwd - Current working directory for relative paths
 */
export declare function resolveFilePath(filePath: string, cwd: string): string;
/**
 * The files a turn always carries, in send order.
 *
 * Task 183: the project's own `Tasks.md` is always sent, with no configuration.
 * It is the file the /tasks drawer edits, found by the same rule (gateway/tasks.ts),
 * and the projection in `readAlwaysIncludeFiles` keeps a migrated one small. A
 * configured entry that resolves to the same file is dropped rather than sent
 * twice. The one opt-out is `alwaysIncludeExcludes`, the existing way to keep a
 * file out of a thread's prompt.
 */
export declare function alwaysIncludePaths(config: CumulusConfig, cwd: string): string[];
/**
 * Read and format all always-include files from config.
 * @param config - Merged configuration
 * @param cwd - Current working directory for relative paths
 */
export declare function readAlwaysIncludeFiles(config: CumulusConfig, cwd: string): Promise<AlwaysIncludeResult>;
/**
 * Save configuration to a file.
 */
export declare function saveConfig(config: CumulusConfig, threadName?: string): Promise<void>;
/**
 * Add a file to the always-include list.
 * @param filePath - Path to add
 * @param threadName - Thread name for thread-specific config, undefined for global
 */
export declare function addAlwaysIncludeFile(filePath: string, threadName?: string): Promise<void>;
/**
 * Remove a file from the always-include list.
 * @param filePath - Path to remove
 * @param threadName - Thread name for thread-specific config, undefined for global
 */
export declare function removeAlwaysIncludeFile(filePath: string, threadName?: string): Promise<void>;
/**
 * List all always-include files from config (without reading them).
 *
 * Returns four buckets (task 163):
 *   - `global`: paths in ~/.cumulus/config.json
 *   - `thread`: paths added on this thread's own config
 *   - `merged`: paths that actually reach the prompt (union minus excludes)
 *   - `excluded`: paths the thread has opted out of via `alwaysIncludeExcludes`
 *
 * The UI uses these together to decide which × / − affordances to show.
 */
export declare function listAlwaysIncludeFiles(threadName?: string): Promise<{
    global: string[];
    thread: string[];
    merged: string[];
    excluded: string[];
}>;
/**
 * Toggle a per-thread opt-out for an always-include path (task 163).
 *
 * Adds `filePath` to the thread's `alwaysIncludeExcludes` if absent, removes it
 * otherwise. Reads/writes the thread's EXACT config (no prefix fallback) so the
 * exclude lives on the actual thread, not its base. Never mutates the global
 * config under any condition.
 *
 * Preserves every other field on the thread config by reading the full config,
 * mutating only the excludes array, and writing it back via saveConfig.
 */
export declare function toggleAlwaysIncludeExclude(filePath: string, threadName: string): Promise<void>;
/**
 * Remove an always-include file from THIS thread's effective list — the single
 * action behind one × button, regardless of where the path actually lives
 * (task 163).
 *
 * - Owned by this thread's own `alwaysInclude` → deleted for real (unchanged
 *   behavior; nothing else references it).
 * - Inherited from global (or a base thread) → never deleted at the source;
 *   added to this thread's `alwaysIncludeExcludes` instead, so the file
 *   disappears from THIS thread only and the global entry survives.
 * - Already excluded → toggling again re-includes it (the undo path).
 *
 * This replaces the two-affordance design (a "delete globally" × plus a
 * separate "exclude locally" −) the first cut shipped: a click on a global row
 * used to either silently no-op or, on any future error, delete the global
 * entry for every thread. One button, scope-aware, can't touch global state
 * from a per-thread click.
 */
export declare function removeAlwaysIncludeForThread(filePath: string, threadName: string): Promise<void>;
//# sourceMappingURL=config.d.ts.map