caik-cli 0.1.1 → 0.6.0

package/dist/chunk-H2ZKCXMJ.js

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+import {
+  __esm,
+  __export
+} from "./chunk-ZLRN7Q7C.js";
+
+// src/daemon/db.ts
+var db_exports = {};
+__export(db_exports, {
+  closeDb: () => closeDb,
+  getDb: () => getDb,
+  getDefaultDbPath: () => getDefaultDbPath,
+  initSchema: () => initSchema,
+  openDb: () => openDb
+});
+import Database from "better-sqlite3";
+import { mkdirSync, existsSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+function getDefaultDbPath() {
+  return join(homedir(), ".caik", "autoresearch.db");
+}
+function openDb(dbPath) {
+  const path = dbPath ?? getDefaultDbPath();
+  const dir = dirname(path);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true, mode: 448 });
+  }
+  const db = new Database(path);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  db.pragma("busy_timeout = 5000");
+  return db;
+}
+function getDb(dbPath) {
+  if (!_db) {
+    _db = openDb(dbPath);
+    initSchema(_db);
+  }
+  return _db;
+}
+function closeDb() {
+  if (_db) {
+    _db.close();
+    _db = null;
+  }
+}
+function initSchema(db) {
+  db.exec(`
+    -- Session buffer: ephemeral tool calls captured during a session
+    CREATE TABLE IF NOT EXISTS session_buffer (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      type TEXT NOT NULL CHECK(type IN ('tool_call', 'correction', 'prompt')),
+      timestamp TEXT NOT NULL,
+      tool_name TEXT,
+      tool_input TEXT,
+      tool_response TEXT,
+      prompt TEXT,
+      correction_type TEXT,
+      slug TEXT,
+      success INTEGER
+    );
+    CREATE INDEX IF NOT EXISTS idx_buffer_session ON session_buffer(session_id);
+
+    -- Traces: permanent records of corrections and sampled successes
+    CREATE TABLE IF NOT EXISTS traces (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      slug TEXT NOT NULL,
+      timestamp TEXT NOT NULL,
+      kind TEXT NOT NULL CHECK(kind IN ('correction', 'success')),
+      tool_name TEXT NOT NULL,
+      tool_input TEXT,
+      tool_response TEXT,
+      correction_type TEXT,
+      correction_prompt TEXT,
+      skill_content_hash TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_traces_slug ON traces(slug);
+    CREATE INDEX IF NOT EXISTS idx_traces_slug_kind ON traces(slug, kind);
+
+    -- Eval suites: one per skill, tracks validation state
+    CREATE TABLE IF NOT EXISTS eval_suites (
+      slug TEXT PRIMARY KEY,
+      version INTEGER NOT NULL DEFAULT 1,
+      tpr REAL,
+      tnr REAL,
+      validation_sample_size INTEGER,
+      validated_at TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    -- Eval cases: individual test assertions linked to a suite
+    CREATE TABLE IF NOT EXISTS eval_cases (
+      id TEXT PRIMARY KEY,
+      suite_slug TEXT NOT NULL REFERENCES eval_suites(slug) ON DELETE CASCADE,
+      trace_id TEXT REFERENCES traces(id),
+      source TEXT NOT NULL CHECK(source IN ('trace', 'synthetic')),
+      category TEXT NOT NULL,
+      assertion_type TEXT NOT NULL,
+      assertion_value TEXT NOT NULL,
+      description TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_cases_suite ON eval_cases(suite_slug);
+
+    -- Loop results: archive of every autoresearch run
+    CREATE TABLE IF NOT EXISTS loop_results (
+      id TEXT PRIMARY KEY,
+      slug TEXT NOT NULL,
+      baseline_pass_rate REAL NOT NULL,
+      best_pass_rate REAL NOT NULL,
+      baseline_pass_count INTEGER NOT NULL,
+      best_pass_count INTEGER NOT NULL,
+      total_cases INTEGER NOT NULL,
+      iterations INTEGER NOT NULL,
+      total_llm_calls INTEGER NOT NULL,
+      duration_ms INTEGER NOT NULL,
+      strategies TEXT NOT NULL,
+      best_content TEXT,
+      applied INTEGER NOT NULL DEFAULT 0,
+      rolled_back INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_results_slug ON loop_results(slug, created_at);
+
+    -- Observations: persistent tool call records from hooks
+    CREATE TABLE IF NOT EXISTS observations (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      slug TEXT NOT NULL,
+      tool TEXT NOT NULL,
+      success INTEGER NOT NULL,
+      platform TEXT,
+      correction_type TEXT,
+      correction_source TEXT,
+      timestamp TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_obs_session ON observations(session_id);
+    CREATE INDEX IF NOT EXISTS idx_obs_slug ON observations(slug);
+    CREATE INDEX IF NOT EXISTS idx_obs_timestamp ON observations(timestamp);
+
+    -- Pending events: queue for API posting with retry
+    CREATE TABLE IF NOT EXISTS pending_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      payload TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    -- Session context: per-session state (fingerprint, model) for session-end
+    CREATE TABLE IF NOT EXISTS session_context (
+      session_id TEXT PRIMARY KEY,
+      stack_fingerprint TEXT,
+      repo_scale TEXT,
+      agent_model TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    -- Session engagement: per-artifact call counts within a session
+    CREATE TABLE IF NOT EXISTS session_engagement (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      slug TEXT NOT NULL,
+      count INTEGER NOT NULL DEFAULT 0,
+      UNIQUE(session_id, slug)
+    );
+    CREATE INDEX IF NOT EXISTS idx_engagement_session ON session_engagement(session_id);
+
+    -- Retention checks: last check timestamp per artifact slug
+    CREATE TABLE IF NOT EXISTS retention_checks (
+      slug TEXT PRIMARY KEY,
+      last_checked_at INTEGER NOT NULL
+    );
+
+    -- Session-end dedup: track which sessions have already buffered a session_end
+    CREATE TABLE IF NOT EXISTS session_end_sent (
+      session_id TEXT PRIMARY KEY,
+      pending_event_id INTEGER,
+      sent_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+  `);
+}
+var _db;
+var init_db = __esm({
+  "src/daemon/db.ts"() {
+    _db = null;
+  }
+});
+
+export {
+  getDefaultDbPath,
+  openDb,
+  getDb,
+  closeDb,
+  initSchema,
+  db_exports,
+  init_db
+};

