@edihasaj/recall 0.5.7 → 0.6.0

package/dist/{chunk-IILLSHLM.js → chunk-KAGIAOD7.js}

@@ -1,16 +1,26 @@
 import {
   activityEvents,
   auditTrail,
+  contradictions,
   feedbackEvents,
   historySnippets,
+  implicitSignals,
+  llmUsage,
+  maintenanceCleanupLog,
   memories,
   memoryEmbeddings,
+  memoryInjections,
   memoryMaintenanceTasks
-} from "./chunk-A5UIRZU6.js";
+} from "./chunk-A6XEULA4.js";
+import {
+  getProviderConfig,
+  hasProviderConfigured,
+  init_keychain
+} from "./chunk-DNFKAHS6.js";
 
 // src/maintenance/tasks.ts
-import { and as and2, desc as desc2, eq as eq7, gt, inArray as inArray2, lt, or, isNull, sql as sql2 } from "drizzle-orm";
-import { randomUUID as randomUUID4 } from "crypto";
+import { and as and4, desc as desc2, eq as eq11, gt, inArray as inArray3, lt, or, isNull, sql as sql3 } from "drizzle-orm";
+import { randomUUID as randomUUID8 } from "crypto";
 import { z as z2 } from "zod";
 
 // src/embeddings/embeddings.ts
