yowtf 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1337 @@
+import { Command } from 'commander';
+import os from 'node:os';
+
+declare const APP_NAME = "yowtf";
+declare const APP_FULL_NAME = "Your Operating Workstation Trouble Finder";
+declare const APP_TAGLINE = "Yo, WTF is happening?";
+declare const APP_VERSION = "0.1.0";
+/**
+ * Creates and configures the complete Commander program for YOWTF.
+ * Registers global options and all 20 public V1 commands.
+ * Adheres to docs/CLI-SPEC.md and docs/COMMANDS.md.
+ */
+declare function createProgram(): Command;
+/**
+ * Executes the Commander program with the provided arguments.
+ * Returns process exit code:
+ * - 0: Success (or help/version output)
+ * - 1: Application/diagnostic failure
+ * - 2: CLI usage error (unknown command, unknown option, invalid path, etc.)
+ */
+declare function runCli(argv?: string[]): Promise<number>;
+
+/**
+ * CLI Error types and exit codes.
+ * Adheres to docs/CLI-SPEC.md Section 48 & Section 55.
+ */
+declare const EXIT_SUCCESS = 0;
+declare const EXIT_APPLICATION_ERROR = 1;
+declare const EXIT_USAGE_ERROR = 2;
+declare class CliError extends Error {
+    readonly exitCode: number;
+    constructor(message: string, exitCode?: number);
+}
+declare class CliUsageError extends CliError {
+    constructor(message: string);
+}
+/**
+ * Formats an error into a clean, human-readable message without exposing raw stack traces or secrets.
+ */
+declare function formatCliError(error: unknown): string;
+
+/**
+ * Global CLI options interface.
+ * Adheres to docs/CLI-SPEC.md Section 7.
+ */
+interface GlobalOptions {
+    readonly verbose?: boolean;
+    readonly color?: boolean;
+    readonly json?: boolean;
+    readonly quiet?: boolean;
+    readonly path?: string;
+}
+/**
+ * Registers all authoritative global options on a Commander command.
+ */
+declare function registerGlobalOptions(command: Command): void;
+
+/**
+ * Resolves and validates the target directory path.
+ * If targetPath is not provided, defaults to normalized current working directory.
+ * If targetPath is provided, validates that it exists, is a directory, and is accessible.
+ * Throws CliUsageError (exit code 2) on failure.
+ * Adheres to docs/CLI-SPEC.md Section 15, 16, & 56.
+ */
+declare function resolveAndValidatePath(rawPath?: string, cwd?: string): string;
+
+interface DispatchOptions extends GlobalOptions {
+    readonly preview?: boolean;
+}
+/**
+ * Dispatches a parsed CLI command to the application layer.
+ * Normalizes global options and path, delegates to the application use case,
+ * and formats the resulting response according to presentation options.
+ */
+declare function dispatchCommand(commandName: string, options: DispatchOptions, commandSpecificOptions?: Record<string, unknown>): Promise<number>;
+
+/**
+ * Platform abstraction types and interfaces.
+ * Adheres to docs/ARCHITECTURE.md Section 5.5 and docs/TECH-STACK.md Section 40.
+ */
+type SupportedPlatform = 'windows' | 'macos' | 'linux';
+type PlatformType = SupportedPlatform | 'unsupported';
+interface PlatformInfo {
+    readonly platform: PlatformType;
+    readonly isSupported: boolean;
+    readonly os: NodeJS.Platform;
+    readonly arch: string;
+    readonly release: string;
+    readonly hostname: string;
+}
+interface MemoryInfo {
+    readonly totalBytes: number;
+    readonly freeBytes: number;
+    readonly usedBytes: number;
+    readonly utilizationPercent: number;
+}
+interface CpuCoreInfo {
+    readonly model: string;
+    readonly speedMHz: number;
+}
+interface CpuInfo {
+    readonly model: string;
+    readonly cores: number;
+    readonly speedMHz?: number;
+    readonly utilizationPercent?: number;
+}
+interface UptimeInfo {
+    readonly uptimeSeconds: number;
+}
+interface SafeCommandOptions {
+    readonly timeoutMs?: number;
+    readonly cwd?: string;
+    readonly env?: NodeJS.ProcessEnv;
+}
+interface SafeCommandResult {
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly exitCode: number;
+    readonly killed: boolean;
+    readonly durationMs: number;
+}
+/**
+ * Standard contract for operating-system-specific fact adapters.
+ * Implementations gather facts without calculating scores, creating findings,
+ * or mutating user state.
+ */
+interface PlatformAdapter {
+    readonly platformType: PlatformType;
+    readonly isSupported: boolean;
+    getPlatformInfo(): PlatformInfo;
+    getMemoryInfo(): Promise<MemoryInfo> | MemoryInfo;
+    getCpuInfo(): Promise<CpuInfo> | CpuInfo;
+    getUptimeInfo(): UptimeInfo;
+    isCommandAvailable(command: string): Promise<boolean>;
+}
+
+/**
+ * Authoritative diagnostic categories.
+ * Adheres to docs/RULE-CATALOGUE.md Section 12 and docs/DETECTION-ENGINE.md Section 12.
+ */
+declare const DIAGNOSTIC_CATEGORIES: readonly ["system", "disk", "process", "port", "network", "environment", "runtime", "tool", "path", "version", "project", "dependency", "git", "config", "cache"];
+type DiagnosticCategory = (typeof DIAGNOSTIC_CATEGORIES)[number];
+declare const CANONICAL_DIAGNOSTIC_CATEGORIES: readonly ["system", "disk", "process", "port", "network", "environment", "runtime", "tool", "path", "version", "project", "dependency", "git", "config", "cache"];
+type CanonicalDiagnosticCategory = DiagnosticCategory;
+/**
+ * Type guard for DiagnosticCategory.
+ * Strictly verifies against the 15 authoritative diagnostic categories.
+ */
+declare function isDiagnosticCategory(value: unknown): value is DiagnosticCategory;
+
+/**
+ * Authoritative diagnostic confidence levels.
+ * Adheres to docs/DETECTION-ENGINE.md Section 31-32.
+ *
+ * Confidence communicates certainty; it does NOT directly modify scoring penalties.
+ */
+declare const FINDING_CONFIDENCES: readonly ["HIGH", "MEDIUM", "LOW"];
+type FindingConfidence = (typeof FINDING_CONFIDENCES)[number];
+/**
+ * Type guard for FindingConfidence.
+ */
+declare function isFindingConfidence(value: unknown): value is FindingConfidence;
+
+/**
+ * Authoritative evidence availability states.
+ * Adheres to docs/DETECTION-ENGINE.md Section 7.
+ */
+declare const EVIDENCE_AVAILABILITIES: readonly ["AVAILABLE", "UNAVAILABLE", "FAILED", "NOT_APPLICABLE"];
+type EvidenceAvailability = (typeof EVIDENCE_AVAILABILITIES)[number];
+declare function isEvidenceAvailability(value: unknown): value is EvidenceAvailability;
+/**
+ * Primitive metadata value types safe for evidence representation without secret exposure.
+ */
+type EvidenceMetadataValue = string | number | boolean;
+/**
+ * Represents a single normalized piece of collected diagnostic evidence.
+ * Adheres to docs/DETECTION-ENGINE.md Section 8-9.
+ */
+interface EvidenceItem<T = unknown> {
+    readonly key: string;
+    readonly source: string;
+    readonly type?: string;
+    readonly availability: EvidenceAvailability;
+    readonly value?: T;
+    readonly unit?: string;
+    readonly metadata?: Readonly<Record<string, EvidenceMetadataValue>>;
+}
+/**
+ * Structured evidence attached to a diagnostic finding explaining why the rule produced its result.
+ * Adheres to docs/DETECTION-ENGINE.md Section 28.
+ */
+interface FindingEvidence {
+    readonly items: readonly EvidenceItem[];
+    readonly details?: Readonly<Record<string, EvidenceMetadataValue | readonly string[]>>;
+}
+/**
+ * Collection of evidence items grouped by category or collector scope.
+ * Adheres to docs/DETECTION-ENGINE.md Section 5.
+ */
+interface EvidenceSet {
+    readonly category?: DiagnosticCategory;
+    readonly items: readonly EvidenceItem[];
+}
+
+/**
+ * Authoritative diagnostic severity levels.
+ * Adheres to docs/DETECTION-ENGINE.md Section 32 and docs/SCORING.md Section 7.
+ *
+ * Severity describes diagnostic impact; scoring calculations belong in the scoring layer.
+ */
+declare const FINDING_SEVERITIES: readonly ["CRITICAL", "HIGH", "MEDIUM", "LOW", "INFO"];
+type FindingSeverity = (typeof FINDING_SEVERITIES)[number];
+/**
+ * Type guard for FindingSeverity.
+ */
+declare function isFindingSeverity(value: unknown): value is FindingSeverity;
+
+/**
+ * Authoritative diagnostic finding statuses.
+ * Adheres to docs/DETECTION-ENGINE.md Section 17-23 and docs/SCORING.md Section 9.
+ */
+declare const FINDING_STATUSES: readonly ["PASS", "FAIL", "WARN", "SKIPPED", "UNAVAILABLE", "ERROR"];
+type FindingStatus = (typeof FINDING_STATUSES)[number];
+/**
+ * Type guard for FindingStatus.
+ */
+declare function isFindingStatus(value: unknown): value is FindingStatus;
+
+/**
+ * Authoritative diagnostic finding model.
+ * Adheres to docs/DETECTION-ENGINE.md Section 24.
+ */
+interface Finding {
+    readonly ruleId: string;
+    readonly category: DiagnosticCategory;
+    readonly status: FindingStatus;
+    readonly severity: FindingSeverity;
+    readonly confidence: FindingConfidence;
+    readonly title: string;
+    readonly summary: string;
+    readonly explanation?: string;
+    readonly impact?: string;
+    readonly remediationHint?: string;
+    readonly evidence?: FindingEvidence;
+}
+interface CreateFindingParams {
+    readonly ruleId: string;
+    readonly category: DiagnosticCategory;
+    readonly status: FindingStatus;
+    readonly severity: FindingSeverity;
+    readonly confidence: FindingConfidence;
+    readonly title: string;
+    readonly summary: string;
+    readonly explanation?: string;
+    readonly impact?: string;
+    readonly remediationHint?: string;
+    readonly evidence?: FindingEvidence;
+}
+/**
+ * Creates and validates an immutable Finding object.
+ * Rejects structurally invalid parameters and enforces deep immutability.
+ */
+declare function createFinding(params: CreateFindingParams): Finding;
+
+/**
+ * Rule Identifier contract and validation.
+ * Adheres to docs/RULE-CATALOGUE.md Section 4 and docs/DETECTION-ENGINE.md Section 11.
+ *
+ * Rule IDs are lowercase, dot-separated identifiers in the canonical format:
+ * <category>.<subject>.<condition>
+ */
+interface ParsedRuleId {
+    readonly category: string;
+    readonly segments: readonly string[];
+    readonly subject?: string;
+    readonly condition?: string;
+}
+/**
+ * Validates whether a string matches the canonical Rule ID format.
+ * Lowercase, dot-separated identifier with at least two segments.
+ */
+declare function isValidRuleId(id: string): boolean;
+/**
+ * Parses a Rule ID into its component parts.
+ * Returns null if the Rule ID is invalid.
+ */
+declare function parseRuleId(id: string): ParsedRuleId | null;
+
+/**
+ * Declarative rule metadata describing a diagnostic rule specification.
+ * Adheres to docs/RULE-CATALOGUE.md Section 5.
+ */
+interface RuleMetadata {
+    readonly id: string;
+    readonly name: string;
+    readonly category: DiagnosticCategory;
+    readonly description: string;
+    readonly severity: FindingSeverity;
+    readonly confidence: FindingConfidence;
+    readonly applicability?: readonly string[];
+    readonly requiredEvidence?: readonly string[];
+    readonly explanation?: string;
+    readonly remediationHint?: string;
+}
+/**
+ * Represents the raw evaluated outcome of a diagnostic rule before finding construction.
+ * Adheres to docs/DETECTION-ENGINE.md Section 16-17.
+ */
+interface RuleEvaluation {
+    readonly ruleId: string;
+    readonly status: FindingStatus;
+    readonly finding?: Finding;
+}
+
+/**
+ * Diagnostic detection result providing coverage transparency.
+ * Adheres to docs/DETECTION-ENGINE.md Section 86.
+ *
+ * Preserves findings, executed rules, skipped rules, unavailable rules, and errors.
+ */
+interface DetectionResult {
+    readonly findings: readonly Finding[];
+    readonly executedRules: readonly string[];
+    readonly skippedRules: readonly string[];
+    readonly unavailableRules: readonly string[];
+    readonly errors: readonly string[];
+}
+
+/**
+ * Core Domain Layer exports for YOWTF.
+ * Adheres to docs/ARCHITECTURE.md Section 5.3, docs/DETECTION-ENGINE.md, and docs/RULE-CATALOGUE.md.
+ */
+
+/**
+ * Diagnostic scan result representing aggregated detection output for reporting.
+ * Adheres to docs/DETECTION-ENGINE.md Section 86 and docs/ARCHITECTURE.md Section 5.3.
+ */
+interface DiagnosticResult extends DetectionResult {
+    readonly status: FindingStatus;
+    readonly summary?: string;
+}
+
+/**
+ * Authoritative score bands.
+ * Adheres to docs/SCORING.md Section 28.
+ */
+declare const SCORE_BANDS: readonly ["EXCELLENT", "GOOD", "FAIR", "POOR", "CRITICAL"];
+type ScoreBand = (typeof SCORE_BANDS)[number];
+/**
+ * Base severity penalties.
+ * Adheres to docs/SCORING.md Section 8 & 57.
+ */
+declare const BASE_SEVERITY_PENALTIES: Readonly<Record<FindingSeverity, number>>;
+declare const SEVERITY_PENALTIES: Readonly<Record<"HIGH" | "MEDIUM" | "LOW" | "CRITICAL" | "INFO", number>>;
+declare const WARN_PENALTY_MULTIPLIER = 0.5;
+/**
+ * Detailed penalty assigned to an individual deduplicated finding.
+ */
+interface FindingPenalty {
+    readonly ruleId: string;
+    readonly severity: FindingSeverity;
+    readonly status: Finding['status'];
+    readonly penalty: number;
+}
+/**
+ * Complete health score result model.
+ * Adheres to docs/SCORING.md Section 3, 28, 38, & 55.
+ */
+interface ScoreResult {
+    readonly score: number;
+    readonly rawScore: number;
+    readonly band: ScoreBand;
+    readonly totalPenalty: number;
+    readonly penalties: readonly FindingPenalty[];
+    readonly totalFindings: number;
+    readonly criticalCount: number;
+    readonly highCount: number;
+    readonly mediumCount: number;
+    readonly lowCount: number;
+    readonly infoCount: number;
+    readonly failCount: number;
+    readonly warnCount: number;
+    readonly passCount: number;
+}
+type HealthScore = ScoreResult;
+interface ScoreCalculator {
+    calculate(findings: readonly Finding[]): ScoreResult;
+}
+/**
+ * Determines the score band from the final clamped and rounded score.
+ * Adheres to docs/SCORING.md Section 28 & 29.
+ *
+ * 90-100: EXCELLENT
+ * 75-89:  GOOD
+ * 60-74:  FAIR
+ * 40-59:  POOR
+ * 0-39:   CRITICAL
+ */
+declare function getScoreBand(score: number): ScoreBand;
+/**
+ * Calculates deterministic health score from diagnostic findings.
+ * Adheres strictly to docs/SCORING.md:
+ * - Starting score = 100
+ * - Deduplication by stable ruleId (retains highest penalty among duplicates)
+ * - FAIL: base penalty (CRITICAL: 25, HIGH: 15, MEDIUM: 8, LOW: 3, INFO: 0)
+ * - WARN: 50% of base penalty (CRITICAL: 12.5, HIGH: 7.5, MEDIUM: 4, LOW: 1.5, INFO: 0)
+ * - PASS, SKIPPED, UNAVAILABLE, ERROR: 0 penalty
+ * - No confidence multiplier
+ * - Final score clamped to 0-100 and rounded to nearest integer
+ */
+declare function calculateScore(findings: readonly Finding[]): ScoreResult;
+/**
+ * Default score calculator implementation.
+ */
+declare class DefaultScoreCalculator implements ScoreCalculator {
+    calculate(findings: readonly Finding[]): ScoreResult;
+}
+
+/**
+ * Diagnostic coverage details.
+ * Adheres to docs/SCORING.md Section 38 and docs/CLI-SPEC.md Section 46.
+ */
+interface DiagnosticCoverage {
+    readonly totalRules: number;
+    readonly executed: number;
+    readonly passed: number;
+    readonly failed: number;
+    readonly warned: number;
+    readonly skipped: number;
+    readonly unavailable: number;
+    readonly errored: number;
+}
+/**
+ * Report metadata identifying tool, version, command, target path, and scope.
+ */
+interface ReportMetadata {
+    readonly tool: string;
+    readonly version: string;
+    readonly command: string;
+    readonly targetPath: string;
+    readonly scope: string;
+    readonly category?: DiagnosticCategory;
+}
+/**
+ * Structured diagnostic report model.
+ * Canonical representation serving both Human and JSON reporters.
+ * Adheres to docs/CLI-SPEC.md Section 46.
+ */
+interface ReportModel {
+    readonly metadata: ReportMetadata;
+    readonly status: FindingStatus;
+    readonly score?: ScoreResult;
+    readonly findings: readonly Finding[];
+    readonly coverage: DiagnosticCoverage;
+}
+/**
+ * Presentation options passed to reporters.
+ */
+interface ReportOptions {
+    readonly json?: boolean;
+    readonly quiet?: boolean;
+    readonly verbose?: boolean;
+    readonly color?: boolean;
+    readonly command?: string;
+}
+/**
+ * Reporter interface for formatting ReportModel into terminal or JSON output.
+ */
+interface Reporter {
+    readonly format: 'terminal' | 'json';
+    render(model: ReportModel, options?: ReportOptions): string;
+}
+
+/**
+ * Scan and execution context provided to detection rules and the detection engine.
+ * Adheres to docs/DETECTION-ENGINE.md Section 36 and 78.
+ */
+interface DetectionContext {
+    readonly platform?: PlatformType | NodeJS.Platform;
+    readonly projectRoot?: string;
+    readonly commandScope?: string;
+    readonly env?: Readonly<Record<string, string | undefined>>;
+    readonly targetArchitecture?: string;
+    readonly targetNodeVersion?: string;
+    readonly targetPythonVersion?: string;
+}
+/**
+ * Standard contract for a diagnostic rule.
+ * Rules evaluate already-collected evidence to produce deterministic findings.
+ * Rules are strictly read-only and never perform collection, scoring, or remediation.
+ * Reference: docs/DETECTION-ENGINE.md Section 6, 10, 16.
+ */
+interface DiagnosticRule {
+    readonly metadata: RuleMetadata;
+    isApplicable(context: DetectionContext, evidence: readonly EvidenceItem[]): boolean;
+    evaluate(context: DetectionContext, evidence: readonly EvidenceItem[]): Promise<RuleEvaluation> | RuleEvaluation;
+}
+interface SyncDiagnosticRule extends DiagnosticRule {
+    evaluate(context: DetectionContext, evidence: readonly EvidenceItem[]): RuleEvaluation;
+}
+/**
+ * Registry interface for managing and selecting diagnostic rules deterministically.
+ * Reference: docs/DETECTION-ENGINE.md Section 39-40.
+ */
+interface RuleRegistryInterface {
+    register(rule: DiagnosticRule): void;
+    get(ruleId: string): DiagnosticRule | undefined;
+    list(): readonly DiagnosticRule[];
+    select(context?: DetectionContext): readonly DiagnosticRule[];
+}
+
+interface DetectionServiceOptions {
+    readonly registry?: RuleRegistryInterface;
+}
+/**
+ * Application service coordinating diagnostic rule evaluation.
+ * Boundary between application orchestration and the detection engine.
+ * Reference: docs/ARCHITECTURE.md Section 5.2 and 5.6.
+ */
+declare class DetectionService {
+    private readonly engine;
+    constructor(options?: DetectionServiceOptions);
+    /**
+     * Executes detection rules against normalized evidence and returns deterministic findings.
+     */
+    runDetection(evidence: readonly EvidenceItem[] | readonly EvidenceSet[], context?: DetectionContext): Promise<DetectionResult>;
+}
+
+/**
+ * Project discovery and collection types.
+ * Adheres to docs/ARCHITECTURE.md Section 18 and docs/RULE-CATALOGUE.md Section 23, 24, 25, 26.
+ */
+type SupportedProjectType = 'node' | 'python' | 'rust' | 'go' | 'java' | 'php' | 'ruby' | 'unknown';
+interface ProjectManifestMetadata {
+    readonly packageName?: string;
+    readonly packageManager?: string;
+    readonly engines?: Readonly<Record<string, string>>;
+    readonly scripts?: readonly string[];
+    readonly declaredDependencyCount?: number;
+}
+interface ProjectManifestInfo {
+    readonly name: string;
+    readonly path: string;
+    readonly ecosystem: SupportedProjectType;
+    readonly metadata?: ProjectManifestMetadata;
+}
+interface ProjectLockfileInfo {
+    readonly name: string;
+    readonly path: string;
+    readonly packageManager: string;
+}
+type ConfigCategory = 'runtime-policy' | 'environment' | 'tooling' | 'general';
+interface ProjectConfigInfo {
+    readonly name: string;
+    readonly path: string;
+    readonly category: ConfigCategory;
+}
+interface ProjectGitInfo {
+    readonly isRepository: boolean;
+    readonly gitDir?: string;
+    readonly branch?: string;
+}
+/**
+ * Structured project context established by project discovery.
+ */
+interface DiscoveredProject {
+    readonly isProject: boolean;
+    readonly rootPath: string;
+    readonly types: readonly SupportedProjectType[];
+    readonly primaryType: SupportedProjectType;
+    readonly manifests: readonly ProjectManifestInfo[];
+    readonly lockfiles: readonly ProjectLockfileInfo[];
+    readonly configFiles: readonly ProjectConfigInfo[];
+    readonly packageManager?: string;
+    readonly git: ProjectGitInfo;
+}
+
+declare class ProjectDiscovery {
+    /**
+     * Discovers project root and inspects structured project facts.
+     * Strictly read-only and safe.
+     */
+    discover(startDir: string): Promise<DiscoveredProject>;
+    /**
+     * Walks upward from startDir to locate the first ancestor directory containing project markers.
+     * Prevents escaping into unrelated directories such as user home or system temp root.
+     */
+    private findProjectRoot;
+    private safeReadDir;
+    private discoverManifests;
+    private safelyParsePackageJson;
+    private discoverLockfiles;
+    private discoverConfigs;
+    private discoverGit;
+    private determineTypes;
+    private resolvePackageManager;
+}
+
+/**
+ * Execution context provided to all collectors during a diagnostic scan.
+ * Reference: docs/ARCHITECTURE.md Section 5.4.
+ */
+interface CollectorContext {
+    readonly cwd: string;
+    readonly platformAdapter: PlatformAdapter;
+    readonly env?: NodeJS.ProcessEnv;
+}
+/**
+ * Standard contract for diagnostic collectors.
+ * Collectors gather raw machine and environment facts without making evaluative decisions.
+ */
+interface Collector<T = EvidenceSet> {
+    readonly name: string;
+    readonly category: DiagnosticCategory;
+    collect(context: CollectorContext): Promise<T>;
+}
+
+/**
+ * ProjectCollector gathers structured facts about the target project,
+ * fulfilling evidence requirements for PROJ-001 through PROJ-004,
+ * DEP-001 through DEP-003, GIT-001, and CFG-001.
+ *
+ * It is strictly read-only and does not calculate scores or create findings.
+ */
+declare class ProjectCollector implements Collector<EvidenceSet> {
+    private readonly discovery;
+    readonly name = "project";
+    readonly category: "project";
+    constructor(discovery?: ProjectDiscovery);
+    collect(context: CollectorContext): Promise<EvidenceSet>;
+    buildEvidenceSet(project: DiscoveredProject): EvidenceSet;
+}
+
+interface ProjectCollectionOptions {
+    readonly targetPath?: string;
+    readonly cwd?: string;
+    readonly platformAdapter?: PlatformAdapter;
+}
+interface ProjectCollectionResult {
+    readonly project: DiscoveredProject;
+    readonly evidence: EvidenceSet;
+}
+/**
+ * Application service coordinating project path resolution, project discovery,
+ * and structured project evidence collection.
+ * Reference: docs/ARCHITECTURE.md Section 5.2 and Section 18.
+ */
+declare class ProjectCollectionService {
+    private readonly discovery;
+    private readonly collector;
+    constructor(discovery?: ProjectDiscovery, collector?: ProjectCollector);
+    /**
+     * Discovers and collects structured project facts for the target directory.
+     */
+    discoverAndCollect(options?: ProjectCollectionOptions): Promise<ProjectCollectionResult>;
+}
+
+/**
+ * SystemCollector collects normalized system facts matching authoritative V1
+ * diagnostic rules (SYS-001 through SYS-005 in docs/RULE-CATALOGUE.md).
+ *
+ * It is strictly read-only and produces structured evidence without making evaluative decisions.
+ */
+declare class SystemCollector implements Collector<EvidenceSet> {
+    readonly name = "system";
+    readonly category: "system";
+    collect(context: CollectorContext): Promise<EvidenceSet>;
+}
+
+interface SystemCollectionOptions {
+    readonly cwd?: string;
+    readonly platformAdapter?: PlatformAdapter;
+}
+/**
+ * Application service coordinating platform resolution and system facts collection.
+ * Serves as the boundary between application use cases/scans and the collection layer.
+ * Reference: docs/ARCHITECTURE.md Section 5.2.
+ */
+declare class SystemCollectionService {
+    private readonly collector;
+    constructor(collector?: SystemCollector);
+    /**
+     * Executes system facts collection and returns normalized structured evidence.
+     */
+    collectSystemEvidence(options?: SystemCollectionOptions): Promise<EvidenceSet>;
+}
+
+interface ScanOrchestratorOptions {
+    readonly systemCollectionService?: SystemCollectionService;
+    readonly projectCollectionService?: ProjectCollectionService;
+    readonly detectionService?: DetectionService;
+}
+interface RunScanOptions {
+    readonly command: string;
+    readonly targetPath: string;
+    readonly verbose?: boolean;
+    readonly json?: boolean;
+    readonly quiet?: boolean;
+    readonly color?: boolean;
+    readonly preview?: boolean;
+    readonly platformAdapter?: PlatformAdapter;
+}
+/**
+ * Application service orchestrating the full diagnostic pipeline:
+ * Discovery -> Evidence Collection -> Rule Detection -> Health Scoring -> Report Assembly.
+ * Adheres to docs/ARCHITECTURE.md Section 5.2 and docs/CLI-SPEC.md Section 46.
+ */
+declare class ScanOrchestratorService {
+    private readonly systemCollectionService;
+    private readonly projectCollectionService;
+    private readonly detectionService;
+    constructor(options?: ScanOrchestratorOptions);
+    /**
+     * Executes an end-to-end diagnostic scan for the specified command and options.
+     */
+    executeScan(options: RunScanOptions): Promise<ReportModel>;
+    private resolveScope;
+}
+
+/**
+ * Application Layer foundational interfaces and use cases.
+ * Orchestrates the scan lifecycle: discovery -> collection -> detection -> scoring -> reporting.
+ * Reference: docs/ARCHITECTURE.md Section 5.2.
+ */
+interface ScanOptions {
+    readonly cwd?: string;
+    readonly verbose?: boolean;
+    readonly json?: boolean;
+    readonly quiet?: boolean;
+    readonly color?: boolean;
+}
+interface ApplicationContext {
+    readonly cwd: string;
+}
+interface CommandContext {
+    readonly command: string;
+    readonly targetPath: string;
+    readonly options: {
+        readonly verbose?: boolean;
+        readonly json?: boolean;
+        readonly quiet?: boolean;
+        readonly color?: boolean;
+        readonly preview?: boolean;
+        readonly platformAdapter?: PlatformAdapter;
+    };
+}
+interface CommandResult {
+    readonly command: string;
+    readonly targetPath: string;
+    readonly status: 'ready' | 'executed' | 'error';
+    readonly message?: string;
+    readonly exitCode: number;
+    readonly reportModel?: ReportModel;
+}
+/**
+ * Application entry point for command execution.
+ * Orchestrates the full diagnostic pipeline:
+ * Discovery -> Evidence Collection -> Detection -> Scoring -> Reporting.
+ */
+declare function executeCommand(context: CommandContext, orchestrator?: ScanOrchestratorService): Promise<CommandResult>;
+
+/**
+ * Deterministic Rule Registry for YOWTF.
+ * Rejects duplicate rule IDs and preserves stable catalog order.
+ * Reference: docs/DETECTION-ENGINE.md Section 39-40.
+ */
+declare class DefaultRuleRegistry implements RuleRegistryInterface {
+    private readonly rulesById;
+    private readonly rulesOrder;
+    constructor(initialRules?: readonly DiagnosticRule[]);
+    register(rule: DiagnosticRule): void;
+    get(ruleId: string): DiagnosticRule | undefined;
+    list(): readonly DiagnosticRule[];
+    select(context?: DetectionContext): readonly DiagnosticRule[];
+}
+/**
+ * Creates a pre-populated rule registry containing all 60 authoritative V1 diagnostic rules.
+ */
+declare function createDefaultRuleRegistry(): DefaultRuleRegistry;
+
+/**
+ * Authoritative Detection Engine for YOWTF.
+ * Executes registered diagnostic rules deterministically against normalized evidence.
+ * Provides fault isolation and structured coverage transparency.
+ * Reference: docs/DETECTION-ENGINE.md Section 85-87.
+ */
+declare class DetectionEngine {
+    private readonly registry;
+    constructor(registry: RuleRegistryInterface);
+    execute(evidenceInput: readonly EvidenceItem[] | readonly EvidenceSet[], context?: DetectionContext): Promise<DetectionResult>;
+}
+
+/**
+ * The authoritative, closed V1 diagnostic rule set for YOWTF.
+ * Order matches docs/RULE-CATALOGUE.md Section 76.
+ * Contains exactly 60 rules across 15 categories.
+ */
+declare const allV1Rules: readonly DiagnosticRule[];
+
+/**
+ * SYS-001: High Memory Pressure
+ * Reference: docs/RULE-CATALOGUE.md Section 13
+ */
+declare const sys001MemoryPressure: SyncDiagnosticRule;
+/**
+ * SYS-002: High CPU Pressure
+ * Reference: docs/RULE-CATALOGUE.md Section 13
+ */
+declare const sys002CpuPressure: SyncDiagnosticRule;
+/**
+ * SYS-003: Recently Restarted System
+ * Reference: docs/RULE-CATALOGUE.md Section 13
+ */
+declare const sys003UptimeShort: SyncDiagnosticRule;
+/**
+ * SYS-004: Architecture Mismatch
+ * Reference: docs/RULE-CATALOGUE.md Section 13
+ */
+declare const sys004ArchitectureMismatch: SyncDiagnosticRule;
+/**
+ * SYS-005: Supported Operating System
+ * Reference: docs/RULE-CATALOGUE.md Section 13
+ */
+declare const sys005PlatformSupported: SyncDiagnosticRule;
+declare const systemRules: readonly DiagnosticRule[];
+
+/**
+ * DISK-001: Low Disk Space
+ * Reference: docs/RULE-CATALOGUE.md Section 14
+ */
+declare const disk001SpaceLow: SyncDiagnosticRule;
+/**
+ * DISK-002: Developer Storage Pressure
+ * Reference: docs/RULE-CATALOGUE.md Section 14
+ */
+declare const disk002DeveloperStoragePressure: SyncDiagnosticRule;
+/**
+ * DISK-003: Project Storage Location Unavailable
+ * Reference: docs/RULE-CATALOGUE.md Section 14
+ */
+declare const disk003ProjectLocationUnavailable: SyncDiagnosticRule;
+/**
+ * DISK-004: Read-Only Project Filesystem
+ * Reference: docs/RULE-CATALOGUE.md Section 14
+ */
+declare const disk004FilesystemReadonly: SyncDiagnosticRule;
+declare const diskRules: readonly DiagnosticRule[];
+
+interface ProcessItem {
+    readonly pid: number;
+    readonly name: string;
+    readonly cpuPercent?: number;
+    readonly memoryPercent?: number;
+    readonly state?: string;
+}
+/**
+ * PROC-001: Resource-Heavy Process
+ * Reference: docs/RULE-CATALOGUE.md Section 15
+ */
+declare const proc001ResourceHog: SyncDiagnosticRule;
+/**
+ * PROC-002: Memory-Heavy Process
+ * Reference: docs/RULE-CATALOGUE.md Section 15
+ */
+declare const proc002MemoryHog: SyncDiagnosticRule;
+/**
+ * PROC-003: Zombie/Defunct Development Process
+ * Reference: docs/RULE-CATALOGUE.md Section 15
+ */
+declare const proc003Zombie: SyncDiagnosticRule;
+/**
+ * PROC-004: Duplicate Development Process
+ * Reference: docs/RULE-CATALOGUE.md Section 15
+ */
+declare const proc004Duplicate: SyncDiagnosticRule;
+declare const processRules: readonly DiagnosticRule[];
+
+interface PortListener {
+    readonly port: number;
+    readonly address: string;
+    readonly pid?: number;
+    readonly processName?: string;
+    readonly hasConflict?: boolean;
+    readonly isDuplicate?: boolean;
+    readonly ownerKnown?: boolean;
+}
+/**
+ * PORT-001: Development Port Conflict
+ * Reference: docs/RULE-CATALOGUE.md Section 16
+ */
+declare const port001DevConflict: SyncDiagnosticRule;
+/**
+ * PORT-002: Duplicate Listener Detection
+ * Reference: docs/RULE-CATALOGUE.md Section 16
+ */
+declare const port002DuplicateListener: SyncDiagnosticRule;
+/**
+ * PORT-003: Unexpected Local Port Exposure
+ * Reference: docs/RULE-CATALOGUE.md Section 16
+ */
+declare const port003UnexpectedExposure: SyncDiagnosticRule;
+/**
+ * PORT-004: Port Owner Unavailable
+ * Reference: docs/RULE-CATALOGUE.md Section 16
+ */
+declare const port004ProcessUnavailable: SyncDiagnosticRule;
+declare const portRules: readonly DiagnosticRule[];
+
+/**
+ * NET-001: Network Interface Information Unavailable
+ * Reference: docs/RULE-CATALOGUE.md Section 17
+ */
+declare const net001InterfaceUnavailable: SyncDiagnosticRule;
+/**
+ * NET-002: DNS Configuration Missing
+ * Reference: docs/RULE-CATALOGUE.md Section 17
+ */
+declare const net002DnsMissing: SyncDiagnosticRule;
+/**
+ * NET-003: Suspicious Proxy Configuration
+ * Reference: docs/RULE-CATALOGUE.md Section 17
+ */
+declare const net003ProxySuspicious: SyncDiagnosticRule;
+/**
+ * NET-004: Local Route Information Unavailable
+ * Reference: docs/RULE-CATALOGUE.md Section 17
+ */
+declare const net004RouteUnavailable: SyncDiagnosticRule;
+declare const networkRules: readonly DiagnosticRule[];
+
+/**
+ * ENV-001: Empty PATH Entry
+ * Reference: docs/RULE-CATALOGUE.md Section 18
+ */
+declare const env001EmptyPathEntry: SyncDiagnosticRule;
+/**
+ * ENV-002: Potential Secret in Environment Metadata
+ * Reference: docs/RULE-CATALOGUE.md Section 18
+ */
+declare const env002SecretExposure: SyncDiagnosticRule;
+/**
+ * ENV-003: Duplicate PATH Entry
+ * Reference: docs/RULE-CATALOGUE.md Section 18
+ */
+declare const env003DuplicatePath: SyncDiagnosticRule;
+/**
+ * ENV-004: Shell Environment PATH Mismatch
+ * Reference: docs/RULE-CATALOGUE.md Section 18
+ */
+declare const env004ShellPathMismatch: SyncDiagnosticRule;
+declare const environmentRules: readonly DiagnosticRule[];
+
+/**
+ * RUN-001: Node.js Runtime Unavailable
+ * Reference: docs/RULE-CATALOGUE.md Section 19
+ */
+declare const run001NodeUnavailable: SyncDiagnosticRule;
+/**
+ * RUN-002: Node.js Runtime Unpinned
+ * Reference: docs/RULE-CATALOGUE.md Section 19
+ */
+declare const run002NodeUnpinned: SyncDiagnosticRule;
+/**
+ * RUN-003: Python Runtime Unavailable
+ * Reference: docs/RULE-CATALOGUE.md Section 19
+ */
+declare const run003PythonUnavailable: SyncDiagnosticRule;
+/**
+ * RUN-004: Python Version Not Pinned
+ * Reference: docs/RULE-CATALOGUE.md Section 19
+ */
+declare const run004PythonUnpinned: SyncDiagnosticRule;
+/**
+ * RUN-005: Java Runtime Unavailable
+ * Reference: docs/RULE-CATALOGUE.md Section 19
+ */
+declare const run005JavaUnavailable: SyncDiagnosticRule;
+/**
+ * RUN-006: Runtime Version Mismatch
+ * Reference: docs/RULE-CATALOGUE.md Section 19
+ */
+declare const run006VersionMismatch: SyncDiagnosticRule;
+declare const runtimeRules: readonly DiagnosticRule[];
+
+/**
+ * TOOL-001: Git Unavailable
+ * Reference: docs/RULE-CATALOGUE.md Section 20
+ */
+declare const tool001GitUnavailable: SyncDiagnosticRule;
+/**
+ * TOOL-002: Package Manager Mismatch
+ * Reference: docs/RULE-CATALOGUE.md Section 20
+ */
+declare const tool002PackageManagerMismatch: SyncDiagnosticRule;
+/**
+ * TOOL-003: Required Package Manager Missing
+ * Reference: docs/RULE-CATALOGUE.md Section 20
+ */
+declare const tool003PackageManagerMissing: SyncDiagnosticRule;
+/**
+ * TOOL-004: Docker Unavailable
+ * Reference: docs/RULE-CATALOGUE.md Section 20
+ */
+declare const tool004DockerUnavailable: SyncDiagnosticRule;
+/**
+ * TOOL-005: Executable Shadowing
+ * Reference: docs/RULE-CATALOGUE.md Section 20
+ */
+declare const tool005ExecutableShadowing: SyncDiagnosticRule;
+declare const toolRules: readonly DiagnosticRule[];
+
+/**
+ * PATH-001: Expected Executable Missing
+ * Reference: docs/RULE-CATALOGUE.md Section 21
+ */
+declare const path001ExecutableMissing: SyncDiagnosticRule;
+/**
+ * PATH-002: Multiple Executable Resolutions
+ * Reference: docs/RULE-CATALOGUE.md Section 21
+ */
+declare const path002ExecutableMultiple: SyncDiagnosticRule;
+/**
+ * PATH-003: Invalid PATH Entry
+ * Reference: docs/RULE-CATALOGUE.md Section 21
+ */
+declare const path003EntryInvalid: SyncDiagnosticRule;
+/**
+ * PATH-004: PATH Order Shadowing
+ * Reference: docs/RULE-CATALOGUE.md Section 21
+ */
+declare const path004OrderShadowing: SyncDiagnosticRule;
+declare const pathRules: readonly DiagnosticRule[];
+
+/**
+ * VER-001: Runtime Version Conflict
+ * Reference: docs/RULE-CATALOGUE.md Section 22
+ */
+declare const ver001RuntimeConflict: SyncDiagnosticRule;
+/**
+ * VER-002: Developer Tool Version Conflict
+ * Reference: docs/RULE-CATALOGUE.md Section 22
+ */
+declare const ver002ToolConflict: SyncDiagnosticRule;
+/**
+ * VER-003: Project Runtime Requirement Unsatisfied
+ * Reference: docs/RULE-CATALOGUE.md Section 22
+ */
+declare const ver003ProjectRuntimeUnsatisfied: SyncDiagnosticRule;
+/**
+ * VER-004: Developer Tool Version Below Project Requirement
+ * Reference: docs/RULE-CATALOGUE.md Section 22
+ */
+declare const ver004ToolOutdated: SyncDiagnosticRule;
+declare const versionRules: readonly DiagnosticRule[];
+
+/**
+ * PROJ-001: Project Manifest Missing
+ * Reference: docs/RULE-CATALOGUE.md Section 23
+ */
+declare const proj001ManifestMissing: SyncDiagnosticRule;
+/**
+ * PROJ-002: Project Lockfile Missing
+ * Reference: docs/RULE-CATALOGUE.md Section 23
+ */
+declare const proj002LockfileMissing: SyncDiagnosticRule;
+/**
+ * PROJ-003: Project Runtime Policy Missing
+ * Reference: docs/RULE-CATALOGUE.md Section 23
+ */
+declare const proj003RuntimePolicyMissing: SyncDiagnosticRule;
+/**
+ * PROJ-004: Ambiguous Project Root
+ * Reference: docs/RULE-CATALOGUE.md Section 23
+ */
+declare const proj004RootAmbiguous: SyncDiagnosticRule;
+declare const projectRules: readonly DiagnosticRule[];
+
+/**
+ * DEP-001: Dependency Lockfile Missing
+ * Reference: docs/RULE-CATALOGUE.md Section 24
+ */
+declare const dep001LockfileMissing: SyncDiagnosticRule;
+/**
+ * DEP-002: Dependency Lockfile Mismatch
+ * Reference: docs/RULE-CATALOGUE.md Section 24
+ */
+declare const dep002LockfileMismatch: SyncDiagnosticRule;
+/**
+ * DEP-003: Dependency Package Manager Mismatch
+ * Reference: docs/RULE-CATALOGUE.md Section 24
+ */
+declare const dep003PackageManagerMismatch: SyncDiagnosticRule;
+/**
+ * DEP-004: Dependency Directory Inconsistency
+ * Reference: docs/RULE-CATALOGUE.md Section 24
+ */
+declare const dep004DirectoryInconsistent: SyncDiagnosticRule;
+declare const dependencyRules: readonly DiagnosticRule[];
+
+/**
+ * GIT-001: Git Repository Missing
+ * Reference: docs/RULE-CATALOGUE.md Section 25
+ */
+declare const git001RepositoryMissing: SyncDiagnosticRule;
+/**
+ * GIT-002: Dirty Working Tree
+ * Reference: docs/RULE-CATALOGUE.md Section 25
+ */
+declare const git002WorkingTreeDirty: SyncDiagnosticRule;
+/**
+ * GIT-003: Untracked Files Present
+ * Reference: docs/RULE-CATALOGUE.md Section 25
+ */
+declare const git003UntrackedFiles: SyncDiagnosticRule;
+/**
+ * GIT-004: Branch Divergence
+ * Reference: docs/RULE-CATALOGUE.md Section 25
+ */
+declare const git004BranchDivergence: SyncDiagnosticRule;
+declare const gitRules: readonly DiagnosticRule[];
+
+/**
+ * CFG-001: Expected Environment Configuration Missing
+ * Reference: docs/RULE-CATALOGUE.md Section 26
+ */
+declare const cfg001EnvFileMissing: SyncDiagnosticRule;
+/**
+ * CFG-002: Required Configuration Metadata Missing
+ * Reference: docs/RULE-CATALOGUE.md Section 26
+ */
+declare const cfg002RequiredValueMissing: SyncDiagnosticRule;
+declare const configRules: readonly DiagnosticRule[];
+
+/**
+ * CACHE-001: Large Developer Cache
+ * Reference: docs/RULE-CATALOGUE.md Section 27
+ */
+declare const cache001StorageLarge: SyncDiagnosticRule;
+/**
+ * CACHE-002: Large Build Artifact
+ * Reference: docs/RULE-CATALOGUE.md Section 27
+ */
+declare const cache002BuildArtifactLarge: SyncDiagnosticRule;
+declare const cacheRules: readonly DiagnosticRule[];
+
+/**
+ * Pure machine-readable JSON reporter.
+ * Adheres strictly to docs/CLI-SPEC.md Section 12, 15, 46, & 47:
+ * - Emits valid, formatted JSON
+ * - Zero ANSI color codes
+ * - Zero spinner noise
+ * - Zero decorative boxes or tables
+ * - Deterministic, stable field ordering
+ * - Quiet mode does not alter or suppress required JSON fields
+ */
+declare class JsonReporter implements Reporter {
+    readonly format: "json";
+    render(model: ReportModel, _options?: ReportOptions): string;
+}
+
+/**
+ * Terminal presentation reporter.
+ * Adheres to docs/CLI-SPEC.md Section 14, 18, 30, 32, 33, 64-68 and docs/COMMANDS.md.
+ * - Supports color/no-color via Chalk level toggle
+ * - Clean, professional layout with Boxen for health scores
+ * - Structured tables via cli-table3 for findings where helpful
+ * - Supports --quiet mode (minimal summary & key failures)
+ * - Supports --verbose mode (exposing rule IDs, coverage, evidence keys)
+ * - Command-specific presentation:
+ *   - score: focused score view
+ *   - explain: deep explanation view (problem -> evidence -> impact -> next action)
+ *   - doctor: prioritized problem view
+ *   - default / category commands: full / scoped diagnostics
+ */
+declare class TerminalReporter implements Reporter {
+    readonly format: "terminal";
+    render(model: ReportModel, options?: ReportOptions): string;
+    private renderScoreOnly;
+    private renderExplainView;
+    private renderStandardView;
+    private formatStatusBadge;
+    private formatSeverity;
+    private colorScore;
+    private colorScoreBand;
+    private getBorderColorForBand;
+}
+
+interface CreateReportModelOptions {
+    readonly command: string;
+    readonly targetPath: string;
+    readonly scope: string;
+    readonly category?: DiagnosticCategory;
+    readonly score?: ScoreResult;
+    readonly tool?: string;
+    readonly version?: string;
+}
+/**
+ * Assembles a canonical ReportModel from detection results, coverage, and metadata.
+ * Adheres to docs/CLI-SPEC.md Section 46 and docs/SCORING.md Section 38.
+ */
+declare function createReportModel(detectionResult: DetectionResult, options: CreateReportModelOptions): ReportModel;
+
+/**
+ * Reporting Layer foundational interfaces and implementations.
+ * Formats and renders diagnostic results to terminal or JSON output.
+ * Adheres to docs/ARCHITECTURE.md Section 5.8, docs/CLI-SPEC.md, and docs/SCORING.md.
+ */
+
+/**
+ * Legacy ReportPayload interface preserved for compatibility.
+ */
+interface ReportPayload {
+    readonly result: DiagnosticResult;
+    readonly score?: HealthScore;
+}
+
+declare class CommandExecutionError extends Error {
+    readonly exitCode: number | null;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly killed: boolean;
+    constructor(message: string, options: {
+        exitCode: number | null;
+        stdout: string;
+        stderr: string;
+        killed: boolean;
+        cause?: unknown;
+    });
+}
+/**
+ * Executes a command safely without shell expansion.
+ * Strictly non-interactive and read-only.
+ */
+declare function executeSafeCommand(file: string, args?: readonly string[], options?: SafeCommandOptions): Promise<SafeCommandResult>;
+
+interface WindowsSystemProvider {
+    arch(): string;
+    release(): string;
+    hostname(): string;
+    totalmem(): number;
+    freemem(): number;
+    cpus(): os.CpuInfo[];
+    uptime(): number;
+}
+declare class WindowsPlatformAdapter implements PlatformAdapter {
+    private readonly provider;
+    readonly platformType: "windows";
+    readonly isSupported = true;
+    constructor(provider?: WindowsSystemProvider);
+    getPlatformInfo(): PlatformInfo;
+    getMemoryInfo(): MemoryInfo;
+    getCpuInfo(): CpuInfo;
+    getUptimeInfo(): UptimeInfo;
+    isCommandAvailable(command: string): Promise<boolean>;
+}
+
+interface DarwinSystemProvider {
+    arch(): string;
+    release(): string;
+    hostname(): string;
+    totalmem(): number;
+    freemem(): number;
+    cpus(): os.CpuInfo[];
+    uptime(): number;
+}
+declare class MacOSPlatformAdapter implements PlatformAdapter {
+    private readonly provider;
+    readonly platformType: "macos";
+    readonly isSupported = true;
+    constructor(provider?: DarwinSystemProvider);
+    getPlatformInfo(): PlatformInfo;
+    getMemoryInfo(): MemoryInfo;
+    getCpuInfo(): CpuInfo;
+    getUptimeInfo(): UptimeInfo;
+    isCommandAvailable(command: string): Promise<boolean>;
+}
+
+interface LinuxSystemProvider {
+    arch(): string;
+    release(): string;
+    hostname(): string;
+    totalmem(): number;
+    freemem(): number;
+    cpus(): os.CpuInfo[];
+    uptime(): number;
+}
+declare class LinuxPlatformAdapter implements PlatformAdapter {
+    private readonly provider;
+    readonly platformType: "linux";
+    readonly isSupported = true;
+    constructor(provider?: LinuxSystemProvider);
+    getPlatformInfo(): PlatformInfo;
+    getMemoryInfo(): MemoryInfo;
+    getCpuInfo(): CpuInfo;
+    getUptimeInfo(): UptimeInfo;
+    isCommandAvailable(command: string): Promise<boolean>;
+}
+
+interface UnsupportedSystemProvider {
+    platform(): NodeJS.Platform;
+    arch(): string;
+    release(): string;
+    hostname(): string;
+    totalmem(): number;
+    freemem(): number;
+    cpus(): os.CpuInfo[];
+    uptime(): number;
+}
+declare class UnsupportedPlatformAdapter implements PlatformAdapter {
+    private readonly provider;
+    readonly platformType: "unsupported";
+    readonly isSupported = false;
+    constructor(provider?: UnsupportedSystemProvider);
+    getPlatformInfo(): PlatformInfo;
+    getMemoryInfo(): MemoryInfo;
+    getCpuInfo(): CpuInfo;
+    getUptimeInfo(): UptimeInfo;
+    isCommandAvailable(_command: string): Promise<boolean>;
+}
+
+declare const SUPPORTED_PLATFORMS: readonly SupportedPlatform[];
+/**
+ * Normalizes an operating system platform identifier into a PlatformType.
+ * Defaults to current process.platform if none is supplied.
+ */
+declare function detectPlatform(osPlatform?: string): PlatformType;
+/**
+ * Checks whether an operating system platform identifier is supported.
+ */
+declare function isSupportedPlatform(osPlatform?: string): boolean;
+/**
+ * Factory that returns the appropriate PlatformAdapter for the given platform.
+ * Defaults to process.platform.
+ */
+declare function resolvePlatformAdapter(osPlatform?: string): PlatformAdapter;
+
+export { APP_FULL_NAME, APP_NAME, APP_TAGLINE, APP_VERSION, type ApplicationContext, BASE_SEVERITY_PENALTIES, CANONICAL_DIAGNOSTIC_CATEGORIES, type CanonicalDiagnosticCategory, CliError, CliUsageError, type Collector, type CollectorContext, type CommandContext, CommandExecutionError, type CommandResult, type ConfigCategory, type CpuCoreInfo, type CpuInfo, type CreateFindingParams, type CreateReportModelOptions, DIAGNOSTIC_CATEGORIES, type DarwinSystemProvider, DefaultRuleRegistry, DefaultScoreCalculator, type DetectionContext, DetectionEngine, type DetectionResult, DetectionService, type DetectionServiceOptions, type DiagnosticCategory, type DiagnosticCoverage, type DiagnosticResult, type DiagnosticRule, type DiscoveredProject, type DispatchOptions, EVIDENCE_AVAILABILITIES, EXIT_APPLICATION_ERROR, EXIT_SUCCESS, EXIT_USAGE_ERROR, type EvidenceAvailability, type EvidenceItem, type EvidenceMetadataValue, type EvidenceSet, FINDING_CONFIDENCES, FINDING_SEVERITIES, FINDING_STATUSES, type Finding, type FindingConfidence, type FindingEvidence, type FindingPenalty, type FindingSeverity, type FindingStatus, type GlobalOptions, type HealthScore, JsonReporter, LinuxPlatformAdapter, type LinuxSystemProvider, MacOSPlatformAdapter, type MemoryInfo, type ParsedRuleId, type PlatformAdapter, type PlatformInfo, type PlatformType, type PortListener, type ProcessItem, type ProjectCollectionOptions, type ProjectCollectionResult, ProjectCollectionService, ProjectCollector, type ProjectConfigInfo, ProjectDiscovery, type ProjectGitInfo, type ProjectLockfileInfo, type ProjectManifestInfo, type ProjectManifestMetadata, type ReportMetadata, type ReportModel, type ReportOptions, type ReportPayload, type Reporter, type RuleEvaluation, type RuleMetadata, type RuleRegistryInterface, type RunScanOptions, SCORE_BANDS, SEVERITY_PENALTIES, SUPPORTED_PLATFORMS, type SafeCommandOptions, type SafeCommandResult, type ScanOptions, type ScanOrchestratorOptions, ScanOrchestratorService, type ScoreBand, type ScoreCalculator, type ScoreResult, type SupportedPlatform, type SupportedProjectType, type SyncDiagnosticRule, type SystemCollectionOptions, SystemCollectionService, SystemCollector, TerminalReporter, UnsupportedPlatformAdapter, type UnsupportedSystemProvider, type UptimeInfo, WARN_PENALTY_MULTIPLIER, WindowsPlatformAdapter, type WindowsSystemProvider, allV1Rules, cache001StorageLarge, cache002BuildArtifactLarge, cacheRules, calculateScore, cfg001EnvFileMissing, cfg002RequiredValueMissing, configRules, createDefaultRuleRegistry, createFinding, createProgram, createReportModel, dep001LockfileMissing, dep002LockfileMismatch, dep003PackageManagerMismatch, dep004DirectoryInconsistent, dependencyRules, detectPlatform, disk001SpaceLow, disk002DeveloperStoragePressure, disk003ProjectLocationUnavailable, disk004FilesystemReadonly, diskRules, dispatchCommand, env001EmptyPathEntry, env002SecretExposure, env003DuplicatePath, env004ShellPathMismatch, environmentRules, executeCommand, executeSafeCommand, formatCliError, getScoreBand, git001RepositoryMissing, git002WorkingTreeDirty, git003UntrackedFiles, git004BranchDivergence, gitRules, isDiagnosticCategory, isEvidenceAvailability, isFindingConfidence, isFindingSeverity, isFindingStatus, isSupportedPlatform, isValidRuleId, net001InterfaceUnavailable, net002DnsMissing, net003ProxySuspicious, net004RouteUnavailable, networkRules, parseRuleId, path001ExecutableMissing, path002ExecutableMultiple, path003EntryInvalid, path004OrderShadowing, pathRules, port001DevConflict, port002DuplicateListener, port003UnexpectedExposure, port004ProcessUnavailable, portRules, proc001ResourceHog, proc002MemoryHog, proc003Zombie, proc004Duplicate, processRules, proj001ManifestMissing, proj002LockfileMissing, proj003RuntimePolicyMissing, proj004RootAmbiguous, projectRules, registerGlobalOptions, resolveAndValidatePath, resolvePlatformAdapter, run001NodeUnavailable, run002NodeUnpinned, run003PythonUnavailable, run004PythonUnpinned, run005JavaUnavailable, run006VersionMismatch, runCli, runtimeRules, sys001MemoryPressure, sys002CpuPressure, sys003UptimeShort, sys004ArchitectureMismatch, sys005PlatformSupported, systemRules, tool001GitUnavailable, tool002PackageManagerMismatch, tool003PackageManagerMissing, tool004DockerUnavailable, tool005ExecutableShadowing, toolRules, ver001RuntimeConflict, ver002ToolConflict, ver003ProjectRuntimeUnsatisfied, ver004ToolOutdated, versionRules };