@edihasaj/recall 0.5.7 → 0.6.0

package/dist/chunk-VEPXEHRZ.js

@@ -1,1763 +0,0 @@
-import {
-  CONFIDENCE,
-  appendEvidence,
-  countDistinctCorrectionSessions,
-  createMemory,
-  demoteMemory,
-  enqueueVerifyCapture,
-  findSemanticDuplicates,
-  findSimilarRejectedExemplar,
-  getMemory,
-  getMemoryFeedback,
-  incrementMemoryRepetition,
-  listMemories,
-  loadEmbeddingConfigFromEnv,
-  memoryDedupeKey,
-  promoteMemory,
-  queryMemories,
-  recordAudit,
-  recordAuditWithSnapshot,
-  updateMemoryCaptureContext
-} from "./chunk-IILLSHLM.js";
-import {
-  contradictions,
-  feedbackEvents,
-  implicitSignals,
-  maintenanceCleanupLog,
-  memories,
-  memoryInjections
-} from "./chunk-A5UIRZU6.js";
-
-// src/maintenance/cleanup.ts
-import { and as and2, eq as eq4, gte, inArray, sql } from "drizzle-orm";
-import { randomUUID as randomUUID2 } from "crypto";
-
-// src/contradictions/detector.ts
-import { eq, and } from "drizzle-orm";
-import { randomUUID } 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(
-          and(
-            eq(contradictions.memory_a_id, a.id),
-            eq(contradictions.memory_b_id, b.id)
-          )
-        ).get();
-        if (!existing) {
-          const id = randomUUID();
-          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(eq(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(eq(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(eq(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(eq(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/repo/quality.ts
-import { eq as eq3 } from "drizzle-orm";
-
-// src/health/scoring.ts
-import { eq as eq2 } 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(eq2(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(eq2(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(eq3(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/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/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);
-}
-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) {
-  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/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 = randomUUID2();
-  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(inArray(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(eq4(feedbackEvents.memory_id, loser.id)).run();
-    const loserInj = db.select().from(memoryInjections).where(eq4(memoryInjections.memory_id, loser.id)).all();
-    for (const inj of loserInj) {
-      const collision = db.select({ id: memoryInjections.id }).from(memoryInjections).where(and2(eq4(memoryInjections.memory_id, winner.id), eq4(memoryInjections.session_id, inj.session_id))).get();
-      if (collision) {
-        db.delete(memoryInjections).where(eq4(memoryInjections.id, inj.id)).run();
-      } else {
-        db.update(memoryInjections).set({ memory_id: winner.id }).where(eq4(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(eq4(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(eq4(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: randomUUID2(),
-      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 = [
-  "is",
-  "are",
-  "use",
-  "uses",
-  "used",
-  "run",
-  "runs",
-  "ran",
-  "must",
-  "never",
-  "always",
-  "do",
-  "don't",
-  "do not",
-  "should",
-  "avoid",
-  "prefer",
-  "keep",
-  "set",
-  "add",
-  "remove",
-  "skip",
-  "replace",
-  "fix",
-  "ensure",
-  "require",
-  "require ",
-  "make",
-  "build",
-  "test",
-  "deploy",
-  "install",
-  "import",
-  "export",
-  "commit",
-  "push",
-  "call",
-  "wrap",
-  "split",
-  "merge",
-  "store",
-  "load",
-  "save",
-  "ignore",
-  "accept",
-  "reject"
-];
-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 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;
-function planRejectFragments(db) {
-  const rows = db.select({
-    id: memories.id,
-    text: memories.text,
-    source: memories.source,
-    status: memories.status
-  }).from(memories).where(and2(eq4(memories.status, "candidate"), eq4(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 < 14) 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 (DANGLING_CONNECTOR_RE.test(text)) reasons.push("dangling_connector");
-  if (RULE_FILLER_PREFIX_RE.test(text)) reasons.push("filler_prefix");
-  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(eq4(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: randomUUID2(),
-    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(and2(eq4(memories.status, "candidate"), eq4(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(eq4(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: randomUUID2(),
-    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(and2(
-    eq4(memories.status, "active"),
-    eq4(memories.type, "command"),
-    eq4(memories.auto_inject, true),
-    gte(memories.injection_count, SUPPRESS_INJECTION_FLOOR)
-  )).all();
-  const out = [];
-  for (const row of candidates) {
-    const followedRow = db.select({ n: sql`count(*)` }).from(feedbackEvents).where(and2(
-      eq4(feedbackEvents.memory_id, row.id),
-      eq4(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(eq4(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: randomUUID2(),
-    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(and2(eq4(memories.status, "active"), inArray(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(eq4(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(eq4(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: randomUUID2(),
-    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(eq4(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: randomUUID2(),
-      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(eq4(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(eq4(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(eq4(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";
-}
-
-export {
-  computeHealthScore,
-  computeAllHealthScores,
-  formatHealthReport,
-  getRepoQualityProfile,
-  seedScannedConfidence,
-  inferScope,
-  detectContradictions,
-  resolveContradiction,
-  autoResolveContradictions,
-  listContradictions,
-  runDeterministicCleanup,
-  planDedupeExact,
-  planRejectFragments,
-  qualityReasons,
-  planPromoteRepeats,
-  planSuppressCommands,
-  planGlobalizeCrossRepo,
-  revertCleanupRun,
-  listCleanupRuns,
-  formatCleanupReport,
-  isTriggerTemplateRule,
-  isHighRiskRule,
-  detectCorrections,
-  processCorrection,
-  processReviewFeedback
-};
-//# sourceMappingURL=chunk-VEPXEHRZ.js.map