harness-evolve 1.0.0

package/dist/index.js

@@ -0,0 +1,3131 @@
+// src/schemas/config.ts
+import { z } from "zod/v4";
+var configSchema = z.object({
+  version: z.number().default(1),
+  analysis: z.object({
+    threshold: z.number().min(1).default(50),
+    enabled: z.boolean().default(true),
+    classifierThresholds: z.record(z.string(), z.number()).default({})
+  }).default({ threshold: 50, enabled: true, classifierThresholds: {} }),
+  hooks: z.object({
+    capturePrompts: z.boolean().default(true),
+    captureTools: z.boolean().default(true),
+    capturePermissions: z.boolean().default(true),
+    captureSessions: z.boolean().default(true)
+  }).default({
+    capturePrompts: true,
+    captureTools: true,
+    capturePermissions: true,
+    captureSessions: true
+  }),
+  scrubbing: z.object({
+    enabled: z.boolean().default(true),
+    highEntropyDetection: z.boolean().default(false),
+    customPatterns: z.array(z.object({
+      name: z.string(),
+      regex: z.string(),
+      replacement: z.string()
+    })).default([])
+  }).default({
+    enabled: true,
+    highEntropyDetection: false,
+    customPatterns: []
+  }),
+  delivery: z.object({
+    stdoutInjection: z.boolean().default(true),
+    maxTokens: z.number().default(200),
+    fullAuto: z.boolean().default(false),
+    maxRecommendationsInFile: z.number().default(20),
+    archiveAfterDays: z.number().default(7)
+  }).default({
+    stdoutInjection: true,
+    maxTokens: 200,
+    fullAuto: false,
+    maxRecommendationsInFile: 20,
+    archiveAfterDays: 7
+  })
+}).strict();
+
+// src/schemas/log-entry.ts
+import { z as z2 } from "zod/v4";
+var promptEntrySchema = z2.object({
+  timestamp: z2.iso.datetime(),
+  session_id: z2.string(),
+  cwd: z2.string(),
+  prompt: z2.string(),
+  prompt_length: z2.number(),
+  transcript_path: z2.string().optional()
+});
+var toolEntrySchema = z2.object({
+  timestamp: z2.iso.datetime(),
+  session_id: z2.string(),
+  event: z2.enum(["pre", "post", "failure"]),
+  tool_name: z2.string(),
+  input_summary: z2.string().optional(),
+  duration_ms: z2.number().optional(),
+  success: z2.boolean().optional()
+});
+var permissionEntrySchema = z2.object({
+  timestamp: z2.iso.datetime(),
+  session_id: z2.string(),
+  tool_name: z2.string(),
+  decision: z2.enum(["approved", "denied", "unknown"])
+});
+var sessionEntrySchema = z2.object({
+  timestamp: z2.iso.datetime(),
+  session_id: z2.string(),
+  event: z2.enum(["start", "end"]),
+  cwd: z2.string().optional()
+});
+
+// src/schemas/counter.ts
+import { z as z3 } from "zod/v4";
+var counterSchema = z3.object({
+  total: z3.number().default(0),
+  session: z3.record(z3.string(), z3.number()).default({}),
+  last_analysis: z3.iso.datetime().optional(),
+  last_updated: z3.iso.datetime()
+});
+
+// src/schemas/hook-input.ts
+import { z as z4 } from "zod/v4";
+var hookCommonSchema = z4.object({
+  session_id: z4.string(),
+  transcript_path: z4.string(),
+  cwd: z4.string(),
+  permission_mode: z4.string()
+});
+var userPromptSubmitInputSchema = hookCommonSchema.extend({
+  hook_event_name: z4.literal("UserPromptSubmit"),
+  prompt: z4.string()
+});
+var preToolUseInputSchema = hookCommonSchema.extend({
+  hook_event_name: z4.literal("PreToolUse"),
+  tool_name: z4.string(),
+  tool_input: z4.record(z4.string(), z4.unknown()),
+  tool_use_id: z4.string()
+});
+var postToolUseInputSchema = hookCommonSchema.extend({
+  hook_event_name: z4.literal("PostToolUse"),
+  tool_name: z4.string(),
+  tool_input: z4.record(z4.string(), z4.unknown()),
+  tool_response: z4.unknown().optional(),
+  tool_use_id: z4.string()
+});
+var postToolUseFailureInputSchema = hookCommonSchema.extend({
+  hook_event_name: z4.literal("PostToolUseFailure"),
+  tool_name: z4.string(),
+  tool_input: z4.record(z4.string(), z4.unknown()),
+  tool_use_id: z4.string(),
+  error: z4.string().optional(),
+  is_interrupt: z4.boolean().optional()
+});
+var permissionRequestInputSchema = hookCommonSchema.extend({
+  hook_event_name: z4.literal("PermissionRequest"),
+  tool_name: z4.string(),
+  tool_input: z4.record(z4.string(), z4.unknown()),
+  permission_suggestions: z4.array(z4.unknown()).optional()
+});
+var stopInputSchema = hookCommonSchema.extend({
+  hook_event_name: z4.literal("Stop"),
+  stop_hook_active: z4.boolean(),
+  last_assistant_message: z4.string().optional()
+});
+
+// src/hooks/shared.ts
+var MAX_LEN = 200;
+function truncate(str, maxLen) {
+  return str.length > maxLen ? str.slice(0, maxLen) + "..." : str;
+}
+function readFromStream(stream) {
+  return new Promise((resolve2, reject) => {
+    let data = "";
+    stream.setEncoding("utf-8");
+    stream.on("data", (chunk) => {
+      data += chunk;
+    });
+    stream.on("end", () => resolve2(data));
+    stream.on("error", reject);
+  });
+}
+function readStdin() {
+  return readFromStream(process.stdin);
+}
+function summarizeToolInput(toolName, toolInput) {
+  switch (toolName) {
+    case "Bash":
+      return truncate(String(toolInput.command ?? ""), MAX_LEN);
+    case "Write":
+    case "Edit":
+    case "Read":
+      return truncate(String(toolInput.file_path ?? ""), MAX_LEN);
+    case "Glob":
+      return truncate(String(toolInput.pattern ?? ""), MAX_LEN);
+    case "Grep":
+      return truncate(String(toolInput.pattern ?? ""), MAX_LEN);
+    default: {
+      const str = JSON.stringify(toolInput);
+      return truncate(str, MAX_LEN);
+    }
+  }
+}
+
+// src/storage/counter.ts
+import { readFile } from "fs/promises";
+import { lock } from "proper-lockfile";
+import writeFileAtomic from "write-file-atomic";
+
+// src/storage/dirs.ts
+import { mkdir } from "fs/promises";
+import { join } from "path";
+var BASE_DIR = join(process.env.HOME ?? "", ".harness-evolve");
+var paths = {
+  base: BASE_DIR,
+  logs: {
+    prompts: join(BASE_DIR, "logs", "prompts"),
+    tools: join(BASE_DIR, "logs", "tools"),
+    permissions: join(BASE_DIR, "logs", "permissions"),
+    sessions: join(BASE_DIR, "logs", "sessions")
+  },
+  analysis: join(BASE_DIR, "analysis"),
+  analysisPreProcessed: join(BASE_DIR, "analysis", "pre-processed"),
+  summary: join(BASE_DIR, "analysis", "pre-processed", "summary.json"),
+  environmentSnapshot: join(BASE_DIR, "analysis", "environment-snapshot.json"),
+  analysisResult: join(BASE_DIR, "analysis", "analysis-result.json"),
+  pending: join(BASE_DIR, "pending"),
+  config: join(BASE_DIR, "config.json"),
+  counter: join(BASE_DIR, "counter.json"),
+  recommendations: join(BASE_DIR, "recommendations.md"),
+  recommendationState: join(BASE_DIR, "analysis", "recommendation-state.json"),
+  recommendationArchive: join(BASE_DIR, "analysis", "recommendations-archive"),
+  notificationFlag: join(BASE_DIR, "analysis", "has-pending-notifications"),
+  autoApplyLog: join(BASE_DIR, "analysis", "auto-apply-log.jsonl"),
+  outcomeHistory: join(BASE_DIR, "analysis", "outcome-history.jsonl")
+};
+var initialized = false;
+async function ensureInit() {
+  if (initialized) return;
+  await mkdir(paths.logs.prompts, { recursive: true });
+  await mkdir(paths.logs.tools, { recursive: true });
+  await mkdir(paths.logs.permissions, { recursive: true });
+  await mkdir(paths.logs.sessions, { recursive: true });
+  await mkdir(paths.analysis, { recursive: true });
+  await mkdir(paths.analysisPreProcessed, { recursive: true });
+  await mkdir(paths.pending, { recursive: true });
+  await mkdir(paths.recommendationArchive, { recursive: true });
+  initialized = true;
+}
+
+// src/storage/counter.ts
+async function readCounter() {
+  await ensureInit();
+  try {
+    const raw = await readFile(paths.counter, "utf-8");
+    return counterSchema.parse(JSON.parse(raw));
+  } catch {
+    return {
+      total: 0,
+      session: {},
+      last_updated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+}
+async function incrementCounter(sessionId) {
+  await ensureInit();
+  try {
+    await readFile(paths.counter, "utf-8");
+  } catch {
+    const initial = {
+      total: 0,
+      session: {},
+      last_updated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await writeFileAtomic(paths.counter, JSON.stringify(initial, null, 2));
+  }
+  const release = await lock(paths.counter, {
+    retries: { retries: 50, minTimeout: 20, maxTimeout: 1e3, randomize: true },
+    stale: 1e4
+    // Consider lock stale after 10 seconds
+  });
+  try {
+    const raw = await readFile(paths.counter, "utf-8");
+    const data = counterSchema.parse(JSON.parse(raw));
+    data.total += 1;
+    data.session[sessionId] = (data.session[sessionId] ?? 0) + 1;
+    data.last_updated = (/* @__PURE__ */ new Date()).toISOString();
+    await writeFileAtomic(paths.counter, JSON.stringify(data, null, 2));
+    return data.total;
+  } finally {
+    await release();
+  }
+}
+async function resetCounter() {
+  await ensureInit();
+  const data = {
+    total: 0,
+    session: {},
+    last_updated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeFileAtomic(paths.counter, JSON.stringify(data, null, 2));
+}
+
+// src/storage/config.ts
+import { readFile as readFile2 } from "fs/promises";
+import writeFileAtomic2 from "write-file-atomic";
+async function loadConfig() {
+  try {
+    const raw = await readFile2(paths.config, "utf-8");
+    return configSchema.parse(JSON.parse(raw));
+  } catch {
+    const defaults = configSchema.parse({});
+    await writeFileAtomic2(paths.config, JSON.stringify(defaults, null, 2));
+    return defaults;
+  }
+}
+
+// src/analysis/jsonl-reader.ts
+import { createReadStream } from "fs";
+import { readdir } from "fs/promises";
+import { createInterface } from "readline";
+import { join as join2 } from "path";
+function formatDate(d) {
+  return d.toISOString().slice(0, 10);
+}
+async function readLogEntries(logDir, schema, options) {
+  let fileNames;
+  try {
+    fileNames = await readdir(logDir);
+  } catch {
+    return [];
+  }
+  let jsonlFiles = fileNames.filter((f) => f.endsWith(".jsonl"));
+  const sinceStr = options?.since ? formatDate(options.since) : void 0;
+  const untilStr = options?.until ? formatDate(options.until) : void 0;
+  if (sinceStr || untilStr) {
+    jsonlFiles = jsonlFiles.filter((f) => {
+      const dateStr = f.replace(".jsonl", "");
+      if (sinceStr && dateStr < sinceStr) return false;
+      if (untilStr && dateStr > untilStr) return false;
+      return true;
+    });
+  }
+  jsonlFiles.sort();
+  const entries = [];
+  for (const file of jsonlFiles) {
+    const filePath = join2(logDir, file);
+    const rl = createInterface({
+      input: createReadStream(filePath, "utf-8"),
+      crlfDelay: Infinity
+    });
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+      try {
+        const parsed = schema.parse(JSON.parse(line));
+        entries.push(parsed);
+      } catch {
+      }
+    }
+  }
+  return entries;
+}
+
+// src/analysis/schemas.ts
+import { z as z5 } from "zod/v4";
+var summarySchema = z5.object({
+  generated_at: z5.iso.datetime(),
+  period: z5.object({
+    since: z5.string(),
+    // YYYY-MM-DD
+    until: z5.string(),
+    // YYYY-MM-DD
+    days: z5.number()
+  }),
+  stats: z5.object({
+    total_prompts: z5.number(),
+    total_tool_uses: z5.number(),
+    total_permissions: z5.number(),
+    unique_sessions: z5.number()
+  }),
+  top_repeated_prompts: z5.array(
+    z5.object({
+      prompt: z5.string(),
+      count: z5.number(),
+      sessions: z5.number()
+    })
+  ).max(20),
+  tool_frequency: z5.array(
+    z5.object({
+      tool_name: z5.string(),
+      count: z5.number(),
+      avg_duration_ms: z5.number().optional()
+    })
+  ),
+  permission_patterns: z5.array(
+    z5.object({
+      tool_name: z5.string(),
+      count: z5.number(),
+      sessions: z5.number()
+    })
+  ),
+  long_prompts: z5.array(
+    z5.object({
+      prompt_preview: z5.string(),
+      length: z5.number(),
+      count: z5.number()
+    })
+  ).max(10)
+});
+var environmentSnapshotSchema = z5.object({
+  generated_at: z5.iso.datetime(),
+  claude_code: z5.object({
+    version: z5.string(),
+    version_known: z5.boolean(),
+    compatible: z5.boolean()
+  }),
+  settings: z5.object({
+    user: z5.unknown().nullable(),
+    project: z5.unknown().nullable(),
+    local: z5.unknown().nullable()
+  }),
+  installed_tools: z5.object({
+    plugins: z5.array(
+      z5.object({
+        name: z5.string(),
+        marketplace: z5.string(),
+        enabled: z5.boolean(),
+        scope: z5.string(),
+        capabilities: z5.array(z5.string())
+      })
+    ),
+    skills: z5.array(
+      z5.object({
+        name: z5.string(),
+        scope: z5.enum(["user", "project"])
+      })
+    ),
+    rules: z5.array(
+      z5.object({
+        name: z5.string(),
+        scope: z5.enum(["user", "project"])
+      })
+    ),
+    hooks: z5.array(
+      z5.object({
+        event: z5.string(),
+        scope: z5.enum(["user", "project", "local"]),
+        type: z5.string()
+      })
+    ),
+    claude_md: z5.array(
+      z5.object({
+        path: z5.string(),
+        exists: z5.boolean()
+      })
+    )
+  }),
+  detected_ecosystems: z5.array(z5.string())
+});
+
+// src/analysis/pre-processor.ts
+import writeFileAtomic3 from "write-file-atomic";
+var PROMPT_TRUNCATE_LEN = 100;
+var LONG_PROMPT_THRESHOLD = 200;
+var DEFAULT_TOP_N = 20;
+var DEFAULT_DAYS = 30;
+var MAX_LONG_PROMPTS = 10;
+function normalizePrompt(prompt) {
+  return prompt.trim().toLowerCase().replace(/\s+/g, " ");
+}
+function formatDate2(d) {
+  return d.toISOString().slice(0, 10);
+}
+function countWithSessions(items) {
+  const map = /* @__PURE__ */ new Map();
+  for (const { key, session } of items) {
+    const existing = map.get(key);
+    if (existing) {
+      existing.count += 1;
+      existing.sessions.add(session);
+    } else {
+      map.set(key, { count: 1, sessions: /* @__PURE__ */ new Set([session]) });
+    }
+  }
+  return map;
+}
+function computeToolFrequency(tools) {
+  const map = /* @__PURE__ */ new Map();
+  for (const entry of tools) {
+    const existing = map.get(entry.tool_name);
+    if (existing) {
+      existing.count += 1;
+      if (entry.event === "post" && entry.duration_ms != null) {
+        existing.durations.push(entry.duration_ms);
+      }
+    } else {
+      const durations = [];
+      if (entry.event === "post" && entry.duration_ms != null) {
+        durations.push(entry.duration_ms);
+      }
+      map.set(entry.tool_name, { count: 1, durations });
+    }
+  }
+  return Array.from(map.entries()).map(([tool_name, { count, durations }]) => ({
+    tool_name,
+    count,
+    avg_duration_ms: durations.length > 0 ? Math.round(
+      durations.reduce((sum, d) => sum + d, 0) / durations.length
+    ) : void 0
+  })).sort((a, b) => b.count - a.count);
+}
+function detectLongPrompts(prompts) {
+  const map = /* @__PURE__ */ new Map();
+  for (const entry of prompts) {
+    const words = entry.prompt.trim().split(/\s+/);
+    if (words.length <= LONG_PROMPT_THRESHOLD) continue;
+    const key = normalizePrompt(entry.prompt);
+    const existing = map.get(key);
+    if (existing) {
+      existing.count += 1;
+    } else {
+      map.set(key, { length: words.length, count: 1 });
+    }
+  }
+  return Array.from(map.entries()).sort((a, b) => b[1].count - a[1].count).slice(0, MAX_LONG_PROMPTS).map(([normalized, { length, count }]) => ({
+    prompt_preview: normalized.slice(0, PROMPT_TRUNCATE_LEN),
+    length,
+    count
+  }));
+}
+async function preProcess(options) {
+  const until = options?.until ?? /* @__PURE__ */ new Date();
+  const since = options?.since ?? new Date(until.getTime() - DEFAULT_DAYS * 864e5);
+  const topN = options?.topN ?? DEFAULT_TOP_N;
+  const [prompts, tools, permissions] = await Promise.all([
+    readLogEntries(paths.logs.prompts, promptEntrySchema, { since, until }),
+    readLogEntries(paths.logs.tools, toolEntrySchema, { since, until }),
+    readLogEntries(paths.logs.permissions, permissionEntrySchema, {
+      since,
+      until
+    })
+  ]);
+  const sessionSet = /* @__PURE__ */ new Set();
+  for (const p of prompts) sessionSet.add(p.session_id);
+  for (const t of tools) sessionSet.add(t.session_id);
+  for (const perm of permissions) sessionSet.add(perm.session_id);
+  const promptCounts = countWithSessions(
+    prompts.map((p) => ({
+      key: normalizePrompt(p.prompt),
+      session: p.session_id
+    }))
+  );
+  const topRepeatedPrompts = Array.from(promptCounts.entries()).sort((a, b) => b[1].count - a[1].count).slice(0, topN).map(([key, { count, sessions }]) => ({
+    prompt: key.slice(0, PROMPT_TRUNCATE_LEN),
+    count,
+    sessions: sessions.size
+  }));
+  const toolFrequency = computeToolFrequency(tools);
+  const permissionCounts = countWithSessions(
+    permissions.map((p) => ({
+      key: p.tool_name,
+      session: p.session_id
+    }))
+  );
+  const permissionPatterns = Array.from(permissionCounts.entries()).sort((a, b) => b[1].count - a[1].count).map(([tool_name, { count, sessions }]) => ({
+    tool_name,
+    count,
+    sessions: sessions.size
+  }));
+  const longPrompts = detectLongPrompts(prompts);
+  const summary = summarySchema.parse({
+    generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    period: {
+      since: formatDate2(since),
+      until: formatDate2(until),
+      days: DEFAULT_DAYS
+    },
+    stats: {
+      total_prompts: prompts.length,
+      total_tool_uses: tools.length,
+      total_permissions: permissions.length,
+      unique_sessions: sessionSet.size
+    },
+    top_repeated_prompts: topRepeatedPrompts,
+    tool_frequency: toolFrequency,
+    permission_patterns: permissionPatterns,
+    long_prompts: longPrompts
+  });
+  await ensureInit();
+  await writeFileAtomic3(paths.summary, JSON.stringify(summary));
+  return summary;
+}
+
+// src/analysis/environment-scanner.ts
+import { readdir as readdir2, readFile as readFile3, access } from "fs/promises";
+import { execFileSync } from "child_process";
+import { join as join3 } from "path";
+import { constants } from "fs";
+import writeFileAtomic4 from "write-file-atomic";
+var KNOWN_COMPATIBLE_MIN = "2.1.0";
+var KNOWN_COMPATIBLE_MAX = "2.1.99";
+async function scanEnvironment(cwd, home) {
+  const homeDir = home ?? process.env.HOME ?? "";
+  const [userSettings, projectSettings, localSettings] = await Promise.all([
+    readSettingsSafe(join3(homeDir, ".claude", "settings.json")),
+    readSettingsSafe(join3(cwd, ".claude", "settings.json")),
+    readSettingsSafe(join3(cwd, ".claude", "settings.local.json"))
+  ]);
+  const enabledPluginNames = extractEnabledPlugins(userSettings);
+  const [claudeVersion, plugins, skills, rules, hooks, claudeMds, ecosystems] = await Promise.all([
+    Promise.resolve(detectClaudeCodeVersion()),
+    discoverPlugins(homeDir, enabledPluginNames),
+    discoverSkills(homeDir, cwd),
+    discoverRules(cwd),
+    Promise.resolve(
+      discoverHooks(userSettings, projectSettings, localSettings)
+    ),
+    discoverClaudeMd(homeDir, cwd),
+    detectEcosystems(cwd, homeDir)
+  ]);
+  const snapshot = {
+    generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    claude_code: claudeVersion,
+    settings: {
+      user: userSettings,
+      project: projectSettings,
+      local: localSettings
+    },
+    installed_tools: {
+      plugins,
+      skills,
+      rules,
+      hooks,
+      claude_md: claudeMds
+    },
+    detected_ecosystems: ecosystems
+  };
+  const validated = environmentSnapshotSchema.parse(snapshot);
+  await ensureInit();
+  await writeFileAtomic4(
+    paths.environmentSnapshot,
+    JSON.stringify(validated)
+  );
+  return validated;
+}
+function detectClaudeCodeVersion() {
+  try {
+    const output = execFileSync("claude", ["--version"], {
+      timeout: 3e3,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const match = output.match(/^(\d+\.\d+\.\d+)/);
+    if (!match) {
+      return { version: "unknown", version_known: false, compatible: false };
+    }
+    const version = match[1];
+    const compatible = compareSemver(version, KNOWN_COMPATIBLE_MIN) >= 0 && compareSemver(version, KNOWN_COMPATIBLE_MAX) <= 0;
+    return { version, version_known: true, compatible };
+  } catch {
+    return { version: "unknown", version_known: false, compatible: false };
+  }
+}
+async function readSettingsSafe(filePath) {
+  try {
+    const raw = await readFile3(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function extractEnabledPlugins(settings) {
+  if (!settings || typeof settings !== "object") return [];
+  const obj = settings;
+  if (!Array.isArray(obj.enabledPlugins)) return [];
+  return obj.enabledPlugins.map((p) => {
+    if (typeof p === "string") return p;
+    if (p && typeof p === "object" && "name" in p) {
+      return String(p.name);
+    }
+    return null;
+  }).filter((n) => n !== null);
+}
+async function discoverPlugins(home, enabledPluginNames) {
+  try {
+    const pluginsFile = join3(home, ".claude", "plugins", "installed_plugins.json");
+    const raw = await readFile3(pluginsFile, "utf-8");
+    const installed = JSON.parse(raw);
+    if (!Array.isArray(installed)) return [];
+    const plugins = [];
+    for (const entry of installed) {
+      if (!entry || typeof entry !== "object") continue;
+      const plugin = entry;
+      const name = String(plugin.name ?? "");
+      const marketplace = String(plugin.marketplace ?? "unknown");
+      const scope = String(plugin.scope ?? "user");
+      const version = String(plugin.version ?? "latest");
+      const enabled = enabledPluginNames.includes(name);
+      const capabilities = await scanPluginCapabilities(
+        home,
+        marketplace,
+        name,
+        version
+      );
+      plugins.push({ name, marketplace, enabled, scope, capabilities });
+    }
+    return plugins;
+  } catch {
+    return [];
+  }
+}
+async function scanPluginCapabilities(home, marketplace, pluginName, version) {
+  const knownCapabilities = ["commands", "skills", "hooks", "agents"];
+  const capabilities = [];
+  try {
+    const cacheDir = join3(
+      home,
+      ".claude",
+      "plugins",
+      "cache",
+      marketplace,
+      pluginName,
+      version
+    );
+    const entries = await readdir2(cacheDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && knownCapabilities.includes(entry.name)) {
+        capabilities.push(entry.name);
+      }
+    }
+  } catch {
+  }
+  return capabilities;
+}
+async function discoverSkills(home, cwd) {
+  const skills = [];
+  try {
+    const userSkillsDir = join3(home, ".claude", "skills");
+    const entries = await readdir2(userSkillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        skills.push({ name: entry.name, scope: "user" });
+      }
+    }
+  } catch {
+  }
+  try {
+    const projectSkillsDir = join3(cwd, ".claude", "skills");
+    const entries = await readdir2(projectSkillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        skills.push({ name: entry.name, scope: "project" });
+      }
+    }
+  } catch {
+  }
+  return skills;
+}
+async function discoverRules(cwd) {
+  const rules = [];
+  try {
+    const rulesDir = join3(cwd, ".claude", "rules");
+    const entries = await readdir2(rulesDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        rules.push({ name: entry.name, scope: "project" });
+      }
+    }
+  } catch {
+  }
+  return rules;
+}
+function discoverHooks(userSettings, projectSettings, localSettings) {
+  const hooks = [];
+  extractHooksFromSettings(userSettings, "user", hooks);
+  extractHooksFromSettings(projectSettings, "project", hooks);
+  extractHooksFromSettings(localSettings, "local", hooks);
+  return hooks;
+}
+function extractHooksFromSettings(settings, scope, hooks) {
+  if (!settings || typeof settings !== "object") return;
+  const obj = settings;
+  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");
+      hooks.push({ event, scope, type });
+    }
+  }
+}
+async function discoverClaudeMd(home, cwd) {
+  const locations = [
+    join3(cwd, "CLAUDE.md"),
+    join3(cwd, ".claude", "CLAUDE.md"),
+    join3(home, ".claude", "CLAUDE.md")
+  ];
+  const results = [];
+  for (const path of locations) {
+    let exists = false;
+    try {
+      await access(path, constants.F_OK);
+      exists = true;
+    } catch {
+    }
+    results.push({ path, exists });
+  }
+  return results;
+}
+async function detectEcosystems(cwd, home) {
+  const ecosystems = [];
+  try {
+    await access(join3(cwd, ".planning"), constants.F_OK);
+    ecosystems.push("gsd");
+  } catch {
+  }
+  try {
+    const skillsDir = join3(home, ".claude", "skills");
+    const entries = await readdir2(skillsDir);
+    if (entries.some((e) => e.toLowerCase().includes("cog"))) {
+      ecosystems.push("cog");
+    }
+  } catch {
+  }
+  return ecosystems;
+}
+function compareSemver(a, b) {
+  const partsA = a.split(".").map(Number);
+  const partsB = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const numA = partsA[i] ?? 0;
+    const numB = partsB[i] ?? 0;
+    if (numA < numB) return -1;
+    if (numA > numB) return 1;
+  }
+  return 0;
+}
+
+// src/analysis/classifiers/repeated-prompts.ts
+function truncate2(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen - 3) + "...";
+}
+function classifyRepeatedPrompts(summary, _snapshot, config) {
+  const recommendations = [];
+  const threshold = config.thresholds.repeated_prompt_min_count;
+  for (let i = 0; i < summary.top_repeated_prompts.length; i++) {
+    const entry = summary.top_repeated_prompts[i];
+    if (entry.count < threshold) continue;
+    const wordCount = entry.prompt.split(/\s+/).length;
+    if (wordCount > 50) continue;
+    const confidence = entry.count >= config.thresholds.repeated_prompt_high_count && entry.sessions >= config.thresholds.repeated_prompt_high_sessions ? "HIGH" : "MEDIUM";
+    const truncatedPrompt = truncate2(entry.prompt, 60);
+    recommendations.push({
+      id: `rec-repeated-${i}`,
+      target: "HOOK",
+      confidence,
+      pattern_type: "repeated_prompt",
+      title: `Repeated prompt: "${truncatedPrompt}"`,
+      description: `This prompt has been used ${entry.count} times across ${entry.sessions} sessions. Consider creating a hook or alias to automate this.`,
+      evidence: {
+        count: entry.count,
+        sessions: entry.sessions,
+        examples: [entry.prompt]
+      },
+      suggested_action: `Create a UserPromptSubmit hook that detects "${truncatedPrompt}" and auto-executes the intended action.`
+    });
+  }
+  return recommendations;
+}
+
+// src/analysis/classifiers/long-prompts.ts
+function classifyLongPrompts(summary, _snapshot, config) {
+  const recommendations = [];
+  for (let i = 0; i < summary.long_prompts.length; i++) {
+    const entry = summary.long_prompts[i];
+    if (entry.length < config.thresholds.long_prompt_min_words) continue;
+    if (entry.count < config.thresholds.long_prompt_min_count) continue;
+    const confidence = entry.count >= config.thresholds.long_prompt_high_count && entry.length >= config.thresholds.long_prompt_high_words ? "HIGH" : "MEDIUM";
+    recommendations.push({
+      id: `rec-long-${i}`,
+      target: "SKILL",
+      confidence,
+      pattern_type: "long_prompt",
+      title: `Long repeated prompt (${entry.length} words, ${entry.count}x)`,
+      description: `A ${entry.length}-word prompt has been used ${entry.count} times. Consider converting it to a reusable skill.`,
+      evidence: {
+        count: entry.count,
+        examples: [entry.prompt_preview]
+      },
+      suggested_action: "Create a skill in .claude/skills/ that encapsulates this prompt as a reusable workflow."
+    });
+  }
+  return recommendations;
+}
+
+// src/analysis/classifiers/permission-patterns.ts
+function classifyPermissionPatterns(summary, _snapshot, config) {
+  const recommendations = [];
+  for (let i = 0; i < summary.permission_patterns.length; i++) {
+    const entry = summary.permission_patterns[i];
+    if (entry.count < config.thresholds.permission_approval_min_count) continue;
+    if (entry.sessions < config.thresholds.permission_approval_min_sessions) continue;
+    const confidence = entry.count >= config.thresholds.permission_approval_high_count && entry.sessions >= config.thresholds.permission_approval_high_sessions ? "HIGH" : "MEDIUM";
+    recommendations.push({
+      id: `rec-permission-always-approved-${i}`,
+      target: "SETTINGS",
+      confidence,
+      pattern_type: "permission-always-approved",
+      title: `Frequently approved tool: ${entry.tool_name}`,
+      description: `You have approved "${entry.tool_name}" ${entry.count} times across ${entry.sessions} sessions. Consider adding it to allowedTools in settings.json.`,
+      evidence: {
+        count: entry.count,
+        sessions: entry.sessions,
+        examples: [`${entry.tool_name} approved ${entry.count} times`]
+      },
+      suggested_action: `Add "${entry.tool_name}" to the "allow" array in ~/.claude/settings.json permissions.`
+    });
+  }
+  return recommendations;
+}
+
+// src/analysis/classifiers/code-corrections.ts
+var CODE_MODIFICATION_TOOLS = /* @__PURE__ */ new Set(["Write", "Edit", "MultiEdit"]);
+var HIGH_USAGE_THRESHOLD = 20;
+function classifyCodeCorrections(summary, _snapshot, _config) {
+  const recommendations = [];
+  let index = 0;
+  for (const entry of summary.tool_frequency) {
+    if (!CODE_MODIFICATION_TOOLS.has(entry.tool_name)) continue;
+    if (entry.count < HIGH_USAGE_THRESHOLD) continue;
+    recommendations.push({
+      id: `rec-correction-${index}`,
+      target: "RULE",
+      confidence: "LOW",
+      pattern_type: "code_correction",
+      title: `Frequent code modifications with ${entry.tool_name} (${entry.count} uses)`,
+      description: `The ${entry.tool_name} tool has been used ${entry.count} times. Review for recurring patterns that could become a coding rule or convention.`,
+      evidence: {
+        count: entry.count,
+        examples: [entry.tool_name]
+      },
+      suggested_action: `Review recent ${entry.tool_name} usage for recurring patterns. If a consistent code style or approach emerges, create a rule in .claude/rules/.`
+    });
+    index++;
+  }
+  return recommendations;
+}
+
+// src/analysis/classifiers/personal-info.ts
+var PERSONAL_KEYWORDS = [
+  "my name is",
+  "i live in",
+  "i work at",
+  "i prefer",
+  "my email",
+  "my project",
+  "always use",
+  "never use"
+];
+var MIN_COUNT = 2;
+function classifyPersonalInfo(summary, _snapshot, _config) {
+  const recommendations = [];
+  const matchedKeywords = /* @__PURE__ */ new Set();
+  let index = 0;
+  for (const entry of summary.top_repeated_prompts) {
+    if (entry.count < MIN_COUNT) continue;
+    const lowerPrompt = entry.prompt.toLowerCase();
+    for (const keyword of PERSONAL_KEYWORDS) {
+      if (matchedKeywords.has(keyword)) continue;
+      if (!lowerPrompt.includes(keyword)) continue;
+      matchedKeywords.add(keyword);
+      recommendations.push({
+        id: `rec-personal-${index}`,
+        target: "MEMORY",
+        confidence: "LOW",
+        pattern_type: "personal_info",
+        title: `Personal preference detected: "${keyword}..."`,
+        description: `A prompt mentioning personal information ("${keyword}") has appeared ${entry.count} times. Consider storing this in memory for automatic context.`,
+        evidence: {
+          count: entry.count,
+          sessions: entry.sessions,
+          examples: [entry.prompt]
+        },
+        suggested_action: "Add this information to memory (e.g., CLAUDE.md or a memory file) so Claude Code can use it without being reminded."
+      });
+      index++;
+    }
+  }
+  return recommendations;
+}
+
+// src/analysis/classifiers/config-drift.ts
+var MAX_HOOKS_BEFORE_REVIEW = 10;
+function classifyConfigDrift(_summary, snapshot, _config) {
+  const recommendations = [];
+  let index = 0;
+  const hookEvents = new Set(snapshot.installed_tools.hooks.map((h) => h.event));
+  const ruleNames = new Set(snapshot.installed_tools.rules.map((r) => r.name));
+  for (const overlap of hookEvents) {
+    if (!ruleNames.has(overlap)) continue;
+    recommendations.push({
+      id: `rec-drift-${index}`,
+      target: "RULE",
+      confidence: "LOW",
+      pattern_type: "config_drift",
+      title: `Hook-rule overlap detected: "${overlap}"`,
+      description: `Both a hook (event: "${overlap}") and a rule (name: "${overlap}") exist. This may indicate duplicated behavior that should be consolidated into one mechanism.`,
+      evidence: {
+        count: 2,
+        examples: [`Hook event: ${overlap}`, `Rule name: ${overlap}`]
+      },
+      suggested_action: `Review the hook and rule for "${overlap}". If they serve the same purpose, consolidate into the more appropriate mechanism (hooks for 100% reliability, rules for guidance).`
+    });
+    index++;
+  }
+  const existingClaudeMd = snapshot.installed_tools.claude_md.filter((c) => c.exists);
+  if (existingClaudeMd.length > 1) {
+    recommendations.push({
+      id: `rec-drift-${index}`,
+      target: "CLAUDE_MD",
+      confidence: "LOW",
+      pattern_type: "config_drift",
+      title: `Multiple CLAUDE.md files detected (${existingClaudeMd.length})`,
+      description: `Found ${existingClaudeMd.length} existing CLAUDE.md files. Multiple CLAUDE.md files may contain contradictory instructions. Review for consistency.`,
+      evidence: {
+        count: existingClaudeMd.length,
+        examples: existingClaudeMd.slice(0, 3).map((c) => c.path)
+      },
+      suggested_action: "Review all CLAUDE.md files for contradictions or redundancies. Consider consolidating shared instructions into the most appropriate scope."
+    });
+    index++;
+  }
+  if (snapshot.installed_tools.hooks.length > MAX_HOOKS_BEFORE_REVIEW) {
+    recommendations.push({
+      id: `rec-drift-${index}`,
+      target: "HOOK",
+      confidence: "LOW",
+      pattern_type: "config_drift",
+      title: `Excessive hook count (${snapshot.installed_tools.hooks.length} hooks)`,
+      description: `Found ${snapshot.installed_tools.hooks.length} hooks across all scopes. This many hooks may indicate redundancy or performance concerns. Review for consolidation.`,
+      evidence: {
+        count: snapshot.installed_tools.hooks.length,
+        examples: snapshot.installed_tools.hooks.slice(0, 3).map((h) => `${h.event} (${h.scope})`)
+      },
+      suggested_action: "Review all hooks for overlapping functionality. Consider combining hooks that trigger on the same event or serve similar purposes."
+    });
+  }
+  return recommendations;
+}
+
+// src/analysis/classifiers/ecosystem-adapter.ts
+var MULTI_STEP_MIN_COUNT = 3;
+function classifyEcosystemAdaptations(summary, snapshot, _config) {
+  const recommendations = [];
+  let index = 0;
+  if (snapshot.claude_code.version_known && !snapshot.claude_code.compatible && snapshot.claude_code.version !== "unknown") {
+    recommendations.push({
+      id: `rec-ecosystem-${index}`,
+      target: "CLAUDE_MD",
+      confidence: "MEDIUM",
+      pattern_type: "version_update",
+      title: `Claude Code version ${snapshot.claude_code.version} detected (outside tested range)`,
+      description: `Your Claude Code version (${snapshot.claude_code.version}) is outside the tested compatible range. New features may be available that change optimal configuration strategies.`,
+      evidence: {
+        count: 1,
+        examples: [`Version: ${snapshot.claude_code.version}`]
+      },
+      suggested_action: `Review Claude Code changelog for version ${snapshot.claude_code.version}. New hook events, permission models, or settings may require harness-evolve configuration updates.`
+    });
+    index++;
+  }
+  if (snapshot.detected_ecosystems.includes("gsd")) {
+    const multiStepPrompts = summary.top_repeated_prompts.filter(
+      (p) => p.count >= MULTI_STEP_MIN_COUNT
+    );
+    if (multiStepPrompts.length > 0) {
+      const topPrompt = multiStepPrompts[0];
+      recommendations.push({
+        id: `rec-ecosystem-${index}`,
+        target: "SKILL",
+        confidence: "LOW",
+        pattern_type: "ecosystem_gsd",
+        title: "GSD workflow detected -- consider /gsd slash commands",
+        description: "GSD is installed in this project. Repeated multi-step prompts may be better served by GSD planning phases or slash commands rather than standalone skills.",
+        evidence: {
+          count: multiStepPrompts.length,
+          examples: [topPrompt.prompt]
+        },
+        suggested_action: "Review repeated prompts and consider if they map to GSD phases (/gsd:plan-phase, /gsd:execute-phase) or custom slash commands.",
+        ecosystem_context: "GSD detected: Use /gsd slash commands and .planning patterns for multi-step workflows instead of standalone skills"
+      });
+      index++;
+    }
+  }
+  if (snapshot.detected_ecosystems.includes("cog")) {
+    recommendations.push({
+      id: `rec-ecosystem-${index}`,
+      target: "MEMORY",
+      confidence: "LOW",
+      pattern_type: "ecosystem_cog",
+      title: "Cog memory system detected -- route memory to Cog tiers",
+      description: "Cog is installed. Personal information and contextual preferences should be routed to Cog's tiered memory system rather than raw CLAUDE.md entries.",
+      evidence: {
+        count: 1,
+        examples: ["Cog detected in ~/.claude/skills/"]
+      },
+      suggested_action: "Use /reflect and /evolve Cog commands for memory management instead of manually editing CLAUDE.md.",
+      ecosystem_context: "Cog detected: Route memory entries to Cog tiers (/reflect, /evolve) instead of raw CLAUDE.md"
+    });
+  }
+  return recommendations;
+}
+
+// src/analysis/experience-level.ts
+function computeExperienceLevel(snapshot) {
+  const hooks = snapshot.installed_tools.hooks.length;
+  const rules = snapshot.installed_tools.rules.length;
+  const skills = snapshot.installed_tools.skills.length;
+  const plugins = snapshot.installed_tools.plugins.length;
+  const claudeMd = snapshot.installed_tools.claude_md.filter((c) => c.exists).length;
+  const ecosystems = snapshot.detected_ecosystems.length;
+  const score = Math.min(
+    100,
+    hooks * 8 + rules * 6 + skills * 5 + plugins * 10 + claudeMd * 3 + ecosystems * 7
+  );
+  const tier = score === 0 ? "newcomer" : score < 30 ? "intermediate" : "power_user";
+  return {
+    tier,
+    score,
+    breakdown: { hooks, rules, skills, plugins, claude_md: claudeMd, ecosystems }
+  };
+}
+
+// src/analysis/classifiers/onboarding.ts
+function classifyOnboarding(_summary, snapshot, _config) {
+  const level = computeExperienceLevel(snapshot);
+  const recommendations = [];
+  let index = 0;
+  if (level.tier === "newcomer") {
+    if (level.breakdown.hooks === 0) {
+      recommendations.push({
+        id: `rec-onboarding-${index}`,
+        target: "HOOK",
+        confidence: "MEDIUM",
+        pattern_type: "onboarding_start_hooks",
+        title: "Start automating: create your first hook",
+        description: "Hooks run automatically on Claude Code lifecycle events (pre-commit, tool use, session start). Start with a formatting or test-on-save hook to experience automation benefits.",
+        evidence: {
+          count: 0,
+          examples: ["No hooks detected in your environment"]
+        },
+        suggested_action: "Add a hook in .claude/settings.json hooks section for automation."
+      });
+      index++;
+    }
+    if (level.breakdown.rules === 0) {
+      recommendations.push({
+        id: `rec-onboarding-${index}`,
+        target: "RULE",
+        confidence: "MEDIUM",
+        pattern_type: "onboarding_start_rules",
+        title: "Define coding preferences: add your first rule",
+        description: "Rules (.claude/rules/) codify conventions that Claude follows automatically. They persist across sessions and ensure consistent behavior.",
+        evidence: {
+          count: 0,
+          examples: ["No rules detected in your environment"]
+        },
+        suggested_action: "Create .claude/rules/ directory with a rule for your preferred coding style."
+      });
+      index++;
+    }
+    if (level.breakdown.claude_md === 0) {
+      recommendations.push({
+        id: `rec-onboarding-${index}`,
+        target: "CLAUDE_MD",
+        confidence: "MEDIUM",
+        pattern_type: "onboarding_start_claudemd",
+        title: "Set project context: create CLAUDE.md",
+        description: "CLAUDE.md gives Claude project-specific context \u2014 tech stack, conventions, and constraints. It is loaded automatically at the start of every conversation.",
+        evidence: {
+          count: 0,
+          examples: ["No CLAUDE.md files detected in your environment"]
+        },
+        suggested_action: "Create CLAUDE.md in your project root with project description and conventions."
+      });
+    }
+  } else if (level.tier === "power_user") {
+    recommendations.push({
+      id: "rec-onboarding-3",
+      target: "SETTINGS",
+      confidence: "LOW",
+      pattern_type: "onboarding_optimize",
+      title: "Consider mechanizing recurring patterns",
+      description: "Your extensive configuration suggests active automation investment. Review for redundancy or upgrade opportunities \u2014 hooks and rules with overlapping concerns can be consolidated.",
+      evidence: {
+        count: level.score,
+        examples: [
+          `${level.breakdown.hooks} hooks, ${level.breakdown.rules} rules, ${level.breakdown.plugins} plugins installed`
+        ]
+      },
+      suggested_action: "Review your hooks and rules for overlapping concerns that could be consolidated."
+    });
+  }
+  return recommendations;
+}
+
+// src/analysis/classifiers/index.ts
+var classifiers = [
+  classifyRepeatedPrompts,
+  classifyLongPrompts,
+  classifyPermissionPatterns,
+  classifyCodeCorrections,
+  classifyPersonalInfo,
+  classifyConfigDrift,
+  classifyEcosystemAdaptations,
+  classifyOnboarding
+];
+
+// src/schemas/recommendation.ts
+import { z as z6 } from "zod/v4";
+var routingTargetSchema = z6.enum([
+  "HOOK",
+  "SKILL",
+  "RULE",
+  "CLAUDE_MD",
+  "MEMORY",
+  "SETTINGS"
+]);
+var confidenceSchema = z6.enum(["HIGH", "MEDIUM", "LOW"]);
+var patternTypeSchema = z6.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 = z6.object({
+  id: z6.string(),
+  target: routingTargetSchema,
+  confidence: confidenceSchema,
+  pattern_type: patternTypeSchema,
+  title: z6.string(),
+  description: z6.string(),
+  evidence: z6.object({
+    count: z6.number(),
+    sessions: z6.number().optional(),
+    examples: z6.array(z6.string()).max(3)
+  }),
+  suggested_action: z6.string(),
+  ecosystem_context: z6.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 = z6.object({
+  thresholds: z6.object({
+    repeated_prompt_min_count: z6.number().default(DEFAULT_THRESHOLDS.repeated_prompt_min_count),
+    repeated_prompt_high_count: z6.number().default(DEFAULT_THRESHOLDS.repeated_prompt_high_count),
+    repeated_prompt_high_sessions: z6.number().default(DEFAULT_THRESHOLDS.repeated_prompt_high_sessions),
+    repeated_prompt_medium_sessions: z6.number().default(DEFAULT_THRESHOLDS.repeated_prompt_medium_sessions),
+    long_prompt_min_words: z6.number().default(DEFAULT_THRESHOLDS.long_prompt_min_words),
+    long_prompt_min_count: z6.number().default(DEFAULT_THRESHOLDS.long_prompt_min_count),
+    long_prompt_high_words: z6.number().default(DEFAULT_THRESHOLDS.long_prompt_high_words),
+    long_prompt_high_count: z6.number().default(DEFAULT_THRESHOLDS.long_prompt_high_count),
+    permission_approval_min_count: z6.number().default(DEFAULT_THRESHOLDS.permission_approval_min_count),
+    permission_approval_min_sessions: z6.number().default(DEFAULT_THRESHOLDS.permission_approval_min_sessions),
+    permission_approval_high_count: z6.number().default(DEFAULT_THRESHOLDS.permission_approval_high_count),
+    permission_approval_high_sessions: z6.number().default(DEFAULT_THRESHOLDS.permission_approval_high_sessions),
+    code_correction_min_failure_rate: z6.number().default(DEFAULT_THRESHOLDS.code_correction_min_failure_rate),
+    code_correction_min_failures: z6.number().default(DEFAULT_THRESHOLDS.code_correction_min_failures)
+  }).default(() => ({ ...DEFAULT_THRESHOLDS })),
+  max_recommendations: z6.number().default(20)
+}).default(() => ({
+  thresholds: { ...DEFAULT_THRESHOLDS },
+  max_recommendations: 20
+}));
+var analysisResultSchema = z6.object({
+  generated_at: z6.iso.datetime(),
+  summary_period: z6.object({
+    since: z6.string(),
+    until: z6.string(),
+    days: z6.number()
+  }),
+  recommendations: z6.array(recommendationSchema),
+  metadata: z6.object({
+    classifier_count: z6.number(),
+    patterns_evaluated: z6.number(),
+    environment_ecosystems: z6.array(z6.string()),
+    claude_code_version: z6.string()
+  })
+});
+
+// src/analysis/analyzer.ts
+var CONFIDENCE_ORDER = {
+  HIGH: 0,
+  MEDIUM: 1,
+  LOW: 2
+};
+function sortRecommendations(a, b) {
+  const confDiff = (CONFIDENCE_ORDER[a.confidence] ?? 3) - (CONFIDENCE_ORDER[b.confidence] ?? 3);
+  if (confDiff !== 0) return confDiff;
+  return b.evidence.count - a.evidence.count;
+}
+function adjustConfidence(recommendations, summaries) {
+  const rateByType = new Map(
+    summaries.map((s) => [s.pattern_type, s.persistence_rate])
+  );
+  return recommendations.map((rec) => {
+    const rate = rateByType.get(rec.pattern_type);
+    if (rate === void 0 || rate >= 0.7) return rec;
+    const downgraded = {
+      HIGH: "MEDIUM",
+      MEDIUM: "LOW",
+      LOW: "LOW"
+    };
+    return {
+      ...rec,
+      confidence: downgraded[rec.confidence] ?? rec.confidence
+    };
+  });
+}
+function analyze(summary, snapshot, config, outcomeSummaries) {
+  const mergedConfig = config ?? analysisConfigSchema.parse({});
+  const recommendations = [];
+  for (const classify of classifiers) {
+    const results = classify(summary, snapshot, mergedConfig);
+    recommendations.push(...results);
+  }
+  const adjusted = outcomeSummaries && outcomeSummaries.length > 0 ? adjustConfidence(recommendations, outcomeSummaries) : recommendations;
+  adjusted.sort(sortRecommendations);
+  const capped = adjusted.slice(0, mergedConfig.max_recommendations);
+  const patternsEvaluated = summary.top_repeated_prompts.length + summary.long_prompts.length + summary.permission_patterns.length + summary.tool_frequency.length;
+  return analysisResultSchema.parse({
+    generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    summary_period: summary.period,
+    recommendations: capped,
+    metadata: {
+      classifier_count: classifiers.length,
+      patterns_evaluated: patternsEvaluated,
+      environment_ecosystems: snapshot.detected_ecosystems,
+      claude_code_version: snapshot.claude_code.version
+    }
+  });
+}
+
+// src/analysis/outcome-tracker.ts
+import { readFile as readFile5, appendFile } from "fs/promises";
+
+// src/delivery/state.ts
+import { readFile as readFile4 } from "fs/promises";
+import writeFileAtomic5 from "write-file-atomic";
+
+// src/schemas/delivery.ts
+import { z as z7 } from "zod/v4";
+var recommendationStatusSchema = z7.enum(["pending", "applied", "dismissed"]);
+var recommendationStateEntrySchema = z7.object({
+  id: z7.string(),
+  status: recommendationStatusSchema,
+  updated_at: z7.iso.datetime(),
+  applied_details: z7.string().optional()
+});
+var recommendationStateSchema = z7.object({
+  entries: z7.array(recommendationStateEntrySchema),
+  last_updated: z7.iso.datetime()
+});
+var autoApplyLogEntrySchema = z7.object({
+  timestamp: z7.iso.datetime(),
+  recommendation_id: z7.string(),
+  target: z7.string(),
+  action: z7.string(),
+  success: z7.boolean(),
+  details: z7.string().optional(),
+  backup_path: z7.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 writeFileAtomic5(
+    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);
+}
+async function getStatusMap() {
+  const state = await loadState();
+  return new Map(state.entries.map((e) => [e.id, e.status]));
+}
+function isNodeError(err) {
+  return err instanceof Error && "code" in err;
+}
+
+// src/schemas/onboarding.ts
+import { z as z8 } from "zod/v4";
+var experienceTierSchema = z8.enum(["newcomer", "intermediate", "power_user"]);
+var experienceLevelSchema = z8.object({
+  tier: experienceTierSchema,
+  score: z8.number().min(0).max(100),
+  breakdown: z8.object({
+    hooks: z8.number(),
+    rules: z8.number(),
+    skills: z8.number(),
+    plugins: z8.number(),
+    claude_md: z8.number(),
+    ecosystems: z8.number()
+  })
+});
+var outcomeEntrySchema = z8.object({
+  recommendation_id: z8.string(),
+  pattern_type: z8.string(),
+  target: z8.string(),
+  applied_at: z8.iso.datetime(),
+  checked_at: z8.iso.datetime(),
+  persisted: z8.boolean(),
+  checks_since_applied: z8.number(),
+  outcome: z8.enum(["positive", "negative", "monitoring"])
+});
+var outcomeSummarySchema = z8.object({
+  pattern_type: z8.string(),
+  total_applied: z8.number(),
+  total_persisted: z8.number(),
+  total_reverted: z8.number(),
+  persistence_rate: z8.number()
+});
+
+// src/analysis/outcome-tracker.ts
+async function trackOutcomes(snapshot) {
+  const state = await loadState();
+  const applied = state.entries.filter((e) => e.status === "applied");
+  if (applied.length === 0) return [];
+  const history = await loadOutcomeHistory();
+  const results = [];
+  for (const entry of applied) {
+    const priorEntries = history.filter(
+      (h) => h.recommendation_id === entry.id
+    );
+    const latest = priorEntries.length > 0 ? priorEntries[priorEntries.length - 1] : void 0;
+    const checksCount = latest ? latest.checks_since_applied + 1 : 1;
+    const persisted = checkPersistence(entry, snapshot);
+    let outcome;
+    if (!persisted) {
+      outcome = "negative";
+    } else if (checksCount >= 5) {
+      outcome = "positive";
+    } else {
+      outcome = "monitoring";
+    }
+    const patternType = inferPatternType(entry.id);
+    const target = inferTarget(entry.id);
+    const outcomeEntry = {
+      recommendation_id: entry.id,
+      pattern_type: patternType,
+      target,
+      applied_at: entry.updated_at,
+      checked_at: (/* @__PURE__ */ new Date()).toISOString(),
+      persisted,
+      checks_since_applied: checksCount,
+      outcome
+    };
+    results.push(outcomeEntry);
+    await appendOutcome(outcomeEntry);
+  }
+  return results;
+}
+function checkPersistence(entry, snapshot) {
+  if (entry.applied_details) {
+    const toolMatch = entry.applied_details.match(/Added (\w+) to allowedTools/);
+    if (toolMatch) {
+      const toolName = toolMatch[1];
+      const userSettings = snapshot.settings.user;
+      if (!userSettings) return false;
+      const allowedTools = userSettings.allowedTools;
+      if (!Array.isArray(allowedTools)) return false;
+      return allowedTools.includes(toolName);
+    }
+  }
+  if (entry.id.startsWith("rec-repeated-")) {
+    return snapshot.installed_tools.hooks.length > 0;
+  }
+  if (entry.id.startsWith("rec-long-")) {
+    return snapshot.installed_tools.skills.length > 0;
+  }
+  if (entry.id.startsWith("rec-correction-")) {
+    return snapshot.installed_tools.rules.length > 0;
+  }
+  return true;
+}
+async function appendOutcome(entry) {
+  await appendFile(
+    paths.outcomeHistory,
+    JSON.stringify(entry) + "\n",
+    "utf-8"
+  );
+}
+async function loadOutcomeHistory() {
+  let raw;
+  try {
+    raw = await readFile5(paths.outcomeHistory, "utf-8");
+  } catch (err) {
+    if (isNodeError2(err) && err.code === "ENOENT") {
+      return [];
+    }
+    throw err;
+  }
+  const entries = [];
+  const lines = raw.split("\n").filter((line) => line.trim().length > 0);
+  for (const line of lines) {
+    try {
+      const parsed = JSON.parse(line);
+      const result = outcomeEntrySchema.safeParse(parsed);
+      if (result.success) {
+        entries.push(result.data);
+      }
+    } catch {
+    }
+  }
+  return entries;
+}
+function computeOutcomeSummaries(history) {
+  if (history.length === 0) return [];
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of history) {
+    const group = groups.get(entry.pattern_type) ?? [];
+    group.push(entry);
+    groups.set(entry.pattern_type, group);
+  }
+  const summaries = [];
+  for (const [patternType, entries] of groups) {
+    const latestByRec = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      latestByRec.set(entry.recommendation_id, entry);
+    }
+    let totalPersisted = 0;
+    let totalReverted = 0;
+    for (const entry of latestByRec.values()) {
+      if (entry.outcome === "positive") {
+        totalPersisted++;
+      } else if (entry.outcome === "negative") {
+        totalReverted++;
+      }
+    }
+    const totalApplied = latestByRec.size;
+    const persistenceRate = totalApplied > 0 ? totalPersisted / totalApplied : 0;
+    summaries.push({
+      pattern_type: patternType,
+      total_applied: totalApplied,
+      total_persisted: totalPersisted,
+      total_reverted: totalReverted,
+      persistence_rate: persistenceRate
+    });
+  }
+  return summaries;
+}
+function inferPatternType(id) {
+  if (id.startsWith("rec-repeated-")) return "repeated_prompt";
+  if (id.startsWith("rec-long-")) return "long_prompt";
+  if (id.startsWith("rec-permission-always-approved-")) return "permission-always-approved";
+  if (id.startsWith("rec-correction-")) return "code_correction";
+  if (id.startsWith("rec-personal-")) return "personal_info";
+  if (id.startsWith("rec-drift-")) return "config_drift";
+  if (id.startsWith("rec-ecosystem-")) return "version_update";
+  if (id.startsWith("rec-onboarding-")) return "onboarding_start_hooks";
+  if (id.startsWith("rec-tool-preference-")) return "tool-preference";
+  return "unknown";
+}
+function inferTarget(id) {
+  if (id.startsWith("rec-repeated-")) return "HOOK";
+  if (id.startsWith("rec-long-")) return "SKILL";
+  if (id.startsWith("rec-permission-always-approved-")) return "SETTINGS";
+  if (id.startsWith("rec-correction-")) return "RULE";
+  if (id.startsWith("rec-personal-")) return "MEMORY";
+  if (id.startsWith("rec-drift-")) return "CLAUDE_MD";
+  if (id.startsWith("rec-ecosystem-")) return "CLAUDE_MD";
+  if (id.startsWith("rec-tool-preference-")) return "SETTINGS";
+  if (id.startsWith("rec-onboarding-")) return "HOOK";
+  return "MEMORY";
+}
+function isNodeError2(err) {
+  return err instanceof Error && "code" in err;
+}
+
+// src/analysis/trigger.ts
+import writeFileAtomic6 from "write-file-atomic";
+import { readFile as readFile6 } from "fs/promises";
+import { lock as lock2 } from "proper-lockfile";
+var COOLDOWN_MS = 6e4;
+async function writeAnalysisResult(result) {
+  await ensureInit();
+  await writeFileAtomic6(paths.analysisResult, JSON.stringify(result, null, 2));
+}
+async function runAnalysis(cwd) {
+  const summary = await preProcess();
+  const snapshot = await scanEnvironment(cwd);
+  let outcomeSummaries;
+  try {
+    await trackOutcomes(snapshot);
+    const history = await loadOutcomeHistory();
+    outcomeSummaries = computeOutcomeSummaries(history);
+  } catch {
+  }
+  const result = analyze(summary, snapshot, void 0, outcomeSummaries);
+  await writeAnalysisResult(result);
+  return result;
+}
+async function resetCounterWithTimestamp() {
+  try {
+    await readFile6(paths.counter, "utf-8");
+  } catch {
+    const initial = {
+      total: 0,
+      session: {},
+      last_updated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await writeFileAtomic6(paths.counter, JSON.stringify(initial, null, 2));
+  }
+  const release = await lock2(paths.counter, {
+    retries: { retries: 50, minTimeout: 20, maxTimeout: 1e3, randomize: true },
+    stale: 1e4
+  });
+  try {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const data = {
+      total: 0,
+      session: {},
+      last_analysis: now,
+      last_updated: now
+    };
+    await writeFileAtomic6(paths.counter, JSON.stringify(data, null, 2));
+  } finally {
+    await release();
+  }
+}
+async function checkAndTriggerAnalysis(cwd) {
+  const config = await loadConfig();
+  if (!config.analysis.enabled) return false;
+  const counter = await readCounter();
+  if (counter.total < config.analysis.threshold) return false;
+  if (counter.last_analysis) {
+    const elapsed = Date.now() - new Date(counter.last_analysis).getTime();
+    if (elapsed < COOLDOWN_MS) return false;
+  }
+  try {
+    await runAnalysis(cwd);
+  } catch {
+    return false;
+  }
+  await resetCounterWithTimestamp();
+  return true;
+}
+
+// src/hooks/stop.ts
+async function handleStop(rawJson) {
+  try {
+    const input = stopInputSchema.parse(JSON.parse(rawJson));
+    if (input.stop_hook_active) return;
+    await checkAndTriggerAnalysis(input.cwd);
+  } catch {
+  }
+}
+async function main() {
+  try {
+    const raw = await readStdin();
+    await handleStop(raw);
+  } catch {
+  }
+  process.exit(0);
+}
+main();
+
+// src/scrubber/patterns.ts
+var SCRUB_PATTERNS = [
+  {
+    name: "aws_key",
+    regex: /AKIA[0-9A-Z]{16}/g,
+    replacement: "[REDACTED:aws_key]"
+  },
+  {
+    name: "aws_secret",
+    regex: /(?:aws_secret_access_key|AWS_SECRET_ACCESS_KEY)[\s=:]+[A-Za-z0-9/+=]{40}/g,
+    replacement: "[REDACTED:aws_secret]"
+  },
+  {
+    name: "github_token",
+    regex: /gh[ps]_[A-Za-z0-9_]{36,}/g,
+    replacement: "[REDACTED:github_token]"
+  },
+  {
+    name: "github_oauth",
+    regex: /gho_[A-Za-z0-9_]{36,}/g,
+    replacement: "[REDACTED:github_oauth]"
+  },
+  {
+    name: "bearer_token",
+    regex: /[Bb]earer\s+[A-Za-z0-9\-._~+/]+=*/g,
+    replacement: "[REDACTED:bearer_token]"
+  },
+  {
+    name: "jwt",
+    regex: /eyJ[A-Za-z0-9\-_]+\.eyJ[A-Za-z0-9\-_]+\.[A-Za-z0-9\-_]+/g,
+    replacement: "[REDACTED:jwt]"
+  },
+  {
+    name: "api_key",
+    regex: /(?:api[_-]?key|apikey)[\s=:]+['"]?[A-Za-z0-9\-._]{20,}['"]?/gi,
+    replacement: "[REDACTED:api_key]"
+  },
+  {
+    name: "secret",
+    regex: /(?:secret|SECRET)[\s=:]+['"]?[A-Za-z0-9\-._]{20,}['"]?/g,
+    replacement: "[REDACTED:secret]"
+  },
+  {
+    name: "private_key",
+    regex: /-----BEGIN (?:RSA |EC |OPENSSH |DSA )?PRIVATE KEY-----/g,
+    replacement: "[REDACTED:private_key]"
+  },
+  {
+    name: "password",
+    regex: /(?:password|passwd|pwd)[\s=:]+['"]?[^\s'"]{8,}['"]?/gi,
+    replacement: "[REDACTED:password]"
+  },
+  {
+    name: "slack_token",
+    regex: /xox[bpors]-[A-Za-z0-9-]{10,}/g,
+    replacement: "[REDACTED:slack_token]"
+  },
+  {
+    name: "google_api_key",
+    regex: /AIza[0-9A-Za-z\-_]{35}/g,
+    replacement: "[REDACTED:google_api_key]"
+  },
+  {
+    name: "stripe_key",
+    regex: /[sr]k_(?:test|live)_[A-Za-z0-9]{20,}/g,
+    replacement: "[REDACTED:stripe_key]"
+  },
+  {
+    name: "db_url",
+    regex: /(?:postgres|mysql|mongodb):\/\/[^\s]+:[^\s]+@[^\s]+/g,
+    replacement: "[REDACTED:db_url]"
+  }
+  // Pattern 15: High-entropy string detection is intentionally omitted.
+  // It requires Shannon entropy calculation and is deferred to when
+  // config.scrubbing.highEntropyDetection is enabled.
+];
+
+// src/scrubber/scrub.ts
+function scrubString(input, extraPatterns) {
+  let result = input;
+  const patterns = extraPatterns ? [...SCRUB_PATTERNS, ...extraPatterns] : SCRUB_PATTERNS;
+  for (const pattern of patterns) {
+    pattern.regex.lastIndex = 0;
+    result = result.replace(pattern.regex, pattern.replacement);
+  }
+  return result;
+}
+function scrubObject(obj, extraPatterns) {
+  if (typeof obj === "string") {
+    return scrubString(obj, extraPatterns);
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => scrubObject(item, extraPatterns));
+  }
+  if (obj !== null && typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = scrubObject(value, extraPatterns);
+    }
+    return result;
+  }
+  return obj;
+}
+
+// src/storage/logger.ts
+import { appendFile as appendFile2 } from "fs/promises";
+import { join as join4 } from "path";
+var SCHEMA_MAP = {
+  prompts: promptEntrySchema,
+  tools: toolEntrySchema,
+  permissions: permissionEntrySchema,
+  sessions: sessionEntrySchema
+};
+function getLogDir(type) {
+  return paths.logs[type];
+}
+function getLogFilePath(type, date) {
+  const dateStr = (date ?? /* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  return join4(getLogDir(type), `${dateStr}.jsonl`);
+}
+async function appendLogEntry(type, rawEntry) {
+  await ensureInit();
+  const schema = SCHEMA_MAP[type];
+  const validated = schema.parse(rawEntry);
+  const scrubbed = scrubObject(validated);
+  const line = JSON.stringify(scrubbed) + "\n";
+  const filePath = getLogFilePath(type);
+  await appendFile2(filePath, line, "utf-8");
+}
+
+// src/delivery/renderer.ts
+var TIER_ORDER = ["HIGH", "MEDIUM", "LOW"];
+function renderRecommendations(result, states) {
+  const lines = [];
+  lines.push("# harness-evolve Recommendations");
+  lines.push("");
+  lines.push(`*Generated: ${result.generated_at}*`);
+  lines.push(
+    `*Period: ${result.summary_period.since} to ${result.summary_period.until} (${result.summary_period.days} days)*`
+  );
+  lines.push("");
+  if (result.recommendations.length === 0) {
+    lines.push("No recommendations at this time.");
+    lines.push("");
+    lines.push("---");
+    lines.push("*Run /evolve to refresh or manage recommendations.*");
+    return lines.join("\n");
+  }
+  for (const tier of TIER_ORDER) {
+    const tierRecs = result.recommendations.filter(
+      (r) => r.confidence === tier
+    );
+    if (tierRecs.length === 0) continue;
+    lines.push(`## ${tier} Confidence`);
+    lines.push("");
+    for (const rec of tierRecs) {
+      const status = (states.get(rec.id) ?? "pending").toUpperCase();
+      lines.push(`### [${status}] ${rec.title}`);
+      lines.push("");
+      lines.push(`**Target:** ${rec.target} | **Pattern:** ${rec.pattern_type}`);
+      const evidenceParts = [`${rec.evidence.count} occurrences`];
+      if (rec.evidence.sessions !== void 0) {
+        evidenceParts.push(`across ${rec.evidence.sessions} sessions`);
+      }
+      lines.push(`**Evidence:** ${evidenceParts.join(" ")}`);
+      lines.push("");
+      lines.push(rec.description);
+      lines.push("");
+      if (rec.evidence.examples.length > 0) {
+        lines.push("**Examples:**");
+        for (const ex of rec.evidence.examples) {
+          lines.push(`- \`${ex}\``);
+        }
+        lines.push("");
+      }
+      lines.push(`**Suggested action:** ${rec.suggested_action}`);
+      lines.push("");
+      if (rec.ecosystem_context !== void 0) {
+        lines.push(`**Ecosystem note:** ${rec.ecosystem_context}`);
+        lines.push("");
+      }
+    }
+  }
+  lines.push("---");
+  lines.push("*Run /evolve to refresh or manage recommendations.*");
+  return lines.join("\n");
+}
+
+// src/delivery/rotator.ts
+import { mkdir as mkdir2 } from "fs/promises";
+import { join as join5 } from "path";
+import writeFileAtomic7 from "write-file-atomic";
+async function rotateRecommendations(config) {
+  const state = await loadState();
+  const cutoff = new Date(Date.now() - config.archiveAfterDays * 864e5);
+  const toArchive = state.entries.filter(
+    (e) => (e.status === "applied" || e.status === "dismissed") && new Date(e.updated_at) < cutoff
+  );
+  if (toArchive.length === 0) {
+    return;
+  }
+  const toKeep = state.entries.filter(
+    (e) => !toArchive.some((a) => a.id === e.id)
+  );
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const archivePath = join5(paths.recommendationArchive, `${today}.json`);
+  await mkdir2(paths.recommendationArchive, { recursive: true });
+  await writeFileAtomic7(archivePath, JSON.stringify(toArchive, null, 2));
+  await saveState({
+    entries: toKeep,
+    last_updated: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+
+// src/delivery/notification.ts
+import { existsSync } from "fs";
+import { readFile as readFile7, unlink, writeFile } from "fs/promises";
+function buildNotification(pendingCount) {
+  const plural = pendingCount === 1 ? "" : "s";
+  return `[harness-evolve] ${pendingCount} new suggestion${plural} found. Run /evolve:apply to review.`;
+}
+async function writeNotificationFlag(pendingCount) {
+  await writeFile(paths.notificationFlag, String(pendingCount), "utf-8");
+}
+async function hasNotificationFlag() {
+  return existsSync(paths.notificationFlag);
+}
+async function clearNotificationFlag() {
+  try {
+    await unlink(paths.notificationFlag);
+  } catch {
+  }
+}
+async function readNotificationFlagCount() {
+  try {
+    const content = await readFile7(paths.notificationFlag, "utf-8");
+    return parseInt(content.trim(), 10) || 0;
+  } catch {
+    return 0;
+  }
+}
+
+// src/delivery/auto-apply.ts
+import { appendFile as appendFile3 } from "fs/promises";
+
+// 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);
+}
+function hasApplier(target) {
+  return registry.has(target);
+}
+
+// src/delivery/appliers/settings-applier.ts
+import { readFile as readFile8, copyFile, mkdir as mkdir3 } from "fs/promises";
+import { join as join6, dirname } from "path";
+import writeFileAtomic8 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 readFile8(settingsFilePath, "utf-8");
+      const settings = JSON.parse(raw);
+      const backup = join6(
+        paths.analysis,
+        "backups",
+        `settings-backup-${rec.id}.json`
+      );
+      await mkdir3(dirname(backup), { recursive: true });
+      await copyFile(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 writeFileAtomic8(
+        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 access2, 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 access2(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 access3, mkdir as mkdir5, chmod, copyFile as copyFile2 } from "fs/promises";
+import { join as join9, basename } from "path";
+
+// src/generators/schemas.ts
+import { z as z9 } 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 YAML_SPECIAL = /[:"'{}[\]#&*!|>\\,\n]/;
+function escapeYaml(text) {
+  if (!YAML_SPECIAL.test(text)) return text;
+  return `"${text.replace(/"/g, '\\"')}"`;
+}
+var generatedArtifactSchema = z9.object({
+  type: z9.enum(["skill", "hook", "claude_md_patch"]),
+  filename: z9.string(),
+  content: z9.string(),
+  source_recommendation_id: z9.string(),
+  metadata: z9.object({
+    generated_at: z9.iso.datetime(),
+    generator_version: z9.string(),
+    pattern_type: z9.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/cli/utils.ts
+import { readFile as readFile9 } from "fs/promises";
+import { join as join8 } from "path";
+import { createInterface as createInterface2 } from "readline/promises";
+import writeFileAtomic9 from "write-file-atomic";
+var HARNESS_EVOLVE_MARKER = "harness-evolve";
+var SETTINGS_PATH = join8(
+  process.env.HOME ?? "",
+  ".claude",
+  "settings.json"
+);
+async function readSettings(settingsPath) {
+  const filePath = settingsPath ?? SETTINGS_PATH;
+  try {
+    const raw = await readFile9(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+async function writeSettings(settings, settingsPath) {
+  const filePath = settingsPath ?? SETTINGS_PATH;
+  await writeFileAtomic9(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 };
+}
+
+// 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 ?? join9(process.env.HOME ?? "", ".claude", "hooks");
+      const scriptFilename = basename(artifact.filename);
+      const scriptPath = join9(hooksDir, scriptFilename);
+      try {
+        await access3(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 ?? join9(process.env.HOME ?? "", ".claude", "settings.json");
+      const settings = await readSettings(settingsPath);
+      const backupDir = join9(paths.analysis, "backups");
+      await mkdir5(backupDir, { recursive: true });
+      const backupFile = join9(backupDir, `settings-backup-${rec.id}.json`);
+      try {
+        await copyFile2(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 readFile10, mkdir as mkdir6 } from "fs/promises";
+import { join as join10, dirname as dirname4 } from "path";
+import writeFileAtomic10 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 ?? join10(process.cwd(), "CLAUDE.md");
+      let existingContent = "";
+      try {
+        existingContent = await readFile10(claudeMdPath, "utf-8");
+      } catch {
+      }
+      if (existingContent) {
+        const backupDir = join10(paths.analysis, "backups");
+        await mkdir6(backupDir, { recursive: true });
+        const backupFile = join10(backupDir, `claudemd-backup-${rec.id}.md`);
+        await writeFileAtomic10(backupFile, existingContent);
+      }
+      const newSection = [
+        "",
+        "",
+        `## ${rec.title}`,
+        "",
+        rec.suggested_action,
+        "",
+        "---",
+        `*Auto-generated by harness-evolve (${rec.id})*`,
+        ""
+      ].join("\n");
+      const updatedContent = existingContent + newSection;
+      await mkdir6(dirname4(claudeMdPath), { recursive: true });
+      await writeFileAtomic10(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());
+async function autoApplyRecommendations(recommendations, options) {
+  const config = await loadConfig();
+  if (!config.delivery.fullAuto) return [];
+  await ensureInit();
+  const stateMap = await getStatusMap();
+  const results = [];
+  const candidates = recommendations.filter(
+    (rec) => rec.confidence === "HIGH" && hasApplier(rec.target) && (stateMap.get(rec.id) ?? "pending") === "pending"
+  );
+  for (const rec of candidates) {
+    const applier = getApplier(rec.target);
+    let result;
+    if (!applier || !applier.canApply(rec)) {
+      result = {
+        recommendation_id: rec.id,
+        success: false,
+        details: `No applicable applier for target '${rec.target}' with pattern_type '${rec.pattern_type}'`
+      };
+    } else {
+      result = await applier.apply(rec, options);
+    }
+    results.push(result);
+    const logEntry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      recommendation_id: rec.id,
+      target: rec.target,
+      action: rec.suggested_action,
+      success: result.success,
+      details: result.details,
+      backup_path: void 0
+    };
+    await appendFile3(
+      paths.autoApplyLog,
+      JSON.stringify(logEntry) + "\n",
+      "utf-8"
+    );
+    if (result.success) {
+      await updateStatus(rec.id, "applied", `Auto-applied: ${result.details}`);
+    }
+  }
+  return results;
+}
+
+// src/scan/context-builder.ts
+import { readFile as readFile11, readdir as readdir3 } from "fs/promises";
+import { join as join11, basename as basename2 } from "path";
+
+// src/scan/schemas.ts
+import { z as z10 } from "zod/v4";
+var scanContextSchema = z10.object({
+  generated_at: z10.iso.datetime(),
+  project_root: z10.string(),
+  claude_md_files: z10.array(
+    z10.object({
+      path: z10.string(),
+      scope: z10.enum(["user", "project", "local"]),
+      content: z10.string(),
+      line_count: z10.number(),
+      headings: z10.array(z10.string()),
+      references: z10.array(z10.string())
+    })
+  ),
+  rules: z10.array(
+    z10.object({
+      path: z10.string(),
+      filename: z10.string(),
+      content: z10.string(),
+      frontmatter: z10.object({
+        paths: z10.array(z10.string()).optional()
+      }).optional(),
+      headings: z10.array(z10.string())
+    })
+  ),
+  settings: z10.object({
+    user: z10.unknown().nullable(),
+    project: z10.unknown().nullable(),
+    local: z10.unknown().nullable()
+  }),
+  commands: z10.array(
+    z10.object({
+      path: z10.string(),
+      name: z10.string(),
+      content: z10.string()
+    })
+  ),
+  hooks_registered: z10.array(
+    z10.object({
+      event: z10.string(),
+      scope: z10.enum(["user", "project", "local"]),
+      type: z10.string(),
+      command: z10.string().optional()
+    })
+  )
+});
+
+// src/scan/context-builder.ts
+async function readFileSafe(path) {
+  try {
+    return await readFile11(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: join11(cwd, "CLAUDE.md"), scope: "project" },
+    { path: join11(cwd, ".claude", "CLAUDE.md"), scope: "local" },
+    { path: join11(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 readdir3(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join11(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 = join11(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: basename2(filePath),
+        content,
+        frontmatter: parseFrontmatter(content),
+        headings: extractHeadings(content)
+      });
+    }
+  }
+  return rules;
+}
+async function readAllSettings(cwd, home) {
+  const settingsPaths = {
+    user: join11(home, ".claude", "settings.json"),
+    project: join11(cwd, ".claude", "settings.json"),
+    local: join11(cwd, ".claude", "settings.local.json")
+  };
+  const readJsonSafe = async (path) => {
+    try {
+      const raw = await readFile11(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 = join11(cwd, ".claude", "commands");
+  const commands = [];
+  try {
+    const entries = await readdir3(commandsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.endsWith(".md")) {
+        const filePath = join11(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 as access4 } from "fs/promises";
+import { constants as constants2 } from "fs";
+import { resolve, dirname as dirname5 } from "path";
+async function fileExistsOnDisk(filePath) {
+  try {
+    await access4(filePath, constants2.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(dirname5(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/generators/skill-generator.ts
+function generateSkill(rec) {
+  if (rec.target !== "SKILL") return null;
+  if (rec.pattern_type !== "long_prompt") return null;
+  const promptPreview = rec.evidence.examples[0] ?? "";
+  const slugName = toSlug(rec.title);
+  const firstSentence = rec.description.split(".")[0];
+  const content = [
+    "---",
+    `name: ${escapeYaml(slugName)}`,
+    `description: ${escapeYaml(firstSentence)}`,
+    "---",
+    "",
+    `# ${rec.title}`,
+    "",
+    "## Instructions",
+    "",
+    promptPreview,
+    "",
+    "---",
+    `*Auto-generated by harness-evolve (${rec.id})*`
+  ].join("\n");
+  return {
+    type: "skill",
+    filename: `.claude/commands/${slugName}.md`,
+    content,
+    source_recommendation_id: rec.id,
+    metadata: {
+      generated_at: nowISO(),
+      generator_version: GENERATOR_VERSION,
+      pattern_type: rec.pattern_type
+    }
+  };
+}
+
+// src/generators/claude-md-generator.ts
+function buildStaleReferencePatch(rec) {
+  const staleRef = rec.evidence.examples[0] ?? "";
+  return [
+    "--- a/CLAUDE.md",
+    "+++ b/CLAUDE.md",
+    "@@ Stale reference removal @@",
+    `- ${staleRef}`,
+    `+ # (removed stale reference: ${staleRef})`
+  ].join("\n");
+}
+function buildRedundancyPatch(rec) {
+  return [
+    "--- a/CLAUDE.md",
+    "+++ b/CLAUDE.md",
+    `@@ Redundancy consolidation: ${rec.title} @@`,
+    "+ # Consolidation needed",
+    "+",
+    `+ ${rec.suggested_action}`
+  ].join("\n");
+}
+function buildGenericPatch(rec) {
+  return [
+    "--- a/CLAUDE.md",
+    "+++ b/CLAUDE.md",
+    `@@ ${rec.title} @@`,
+    `+ ## ${rec.title}`,
+    "+",
+    `+ ${rec.suggested_action}`
+  ].join("\n");
+}
+function generateClaudeMdPatch(rec) {
+  if (rec.target !== "CLAUDE_MD") return null;
+  let patchContent;
+  switch (rec.pattern_type) {
+    case "scan_stale_reference":
+      patchContent = buildStaleReferencePatch(rec);
+      break;
+    case "scan_redundancy":
+      patchContent = buildRedundancyPatch(rec);
+      break;
+    default:
+      patchContent = buildGenericPatch(rec);
+      break;
+  }
+  return {
+    type: "claude_md_patch",
+    filename: "CLAUDE.md",
+    content: patchContent,
+    source_recommendation_id: rec.id,
+    metadata: {
+      generated_at: nowISO(),
+      generator_version: GENERATOR_VERSION,
+      pattern_type: rec.pattern_type
+    }
+  };
+}
+
+// src/cli/scan.ts
+var CONFIDENCE_ORDER2 = { HIGH: 0, MEDIUM: 1, LOW: 2 };
+function registerScanCommand(program) {
+  program.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_ORDER2[a.confidence] ?? 3) - (CONFIDENCE_ORDER2[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 readFile12, appendFile as appendFile4 } from "fs/promises";
+var CONFIDENCE_ORDER3 = { HIGH: 0, MEDIUM: 1, LOW: 2 };
+async function loadAnalysisResult() {
+  try {
+    const raw = await readFile12(paths.analysisResult, "utf-8");
+    const parsed = analysisResultSchema.parse(JSON.parse(raw));
+    return parsed.recommendations;
+  } catch {
+    return [];
+  }
+}
+function registerPendingCommand(program) {
+  program.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_ORDER3[a.confidence] ?? 3) - (CONFIDENCE_ORDER3[b.confidence] ?? 3)
+    );
+    console.log(JSON.stringify({ pending, count: pending.length }, null, 2));
+  });
+}
+function registerApplyOneCommand(program) {
+  program.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 appendFile4(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(program) {
+  program.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;
+    }
+  });
+}
+export {
+  ClaudeMdApplier,
+  GENERATOR_VERSION,
+  HookApplier,
+  SCRUB_PATTERNS,
+  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,
+  handleStop,
+  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
+};
+//# sourceMappingURL=index.js.map