harness-evolve 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1029 @@
+import { z } from 'zod/v4';
+export { handleStop } from './hooks/stop.js';
+import { Command } from '@commander-js/extra-typings';
+
+declare const configSchema: z.ZodObject<{
+    version: z.ZodDefault<z.ZodNumber>;
+    analysis: z.ZodDefault<z.ZodObject<{
+        threshold: z.ZodDefault<z.ZodNumber>;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        classifierThresholds: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    }, z.core.$strip>>;
+    hooks: z.ZodDefault<z.ZodObject<{
+        capturePrompts: z.ZodDefault<z.ZodBoolean>;
+        captureTools: z.ZodDefault<z.ZodBoolean>;
+        capturePermissions: z.ZodDefault<z.ZodBoolean>;
+        captureSessions: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    scrubbing: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        highEntropyDetection: z.ZodDefault<z.ZodBoolean>;
+        customPatterns: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            regex: z.ZodString;
+            replacement: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    delivery: z.ZodDefault<z.ZodObject<{
+        stdoutInjection: z.ZodDefault<z.ZodBoolean>;
+        maxTokens: z.ZodDefault<z.ZodNumber>;
+        fullAuto: z.ZodDefault<z.ZodBoolean>;
+        maxRecommendationsInFile: z.ZodDefault<z.ZodNumber>;
+        archiveAfterDays: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+type Config = z.infer<typeof configSchema>;
+
+declare const promptEntrySchema: z.ZodObject<{
+    timestamp: z.ZodISODateTime;
+    session_id: z.ZodString;
+    cwd: z.ZodString;
+    prompt: z.ZodString;
+    prompt_length: z.ZodNumber;
+    transcript_path: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type PromptEntry = z.infer<typeof promptEntrySchema>;
+declare const toolEntrySchema: z.ZodObject<{
+    timestamp: z.ZodISODateTime;
+    session_id: z.ZodString;
+    event: z.ZodEnum<{
+        pre: "pre";
+        post: "post";
+        failure: "failure";
+    }>;
+    tool_name: z.ZodString;
+    input_summary: z.ZodOptional<z.ZodString>;
+    duration_ms: z.ZodOptional<z.ZodNumber>;
+    success: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type ToolEntry = z.infer<typeof toolEntrySchema>;
+declare const permissionEntrySchema: z.ZodObject<{
+    timestamp: z.ZodISODateTime;
+    session_id: z.ZodString;
+    tool_name: z.ZodString;
+    decision: z.ZodEnum<{
+        unknown: "unknown";
+        approved: "approved";
+        denied: "denied";
+    }>;
+}, z.core.$strip>;
+type PermissionEntry = z.infer<typeof permissionEntrySchema>;
+declare const sessionEntrySchema: z.ZodObject<{
+    timestamp: z.ZodISODateTime;
+    session_id: z.ZodString;
+    event: z.ZodEnum<{
+        start: "start";
+        end: "end";
+    }>;
+    cwd: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type SessionEntry = z.infer<typeof sessionEntrySchema>;
+
+declare const counterSchema: z.ZodObject<{
+    total: z.ZodDefault<z.ZodNumber>;
+    session: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    last_analysis: z.ZodOptional<z.ZodISODateTime>;
+    last_updated: z.ZodISODateTime;
+}, z.core.$strip>;
+type Counter = z.infer<typeof counterSchema>;
+
+declare const hookCommonSchema: z.ZodObject<{
+    session_id: z.ZodString;
+    transcript_path: z.ZodString;
+    cwd: z.ZodString;
+    permission_mode: z.ZodString;
+}, z.core.$strip>;
+type HookCommon = z.infer<typeof hookCommonSchema>;
+declare const userPromptSubmitInputSchema: z.ZodObject<{
+    session_id: z.ZodString;
+    transcript_path: z.ZodString;
+    cwd: z.ZodString;
+    permission_mode: z.ZodString;
+    hook_event_name: z.ZodLiteral<"UserPromptSubmit">;
+    prompt: z.ZodString;
+}, z.core.$strip>;
+type UserPromptSubmitInput = z.infer<typeof userPromptSubmitInputSchema>;
+declare const preToolUseInputSchema: z.ZodObject<{
+    session_id: z.ZodString;
+    transcript_path: z.ZodString;
+    cwd: z.ZodString;
+    permission_mode: z.ZodString;
+    hook_event_name: z.ZodLiteral<"PreToolUse">;
+    tool_name: z.ZodString;
+    tool_input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    tool_use_id: z.ZodString;
+}, z.core.$strip>;
+type PreToolUseInput = z.infer<typeof preToolUseInputSchema>;
+declare const postToolUseInputSchema: z.ZodObject<{
+    session_id: z.ZodString;
+    transcript_path: z.ZodString;
+    cwd: z.ZodString;
+    permission_mode: z.ZodString;
+    hook_event_name: z.ZodLiteral<"PostToolUse">;
+    tool_name: z.ZodString;
+    tool_input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    tool_response: z.ZodOptional<z.ZodUnknown>;
+    tool_use_id: z.ZodString;
+}, z.core.$strip>;
+type PostToolUseInput = z.infer<typeof postToolUseInputSchema>;
+declare const postToolUseFailureInputSchema: z.ZodObject<{
+    session_id: z.ZodString;
+    transcript_path: z.ZodString;
+    cwd: z.ZodString;
+    permission_mode: z.ZodString;
+    hook_event_name: z.ZodLiteral<"PostToolUseFailure">;
+    tool_name: z.ZodString;
+    tool_input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    tool_use_id: z.ZodString;
+    error: z.ZodOptional<z.ZodString>;
+    is_interrupt: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type PostToolUseFailureInput = z.infer<typeof postToolUseFailureInputSchema>;
+declare const permissionRequestInputSchema: z.ZodObject<{
+    session_id: z.ZodString;
+    transcript_path: z.ZodString;
+    cwd: z.ZodString;
+    permission_mode: z.ZodString;
+    hook_event_name: z.ZodLiteral<"PermissionRequest">;
+    tool_name: z.ZodString;
+    tool_input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    permission_suggestions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+}, z.core.$strip>;
+type PermissionRequestInput = z.infer<typeof permissionRequestInputSchema>;
+declare const stopInputSchema: z.ZodObject<{
+    session_id: z.ZodString;
+    transcript_path: z.ZodString;
+    cwd: z.ZodString;
+    permission_mode: z.ZodString;
+    hook_event_name: z.ZodLiteral<"Stop">;
+    stop_hook_active: z.ZodBoolean;
+    last_assistant_message: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type StopInput = z.infer<typeof stopInputSchema>;
+
+/**
+ * Read all data from a readable stream into a string buffer.
+ * Used for testability -- readStdin() delegates to this with process.stdin.
+ */
+declare function readFromStream(stream: NodeJS.ReadableStream): Promise<string>;
+/**
+ * Read all stdin data into a string buffer.
+ * Claude Code pipes JSON to hook stdin; this collects all chunks before parsing.
+ */
+declare function readStdin(): Promise<string>;
+/**
+ * Produce a concise summary of tool_input, capped at 200 characters.
+ * Prevents Write/Edit tool inputs (with full file content) from bloating logs.
+ */
+declare function summarizeToolInput(toolName: string, toolInput: Record<string, unknown>): string;
+
+declare const paths: {
+    readonly base: string;
+    readonly logs: {
+        readonly prompts: string;
+        readonly tools: string;
+        readonly permissions: string;
+        readonly sessions: string;
+    };
+    readonly analysis: string;
+    readonly analysisPreProcessed: string;
+    readonly summary: string;
+    readonly environmentSnapshot: string;
+    readonly analysisResult: string;
+    readonly pending: string;
+    readonly config: string;
+    readonly counter: string;
+    readonly recommendations: string;
+    readonly recommendationState: string;
+    readonly recommendationArchive: string;
+    readonly notificationFlag: string;
+    readonly autoApplyLog: string;
+    readonly outcomeHistory: string;
+};
+declare function ensureInit(): Promise<void>;
+
+declare function loadConfig(): Promise<Config>;
+
+interface ScrubPattern {
+    name: string;
+    regex: RegExp;
+    replacement: string;
+}
+declare const SCRUB_PATTERNS: ScrubPattern[];
+
+/**
+ * Scrub secrets from a string using built-in patterns
+ * plus optional extra patterns (e.g., user-defined custom patterns).
+ */
+declare function scrubString(input: string, extraPatterns?: ScrubPattern[]): string;
+/**
+ * Recursively scrub all string values in an object/array structure.
+ * Non-string primitives (numbers, booleans, null, undefined) pass through unchanged.
+ */
+declare function scrubObject<T>(obj: T, extraPatterns?: ScrubPattern[]): T;
+
+declare const SCHEMA_MAP: {
+    readonly prompts: z.ZodObject<{
+        timestamp: z.ZodISODateTime;
+        session_id: z.ZodString;
+        cwd: z.ZodString;
+        prompt: z.ZodString;
+        prompt_length: z.ZodNumber;
+        transcript_path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly tools: z.ZodObject<{
+        timestamp: z.ZodISODateTime;
+        session_id: z.ZodString;
+        event: z.ZodEnum<{
+            pre: "pre";
+            post: "post";
+            failure: "failure";
+        }>;
+        tool_name: z.ZodString;
+        input_summary: z.ZodOptional<z.ZodString>;
+        duration_ms: z.ZodOptional<z.ZodNumber>;
+        success: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    readonly permissions: z.ZodObject<{
+        timestamp: z.ZodISODateTime;
+        session_id: z.ZodString;
+        tool_name: z.ZodString;
+        decision: z.ZodEnum<{
+            unknown: "unknown";
+            approved: "approved";
+            denied: "denied";
+        }>;
+    }, z.core.$strip>;
+    readonly sessions: z.ZodObject<{
+        timestamp: z.ZodISODateTime;
+        session_id: z.ZodString;
+        event: z.ZodEnum<{
+            start: "start";
+            end: "end";
+        }>;
+        cwd: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+};
+type LogType = keyof typeof SCHEMA_MAP;
+/**
+ * Validate, scrub, and append a log entry as a JSONL line.
+ *
+ * Uses native fs.appendFile (NOT write-file-atomic) because:
+ * - JSONL is append-only, not replace
+ * - appendFile is atomic for writes <4KB on POSIX
+ * - write-file-atomic replaces entire file (anti-pattern for appends)
+ */
+declare function appendLogEntry(type: LogType, rawEntry: unknown): Promise<void>;
+
+/**
+ * Read the current counter state from disk.
+ * Returns defaults (total=0, session={}) if no counter file exists.
+ */
+declare function readCounter(): Promise<Counter>;
+/**
+ * Atomically increment the interaction counter with cross-process safety.
+ *
+ * Uses proper-lockfile (mkdir-based, macOS-safe) for cross-process locking
+ * and write-file-atomic for crash-safe writes inside the lock.
+ *
+ * Pattern: ensure-file -> lock -> read -> increment -> atomic-write -> unlock
+ */
+declare function incrementCounter(sessionId: string): Promise<number>;
+/**
+ * Reset the counter to zero. Used for testing and post-analysis reset.
+ */
+declare function resetCounter(): Promise<void>;
+
+declare const summarySchema: z.ZodObject<{
+    generated_at: z.ZodISODateTime;
+    period: z.ZodObject<{
+        since: z.ZodString;
+        until: z.ZodString;
+        days: z.ZodNumber;
+    }, z.core.$strip>;
+    stats: z.ZodObject<{
+        total_prompts: z.ZodNumber;
+        total_tool_uses: z.ZodNumber;
+        total_permissions: z.ZodNumber;
+        unique_sessions: z.ZodNumber;
+    }, z.core.$strip>;
+    top_repeated_prompts: z.ZodArray<z.ZodObject<{
+        prompt: z.ZodString;
+        count: z.ZodNumber;
+        sessions: z.ZodNumber;
+    }, z.core.$strip>>;
+    tool_frequency: z.ZodArray<z.ZodObject<{
+        tool_name: z.ZodString;
+        count: z.ZodNumber;
+        avg_duration_ms: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    permission_patterns: z.ZodArray<z.ZodObject<{
+        tool_name: z.ZodString;
+        count: z.ZodNumber;
+        sessions: z.ZodNumber;
+    }, z.core.$strip>>;
+    long_prompts: z.ZodArray<z.ZodObject<{
+        prompt_preview: z.ZodString;
+        length: z.ZodNumber;
+        count: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type Summary = z.infer<typeof summarySchema>;
+declare const environmentSnapshotSchema: z.ZodObject<{
+    generated_at: z.ZodISODateTime;
+    claude_code: z.ZodObject<{
+        version: z.ZodString;
+        version_known: z.ZodBoolean;
+        compatible: z.ZodBoolean;
+    }, z.core.$strip>;
+    settings: z.ZodObject<{
+        user: z.ZodNullable<z.ZodUnknown>;
+        project: z.ZodNullable<z.ZodUnknown>;
+        local: z.ZodNullable<z.ZodUnknown>;
+    }, z.core.$strip>;
+    installed_tools: z.ZodObject<{
+        plugins: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            marketplace: z.ZodString;
+            enabled: z.ZodBoolean;
+            scope: z.ZodString;
+            capabilities: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        skills: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            scope: z.ZodEnum<{
+                user: "user";
+                project: "project";
+            }>;
+        }, z.core.$strip>>;
+        rules: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            scope: z.ZodEnum<{
+                user: "user";
+                project: "project";
+            }>;
+        }, z.core.$strip>>;
+        hooks: z.ZodArray<z.ZodObject<{
+            event: z.ZodString;
+            scope: z.ZodEnum<{
+                user: "user";
+                project: "project";
+                local: "local";
+            }>;
+            type: z.ZodString;
+        }, z.core.$strip>>;
+        claude_md: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            exists: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    detected_ecosystems: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type EnvironmentSnapshot = z.infer<typeof environmentSnapshotSchema>;
+
+/**
+ * Read and parse all JSONL entries from a log directory, optionally
+ * filtered by date range. Files are read in chronological order
+ * (sorted by YYYY-MM-DD filename).
+ *
+ * @param logDir  - Directory containing YYYY-MM-DD.jsonl files
+ * @param schema  - Zod schema for parsing and type inference
+ * @param options - Optional date range filter (inclusive boundaries)
+ * @returns Array of validated, typed entries
+ */
+declare function readLogEntries<T>(logDir: string, schema: z.ZodType<T>, options?: {
+    since?: Date;
+    until?: Date;
+}): Promise<T[]>;
+
+/**
+ * Pre-process accumulated JSONL logs and produce a compact summary.
+ *
+ * Reads prompt, tool, and permission logs within the specified date range,
+ * computes frequency counts with cross-session aggregation, and writes
+ * the result atomically to paths.summary.
+ *
+ * @param options.since - Start of date range (defaults to 30 days ago)
+ * @param options.until - End of date range (defaults to now)
+ * @param options.topN  - Max entries in top_repeated_prompts (defaults to 20)
+ * @returns The validated Summary object
+ */
+declare function preProcess(options?: {
+    since?: Date;
+    until?: Date;
+    topN?: number;
+}): Promise<Summary>;
+
+/**
+ * Scan the user's environment to discover installed Claude Code tools,
+ * settings, version info, and ecosystem presence. Writes the snapshot
+ * atomically to paths.environmentSnapshot.
+ *
+ * @param cwd  - Current working directory (project root)
+ * @param home - User home directory (defaults to process.env.HOME)
+ * @returns Validated EnvironmentSnapshot
+ */
+declare function scanEnvironment(cwd: string, home?: string): Promise<EnvironmentSnapshot>;
+
+declare const routingTargetSchema: z.ZodEnum<{
+    HOOK: "HOOK";
+    SKILL: "SKILL";
+    RULE: "RULE";
+    CLAUDE_MD: "CLAUDE_MD";
+    MEMORY: "MEMORY";
+    SETTINGS: "SETTINGS";
+}>;
+type RoutingTarget = z.infer<typeof routingTargetSchema>;
+declare const confidenceSchema: z.ZodEnum<{
+    HIGH: "HIGH";
+    MEDIUM: "MEDIUM";
+    LOW: "LOW";
+}>;
+type Confidence = z.infer<typeof confidenceSchema>;
+declare const recommendationSchema: z.ZodObject<{
+    id: z.ZodString;
+    target: z.ZodEnum<{
+        HOOK: "HOOK";
+        SKILL: "SKILL";
+        RULE: "RULE";
+        CLAUDE_MD: "CLAUDE_MD";
+        MEMORY: "MEMORY";
+        SETTINGS: "SETTINGS";
+    }>;
+    confidence: z.ZodEnum<{
+        HIGH: "HIGH";
+        MEDIUM: "MEDIUM";
+        LOW: "LOW";
+    }>;
+    pattern_type: z.ZodEnum<{
+        repeated_prompt: "repeated_prompt";
+        long_prompt: "long_prompt";
+        "permission-always-approved": "permission-always-approved";
+        code_correction: "code_correction";
+        personal_info: "personal_info";
+        config_drift: "config_drift";
+        version_update: "version_update";
+        ecosystem_gsd: "ecosystem_gsd";
+        ecosystem_cog: "ecosystem_cog";
+        onboarding_start_hooks: "onboarding_start_hooks";
+        onboarding_start_rules: "onboarding_start_rules";
+        onboarding_start_claudemd: "onboarding_start_claudemd";
+        onboarding_optimize: "onboarding_optimize";
+        scan_redundancy: "scan_redundancy";
+        scan_missing_mechanization: "scan_missing_mechanization";
+        scan_stale_reference: "scan_stale_reference";
+    }>;
+    title: z.ZodString;
+    description: z.ZodString;
+    evidence: z.ZodObject<{
+        count: z.ZodNumber;
+        sessions: z.ZodOptional<z.ZodNumber>;
+        examples: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    suggested_action: z.ZodString;
+    ecosystem_context: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type Recommendation = z.infer<typeof recommendationSchema>;
+declare const analysisConfigSchema: z.ZodDefault<z.ZodObject<{
+    thresholds: z.ZodDefault<z.ZodObject<{
+        repeated_prompt_min_count: z.ZodDefault<z.ZodNumber>;
+        repeated_prompt_high_count: z.ZodDefault<z.ZodNumber>;
+        repeated_prompt_high_sessions: z.ZodDefault<z.ZodNumber>;
+        repeated_prompt_medium_sessions: z.ZodDefault<z.ZodNumber>;
+        long_prompt_min_words: z.ZodDefault<z.ZodNumber>;
+        long_prompt_min_count: z.ZodDefault<z.ZodNumber>;
+        long_prompt_high_words: z.ZodDefault<z.ZodNumber>;
+        long_prompt_high_count: z.ZodDefault<z.ZodNumber>;
+        permission_approval_min_count: z.ZodDefault<z.ZodNumber>;
+        permission_approval_min_sessions: z.ZodDefault<z.ZodNumber>;
+        permission_approval_high_count: z.ZodDefault<z.ZodNumber>;
+        permission_approval_high_sessions: z.ZodDefault<z.ZodNumber>;
+        code_correction_min_failure_rate: z.ZodDefault<z.ZodNumber>;
+        code_correction_min_failures: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    max_recommendations: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>>;
+type AnalysisConfig = z.infer<typeof analysisConfigSchema>;
+declare const analysisResultSchema: z.ZodObject<{
+    generated_at: z.ZodISODateTime;
+    summary_period: z.ZodObject<{
+        since: z.ZodString;
+        until: z.ZodString;
+        days: z.ZodNumber;
+    }, z.core.$strip>;
+    recommendations: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        target: z.ZodEnum<{
+            HOOK: "HOOK";
+            SKILL: "SKILL";
+            RULE: "RULE";
+            CLAUDE_MD: "CLAUDE_MD";
+            MEMORY: "MEMORY";
+            SETTINGS: "SETTINGS";
+        }>;
+        confidence: z.ZodEnum<{
+            HIGH: "HIGH";
+            MEDIUM: "MEDIUM";
+            LOW: "LOW";
+        }>;
+        pattern_type: z.ZodEnum<{
+            repeated_prompt: "repeated_prompt";
+            long_prompt: "long_prompt";
+            "permission-always-approved": "permission-always-approved";
+            code_correction: "code_correction";
+            personal_info: "personal_info";
+            config_drift: "config_drift";
+            version_update: "version_update";
+            ecosystem_gsd: "ecosystem_gsd";
+            ecosystem_cog: "ecosystem_cog";
+            onboarding_start_hooks: "onboarding_start_hooks";
+            onboarding_start_rules: "onboarding_start_rules";
+            onboarding_start_claudemd: "onboarding_start_claudemd";
+            onboarding_optimize: "onboarding_optimize";
+            scan_redundancy: "scan_redundancy";
+            scan_missing_mechanization: "scan_missing_mechanization";
+            scan_stale_reference: "scan_stale_reference";
+        }>;
+        title: z.ZodString;
+        description: z.ZodString;
+        evidence: z.ZodObject<{
+            count: z.ZodNumber;
+            sessions: z.ZodOptional<z.ZodNumber>;
+            examples: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+        suggested_action: z.ZodString;
+        ecosystem_context: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    metadata: z.ZodObject<{
+        classifier_count: z.ZodNumber;
+        patterns_evaluated: z.ZodNumber;
+        environment_ecosystems: z.ZodArray<z.ZodString>;
+        claude_code_version: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type AnalysisResult = z.infer<typeof analysisResultSchema>;
+
+declare const experienceTierSchema: z.ZodEnum<{
+    newcomer: "newcomer";
+    intermediate: "intermediate";
+    power_user: "power_user";
+}>;
+type ExperienceTier = z.infer<typeof experienceTierSchema>;
+declare const experienceLevelSchema: z.ZodObject<{
+    tier: z.ZodEnum<{
+        newcomer: "newcomer";
+        intermediate: "intermediate";
+        power_user: "power_user";
+    }>;
+    score: z.ZodNumber;
+    breakdown: z.ZodObject<{
+        hooks: z.ZodNumber;
+        rules: z.ZodNumber;
+        skills: z.ZodNumber;
+        plugins: z.ZodNumber;
+        claude_md: z.ZodNumber;
+        ecosystems: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type ExperienceLevel = z.infer<typeof experienceLevelSchema>;
+declare const outcomeEntrySchema: z.ZodObject<{
+    recommendation_id: z.ZodString;
+    pattern_type: z.ZodString;
+    target: z.ZodString;
+    applied_at: z.ZodISODateTime;
+    checked_at: z.ZodISODateTime;
+    persisted: z.ZodBoolean;
+    checks_since_applied: z.ZodNumber;
+    outcome: z.ZodEnum<{
+        positive: "positive";
+        negative: "negative";
+        monitoring: "monitoring";
+    }>;
+}, z.core.$strip>;
+type OutcomeEntry = z.infer<typeof outcomeEntrySchema>;
+declare const outcomeSummarySchema: z.ZodObject<{
+    pattern_type: z.ZodString;
+    total_applied: z.ZodNumber;
+    total_persisted: z.ZodNumber;
+    total_reverted: z.ZodNumber;
+    persistence_rate: z.ZodNumber;
+}, z.core.$strip>;
+type OutcomeSummary = z.infer<typeof outcomeSummarySchema>;
+
+/**
+ * Adjust recommendation confidence based on historical outcome data.
+ * Pattern types with >30% revert rate (persistence_rate < 0.7) get
+ * downgraded by one tier: HIGH->MEDIUM, MEDIUM->LOW, LOW stays LOW.
+ */
+declare function adjustConfidence(recommendations: Recommendation[], summaries: OutcomeSummary[]): Recommendation[];
+/**
+ * Analyze a pre-processed summary and environment snapshot to produce
+ * structured recommendations.
+ *
+ * @param summary - Pre-processed usage summary from pre-processor
+ * @param snapshot - Environment snapshot from environment-scanner
+ * @param config - Optional analysis configuration (defaults applied if omitted)
+ * @param outcomeSummaries - Optional outcome summaries for confidence adjustment
+ * @returns Validated AnalysisResult with sorted, capped recommendations
+ */
+declare function analyze(summary: Summary, snapshot: EnvironmentSnapshot, config?: AnalysisConfig, outcomeSummaries?: OutcomeSummary[]): AnalysisResult;
+
+type Classifier = (summary: Summary, snapshot: EnvironmentSnapshot, config: AnalysisConfig) => Recommendation[];
+
+/**
+ * Write an AnalysisResult to the analysis-result.json path atomically.
+ */
+declare function writeAnalysisResult(result: AnalysisResult): Promise<void>;
+/**
+ * Run the full analysis pipeline: preProcess -> scanEnvironment -> analyze -> write.
+ *
+ * @param cwd - Current working directory for environment scanning
+ * @returns The generated AnalysisResult
+ */
+declare function runAnalysis(cwd: string): Promise<AnalysisResult>;
+/**
+ * Check if analysis should be triggered and run it if conditions are met.
+ *
+ * Conditions:
+ * 1. analysis.enabled is true in config
+ * 2. counter.total >= config.analysis.threshold
+ * 3. Not within cooldown period since last_analysis
+ *
+ * On success: resets counter and records last_analysis timestamp.
+ * On failure: preserves counter data for retry at next check.
+ *
+ * @param cwd - Current working directory
+ * @returns true if analysis was triggered, false otherwise
+ */
+declare function checkAndTriggerAnalysis(cwd: string): Promise<boolean>;
+
+declare const recommendationStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    applied: "applied";
+    dismissed: "dismissed";
+}>;
+type RecommendationStatus = z.infer<typeof recommendationStatusSchema>;
+declare const recommendationStateEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        pending: "pending";
+        applied: "applied";
+        dismissed: "dismissed";
+    }>;
+    updated_at: z.ZodISODateTime;
+    applied_details: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type RecommendationStateEntry = z.infer<typeof recommendationStateEntrySchema>;
+declare const recommendationStateSchema: z.ZodObject<{
+    entries: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            pending: "pending";
+            applied: "applied";
+            dismissed: "dismissed";
+        }>;
+        updated_at: z.ZodISODateTime;
+        applied_details: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    last_updated: z.ZodISODateTime;
+}, z.core.$strip>;
+type RecommendationState = z.infer<typeof recommendationStateSchema>;
+declare const autoApplyLogEntrySchema: z.ZodObject<{
+    timestamp: z.ZodISODateTime;
+    recommendation_id: z.ZodString;
+    target: z.ZodString;
+    action: z.ZodString;
+    success: z.ZodBoolean;
+    details: z.ZodOptional<z.ZodString>;
+    backup_path: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type AutoApplyLogEntry = z.infer<typeof autoApplyLogEntrySchema>;
+
+/**
+ * Render an AnalysisResult to a markdown string grouped by confidence tier.
+ * Status prefixes (PENDING/APPLIED/DISMISSED) are looked up from the states map.
+ */
+declare function renderRecommendations(result: AnalysisResult, states: Map<string, RecommendationStatus>): string;
+
+/**
+ * Load the recommendation state from disk.
+ * Returns an empty state when the file does not exist.
+ */
+declare function loadState(): Promise<RecommendationState>;
+/**
+ * Save the recommendation state atomically to disk.
+ */
+declare function saveState(state: RecommendationState): Promise<void>;
+/**
+ * Update the status of a recommendation by ID.
+ * Creates a new entry if the ID is not found.
+ */
+declare function updateStatus(id: string, status: RecommendationStatus, details?: string): Promise<void>;
+/**
+ * Get a Map of recommendation ID to status for quick lookups.
+ */
+declare function getStatusMap(): Promise<Map<string, RecommendationStatus>>;
+
+interface RotatorConfig {
+    maxRecommendationsInFile: number;
+    archiveAfterDays: number;
+}
+/**
+ * Rotate old applied/dismissed recommendations to archive files.
+ * Pending entries are never archived regardless of age.
+ */
+declare function rotateRecommendations(config: RotatorConfig): Promise<void>;
+
+/**
+ * Build a one-line notification string referencing /evolve:apply.
+ * Output is always under 200 characters (well under 200 tokens).
+ */
+declare function buildNotification(pendingCount: number): string;
+/**
+ * Write the notification flag file with the pending recommendation count.
+ * The UserPromptSubmit hook reads this flag to decide whether to inject a notification.
+ */
+declare function writeNotificationFlag(pendingCount: number): Promise<void>;
+/**
+ * Check whether a notification flag file exists.
+ */
+declare function hasNotificationFlag(): Promise<boolean>;
+/**
+ * Remove the notification flag file.
+ * Does not throw when the flag file does not exist.
+ */
+declare function clearNotificationFlag(): Promise<void>;
+/**
+ * Read the pending count from the notification flag file.
+ * Returns 0 if the file cannot be read or parsed.
+ */
+declare function readNotificationFlagCount(): Promise<number>;
+
+interface ApplierOptions {
+    /** Override settings.json path (used in testing) */
+    settingsPath?: string;
+    /** Override rules directory (used in testing) */
+    rulesDir?: string;
+    /** Override hooks directory (used in testing) */
+    hooksDir?: string;
+    /** Override CLAUDE.md path (used in testing) */
+    claudeMdPath?: string;
+}
+interface Applier {
+    readonly target: string;
+    canApply(rec: Recommendation): boolean;
+    apply(rec: Recommendation, options?: ApplierOptions): Promise<AutoApplyResult>;
+}
+
+interface AutoApplyResult {
+    recommendation_id: string;
+    success: boolean;
+    details: string;
+}
+interface AutoApplyOptions extends ApplierOptions {
+}
+/**
+ * Auto-apply HIGH-confidence recommendations when fullAuto is enabled.
+ * Returns an empty array when fullAuto is false (default, per QUA-01).
+ *
+ * Dispatches to the appropriate Applier based on rec.target via the
+ * applier registry. Only processes recommendations whose target has a
+ * registered applier and whose applier.canApply() returns true.
+ */
+declare function autoApplyRecommendations(recommendations: Recommendation[], options?: AutoApplyOptions): Promise<AutoApplyResult[]>;
+
+declare function computeExperienceLevel(snapshot: EnvironmentSnapshot): ExperienceLevel;
+
+/**
+ * Classify onboarding needs based on user experience tier.
+ *
+ * Newcomer (score=0): Up to 3 MEDIUM-confidence "start here" recommendations
+ * for missing hooks, rules, and CLAUDE.md.
+ *
+ * Power user (score>=30): 1 LOW-confidence "optimize" recommendation
+ * suggesting consolidation review.
+ *
+ * Intermediate (1-29): No recommendations (existing classifiers handle
+ * pattern-specific suggestions).
+ */
+declare function classifyOnboarding(_summary: Summary, snapshot: EnvironmentSnapshot, _config: AnalysisConfig): Recommendation[];
+
+/**
+ * Track outcomes for all applied recommendations by checking their
+ * persistence in the current environment snapshot.
+ *
+ * For each applied recommendation:
+ * 1. Check if the change still exists in the environment
+ * 2. Determine outcome: positive (persisted 5+ checks), negative (reverted),
+ *    or monitoring (persisted but < 5 checks)
+ * 3. Append outcome entry to JSONL history
+ *
+ * @param snapshot - Current environment snapshot
+ * @returns Array of outcome entries for all applied recommendations
+ */
+declare function trackOutcomes(snapshot: EnvironmentSnapshot): Promise<OutcomeEntry[]>;
+/**
+ * Load outcome history from the JSONL file.
+ * Returns empty array when the file does not exist.
+ * Silently skips invalid or malformed lines.
+ */
+declare function loadOutcomeHistory(): Promise<OutcomeEntry[]>;
+/**
+ * Compute outcome summaries grouped by pattern_type.
+ * For each group: counts unique recommendation_ids, tallies positive
+ * (persisted) and negative (reverted) outcomes, and computes
+ * persistence_rate = persisted / total_applied.
+ *
+ * Uses the latest outcome per recommendation_id for determination.
+ */
+declare function computeOutcomeSummaries(history: OutcomeEntry[]): OutcomeSummary[];
+
+declare const scanContextSchema: z.ZodObject<{
+    generated_at: z.ZodISODateTime;
+    project_root: z.ZodString;
+    claude_md_files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        scope: z.ZodEnum<{
+            user: "user";
+            project: "project";
+            local: "local";
+        }>;
+        content: z.ZodString;
+        line_count: z.ZodNumber;
+        headings: z.ZodArray<z.ZodString>;
+        references: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    rules: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        filename: z.ZodString;
+        content: z.ZodString;
+        frontmatter: z.ZodOptional<z.ZodObject<{
+            paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        headings: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    settings: z.ZodObject<{
+        user: z.ZodNullable<z.ZodUnknown>;
+        project: z.ZodNullable<z.ZodUnknown>;
+        local: z.ZodNullable<z.ZodUnknown>;
+    }, z.core.$strip>;
+    commands: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        name: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strip>>;
+    hooks_registered: z.ZodArray<z.ZodObject<{
+        event: z.ZodString;
+        scope: z.ZodEnum<{
+            user: "user";
+            project: "project";
+            local: "local";
+        }>;
+        type: z.ZodString;
+        command: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type ScanContext = z.infer<typeof scanContextSchema>;
+
+type Scanner = (context: ScanContext) => Recommendation[] | Promise<Recommendation[]>;
+
+interface ScanResult {
+    generated_at: string;
+    scan_context: ScanContext;
+    recommendations: Recommendation[];
+}
+/**
+ * Run a deep scan of Claude Code configuration at the given directory.
+ * Reads all config files into a ScanContext, then runs all registered
+ * scanners to detect quality issues. Returns merged recommendations.
+ *
+ * Errors in individual scanners are caught and logged, not propagated.
+ * An empty recommendations array means no issues detected.
+ */
+declare function runDeepScan(cwd: string, home?: string): Promise<ScanResult>;
+
+/**
+ * Build a complete ScanContext by reading all configuration sources.
+ * Returns a validated ScanContext or throws if validation fails.
+ *
+ * @param cwd  - Project root directory
+ * @param home - User home directory (defaults to process.env.HOME)
+ */
+declare function buildScanContext(cwd: string, home?: string): Promise<ScanContext>;
+
+/**
+ * Scan for redundant configuration: duplicate headings across CLAUDE.md
+ * and rules, and duplicate rule files with matching heading sets.
+ */
+declare function scanRedundancy(context: ScanContext): Recommendation[];
+
+/**
+ * Scan for operations described in text that should be enforced via hooks.
+ * Skips patterns that are already covered by a registered hook for the
+ * corresponding event type.
+ */
+declare function scanMechanization(context: ScanContext): Recommendation[];
+
+/**
+ * Scan for stale references: broken @references in CLAUDE.md files and
+ * hook commands pointing to non-existent scripts.
+ *
+ * This scanner is async because it needs to check the filesystem for
+ * reference targets not present in the ScanContext.
+ */
+declare function scanStaleness(context: ScanContext): Promise<Recommendation[]>;
+
+declare const GENERATOR_VERSION = "1.0.0";
+declare const generatedArtifactSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        skill: "skill";
+        hook: "hook";
+        claude_md_patch: "claude_md_patch";
+    }>;
+    filename: z.ZodString;
+    content: z.ZodString;
+    source_recommendation_id: z.ZodString;
+    metadata: z.ZodObject<{
+        generated_at: z.ZodISODateTime;
+        generator_version: z.ZodString;
+        pattern_type: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type GeneratedArtifact = z.infer<typeof generatedArtifactSchema>;
+interface GeneratorOptions {
+    projectRoot?: string;
+}
+
+/**
+ * Generate a skill file draft from a long_prompt SKILL recommendation.
+ *
+ * @param rec - A Recommendation object (typically from the long-prompts classifier)
+ * @returns GeneratedArtifact with type 'skill', or null if the recommendation
+ *          is not applicable (wrong target or pattern_type)
+ */
+declare function generateSkill(rec: Recommendation): GeneratedArtifact | null;
+
+/**
+ * Generate a bash hook script draft from a HOOK-targeted recommendation.
+ *
+ * @param rec - A Recommendation object (from mechanization scanner or repeated-prompts classifier)
+ * @returns GeneratedArtifact with type 'hook', or null if the recommendation
+ *          is not applicable (wrong target)
+ */
+declare function generateHook(rec: Recommendation): GeneratedArtifact | null;
+
+/**
+ * Generate a CLAUDE.md patch from a CLAUDE_MD-targeted recommendation.
+ *
+ * @param rec - A Recommendation object (from deep scan or analysis classifiers)
+ * @returns GeneratedArtifact with type 'claude_md_patch', or null if the
+ *          recommendation is not applicable (wrong target)
+ */
+declare function generateClaudeMdPatch(rec: Recommendation): GeneratedArtifact | null;
+
+declare class HookApplier implements Applier {
+    readonly target = "HOOK";
+    canApply(rec: Recommendation): boolean;
+    apply(rec: Recommendation, options?: ApplierOptions): Promise<AutoApplyResult>;
+}
+
+declare class ClaudeMdApplier implements Applier {
+    readonly target = "CLAUDE_MD";
+    canApply(rec: Recommendation): boolean;
+    apply(rec: Recommendation, options?: ApplierOptions): Promise<AutoApplyResult>;
+}
+
+/**
+ * Register the 'scan' subcommand on a Commander.js program.
+ *
+ * Runs a full deep configuration scan (CLAUDE.md, rules, settings, hooks)
+ * and outputs the results as structured JSON to stdout. The output omits
+ * scan_context to keep it concise for slash command consumers.
+ */
+declare function registerScanCommand(program: Command): void;
+
+/**
+ * Register the 'pending' subcommand on a Commander.js program.
+ *
+ * Reads the analysis result and recommendation state, filters to
+ * recommendations that are not yet applied or dismissed, and outputs
+ * the pending list as structured JSON.
+ */
+declare function registerPendingCommand(program: Command): void;
+/**
+ * Register the 'apply-one' subcommand on a Commander.js program.
+ *
+ * Loads the recommendation by ID from analysis result, finds the correct
+ * applier from the registry, applies the recommendation, logs the attempt,
+ * and updates the recommendation status on success.
+ */
+declare function registerApplyOneCommand(program: Command): void;
+/**
+ * Register the 'dismiss' subcommand on a Commander.js program.
+ *
+ * Permanently dismisses a recommendation by updating its status to 'dismissed'.
+ * Outputs JSON confirmation with the recommendation ID and status.
+ */
+declare function registerDismissCommand(program: Command): void;
+
+export { type AnalysisConfig, type AnalysisResult, type AutoApplyLogEntry, type Classifier, ClaudeMdApplier, type Confidence, type Config, type Counter, type EnvironmentSnapshot, type ExperienceLevel, type ExperienceTier, GENERATOR_VERSION, type GeneratedArtifact, type GeneratorOptions, HookApplier, type HookCommon, type LogType, type OutcomeEntry, type OutcomeSummary, type PermissionEntry, type PermissionRequestInput, type PostToolUseFailureInput, type PostToolUseInput, type PreToolUseInput, type PromptEntry, type Recommendation, type RecommendationState, type RecommendationStateEntry, type RecommendationStatus, type RoutingTarget, SCRUB_PATTERNS, type ScanContext, type ScanResult, type Scanner, type ScrubPattern, type SessionEntry, type StopInput, type Summary, type ToolEntry, type UserPromptSubmitInput, adjustConfidence, analysisConfigSchema, analysisResultSchema, analyze, appendLogEntry, autoApplyLogEntrySchema, autoApplyRecommendations, buildNotification, buildScanContext, checkAndTriggerAnalysis, classifyOnboarding, clearNotificationFlag, computeExperienceLevel, computeOutcomeSummaries, confidenceSchema, configSchema, counterSchema, ensureInit, environmentSnapshotSchema, experienceLevelSchema, experienceTierSchema, generateClaudeMdPatch, generateHook, generateSkill, generatedArtifactSchema, getStatusMap, hasNotificationFlag, hookCommonSchema, incrementCounter, loadConfig, loadOutcomeHistory, loadState, outcomeEntrySchema, outcomeSummarySchema, paths, permissionEntrySchema, permissionRequestInputSchema, postToolUseFailureInputSchema, postToolUseInputSchema, preProcess, preToolUseInputSchema, promptEntrySchema, readCounter, readFromStream, readLogEntries, readNotificationFlagCount, readStdin, recommendationSchema, recommendationStateEntrySchema, recommendationStateSchema, recommendationStatusSchema, registerApplyOneCommand, registerDismissCommand, registerPendingCommand, registerScanCommand, renderRecommendations, resetCounter, rotateRecommendations, routingTargetSchema, runAnalysis, runDeepScan, saveState, scanContextSchema, scanEnvironment, scanMechanization, scanRedundancy, scanStaleness, scrubObject, scrubString, sessionEntrySchema, stopInputSchema, summarizeToolInput, summarySchema, toolEntrySchema, trackOutcomes, updateStatus, userPromptSubmitInputSchema, writeAnalysisResult, writeNotificationFlag };