harness-evolve 1.0.0

package/dist/hooks/stop.js

@@ -0,0 +1,1609 @@
+// src/schemas/hook-input.ts
+import { z } from "zod/v4";
+var hookCommonSchema = z.object({
+  session_id: z.string(),
+  transcript_path: z.string(),
+  cwd: z.string(),
+  permission_mode: z.string()
+});
+var userPromptSubmitInputSchema = hookCommonSchema.extend({
+  hook_event_name: z.literal("UserPromptSubmit"),
+  prompt: z.string()
+});
+var preToolUseInputSchema = hookCommonSchema.extend({
+  hook_event_name: z.literal("PreToolUse"),
+  tool_name: z.string(),
+  tool_input: z.record(z.string(), z.unknown()),
+  tool_use_id: z.string()
+});
+var postToolUseInputSchema = hookCommonSchema.extend({
+  hook_event_name: z.literal("PostToolUse"),
+  tool_name: z.string(),
+  tool_input: z.record(z.string(), z.unknown()),
+  tool_response: z.unknown().optional(),
+  tool_use_id: z.string()
+});
+var postToolUseFailureInputSchema = hookCommonSchema.extend({
+  hook_event_name: z.literal("PostToolUseFailure"),
+  tool_name: z.string(),
+  tool_input: z.record(z.string(), z.unknown()),
+  tool_use_id: z.string(),
+  error: z.string().optional(),
+  is_interrupt: z.boolean().optional()
+});
+var permissionRequestInputSchema = hookCommonSchema.extend({
+  hook_event_name: z.literal("PermissionRequest"),
+  tool_name: z.string(),
+  tool_input: z.record(z.string(), z.unknown()),
+  permission_suggestions: z.array(z.unknown()).optional()
+});
+var stopInputSchema = hookCommonSchema.extend({
+  hook_event_name: z.literal("Stop"),
+  stop_hook_active: z.boolean(),
+  last_assistant_message: z.string().optional()
+});
+
+// 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 as z2 } from "zod/v4";
+var counterSchema = z2.object({
+  total: z2.number().default(0),
+  session: z2.record(z2.string(), z2.number()).default({}),
+  last_analysis: z2.iso.datetime().optional(),
+  last_updated: z2.iso.datetime()
+});
+
+// src/storage/dirs.ts
+import { mkdir } 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()
+    };
+  }
+}
+
+// src/storage/config.ts
+import { readFile as readFile2 } from "fs/promises";
+import writeFileAtomic2 from "write-file-atomic";
+
+// src/schemas/config.ts
+import { z as z3 } from "zod/v4";
+var configSchema = z3.object({
+  version: z3.number().default(1),
+  analysis: z3.object({
+    threshold: z3.number().min(1).default(50),
+    enabled: z3.boolean().default(true),
+    classifierThresholds: z3.record(z3.string(), z3.number()).default({})
+  }).default({ threshold: 50, enabled: true, classifierThresholds: {} }),
+  hooks: z3.object({
+    capturePrompts: z3.boolean().default(true),
+    captureTools: z3.boolean().default(true),
+    capturePermissions: z3.boolean().default(true),
+    captureSessions: z3.boolean().default(true)
+  }).default({
+    capturePrompts: true,
+    captureTools: true,
+    capturePermissions: true,
+    captureSessions: true
+  }),
+  scrubbing: z3.object({
+    enabled: z3.boolean().default(true),
+    highEntropyDetection: z3.boolean().default(false),
+    customPatterns: z3.array(z3.object({
+      name: z3.string(),
+      regex: z3.string(),
+      replacement: z3.string()
+    })).default([])
+  }).default({
+    enabled: true,
+    highEntropyDetection: false,
+    customPatterns: []
+  }),
+  delivery: z3.object({
+    stdoutInjection: z3.boolean().default(true),
+    maxTokens: z3.number().default(200),
+    fullAuto: z3.boolean().default(false),
+    maxRecommendationsInFile: z3.number().default(20),
+    archiveAfterDays: z3.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 z4 } from "zod/v4";
+var summarySchema = z4.object({
+  generated_at: z4.iso.datetime(),
+  period: z4.object({
+    since: z4.string(),
+    // YYYY-MM-DD
+    until: z4.string(),
+    // YYYY-MM-DD
+    days: z4.number()
+  }),
+  stats: z4.object({
+    total_prompts: z4.number(),
+    total_tool_uses: z4.number(),
+    total_permissions: z4.number(),
+    unique_sessions: z4.number()
+  }),
+  top_repeated_prompts: z4.array(
+    z4.object({
+      prompt: z4.string(),
+      count: z4.number(),
+      sessions: z4.number()
+    })
+  ).max(20),
+  tool_frequency: z4.array(
+    z4.object({
+      tool_name: z4.string(),
+      count: z4.number(),
+      avg_duration_ms: z4.number().optional()
+    })
+  ),
+  permission_patterns: z4.array(
+    z4.object({
+      tool_name: z4.string(),
+      count: z4.number(),
+      sessions: z4.number()
+    })
+  ),
+  long_prompts: z4.array(
+    z4.object({
+      prompt_preview: z4.string(),
+      length: z4.number(),
+      count: z4.number()
+    })
+  ).max(10)
+});
+var environmentSnapshotSchema = z4.object({
+  generated_at: z4.iso.datetime(),
+  claude_code: z4.object({
+    version: z4.string(),
+    version_known: z4.boolean(),
+    compatible: z4.boolean()
+  }),
+  settings: z4.object({
+    user: z4.unknown().nullable(),
+    project: z4.unknown().nullable(),
+    local: z4.unknown().nullable()
+  }),
+  installed_tools: z4.object({
+    plugins: z4.array(
+      z4.object({
+        name: z4.string(),
+        marketplace: z4.string(),
+        enabled: z4.boolean(),
+        scope: z4.string(),
+        capabilities: z4.array(z4.string())
+      })
+    ),
+    skills: z4.array(
+      z4.object({
+        name: z4.string(),
+        scope: z4.enum(["user", "project"])
+      })
+    ),
+    rules: z4.array(
+      z4.object({
+        name: z4.string(),
+        scope: z4.enum(["user", "project"])
+      })
+    ),
+    hooks: z4.array(
+      z4.object({
+        event: z4.string(),
+        scope: z4.enum(["user", "project", "local"]),
+        type: z4.string()
+      })
+    ),
+    claude_md: z4.array(
+      z4.object({
+        path: z4.string(),
+        exists: z4.boolean()
+      })
+    )
+  }),
+  detected_ecosystems: z4.array(z4.string())
+});
+
+// src/schemas/log-entry.ts
+import { z as z5 } from "zod/v4";
+var promptEntrySchema = z5.object({
+  timestamp: z5.iso.datetime(),
+  session_id: z5.string(),
+  cwd: z5.string(),
+  prompt: z5.string(),
+  prompt_length: z5.number(),
+  transcript_path: z5.string().optional()
+});
+var toolEntrySchema = z5.object({
+  timestamp: z5.iso.datetime(),
+  session_id: z5.string(),
+  event: z5.enum(["pre", "post", "failure"]),
+  tool_name: z5.string(),
+  input_summary: z5.string().optional(),
+  duration_ms: z5.number().optional(),
+  success: z5.boolean().optional()
+});
+var permissionEntrySchema = z5.object({
+  timestamp: z5.iso.datetime(),
+  session_id: z5.string(),
+  tool_name: z5.string(),
+  decision: z5.enum(["approved", "denied", "unknown"])
+});
+var sessionEntrySchema = z5.object({
+  timestamp: z5.iso.datetime(),
+  session_id: z5.string(),
+  event: z5.enum(["start", "end"]),
+  cwd: z5.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 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;
+  }
+}
+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/shared.ts
+function readFromStream(stream) {
+  return new Promise((resolve, reject) => {
+    let data = "";
+    stream.setEncoding("utf-8");
+    stream.on("data", (chunk) => {
+      data += chunk;
+    });
+    stream.on("end", () => resolve(data));
+    stream.on("error", reject);
+  });
+}
+function readStdin() {
+  return readFromStream(process.stdin);
+}
+
+// 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();
+export {
+  handleStop
+};
+//# sourceMappingURL=stop.js.map