package/dist/chunk-ILMOSMD3.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+import {
+  mapHttpError,
+  mapNetworkError
+} from "./chunk-2YHUDOJL.js";
+
+// src/api.ts
+var CaikApiClient = class {
+  baseUrl;
+  apiKey;
+  verbose;
+  constructor(config) {
+    this.baseUrl = config.apiUrl.replace(/\/+$/, "");
+    this.apiKey = config.apiKey;
+    this.verbose = config.verbose ?? false;
+  }
+  async get(path, params) {
+    const url = new URL(`${this.baseUrl}/api/v1${path}`);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return this.request(url.toString(), { method: "GET" });
+  }
+  async post(path, body) {
+    return this.request(`${this.baseUrl}/api/v1${path}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+  }
+  async patch(path, body) {
+    return this.request(`${this.baseUrl}/api/v1${path}`, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+  }
+  async del(path) {
+    return this.request(`${this.baseUrl}/api/v1${path}`, { method: "DELETE" });
+  }
+  async request(url, init) {
+    const headers = {
+      ...init.headers
+    };
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    if (this.verbose) {
+      console.error(`[verbose] ${init.method} ${url}`);
+    }
+    const start = Date.now();
+    let response;
+    try {
+      response = await fetch(url, { ...init, headers });
+    } catch (err) {
+      throw mapNetworkError(err);
+    }
+    if (this.verbose) {
+      console.error(`[verbose] ${response.status} (${Date.now() - start}ms)`);
+    }
+    if (!response.ok) {
+      let body;
+      try {
+        body = await response.json();
+      } catch {
+        body = await response.text().catch(() => null);
+      }
+      throw mapHttpError(response.status, body);
+    }
+    if (response.status === 204) {
+      return void 0;
+    }
+    return response.json();
+  }
+};
+
+export {
+  CaikApiClient
+};

package/dist/chunk-KYTHKH6V.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+
+// src/config.ts
+import { readFileSync, writeFileSync, mkdirSync, chmodSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var CONTRIBUTION_LEVELS = [
+  { value: "none", name: "None", description: "Nothing sent. Directory access only." },
+  { value: "minimal", name: "Minimal", description: "Install/uninstall + engagement + retention. Basic recommendations." },
+  { value: "contributor", name: "Contributor", description: "Error/success signals + co-installs. Full recommendations. (default)" },
+  { value: "collective", name: "Collective", description: "Stack context + session shape + workflow patterns. Proactive recommendations + leaderboard." }
+];
+var DEFAULT_CONFIG = {
+  apiUrl: "https://www.caik.dev",
+  defaultLimit: 10,
+  version: 1
+};
+function getConfigDir() {
+  return join(homedir(), ".caik");
+}
+function getConfigPath() {
+  return join(getConfigDir(), "config.json");
+}
+function readConfig() {
+  const path = getConfigPath();
+  if (!existsSync(path)) {
+    return { ...DEFAULT_CONFIG };
+  }
+  try {
+    const raw = readFileSync(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    return { ...DEFAULT_CONFIG, ...parsed };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function writeConfig(config) {
+  const dir = getConfigDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true, mode: 448 });
+  }
+  const path = getConfigPath();
+  writeFileSync(path, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  chmodSync(path, 384);
+}
+function getOrCreateInstallationId() {
+  const config = readConfig();
+  if (config.installationId) return config.installationId;
+  const id = `inst_${globalThis.crypto.randomUUID().replace(/-/g, "").slice(0, 16)}`;
+  writeConfig({ ...config, installationId: id });
+  return id;
+}
+function getApiKey() {
+  return process.env.CAIK_API_KEY ?? readConfig().apiKey;
+}
+function setApiKey(key) {
+  const config = readConfig();
+  config.apiKey = key;
+  writeConfig(config);
+}
+function resolveConfig(opts) {
+  const config = readConfig();
+  return {
+    apiUrl: opts.apiUrl ?? process.env.CAIK_API_URL ?? config.apiUrl ?? DEFAULT_CONFIG.apiUrl,
+    apiKey: opts.apiKey ?? process.env.CAIK_API_KEY ?? config.apiKey
+  };
+}
+
+export {
+  CONTRIBUTION_LEVELS,
+  getConfigDir,
+  getConfigPath,
+  readConfig,
+  writeConfig,
+  getOrCreateInstallationId,
+  getApiKey,
+  setApiKey,
+  resolveConfig
+};

package/dist/chunk-LTKHLRM4.js

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+import {
+  runEvalSuite
+} from "./chunk-D4IM3YRX.js";
+import {
+  callAnthropic
+} from "./chunk-DJJHS7KK.js";
+import {
+  findRegistryEntry,
+  upsertRegistryEntry
+} from "./chunk-DKZBQRR3.js";
+
+// src/daemon/autoresearch.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { randomUUID } from "crypto";
+var STRATEGY_DESCRIPTIONS = {
+  targeted_fix: "Fix the specific failing eval cases while preserving passing behavior.",
+  simplify: "Simplify the skill instructions while maintaining the same behavior.",
+  restructure: "Restructure the skill for clarity and completeness.",
+  scope_narrow: "Narrow the scope \u2014 be more specific about what the skill does and doesn't do.",
+  format_refine: "Add explicit format specifications for output structure."
+};
+function selectStrategies(suite, failedCaseIds) {
+  const strategies = ["targeted_fix"];
+  if (failedCaseIds.length === 0) return strategies;
+  const failedCases = suite.cases.filter((c) => failedCaseIds.includes(c.id));
+  const failedCategories = failedCases.map((c) => c.category.toLowerCase());
+  const failRate = failedCaseIds.length / Math.max(suite.cases.length, 1);
+  if (failedCategories.some((c) => c.includes("scope"))) {
+    strategies.push("scope_narrow");
+  }
+  if (failedCategories.some((c) => c.includes("format"))) {
+    strategies.push("format_refine");
+  }
+  if (failRate <= 0.3) {
+    strategies.push("simplify");
+  }
+  const uniqueCategories = new Set(failedCategories);
+  if (failRate > 0.5 && uniqueCategories.size >= 2) {
+    strategies.push("restructure");
+  }
+  return [...new Set(strategies)];
+}
+function shouldAutoApply(mode, result) {
+  if (mode === "manual") return false;
+  if (!result.bestContent) return false;
+  if (mode === "assisted") {
+    return result.bestScore.passRate === 1 && result.bestScore.lengthRatio >= 0.7 && result.bestScore.lengthRatio <= 1.5;
+  }
+  if (mode === "autonomous") {
+    return result.bestScore.passRate > result.baselineScore.passRate;
+  }
+  return false;
+}
+var MUTATION_SYSTEM = `You are improving a Claude Code artifact. You will be given the current content, the specific eval cases it fails, and context from the correction traces that generated those cases. Make targeted changes to pass the failing cases while preserving behavior for passing cases. Return ONLY the improved content, no explanation or commentary.`;
+async function generateMutations(currentContent, suite, failedCaseIds, strategies, apiKey, model) {
+  const failedCases = suite.cases.filter((c) => failedCaseIds.includes(c.id));
+  const mutations = [];
+  let llmCalls = 0;
+  const failedCaseSummary = failedCases.map((c) => `- [${c.category}] ${c.description} (${c.assertion.type})`).join("\n");
+  const passingCases = suite.cases.filter((c) => !failedCaseIds.includes(c.id));
+  const passingCaseSummary = passingCases.length > 0 ? passingCases.map((c) => `- [${c.category}] ${c.description}`).join("\n") : "(none)";
+  for (const strategy of strategies) {
+    const userMessage = `Current artifact content:
+<skill>
+${currentContent}
+</skill>
+
+Failing eval cases (${failedCaseIds.length}/${suite.cases.length}) \u2014 FIX THESE:
+${failedCaseSummary}
+
+Passing eval cases (${passingCases.length}/${suite.cases.length}) \u2014 PRESERVE THESE:
+${passingCaseSummary}
+
+Strategy: ${strategy} \u2014 ${STRATEGY_DESCRIPTIONS[strategy] ?? "Improve the skill."}
+
+Rewrite the skill to pass the failing cases while keeping the passing cases passing.`;
+    try {
+      const result = await callAnthropic(apiKey, {
+        model,
+        system: MUTATION_SYSTEM,
+        userMessage,
+        maxTokens: 4096
+      });
+      llmCalls++;
+      let content = result.text.trim();
+      content = content.replace(/^<skill>\s*/i, "").replace(/\s*<\/skill>\s*$/i, "");
+      const ratio = content.length / currentContent.length;
+      if (ratio >= 0.3 && ratio <= 3 && content.length > 10) {
+        mutations.push({ content, strategy });
+      }
+    } catch {
+    }
+  }
+  return { mutations, llmCalls };
+}
+async function autoResearchLoop(slug, skillPath, suite, config, apiKey) {
+  const startTime = Date.now();
+  let totalLLMCalls = 0;
+  const usedStrategies = [];
+  const currentContent = readFileSync(skillPath, "utf-8");
+  const baselineScore = await runEvalSuite(currentContent, suite, currentContent, apiKey, config.mutationModel);
+  let best = currentContent;
+  let bestScore = baselineScore;
+  for (let iteration = 0; iteration < config.maxIterations; iteration++) {
+    if (totalLLMCalls >= config.maxLLMCalls) break;
+    const strategies = selectStrategies(suite, bestScore.failedCaseIds).slice(
+      0,
+      config.mutationsPerIteration
+    );
+    const { mutations, llmCalls } = await generateMutations(
+      best,
+      suite,
+      bestScore.failedCaseIds,
+      strategies,
+      apiKey,
+      config.mutationModel
+    );
+    totalLLMCalls += llmCalls;
+    let improved = false;
+    for (const mutation of mutations) {
+      if (totalLLMCalls >= config.maxLLMCalls) break;
+      const score = await runEvalSuite(mutation.content, suite, currentContent, apiKey, config.mutationModel);
+      if (score.passRate > bestScore.passRate) {
+        best = mutation.content;
+        bestScore = score;
+        improved = true;
+        if (!usedStrategies.includes(mutation.strategy)) {
+          usedStrategies.push(mutation.strategy);
+        }
+      }
+    }
+    if (bestScore.passRate === 1) break;
+    if (!improved) break;
+  }
+  const duration = Date.now() - startTime;
+  return {
+    bestContent: best !== currentContent ? best : null,
+    baselineScore,
+    bestScore,
+    iterations: Math.min(config.maxIterations, totalLLMCalls),
+    totalLLMCalls,
+    strategies: usedStrategies,
+    duration
+  };
+}
+function applyImprovement(slug, skillPath, improvedContent, result, db) {
+  const entry = findRegistryEntry(slug);
+  if (!entry) return;
+  const versionsDir = join(homedir(), ".caik", "versions", slug);
+  mkdirSync(versionsDir, { recursive: true });
+  const versionFile = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-") + ".md";
+  writeFileSync(join(versionsDir, versionFile), readFileSync(skillPath, "utf-8"), "utf-8");
+  writeFileSync(skillPath, improvedContent, "utf-8");
+  const obsPath = join(homedir(), ".caik", "observations", `${slug}.jsonl`);
+  if (existsSync(obsPath)) {
+    writeFileSync(obsPath, "", "utf-8");
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const updatedEntry = {
+    ...entry,
+    updatedAt: now,
+    lastImprovedAt: now,
+    localVersion: (entry.localVersion ?? 0) + 1,
+    pendingImprovement: false,
+    lastAutoAppliedAt: now,
+    preApplyCorrectionRate: result.baselineScore.passRate,
+    improvementLog: [
+      ...entry.improvementLog ?? [],
+      { ts: now, type: `autoresearch:${result.strategies.join("+")}` }
+    ],
+    lastLoopResult: {
+      score: result.bestScore.passRate,
+      iterations: result.iterations,
+      timestamp: now
+    }
+  };
+  upsertRegistryEntry(updatedEntry);
+  db.prepare(
+    `INSERT INTO loop_results (id, slug, baseline_pass_rate, best_pass_rate, baseline_pass_count, best_pass_count,
+     total_cases, iterations, total_llm_calls, duration_ms, strategies, best_content, applied, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?)`
+  ).run(
+    randomUUID(),
+    slug,
+    result.baselineScore.passRate,
+    result.bestScore.passRate,
+    result.baselineScore.passCount,
+    result.bestScore.passCount,
+    result.bestScore.totalCases,
+    result.iterations,
+    result.totalLLMCalls,
+    result.duration,
+    JSON.stringify(result.strategies),
+    improvedContent,
+    now
+  );
+}
+function proposeImprovement(slug, skillPath, improvedContent, result, db) {
+  const entry = findRegistryEntry(slug);
+  if (!entry) return;
+  const currentContent = readFileSync(skillPath, "utf-8");
+  const versionsDir = join(homedir(), ".caik", "versions", slug);
+  mkdirSync(versionsDir, { recursive: true });
+  const versionFile = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-") + ".md";
+  writeFileSync(join(versionsDir, versionFile), currentContent, "utf-8");
+  const proposedPath = skillPath.endsWith("SKILL.md") ? skillPath.replace(/SKILL\.md$/, "SKILL.proposed.md") : `${skillPath}.proposed`;
+  writeFileSync(proposedPath, improvedContent, "utf-8");
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const updatedEntry = {
+    ...entry,
+    updatedAt: now,
+    pendingImprovement: true,
+    improvementLog: [
+      ...entry.improvementLog ?? [],
+      { ts: now, type: `autoresearch:${result.strategies.join("+")}` }
+    ],
+    lastLoopResult: {
+      score: result.bestScore.passRate,
+      iterations: result.iterations,
+      timestamp: now
+    }
+  };
+  upsertRegistryEntry(updatedEntry);
+  db.prepare(
+    `INSERT INTO loop_results (id, slug, baseline_pass_rate, best_pass_rate, baseline_pass_count, best_pass_count,
+     total_cases, iterations, total_llm_calls, duration_ms, strategies, best_content, applied, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?)`
+  ).run(
+    randomUUID(),
+    slug,
+    result.baselineScore.passRate,
+    result.bestScore.passRate,
+    result.baselineScore.passCount,
+    result.bestScore.passCount,
+    result.bestScore.totalCases,
+    result.iterations,
+    result.totalLLMCalls,
+    result.duration,
+    JSON.stringify(result.strategies),
+    improvedContent,
+    now
+  );
+}
+function checkWatchdog(slug, entry, observations) {
+  if (!entry.lastAutoAppliedAt) return { shouldRollback: false };
+  const postApply = observations.filter(
+    (o) => new Date(o.timestamp) > new Date(entry.lastAutoAppliedAt)
+  );
+  if (postApply.length < 10) return { shouldRollback: false };
+  const postCorrectionRate = postApply.filter((o) => o.correctionType).length / postApply.length;
+  const preCorrectionRate = entry.preApplyCorrectionRate ?? 0;
+  if (postCorrectionRate - preCorrectionRate > 0.2) {
+    return {
+      shouldRollback: true,
+      reason: `Correction rate increased from ${(preCorrectionRate * 100).toFixed(0)}% to ${(postCorrectionRate * 100).toFixed(0)}%`
+    };
+  }
+  return { shouldRollback: false };
+}
+
+export {
+  selectStrategies,
+  shouldAutoApply,
+  generateMutations,
+  autoResearchLoop,
+  applyImprovement,
+  proposeImprovement,
+  checkWatchdog
+};