/**
 * Whether Claude Code can actually load the ruflo mod plugins (ADR-404).
 *
 * `enabledPlugins["ruflo-mods@ruflo"] = true` in settings is only a request.
 * Observed live on Claude Code 2.1.287: an interactive, trusted session clones
 * the `ruflo` marketplace a project declares and loads an enabled plugin
 * straight from that clone (no install record needed); a headless `-p` run
 * clones nothing. A clone from before ruflo-mods shipped has no
 * `plugins/ruflo-mods`, and Claude Code skips the enabled plugin without a
 * word: `/ruflo-mods` is an unknown command, and the clone is not refreshed
 * on start. So the clone decides; an install record (`installed_plugins.json`,
 * pointing into `plugins/cache/`) is a cached copy that still loads when the
 * clone goes stale.
 *
 * Read-only. The config directory is `CLAUDE_CONFIG_DIR` when set, else
 * `~/.claude`, as Claude Code itself resolves it.
 */
import { type MarketplaceEntry, type ModPlugin, type Scope } from './install.js';
import type { Finding } from './probe.js';
/** The two filesystem reads detection needs; injectable for tests. */
export interface ReadFs {
    exists(path: string): boolean;
    readText(path: string): string | undefined;
}
export declare const nodeReadFs: ReadFs;
export declare function claudeConfigDir(env: NodeJS.ProcessEnv, home: string): string;
export interface MarketplaceState {
    /** Listed in known_marketplaces.json (so `marketplace update ruflo` works). */
    known: boolean;
    /** The local clone (or, for a directory source, the directory), when it exists on disk. */
    location: string | null;
    /** The source Claude Code knows the marketplace by, when known. */
    source?: MarketplaceEntry['source'];
}
/** "github ruvnet/ruflo" or "directory /path" (a working tree: no clone, nothing to go stale). */
export declare function describeSource(source: unknown): string;
export declare function sameSource(a: unknown, b: unknown): boolean;
export declare function marketplaceState(configDir: string, fs?: ReadFs): MarketplaceState;
/** The plugin's manifest inside a clone: its marketplace.json `source`, else plugins/<name>. */
export declare function pluginManifestIn(clone: string, id: string, fs?: ReadFs): string;
/** The clone carries this plugin. */
export declare function cloneHas(market: MarketplaceState, id: string, fs?: ReadFs): boolean;
export interface InstalledState {
    installed: boolean;
    scope?: string;
    installPath?: string;
}
/** Installed for this project: user scope anywhere, local/project scope for this root; its cache dir present. */
export declare function installedState(projectRoot: string, configDir: string, id: string, fs?: ReadFs): InstalledState;
/**
 * The exact commands that refresh the marketplace and install the plugins,
 * for a person to run. `known` is true only when Claude Code already knows
 * the marketplace by the wanted source (then an update suffices). A
 * directory source loads live from the working tree: nothing to install.
 */
export declare function repairCommands(projectRoot: string, scope: Scope | 'user', known: boolean, plugins?: readonly ModPlugin[], wanted?: MarketplaceEntry): string[];
/**
 * The marketplace finding plus one finding per plugin enabled in settings.
 * A required plugin missing from the clone with no cached install is the
 * failure Claude Code hides; a plugin not yet released is "pending".
 */
export declare function resolveFindings(projectRoot: string, scope: Scope | 'user', configDir: string, fs?: ReadFs, enabled?: readonly string[], declared?: unknown): Finding[];
//# sourceMappingURL=plugin-resolve.d.ts.map