@@ -128,7 +138,8 @@ var MaintenanceTaskKind = z.enum([
   "refine_candidate",
   "summarize_session",
   "synthesize_repo",
-  "verify_capture"
+  "verify_capture",
+  "extract_rules_from_prompt"
 ]);
 var MaintenanceTaskStatus = z.enum([
   "pending",
@@ -1536,8 +1547,8 @@ function rowToMemory(row) {
 }
 
 // src/maintenance/appliers.ts
-import { eq as eq6 } from "drizzle-orm";
-import { randomUUID as randomUUID3 } from "crypto";
+import { eq as eq10 } from "drizzle-orm";
+import { randomUUID as randomUUID7 } from "crypto";
 
 // src/models/memory.ts
 import { eq as eq4, and, gte, inArray, like, sql } from "drizzle-orm";
@@ -2074,6 +2085,2362 @@ function rowToAudit(row) {
   };
 }
 
+// src/repo/quality.ts
+import { eq as eq7 } from "drizzle-orm";
+
+// src/health/scoring.ts
+import { eq as eq6 } from "drizzle-orm";
+var WEIGHTS = {
+  confidence: 0.4,
+  freshness: 0.25,
+  follow_rate: 0.2,
+  signal_ratio: 0.15
+};
+function computeHealthScore(db, memoryId) {
+  const mem = getMemory(db, memoryId);
+  if (!mem) return null;
+  const confidence = mem.confidence;
+  const freshness = computeFreshness(mem);
+  const followRate = computeFollowRate(db, memoryId);
+  const signalRatio = computeSignalRatio(db, memoryId);
+  const score = WEIGHTS.confidence * confidence + WEIGHTS.freshness * freshness + WEIGHTS.follow_rate * followRate + WEIGHTS.signal_ratio * signalRatio;
+  return {
+    memory_id: memoryId,
+    score: clamp(score),
+    confidence_component: confidence,
+    freshness_component: freshness,
+    follow_rate_component: followRate,
+    signal_ratio_component: signalRatio,
+    computed_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function computeAllHealthScores(db, repo) {
+  const mems = repo ? queryMemories(db, { repo }) : listMemories(db);
+  const scores = [];
+  for (const mem of mems) {
+    if (mem.status === "rejected") continue;
+    const score = computeHealthScore(db, mem.id);
+    if (score) scores.push(score);
+  }
+  return scores.sort((a, b) => b.score - a.score);
+}
+function computeFreshness(mem) {
+  const now = Date.now();
+  const referenceDate = mem.last_validated_at ?? mem.last_injected_at ?? mem.updated_at;
+  const age = now - new Date(referenceDate).getTime();
+  const dayMs = 864e5;
+  const halfLife = 30 * dayMs;
+  const freshness = Math.pow(0.5, age / halfLife);
+  return clamp(freshness);
+}
+function computeFollowRate(db, memoryId) {
+  const feedback = db.select().from(feedbackEvents).where(eq6(feedbackEvents.memory_id, memoryId)).all();
+  if (feedback.length === 0) return 0.5;
+  const followed = feedback.filter((f) => f.outcome === "followed").length;
+  return followed / feedback.length;
+}
+function computeSignalRatio(db, memoryId) {
+  const signals = db.select().from(implicitSignals).where(eq6(implicitSignals.memory_id, memoryId)).all();
+  if (signals.length === 0) return 0.5;
+  const positive = signals.filter(
+    (s) => ["test_pass", "file_unchanged", "task_accepted"].includes(s.signal_type)
+  ).length;
+  return positive / signals.length;
+}
+function formatHealthReport(scores) {
+  if (scores.length === 0) return "No memories to score.";
+  const lines = [
+    "# Memory Health Report",
+    "",
+    `Total: ${scores.length} memories scored`,
+    "",
+    "| Score | Conf | Fresh | Follow | Signal | ID       |",
+    "|-------|------|-------|--------|--------|----------|"
+  ];
+  for (const s of scores.slice(0, 30)) {
+    lines.push(
+      `| ${pct(s.score)} | ${pct(s.confidence_component)} | ${pct(s.freshness_component)} | ${pct(s.follow_rate_component)} | ${pct(s.signal_ratio_component)} | ${s.memory_id.slice(0, 8)} |`
+    );
+  }
+  const avg = scores.reduce((sum, s) => sum + s.score, 0) / scores.length;
+  const unhealthy = scores.filter((s) => s.score < 0.3).length;
+  const healthy = scores.filter((s) => s.score >= 0.6).length;
+  lines.push("");
+  lines.push(`Avg score: ${pct(avg)}`);
+  lines.push(`Healthy (\u22650.6): ${healthy} | Unhealthy (<0.3): ${unhealthy}`);
+  return lines.join("\n");
+}
+function clamp(n) {
+  return Math.max(0, Math.min(1, n));
+}
+function pct(n) {
+  return (n * 100).toFixed(0).padStart(3) + "%";
+}
+
+// src/repo/quality.ts
+function getRepoQualityProfile(db, repo) {
+  if (!repo) {
+    return defaultProfile();
+  }
+  const memories4 = queryMemories(db, { repo }).filter((m) => m.status !== "rejected");
+  const active = memories4.filter((m) => m.status === "active");
+  const activeCount = active.length;
+  const totalCount = memories4.length;
+  const health = computeAllHealthScores(db, repo);
+  const avgHealth = health.length > 0 ? health.reduce((sum, item) => sum + item.score, 0) / health.length : 0;
+  const totalInjections = memories4.reduce((sum, m) => sum + m.injection_count, 0);
+  const totalOverrides = memories4.reduce((sum, m) => sum + m.override_count, 0);
+  const overrideRate = totalInjections > 0 ? totalOverrides / totalInjections : 0;
+  const ids = new Set(memories4.map((m) => m.id));
+  const unresolved = db.select().from(contradictions).where(eq7(contradictions.resolved, false)).all().filter((item) => ids.has(item.memory_a_id) || ids.has(item.memory_b_id));
+  const contradictionRate = activeCount > 0 ? unresolved.length / activeCount : 0;
+  const stage = classifyStage(activeCount);
+  const pressure = clamp2(activeCount / 50);
+  const score = clamp2(
+    avgHealth * 0.5 + (1 - clamp2(overrideRate)) * 0.25 + (1 - clamp2(contradictionRate)) * 0.15 + (1 - pressure) * 0.1
+  );
+  let repeatSessionsRequired = stage === "cold" ? 2 : stage === "growing" ? 3 : 4;
+  if (score >= 0.75 && repeatSessionsRequired > 2) {
+    repeatSessionsRequired -= 1;
+  } else if (score < 0.45) {
+    repeatSessionsRequired += 1;
+  }
+  let compileConfidenceThreshold = stage === "cold" ? CONFIDENCE.ACTIVE_MIN : stage === "growing" ? 0.68 : 0.72;
+  if (score < 0.45) {
+    compileConfidenceThreshold += 0.05;
+  } else if (score > 0.8) {
+    compileConfidenceThreshold -= 0.03;
+  }
+  let dedupSimilarityThreshold = stage === "cold" ? 0.85 : stage === "growing" ? 0.8 : 0.75;
+  if (score < 0.45) {
+    dedupSimilarityThreshold -= 0.05;
+  }
+  return {
+    repo,
+    stage,
+    score,
+    total_count: totalCount,
+    active_count: activeCount,
+    avg_health: avgHealth,
+    override_rate: clamp2(overrideRate),
+    contradiction_rate: clamp2(contradictionRate),
+    repeat_sessions_required: repeatSessionsRequired,
+    compile_confidence_threshold: clamp2(
+      compileConfidenceThreshold,
+      CONFIDENCE.ACTIVE_MIN,
+      0.82
+    ),
+    dedup_similarity_threshold: clamp2(dedupSimilarityThreshold, 0.65, 0.9)
+  };
+}
+function seedCandidateConfidence(baseConfidence, profile) {
+  const maturityPenalty = profile.stage === "cold" ? 0 : profile.stage === "growing" ? 0.03 : 0.05;
+  const qualityPenalty = profile.score < 0.45 ? 0.03 : 0;
+  return clamp2(
+    baseConfidence - maturityPenalty - qualityPenalty,
+    CONFIDENCE.TRANSIENT_MAX + 0.05,
+    CONFIDENCE.ACTIVE_MIN - 0.01
+  );
+}
+function seedScannedConfidence(baseConfidence, profile) {
+  const maturityPenalty = profile.stage === "cold" ? 0 : profile.stage === "growing" ? 0.02 : 0.05;
+  const qualityPenalty = profile.score < 0.45 ? 0.03 : 0;
+  return clamp2(
+    baseConfidence - maturityPenalty - qualityPenalty,
+    0.5,
+    0.85
+  );
+}
+function classifyStage(activeCount) {
+  if (activeCount < 10) return "cold";
+  if (activeCount < 50) return "growing";
+  return "mature";
+}
+function defaultProfile() {
+  return {
+    stage: "cold",
+    score: 0.35,
+    total_count: 0,
+    active_count: 0,
+    avg_health: 0,
+    override_rate: 0,
+    contradiction_rate: 0,
+    repeat_sessions_required: 2,
+    compile_confidence_threshold: CONFIDENCE.ACTIVE_MIN,
+    dedup_similarity_threshold: 0.85
+  };
+}
+function clamp2(n, min = 0, max = 1) {
+  return Math.max(min, Math.min(max, n));
+}
+
+// src/llm/client.ts
+init_keychain();
+import { randomUUID as randomUUID3 } from "crypto";
+var LlmCredentialError = class extends Error {
+};
+var LlmRequestError = class extends Error {
+};
+var DEFAULT_MODELS = {
+  openai: "gpt-4o-mini",
+  anthropic: "claude-haiku-4-5-20251001",
+  // For Azure the "model" is the deployment name, set by the user when they
+  // provisioned the deployment. We leave it empty so we always fall through
+  // to the deployment from AzureOpenAiConfig.
+  "azure-openai": ""
+};
+var COST_PER_M_TOKENS = {
+  "gpt-4o-mini": { input: 0.15, output: 0.6 },
+  "gpt-4o": { input: 2.5, output: 10 },
+  "claude-haiku-4-5-20251001": { input: 1, output: 5 },
+  "claude-sonnet-4-6": { input: 3, output: 15 },
+  "claude-opus-4-7": { input: 15, output: 75 }
+};
+async function callLlm(db, input) {
+  const provider = input.provider;
+  const config = getProviderConfig(provider);
+  if (!config) {
+    throw new LlmCredentialError(missingCredentialMessage(provider));
+  }
+  const model = input.model ?? (provider === "azure-openai" ? config.deployment : DEFAULT_MODELS[provider]);
+  const started = Date.now();
+  let result = null;
+  let errorMessage;
+  try {
+    if (provider === "openai") {
+      result = await callOpenAi(config.key, model, input);
+    } else if (provider === "anthropic") {
+      result = await callAnthropic(config.key, model, input);
+    } else {
+      result = await callAzureOpenAi(config, model, input);
+    }
+    return result;
+  } catch (err) {
+    errorMessage = err instanceof Error ? err.message : String(err);
+    throw err;
+  } finally {
+    try {
+      await recordUsage(db, {
+        provider,
+        model,
+        task_kind: input.task_kind,
+        task_id: input.task_id ?? null,
+        repo: input.repo ?? null,
+        usage: result?.usage ?? { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0, cost_usd: null },
+        duration_ms: Date.now() - started,
+        ok: Boolean(result),
+        error: errorMessage
+      });
+    } catch {
+    }
+  }
+}
+async function callOpenAi(apiKey, model, input) {
+  const started = Date.now();
+  const response = await fetch("https://api.openai.com/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      model,
+      messages: [
+        { role: "system", content: input.system },
+        { role: "user", content: input.user }
+      ],
+      max_completion_tokens: input.max_output_tokens ?? 2048,
+      temperature: input.temperature ?? 0
+    })
+  });
+  if (!response.ok) {
+    const body = await safeText(response);
+    throw new LlmRequestError(`OpenAI ${response.status}: ${body.slice(0, 400)}`);
+  }
+  const payload = await response.json();
+  const text = payload.choices?.[0]?.message?.content?.trim() ?? "";
+  const prompt_tokens = payload.usage?.prompt_tokens ?? 0;
+  const completion_tokens = payload.usage?.completion_tokens ?? 0;
+  const total_tokens = payload.usage?.total_tokens ?? prompt_tokens + completion_tokens;
+  return {
+    text,
+    model,
+    provider: "openai",
+    duration_ms: Date.now() - started,
+    usage: {
+      prompt_tokens,
+      completion_tokens,
+      total_tokens,
+      cost_usd: computeCost(model, prompt_tokens, completion_tokens)
+    }
+  };
+}
+async function callAzureOpenAi(config, deployment, input) {
+  const started = Date.now();
+  const url = `${config.endpoint}/openai/deployments/${encodeURIComponent(deployment)}/chat/completions?api-version=${encodeURIComponent(config.api_version)}`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "api-key": config.key
+    },
+    body: JSON.stringify({
+      messages: [
+        { role: "system", content: input.system },
+        { role: "user", content: input.user }
+      ],
+      max_completion_tokens: input.max_output_tokens ?? 2048,
+      temperature: input.temperature ?? 0
+    })
+  });
+  if (!response.ok) {
+    const body = await safeText(response);
+    throw new LlmRequestError(`Azure OpenAI ${response.status}: ${body.slice(0, 400)}`);
+  }
+  const payload = await response.json();
+  const text = payload.choices?.[0]?.message?.content?.trim() ?? "";
+  const prompt_tokens = payload.usage?.prompt_tokens ?? 0;
+  const completion_tokens = payload.usage?.completion_tokens ?? 0;
+  const total_tokens = payload.usage?.total_tokens ?? prompt_tokens + completion_tokens;
+  return {
+    text,
+    model: deployment,
+    provider: "azure-openai",
+    duration_ms: Date.now() - started,
+    usage: {
+      prompt_tokens,
+      completion_tokens,
+      total_tokens,
+      cost_usd: computeCost(deployment, prompt_tokens, completion_tokens)
+    }
+  };
+}
+async function callAnthropic(apiKey, model, input) {
+  const started = Date.now();
+  const response = await fetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01"
+    },
+    body: JSON.stringify({
+      model,
+      system: input.system,
+      messages: [{ role: "user", content: input.user }],
+      max_tokens: input.max_output_tokens ?? 2048,
+      temperature: input.temperature ?? 0
+    })
+  });
+  if (!response.ok) {
+    const body = await safeText(response);
+    throw new LlmRequestError(`Anthropic ${response.status}: ${body.slice(0, 400)}`);
+  }
+  const payload = await response.json();
+  const text = (payload.content ?? []).filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text).join("").trim();
+  const prompt_tokens = payload.usage?.input_tokens ?? 0;
+  const completion_tokens = payload.usage?.output_tokens ?? 0;
+  return {
+    text,
+    model,
+    provider: "anthropic",
+    duration_ms: Date.now() - started,
+    usage: {
+      prompt_tokens,
+      completion_tokens,
+      total_tokens: prompt_tokens + completion_tokens,
+      cost_usd: computeCost(model, prompt_tokens, completion_tokens)
+    }
+  };
+}
+function computeCost(model, inputTokens, outputTokens) {
+  const rates = COST_PER_M_TOKENS[model];
+  if (!rates) return null;
+  return inputTokens / 1e6 * rates.input + outputTokens / 1e6 * rates.output;
+}
+async function recordUsage(db, row) {
+  await db.insert(llmUsage).values({
+    id: randomUUID3(),
+    provider: row.provider,
+    model: row.model,
+    task_kind: row.task_kind,
+    task_id: row.task_id,
+    repo: row.repo,
+    prompt_tokens: row.usage.prompt_tokens,
+    completion_tokens: row.usage.completion_tokens,
+    total_tokens: row.usage.total_tokens,
+    cost_usd: row.usage.cost_usd ?? null,
+    duration_ms: row.duration_ms,
+    ok: row.ok,
+    error: row.error ?? null,
+    created_at: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+function missingCredentialMessage(provider) {
+  switch (provider) {
+    case "openai":
+      return `No API key for provider "openai". Set it via \`recall maintenance credentials set openai <key>\` or the OPENAI_API_KEY env var.`;
+    case "anthropic":
+      return `No API key for provider "anthropic". Set it via \`recall maintenance credentials set anthropic <key>\` or the ANTHROPIC_API_KEY env var.`;
+    case "azure-openai":
+      return `Azure OpenAI is not fully configured. Run \`recall maintenance credentials set azure --endpoint <url> --deployment <name> --api-version <version> <key>\` or set AZURE_OPENAI_{ENDPOINT,DEPLOYMENT,API_VERSION,API_KEY}.`;
+  }
+}
+async function safeText(response) {
+  try {
+    return await response.text();
+  } catch {
+    return "";
+  }
+}
+
+// src/maintenance/dispatcher.ts
+init_keychain();
+var DISPATCH_AGENT = "recall:dispatcher";
+var DEFAULT_LEASE_SECONDS = 120;
+async function dispatchPendingTasks(db, options = {}) {
+  const provider = resolveProvider2(options.provider);
+  const report = {
+    provider,
+    model: null,
+    dry_run: Boolean(options.dryRun),
+    attempted: 0,
+    applied: 0,
+    rejected: 0,
+    released: 0,
+    outcomes: []
+  };
+  if (!provider) return report;
+  const pending = listTasks(db, {
+    status: "pending",
+    kinds: options.kinds,
+    repo: options.repo,
+    limit: options.maxTasks ?? 5
+  });
+  for (const task of pending) {
+    if (options.dryRun) {
+      report.outcomes.push({
+        task_id: task.id,
+        kind: task.kind,
+        repo: task.repo,
+        status: "skipped",
+        reason: "dry-run"
+      });
+      continue;
+    }
+    report.attempted += 1;
+    const outcome = await runSingle(db, task, provider, options.model);
+    report.outcomes.push(outcome);
+    if (outcome.status === "applied") report.applied += 1;
+    else if (outcome.status === "rejected") report.rejected += 1;
+    else if (outcome.status === "released") report.released += 1;
+    if (outcome.prompt_tokens != null && !report.model) {
+      const last = report.outcomes[report.outcomes.length - 1];
+      report.model = last.task_id ? options.model ?? null : null;
+    }
+  }
+  return report;
+}
+async function runSingle(db, task, provider, model) {
+  let claimed;
+  try {
+    const claim = claimTask(db, task.id, DISPATCH_AGENT, DEFAULT_LEASE_SECONDS);
+    claimed = claim.task;
+  } catch (err) {
+    if (err instanceof TaskClaimConflictError) {
+      return {
+        task_id: task.id,
+        kind: task.kind,
+        repo: task.repo,
+        status: "skipped",
+        reason: err.reason
+      };
+    }
+    throw err;
+  }
+  const prompt = buildPrompt(claimed);
+  if (!prompt) {
+    releaseTask(db, claimed.id, DISPATCH_AGENT);
+    return {
+      task_id: claimed.id,
+      kind: claimed.kind,
+      repo: claimed.repo,
+      status: "released",
+      reason: "no prompt builder"
+    };
+  }
+  try {
+    const llmResult = await callLlm(db, {
+      provider,
+      model,
+      system: prompt.system,
+      user: prompt.user,
+      max_output_tokens: prompt.max_output_tokens,
+      task_kind: claimed.kind,
+      task_id: claimed.id,
+      repo: claimed.repo
+    });
+    const parsed = parseJson(llmResult.text);
+    if (!parsed) {
+      releaseTask(db, claimed.id, DISPATCH_AGENT);
+      return {
+        task_id: claimed.id,
+        kind: claimed.kind,
+        repo: claimed.repo,
+        status: "released",
+        reason: "llm did not return valid JSON",
+        prompt_tokens: llmResult.usage.prompt_tokens,
+        completion_tokens: llmResult.usage.completion_tokens,
+        cost_usd: llmResult.usage.cost_usd,
+        duration_ms: llmResult.duration_ms
+      };
+    }
+    const submit = submitTask(db, claimed.id, DISPATCH_AGENT, parsed);
+    if (submit.status === "applied") {
+      return {
+        task_id: claimed.id,
+        kind: claimed.kind,
+        repo: claimed.repo,
+        status: "applied",
+        target_id: submit.target_id,
+        changed_fields: submit.changed_fields,
+        prompt_tokens: llmResult.usage.prompt_tokens,
+        completion_tokens: llmResult.usage.completion_tokens,
+        cost_usd: llmResult.usage.cost_usd,
+        duration_ms: llmResult.duration_ms
+      };
+    }
+    return {
+      task_id: claimed.id,
+      kind: claimed.kind,
+      repo: claimed.repo,
+      status: "rejected",
+      reason: submit.reason,
+      prompt_tokens: llmResult.usage.prompt_tokens,
+      completion_tokens: llmResult.usage.completion_tokens,
+      cost_usd: llmResult.usage.cost_usd,
+      duration_ms: llmResult.duration_ms
+    };
+  } catch (err) {
+    releaseTask(db, claimed.id, DISPATCH_AGENT);
+    const reason = err instanceof LlmCredentialError ? err.message : err instanceof Error ? err.message : String(err);
+    return {
+      task_id: claimed.id,
+      kind: claimed.kind,
+      repo: claimed.repo,
+      status: "released",
+      reason
+    };
+  }
+}
+function hasAnyLlmProvider() {
+  return resolveProvider2() != null;
+}
+function resolveProvider2(preferred) {
+  const candidates = preferred ? [preferred] : ["anthropic", "azure-openai", "openai"];
+  for (const provider of candidates) {
+    if (hasProviderConfigured(provider)) return provider;
+  }
+  return null;
+}
+function parseJson(text) {
+  const trimmed = text.trim();
+  if (trimmed.length === 0) return null;
+  const stripped = trimmed.replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/i, "").trim();
+  try {
+    return JSON.parse(stripped);
+  } catch {
+    const first = stripped.indexOf("{");
+    const last = stripped.lastIndexOf("}");
+    if (first >= 0 && last > first) {
+      try {
+        return JSON.parse(stripped.slice(first, last + 1));
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+}
+function buildPrompt(task) {
+  switch (task.kind) {
+    case "verify_capture":
+      return buildVerifyCapturePrompt(task);
+    case "refine_candidate":
+      return buildRefineCandidatePrompt(task);
+    case "summarize_history":
+      return buildSummarizeHistoryPrompt(task);
+    case "merge_duplicates":
+      return buildMergeDuplicatesPrompt(task);
+    case "summarize_session":
+      return buildSummarizeSessionPrompt(task);
+    case "synthesize_repo":
+      return buildSynthesizeRepoPrompt(task);
+    case "extract_rules_from_prompt":
+      return buildExtractRulesFromPromptPrompt(task);
+    default:
+      return null;
+  }
+}
+function buildExtractRulesFromPromptPrompt(task) {
+  const payload = task.payload;
+  const system = [
+    "You are the capture judge for a coding-agent memory store.",
+    "Read the USER PROMPT below and extract zero or more DURABLE RULES the user is stating about how the agent should behave on this repo (or globally).",
+    "A rule must be:",
+    "  (a) Imperative \u2014 telling the agent what to always/never do, or what to prefer.",
+    "  (b) Durable \u2014 the user expects it to apply across future sessions, not just this one task.",
+    "  (c) Specific \u2014 concrete enough that an agent can follow it without further clarification.",
+    "Recognize rules in ANY natural language (English, Spanish, French, German, Italian, Portuguese, Russian, Chinese, Japanese, Albanian, Turkish, Arabic, \u2026). When the source is non-English, return the cleaned rule TEXT in English so memories are searchable across sessions.",
+    "REJECT (return empty list):",
+    "  \u2022 Questions ('should we use X?'), one-off task requests ('please fix this bug now'), narration ('I never use X' as description of past behavior), code paste, error logs, transcripts.",
+    "  \u2022 Trigger-template rules ('when user says X, do Y') and destructive-risky rules (delete/wipe/drop + settings/secrets/branches/files) \u2014 return them but flag is_destructive_risky=true so they require explicit user confirm before going active.",
+    "  \u2022 Anything where the intent is ambiguous without surrounding context.",
+    "Output a single CANONICAL sentence per rule, in imperative mood. Strip filler words (uh, um, like, you know).",
+    "Set scope as tight as the evidence supports: 'path' if a specific file/dir is referenced, 'repo' for repo-wide, 'global' only if the user explicitly says 'across all my projects' / 'globally' / 'everywhere'.",
+    "Confidence: 0.9+ for unambiguous explicit rules, 0.5-0.8 for inferred/soft preferences, below 0.5 means you should probably not return it at all.",
+    "Be STRICT \u2014 false positives produce wrong agent behavior. When unsure, prefer empty list over a low-confidence guess.",
+    JSON_ONLY
+  ].join(" ");
+  const recentToolsSummary = summarizeRecentToolCalls(payload.recent_tool_calls);
+  const user = [
+    `Repo: ${JSON.stringify(payload.repo ?? null)}`,
+    `Path: ${JSON.stringify(payload.path ?? null)}`,
+    `Agent: ${JSON.stringify(payload.agent ?? null)}`,
+    payload.prev_assistant_turn ? `Previous assistant turn (for context only \u2014 do not extract rules from it): ${JSON.stringify(payload.prev_assistant_turn.slice(0, 800))}` : "Previous assistant turn: null",
+    recentToolsSummary ? `Recent tool calls: ${recentToolsSummary}` : "Recent tool calls: none",
+    "",
+    `USER PROMPT:`,
+    JSON.stringify(payload.raw_prompt ?? ""),
+    "",
+    'Return JSON: {"rules": [{"text": string, "type": "rule"|"decision"|"review_pattern"|"command"|"gotcha", "scope": "session"|"path"|"repo"|"team"|"global", "path_scope": string|null, "confidence": number, "is_destructive_risky": boolean, "rationale": string}], "dropped_reason": string?}',
+    'When the prompt contains no durable rule, return {"rules": []} with a brief dropped_reason.'
+  ].join("\n");
+  return { system, user, max_output_tokens: 800 };
+}
+function summarizeRecentToolCalls(value) {
+  if (!Array.isArray(value) || value.length === 0) return null;
+  return value.slice(-5).map((entry) => {
+    if (!entry || typeof entry !== "object") return null;
+    const name = typeof entry.name === "string" ? entry.name : "tool";
+    const path = typeof entry.path === "string" ? entry.path : null;
+    return path ? `${name}(${path})` : name;
+  }).filter(Boolean).join(", ");
+}
+function buildVerifyCapturePrompt(task) {
+  const payload = task.payload;
+  const system = [
+    "You verify a captured candidate rule for a coding-agent memory store.",
+    "Decide if it is a durable rule worth saving, salvageable but needs rewriting, or noise/narration.",
+    "Be strict \u2014 false positives produce wrong agent behavior. When unsure, prefer reject over save.",
+    "Reject voice transcripts, descriptive clauses about what the user does ('things I never use'), one-shot task chatter, and any text whose intent is unclear without surrounding context.",
+    "When rewriting, output a single canonical sentence in imperative mood. Keep scope as tight as the evidence supports.",
+    'Flag is_destructive_risky=true when the rule pairs a destructive verb (remove/delete/drop/wipe) with high-risk targets (settings/config/files/secrets/branches), OR when it is shaped as a literal-trigger rule ("when user says X, do Y") \u2014 both require explicit user confirm regardless.',
+    JSON_ONLY
+  ].join(" ");
+  const user = [
+    `Candidate text: ${JSON.stringify(payload.text ?? "")}`,
+    `Inferred scope: ${payload.inferred_scope ?? "repo"}`,
+    `Inferred path_scope: ${JSON.stringify(payload.inferred_path_scope ?? null)}`,
+    `Repo: ${JSON.stringify(payload.repo ?? null)}`,
+    `Capture context: ${JSON.stringify(payload.capture_context ?? null)}`,
+    "",
+    'Return JSON: {"verdict": "save"|"rewrite"|"reject", "cleaned_text"?: string, "scope"?: "session"|"path"|"repo"|"team"|"global", "path_scope"?: string|null, "is_destructive_risky"?: boolean, "reason"?: string}'
+  ].join("\n");
+  return { system, user };
+}
+var JSON_ONLY = "Respond with a single JSON object matching the required schema, no prose, no markdown fences.";
+function buildRefineCandidatePrompt(task) {
+  const payload = task.payload;
+  const system = [
+    "You refine candidate memories in a coding-agent memory store.",
+    "Keep only durable rules/commands/gotchas. Clamp scope tighter when the evidence is path-specific.",
+    JSON_ONLY
+  ].join(" ");
+  const user = [
+    `Current memory text: ${JSON.stringify(payload.text ?? "")}`,
+    `Current scope: ${payload.current_scope ?? "repo"}`,
+    `Current path_scope: ${JSON.stringify(payload.current_path_scope ?? null)}`,
+    `Repo: ${JSON.stringify(payload.repo ?? null)}`,
+    `Repetition count: ${payload.repetition_count ?? 0}`,
+    "",
+    'Return JSON: {"refined_text": string, "scope": "session"|"path"|"repo"|"team"|"global", "path_scope": string|null, "rationale": string, "verdict"?: "rewrite"|"reject"}'
+  ].join("\n");
+  return { system, user };
+}
+function buildSummarizeHistoryPrompt(task) {
+  const payload = task.payload;
+  const system = [
+    "You compress activity snippets in a coding-agent memory store.",
+    "Keep the essential facts; drop filler. <= 3 short sentences.",
+    JSON_ONLY
+  ].join(" ");
+  const user = [
+    `Kind: ${payload.kind ?? "unknown"}`,
+    `Repo: ${JSON.stringify(payload.repo ?? null)}`,
+    `Current text: ${JSON.stringify(payload.current_text ?? "")}`,
+    "",
+    'Return JSON: {"summary_text": string, "tags": [string, ...]}'
+  ].join("\n");
+  return { system, user };
+}
+function buildMergeDuplicatesPrompt(task) {
+  const payload = task.payload;
+  const system = [
+    "You pick the best memory among near-duplicates in a coding-agent memory store.",
+    "Choose the single winning id. You may also rewrite the winner's text for clarity, and tighten its scope if evidence supports it.",
+    JSON_ONLY
+  ].join(" ");
+  const user = [
+    `Repo: ${JSON.stringify(payload.repo ?? null)}`,
+    `Cluster:`,
+    JSON.stringify(payload.cluster ?? [], null, 2),
+    "",
+    'Return JSON: {"winner_id": uuid, "winner_text"?: string, "winner_scope"?: "session"|"path"|"repo"|"team", "winner_path_scope"?: string|null, "rationale"?: string}'
+  ].join("\n");
+  return { system, user };
+}
+function buildSummarizeSessionPrompt(task) {
+  const payload = task.payload;
+  const system = [
+    "You condense a coding-agent session into a brief durable summary.",
+    "<= 5 short bullet points; no filler.",
+    JSON_ONLY
+  ].join(" ");
+  const user = [
+    `Session: ${payload.session_id ?? "unknown"}`,
+    `Repo: ${JSON.stringify(payload.repo ?? null)}`,
+    `Events: ${JSON.stringify(payload.events ?? [], null, 2).slice(0, 12e3)}`,
+    "",
+    'Return JSON: {"summary_text": string}'
+  ].join("\n");
+  return { system, user };
+}
+function buildSynthesizeRepoPrompt(task) {
+  const payload = task.payload;
+  const system = [
+    "You synthesize a concise repo-level summary from the stable memory set.",
+    "Focus on commands, rules, gotchas, and decisions that repeat across sessions.",
+    JSON_ONLY
+  ].join(" ");
+  const user = [
+    `Repo: ${JSON.stringify(payload.repo ?? null)}`,
+    `Memory set: ${JSON.stringify(payload.memories ?? [], null, 2).slice(0, 12e3)}`,
+    "",
+    'Return JSON: {"summary_text": string}'
+  ].join("\n");
+  return { system, user };
+}
+function formatDispatchReport(report) {
+  const lines = [
+    "# Recall Maintenance Dispatch",
+    `Provider:   ${report.provider ?? "(none \u2014 no API key)"}`,
+    `Dry run:    ${report.dry_run ? "yes" : "no"}`,
+    `Attempted:  ${report.attempted}`,
+    `Applied:    ${report.applied}`,
+    `Rejected:   ${report.rejected}`,
+    `Released:   ${report.released}`
+  ];
+  if (report.outcomes.length > 0) {
+    lines.push("", "## Outcomes");
+    for (const o of report.outcomes) {
+      const cost = o.cost_usd != null ? ` $${o.cost_usd.toFixed(4)}` : "";
+      const tokens = o.prompt_tokens != null ? ` tokens=${(o.prompt_tokens ?? 0) + (o.completion_tokens ?? 0)}` : "";
+      const reason = o.reason ? ` \u2014 ${o.reason}` : "";
+      lines.push(`  ${o.task_id.slice(0, 8)} ${o.kind.padEnd(20)} ${o.status.padEnd(10)}${tokens}${cost}${reason}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/capture/correction.ts
+import { randomUUID as randomUUID6 } from "crypto";
+
+// src/capture/scope.ts
+import { execSync } from "child_process";
+import { dirname, extname, basename } from "path";
+var SCOPE_MARKERS = [
+  {
+    pattern: /\b(in this file|this file only|just this file)\b/i,
+    scope: "path",
+    reason: "explicit file scope marker"
+  },
+  {
+    pattern: /\b(in this directory|in this folder|this dir)\b/i,
+    scope: "path",
+    reason: "explicit directory scope marker"
+  },
+  {
+    pattern: /\b(in this repo|for this repo|repo-wide|across the repo|this project)\b/i,
+    scope: "repo",
+    reason: "explicit repo scope marker"
+  },
+  {
+    pattern: /\b(team-wide|company-wide|org-wide|for the team|for the org|across the team)\b/i,
+    scope: "team",
+    reason: "explicit team/org scope marker"
+  },
+  {
+    pattern: /\b(for me always|always for me|agent-wide|regardless of project|across all my repos|in all my work|for all (?:my )?projects|everywhere|all repos)\b/i,
+    scope: "global",
+    reason: "explicit global/cross-repo scope marker"
+  },
+  {
+    pattern: /\b(just for now|this time|for this task|temporarily)\b/i,
+    scope: "session",
+    reason: "explicit session scope marker"
+  }
+];
+var FRAMEWORK_INDICATORS = [
+  /\b(typescript|javascript|python|rust|go|java|swift|ruby)\b/i,
+  /\b(react|vue|angular|svelte|next\.?js|express|fastify|django|flask|rails)\b/i,
+  /\b(eslint|prettier|biome|ruff|clippy|rubocop)\b/i,
+  /\b(jest|vitest|pytest|cargo test|go test)\b/i,
+  /\b(npm|yarn|pnpm|bun|pip|uv|poetry|cargo|go mod)\b/i
+];
+var FILE_TYPE_SCOPES = {
+  // Config files → repo scope
+  ".json": "repo",
+  ".yaml": "repo",
+  ".yml": "repo",
+  ".toml": "repo",
+  ".ini": "repo",
+  // Source files → path scope
+  ".ts": "path",
+  ".tsx": "path",
+  ".js": "path",
+  ".jsx": "path",
+  ".py": "path",
+  ".rs": "path",
+  ".go": "path",
+  ".swift": "path",
+  ".java": "path",
+  ".rb": "path",
+  // Test files → path scope
+  ".test.ts": "path",
+  ".spec.ts": "path",
+  ".test.js": "path",
+  ".spec.js": "path"
+};
+function inferScope(correctionText, contextPath, repoPath, context = {}) {
+  const markerHaystack = `${context.original_text ?? ""} ${correctionText}`;
+  for (const marker of SCOPE_MARKERS) {
+    if (marker.pattern.test(markerHaystack)) {
+      return {
+        scope: marker.scope,
+        path_scope: marker.scope === "path" && contextPath ? inferPathScope(contextPath) : null,
+        confidence_modifier: 0.1,
+        // boost for explicit markers
+        reason: marker.reason
+      };
+    }
+  }
+  for (const indicator of FRAMEWORK_INDICATORS) {
+    if (indicator.test(correctionText)) {
+      return {
+        scope: "repo",
+        path_scope: null,
+        confidence_modifier: 0.05,
+        reason: "language/framework reference implies repo scope"
+      };
+    }
+  }
+  if (contextPath) {
+    const ext = extname(contextPath);
+    const base = basename(contextPath);
+    if (base.includes(".test.") || base.includes(".spec.") || contextPath.includes("__tests__") || contextPath.includes("/test/")) {
+      return {
+        scope: "path",
+        path_scope: inferPathScope(contextPath),
+        confidence_modifier: 0,
+        reason: "test file context \u2192 path scope"
+      };
+    }
+    if (FILE_TYPE_SCOPES[ext] === "repo" || base === "package.json" || base === "tsconfig.json" || base === "Makefile") {
+      return {
+        scope: "repo",
+        path_scope: null,
+        confidence_modifier: 0.05,
+        reason: "config file context \u2192 repo scope"
+      };
+    }
+    if (FILE_TYPE_SCOPES[ext] === "path") {
+      return {
+        scope: "path",
+        path_scope: inferPathScope(contextPath),
+        confidence_modifier: 0,
+        reason: "source file context \u2192 directory scope"
+      };
+    }
+  }
+  const toolScope = inferFromRecentTools(context.recent_tool_calls);
+  if (toolScope) {
+    return toolScope;
+  }
+  const assistantScope = inferFromAssistantTurn(context.prev_assistant_turn);
+  if (assistantScope) {
+    return assistantScope;
+  }
+  if (hasSpecificFileReference(correctionText)) {
+    return {
+      scope: "path",
+      path_scope: extractPathFromText(correctionText),
+      confidence_modifier: 0,
+      reason: "specific file/path reference in correction"
+    };
+  }
+  if (contextPath && repoPath) {
+    const ownerScope = inferFromGitOwnership(contextPath, repoPath);
+    if (ownerScope) return ownerScope;
+  }
+  return {
+    scope: "repo",
+    path_scope: null,
+    confidence_modifier: 0,
+    reason: "default: no specific scope signals detected"
+  };
+}
+function inferPathScope(filePath) {
+  const dir = dirname(filePath);
+  return `${dir}/**`;
+}
+function hasSpecificFileReference(text) {
+  return /\b[\w-]+\.(ts|js|py|rs|go|swift|java|rb|tsx|jsx|vue|svelte)\b/.test(text) || /\b(src|lib|app|components|utils|test|spec)\//.test(text);
+}
+function extractPathFromText(text) {
+  const pathMatch = text.match(
+    /\b((?:src|lib|app|components|utils|test|spec)\/[\w/.-]+)/
+  );
+  if (pathMatch) return `${pathMatch[1]}**`;
+  const dirMatch = text.match(
+    /\b((?:src|lib|app|components|utils|test|spec)\/[\w/-]*)/
+  );
+  if (dirMatch) return `${dirMatch[1]}/**`;
+  return null;
+}
+var SOURCE_AWARE_TOOLS = /* @__PURE__ */ new Set([
+  "Read",
+  "Edit",
+  "Write",
+  "MultiEdit",
+  "NotebookEdit",
+  "NotebookRead",
+  "Grep",
+  "Glob"
+]);
+function isPathInsideRepo(path) {
+  if (path.startsWith("/")) return false;
+  if (/^(?:Applications|app|usr|opt|System|Library|private|var|tmp)\//.test(path)) return false;
+  return true;
+}
+function inferFromRecentTools(toolCalls) {
+  if (!toolCalls || toolCalls.length === 0) return null;
+  for (const toolCall of toolCalls) {
+    if (toolCall.path && SOURCE_AWARE_TOOLS.has(toolCall.name) && isPathInsideRepo(toolCall.path)) {
+      return {
+        scope: "path",
+        path_scope: inferPathScope(toolCall.path),
+        confidence_modifier: 0.05,
+        reason: `recent tool path context: ${toolCall.path}`
+      };
+    }
+    const inferredPath = extractPathFromText(toolCall.input_summary ?? "");
+    if (inferredPath) {
+      return {
+        scope: "path",
+        path_scope: inferredPath,
+        confidence_modifier: 0.05,
+        reason: "recent tool summary implies path scope"
+      };
+    }
+    const summary = toolCall.input_summary ?? "";
+    if (/\b(pytest|vitest|jest|cargo test|go test)\b/i.test(summary)) {
+      return {
+        scope: "repo",
+        path_scope: null,
+        confidence_modifier: 0.04,
+        reason: "recent test/tool pattern implies repo scope"
+      };
+    }
+  }
+  return null;
+}
+function inferFromAssistantTurn(assistantTurn) {
+  if (!assistantTurn) return null;
+  const inferredPath = extractPathFromText(assistantTurn);
+  if (inferredPath) {
+    return {
+      scope: "path",
+      path_scope: inferredPath,
+      confidence_modifier: 0.05,
+      reason: "previous assistant turn referenced a path"
+    };
+  }
+  for (const indicator of FRAMEWORK_INDICATORS) {
+    if (indicator.test(assistantTurn)) {
+      return {
+        scope: "repo",
+        path_scope: null,
+        confidence_modifier: 0.03,
+        reason: "previous assistant turn referenced repo-level tooling/framework"
+      };
+    }
+  }
+  return null;
+}
+function inferFromGitOwnership(filePath, repoPath) {
+  try {
+    const codeowners = execSync(
+      `cat .github/CODEOWNERS 2>/dev/null || cat CODEOWNERS 2>/dev/null || echo ""`,
+      { cwd: repoPath, encoding: "utf-8" }
+    ).trim();
+    if (codeowners) {
+      const dir = dirname(filePath);
+      for (const line of codeowners.split("\n")) {
+        if (line.startsWith("#") || !line.trim()) continue;
+        const parts = line.trim().split(/\s+/);
+        if (parts.length >= 2 && filePath.includes(parts[0].replace("*", ""))) {
+          return {
+            scope: "path",
+            path_scope: `${parts[0]}`,
+            confidence_modifier: 0.05,
+            reason: `CODEOWNERS match: ${parts[0]} \u2192 ${parts.slice(1).join(", ")}`
+          };
+        }
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+
+// src/maintenance/cleanup.ts
+import { and as and3, eq as eq9, gte as gte2, inArray as inArray2, sql as sql2 } from "drizzle-orm";
+import { randomUUID as randomUUID5 } from "crypto";
+
+// src/contradictions/detector.ts
+import { eq as eq8, and as and2 } from "drizzle-orm";
+import { randomUUID as randomUUID4 } from "crypto";
+function detectContradictions(db, repo) {
+  const mems = queryMemories(db, { repo }).filter(
+    (m) => m.status === "active" || m.status === "candidate"
+  );
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < mems.length; i++) {
+    for (let j = i + 1; j < mems.length; j++) {
+      const a = mems[i];
+      const b = mems[j];
+      const pairKey = [a.id, b.id].sort().join(":");
+      if (seen.has(pairKey)) continue;
+      const contradiction = checkContradiction(a, b);
+      if (contradiction) {
+        seen.add(pairKey);
+        const existing = db.select().from(contradictions).where(
+          and2(
+            eq8(contradictions.memory_a_id, a.id),
+            eq8(contradictions.memory_b_id, b.id)
+          )
+        ).get();
+        if (!existing) {
+          const id = randomUUID4();
+          const now = (/* @__PURE__ */ new Date()).toISOString();
+          db.insert(contradictions).values({
+            id,
+            memory_a_id: a.id,
+            memory_b_id: b.id,
+            contradiction_type: contradiction.type,
+            severity: contradiction.severity,
+            description: contradiction.description,
+            resolved: false,
+            detected_at: now
+          }).run();
+          recordAudit(db, a.id, "contradiction_detected", "system", contradiction.description);
+          recordAudit(db, b.id, "contradiction_detected", "system", contradiction.description);
+          found.push({
+            id,
+            memory_a_id: a.id,
+            memory_b_id: b.id,
+            contradiction_type: contradiction.type,
+            severity: contradiction.severity,
+            description: contradiction.description,
+            resolved: false,
+            resolution: null,
+            detected_at: now,
+            resolved_at: null
+          });
+        }
+      }
+    }
+  }
+  return found;
+}
+function checkContradiction(a, b) {
+  if (!scopesOverlap(a, b)) return null;
+  const negation = checkDirectNegation(a, b);
+  if (negation) return negation;
+  const conflict = checkConflictingRules(a, b);
+  if (conflict) return conflict;
+  if (a.supersedes === b.id || b.supersedes === a.id) {
+    return {
+      type: "superseded",
+      severity: "medium",
+      description: `One memory supersedes the other`
+    };
+  }
+  return null;
+}
+var NEGATION_PAIRS = [
+  [/\balways\b/i, /\bnever\b/i],
+  [/\bdo\b/i, /\bdo not\b|don't\b/i],
+  [/\buse\b/i, /\bdo not use\b|don't use\b|never use\b/i],
+  [/\brequired\b/i, /\bforbidden\b|prohibited\b/i],
+  [/\benable\b/i, /\bdisable\b/i]
+];
+function checkDirectNegation(a, b) {
+  for (const [pos, neg] of NEGATION_PAIRS) {
+    const aPos = pos.test(a.text) && !neg.test(a.text);
+    const aNeg = neg.test(a.text) && !pos.test(a.text);
+    const bPos = pos.test(b.text) && !neg.test(b.text);
+    const bNeg = neg.test(b.text) && !pos.test(b.text);
+    if (aPos && bNeg || aNeg && bPos) {
+      const subjectA = extractSubject(a.text);
+      const subjectB = extractSubject(b.text);
+      if (subjectA && subjectB && wordOverlap(subjectA, subjectB) > 0.5) {
+        return {
+          type: "direct_negation",
+          severity: "high",
+          description: `"${a.text}" contradicts "${b.text}"`
+        };
+      }
+    }
+  }
+  return null;
+}
+function checkConflictingRules(a, b) {
+  if (a.type !== b.type) return null;
+  if (a.type !== "rule" && a.type !== "command") return null;
+  const useA = a.text.match(/\buse\s+(\S+)/i);
+  const useB = b.text.match(/\buse\s+(\S+)/i);
+  if (useA && useB) {
+    const toolA = useA[1].toLowerCase().replace(/[,.:;]/g, "");
+    const toolB = useB[1].toLowerCase().replace(/[,.:;]/g, "");
+    if (toolA !== toolB) {
+      const contextA = extractContext(a.text);
+      const contextB = extractContext(b.text);
+      if (contextA && contextB && wordOverlap(contextA, contextB) > 0.3) {
+        return {
+          type: "conflicting_rules",
+          severity: "medium",
+          description: `"use ${toolA}" vs "use ${toolB}" in similar context`
+        };
+      }
+    }
+  }
+  const sim = wordOverlap(a.text, b.text);
+  if (sim > 0.6 && sim < 0.95 && a.text !== b.text) {
+    return {
+      type: "scope_overlap",
+      severity: "low",
+      description: `Very similar memories (${(sim * 100).toFixed(0)}% overlap): "${a.text.slice(0, 50)}" vs "${b.text.slice(0, 50)}"`
+    };
+  }
+  return null;
+}
+function resolveContradiction(db, contradictionId, keepMemoryId, actor, resolution) {
+  const row = db.select().from(contradictions).where(eq8(contradictions.id, contradictionId)).get();
+  if (!row) return false;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const demoteId = row.memory_a_id === keepMemoryId ? row.memory_b_id : row.memory_a_id;
+  demoteMemory(db, demoteId, `contradiction resolved: keep ${keepMemoryId.slice(0, 8)}`);
+  db.update(contradictions).set({
+    resolved: true,
+    resolution: resolution ?? `Kept ${keepMemoryId.slice(0, 8)}, demoted ${demoteId.slice(0, 8)}`,
+    resolved_at: now
+  }).where(eq8(contradictions.id, contradictionId)).run();
+  recordAudit(db, keepMemoryId, "contradiction_resolved", actor, resolution ?? null);
+  recordAudit(db, demoteId, "contradiction_resolved", actor, `demoted in favor of ${keepMemoryId.slice(0, 8)}`);
+  return true;
+}
+function autoResolveContradictions(db, repo) {
+  const unresolved = db.select().from(contradictions).where(eq8(contradictions.resolved, false)).all();
+  let resolved = 0;
+  for (const c of unresolved) {
+    const a = getMemory(db, c.memory_a_id);
+    const b = getMemory(db, c.memory_b_id);
+    if (!a || !b) continue;
+    if (repo && a.repo !== repo && b.repo !== repo) continue;
+    if (c.severity === "low") continue;
+    if (Math.abs(a.confidence - b.confidence) < 0.15) continue;
+    const keepId = a.confidence >= b.confidence ? a.id : b.id;
+    resolveContradiction(db, c.id, keepId, "auto-resolver", "Auto-resolved: higher confidence wins");
+    resolved++;
+  }
+  return resolved;
+}
+function listContradictions(db, options = {}) {
+  if (options.resolved !== void 0) {
+    return db.select().from(contradictions).where(eq8(contradictions.resolved, options.resolved)).all();
+  }
+  return db.select().from(contradictions).all();
+}
+function scopesOverlap(a, b) {
+  if (a.scope === "global" || b.scope === "global") return true;
+  if (a.scope === "team" || b.scope === "team") return true;
+  if (a.scope === "repo" && b.scope === "repo") {
+    return !a.repo || !b.repo || a.repo === b.repo;
+  }
+  if (a.scope === "path" && b.scope === "path") {
+    if (!a.path_scope || !b.path_scope) return true;
+    return a.path_scope.startsWith(b.path_scope.replace("/**", "")) || b.path_scope.startsWith(a.path_scope.replace("/**", ""));
+  }
+  if (a.scope === "repo" && b.scope === "path" || a.scope === "path" && b.scope === "repo") {
+    return !a.repo || !b.repo || a.repo === b.repo;
+  }
+  return false;
+}
+function extractSubject(text) {
+  return text.replace(/\b(always|never|must|do not|don't|use|do|run|call|import)\b/gi, "").trim().toLowerCase();
+}
+function extractContext(text) {
+  return text.replace(/\buse\s+\S+/i, "").trim().toLowerCase();
+}
+function wordOverlap(a, b) {
+  const wordsA = new Set(a.toLowerCase().split(/\s+/).filter((w) => w.length > 2));
+  const wordsB = new Set(b.toLowerCase().split(/\s+/).filter((w) => w.length > 2));
+  if (wordsA.size === 0 || wordsB.size === 0) return 0;
+  const intersection = [...wordsA].filter((w) => wordsB.has(w));
+  const union = /* @__PURE__ */ new Set([...wordsA, ...wordsB]);
+  return intersection.length / union.size;
+}
+
+// src/maintenance/cleanup.ts
+var SUPPRESS_INJECTION_FLOOR = 50;
+var GLOBALIZE_REPO_FLOOR = 3;
+var DEFAULT_ACTOR = "maintenance:cleanup";
+function runDeterministicCleanup(db, opts = { dryRun: true }) {
+  const runId = randomUUID5();
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const plan = [];
+  if (!opts.only || opts.only === "dedupe_exact_merge") {
+    plan.push(...planDedupeExact(db));
+  }
+  if (!opts.only || opts.only === "reject_fragment_candidate") {
+    plan.push(...planRejectFragments(db));
+  }
+  if (!opts.only || opts.only === "promote_repeat_correction") {
+    plan.push(...planPromoteRepeats(db));
+  }
+  if (!opts.only || opts.only === "suppress_unproductive_command") {
+    plan.push(...planSuppressCommands(db));
+  }
+  if (!opts.only || opts.only === "globalize_cross_repo") {
+    plan.push(...planGlobalizeCrossRepo(db));
+  }
+  const counts = summarize(plan);
+  if (!opts.dryRun) {
+    for (const item of plan) {
+      switch (item.kind) {
+        case "dedupe_exact_merge":
+          applyDedupeExact(db, runId, item);
+          break;
+        case "reject_fragment_candidate":
+          applyRejectFragment(db, runId, item);
+          break;
+        case "promote_repeat_correction":
+          applyPromoteRepeat(db, runId, item);
+          break;
+        case "suppress_unproductive_command":
+          applySuppressCommand(db, runId, item);
+          break;
+        case "globalize_cross_repo":
+          applyGlobalizeCrossRepo(db, runId, item);
+          break;
+      }
+    }
+  }
+  return {
+    run_id: runId,
+    dry_run: opts.dryRun,
+    started_at: startedAt,
+    finished_at: (/* @__PURE__ */ new Date()).toISOString(),
+    counts,
+    plan
+  };
+}
+function summarize(plan) {
+  let dedupeClusters = 0;
+  let dedupeLosers = 0;
+  let fragmentRejections = 0;
+  let repeatPromotions = 0;
+  let commandSuppressions = 0;
+  let globalizations = 0;
+  let globalizeLosers = 0;
+  for (const p of plan) {
+    if (p.kind === "dedupe_exact_merge") {
+      dedupeClusters += 1;
+      dedupeLosers += p.loser_ids.length;
+    } else if (p.kind === "reject_fragment_candidate") {
+      fragmentRejections += 1;
+    } else if (p.kind === "promote_repeat_correction") {
+      repeatPromotions += 1;
+    } else if (p.kind === "suppress_unproductive_command") {
+      commandSuppressions += 1;
+    } else {
+      globalizations += 1;
+      globalizeLosers += p.loser_ids.length;
+    }
+  }
+  return {
+    dedupe_clusters: dedupeClusters,
+    dedupe_losers: dedupeLosers,
+    fragment_rejections: fragmentRejections,
+    repeat_promotions: repeatPromotions,
+    command_suppressions: commandSuppressions,
+    globalizations,
+    globalize_losers: globalizeLosers
+  };
+}
+function normalizeText(text) {
+  return text.toLowerCase().replace(/\s+/g, " ").replace(/[\s.;:,!?`]+$/g, "").trim();
+}
+function scopeKey(row) {
+  return [row.type, row.scope, row.repo ?? "", row.path_scope ?? "", row.norm].join("\0");
+}
+function planDedupeExact(db) {
+  const rows = db.select({
+    id: memories.id,
+    type: memories.type,
+    text: memories.text,
+    scope: memories.scope,
+    repo: memories.repo,
+    path_scope: memories.path_scope,
+    status: memories.status,
+    injection_count: memories.injection_count,
+    confidence: memories.confidence,
+    created_at: memories.created_at
+  }).from(memories).where(inArray2(memories.status, ["active", "candidate"])).all();
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const norm = normalizeText(row.text);
+    if (!norm) continue;
+    const key = scopeKey({ ...row, norm });
+    const list = groups.get(key) ?? [];
+    list.push(row);
+    groups.set(key, list);
+  }
+  const plans = [];
+  for (const [key, list] of groups) {
+    if (list.length < 2) continue;
+    const sorted = [...list].sort((a, b) => {
+      const statusRank = (s) => s === "active" ? 0 : 1;
+      const dStatus = statusRank(a.status) - statusRank(b.status);
+      if (dStatus !== 0) return dStatus;
+      if (a.injection_count !== b.injection_count) return b.injection_count - a.injection_count;
+      if (a.confidence !== b.confidence) return b.confidence - a.confidence;
+      return a.created_at.localeCompare(b.created_at);
+    });
+    const winner = sorted[0];
+    const losers = sorted.slice(1);
+    const total = list.reduce((acc, r) => acc + r.injection_count, 0);
+    plans.push({
+      kind: "dedupe_exact_merge",
+      winner_id: winner.id,
+      winner_text: winner.text,
+      loser_ids: losers.map((l) => l.id),
+      scope_key: key,
+      total_injection_count: total
+    });
+  }
+  return plans;
+}
+function applyDedupeExact(db, runId, plan) {
+  const winner = getMemory(db, plan.winner_id);
+  if (!winner) return;
+  const losers = plan.loser_ids.map((id) => getMemory(db, id)).filter((m) => m != null);
+  if (losers.length === 0) return;
+  const sumCounts = losers.reduce(
+    (acc, l) => ({
+      injection: acc.injection + l.injection_count,
+      override: acc.override + l.override_count,
+      repetition: acc.repetition + l.repetition_count
+    }),
+    { injection: 0, override: 0, repetition: 0 }
+  );
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const loser of losers) {
+    db.update(feedbackEvents).set({ memory_id: winner.id }).where(eq9(feedbackEvents.memory_id, loser.id)).run();
+    const loserInj = db.select().from(memoryInjections).where(eq9(memoryInjections.memory_id, loser.id)).all();
+    for (const inj of loserInj) {
+      const collision = db.select({ id: memoryInjections.id }).from(memoryInjections).where(and3(eq9(memoryInjections.memory_id, winner.id), eq9(memoryInjections.session_id, inj.session_id))).get();
+      if (collision) {
+        db.delete(memoryInjections).where(eq9(memoryInjections.id, inj.id)).run();
+      } else {
+        db.update(memoryInjections).set({ memory_id: winner.id }).where(eq9(memoryInjections.id, inj.id)).run();
+      }
+    }
+  }
+  db.update(memories).set({
+    injection_count: winner.injection_count + sumCounts.injection,
+    override_count: winner.override_count + sumCounts.override,
+    repetition_count: winner.repetition_count + sumCounts.repetition,
+    updated_at: now
+  }).where(eq9(memories.id, winner.id)).run();
+  for (const loser of losers) {
+    db.update(memories).set({ status: "rejected", supersedes: winner.id, dedupe_key: null, updated_at: now }).where(eq9(memories.id, loser.id)).run();
+    const after = getMemory(db, loser.id);
+    recordAuditWithSnapshot(
+      db,
+      loser.id,
+      "rejected",
+      DEFAULT_ACTOR,
+      `dedupe_exact:merged_into:${winner.id}:run:${runId}`,
+      loser,
+      after ?? null
+    );
+    db.insert(maintenanceCleanupLog).values({
+      id: randomUUID5(),
+      run_id: runId,
+      action: "dedupe_exact_merge",
+      memory_id: loser.id,
+      related_memory_id: winner.id,
+      before_snapshot: loser,
+      after_snapshot: after,
+      details: { scope_key: plan.scope_key, transferred_injection_count: loser.injection_count },
+      reverted: false,
+      reverted_at: null,
+      created_at: now
+    }).run();
+  }
+}
+var VERB_HINTS = [
+  "use",
+  "uses",
+  "used",
+  "run",
+  "runs",
+  "ran",
+  "avoid",
+  "prefer",
+  "keep",
+  "set",
+  "add",
+  "remove",
+  "skip",
+  "replace",
+  "fix",
+  "ensure",
+  "require",
+  "make",
+  "build",
+  "test",
+  "deploy",
+  "install",
+  "import",
+  "export",
+  "commit",
+  "push",
+  "call",
+  "wrap",
+  "split",
+  "merge",
+  "store",
+  "load",
+  "save",
+  "ignore",
+  "accept",
+  "reject",
+  "update",
+  "create",
+  "delete",
+  "rename",
+  "move",
+  "copy",
+  "validate",
+  "verify",
+  "check",
+  "follow",
+  "read",
+  "write",
+  "open",
+  "close",
+  "send",
+  "receive",
+  "configure",
+  "enable",
+  "disable"
+];
+var BARE_MODAL_RE = /^\s*(must|never|always|do not|don't|required|prefer|should)\b[^\w]*(stay|do|stop|go|reply|reply\?)?\s*$/i;
+var TRAILING_QUESTION_RE = /\?\s*$/;
+var DANGLING_CONNECTOR_RE = /\b(?:and|or|but|with|without|to|from|for|of|as|because|instead|over|the|a|an|on|in|at|by)\s*$/i;
+var TRAILING_DOUBLE_DOT_RE = /\.{2,}\s*$/;
+var TRAILING_DASH_RE = /[—–-]\s*$/;
+var EMBEDDED_QUESTION_RE = /^\s*(?:always|never|must|don't|do not|required|prefer|should)\s+(?:can|could|would|will|do|does|did|is|are|was|were|have|has|should|may|might)\s+(?:you|we|i|they|it|he|she)\b/i;
+var RULE_FILLER_PREFIX_RE = /^\s*(?:always|never|must|don't|do not|prefer|required)\s+(?:just|now|uh|um|so|like|maybe|kinda|sort\s+of)\b/i;
+var MAX_RULE_LENGTH = 300;
+var MIN_RULE_LENGTH = 20;
+function planRejectFragments(db) {
+  const rows = db.select({
+    id: memories.id,
+    text: memories.text,
+    source: memories.source,
+    status: memories.status
+  }).from(memories).where(and3(eq9(memories.status, "candidate"), eq9(memories.source, "user_correction"))).all();
+  const out = [];
+  for (const row of rows) {
+    const reasons = qualityReasons(row.text);
+    if (reasons.length > 0) {
+      out.push({
+        kind: "reject_fragment_candidate",
+        memory_id: row.id,
+        text: row.text,
+        reasons
+      });
+    }
+  }
+  return out;
+}
+function qualityReasons(rawText) {
+  const text = rawText.trim();
+  const reasons = [];
+  if (text.length < MIN_RULE_LENGTH) reasons.push("too_short");
+  if (text.length > MAX_RULE_LENGTH) reasons.push("too_long");
+  if (TRAILING_QUESTION_RE.test(text)) reasons.push("trailing_question");
+  if (BARE_MODAL_RE.test(text)) reasons.push("bare_modal");
+  if (TRAILING_DOUBLE_DOT_RE.test(text)) reasons.push("trailing_double_dot");
+  if (TRAILING_DASH_RE.test(text)) reasons.push("trailing_dash");
+  if (DANGLING_CONNECTOR_RE.test(text)) reasons.push("dangling_connector");
+  if (RULE_FILLER_PREFIX_RE.test(text)) reasons.push("filler_prefix");
+  if (EMBEDDED_QUESTION_RE.test(text)) reasons.push("embedded_question");
+  const words = text.toLowerCase().replace(/[^\w' ]+/g, " ").split(/\s+/).filter(Boolean);
+  const hasVerb = words.some((w) => VERB_HINTS.includes(w));
+  if (!hasVerb) reasons.push("no_verb");
+  return reasons;
+}
+function applyRejectFragment(db, runId, plan) {
+  const before = getMemory(db, plan.memory_id);
+  if (!before || before.status !== "candidate") return;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.update(memories).set({ status: "rejected", dedupe_key: null, updated_at: now }).where(eq9(memories.id, plan.memory_id)).run();
+  const after = getMemory(db, plan.memory_id);
+  recordAuditWithSnapshot(
+    db,
+    plan.memory_id,
+    "rejected",
+    DEFAULT_ACTOR,
+    `cleanup_fragment:${plan.reasons.join(",")}:run:${runId}`,
+    before,
+    after ?? null
+  );
+  db.insert(maintenanceCleanupLog).values({
+    id: randomUUID5(),
+    run_id: runId,
+    action: "reject_fragment_candidate",
+    memory_id: plan.memory_id,
+    related_memory_id: null,
+    before_snapshot: before,
+    after_snapshot: after,
+    details: { reasons: plan.reasons },
+    reverted: false,
+    reverted_at: null,
+    created_at: now
+  }).run();
+}
+function planPromoteRepeats(db) {
+  const rows = db.select({
+    id: memories.id,
+    text: memories.text,
+    repetition_count: memories.repetition_count,
+    source: memories.source,
+    status: memories.status
+  }).from(memories).where(and3(eq9(memories.status, "candidate"), eq9(memories.source, "user_correction"))).all();
+  const out = [];
+  for (const row of rows) {
+    const text = row.text.trim();
+    if (qualityReasons(text).length > 0) continue;
+    if (isDestructiveRisky(text)) continue;
+    if (row.repetition_count >= 2) {
+      out.push({ kind: "promote_repeat_correction", memory_id: row.id, text, matched_pattern: "repetition" });
+    }
+  }
+  return out;
+}
+function applyPromoteRepeat(db, runId, plan) {
+  const before = getMemory(db, plan.memory_id);
+  if (!before || before.status !== "candidate") return;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.update(memories).set({ status: "active", confidence: Math.max(before.confidence, 0.7), updated_at: now, last_validated_at: now }).where(eq9(memories.id, plan.memory_id)).run();
+  const after = getMemory(db, plan.memory_id);
+  recordAuditWithSnapshot(
+    db,
+    plan.memory_id,
+    "promoted",
+    DEFAULT_ACTOR,
+    `cleanup_promote:${plan.matched_pattern}:run:${runId}`,
+    before,
+    after ?? null
+  );
+  db.insert(maintenanceCleanupLog).values({
+    id: randomUUID5(),
+    run_id: runId,
+    action: "promote_repeat_correction",
+    memory_id: plan.memory_id,
+    related_memory_id: null,
+    before_snapshot: before,
+    after_snapshot: after,
+    details: { matched_pattern: plan.matched_pattern },
+    reverted: false,
+    reverted_at: null,
+    created_at: now
+  }).run();
+}
+function planSuppressCommands(db) {
+  const candidates = db.select({
+    id: memories.id,
+    text: memories.text,
+    injection_count: memories.injection_count
+  }).from(memories).where(and3(
+    eq9(memories.status, "active"),
+    eq9(memories.type, "command"),
+    eq9(memories.auto_inject, true),
+    gte2(memories.injection_count, SUPPRESS_INJECTION_FLOOR)
+  )).all();
+  const out = [];
+  for (const row of candidates) {
+    const followedRow = db.select({ n: sql2`count(*)` }).from(feedbackEvents).where(and3(
+      eq9(feedbackEvents.memory_id, row.id),
+      eq9(feedbackEvents.outcome, "followed")
+    )).get();
+    const followed = followedRow?.n ?? 0;
+    if (followed > 0) continue;
+    out.push({
+      kind: "suppress_unproductive_command",
+      memory_id: row.id,
+      text: row.text,
+      injection_count: row.injection_count,
+      followed_count: followed
+    });
+  }
+  return out;
+}
+function applySuppressCommand(db, runId, plan) {
+  const before = getMemory(db, plan.memory_id);
+  if (!before || !before.auto_inject) return;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.update(memories).set({ auto_inject: false, updated_at: now }).where(eq9(memories.id, plan.memory_id)).run();
+  const after = getMemory(db, plan.memory_id);
+  recordAuditWithSnapshot(
+    db,
+    plan.memory_id,
+    "demoted",
+    DEFAULT_ACTOR,
+    `cleanup_suppress_command:inj=${plan.injection_count},followed=0:run:${runId}`,
+    before,
+    after ?? null
+  );
+  db.insert(maintenanceCleanupLog).values({
+    id: randomUUID5(),
+    run_id: runId,
+    action: "suppress_unproductive_command",
+    memory_id: plan.memory_id,
+    related_memory_id: null,
+    before_snapshot: before,
+    after_snapshot: after,
+    details: {
+      injection_count: plan.injection_count,
+      followed_count: plan.followed_count
+    },
+    reverted: false,
+    reverted_at: null,
+    created_at: now
+  }).run();
+}
+function planGlobalizeCrossRepo(db) {
+  const rows = db.select({
+    id: memories.id,
+    type: memories.type,
+    text: memories.text,
+    scope: memories.scope,
+    repo: memories.repo,
+    injection_count: memories.injection_count,
+    confidence: memories.confidence,
+    created_at: memories.created_at
+  }).from(memories).where(and3(eq9(memories.status, "active"), inArray2(memories.type, ["command", "rule"]))).all();
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (row.scope === "global") continue;
+    if (!row.repo) continue;
+    const norm = normalizeText(row.text);
+    if (!norm) continue;
+    const key = `${row.type}::${norm}`;
+    const list = groups.get(key) ?? [];
+    list.push(row);
+    groups.set(key, list);
+  }
+  const allActive = queryMemories(db, { status: "active" }).filter((m) => m.type === "rule" || m.type === "command");
+  const plans = [];
+  for (const list of groups.values()) {
+    const repos = new Set(list.map((r) => r.repo));
+    if (repos.size < GLOBALIZE_REPO_FLOOR) continue;
+    const sorted = [...list].sort((a, b) => {
+      if (a.injection_count !== b.injection_count) return b.injection_count - a.injection_count;
+      if (a.confidence !== b.confidence) return b.confidence - a.confidence;
+      return a.created_at.localeCompare(b.created_at);
+    });
+    const winner = sorted[0];
+    const winnerMemory = getMemory(db, winner.id);
+    if (!winnerMemory) continue;
+    const clusterIds = new Set(list.map((r) => r.id));
+    const conflict = allActive.find((other) => {
+      if (clusterIds.has(other.id)) return false;
+      if (!other.repo || repos.has(other.repo)) return false;
+      const winnerAsGlobal = { ...winnerMemory, scope: "global" };
+      return checkContradiction(winnerAsGlobal, other) != null;
+    });
+    if (conflict) continue;
+    const losers = sorted.slice(1);
+    const total = list.reduce((acc, r) => acc + r.injection_count, 0);
+    plans.push({
+      kind: "globalize_cross_repo",
+      winner_id: winner.id,
+      winner_text: winner.text,
+      loser_ids: losers.map((l) => l.id),
+      repos: [...repos],
+      total_injection_count: total
+    });
+  }
+  return plans;
+}
+function applyGlobalizeCrossRepo(db, runId, plan) {
+  const winner = getMemory(db, plan.winner_id);
+  if (!winner) return;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const globalDedupeKey = memoryDedupeKey({ ...winner, scope: "global", repo: null });
+  const globalDedupeCollision = db.select({ id: memories.id }).from(memories).where(eq9(memories.dedupe_key, globalDedupeKey)).get();
+  db.update(memories).set({
+    scope: "global",
+    repo: null,
+    dedupe_key: globalDedupeCollision && globalDedupeCollision.id !== winner.id ? null : globalDedupeKey,
+    updated_at: now
+  }).where(eq9(memories.id, winner.id)).run();
+  const after = getMemory(db, winner.id);
+  recordAuditWithSnapshot(
+    db,
+    winner.id,
+    "edited",
+    DEFAULT_ACTOR,
+    `cleanup_globalize:winner:run:${runId}`,
+    winner,
+    after ?? null
+  );
+  db.insert(maintenanceCleanupLog).values({
+    id: randomUUID5(),
+    run_id: runId,
+    action: "globalize_cross_repo",
+    memory_id: winner.id,
+    related_memory_id: null,
+    before_snapshot: winner,
+    after_snapshot: after,
+    details: { role: "winner", repos: plan.repos },
+    reverted: false,
+    reverted_at: null,
+    created_at: now
+  }).run();
+  for (const loserId of plan.loser_ids) {
+    const loser = getMemory(db, loserId);
+    if (!loser || loser.status === "rejected") continue;
+    db.update(memories).set({ status: "rejected", supersedes: winner.id, dedupe_key: null, updated_at: now }).where(eq9(memories.id, loserId)).run();
+    const afterLoser = getMemory(db, loserId);
+    recordAuditWithSnapshot(
+      db,
+      loserId,
+      "rejected",
+      DEFAULT_ACTOR,
+      `cleanup_globalize:loser:winner=${winner.id}:run:${runId}`,
+      loser,
+      afterLoser ?? null
+    );
+    db.insert(maintenanceCleanupLog).values({
+      id: randomUUID5(),
+      run_id: runId,
+      action: "globalize_cross_repo",
+      memory_id: loserId,
+      related_memory_id: winner.id,
+      before_snapshot: loser,
+      after_snapshot: afterLoser,
+      details: { role: "loser", repo: loser.repo },
+      reverted: false,
+      reverted_at: null,
+      created_at: now
+    }).run();
+  }
+}
+function revertCleanupRun(db, runId) {
+  const rows = db.select().from(maintenanceCleanupLog).where(eq9(maintenanceCleanupLog.run_id, runId)).all();
+  if (rows.length === 0) {
+    return { run_id: runId, reverted: 0, skipped: 0, reasons: { not_found: 1 } };
+  }
+  const reasons = {};
+  let reverted = 0;
+  let skipped = 0;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const row of rows) {
+    if (row.reverted) {
+      skipped += 1;
+      reasons.already_reverted = (reasons.already_reverted ?? 0) + 1;
+      continue;
+    }
+    const before = row.before_snapshot;
+    if (!before || !before.status) {
+      skipped += 1;
+      reasons.no_snapshot = (reasons.no_snapshot ?? 0) + 1;
+      continue;
+    }
+    const current = getMemory(db, row.memory_id);
+    if (!current) {
+      skipped += 1;
+      reasons.memory_missing = (reasons.memory_missing ?? 0) + 1;
+      continue;
+    }
+    db.update(memories).set({
+      status: before.status,
+      text: before.text ?? current.text,
+      scope: before.scope ?? current.scope,
+      path_scope: before.path_scope ?? current.path_scope,
+      repo: before.repo !== void 0 ? before.repo : current.repo,
+      confidence: before.confidence ?? current.confidence,
+      injection_count: before.injection_count ?? current.injection_count,
+      override_count: before.override_count ?? current.override_count,
+      repetition_count: before.repetition_count ?? current.repetition_count,
+      supersedes: before.supersedes ?? null,
+      auto_inject: before.auto_inject ?? current.auto_inject,
+      updated_at: now
+    }).where(eq9(memories.id, row.memory_id)).run();
+    const after = getMemory(db, row.memory_id);
+    recordAuditWithSnapshot(
+      db,
+      row.memory_id,
+      "rolled_back",
+      DEFAULT_ACTOR,
+      `cleanup_revert:run:${runId}:log:${row.id}`,
+      current,
+      after ?? null
+    );
+    db.update(maintenanceCleanupLog).set({ reverted: true, reverted_at: now }).where(eq9(maintenanceCleanupLog.id, row.id)).run();
+    reverted += 1;
+  }
+  return { run_id: runId, reverted, skipped, reasons };
+}
+function listCleanupRuns(db, limit = 10) {
+  const rows = db.select().from(maintenanceCleanupLog).all();
+  const byRun = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    let entry = byRun.get(row.run_id);
+    if (!entry) {
+      entry = {
+        run_id: row.run_id,
+        started_at: row.created_at,
+        finished_at: row.created_at,
+        total: 0,
+        by_action: {},
+        reverted: 0
+      };
+      byRun.set(row.run_id, entry);
+    }
+    entry.total += 1;
+    entry.by_action[row.action] = (entry.by_action[row.action] ?? 0) + 1;
+    if (row.reverted) entry.reverted += 1;
+    if (row.created_at < entry.started_at) entry.started_at = row.created_at;
+    if (row.created_at > entry.finished_at) entry.finished_at = row.created_at;
+  }
+  return [...byRun.values()].sort((a, b) => b.finished_at.localeCompare(a.finished_at)).slice(0, limit);
+}
+function formatCleanupReport(report) {
+  const lines = [];
+  lines.push(`Cleanup ${report.dry_run ? "DRY-RUN" : "APPLY"} run=${report.run_id.slice(0, 8)}`);
+  lines.push(`  dedupe_clusters:      ${report.counts.dedupe_clusters}`);
+  lines.push(`  dedupe_losers:        ${report.counts.dedupe_losers}`);
+  lines.push(`  fragment_rejections:  ${report.counts.fragment_rejections}`);
+  lines.push(`  repeat_promotions:    ${report.counts.repeat_promotions}`);
+  lines.push(`  command_suppressions: ${report.counts.command_suppressions}`);
+  lines.push(`  globalizations:       ${report.counts.globalizations} (losers=${report.counts.globalize_losers})`);
+  if (report.plan.length === 0) {
+    lines.push("  (no actions)");
+    return lines.join("\n");
+  }
+  lines.push("");
+  for (const item of report.plan) {
+    if (item.kind === "dedupe_exact_merge") {
+      lines.push(`  merge: keep ${item.winner_id.slice(0, 8)}  drop ${item.loser_ids.length}  inj=${item.total_injection_count}`);
+      lines.push(`         "${truncate(item.winner_text, 80)}"`);
+    } else if (item.kind === "reject_fragment_candidate") {
+      lines.push(`  reject: ${item.memory_id.slice(0, 8)}  reasons=${item.reasons.join(",")}`);
+      lines.push(`          "${truncate(item.text, 80)}"`);
+    } else if (item.kind === "promote_repeat_correction") {
+      lines.push(`  promote: ${item.memory_id.slice(0, 8)}  via=${item.matched_pattern}`);
+      lines.push(`           "${truncate(item.text, 80)}"`);
+    } else if (item.kind === "suppress_unproductive_command") {
+      lines.push(`  suppress: ${item.memory_id.slice(0, 8)}  inj=${item.injection_count}  followed=${item.followed_count}`);
+      lines.push(`            "${truncate(item.text, 80)}"`);
+    } else {
+      lines.push(`  globalize: keep ${item.winner_id.slice(0, 8)}  drop ${item.loser_ids.length}  repos=[${item.repos.join(",")}]`);
+      lines.push(`             "${truncate(item.winner_text, 80)}"`);
+    }
+  }
+  return lines.join("\n");
+}
+function truncate(s, n) {
+  if (s.length <= n) return s;
+  return s.slice(0, n - 1) + "\u2026";
+}
+
+// src/capture/correction.ts
+var NEGATION_REPLACEMENT = /\b(?:not|don't|do not|never|stop)\s+(?:use|do|run|call|import)\s+(.+?)[\s,;.]+(?:use|do|run|call|import|instead)\s+(.+)/i;
+var EXPLICIT_RULE = /\b(always|never|must|required|forbidden|don't ever)\b\s+(.+)/i;
+var WHEN_DO_RULE = /\b(?:whenever|each time|every time|when(?:ever)?)\s+(?:i|you|we)\s+(say|use|ask|mention|do|run)\s+(.+?)[,.]?\s+(?:we|you|i|please|always|just)?\s*(do|run|use|please|add|make|update|commit|push|backup|back up|sync|verify|check|ensure)\s+(.+)/i;
+var REVIEW_FEEDBACK = /\b(?:review|reviewer|PR feedback|code review)\s+(?:said|says|asked|wants|requires|flagged)\s+(.+)/i;
+var SOFT_PREFERENCE = /\b(?:we|I|the team|this repo)\s+(?:prefer|usually use|tend to use|lean on|default to|use)\s+(.+?)(?:\s+(?:instead of|not|over)\s+(.+))?$/i;
+var SOFT_DECISION = /\b(?:let's|lets|let us|we should|we'll|we will|we can|use)\s+(?:use|keep|follow|stick with|go with)\s+(.+?)(?:\s+(?:instead of|over)\s+(.+))?(?:[.!]|$)/i;
+var CONFIG_BACKED_DECISION = /\b(?:editorconfig|prettier|eslint|tsconfig|package\.json|ci|workflow|this repo)\b.*\b(?:says|uses|wants|defaults to|is configured for)\s+(.+)/i;
+var QUESTION_ONLY = /^\s*(?:should|could|would|can|do)\b.*\?\s*$/i;
+var DESCRIPTIVE_MODAL_RE = /\b(?:i|you|we|they|those|that|which|who)(?:\s+\w+){0,2}\s+(?:always|never|must|don't|do not|prefer|required|forbidden)\b/i;
+var DESTRUCTIVE_VERB_RE = /\b(?:remove|delete|drop|wipe|clear|purge|erase|nuke|truncate|reset|destroy)\b/i;
+var HIGH_RISK_TARGET_RE = /\b(?:plugin|plugins|setting|settings|config|configs|configuration|file|files|folder|folders|directory|directories|memor(?:y|ies)|database|db|repo|repos|repository|branch|branches|commit|commits|history|backup|backups|secret|secrets|credential|credentials|key|keys|token|tokens)\b/i;
+function isDestructiveRisky(text) {
+  return DESTRUCTIVE_VERB_RE.test(text) && HIGH_RISK_TARGET_RE.test(text);
+}
+var TRIGGER_TEMPLATE_RE = /^\s*when(?:ever)?\s+(?:the\s+)?user\s+(?:says|asks|writes|types|mentions|uses|requests)\b/i;
+function isTriggerTemplateRule(text) {
+  return TRIGGER_TEMPLATE_RE.test(text);
+}
+function isHighRiskRule(text) {
+  return isDestructiveRisky(text) || isTriggerTemplateRule(text);
+}
+var NON_LETTER = "(?<![\\p{L}])(?:";
+var NON_LETTER_END = ")(?![\\p{L}])";
+var PROMPT_SCREEN_RE = new RegExp(
+  [
+    // English imperatives + save verbs (ASCII — `\b` works)
+    "\\b(?:always|never|don't|do\\s*not|must|should|prefer|avoid|remember|memorize|note|save\\s+this|keep\\s+in\\s+mind|by\\s+default|use\\s+only|forbid|please\\s+(?:always|never))\\b",
+    // Romance languages (handle diacritics with Unicode boundaries)
+    `${NON_LETTER}siempre|nunca|jam\xE1s|no\\s+uses|prefiere|recuerda${NON_LETTER_END}`,
+    `${NON_LETTER}toujours|jamais|n'utilise(?:z)?\\s+pas|pr\xE9f\xE8re|rappel${NON_LETTER_END}`,
+    `${NON_LETTER}immer|nie(?:mals)?|nicht\\s+verwenden|bevorzuge|merk\\s*dir${NON_LETTER_END}`,
+    `${NON_LETTER}sempre|mai|non\\s+usare|preferisci|ricorda${NON_LETTER_END}`,
+    `${NON_LETTER}n\xE3o\\s+use|prefira|lembre${NON_LETTER_END}`,
+    // Russian (Cyrillic)
+    `${NON_LETTER}\u0432\u0441\u0435\u0433\u0434\u0430|\u043D\u0438\u043A\u043E\u0433\u0434\u0430|\u043D\u0435\\s+\u0438\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0439|\u043F\u0440\u0435\u0434\u043F\u043E\u0447\u0442\u0438|\u0437\u0430\u043F\u043E\u043C\u043D\u0438${NON_LETTER_END}`,
+    // CJK — no word boundaries needed
+    "(?:\u603B\u662F|\u4ECE\u4E0D|\u4E0D\u8981\u4F7F\u7528|\u504F\u597D|\u8BB0\u4F4F|\u5E38\u306B|\u6C7A\u3057\u3066|\u4F7F\u308F\u306A\u3044|\u899A\u3048\u3066)",
+    // Albanian (Edi's native) — has diacritics
+    `${NON_LETTER}gjithmon\xEB|asnj\xEBher\xEB|kurr\xEB|mos\\s+p\xEBrdor|mbaj\\s+mend${NON_LETTER_END}`,
+    // Turkish
+    `${NON_LETTER}her\\s*zaman|asla|kullanma|tercih\\s+et|hat\u0131rla${NON_LETTER_END}`
+  ].join("|"),
+  "iu"
+);
+function wakeDispatcherBestEffort() {
+  const port = parseInt(process.env.RECALL_DAEMON_PORT ?? "47649", 10);
+  fetch(`http://127.0.0.1:${port}/dispatch/wake`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: "{}",
+    signal: AbortSignal.timeout(250)
+  }).catch(() => {
+  });
+}
+function isPromptWorthLLM(text) {
+  const trimmed = text.trim();
+  if (trimmed.length < 8) return false;
+  if (/^```/.test(trimmed)) return false;
+  if (trimmed.length > 800) return true;
+  return PROMPT_SCREEN_RE.test(trimmed);
+}
+function detectCorrections(text) {
+  const normalizedText = text.trim();
+  if (QUESTION_ONLY.test(normalizedText)) return [];
+  if (looksLikePastedTranscript(normalizedText)) return [];
+  const matches = [];
+  const segments = correctionCandidateSegments(normalizedText);
+  for (const segment of segments) {
+    const descriptive = DESCRIPTIVE_MODAL_RE.exec(segment);
+    if (descriptive && descriptive.index > 0) continue;
+    const whenDo = segment.match(WHEN_DO_RULE);
+    if (whenDo) {
+      const trigger = stripTrailingPunctuation(whenDo[2]);
+      const action = stripTrailingPunctuation(`${whenDo[3]} ${whenDo[4]}`);
+      matches.push({
+        type: "rule",
+        text: `When user ${whenDo[1].toLowerCase()}s "${trigger}", ${action}.`,
+        confidence: 0.5,
+        original: segment
+      });
+      continue;
+    }
+    const negMatch = segment.match(NEGATION_REPLACEMENT);
+    if (negMatch) {
+      matches.push({
+        type: "rule",
+        text: `Do not use ${negMatch[1].trim()}. Use ${negMatch[2].trim()} instead.`,
+        confidence: 0.45,
+        original: segment
+      });
+      continue;
+    }
+    const reviewMatch = segment.match(REVIEW_FEEDBACK);
+    if (reviewMatch) {
+      matches.push({
+        type: "review_pattern",
+        text: reviewMatch[1].trim(),
+        confidence: 0.55
+        // stronger — review feedback
+      });
+      continue;
+    }
+    const ruleMatch = segment.match(EXPLICIT_RULE);
+    if (ruleMatch) {
+      matches.push({
+        type: "rule",
+        text: `${ruleMatch[1]} ${ruleMatch[2].trim()}`,
+        confidence: 0.5
+      });
+      continue;
+    }
+    const decisionMatch = segment.match(SOFT_DECISION);
+    if (decisionMatch && isDurableDecision(segment, decisionMatch[1], decisionMatch[2])) {
+      const decision = decisionMatch[2] ? `Prefer ${decisionMatch[1].trim()} over ${decisionMatch[2].trim()}` : `Use ${stripTrailingPunctuation(decisionMatch[1])}`;
+      matches.push({
+        type: "decision",
+        text: ensureSentence(decision),
+        confidence: 0.38
+      });
+      continue;
+    }
+    const prefMatch = segment.match(SOFT_PREFERENCE);
+    if (prefMatch && isDurableDecision(segment, prefMatch[1], prefMatch[2])) {
+      const pref = prefMatch[2] ? `Prefer ${prefMatch[1].trim()} over ${prefMatch[2].trim()}` : `Prefer ${stripTrailingPunctuation(prefMatch[1])}`;
+      matches.push({
+        type: "decision",
+        text: ensureSentence(pref),
+        confidence: 0.36
+      });
+      continue;
+    }
+    const configMatch = segment.match(CONFIG_BACKED_DECISION);
+    if (configMatch) {
+      matches.push({
+        type: "decision",
+        text: ensureSentence(`Follow configured repo convention: ${stripTrailingPunctuation(configMatch[1])}`),
+        confidence: 0.42
+      });
+    }
+  }
+  return matches;
+}
+function stripTrailingPunctuation(text) {
+  return text.trim().replace(/[.?!,:;]+$/, "");
+}
+function ensureSentence(text) {
+  const cleaned = stripTrailingPunctuation(text);
+  return cleaned.endsWith(".") ? cleaned : `${cleaned}.`;
+}
+var TRANSCRIPT_MARKERS = [
+  "\u203B recap:",
+  "\u273B",
+  "\u23FA",
+  "\u23BF",
+  "\u276F",
+  "Bash(",
+  "Hook activity",
+  "Top reused memories",
+  "RECENT INJECTIONS",
+  "BREAKDOWN BY TYPE",
+  "sqlite3"
+];
+var DURABLE_DECISION_HINT = /\b(repo|repository|project|default|defaults|convention(?:al|s)?|configured|config|editorconfig|prettier|eslint|tsconfig|package\.json|ci|workflow|style|pattern|architecture|runtime|database|sqlite|pnpm|yarn|npm|uv|pytest|vitest)\b/i;
+var TRANSCRIPT_LINE_RE = /^(?:[⏺⎿❯✻※]|(?:Bash|Edit|Write|Read|Grep|Glob|Task|TodoWrite)\(|\s*(?:│|├|┌|└|─)|\s*…|\s*={3,})/u;
+function looksLikePastedTranscript(text) {
+  if (text.length < 1200) return false;
+  const markerCount = TRANSCRIPT_MARKERS.reduce(
+    (total, marker) => total + (text.includes(marker) ? 1 : 0),
+    0
+  );
+  return markerCount >= 2;
+}
+function correctionCandidateSegments(text) {
+  const lines = text.split(/\r?\n/);
+  const singleLine = lines.length === 1;
+  const segments = singleLine ? [text] : lines.map((line) => line.trim()).filter(Boolean);
+  return segments.map(stripListPrefix).filter((line) => line.length >= 8 && line.length <= 500).filter((line) => !TRANSCRIPT_LINE_RE.test(line)).filter((line) => !line.startsWith("```"));
+}
+function stripListPrefix(text) {
+  return text.replace(/^\s*(?:[-*]|\d+[.)])\s+/, "").trim();
+}
+function isDurableDecision(segment, first, second) {
+  const haystack = `${segment} ${first} ${second ?? ""}`;
+  if (/\b(?:instead of|over)\b/i.test(haystack)) return true;
+  return DURABLE_DECISION_HINT.test(haystack);
+}
+async function processCorrection(db, text, ctx) {
+  if (process.env.RECALL_LLM_CAPTURE_DISABLED !== "true" && hasAnyLlmProvider() && isPromptWorthLLM(text)) {
+    const promptId = `prompt:${ctx.sessionId}:${Date.now()}:${randomUUID6().slice(0, 8)}`;
+    const taskId = enqueueExtractRulesFromPrompt(db, {
+      prompt_id: promptId,
+      raw_prompt: text,
+      repo: ctx.repo ?? null,
+      path: ctx.path ?? null,
+      agent: ctx.agent ?? null,
+      session_id: ctx.sessionId,
+      prev_assistant_turn: ctx.prev_assistant_turn ?? null,
+      recent_tool_calls: ctx.recent_tool_calls ?? null
+    });
+    wakeDispatcherBestEffort();
+    return taskId ? [] : [];
+  }
+  const corrections = detectCorrections(text);
+  if (corrections.length === 0) return [];
+  const profile = getRepoQualityProfile(db, ctx.repo);
+  const ids = [];
+  const captureContext = buildCaptureContext(ctx);
+  for (const correction of corrections) {
+    if (correction.type !== "review_pattern") {
+      const reasons = qualityReasons(correction.text);
+      if (reasons.length > 0) continue;
+    }
+    if (await isSimilarToRejectedFragmentSemantic(db, correction.text)) continue;
+    const evidence = correction.type === "review_pattern" ? {
+      type: "review_feedback",
+      reported_by_user: true,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      context: text
+    } : {
+      type: "session_correction",
+      session: ctx.sessionId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      context: text
+    };
+    const duplicate = await findDuplicateMemory(
+      db,
+      ctx.repo,
+      correction.type,
+      correction.text,
+      profile.dedup_similarity_threshold
+    );
+    if (duplicate) {
+      const before = getMemory(db, duplicate.id);
+      appendEvidence(db, duplicate.id, evidence);
+      if (captureContext) {
+        updateMemoryCaptureContext(db, duplicate.id, captureContext);
+      }
+      if (before && !before.evidence.some((entry) => entry.type === "session_correction" && entry.session === ctx.sessionId)) {
+        incrementMemoryRepetition(db, duplicate.id);
+      }
+      const updated = getMemory(db, duplicate.id);
+      if (updated && updated.status !== "active" && !isHighRiskRule(updated.text) && countDistinctCorrectionSessions(updated) >= profile.repeat_sessions_required) {
+        promoteMemory(db, duplicate.id, "repeat_correction");
+        const after = getMemory(db, duplicate.id);
+        recordAuditWithSnapshot(
+          db,
+          duplicate.id,
+          "promoted",
+          "system",
+          `repetition:${after?.repetition_count ?? updated.repetition_count}`,
+          before ?? null,
+          after ?? null
+        );
+      }
+      ids.push(duplicate.id);
+      continue;
+    }
+    const inferredScope = inferScope(
+      correction.text,
+      ctx.path,
+      void 0,
+      {
+        prev_assistant_turn: ctx.prev_assistant_turn,
+        recent_tool_calls: ctx.recent_tool_calls,
+        original_text: text
+      }
+    );
+    const input = {
+      type: correction.type,
+      text: correction.text,
+      scope: inferredScope.scope,
+      path_scope: inferredScope.path_scope,
+      repo: ctx.repo ?? null,
+      source: correction.type === "review_pattern" ? "user_reported_review" : "user_correction",
+      confidence: seedCandidateConfidence(
+        Math.min(1, correction.confidence + inferredScope.confidence_modifier),
+        profile
+      ),
+      evidence: [evidence],
+      capture_context: captureContext
+    };
+    const id = createMemory(db, input);
+    maybePromoteGroupCandidate(db, id);
+    enqueueVerifyCapture(db, {
+      id,
+      text: input.text,
+      scope: input.scope,
+      path_scope: input.path_scope ?? null,
+      repo: input.repo ?? null,
+      capture_context: captureContext ?? null
+    });
+    ids.push(id);
+  }
+  return ids;
+}
+function maybePromoteGroupCandidate(db, candidateId) {
+  const candidate = getMemory(db, candidateId);
+  if (!candidate || candidate.status !== "candidate") return;
+  if (isHighRiskRule(candidate.text)) return;
+  const followedCount = queryMemories(db, {
+    repo: candidate.repo ?? void 0,
+    type: candidate.type,
+    scope: candidate.scope
+  }).filter((memory) => memory.id !== candidate.id).reduce((total, memory) => total + getMemoryFeedback(db, memory.id).filter((entry) => entry.outcome === "followed").length, 0);
+  if (followedCount < 3) return;
+  const before = candidate;
+  promoteMemory(db, candidate.id, "repeat_correction");
+  const after = getMemory(db, candidate.id);
+  recordAuditWithSnapshot(
+    db,
+    candidate.id,
+    "promoted",
+    "system",
+    `repetition:group_followed:${followedCount}`,
+    before,
+    after ?? null
+  );
+}
+function buildCaptureContext(ctx) {
+  const recentToolCalls = (ctx.recent_tool_calls ?? []).slice(-5).map((toolCall) => ({
+    name: toolCall.name,
+    path: toolCall.path ?? extractContextPath(toolCall.input_summary),
+    exit_code: toolCall.exit_code
+  }));
+  const hasContext = Boolean(ctx.prev_assistant_turn) || recentToolCalls.length > 0 || Boolean(ctx.repo) || Boolean(ctx.path) || Boolean(ctx.agent);
+  if (!hasContext) return null;
+  return {
+    prev_assistant_text: ctx.prev_assistant_turn,
+    recent_tool_calls: recentToolCalls,
+    repo: ctx.repo ?? null,
+    path: ctx.path ?? null,
+    agent: ctx.agent
+  };
+}
+function extractContextPath(text) {
+  if (!text) return void 0;
+  const match = text.match(
+    /\b((?:src|lib|app|components|utils|test|spec)\/[\w./-]+|[\w./-]+\.(?:ts|tsx|js|jsx|py|rs|go|swift|java|rb|json|toml|ya?ml))\b/
+  );
+  return match?.[1];
+}
+async function processReviewFeedback(db, feedback, ctx) {
+  const profile = getRepoQualityProfile(db, ctx.repo);
+  const evidence = {
+    type: "review_feedback",
+    reported_by_user: true,
+    reviewer: ctx.reviewer,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    context: feedback
+  };
+  const corrections = detectCorrections(feedback);
+  if (corrections.length > 0) {
+    const ids = [];
+    for (const correction of corrections) {
+      const duplicate = await findDuplicateMemory(
+        db,
+        ctx.repo,
+        correction.type,
+        correction.text,
+        profile.dedup_similarity_threshold
+      );
+      if (duplicate) {
+        appendEvidence(db, duplicate.id, evidence);
+        const updated = getMemory(db, duplicate.id);
+        if (updated && updated.status !== "active" && countDistinctCorrectionSessions(updated) >= Math.max(1, profile.repeat_sessions_required - 1)) {
+          promoteMemory(db, duplicate.id, "review_feedback");
+        }
+        ids.push(duplicate.id);
+        continue;
+      }
+      const id2 = createMemory(db, {
+        type: correction.type,
+        text: correction.text,
+        scope: ctx.path ? "path" : "repo",
+        path_scope: ctx.path ?? null,
+        repo: ctx.repo ?? null,
+        source: "user_reported_review",
+        confidence: seedCandidateConfidence(correction.confidence + 0.1, profile),
+        evidence: [evidence]
+      });
+      ids.push(id2);
+    }
+    return ids;
+  }
+  const id = createMemory(db, {
+    type: "review_pattern",
+    text: feedback,
+    scope: ctx.path ? "path" : "repo",
+    path_scope: ctx.path ?? null,
+    repo: ctx.repo ?? null,
+    source: "user_reported_review",
+    confidence: seedCandidateConfidence(0.4, profile),
+    evidence: [evidence]
+  });
+  return [id];
+}
+function textSimilarity(a, b) {
+  const wordsA = new Set(a.toLowerCase().split(/\s+/));
+  const wordsB = new Set(b.toLowerCase().split(/\s+/));
+  const intersection = [...wordsA].filter((w) => wordsB.has(w));
+  const union = /* @__PURE__ */ new Set([...wordsA, ...wordsB]);
+  return intersection.length / union.size;
+}
+var REJECTED_EXEMPLAR_THRESHOLD = 0.7;
+var REJECTED_EXEMPLAR_SEMANTIC_THRESHOLD = 0.85;
+function isSimilarToRejectedFragment(db, text, threshold = REJECTED_EXEMPLAR_THRESHOLD) {
+  const rejected = queryMemories(db, { status: "rejected" }).filter((m) => m.source === "user_correction" || m.source === "user_reported_review");
+  for (const exemplar of rejected) {
+    if (textSimilarity(text, exemplar.text) >= threshold) return true;
+  }
+  return false;
+}
+async function isSimilarToRejectedFragmentSemantic(db, text, options = {}) {
+  const lexicalT = options.lexicalThreshold ?? REJECTED_EXEMPLAR_THRESHOLD;
+  const semanticT = options.semanticThreshold ?? REJECTED_EXEMPLAR_SEMANTIC_THRESHOLD;
+  if (isSimilarToRejectedFragment(db, text, lexicalT)) return true;
+  const config = loadEmbeddingConfigFromEnv();
+  if (!config) return false;
+  const match = await findSimilarRejectedExemplar(db, text, config, semanticT);
+  return match != null;
+}
+async function findDuplicateMemory(db, repo, type, text, threshold) {
+  if (!repo) return void 0;
+  const existing = queryMemories(db, { repo }).filter((m) => m.status !== "rejected" && m.type === type);
+  let best;
+  let bestScore = 0;
+  for (const memory of existing) {
+    const score = textSimilarity(memory.text, text);
+    if (score >= threshold && score > bestScore) {
+      best = memory;
+      bestScore = score;
+    }
+  }
+  if (best) return best;
+  const config = loadEmbeddingConfigFromEnv();
+  if (!config) return void 0;
+  const semantic = await findSemanticDuplicates(
+    db,
+    text,
+    config,
+    threshold,
+    { repo, type, limit: 1 }
+  );
+  return semantic[0] ? getMemory(db, semantic[0].id) : void 0;
+}
+
 // src/maintenance/appliers.ts
 var ApplyError = class extends Error {
   constructor(message, code) {
@@ -2107,7 +4474,7 @@ function applyRefineCandidate(db, task, result) {
     path_scope: newPathScope,
     updated_at: now,
     last_validated_at: now
-  }).where(eq6(memories.id, memoryId)).run();
+  }).where(eq10(memories.id, memoryId)).run();
   queueMemoryEmbeddingSync(db, memoryId);
   const after = getMemory(db, memoryId);
   const reason = result.rationale ? `refined:${task.id}:${result.rationale.slice(0, 200)}` : `refined:${task.id}`;
@@ -2151,7 +4518,7 @@ function applyVerifyCapture(db, task, result) {
     path_scope: newPathScope,
     updated_at: now,
     last_validated_at: now
-  }).where(eq6(memories.id, memoryId)).run();
+  }).where(eq10(memories.id, memoryId)).run();
   queueMemoryEmbeddingSync(db, memoryId);
   const after = getMemory(db, memoryId);
   const reason = result.reason ? `verify:rewrite:${task.id}:${result.reason.slice(0, 200)}` : `verify:rewrite:${task.id}`;
@@ -2171,7 +4538,7 @@ function rejectMemoryFromTask(db, task, memoryId, before, actor, reasonText) {
     return { audit_entry_id: null, target_id: memoryId, changed_fields: [] };
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  db.update(memories).set({ status: "rejected", confidence: 0, dedupe_key: null, updated_at: now }).where(eq6(memories.id, memoryId)).run();
+  db.update(memories).set({ status: "rejected", confidence: 0, dedupe_key: null, updated_at: now }).where(eq10(memories.id, memoryId)).run();
   queueMemoryEmbeddingSync(db, memoryId);
   const after = getMemory(db, memoryId);
   const reason = reasonText ? `${task.kind}:reject:${task.id}:${reasonText.slice(0, 200)}` : `${task.kind}:reject:${task.id}`;
@@ -2189,7 +4556,7 @@ function rejectMemoryFromTask(db, task, memoryId, before, actor, reasonText) {
 function applySummarizeHistory(db, task, result) {
   const snippetId = task.payload.snippet_id;
   if (!snippetId) throw new ApplyError("payload missing snippet_id", "invalid-state");
-  const existing = db.select().from(historySnippets).where(eq6(historySnippets.id, snippetId)).get();
+  const existing = db.select().from(historySnippets).where(eq10(historySnippets.id, snippetId)).get();
   if (!existing) throw new ApplyError(`history snippet ${snippetId} not found`, "target-missing");
   const changed = [];
   if (existing.text !== result.summary_text) changed.push("text");
@@ -2199,7 +4566,7 @@ function applySummarizeHistory(db, task, result) {
   db.update(historySnippets).set({
     text: result.summary_text,
     updated_at: (/* @__PURE__ */ new Date()).toISOString()
-  }).where(eq6(historySnippets.id, snippetId)).run();
+  }).where(eq10(historySnippets.id, snippetId)).run();
   return { audit_entry_id: null, target_id: snippetId, changed_fields: changed };
 }
 function applyMergeDuplicates(db, task, result) {
@@ -2228,7 +4595,7 @@ function applyMergeDuplicates(db, task, result) {
       path_scope: nextPathScope,
       updated_at: now,
       last_validated_at: now
-    }).where(eq6(memories.id, winnerId)).run();
+    }).where(eq10(memories.id, winnerId)).run();
     queueMemoryEmbeddingSync(db, winnerId);
     const after = getMemory(db, winnerId);
     recordAuditWithSnapshot(
@@ -2252,7 +4619,7 @@ function applyMergeDuplicates(db, task, result) {
       supersedes: winnerId,
       dedupe_key: null,
       updated_at: now
-    }).where(eq6(memories.id, cand.id)).run();
+    }).where(eq10(memories.id, cand.id)).run();
     queueMemoryEmbeddingSync(db, cand.id);
     const afterLoser = getMemory(db, cand.id);
     recordAuditWithSnapshot(
@@ -2276,7 +4643,7 @@ function applySummarizeSession(db, task, result) {
   const payload = task.payload;
   const sessionId = payload.session_id;
   if (!sessionId) throw new ApplyError("payload missing session_id", "invalid-state");
-  const id = randomUUID3();
+  const id = randomUUID7();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   db.insert(historySnippets).values({
     id,
@@ -2294,7 +4661,7 @@ function applySynthesizeRepo(db, task, result) {
   const payload = task.payload;
   const repo = payload.repo;
   if (!repo) throw new ApplyError("payload missing repo", "invalid-state");
-  const id = randomUUID3();
+  const id = randomUUID7();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   db.insert(historySnippets).values({
     id,
@@ -2308,6 +4675,78 @@ function applySynthesizeRepo(db, task, result) {
   }).run();
   return { audit_entry_id: null, target_id: id, changed_fields: ["text"] };
 }
+function applyExtractRulesFromPrompt(db, task, result) {
+  const payload = task.payload;
+  const repo = payload.repo ?? null;
+  const profile = getRepoQualityProfile(db, repo ?? void 0);
+  if (!result.rules || result.rules.length === 0) {
+    return { audit_entry_id: null, target_id: task.id, changed_fields: [] };
+  }
+  const captureContext = {
+    prev_assistant_text: void 0,
+    recent_tool_calls: [],
+    repo,
+    path: payload.path ?? null,
+    agent: payload.agent ?? void 0
+  };
+  const createdIds = [];
+  for (const rule of result.rules) {
+    if (existsSimilar(db, repo, rule)) continue;
+    const memoryType = rule.type ?? "rule";
+    const id = createMemory(db, {
+      type: memoryType,
+      text: rule.text,
+      scope: rule.scope,
+      path_scope: rule.path_scope ?? null,
+      repo,
+      source: "user_correction",
+      confidence: seedCandidateConfidence(rule.confidence, profile),
+      evidence: [
+        {
+          type: "session_correction",
+          session: payload.session_id ?? "unknown",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          context: payload.raw_prompt ?? ""
+        }
+      ],
+      capture_context: captureContext
+    });
+    createdIds.push(id);
+    const after = getMemory(db, id);
+    recordAuditWithSnapshot(
+      db,
+      id,
+      "created",
+      `maintenance:${task.claimed_by ?? "llm"}`,
+      `extract_rules_from_prompt:${task.id}${rule.rationale ? `:${rule.rationale.slice(0, 200)}` : ""}`,
+      null,
+      after ?? null
+    );
+    if (rule.is_destructive_risky || isHighRiskRule(rule.text)) {
+    }
+  }
+  return {
+    audit_entry_id: null,
+    target_id: createdIds[0] ?? task.id,
+    changed_fields: createdIds.length > 0 ? ["created_memories"] : []
+  };
+}
+function existsSimilar(db, repo, rule) {
+  if (!repo) return false;
+  const candidates = queryMemories(db, { repo: repo ?? void 0, type: rule.type }).filter((memory) => memory.status !== "rejected");
+  const normalized = rule.text.toLowerCase().trim();
+  return candidates.some((memory) => {
+    if (memory.text.toLowerCase().trim() === normalized) return true;
+    return jaccard(memory.text, rule.text) >= 0.85;
+  });
+}
+function jaccard(a, b) {
+  const wordsA = new Set(a.toLowerCase().split(/\s+/));
+  const wordsB = new Set(b.toLowerCase().split(/\s+/));
+  const intersection = [...wordsA].filter((w) => wordsB.has(w));
+  const union = /* @__PURE__ */ new Set([...wordsA, ...wordsB]);
+  return union.size === 0 ? 0 : intersection.length / union.size;
+}
 function applyTaskResult(db, task, result) {
   switch (task.kind) {
     case "verify_capture":
@@ -2322,6 +4761,8 @@ function applyTaskResult(db, task, result) {
       return applySummarizeSession(db, task, result);
     case "synthesize_repo":
       return applySynthesizeRepo(db, task, result);
+    case "extract_rules_from_prompt":
+      return applyExtractRulesFromPrompt(db, task, result);
     default: {
       const never = task.kind;
       throw new ApplyError(`unknown kind ${never}`, "unsupported-kind");
@@ -2332,8 +4773,13 @@ function applyTaskResult(db, task, result) {
 // src/maintenance/tasks.ts
 var OPEN_STATUSES = ["pending", "claimed", "submitted"];
 var ACTIVE_STATUSES = [...OPEN_STATUSES, "completed"];
-var DEFAULT_LEASE_SECONDS = 600;
+var DEFAULT_LEASE_SECONDS2 = 600;
 var DEFAULT_PRIORITIES = {
+  // extract_rules_from_prompt runs at higher priority than verify_capture
+  // because it is the primary capture path when an LLM provider is
+  // configured — its output IS the candidate creation. Without it, real
+  // rules never enter the queue at all.
+  extract_rules_from_prompt: 14,
   verify_capture: 12,
   refine_candidate: 10,
   merge_duplicates: 8,
@@ -2376,16 +4822,16 @@ function targetKey(kind, target) {
   return `${kind}:${target}`;
 }
 function hasActiveTaskForTarget(db, kind, target) {
-  const row = db.select({ id: memoryMaintenanceTasks.id }).from(memoryMaintenanceTasks).where(and2(
-    eq7(memoryMaintenanceTasks.kind, kind),
-    eq7(memoryMaintenanceTasks.target_key, targetKey(kind, target)),
-    inArray2(memoryMaintenanceTasks.status, ACTIVE_STATUSES)
+  const row = db.select({ id: memoryMaintenanceTasks.id }).from(memoryMaintenanceTasks).where(and4(
+    eq11(memoryMaintenanceTasks.kind, kind),
+    eq11(memoryMaintenanceTasks.target_key, targetKey(kind, target)),
+    inArray3(memoryMaintenanceTasks.status, ACTIVE_STATUSES)
   )).limit(1).get();
   return Boolean(row);
 }
 function insertTaskIdempotent(db, input) {
   if (hasActiveTaskForTarget(db, input.kind, input.target)) return null;
-  const id = randomUUID4();
+  const id = randomUUID8();
   db.insert(memoryMaintenanceTasks).values({
     id,
     kind: input.kind,
@@ -2408,13 +4854,13 @@ function insertTaskIdempotent(db, input) {
   return id;
 }
 function deleteTask(db, id) {
-  const result = db.delete(memoryMaintenanceTasks).where(eq7(memoryMaintenanceTasks.id, id)).run();
+  const result = db.delete(memoryMaintenanceTasks).where(eq11(memoryMaintenanceTasks.id, id)).run();
   return result.changes > 0;
 }
 function getTaskStats(db) {
   const rows = db.select().from(memoryMaintenanceTasks).all();
   const by_status = { pending: 0, claimed: 0, submitted: 0, completed: 0, abandoned: 0 };
-  const by_kind = { verify_capture: 0, refine_candidate: 0, merge_duplicates: 0, summarize_history: 0, summarize_session: 0, synthesize_repo: 0 };
+  const by_kind = { verify_capture: 0, refine_candidate: 0, merge_duplicates: 0, summarize_history: 0, summarize_session: 0, synthesize_repo: 0, extract_rules_from_prompt: 0 };
   const by_kind_status = {};
   const dayAgo = new Date(Date.now() - 864e5).toISOString();
   let completed_last_24h = 0;
@@ -2451,24 +4897,24 @@ function getTaskStats(db) {
   };
 }
 function getTask(db, id) {
-  const row = db.select().from(memoryMaintenanceTasks).where(eq7(memoryMaintenanceTasks.id, id)).get();
+  const row = db.select().from(memoryMaintenanceTasks).where(eq11(memoryMaintenanceTasks.id, id)).get();
   return row ? rowToTask(row) : void 0;
 }
 function listTasks(db, query = {}) {
   const conditions = [];
   if (query.status) {
     const statuses = Array.isArray(query.status) ? query.status : [query.status];
-    conditions.push(inArray2(memoryMaintenanceTasks.status, statuses));
+    conditions.push(inArray3(memoryMaintenanceTasks.status, statuses));
   }
   if (query.kinds?.length) {
-    conditions.push(inArray2(memoryMaintenanceTasks.kind, query.kinds));
+    conditions.push(inArray3(memoryMaintenanceTasks.kind, query.kinds));
   }
   if (query.repo) {
-    conditions.push(eq7(memoryMaintenanceTasks.repo, query.repo));
+    conditions.push(eq11(memoryMaintenanceTasks.repo, query.repo));
   }
   let stmt = db.select().from(memoryMaintenanceTasks).$dynamic();
-  if (conditions.length) stmt = stmt.where(and2(...conditions));
-  stmt = stmt.orderBy(sql2`${memoryMaintenanceTasks.priority} DESC`, memoryMaintenanceTasks.created_at).limit(query.limit ?? 50);
+  if (conditions.length) stmt = stmt.where(and4(...conditions));
+  stmt = stmt.orderBy(sql3`${memoryMaintenanceTasks.priority} DESC`, memoryMaintenanceTasks.created_at).limit(query.limit ?? 50);
   return stmt.all().map(rowToTask);
 }
 function sweepExpiredLeases(db, now = /* @__PURE__ */ new Date()) {
@@ -2478,9 +4924,9 @@ function sweepExpiredLeases(db, now = /* @__PURE__ */ new Date()) {
     claimed_by: null,
     claimed_at: null,
     claim_expires_at: null,
-    attempts: sql2`${memoryMaintenanceTasks.attempts} + 1`
-  }).where(and2(
-    eq7(memoryMaintenanceTasks.status, "claimed"),
+    attempts: sql3`${memoryMaintenanceTasks.attempts} + 1`
+  }).where(and4(
+    eq11(memoryMaintenanceTasks.status, "claimed"),
     lt(memoryMaintenanceTasks.claim_expires_at, nowIso)
   )).run();
   return result.changes;
@@ -2491,8 +4937,8 @@ function expireStalePendingTasks(db, maxAgeDays, now = /* @__PURE__ */ new Date(
     status: "abandoned",
     failure_reason: "expired_no_dispatcher",
     completed_at: now.toISOString()
-  }).where(and2(
-    eq7(memoryMaintenanceTasks.status, "pending"),
+  }).where(and4(
+    eq11(memoryMaintenanceTasks.status, "pending"),
     lt(memoryMaintenanceTasks.created_at, cutoff)
   )).run();
   return result.changes;
@@ -2503,9 +4949,9 @@ function abandonOverAttemptTasks(db) {
     status: "abandoned",
     failure_reason: "max_attempts_exceeded",
     completed_at: nowIso
-  }).where(and2(
-    inArray2(memoryMaintenanceTasks.status, ["pending", "claimed"]),
-    sql2`${memoryMaintenanceTasks.attempts} >= ${memoryMaintenanceTasks.max_attempts}`
+  }).where(and4(
+    inArray3(memoryMaintenanceTasks.status, ["pending", "claimed"]),
+    sql3`${memoryMaintenanceTasks.attempts} >= ${memoryMaintenanceTasks.max_attempts}`
   )).run();
   return result.changes;
 }
@@ -2513,27 +4959,44 @@ function applyBacklogCaps(db, config) {
   let dropped = 0;
   const overKindRows = db.select({
     kind: memoryMaintenanceTasks.kind,
-    count: sql2`count(*)`.as("count")
-  }).from(memoryMaintenanceTasks).where(eq7(memoryMaintenanceTasks.status, "pending")).groupBy(memoryMaintenanceTasks.kind).all();
+    count: sql3`count(*)`.as("count")
+  }).from(memoryMaintenanceTasks).where(eq11(memoryMaintenanceTasks.status, "pending")).groupBy(memoryMaintenanceTasks.kind).all();
   for (const { kind, count } of overKindRows) {
     if (count <= config.max_per_kind) continue;
     const toDrop = count - config.max_per_kind;
     dropped += dropLowestPriorityPending(db, toDrop, { kind });
   }
-  const pendingCount = db.select({ n: sql2`count(*)` }).from(memoryMaintenanceTasks).where(eq7(memoryMaintenanceTasks.status, "pending")).get()?.n ?? 0;
+  const pendingCount = db.select({ n: sql3`count(*)` }).from(memoryMaintenanceTasks).where(eq11(memoryMaintenanceTasks.status, "pending")).get()?.n ?? 0;
   if (pendingCount > config.max_pending) {
     dropped += dropLowestPriorityPending(db, pendingCount - config.max_pending);
   }
   return dropped;
 }
 function dropLowestPriorityPending(db, limit, filter = {}) {
-  const conditions = [eq7(memoryMaintenanceTasks.status, "pending")];
-  if (filter.kind) conditions.push(eq7(memoryMaintenanceTasks.kind, filter.kind));
-  const ids = db.select({ id: memoryMaintenanceTasks.id }).from(memoryMaintenanceTasks).where(and2(...conditions)).orderBy(memoryMaintenanceTasks.priority, sql2`${memoryMaintenanceTasks.created_at} DESC`).limit(limit).all().map((r) => r.id);
+  const conditions = [eq11(memoryMaintenanceTasks.status, "pending")];
+  if (filter.kind) conditions.push(eq11(memoryMaintenanceTasks.kind, filter.kind));
+  const ids = db.select({ id: memoryMaintenanceTasks.id }).from(memoryMaintenanceTasks).where(and4(...conditions)).orderBy(memoryMaintenanceTasks.priority, sql3`${memoryMaintenanceTasks.created_at} DESC`).limit(limit).all().map((r) => r.id);
   if (!ids.length) return 0;
-  const result = db.delete(memoryMaintenanceTasks).where(inArray2(memoryMaintenanceTasks.id, ids)).run();
+  const result = db.delete(memoryMaintenanceTasks).where(inArray3(memoryMaintenanceTasks.id, ids)).run();
   return result.changes;
 }
+function enqueueExtractRulesFromPrompt(db, payload) {
+  return insertTaskIdempotent(db, {
+    kind: "extract_rules_from_prompt",
+    target: payload.prompt_id,
+    repo: payload.repo,
+    payload: {
+      prompt_id: payload.prompt_id,
+      raw_prompt: payload.raw_prompt,
+      repo: payload.repo,
+      path: payload.path,
+      agent: payload.agent,
+      session_id: payload.session_id,
+      prev_assistant_turn: payload.prev_assistant_turn ?? null,
+      recent_tool_calls: payload.recent_tool_calls ?? null
+    }
+  });
+}
 function enqueueVerifyCapture(db, memory) {
   return insertTaskIdempotent(db, {
     kind: "verify_capture",
@@ -2550,9 +5013,9 @@ function enqueueVerifyCapture(db, memory) {
   });
 }
 function produceRefineCandidateTasks(db, config) {
-  const candidates = db.select().from(memories).where(and2(
-    eq7(memories.status, "candidate"),
-    or(eq7(memories.scope, "repo"), isNull(memories.path_scope))
+  const candidates = db.select().from(memories).where(and4(
+    eq11(memories.status, "candidate"),
+    or(eq11(memories.scope, "repo"), isNull(memories.path_scope))
   )).all();
   let enqueued = 0;
   for (const row of candidates) {
@@ -2578,7 +5041,7 @@ function produceRefineCandidateTasks(db, config) {
 }
 function produceSummarizeHistoryTasks(db, config) {
   const cutoff = new Date(Date.now() - config.summary_max_age_days * 864e5).toISOString();
-  const snippets = db.select().from(historySnippets).where(sql2`${historySnippets.created_at} >= ${cutoff}`).all();
+  const snippets = db.select().from(historySnippets).where(sql3`${historySnippets.created_at} >= ${cutoff}`).all();
   let enqueued = 0;
   for (const snippet of snippets) {
     if (!snippetHasMeaningfulContent(snippet.text)) continue;
@@ -2609,7 +5072,7 @@ function snippetHasMeaningfulContent(text) {
 async function produceMergeDuplicateTasks(db, config) {
   const embeddingConfig = loadEmbeddingConfigFromEnv();
   if (!embeddingConfig) return 0;
-  const activeMemories = db.select().from(memories).where(eq7(memories.status, "active")).all();
+  const activeMemories = db.select().from(memories).where(eq11(memories.status, "active")).all();
   const visited = /* @__PURE__ */ new Set();
   let enqueued = 0;
   for (const mem of activeMemories) {
@@ -2630,7 +5093,7 @@ async function produceMergeDuplicateTasks(db, config) {
       for (const id2 of cluster) visited.add(id2);
       continue;
     }
-    const clusterRows = db.select().from(memories).where(inArray2(memories.id, cluster)).all();
+    const clusterRows = db.select().from(memories).where(inArray3(memories.id, cluster)).all();
     const candidates = clusterRows.map((row) => ({
       id: row.id,
       text: row.text,
@@ -2655,18 +5118,18 @@ async function produceMergeDuplicateTasks(db, config) {
 }
 function produceSummarizeSessionTasks(db, config) {
   const cutoff = new Date(Date.now() - config.summary_max_age_days * 864e5).toISOString();
-  const sessionEnds = db.select().from(activityEvents).where(and2(
-    eq7(activityEvents.event_type, "session_end"),
+  const sessionEnds = db.select().from(activityEvents).where(and4(
+    eq11(activityEvents.event_type, "session_end"),
     gt(activityEvents.created_at, cutoff)
   )).orderBy(desc2(activityEvents.created_at)).all();
   let enqueued = 0;
   for (const end of sessionEnds) {
     if (!end.session_id) continue;
-    const events = db.select().from(activityEvents).where(eq7(activityEvents.session_id, end.session_id)).all();
+    const events = db.select().from(activityEvents).where(eq11(activityEvents.session_id, end.session_id)).all();
     if (events.length < config.session_min_activity_events) continue;
-    const existing = db.select().from(historySnippets).where(and2(
-      eq7(historySnippets.session_id, end.session_id),
-      eq7(historySnippets.kind, "session_summary")
+    const existing = db.select().from(historySnippets).where(and4(
+      eq11(historySnippets.session_id, end.session_id),
+      eq11(historySnippets.kind, "session_summary")
     )).get();
     if (existing) continue;
     const repo = end.repo ?? events.find((e) => e.repo)?.repo ?? null;
@@ -2690,22 +5153,22 @@ function produceSummarizeSessionTasks(db, config) {
 function produceSynthesizeRepoTasks(db, config) {
   const rows = db.select({
     repo: memories.repo,
-    count: sql2`count(*)`.as("count")
-  }).from(memories).where(eq7(memories.status, "active")).groupBy(memories.repo).all();
+    count: sql3`count(*)`.as("count")
+  }).from(memories).where(eq11(memories.status, "active")).groupBy(memories.repo).all();
   const cutoff = new Date(Date.now() - config.repo_synthesis_refresh_days * 864e5).toISOString();
   let enqueued = 0;
   for (const { repo, count } of rows) {
     if (!repo) continue;
     if (count < config.repo_synthesis_min_memories) continue;
-    const recent = db.select().from(historySnippets).where(and2(
-      eq7(historySnippets.repo, repo),
-      eq7(historySnippets.kind, "repo_synthesis"),
+    const recent = db.select().from(historySnippets).where(and4(
+      eq11(historySnippets.repo, repo),
+      eq11(historySnippets.kind, "repo_synthesis"),
       gt(historySnippets.updated_at, cutoff)
     )).get();
     if (recent) continue;
-    const topMemories = db.select().from(memories).where(and2(
-      eq7(memories.repo, repo),
-      eq7(memories.status, "active")
+    const topMemories = db.select().from(memories).where(and4(
+      eq11(memories.repo, repo),
+      eq11(memories.status, "active")
     )).orderBy(desc2(memories.confidence)).limit(20).all().map((row) => ({
       id: row.id,
       text: row.text,
@@ -2783,13 +5246,27 @@ var SummarizeSessionResult = z2.object({
 var SynthesizeRepoResult = z2.object({
   summary_text: z2.string().min(1).max(8e3)
 });
+var ExtractedRule = z2.object({
+  text: z2.string().min(1).max(2e3),
+  type: z2.enum(["rule", "decision", "review_pattern", "command", "gotcha"]),
+  scope: MemoryScope2,
+  path_scope: z2.string().max(512).nullable().optional(),
+  confidence: z2.number().min(0).max(1),
+  is_destructive_risky: z2.boolean().optional(),
+  rationale: z2.string().max(500).optional()
+});
+var ExtractRulesFromPromptResult = z2.object({
+  rules: z2.array(ExtractedRule).max(10),
+  dropped_reason: z2.string().max(500).optional()
+});
 var RESULT_SCHEMAS = {
   verify_capture: VerifyCaptureResult,
   refine_candidate: RefineCandidateResult,
   summarize_history: SummarizeHistoryResult,
   merge_duplicates: MergeDuplicatesResult,
   summarize_session: SummarizeSessionResult,
-  synthesize_repo: SynthesizeRepoResult
+  synthesize_repo: SynthesizeRepoResult,
+  extract_rules_from_prompt: ExtractRulesFromPromptResult
 };
 function payloadSummary(payload) {
   const out = {};
@@ -2830,7 +5307,7 @@ var TaskClaimConflictError = class extends Error {
   taskId;
   reason;
 };
-function claimTask(db, taskId, agent, leaseSeconds = DEFAULT_LEASE_SECONDS) {
+function claimTask(db, taskId, agent, leaseSeconds = DEFAULT_LEASE_SECONDS2) {
   const now = /* @__PURE__ */ new Date();
   const expiresAt = new Date(now.getTime() + leaseSeconds * 1e3).toISOString();
   const nowIso = now.toISOString();
@@ -2839,9 +5316,9 @@ function claimTask(db, taskId, agent, leaseSeconds = DEFAULT_LEASE_SECONDS) {
     claimed_by: agent,
     claimed_at: nowIso,
     claim_expires_at: expiresAt
-  }).where(and2(
-    eq7(memoryMaintenanceTasks.id, taskId),
-    eq7(memoryMaintenanceTasks.status, "pending")
+  }).where(and4(
+    eq11(memoryMaintenanceTasks.id, taskId),
+    eq11(memoryMaintenanceTasks.status, "pending")
   )).run();
   if (result.changes === 0) {
     const existing = getTask(db, taskId);
@@ -2873,7 +5350,7 @@ function submitTask(db, taskId, agent, result) {
       attempts,
       failure_reason: parsed.error.issues.map((i) => `${i.path.join(".")}:${i.message}`).join("; ").slice(0, 500),
       completed_at: abandoned ? now2 : null
-    }).where(eq7(memoryMaintenanceTasks.id, taskId)).run();
+    }).where(eq11(memoryMaintenanceTasks.id, taskId)).run();
     return {
       status: "rejected",
       task_id: taskId,
@@ -2899,7 +5376,7 @@ function submitTask(db, taskId, agent, result) {
       attempts,
       failure_reason: `apply-failed: ${message}`.slice(0, 500),
       completed_at: abandoned ? now2 : null
-    }).where(eq7(memoryMaintenanceTasks.id, taskId)).run();
+    }).where(eq11(memoryMaintenanceTasks.id, taskId)).run();
     return {
       status: "rejected",
       task_id: taskId,
@@ -2915,7 +5392,7 @@ function submitTask(db, taskId, agent, result) {
     submitted_at: now,
     completed_at: now,
     failure_reason: null
-  }).where(eq7(memoryMaintenanceTasks.id, taskId)).run();
+  }).where(eq11(memoryMaintenanceTasks.id, taskId)).run();
   return {
     status: "applied",
     task_id: taskId,
@@ -2937,13 +5414,12 @@ function releaseTask(db, taskId, agent, reason) {
     claimed_at: null,
     claim_expires_at: null,
     failure_reason: reason ? reason.slice(0, 500) : null
-  }).where(eq7(memoryMaintenanceTasks.id, taskId)).run();
+  }).where(eq11(memoryMaintenanceTasks.id, taskId)).run();
   return { status: "released" };
 }
 
 export {
   getEmbeddingCacheRoot,
-  memoryDedupeKey,
   historySnippetDedupeKey,
   activityEventDedupeKey,
   hookCallDedupeKey,
@@ -2963,8 +5439,6 @@ export {
   verifyEmbeddings,
   rebuildEmbeddingIndex,
   hybridSearch,
-  findSemanticDuplicates,
-  findSimilarRejectedExemplar,
   statusFromConfidence,
   createMemory,
   getMemory,
@@ -2976,21 +5450,21 @@ export {
   demoteGlobalMemory,
   rejectMemory,
   confirmMemory,
-  appendEvidence,
-  updateMemoryCaptureContext,
-  incrementMemoryRepetition,
-  countDistinctCorrectionSessions,
   recordFeedback,
-  getMemoryFeedback,
   getMemoryFeedbackSummaries,
   feedbackWeightedScore,
+  computeHealthScore,
+  computeAllHealthScores,
+  formatHealthReport,
+  getRepoQualityProfile,
+  seedScannedConfidence,
   recordAudit,
   recordAuditWithSnapshot,
   getAuditTrail,
   getRecentAudit,
   rollbackMemory,
   formatAuditTrail,
-  DEFAULT_LEASE_SECONDS,
+  DEFAULT_LEASE_SECONDS2 as DEFAULT_LEASE_SECONDS,
   DEFAULT_PRIORITIES,
   DEFAULT_ENQUEUE_CONFIG,
   targetKey,
@@ -3004,6 +5478,7 @@ export {
   expireStalePendingTasks,
   abandonOverAttemptTasks,
   applyBacklogCaps,
+  enqueueExtractRulesFromPrompt,
   enqueueVerifyCapture,
   produceRefineCandidateTasks,
   produceSummarizeHistoryTasks,
@@ -3016,6 +5491,30 @@ export {
   TaskClaimConflictError,
   claimTask,
   submitTask,
-  releaseTask
+  releaseTask,
+  dispatchPendingTasks,
+  hasAnyLlmProvider,
+  buildPrompt,
+  formatDispatchReport,
+  inferScope,
+  detectContradictions,
+  resolveContradiction,
+  autoResolveContradictions,
+  listContradictions,
+  runDeterministicCleanup,
+  planDedupeExact,
+  planRejectFragments,
+  qualityReasons,
+  planPromoteRepeats,
+  planSuppressCommands,
+  planGlobalizeCrossRepo,
+  revertCleanupRun,
+  listCleanupRuns,
+  formatCleanupReport,
+  isTriggerTemplateRule,
+  isHighRiskRule,
+  detectCorrections,
+  processCorrection,
+  processReviewFeedback
 };
-//# sourceMappingURL=chunk-IILLSHLM.js.map
+//# sourceMappingURL=chunk-KAGIAOD7.js.map