harness-evolve 1.0.0

package/dist/cli.js

@@ -0,0 +1,1685 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "@commander-js/extra-typings";
+import { readFileSync } from "fs";
+import { join as join10 } from "path";
+
+// src/cli/init.ts
+import { copyFile, mkdir, access as access2, writeFile } from "fs/promises";
+import { dirname as dirname3, join as join3 } from "path";
+
+// src/cli/utils.ts
+import { readFile } from "fs/promises";
+import { join } from "path";
+import { createInterface } from "readline/promises";
+import writeFileAtomic from "write-file-atomic";
+var HARNESS_EVOLVE_MARKER = "harness-evolve";
+var SETTINGS_PATH = join(
+  process.env.HOME ?? "",
+  ".claude",
+  "settings.json"
+);
+var HOOK_REGISTRATIONS = [
+  {
+    event: "UserPromptSubmit",
+    hookFile: "user-prompt-submit.js",
+    timeout: 10,
+    async: false,
+    description: "Captures prompts and delivers optimization notifications"
+  },
+  {
+    event: "PreToolUse",
+    hookFile: "pre-tool-use.js",
+    timeout: 10,
+    async: true,
+    description: "Tracks tool usage patterns before execution"
+  },
+  {
+    event: "PostToolUse",
+    hookFile: "post-tool-use.js",
+    timeout: 10,
+    async: true,
+    description: "Records tool outcomes for pattern analysis"
+  },
+  {
+    event: "PostToolUseFailure",
+    hookFile: "post-tool-use-failure.js",
+    timeout: 10,
+    async: true,
+    description: "Logs tool failures to detect correction patterns"
+  },
+  {
+    event: "PermissionRequest",
+    hookFile: "permission-request.js",
+    timeout: 10,
+    async: true,
+    description: "Monitors permission decisions for auto-approval suggestions"
+  },
+  {
+    event: "Stop",
+    hookFile: "stop.js",
+    timeout: 10,
+    async: true,
+    description: "Triggers analysis when interaction threshold is reached"
+  }
+];
+function resolveHookPath(hookFile, baseDirOverride) {
+  const baseDir = baseDirOverride ?? import.meta.dirname;
+  return join(baseDir, "hooks", hookFile);
+}
+async function readSettings(settingsPath) {
+  const filePath = settingsPath ?? SETTINGS_PATH;
+  try {
+    const raw = await readFile(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+async function writeSettings(settings, settingsPath) {
+  const filePath = settingsPath ?? SETTINGS_PATH;
+  await writeFileAtomic(filePath, JSON.stringify(settings, null, 2));
+}
+function mergeHooks(existing, hookCommands) {
+  const hooks = existing.hooks != null ? { ...existing.hooks } : {};
+  for (const hc of hookCommands) {
+    const eventArray = Array.isArray(hooks[hc.event]) ? [...hooks[hc.event]] : [];
+    const alreadyRegistered = eventArray.some((entry) => {
+      const innerHooks = entry.hooks;
+      if (!Array.isArray(innerHooks)) return false;
+      return innerHooks.some(
+        (h) => String(h.command ?? "").includes(HARNESS_EVOLVE_MARKER)
+      );
+    });
+    if (!alreadyRegistered) {
+      const hookEntry = {
+        type: "command",
+        command: hc.command,
+        timeout: hc.timeout
+      };
+      if (hc.async) {
+        hookEntry.async = true;
+      }
+      eventArray.push({
+        matcher: "*",
+        hooks: [hookEntry]
+      });
+    }
+    hooks[hc.event] = eventArray;
+  }
+  return { ...existing, hooks };
+}
+async function confirm(message) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    const answer = await rl.question(`${message} [y/N] `);
+    return /^y(es)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+}
+
+// src/scan/context-builder.ts
+import { readFile as readFile2, readdir } from "fs/promises";
+import { join as join2, basename } from "path";
+
+// src/scan/schemas.ts
+import { z } from "zod/v4";
+var scanContextSchema = z.object({
+  generated_at: z.iso.datetime(),
+  project_root: z.string(),
+  claude_md_files: z.array(
+    z.object({
+      path: z.string(),
+      scope: z.enum(["user", "project", "local"]),
+      content: z.string(),
+      line_count: z.number(),
+      headings: z.array(z.string()),
+      references: z.array(z.string())
+    })
+  ),
+  rules: z.array(
+    z.object({
+      path: z.string(),
+      filename: z.string(),
+      content: z.string(),
+      frontmatter: z.object({
+        paths: z.array(z.string()).optional()
+      }).optional(),
+      headings: z.array(z.string())
+    })
+  ),
+  settings: z.object({
+    user: z.unknown().nullable(),
+    project: z.unknown().nullable(),
+    local: z.unknown().nullable()
+  }),
+  commands: z.array(
+    z.object({
+      path: z.string(),
+      name: z.string(),
+      content: z.string()
+    })
+  ),
+  hooks_registered: z.array(
+    z.object({
+      event: z.string(),
+      scope: z.enum(["user", "project", "local"]),
+      type: z.string(),
+      command: z.string().optional()
+    })
+  )
+});
+
+// src/scan/context-builder.ts
+async function readFileSafe(path) {
+  try {
+    return await readFile2(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function extractHeadings(content) {
+  const headings = [];
+  const regex = /^#{1,6}\s+(.+)$/gm;
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    headings.push(match[1].trim());
+  }
+  return headings;
+}
+function extractReferences(content) {
+  const refs = [];
+  const regex = /@([\w./-]+)/g;
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    const ref = match[1];
+    const idx = match.index;
+    if (idx > 0 && /\w/.test(content[idx - 1])) {
+      continue;
+    }
+    const cleaned = ref.replace(/\.$/, "");
+    refs.push(cleaned);
+  }
+  return refs;
+}
+async function readClaudeMdFiles(cwd, home) {
+  const locations = [
+    { path: join2(cwd, "CLAUDE.md"), scope: "project" },
+    { path: join2(cwd, ".claude", "CLAUDE.md"), scope: "local" },
+    { path: join2(home, ".claude", "CLAUDE.md"), scope: "user" }
+  ];
+  const files = [];
+  for (const loc of locations) {
+    const content = await readFileSafe(loc.path);
+    if (content !== null) {
+      files.push({
+        path: loc.path,
+        scope: loc.scope,
+        content,
+        line_count: content.split("\n").length,
+        headings: extractHeadings(content),
+        references: extractReferences(content)
+      });
+    }
+  }
+  return files;
+}
+async function collectMdFiles(dir) {
+  const results = [];
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join2(dir, entry.name);
+      if (entry.isDirectory()) {
+        const nested = await collectMdFiles(fullPath);
+        results.push(...nested);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        results.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return void 0;
+  const frontmatter = match[1];
+  const pathsMatch = frontmatter.match(
+    /paths:\s*\n((?:\s*-\s*.+\n?)*)/
+  );
+  if (!pathsMatch) return {};
+  const paths2 = pathsMatch[1].split("\n").map((line) => line.replace(/^\s*-\s*/, "").trim()).filter((line) => line.length > 0);
+  return paths2.length > 0 ? { paths: paths2 } : {};
+}
+async function readRuleFiles(cwd) {
+  const rulesDir = join2(cwd, ".claude", "rules");
+  const mdFiles = await collectMdFiles(rulesDir);
+  const rules = [];
+  for (const filePath of mdFiles) {
+    const content = await readFileSafe(filePath);
+    if (content !== null) {
+      rules.push({
+        path: filePath,
+        filename: basename(filePath),
+        content,
+        frontmatter: parseFrontmatter(content),
+        headings: extractHeadings(content)
+      });
+    }
+  }
+  return rules;
+}
+async function readAllSettings(cwd, home) {
+  const settingsPaths = {
+    user: join2(home, ".claude", "settings.json"),
+    project: join2(cwd, ".claude", "settings.json"),
+    local: join2(cwd, ".claude", "settings.local.json")
+  };
+  const readJsonSafe = async (path) => {
+    try {
+      const raw = await readFile2(path, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  };
+  const [user, project, local] = await Promise.all([
+    readJsonSafe(settingsPaths.user),
+    readJsonSafe(settingsPaths.project),
+    readJsonSafe(settingsPaths.local)
+  ]);
+  return { user, project, local };
+}
+async function readCommandFiles(cwd) {
+  const commandsDir = join2(cwd, ".claude", "commands");
+  const commands = [];
+  try {
+    const entries = await readdir(commandsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.endsWith(".md")) {
+        const filePath = join2(commandsDir, entry.name);
+        const content = await readFileSafe(filePath);
+        if (content !== null) {
+          commands.push({
+            path: filePath,
+            name: entry.name.replace(/\.md$/, ""),
+            content
+          });
+        }
+      }
+    }
+  } catch {
+  }
+  return commands;
+}
+function extractHooksFromAllSettings(settings) {
+  const hooks = [];
+  const extractFromScope = (settingsObj, scope) => {
+    if (!settingsObj || typeof settingsObj !== "object") return;
+    const obj = settingsObj;
+    if (!obj.hooks || typeof obj.hooks !== "object") return;
+    const hooksConfig = obj.hooks;
+    for (const [event, defs] of Object.entries(hooksConfig)) {
+      if (!Array.isArray(defs)) continue;
+      for (const def of defs) {
+        if (!def || typeof def !== "object") continue;
+        const hookDef = def;
+        const type = String(hookDef.type ?? "command");
+        const command = typeof hookDef.command === "string" ? hookDef.command : void 0;
+        hooks.push({ event, scope, type, command });
+      }
+    }
+  };
+  extractFromScope(settings.user, "user");
+  extractFromScope(settings.project, "project");
+  extractFromScope(settings.local, "local");
+  return hooks;
+}
+async function buildScanContext(cwd, home) {
+  const homeDir = home ?? process.env.HOME ?? "";
+  const [claudeMdFiles, rules, settings, commands] = await Promise.all([
+    readClaudeMdFiles(cwd, homeDir),
+    readRuleFiles(cwd),
+    readAllSettings(cwd, homeDir),
+    readCommandFiles(cwd)
+  ]);
+  const hooksRegistered = extractHooksFromAllSettings(settings);
+  const ctx = {
+    generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    project_root: cwd,
+    claude_md_files: claudeMdFiles,
+    rules,
+    settings,
+    commands,
+    hooks_registered: hooksRegistered
+  };
+  return scanContextSchema.parse(ctx);
+}
+
+// src/scan/scanners/redundancy.ts
+function normalizeText(text) {
+  return text.toLowerCase().trim().replace(/\s+/g, " ");
+}
+function scanRedundancy(context) {
+  const recommendations = [];
+  let index = 0;
+  const claudeMdHeadings = context.claude_md_files.flatMap(
+    (f) => f.headings.map((h) => ({ heading: normalizeText(h), source: f.path }))
+  );
+  const ruleHeadings = context.rules.flatMap(
+    (r) => r.headings.map((h) => ({ heading: normalizeText(h), source: r.path }))
+  );
+  for (const cmdH of claudeMdHeadings) {
+    const match = ruleHeadings.find((rH) => rH.heading === cmdH.heading);
+    if (match) {
+      recommendations.push({
+        id: `rec-scan-redundancy-${index++}`,
+        target: "RULE",
+        confidence: "MEDIUM",
+        pattern_type: "scan_redundancy",
+        title: `Redundant section: "${cmdH.heading}"`,
+        description: `The heading "${cmdH.heading}" appears in both ${cmdH.source} and ${match.source}. This may indicate duplicated instructions.`,
+        evidence: {
+          count: 2,
+          examples: [cmdH.source, match.source]
+        },
+        suggested_action: "Consolidate into one location. If it belongs in rules, remove from CLAUDE.md. If it belongs in CLAUDE.md, remove the rule file."
+      });
+    }
+  }
+  const rulesByHeadingSet = /* @__PURE__ */ new Map();
+  for (const rule of context.rules) {
+    const key = rule.headings.map((h) => normalizeText(h)).sort().join("||");
+    if (!key) continue;
+    const existing = rulesByHeadingSet.get(key) ?? [];
+    existing.push(rule.path);
+    rulesByHeadingSet.set(key, existing);
+  }
+  for (const [, paths2] of rulesByHeadingSet) {
+    if (paths2.length < 2) continue;
+    recommendations.push({
+      id: `rec-scan-redundancy-${index++}`,
+      target: "RULE",
+      confidence: "MEDIUM",
+      pattern_type: "scan_redundancy",
+      title: `Duplicate rule files detected (${paths2.length} files with same headings)`,
+      description: `${paths2.length} rule files share the same heading structure: ${paths2.join(", ")}. They may contain redundant content.`,
+      evidence: {
+        count: paths2.length,
+        examples: paths2.slice(0, 3)
+      },
+      suggested_action: "Review these rule files and merge them into a single file, or differentiate their content."
+    });
+  }
+  return recommendations;
+}
+
+// src/scan/scanners/mechanization.ts
+var MECHANIZATION_INDICATORS = [
+  { regex: /always\s+run\s+["`']?(\S+)/i, hookEvent: "PreToolUse", label: "always run" },
+  {
+    regex: /before\s+committing?,?\s+run\s+["`']?(\S+)/i,
+    hookEvent: "PreToolUse",
+    label: "pre-commit check"
+  },
+  {
+    regex: /after\s+every\s+(?:edit|change|write)/i,
+    hookEvent: "PostToolUse",
+    label: "post-edit action"
+  },
+  {
+    regex: /must\s+(?:always\s+)?check\s+["`']?(\S+)/i,
+    hookEvent: "PreToolUse",
+    label: "mandatory check"
+  },
+  {
+    regex: /never\s+(?:allow|permit|run)\s+["`']?(\S+)/i,
+    hookEvent: "PreToolUse",
+    label: "forbidden operation"
+  },
+  {
+    regex: /forbidden.*(?:rm\s+-rf|drop\s+|delete\s+|truncate)/i,
+    hookEvent: "PreToolUse",
+    label: "dangerous command guard"
+  }
+];
+function scanMechanization(context) {
+  const recommendations = [];
+  let index = 0;
+  const allTextSources = [
+    ...context.claude_md_files.map((f) => ({ content: f.content, source: f.path })),
+    ...context.rules.map((r) => ({ content: r.content, source: r.path }))
+  ];
+  for (const source of allTextSources) {
+    for (const indicator of MECHANIZATION_INDICATORS) {
+      const match = source.content.match(indicator.regex);
+      if (!match) continue;
+      const alreadyCovered = context.hooks_registered.some(
+        (h) => h.event === indicator.hookEvent
+      );
+      if (alreadyCovered) continue;
+      recommendations.push({
+        id: `rec-scan-mechanize-${index++}`,
+        target: "HOOK",
+        confidence: "MEDIUM",
+        pattern_type: "scan_missing_mechanization",
+        title: `Mechanizable rule: "${match[0].substring(0, 60)}"`,
+        description: `Found a rule in ${source.source} that describes an operation suitable for a ${indicator.hookEvent} hook: "${match[0]}". Hooks provide 100% reliable execution, while rules depend on Claude's probabilistic compliance.`,
+        evidence: {
+          count: 1,
+          examples: [match[0].substring(0, 100)]
+        },
+        suggested_action: `Create a ${indicator.hookEvent} hook to enforce this rule automatically. See Claude Code hooks docs for ${indicator.hookEvent} event.`
+      });
+    }
+  }
+  return recommendations;
+}
+
+// src/scan/scanners/staleness.ts
+import { access } from "fs/promises";
+import { constants } from "fs";
+import { resolve, dirname as dirname2 } from "path";
+async function fileExistsOnDisk(filePath) {
+  try {
+    await access(filePath, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function extractPathFromCommand(command) {
+  const quotedMatch = command.match(/(?:node|sh|bash|python)\s+["']([^"']+)["']/i);
+  if (quotedMatch) return quotedMatch[1];
+  const unquotedMatch = command.match(
+    /(?:node|sh|bash|python)\s+(\S+\.(?:js|ts|sh|py|mjs|cjs))/i
+  );
+  if (unquotedMatch) return unquotedMatch[1];
+  return null;
+}
+async function scanStaleness(context) {
+  const recommendations = [];
+  let index = 0;
+  for (const claudeMd of context.claude_md_files) {
+    for (const ref of claudeMd.references) {
+      const resolved = resolve(dirname2(claudeMd.path), ref);
+      const inContext = context.rules.some((r) => r.path === resolved) || context.claude_md_files.some((f) => f.path === resolved) || context.commands.some((c) => c.path === resolved);
+      if (inContext) continue;
+      const existsOnDisk = await fileExistsOnDisk(resolved);
+      if (existsOnDisk) continue;
+      recommendations.push({
+        id: `rec-scan-stale-${index++}`,
+        target: "CLAUDE_MD",
+        confidence: "HIGH",
+        pattern_type: "scan_stale_reference",
+        title: `Stale reference: @${ref}`,
+        description: `${claudeMd.path} references @${ref}, but this file does not exist.`,
+        evidence: {
+          count: 1,
+          examples: [`@${ref} in ${claudeMd.path}`]
+        },
+        suggested_action: `Remove the @${ref} reference from ${claudeMd.path}, or create the missing file.`
+      });
+    }
+  }
+  for (const hook of context.hooks_registered) {
+    if (!hook.command) continue;
+    const scriptPath = extractPathFromCommand(hook.command);
+    if (!scriptPath) continue;
+    const exists = await fileExistsOnDisk(scriptPath);
+    if (exists) continue;
+    recommendations.push({
+      id: `rec-scan-stale-${index++}`,
+      target: "SETTINGS",
+      confidence: "HIGH",
+      pattern_type: "scan_stale_reference",
+      title: `Stale hook script: ${scriptPath}`,
+      description: `Hook (${hook.event}, ${hook.scope}) references script "${scriptPath}", but this file does not exist. The hook will fail when triggered.`,
+      evidence: {
+        count: 1,
+        examples: [`${hook.event} hook command: ${hook.command}`]
+      },
+      suggested_action: `Create the missing script at "${scriptPath}", or update the hook command in settings.json.`
+    });
+  }
+  return recommendations;
+}
+
+// src/scan/scanners/index.ts
+var scanners = [scanRedundancy, scanMechanization, scanStaleness];
+
+// src/scan/index.ts
+async function runDeepScan(cwd, home) {
+  const scanContext = await buildScanContext(cwd, home);
+  const recommendations = [];
+  for (const scanner of scanners) {
+    try {
+      const result = await scanner(scanContext);
+      recommendations.push(...result);
+    } catch (err) {
+      console.error(
+        `Scanner error: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return {
+    generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    scan_context: scanContext,
+    recommendations
+  };
+}
+
+// src/commands/evolve-scan.ts
+function generateScanCommand() {
+  return `---
+name: scan
+description: Run a deep harness-evolve configuration scan to detect quality issues
+disable-model-invocation: true
+---
+
+# Evolve Scan
+
+Run a deep scan of the current project's Claude Code configuration to detect quality issues and optimization opportunities.
+
+## What This Does
+
+Analyzes your Claude Code configuration files to detect:
+- **Redundant rules** -- same constraint defined in multiple files (CLAUDE.md, .claude/rules/, settings.json)
+- **Missing mechanization** -- operations in rules or CLAUDE.md that should be hooks for 100% reliability
+- **Stale config** -- references to non-existent files, outdated commands, or unused settings
+- **Configuration drift** -- inconsistencies between .claude/commands/, rules, and settings
+
+Files scanned: CLAUDE.md, .claude/rules/, settings.json, .claude/commands/
+
+## Instructions
+
+Run the scan CLI command:
+
+\`\`\`bash
+npx harness-evolve scan
+\`\`\`
+
+Or if globally installed:
+
+\`\`\`bash
+harness-evolve scan
+\`\`\`
+
+## Presenting Results
+
+Present the results grouped by confidence level (HIGH first, then MEDIUM, then LOW):
+
+1. **HIGH confidence** -- Issues that are very likely real problems. Recommend immediate action.
+2. **MEDIUM confidence** -- Probable issues worth reviewing. Present with context for user to decide.
+3. **LOW confidence** -- Possible improvements. Mention briefly and let user prioritize.
+
+For each issue, show:
+- Confidence level and category
+- Description of the problem
+- Affected file(s)
+- Suggested fix
+
+If issues are found, suggest running \`/evolve:apply\` to review and apply the recommendations interactively.
+
+If no issues are found, congratulate the user on a clean configuration.
+`;
+}
+
+// src/commands/evolve-apply.ts
+function generateApplyCommand() {
+  return `---
+name: apply
+description: Review and apply pending harness-evolve recommendations one by one
+disable-model-invocation: true
+argument-hint: "[filter: all|high|medium|low]"
+---
+
+# Evolve Apply
+
+Review pending harness-evolve recommendations interactively. For each recommendation, you can choose to apply it, skip it for later, or permanently dismiss it.
+
+## Arguments
+
+If \`$ARGUMENTS\` is provided (e.g., "high", "medium", or "low"), filter recommendations to only show that confidence level. If empty or "all", show all pending recommendations.
+
+## Instructions
+
+### Step 1: Read Pending Recommendations
+
+\`\`\`bash
+npx harness-evolve pending
+\`\`\`
+
+If the command outputs no pending recommendations, inform the user:
+> No pending recommendations. Run \`/evolve:scan\` to analyze your configuration and generate new recommendations.
+
+### Step 2: Present Each Recommendation
+
+For each pending recommendation, present the following:
+
+- **Confidence level** (HIGH / MEDIUM / LOW)
+- **Title** -- what the recommendation is about
+- **Description** -- detailed explanation of the issue
+- **Evidence** -- what data or pattern triggered this recommendation
+- **Suggested action** -- what change is proposed
+
+### Step 3: Ask User to Choose
+
+For each recommendation, ask the user to choose one of three actions:
+
+1. **Apply** -- Execute the recommendation. Run:
+   \`\`\`bash
+   npx harness-evolve apply-one <id>
+   \`\`\`
+   Report the result (success or failure) and show what changed.
+
+2. **Skip** -- Do nothing for now. The recommendation stays pending for future review. No command needed.
+
+3. **Ignore** -- Permanently dismiss this recommendation. Run:
+   \`\`\`bash
+   npx harness-evolve dismiss <id>
+   \`\`\`
+   Confirm the recommendation has been dismissed.
+
+### Step 4: Continue or Finish
+
+After processing each recommendation, move to the next one. When all recommendations have been processed, summarize what was done:
+- How many applied
+- How many skipped
+- How many ignored
+
+## Notes
+
+- Recommendations are generated by \`harness-evolve scan\` or automatic background analysis
+- Applied recommendations modify configuration files (settings.json, CLAUDE.md, .claude/rules/, etc.)
+- Ignored recommendations will not appear in future \`/evolve:apply\` sessions
+- Skipped recommendations remain pending and will reappear next time
+`;
+}
+
+// src/cli/init.ts
+async function fileExists(path) {
+  try {
+    await access2(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function installSlashCommands(projectDir) {
+  const commandsDir = join3(projectDir, ".claude", "commands", "evolve");
+  await mkdir(commandsDir, { recursive: true });
+  const commands = [
+    { name: "scan", generate: generateScanCommand, path: join3(commandsDir, "scan.md") },
+    { name: "apply", generate: generateApplyCommand, path: join3(commandsDir, "apply.md") }
+  ];
+  for (const cmd of commands) {
+    if (await fileExists(cmd.path)) {
+      console.log(`  /evolve:${cmd.name} already installed, skipping`);
+    } else {
+      await writeFile(cmd.path, cmd.generate(), "utf-8");
+      console.log(`  /evolve:${cmd.name} installed`);
+    }
+  }
+}
+async function runInit(options) {
+  const settingsPath = options.settingsPath ?? SETTINGS_PATH;
+  const hookCommands = HOOK_REGISTRATIONS.map((reg) => {
+    const absolutePath = resolveHookPath(reg.hookFile, options.baseDirOverride);
+    return {
+      event: reg.event,
+      command: `node "${absolutePath}"`,
+      timeout: reg.timeout,
+      async: reg.async,
+      description: reg.description
+    };
+  });
+  console.log("\nPlanned hook registrations:\n");
+  for (const hc of hookCommands) {
+    const asyncLabel = hc.async ? " (async)" : "";
+    console.log(`  ${hc.event}${asyncLabel} -- ${hc.description}`);
+    console.log(`    -> ${hc.command}`);
+  }
+  console.log("");
+  const samplePath = hookCommands[0].command;
+  if (samplePath.includes(".npm/_npx/")) {
+    console.log(
+      "WARNING: Detected npx installation. Hook paths may break when the"
+    );
+    console.log(
+      "npx cache is cleared. For persistent installation, use: npm i -g harness-evolve\n"
+    );
+  }
+  if (!options.yes) {
+    const accepted = await confirm("Register hooks in settings.json?");
+    if (!accepted) {
+      console.log("Aborted.");
+      return;
+    }
+  }
+  await mkdir(dirname3(settingsPath), { recursive: true });
+  const exists = await fileExists(settingsPath);
+  if (exists) {
+    await copyFile(settingsPath, settingsPath + ".backup");
+    console.log(`Backup created: ${settingsPath}.backup`);
+  }
+  const settings = await readSettings(settingsPath);
+  const merged = mergeHooks(settings, hookCommands);
+  await writeSettings(merged, settingsPath);
+  console.log(
+    `Hooks registered successfully! (${hookCommands.length} events)`
+  );
+  console.log("\nInstalling slash commands...\n");
+  await installSlashCommands(options.projectDir ?? process.cwd());
+  try {
+    console.log("\nScanning configuration...\n");
+    const scanResult = await runDeepScan(process.cwd());
+    if (scanResult.recommendations.length > 0) {
+      console.log(
+        `Found ${scanResult.recommendations.length} configuration suggestion(s):
+`
+      );
+      for (const rec of scanResult.recommendations) {
+        console.log(`  [${rec.confidence}] ${rec.title}`);
+        console.log(`    ${rec.description}`);
+        console.log(`    Suggested: ${rec.suggested_action}
+`);
+      }
+    } else {
+      console.log("Configuration looks clean -- no issues detected.\n");
+    }
+  } catch (err) {
+    console.error(
+      `Warning: Configuration scan failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+function registerInitCommand(program2) {
+  program2.command("init").description("Register harness-evolve hooks in Claude Code settings").option("--yes", "Skip confirmation prompt").action(async (opts) => {
+    await runInit({ yes: opts.yes ?? false });
+  });
+}
+
+// src/storage/counter.ts
+import { readFile as readFile3 } from "fs/promises";
+import { lock } from "proper-lockfile";
+import writeFileAtomic2 from "write-file-atomic";
+
+// src/schemas/counter.ts
+import { z as z2 } from "zod/v4";
+var counterSchema = z2.object({
+  total: z2.number().default(0),
+  session: z2.record(z2.string(), z2.number()).default({}),
+  last_analysis: z2.iso.datetime().optional(),
+  last_updated: z2.iso.datetime()
+});
+
+// src/storage/dirs.ts
+import { mkdir as mkdir2 } from "fs/promises";
+import { join as join4 } from "path";
+var BASE_DIR = join4(process.env.HOME ?? "", ".harness-evolve");
+var paths = {
+  base: BASE_DIR,
+  logs: {
+    prompts: join4(BASE_DIR, "logs", "prompts"),
+    tools: join4(BASE_DIR, "logs", "tools"),
+    permissions: join4(BASE_DIR, "logs", "permissions"),
+    sessions: join4(BASE_DIR, "logs", "sessions")
+  },
+  analysis: join4(BASE_DIR, "analysis"),
+  analysisPreProcessed: join4(BASE_DIR, "analysis", "pre-processed"),
+  summary: join4(BASE_DIR, "analysis", "pre-processed", "summary.json"),
+  environmentSnapshot: join4(BASE_DIR, "analysis", "environment-snapshot.json"),
+  analysisResult: join4(BASE_DIR, "analysis", "analysis-result.json"),
+  pending: join4(BASE_DIR, "pending"),
+  config: join4(BASE_DIR, "config.json"),
+  counter: join4(BASE_DIR, "counter.json"),
+  recommendations: join4(BASE_DIR, "recommendations.md"),
+  recommendationState: join4(BASE_DIR, "analysis", "recommendation-state.json"),
+  recommendationArchive: join4(BASE_DIR, "analysis", "recommendations-archive"),
+  notificationFlag: join4(BASE_DIR, "analysis", "has-pending-notifications"),
+  autoApplyLog: join4(BASE_DIR, "analysis", "auto-apply-log.jsonl"),
+  outcomeHistory: join4(BASE_DIR, "analysis", "outcome-history.jsonl")
+};
+var initialized = false;
+async function ensureInit() {
+  if (initialized) return;
+  await mkdir2(paths.logs.prompts, { recursive: true });
+  await mkdir2(paths.logs.tools, { recursive: true });
+  await mkdir2(paths.logs.permissions, { recursive: true });
+  await mkdir2(paths.logs.sessions, { recursive: true });
+  await mkdir2(paths.analysis, { recursive: true });
+  await mkdir2(paths.analysisPreProcessed, { recursive: true });
+  await mkdir2(paths.pending, { recursive: true });
+  await mkdir2(paths.recommendationArchive, { recursive: true });
+  initialized = true;
+}
+
+// src/storage/counter.ts
+async function readCounter() {
+  await ensureInit();
+  try {
+    const raw = await readFile3(paths.counter, "utf-8");
+    return counterSchema.parse(JSON.parse(raw));
+  } catch {
+    return {
+      total: 0,
+      session: {},
+      last_updated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+}
+
+// src/delivery/state.ts
+import { readFile as readFile4 } from "fs/promises";
+import writeFileAtomic3 from "write-file-atomic";
+
+// src/schemas/delivery.ts
+import { z as z3 } from "zod/v4";
+var recommendationStatusSchema = z3.enum(["pending", "applied", "dismissed"]);
+var recommendationStateEntrySchema = z3.object({
+  id: z3.string(),
+  status: recommendationStatusSchema,
+  updated_at: z3.iso.datetime(),
+  applied_details: z3.string().optional()
+});
+var recommendationStateSchema = z3.object({
+  entries: z3.array(recommendationStateEntrySchema),
+  last_updated: z3.iso.datetime()
+});
+var autoApplyLogEntrySchema = z3.object({
+  timestamp: z3.iso.datetime(),
+  recommendation_id: z3.string(),
+  target: z3.string(),
+  action: z3.string(),
+  success: z3.boolean(),
+  details: z3.string().optional(),
+  backup_path: z3.string().optional()
+});
+
+// src/delivery/state.ts
+async function loadState() {
+  try {
+    const raw = await readFile4(paths.recommendationState, "utf-8");
+    return recommendationStateSchema.parse(JSON.parse(raw));
+  } catch (err) {
+    if (isNodeError(err) && err.code === "ENOENT") {
+      return { entries: [], last_updated: (/* @__PURE__ */ new Date()).toISOString() };
+    }
+    throw err;
+  }
+}
+async function saveState(state) {
+  await writeFileAtomic3(
+    paths.recommendationState,
+    JSON.stringify(state, null, 2)
+  );
+}
+async function updateStatus(id, status, details) {
+  const state = await loadState();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const existing = state.entries.find((e) => e.id === id);
+  if (existing) {
+    existing.status = status;
+    existing.updated_at = now;
+    if (status === "applied" && details !== void 0) {
+      existing.applied_details = details;
+    } else if (status !== "applied") {
+      existing.applied_details = void 0;
+    }
+  } else {
+    state.entries.push({
+      id,
+      status,
+      updated_at: now,
+      ...status === "applied" && details !== void 0 ? { applied_details: details } : {}
+    });
+  }
+  state.last_updated = now;
+  await saveState(state);
+}
+function isNodeError(err) {
+  return err instanceof Error && "code" in err;
+}
+
+// src/cli/status.ts
+async function runStatus(options) {
+  const settingsPath = options.settingsPath ?? SETTINGS_PATH;
+  const counter = await readCounter();
+  const state = await loadState();
+  const pendingCount = state.entries.filter(
+    (e) => e.status === "pending"
+  ).length;
+  const settings = await readSettings(settingsPath);
+  const hooksRegistered = JSON.stringify(settings.hooks ?? {}).includes(
+    HARNESS_EVOLVE_MARKER
+  );
+  console.log("");
+  console.log("harness-evolve status");
+  console.log("=====================");
+  console.log(`Interactions:     ${counter.total}`);
+  console.log(`Last analysis:    ${counter.last_analysis ?? "never"}`);
+  console.log(`Pending recs:     ${pendingCount}`);
+  console.log(`Hooks registered: ${hooksRegistered ? "Yes" : "No"}`);
+  console.log("");
+}
+function registerStatusCommand(program2) {
+  program2.command("status").description("Show harness-evolve status and statistics").action(async () => {
+    await runStatus({});
+  });
+}
+
+// src/cli/uninstall.ts
+import { copyFile as copyFile2, rm, rmdir, access as access3 } from "fs/promises";
+import { constants as constants2 } from "fs";
+import { join as join5 } from "path";
+async function removeSlashCommands(projectDir) {
+  const commandsDir = join5(projectDir, ".claude", "commands", "evolve");
+  for (const file of ["scan.md", "apply.md"]) {
+    try {
+      await rm(join5(commandsDir, file));
+      console.log(`  Removed /evolve:${file.replace(".md", "")}`);
+    } catch {
+    }
+  }
+  try {
+    await rmdir(commandsDir);
+  } catch {
+  }
+}
+async function runUninstall(options) {
+  const settingsPath = options.settingsPath ?? SETTINGS_PATH;
+  const settings = await readSettings(settingsPath);
+  const hooks = settings.hooks;
+  if (!hooks || Object.keys(hooks).length === 0) {
+    console.log("No harness-evolve hooks found in settings.json");
+  } else {
+    let removedCount = 0;
+    const filteredHooks = {};
+    for (const [event, entries] of Object.entries(hooks)) {
+      if (!Array.isArray(entries)) {
+        filteredHooks[event] = entries;
+        continue;
+      }
+      const kept = entries.filter((entry) => {
+        const innerHooks = entry.hooks;
+        if (!Array.isArray(innerHooks)) return true;
+        const isHarnessEvolve = innerHooks.some(
+          (h) => String(h.command ?? "").includes(HARNESS_EVOLVE_MARKER)
+        );
+        if (isHarnessEvolve) removedCount++;
+        return !isHarnessEvolve;
+      });
+      if (kept.length > 0) {
+        filteredHooks[event] = kept;
+      }
+    }
+    if (removedCount > 0) {
+      await copyFile2(settingsPath, settingsPath + ".backup");
+      console.log(`Backup created: ${settingsPath}.backup`);
+      settings.hooks = filteredHooks;
+      await writeSettings(settings, settingsPath);
+      console.log("Removed harness-evolve hooks from settings.json");
+    } else {
+      console.log("No harness-evolve hooks found in settings.json");
+    }
+  }
+  console.log("\nRemoving slash commands...");
+  await removeSlashCommands(options.projectDir ?? process.cwd());
+  if (options.purge) {
+    if (!options.yes) {
+      const accepted = await confirm(
+        "Delete all harness-evolve data (~/.harness-evolve/)?"
+      );
+      if (!accepted) {
+        console.log("Data directory preserved.");
+        return;
+      }
+    }
+    try {
+      await access3(paths.base, constants2.F_OK);
+      await rm(paths.base, { recursive: true, force: true });
+      console.log(`Deleted data directory: ${paths.base}`);
+    } catch {
+      console.log(`Data directory not found: ${paths.base}`);
+    }
+  }
+}
+function registerUninstallCommand(program2) {
+  program2.command("uninstall").description("Remove harness-evolve hooks and optionally delete data").option("--purge", "Also delete ~/.harness-evolve/ data directory").option("--yes", "Skip confirmation prompt").action(async (opts) => {
+    await runUninstall({
+      purge: opts.purge ?? false,
+      yes: opts.yes ?? false
+    });
+  });
+}
+
+// src/cli/scan.ts
+var CONFIDENCE_ORDER = { HIGH: 0, MEDIUM: 1, LOW: 2 };
+function registerScanCommand(program2) {
+  program2.command("scan").description("Run deep configuration scan and output results as JSON").action(async () => {
+    try {
+      const result = await runDeepScan(process.cwd());
+      const sorted = [...result.recommendations].sort(
+        (a, b) => (CONFIDENCE_ORDER[a.confidence] ?? 3) - (CONFIDENCE_ORDER[b.confidence] ?? 3)
+      );
+      const output = {
+        generated_at: result.generated_at,
+        recommendation_count: sorted.length,
+        recommendations: sorted
+      };
+      console.log(JSON.stringify(output, null, 2));
+    } catch (err) {
+      console.log(JSON.stringify({
+        error: err instanceof Error ? err.message : String(err),
+        recommendations: []
+      }, null, 2));
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/cli/apply.ts
+import { readFile as readFile8, appendFile as appendFile2 } from "fs/promises";
+
+// src/schemas/recommendation.ts
+import { z as z4 } from "zod/v4";
+var routingTargetSchema = z4.enum([
+  "HOOK",
+  "SKILL",
+  "RULE",
+  "CLAUDE_MD",
+  "MEMORY",
+  "SETTINGS"
+]);
+var confidenceSchema = z4.enum(["HIGH", "MEDIUM", "LOW"]);
+var patternTypeSchema = z4.enum([
+  "repeated_prompt",
+  "long_prompt",
+  "permission-always-approved",
+  "code_correction",
+  "personal_info",
+  "config_drift",
+  "version_update",
+  "ecosystem_gsd",
+  "ecosystem_cog",
+  "onboarding_start_hooks",
+  "onboarding_start_rules",
+  "onboarding_start_claudemd",
+  "onboarding_optimize",
+  "scan_redundancy",
+  "scan_missing_mechanization",
+  "scan_stale_reference"
+]);
+var recommendationSchema = z4.object({
+  id: z4.string(),
+  target: routingTargetSchema,
+  confidence: confidenceSchema,
+  pattern_type: patternTypeSchema,
+  title: z4.string(),
+  description: z4.string(),
+  evidence: z4.object({
+    count: z4.number(),
+    sessions: z4.number().optional(),
+    examples: z4.array(z4.string()).max(3)
+  }),
+  suggested_action: z4.string(),
+  ecosystem_context: z4.string().optional()
+});
+var DEFAULT_THRESHOLDS = {
+  repeated_prompt_min_count: 5,
+  repeated_prompt_high_count: 10,
+  repeated_prompt_high_sessions: 3,
+  repeated_prompt_medium_sessions: 2,
+  long_prompt_min_words: 200,
+  long_prompt_min_count: 2,
+  long_prompt_high_words: 300,
+  long_prompt_high_count: 3,
+  permission_approval_min_count: 10,
+  permission_approval_min_sessions: 3,
+  permission_approval_high_count: 15,
+  permission_approval_high_sessions: 4,
+  code_correction_min_failure_rate: 0.3,
+  code_correction_min_failures: 3
+};
+var analysisConfigSchema = z4.object({
+  thresholds: z4.object({
+    repeated_prompt_min_count: z4.number().default(DEFAULT_THRESHOLDS.repeated_prompt_min_count),
+    repeated_prompt_high_count: z4.number().default(DEFAULT_THRESHOLDS.repeated_prompt_high_count),
+    repeated_prompt_high_sessions: z4.number().default(DEFAULT_THRESHOLDS.repeated_prompt_high_sessions),
+    repeated_prompt_medium_sessions: z4.number().default(DEFAULT_THRESHOLDS.repeated_prompt_medium_sessions),
+    long_prompt_min_words: z4.number().default(DEFAULT_THRESHOLDS.long_prompt_min_words),
+    long_prompt_min_count: z4.number().default(DEFAULT_THRESHOLDS.long_prompt_min_count),
+    long_prompt_high_words: z4.number().default(DEFAULT_THRESHOLDS.long_prompt_high_words),
+    long_prompt_high_count: z4.number().default(DEFAULT_THRESHOLDS.long_prompt_high_count),
+    permission_approval_min_count: z4.number().default(DEFAULT_THRESHOLDS.permission_approval_min_count),
+    permission_approval_min_sessions: z4.number().default(DEFAULT_THRESHOLDS.permission_approval_min_sessions),
+    permission_approval_high_count: z4.number().default(DEFAULT_THRESHOLDS.permission_approval_high_count),
+    permission_approval_high_sessions: z4.number().default(DEFAULT_THRESHOLDS.permission_approval_high_sessions),
+    code_correction_min_failure_rate: z4.number().default(DEFAULT_THRESHOLDS.code_correction_min_failure_rate),
+    code_correction_min_failures: z4.number().default(DEFAULT_THRESHOLDS.code_correction_min_failures)
+  }).default(() => ({ ...DEFAULT_THRESHOLDS })),
+  max_recommendations: z4.number().default(20)
+}).default(() => ({
+  thresholds: { ...DEFAULT_THRESHOLDS },
+  max_recommendations: 20
+}));
+var analysisResultSchema = z4.object({
+  generated_at: z4.iso.datetime(),
+  summary_period: z4.object({
+    since: z4.string(),
+    until: z4.string(),
+    days: z4.number()
+  }),
+  recommendations: z4.array(recommendationSchema),
+  metadata: z4.object({
+    classifier_count: z4.number(),
+    patterns_evaluated: z4.number(),
+    environment_ecosystems: z4.array(z4.string()),
+    claude_code_version: z4.string()
+  })
+});
+
+// src/delivery/auto-apply.ts
+import { appendFile } from "fs/promises";
+
+// src/storage/config.ts
+import { readFile as readFile5 } from "fs/promises";
+import writeFileAtomic4 from "write-file-atomic";
+
+// src/schemas/config.ts
+import { z as z5 } from "zod/v4";
+var configSchema = z5.object({
+  version: z5.number().default(1),
+  analysis: z5.object({
+    threshold: z5.number().min(1).default(50),
+    enabled: z5.boolean().default(true),
+    classifierThresholds: z5.record(z5.string(), z5.number()).default({})
+  }).default({ threshold: 50, enabled: true, classifierThresholds: {} }),
+  hooks: z5.object({
+    capturePrompts: z5.boolean().default(true),
+    captureTools: z5.boolean().default(true),
+    capturePermissions: z5.boolean().default(true),
+    captureSessions: z5.boolean().default(true)
+  }).default({
+    capturePrompts: true,
+    captureTools: true,
+    capturePermissions: true,
+    captureSessions: true
+  }),
+  scrubbing: z5.object({
+    enabled: z5.boolean().default(true),
+    highEntropyDetection: z5.boolean().default(false),
+    customPatterns: z5.array(z5.object({
+      name: z5.string(),
+      regex: z5.string(),
+      replacement: z5.string()
+    })).default([])
+  }).default({
+    enabled: true,
+    highEntropyDetection: false,
+    customPatterns: []
+  }),
+  delivery: z5.object({
+    stdoutInjection: z5.boolean().default(true),
+    maxTokens: z5.number().default(200),
+    fullAuto: z5.boolean().default(false),
+    maxRecommendationsInFile: z5.number().default(20),
+    archiveAfterDays: z5.number().default(7)
+  }).default({
+    stdoutInjection: true,
+    maxTokens: 200,
+    fullAuto: false,
+    maxRecommendationsInFile: 20,
+    archiveAfterDays: 7
+  })
+}).strict();
+
+// src/delivery/appliers/index.ts
+var registry = /* @__PURE__ */ new Map();
+function registerApplier(applier) {
+  registry.set(applier.target, applier);
+}
+function getApplier(target) {
+  return registry.get(target);
+}
+
+// src/delivery/appliers/settings-applier.ts
+import { readFile as readFile6, copyFile as copyFile3, mkdir as mkdir3 } from "fs/promises";
+import { join as join6, dirname as dirname4 } from "path";
+import writeFileAtomic5 from "write-file-atomic";
+var SettingsApplier = class {
+  target = "SETTINGS";
+  canApply(rec) {
+    return rec.confidence === "HIGH" && rec.target === "SETTINGS" && rec.pattern_type === "permission-always-approved";
+  }
+  async apply(rec, options) {
+    try {
+      if (rec.pattern_type !== "permission-always-approved") {
+        return {
+          recommendation_id: rec.id,
+          success: false,
+          details: `Skipped: pattern_type '${rec.pattern_type}' not supported for auto-apply in v1`
+        };
+      }
+      const settingsFilePath = options?.settingsPath ?? join6(process.env.HOME ?? "", ".claude", "settings.json");
+      const raw = await readFile6(settingsFilePath, "utf-8");
+      const settings = JSON.parse(raw);
+      const backup = join6(
+        paths.analysis,
+        "backups",
+        `settings-backup-${rec.id}.json`
+      );
+      await mkdir3(dirname4(backup), { recursive: true });
+      await copyFile3(settingsFilePath, backup);
+      const toolName = extractToolName(rec);
+      if (!toolName) {
+        return {
+          recommendation_id: rec.id,
+          success: false,
+          details: "Could not extract tool name from recommendation evidence"
+        };
+      }
+      const allowedTools = Array.isArray(settings.allowedTools) ? settings.allowedTools : [];
+      if (!allowedTools.includes(toolName)) {
+        allowedTools.push(toolName);
+      }
+      settings.allowedTools = allowedTools;
+      await writeFileAtomic5(
+        settingsFilePath,
+        JSON.stringify(settings, null, 2)
+      );
+      return {
+        recommendation_id: rec.id,
+        success: true,
+        details: `Added ${toolName} to allowedTools`
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        recommendation_id: rec.id,
+        success: false,
+        details: message
+      };
+    }
+  }
+};
+function extractToolName(rec) {
+  for (const example of rec.evidence.examples) {
+    const match = example.match(/^(\w+)\(/);
+    if (match) return match[1];
+  }
+  return void 0;
+}
+
+// src/delivery/appliers/rule-applier.ts
+import { writeFile as writeFile2, access as access4, mkdir as mkdir4 } from "fs/promises";
+import { join as join7 } from "path";
+var RuleApplier = class {
+  target = "RULE";
+  canApply(rec) {
+    return rec.confidence === "HIGH" && rec.target === "RULE";
+  }
+  async apply(rec, options) {
+    const rulesDir = options?.rulesDir ?? join7(process.env.HOME ?? "", ".claude", "rules");
+    const fileName = `evolve-${rec.pattern_type}.md`;
+    const filePath = join7(rulesDir, fileName);
+    try {
+      await access4(filePath);
+      return {
+        recommendation_id: rec.id,
+        success: false,
+        details: `Rule file already exists: ${fileName}`
+      };
+    } catch {
+    }
+    try {
+      await mkdir4(rulesDir, { recursive: true });
+      const content = [
+        `# ${rec.title}`,
+        "",
+        rec.description,
+        "",
+        "## Action",
+        "",
+        rec.suggested_action,
+        "",
+        "---",
+        `*Auto-generated by harness-evolve (${rec.id})*`
+      ].join("\n");
+      await writeFile2(filePath, content, "utf-8");
+      return {
+        recommendation_id: rec.id,
+        success: true,
+        details: `Created rule file: ${fileName}`
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        recommendation_id: rec.id,
+        success: false,
+        details: message
+      };
+    }
+  }
+};
+
+// src/delivery/appliers/hook-applier.ts
+import { writeFile as writeFile3, access as access5, mkdir as mkdir5, chmod, copyFile as copyFile4 } from "fs/promises";
+import { join as join8, basename as basename2 } from "path";
+
+// src/generators/schemas.ts
+import { z as z6 } from "zod/v4";
+var GENERATOR_VERSION = "1.0.0";
+function nowISO() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function toSlug(text) {
+  if (!text) return "";
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 50);
+}
+var generatedArtifactSchema = z6.object({
+  type: z6.enum(["skill", "hook", "claude_md_patch"]),
+  filename: z6.string(),
+  content: z6.string(),
+  source_recommendation_id: z6.string(),
+  metadata: z6.object({
+    generated_at: z6.iso.datetime(),
+    generator_version: z6.string(),
+    pattern_type: z6.string()
+  })
+});
+
+// src/generators/hook-generator.ts
+function extractHookEvent(rec) {
+  const descMatch = rec.description.match(/suitable for a (\w+) hook/i);
+  if (descMatch) return descMatch[1];
+  const actionMatch = rec.suggested_action.match(/Create a (\w+) hook/i);
+  if (actionMatch) return actionMatch[1];
+  return "PreToolUse";
+}
+function generateHook(rec) {
+  if (rec.target !== "HOOK") return null;
+  const hookEvent = extractHookEvent(rec);
+  const slugName = toSlug(rec.title);
+  const content = [
+    "#!/usr/bin/env bash",
+    `# Auto-generated hook for: ${rec.title}`,
+    `# Hook event: ${hookEvent}`,
+    `# Source: harness-evolve (${rec.id})`,
+    "#",
+    "# TODO: Review and customize this script before use.",
+    "",
+    "# Read hook input from stdin",
+    "INPUT=$(cat)",
+    "",
+    "# Extract relevant fields",
+    `# Adjust jq path based on your ${hookEvent} event schema`,
+    "",
+    `# ${rec.suggested_action}`,
+    "",
+    "# Exit 0 to allow, exit 2 to block",
+    "exit 0"
+  ].join("\n");
+  return {
+    type: "hook",
+    filename: `.claude/hooks/evolve-${slugName}.sh`,
+    content,
+    source_recommendation_id: rec.id,
+    metadata: {
+      generated_at: nowISO(),
+      generator_version: GENERATOR_VERSION,
+      pattern_type: rec.pattern_type
+    }
+  };
+}
+
+// src/delivery/appliers/hook-applier.ts
+var HookApplier = class {
+  target = "HOOK";
+  canApply(rec) {
+    return rec.confidence === "HIGH" && rec.target === "HOOK";
+  }
+  async apply(rec, options) {
+    try {
+      const artifact = generateHook(rec);
+      if (!artifact) {
+        return {
+          recommendation_id: rec.id,
+          success: false,
+          details: "Generator returned null \u2014 recommendation not applicable for hook generation"
+        };
+      }
+      const hooksDir = options?.hooksDir ?? join8(process.env.HOME ?? "", ".claude", "hooks");
+      const scriptFilename = basename2(artifact.filename);
+      const scriptPath = join8(hooksDir, scriptFilename);
+      try {
+        await access5(scriptPath);
+        return {
+          recommendation_id: rec.id,
+          success: false,
+          details: `Hook file already exists: ${scriptFilename}`
+        };
+      } catch {
+      }
+      await mkdir5(hooksDir, { recursive: true });
+      await writeFile3(scriptPath, artifact.content, "utf-8");
+      await chmod(scriptPath, 493);
+      const settingsPath = options?.settingsPath ?? join8(process.env.HOME ?? "", ".claude", "settings.json");
+      const settings = await readSettings(settingsPath);
+      const backupDir = join8(paths.analysis, "backups");
+      await mkdir5(backupDir, { recursive: true });
+      const backupFile = join8(backupDir, `settings-backup-${rec.id}.json`);
+      try {
+        await copyFile4(settingsPath, backupFile);
+      } catch {
+        await writeFile3(backupFile, JSON.stringify(settings, null, 2), "utf-8");
+      }
+      const eventMatch = artifact.content.match(/# Hook event: (\w+)/);
+      const hookEvent = eventMatch?.[1] ?? "PreToolUse";
+      const merged = mergeHooks(settings, [
+        {
+          event: hookEvent,
+          command: `bash "${scriptPath}"`,
+          timeout: 10,
+          async: true
+        }
+      ]);
+      await writeSettings(merged, settingsPath);
+      return {
+        recommendation_id: rec.id,
+        success: true,
+        details: `Created hook script: ${scriptFilename} and registered under ${hookEvent}`
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        recommendation_id: rec.id,
+        success: false,
+        details: message
+      };
+    }
+  }
+};
+
+// src/delivery/appliers/claude-md-applier.ts
+import { readFile as readFile7, mkdir as mkdir6 } from "fs/promises";
+import { join as join9, dirname as dirname6 } from "path";
+import writeFileAtomic6 from "write-file-atomic";
+var DESTRUCTIVE_PATTERNS = /* @__PURE__ */ new Set([
+  "scan_stale_reference",
+  "scan_redundancy"
+]);
+var ClaudeMdApplier = class {
+  target = "CLAUDE_MD";
+  canApply(rec) {
+    return rec.confidence === "HIGH" && rec.target === "CLAUDE_MD";
+  }
+  async apply(rec, options) {
+    try {
+      if (DESTRUCTIVE_PATTERNS.has(rec.pattern_type)) {
+        return {
+          recommendation_id: rec.id,
+          success: false,
+          details: `Pattern type '${rec.pattern_type}' requires manual review \u2014 cannot safely auto-apply`
+        };
+      }
+      const claudeMdPath = options?.claudeMdPath ?? join9(process.cwd(), "CLAUDE.md");
+      let existingContent = "";
+      try {
+        existingContent = await readFile7(claudeMdPath, "utf-8");
+      } catch {
+      }
+      if (existingContent) {
+        const backupDir = join9(paths.analysis, "backups");
+        await mkdir6(backupDir, { recursive: true });
+        const backupFile = join9(backupDir, `claudemd-backup-${rec.id}.md`);
+        await writeFileAtomic6(backupFile, existingContent);
+      }
+      const newSection = [
+        "",
+        "",
+        `## ${rec.title}`,
+        "",
+        rec.suggested_action,
+        "",
+        "---",
+        `*Auto-generated by harness-evolve (${rec.id})*`,
+        ""
+      ].join("\n");
+      const updatedContent = existingContent + newSection;
+      await mkdir6(dirname6(claudeMdPath), { recursive: true });
+      await writeFileAtomic6(claudeMdPath, updatedContent);
+      return {
+        recommendation_id: rec.id,
+        success: true,
+        details: `Appended section: ${rec.title}`
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        recommendation_id: rec.id,
+        success: false,
+        details: message
+      };
+    }
+  }
+};
+
+// src/delivery/auto-apply.ts
+registerApplier(new SettingsApplier());
+registerApplier(new RuleApplier());
+registerApplier(new HookApplier());
+registerApplier(new ClaudeMdApplier());
+
+// src/cli/apply.ts
+var CONFIDENCE_ORDER2 = { HIGH: 0, MEDIUM: 1, LOW: 2 };
+async function loadAnalysisResult() {
+  try {
+    const raw = await readFile8(paths.analysisResult, "utf-8");
+    const parsed = analysisResultSchema.parse(JSON.parse(raw));
+    return parsed.recommendations;
+  } catch {
+    return [];
+  }
+}
+function registerPendingCommand(program2) {
+  program2.command("pending").description("List pending recommendations as JSON").action(async () => {
+    const allRecs = await loadAnalysisResult();
+    const state = await loadState();
+    const statusMap = new Map(state.entries.map((e) => [e.id, e.status]));
+    const pending = allRecs.filter((rec) => {
+      const status = statusMap.get(rec.id);
+      return status === void 0 || status === "pending";
+    }).sort(
+      (a, b) => (CONFIDENCE_ORDER2[a.confidence] ?? 3) - (CONFIDENCE_ORDER2[b.confidence] ?? 3)
+    );
+    console.log(JSON.stringify({ pending, count: pending.length }, null, 2));
+  });
+}
+function registerApplyOneCommand(program2) {
+  program2.command("apply-one").description("Apply a single recommendation by ID").argument("<id>", "Recommendation ID to apply").action(async (id) => {
+    try {
+      const allRecs = await loadAnalysisResult();
+      const rec = allRecs.find((r) => r.id === id);
+      if (!rec) {
+        console.log(JSON.stringify({
+          recommendation_id: id,
+          success: false,
+          details: `Recommendation '${id}' not found`
+        }));
+        process.exitCode = 1;
+        return;
+      }
+      const applier = getApplier(rec.target);
+      if (!applier || !applier.canApply(rec)) {
+        console.log(JSON.stringify({
+          recommendation_id: id,
+          success: false,
+          details: `No applicable applier for target '${rec.target}'`
+        }));
+        process.exitCode = 1;
+        return;
+      }
+      const result = await applier.apply(rec);
+      const logEntry = {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        recommendation_id: rec.id,
+        target: rec.target,
+        action: rec.suggested_action,
+        success: result.success,
+        details: result.details
+      };
+      try {
+        await appendFile2(paths.autoApplyLog, JSON.stringify(logEntry) + "\n", "utf-8");
+      } catch {
+      }
+      if (result.success) {
+        await updateStatus(id, "applied", `Applied via /evolve:apply: ${result.details}`);
+      }
+      console.log(JSON.stringify(result, null, 2));
+    } catch (err) {
+      console.log(JSON.stringify({
+        recommendation_id: id,
+        success: false,
+        details: err instanceof Error ? err.message : String(err)
+      }));
+      process.exitCode = 1;
+    }
+  });
+}
+function registerDismissCommand(program2) {
+  program2.command("dismiss").description("Permanently dismiss a recommendation by ID").argument("<id>", "Recommendation ID to dismiss").action(async (id) => {
+    try {
+      await updateStatus(id, "dismissed", "Dismissed by user via /evolve:apply");
+      console.log(JSON.stringify({ id, status: "dismissed" }, null, 2));
+    } catch (err) {
+      console.log(JSON.stringify({
+        id,
+        error: err instanceof Error ? err.message : String(err)
+      }));
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/cli.ts
+var pkg = JSON.parse(
+  readFileSync(join10(import.meta.dirname, "..", "package.json"), "utf-8")
+);
+var program = new Command().name("harness-evolve").description("Self-iteration engine for Claude Code").version(pkg.version);
+registerInitCommand(program);
+registerStatusCommand(program);
+registerUninstallCommand(program);
+registerScanCommand(program);
+registerPendingCommand(program);
+registerApplyOneCommand(program);
+registerDismissCommand(program);
+program.parse();
+//# sourceMappingURL=cli.js.map