harness-evolve 1.0.0

package/dist/delivery/run-evolve.js

@@ -0,0 +1,2069 @@
+// src/storage/counter.ts
+import { readFile } from "fs/promises";
+import { lock } from "proper-lockfile";
+import writeFileAtomic from "write-file-atomic";
+
+// src/schemas/counter.ts
+import { z } from "zod/v4";
+var counterSchema = z.object({
+  total: z.number().default(0),
+  session: z.record(z.string(), z.number()).default({}),
+  last_analysis: z.iso.datetime().optional(),
+  last_updated: z.iso.datetime()
+});
+
+// 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/config.ts
+import { readFile as readFile2 } from "fs/promises";
+import writeFileAtomic2 from "write-file-atomic";
+
+// src/schemas/config.ts
+import { z as z2 } from "zod/v4";
+var configSchema = z2.object({
+  version: z2.number().default(1),
+  analysis: z2.object({
+    threshold: z2.number().min(1).default(50),
+    enabled: z2.boolean().default(true),
+    classifierThresholds: z2.record(z2.string(), z2.number()).default({})
+  }).default({ threshold: 50, enabled: true, classifierThresholds: {} }),
+  hooks: z2.object({
+    capturePrompts: z2.boolean().default(true),
+    captureTools: z2.boolean().default(true),
+    capturePermissions: z2.boolean().default(true),
+    captureSessions: z2.boolean().default(true)
+  }).default({
+    capturePrompts: true,
+    captureTools: true,
+    capturePermissions: true,
+    captureSessions: true
+  }),
+  scrubbing: z2.object({
+    enabled: z2.boolean().default(true),
+    highEntropyDetection: z2.boolean().default(false),
+    customPatterns: z2.array(z2.object({
+      name: z2.string(),
+      regex: z2.string(),
+      replacement: z2.string()
+    })).default([])
+  }).default({
+    enabled: true,
+    highEntropyDetection: false,
+    customPatterns: []
+  }),
+  delivery: z2.object({
+    stdoutInjection: z2.boolean().default(true),
+    maxTokens: z2.number().default(200),
+    fullAuto: z2.boolean().default(false),
+    maxRecommendationsInFile: z2.number().default(20),
+    archiveAfterDays: z2.number().default(7)
+  }).default({
+    stdoutInjection: true,
+    maxTokens: 200,
+    fullAuto: false,
+    maxRecommendationsInFile: 20,
+    archiveAfterDays: 7
+  })
+}).strict();
+
+// src/storage/config.ts
+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 z3 } from "zod/v4";
+var summarySchema = z3.object({
+  generated_at: z3.iso.datetime(),
+  period: z3.object({
+    since: z3.string(),
+    // YYYY-MM-DD
+    until: z3.string(),
+    // YYYY-MM-DD
+    days: z3.number()
+  }),
+  stats: z3.object({
+    total_prompts: z3.number(),
+    total_tool_uses: z3.number(),
+    total_permissions: z3.number(),
+    unique_sessions: z3.number()
+  }),
+  top_repeated_prompts: z3.array(
+    z3.object({
+      prompt: z3.string(),
+      count: z3.number(),
+      sessions: z3.number()
+    })
+  ).max(20),
+  tool_frequency: z3.array(
+    z3.object({
+      tool_name: z3.string(),
+      count: z3.number(),
+      avg_duration_ms: z3.number().optional()
+    })
+  ),
+  permission_patterns: z3.array(
+    z3.object({
+      tool_name: z3.string(),
+      count: z3.number(),
+      sessions: z3.number()
+    })
+  ),
+  long_prompts: z3.array(
+    z3.object({
+      prompt_preview: z3.string(),
+      length: z3.number(),
+      count: z3.number()
+    })
+  ).max(10)
+});
+var environmentSnapshotSchema = z3.object({
+  generated_at: z3.iso.datetime(),
+  claude_code: z3.object({
+    version: z3.string(),
+    version_known: z3.boolean(),
+    compatible: z3.boolean()
+  }),
+  settings: z3.object({
+    user: z3.unknown().nullable(),
+    project: z3.unknown().nullable(),
+    local: z3.unknown().nullable()
+  }),
+  installed_tools: z3.object({
+    plugins: z3.array(
+      z3.object({
+        name: z3.string(),
+        marketplace: z3.string(),
+        enabled: z3.boolean(),
+        scope: z3.string(),
+        capabilities: z3.array(z3.string())
+      })
+    ),
+    skills: z3.array(
+      z3.object({
+        name: z3.string(),
+        scope: z3.enum(["user", "project"])
+      })
+    ),
+    rules: z3.array(
+      z3.object({
+        name: z3.string(),
+        scope: z3.enum(["user", "project"])
+      })
+    ),
+    hooks: z3.array(
+      z3.object({
+        event: z3.string(),
+        scope: z3.enum(["user", "project", "local"]),
+        type: z3.string()
+      })
+    ),
+    claude_md: z3.array(
+      z3.object({
+        path: z3.string(),
+        exists: z3.boolean()
+      })
+    )
+  }),
+  detected_ecosystems: z3.array(z3.string())
+});
+
+// src/schemas/log-entry.ts
+import { z as z4 } from "zod/v4";
+var promptEntrySchema = z4.object({
+  timestamp: z4.iso.datetime(),
+  session_id: z4.string(),
+  cwd: z4.string(),
+  prompt: z4.string(),
+  prompt_length: z4.number(),
+  transcript_path: z4.string().optional()
+});
+var toolEntrySchema = z4.object({
+  timestamp: z4.iso.datetime(),
+  session_id: z4.string(),
+  event: z4.enum(["pre", "post", "failure"]),
+  tool_name: z4.string(),
+  input_summary: z4.string().optional(),
+  duration_ms: z4.number().optional(),
+  success: z4.boolean().optional()
+});
+var permissionEntrySchema = z4.object({
+  timestamp: z4.iso.datetime(),
+  session_id: z4.string(),
+  tool_name: z4.string(),
+  decision: z4.enum(["approved", "denied", "unknown"])
+});
+var sessionEntrySchema = z4.object({
+  timestamp: z4.iso.datetime(),
+  session_id: z4.string(),
+  event: z4.enum(["start", "end"]),
+  cwd: z4.string().optional()
+});
+
+// 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 truncate(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 = truncate(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 z5 } from "zod/v4";
+var routingTargetSchema = z5.enum([
+  "HOOK",
+  "SKILL",
+  "RULE",
+  "CLAUDE_MD",
+  "MEMORY",
+  "SETTINGS"
+]);
+var confidenceSchema = z5.enum(["HIGH", "MEDIUM", "LOW"]);
+var patternTypeSchema = z5.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 = z5.object({
+  id: z5.string(),
+  target: routingTargetSchema,
+  confidence: confidenceSchema,
+  pattern_type: patternTypeSchema,
+  title: z5.string(),
+  description: z5.string(),
+  evidence: z5.object({
+    count: z5.number(),
+    sessions: z5.number().optional(),
+    examples: z5.array(z5.string()).max(3)
+  }),
+  suggested_action: z5.string(),
+  ecosystem_context: z5.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 = z5.object({
+  thresholds: z5.object({
+    repeated_prompt_min_count: z5.number().default(DEFAULT_THRESHOLDS.repeated_prompt_min_count),
+    repeated_prompt_high_count: z5.number().default(DEFAULT_THRESHOLDS.repeated_prompt_high_count),
+    repeated_prompt_high_sessions: z5.number().default(DEFAULT_THRESHOLDS.repeated_prompt_high_sessions),
+    repeated_prompt_medium_sessions: z5.number().default(DEFAULT_THRESHOLDS.repeated_prompt_medium_sessions),
+    long_prompt_min_words: z5.number().default(DEFAULT_THRESHOLDS.long_prompt_min_words),
+    long_prompt_min_count: z5.number().default(DEFAULT_THRESHOLDS.long_prompt_min_count),
+    long_prompt_high_words: z5.number().default(DEFAULT_THRESHOLDS.long_prompt_high_words),
+    long_prompt_high_count: z5.number().default(DEFAULT_THRESHOLDS.long_prompt_high_count),
+    permission_approval_min_count: z5.number().default(DEFAULT_THRESHOLDS.permission_approval_min_count),
+    permission_approval_min_sessions: z5.number().default(DEFAULT_THRESHOLDS.permission_approval_min_sessions),
+    permission_approval_high_count: z5.number().default(DEFAULT_THRESHOLDS.permission_approval_high_count),
+    permission_approval_high_sessions: z5.number().default(DEFAULT_THRESHOLDS.permission_approval_high_sessions),
+    code_correction_min_failure_rate: z5.number().default(DEFAULT_THRESHOLDS.code_correction_min_failure_rate),
+    code_correction_min_failures: z5.number().default(DEFAULT_THRESHOLDS.code_correction_min_failures)
+  }).default(() => ({ ...DEFAULT_THRESHOLDS })),
+  max_recommendations: z5.number().default(20)
+}).default(() => ({
+  thresholds: { ...DEFAULT_THRESHOLDS },
+  max_recommendations: 20
+}));
+var analysisResultSchema = z5.object({
+  generated_at: z5.iso.datetime(),
+  summary_period: z5.object({
+    since: z5.string(),
+    until: z5.string(),
+    days: z5.number()
+  }),
+  recommendations: z5.array(recommendationSchema),
+  metadata: z5.object({
+    classifier_count: z5.number(),
+    patterns_evaluated: z5.number(),
+    environment_ecosystems: z5.array(z5.string()),
+    claude_code_version: z5.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 z6 } from "zod/v4";
+var recommendationStatusSchema = z6.enum(["pending", "applied", "dismissed"]);
+var recommendationStateEntrySchema = z6.object({
+  id: z6.string(),
+  status: recommendationStatusSchema,
+  updated_at: z6.iso.datetime(),
+  applied_details: z6.string().optional()
+});
+var recommendationStateSchema = z6.object({
+  entries: z6.array(recommendationStateEntrySchema),
+  last_updated: z6.iso.datetime()
+});
+var autoApplyLogEntrySchema = z6.object({
+  timestamp: z6.iso.datetime(),
+  recommendation_id: z6.string(),
+  target: z6.string(),
+  action: z6.string(),
+  success: z6.boolean(),
+  details: z6.string().optional(),
+  backup_path: z6.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 z7 } from "zod/v4";
+var experienceTierSchema = z7.enum(["newcomer", "intermediate", "power_user"]);
+var experienceLevelSchema = z7.object({
+  tier: experienceTierSchema,
+  score: z7.number().min(0).max(100),
+  breakdown: z7.object({
+    hooks: z7.number(),
+    rules: z7.number(),
+    skills: z7.number(),
+    plugins: z7.number(),
+    claude_md: z7.number(),
+    ecosystems: z7.number()
+  })
+});
+var outcomeEntrySchema = z7.object({
+  recommendation_id: z7.string(),
+  pattern_type: z7.string(),
+  target: z7.string(),
+  applied_at: z7.iso.datetime(),
+  checked_at: z7.iso.datetime(),
+  persisted: z7.boolean(),
+  checks_since_applied: z7.number(),
+  outcome: z7.enum(["positive", "negative", "monitoring"])
+});
+var outcomeSummarySchema = z7.object({
+  pattern_type: z7.string(),
+  total_applied: z7.number(),
+  total_persisted: z7.number(),
+  total_reverted: z7.number(),
+  persistence_rate: z7.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";
+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;
+}
+
+// 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 join4 } 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 = join4(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";
+async function writeNotificationFlag(pendingCount) {
+  await writeFile(paths.notificationFlag, String(pendingCount), "utf-8");
+}
+
+// src/delivery/auto-apply.ts
+import { appendFile as appendFile2 } 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 join5, 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 ?? join5(process.env.HOME ?? "", ".claude", "settings.json");
+      const raw = await readFile8(settingsFilePath, "utf-8");
+      const settings = JSON.parse(raw);
+      const backup = join5(
+        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 join6 } from "path";
+var RuleApplier = class {
+  target = "RULE";
+  canApply(rec) {
+    return rec.confidence === "HIGH" && rec.target === "RULE";
+  }
+  async apply(rec, options) {
+    const rulesDir = options?.rulesDir ?? join6(process.env.HOME ?? "", ".claude", "rules");
+    const fileName = `evolve-${rec.pattern_type}.md`;
+    const filePath = join6(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 join8, basename } from "path";
+
+// src/generators/schemas.ts
+import { z as z8 } from "zod/v4";
+var GENERATOR_VERSION = "1.0.0";
+function nowISO() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function toSlug(text) {
+  if (!text) return "";
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 50);
+}
+var generatedArtifactSchema = z8.object({
+  type: z8.enum(["skill", "hook", "claude_md_patch"]),
+  filename: z8.string(),
+  content: z8.string(),
+  source_recommendation_id: z8.string(),
+  metadata: z8.object({
+    generated_at: z8.iso.datetime(),
+    generator_version: z8.string(),
+    pattern_type: z8.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 join7 } from "path";
+import { createInterface as createInterface2 } from "readline/promises";
+import writeFileAtomic9 from "write-file-atomic";
+var HARNESS_EVOLVE_MARKER = "harness-evolve";
+var SETTINGS_PATH = join7(
+  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 ?? join8(process.env.HOME ?? "", ".claude", "hooks");
+      const scriptFilename = basename(artifact.filename);
+      const scriptPath = join8(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 ?? join8(process.env.HOME ?? "", ".claude", "settings.json");
+      const settings = await readSettings(settingsPath);
+      const backupDir = join8(paths.analysis, "backups");
+      await mkdir5(backupDir, { recursive: true });
+      const backupFile = join8(backupDir, `settings-backup-${rec.id}.json`);
+      try {
+        await 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 join9, 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 ?? join9(process.cwd(), "CLAUDE.md");
+      let existingContent = "";
+      try {
+        existingContent = await readFile10(claudeMdPath, "utf-8");
+      } catch {
+      }
+      if (existingContent) {
+        const backupDir = join9(paths.analysis, "backups");
+        await mkdir6(backupDir, { recursive: true });
+        const backupFile = join9(backupDir, `claudemd-backup-${rec.id}.md`);
+        await 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 appendFile2(
+      paths.autoApplyLog,
+      JSON.stringify(logEntry) + "\n",
+      "utf-8"
+    );
+    if (result.success) {
+      await updateStatus(rec.id, "applied", `Auto-applied: ${result.details}`);
+    }
+  }
+  return results;
+}
+
+// src/delivery/run-evolve.ts
+import writeFileAtomic11 from "write-file-atomic";
+async function main() {
+  const cwd = process.argv[2] || process.cwd();
+  await ensureInit();
+  const config = await loadConfig();
+  const result = await runAnalysis(cwd);
+  const stateMap = await getStatusMap();
+  await rotateRecommendations({
+    maxRecommendationsInFile: config.delivery.maxRecommendationsInFile,
+    archiveAfterDays: config.delivery.archiveAfterDays
+  });
+  const markdown = renderRecommendations(result, stateMap);
+  await writeFileAtomic11(paths.recommendations, markdown);
+  try {
+    await autoApplyRecommendations(result.recommendations);
+  } catch {
+  }
+  const updatedStateMap = await getStatusMap();
+  const pendingCount = result.recommendations.filter(
+    (r) => (updatedStateMap.get(r.id) ?? "pending") === "pending"
+  ).length;
+  if (pendingCount > 0) {
+    await writeNotificationFlag(pendingCount);
+  }
+  const pending = result.recommendations.filter(
+    (r) => (updatedStateMap.get(r.id) ?? "pending") === "pending"
+  );
+  console.log(
+    JSON.stringify({
+      total: result.recommendations.length,
+      pending: pending.length,
+      high: pending.filter((r) => r.confidence === "HIGH").length,
+      medium: pending.filter((r) => r.confidence === "MEDIUM").length,
+      low: pending.filter((r) => r.confidence === "LOW").length,
+      file: paths.recommendations
+    })
+  );
+}
+main().catch(() => process.exit(1));
+//# sourceMappingURL=run-evolve.js.map