opencode-swarm 7.67.0 → 7.68.1

package/dist/cli/index.js

@@ -52,7 +52,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.67.0",
+    version: "7.68.1",
     description: "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
     main: "dist/index.js",
     types: "dist/index.d.ts",
@@ -19221,7 +19221,7 @@ var init_loader = __esm(() => {
 });
 
 // src/config/evidence-schema.ts
-var EVIDENCE_MAX_JSON_BYTES, EVIDENCE_MAX_PATCH_BYTES, EVIDENCE_MAX_TASK_BYTES, EvidenceTypeSchema, EvidenceVerdictSchema, BaseEvidenceSchema, ReviewEvidenceSchema, TestEvidenceSchema, DiffEvidenceSchema, ApprovalEvidenceSchema, NoteEvidenceSchema, RetrospectiveEvidenceSchema, SyntaxEvidenceSchema, PlaceholderEvidenceSchema, SastFindingSchema, SastEvidenceSchema, SbomEvidenceSchema, BuildEvidenceSchema, QualityBudgetEvidenceSchema, SecretscanEvidenceSchema, EvidenceSchema, EvidenceBundleSchema;
+var EVIDENCE_MAX_JSON_BYTES, EVIDENCE_MAX_PATCH_BYTES, EVIDENCE_MAX_TASK_BYTES, EvidenceTypeSchema, EvidenceVerdictSchema, BaseEvidenceSchema, ReviewEvidenceSchema, TestEvidenceSchema, DiffEvidenceSchema, ApprovalEvidenceSchema, NoteEvidenceSchema, RetrospectiveEvidenceSchema, SyntaxEvidenceSchema, PlaceholderEvidenceSchema, SastFindingSchema, SastEvidenceSchema, SbomEvidenceSchema, BuildEvidenceSchema, QualityBudgetEvidenceSchema, SecretscanEvidenceSchema, GateEvidenceBaseSchema, MutationGateEvidenceSchema, DriftVerificationEvidenceSchema, HallucinationVerificationEvidenceSchema, EvidenceSchema, EvidenceBundleSchema;
 var init_evidence_schema = __esm(() => {
   init_zod();
   EVIDENCE_MAX_JSON_BYTES = 500 * 1024;
@@ -19240,11 +19240,16 @@ var init_evidence_schema = __esm(() => {
     "sbom",
     "build",
     "quality_budget",
-    "secretscan"
+    "secretscan",
+    "mutation-gate",
+    "drift-verification",
+    "hallucination-verification"
   ]);
   EvidenceVerdictSchema = exports_external.enum([
     "pass",
     "fail",
+    "warn",
+    "skip",
     "approved",
     "rejected",
     "info"
@@ -19450,6 +19455,30 @@ var init_evidence_schema = __esm(() => {
     files_scanned: exports_external.number().int().min(0).default(0),
     skipped_files: exports_external.number().int().min(0).default(0)
   });
+  GateEvidenceBaseSchema = exports_external.object({
+    task_id: exports_external.string().optional(),
+    agent: exports_external.string().optional(),
+    timestamp: exports_external.string().datetime(),
+    summary: exports_external.string().min(1),
+    metadata: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
+  });
+  MutationGateEvidenceSchema = GateEvidenceBaseSchema.extend({
+    type: exports_external.literal("mutation-gate"),
+    verdict: exports_external.enum(["pass", "warn", "fail", "skip"]),
+    killRate: exports_external.number().min(0).max(1).optional(),
+    adjustedKillRate: exports_external.number().min(0).max(1).optional(),
+    survivedMutants: exports_external.string().optional()
+  });
+  DriftVerificationEvidenceSchema = GateEvidenceBaseSchema.extend({
+    type: exports_external.literal("drift-verification"),
+    verdict: exports_external.enum(["approved", "rejected"]),
+    requirementCoverage: exports_external.string().optional()
+  });
+  HallucinationVerificationEvidenceSchema = GateEvidenceBaseSchema.extend({
+    type: exports_external.literal("hallucination-verification"),
+    verdict: exports_external.enum(["approved", "rejected"]),
+    findings: exports_external.string().optional()
+  });
   EvidenceSchema = exports_external.discriminatedUnion("type", [
     ReviewEvidenceSchema,
     TestEvidenceSchema,
@@ -19463,7 +19492,10 @@ var init_evidence_schema = __esm(() => {
     SbomEvidenceSchema,
     BuildEvidenceSchema,
     QualityBudgetEvidenceSchema,
-    SecretscanEvidenceSchema
+    SecretscanEvidenceSchema,
+    MutationGateEvidenceSchema,
+    DriftVerificationEvidenceSchema,
+    HallucinationVerificationEvidenceSchema
   ]);
   EvidenceBundleSchema = exports_external.object({
     schema_version: exports_external.literal("1.0.0"),
@@ -36950,14 +36982,217 @@ var init_event_bus = __esm(() => {
   init_utils();
 });
 
+// src/hooks/knowledge-events.ts
+import { existsSync as existsSync9 } from "fs";
+import { appendFile as appendFile2, mkdir as mkdir2, readFile as readFile2, writeFile as writeFile3 } from "fs/promises";
+import * as path12 from "path";
+function resolveKnowledgeEventsPath(directory) {
+  return path12.join(directory, ".swarm", "knowledge-events.jsonl");
+}
+function resolveLegacyApplicationLogPath(directory) {
+  return path12.join(directory, ".swarm", "knowledge-application.jsonl");
+}
+async function readKnowledgeEvents(directory) {
+  const filePath = resolveKnowledgeEventsPath(directory);
+  if (!existsSync9(filePath))
+    return [];
+  const content = await readFile2(filePath, "utf-8");
+  const out = [];
+  for (const line of content.split(`
+`)) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    try {
+      out.push(JSON.parse(trimmed));
+    } catch {
+      warn(`[knowledge-events] Skipping corrupted JSONL line in ${filePath}: ${trimmed.slice(0, 80)}`);
+    }
+  }
+  return out;
+}
+async function readLegacyApplicationRecords(directory) {
+  const filePath = resolveLegacyApplicationLogPath(directory);
+  if (!existsSync9(filePath))
+    return [];
+  const content = await readFile2(filePath, "utf-8");
+  const out = [];
+  for (const line of content.split(`
+`)) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    try {
+      out.push(JSON.parse(trimmed));
+    } catch {
+      warn(`[knowledge-events] Skipping corrupted JSONL line in ${filePath}: ${trimmed.slice(0, 80)}`);
+    }
+  }
+  return out;
+}
+function emptyRollup() {
+  return {
+    shown_count: 0,
+    acknowledged_count: 0,
+    applied_explicit_count: 0,
+    ignored_count: 0,
+    violated_count: 0,
+    contradicted_count: 0,
+    n_a_count: 0,
+    succeeded_after_shown_count: 0,
+    failed_after_shown_count: 0,
+    partial_after_shown_count: 0,
+    violation_timestamps: []
+  };
+}
+function get(map3, id) {
+  let r = map3.get(id);
+  if (!r) {
+    r = emptyRollup();
+    map3.set(id, r);
+  }
+  return r;
+}
+function maxIso(current, candidate) {
+  if (!current)
+    return candidate;
+  return candidate > current ? candidate : current;
+}
+function recomputeCounters(events, legacyRecords = []) {
+  const map3 = new Map;
+  const retrievedIds = new Set;
+  for (const e of events) {
+    switch (e.type) {
+      case "retrieved": {
+        for (const id of e.result_ids) {
+          retrievedIds.add(id);
+          get(map3, id).shown_count += 1;
+        }
+        break;
+      }
+      case "acknowledged": {
+        const r = get(map3, e.knowledge_id);
+        r.acknowledged_count += 1;
+        r.last_acknowledged_at = maxIso(r.last_acknowledged_at, e.timestamp);
+        break;
+      }
+      case "applied": {
+        const r = get(map3, e.knowledge_id);
+        r.applied_explicit_count += 1;
+        r.last_applied_at = maxIso(r.last_applied_at, e.timestamp);
+        break;
+      }
+      case "ignored":
+        get(map3, e.knowledge_id).ignored_count += 1;
+        break;
+      case "violated": {
+        const r = get(map3, e.knowledge_id);
+        r.violated_count += 1;
+        r.violation_timestamps.push(e.timestamp);
+        break;
+      }
+      case "contradicted":
+        get(map3, e.knowledge_id).contradicted_count += 1;
+        break;
+      case "n_a":
+        get(map3, e.knowledge_id).n_a_count += 1;
+        break;
+      case "outcome": {
+        if (!e.knowledge_id)
+          break;
+        const r = get(map3, e.knowledge_id);
+        if (e.outcome === "success")
+          r.succeeded_after_shown_count += 1;
+        else if (e.outcome === "failure")
+          r.failed_after_shown_count += 1;
+        else if (e.outcome === "partial")
+          r.partial_after_shown_count += 1;
+        break;
+      }
+    }
+  }
+  for (const rec of legacyRecords) {
+    const r = get(map3, rec.knowledgeId);
+    switch (rec.result) {
+      case "shown":
+        if (!retrievedIds.has(rec.knowledgeId))
+          r.shown_count += 1;
+        break;
+      case "acknowledged":
+        r.acknowledged_count += 1;
+        r.last_acknowledged_at = maxIso(r.last_acknowledged_at, rec.timestamp);
+        break;
+      case "applied":
+        r.applied_explicit_count += 1;
+        r.last_applied_at = maxIso(r.last_applied_at, rec.timestamp);
+        break;
+      case "ignored":
+        r.ignored_count += 1;
+        break;
+      case "violated":
+        r.violated_count += 1;
+        r.violation_timestamps.push(rec.timestamp);
+        break;
+    }
+  }
+  for (const r of map3.values()) {
+    if (r.violation_timestamps.length > 1) {
+      r.violation_timestamps.sort((a, b) => a < b ? 1 : a > b ? -1 : 0);
+    }
+    if (r.violation_timestamps.length > MAX_VIOLATION_TIMESTAMPS) {
+      r.violation_timestamps = r.violation_timestamps.slice(0, MAX_VIOLATION_TIMESTAMPS);
+    }
+  }
+  return map3;
+}
+async function readKnowledgeCounterRollups(directory) {
+  try {
+    const [events, legacyRecords] = await Promise.all([
+      readKnowledgeEvents(directory),
+      readLegacyApplicationRecords(directory)
+    ]);
+    return recomputeCounters(events, legacyRecords);
+  } catch (err) {
+    warn(`[knowledge-events] readKnowledgeCounterRollups failed: ${err instanceof Error ? err.message : String(err)}`);
+    return new Map;
+  }
+}
+function effectiveRetrievalOutcomes(stored, rollup) {
+  const base = stored ?? {
+    applied_count: 0,
+    succeeded_after_count: 0,
+    failed_after_count: 0
+  };
+  if (!rollup)
+    return base;
+  return {
+    ...base,
+    ...rollup
+  };
+}
+var import_proper_lockfile3, RECEIPT_EVENT_TYPES, MAX_VIOLATION_TIMESTAMPS = 10;
+var init_knowledge_events = __esm(() => {
+  init_logger();
+  import_proper_lockfile3 = __toESM(require_proper_lockfile(), 1);
+  RECEIPT_EVENT_TYPES = new Set([
+    "acknowledged",
+    "applied",
+    "ignored",
+    "contradicted",
+    "violated",
+    "n_a",
+    "override"
+  ]);
+});
+
 // src/evidence/task-file.ts
 import { renameSync as renameSync6, unlinkSync as unlinkSync4 } from "fs";
-import * as path12 from "path";
+import * as path13 from "path";
 function taskEvidenceRelPath(taskId) {
-  return path12.join("evidence", `${taskId}.json`);
+  return path13.join("evidence", `${taskId}.json`);
 }
 function taskEvidencePath(directory, taskId) {
-  return path12.join(directory, ".swarm", taskEvidenceRelPath(taskId));
+  return path13.join(directory, ".swarm", taskEvidenceRelPath(taskId));
 }
 async function atomicWriteFile(targetPath, content) {
   const tempPath = `${targetPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
@@ -36981,40 +37216,40 @@ var init_task_file = __esm(() => {
 });
 
 // src/hooks/knowledge-store.ts
-import { existsSync as existsSync9 } from "fs";
-import { appendFile as appendFile2, mkdir as mkdir2, readFile as readFile2 } from "fs/promises";
+import { existsSync as existsSync10 } from "fs";
+import { appendFile as appendFile3, mkdir as mkdir3, readFile as readFile3 } from "fs/promises";
 import * as os4 from "os";
-import * as path13 from "path";
+import * as path14 from "path";
 function resolveSwarmKnowledgePath(directory) {
-  return path13.join(directory, ".swarm", "knowledge.jsonl");
+  return path14.join(directory, ".swarm", "knowledge.jsonl");
 }
 function resolveSwarmRejectedPath(directory) {
-  return path13.join(directory, ".swarm", "knowledge-rejected.jsonl");
+  return path14.join(directory, ".swarm", "knowledge-rejected.jsonl");
 }
 function resolveSwarmRetractionsPath(directory) {
-  return path13.join(directory, ".swarm", "knowledge-retractions.jsonl");
+  return path14.join(directory, ".swarm", "knowledge-retractions.jsonl");
 }
 function resolveHiveKnowledgePath() {
   const platform = process.platform;
   const home = process.env.HOME || os4.homedir();
   let dataDir;
   if (platform === "win32") {
-    dataDir = path13.join(process.env.LOCALAPPDATA || path13.join(home, "AppData", "Local"), "opencode-swarm", "Data");
+    dataDir = path14.join(process.env.LOCALAPPDATA || path14.join(home, "AppData", "Local"), "opencode-swarm", "Data");
   } else if (platform === "darwin") {
-    dataDir = path13.join(home, "Library", "Application Support", "opencode-swarm");
+    dataDir = path14.join(home, "Library", "Application Support", "opencode-swarm");
   } else {
-    dataDir = path13.join(process.env.XDG_DATA_HOME || path13.join(home, ".local", "share"), "opencode-swarm");
+    dataDir = path14.join(process.env.XDG_DATA_HOME || path14.join(home, ".local", "share"), "opencode-swarm");
   }
-  return path13.join(dataDir, "shared-learnings.jsonl");
+  return path14.join(dataDir, "shared-learnings.jsonl");
 }
 function resolveHiveRejectedPath() {
   const hivePath = resolveHiveKnowledgePath();
-  return path13.join(path13.dirname(hivePath), "shared-learnings-rejected.jsonl");
+  return path14.join(path14.dirname(hivePath), "shared-learnings-rejected.jsonl");
 }
 async function readKnowledge(filePath) {
-  if (!existsSync9(filePath))
+  if (!existsSync10(filePath))
     return [];
-  const content = await readFile2(filePath, "utf-8");
+  const content = await readFile3(filePath, "utf-8");
   const results = [];
   for (const line of content.split(`
 `)) {
@@ -37106,15 +37341,15 @@ async function appendRetractionRecord(directory, record3) {
   await appendKnowledge(resolveSwarmRetractionsPath(directory), record3);
 }
 async function appendKnowledge(filePath, entry) {
-  const dir = path13.dirname(filePath);
-  await mkdir2(dir, { recursive: true });
+  const dir = path14.dirname(filePath);
+  await mkdir3(dir, { recursive: true });
   let release = null;
   try {
-    release = await import_proper_lockfile3.default.lock(dir, {
+    release = await import_proper_lockfile4.default.lock(dir, {
       retries: { retries: 5, minTimeout: 100, maxTimeout: 500 },
       stale: 5000
     });
-    await appendFile2(filePath, `${JSON.stringify(entry)}
+    await appendFile3(filePath, `${JSON.stringify(entry)}
 `, "utf-8");
   } finally {
     if (release) {
@@ -37125,11 +37360,11 @@ async function appendKnowledge(filePath, entry) {
   }
 }
 async function rewriteKnowledge(filePath, entries) {
-  const dir = path13.dirname(filePath);
-  await mkdir2(dir, { recursive: true });
+  const dir = path14.dirname(filePath);
+  await mkdir3(dir, { recursive: true });
   let release = null;
   try {
-    release = await import_proper_lockfile3.default.lock(dir, {
+    release = await import_proper_lockfile4.default.lock(dir, {
       retries: { retries: 5, minTimeout: 100, maxTimeout: 500 },
       stale: 5000
     });
@@ -37146,15 +37381,15 @@ async function rewriteKnowledge(filePath, entries) {
   }
 }
 async function transactFile(filePath, read, write, mutate) {
-  const dir = path13.dirname(filePath);
+  const dir = path14.dirname(filePath);
   try {
-    await mkdir2(dir, { recursive: true });
+    await mkdir3(dir, { recursive: true });
   } catch {
     return false;
   }
   let release = null;
   try {
-    release = await import_proper_lockfile3.default.lock(dir, {
+    release = await import_proper_lockfile4.default.lock(dir, {
       retries: { retries: 5, minTimeout: 100, maxTimeout: 500 },
       stale: 5000
     });
@@ -37301,9 +37536,9 @@ async function applyConfidenceDeltas(filePath, deltas) {
   }
   let release = null;
   try {
-    const dir = path13.dirname(filePath);
-    await mkdir2(dir, { recursive: true });
-    release = await import_proper_lockfile3.default.lock(dir, {
+    const dir = path14.dirname(filePath);
+    await mkdir3(dir, { recursive: true });
+    release = await import_proper_lockfile4.default.lock(dir, {
       retries: { retries: 5, minTimeout: 100, maxTimeout: 500 },
       stale: 5000
     });
@@ -37336,15 +37571,432 @@ async function applyConfidenceDeltas(filePath, deltas) {
     }
   }
 }
-var import_proper_lockfile3, OUTCOME_SIGNAL_SMOOTHING = 4, CONFIDENCE_FLOOR = 0.1, CONFIDENCE_CEILING = 1;
+var import_proper_lockfile4, OUTCOME_SIGNAL_SMOOTHING = 4, CONFIDENCE_FLOOR = 0.1, CONFIDENCE_CEILING = 1;
 var init_knowledge_store = __esm(() => {
   init_task_file();
-  import_proper_lockfile3 = __toESM(require_proper_lockfile(), 1);
+  import_proper_lockfile4 = __toESM(require_proper_lockfile(), 1);
+});
+
+// src/hooks/knowledge-escalator.ts
+async function readRecentEscalations(directory, windowDays = ESCALATION_DISPLAY_WINDOW_DAYS, now = new Date) {
+  try {
+    const cutoff = now.getTime() - windowDays * 24 * 60 * 60 * 1000;
+    const events = await readKnowledgeEvents(directory);
+    const out = [];
+    for (const e of events) {
+      if (e.type !== "escalation")
+        continue;
+      const t = Date.parse(e.timestamp);
+      if (Number.isNaN(t) || t < cutoff)
+        continue;
+      out.push({
+        entry_id: e.entry_id,
+        from: e.from,
+        to: e.to,
+        reason: e.reason,
+        at: e.timestamp
+      });
+    }
+    out.sort((a, b) => a.at < b.at ? 1 : a.at > b.at ? -1 : 0);
+    return out;
+  } catch {
+    return [];
+  }
+}
+var ESCALATION_DISPLAY_WINDOW_DAYS = 7;
+var init_knowledge_escalator = __esm(() => {
+  init_knowledge_events();
+  init_knowledge_store();
+});
+
+// src/services/learning-metrics.ts
+function safeDivide(numerator, denominator) {
+  return denominator === 0 ? 0 : numerator / denominator;
+}
+function truncateLesson(lesson) {
+  if (lesson.length <= MAX_LESSON_DISPLAY_CHARS)
+    return lesson;
+  return `${lesson.slice(0, MAX_LESSON_DISPLAY_CHARS - 3)}...`;
+}
+function isReceiptType(event) {
+  return event.type === "acknowledged" || event.type === "applied" || event.type === "ignored" || event.type === "contradicted" || event.type === "violated" || event.type === "n_a" || event.type === "override";
+}
+function countWindowedReceipts(events, entryId, windowMs, nowMs) {
+  const cutoff = nowMs - windowMs;
+  let violations = 0;
+  let totalReceipts = 0;
+  for (const e of events) {
+    if (!isReceiptType(e))
+      continue;
+    if (e.knowledge_id !== entryId)
+      continue;
+    const t = Date.parse(e.timestamp);
+    if (Number.isNaN(t) || t < cutoff)
+      continue;
+    totalReceipts++;
+    if (e.type === "violated")
+      violations++;
+  }
+  return { violations, totalReceipts };
+}
+function determineTrend(rate7d, rate30d, hasData) {
+  if (!hasData)
+    return "no_data";
+  if (rate7d < rate30d)
+    return "improving";
+  if (rate7d > rate30d)
+    return "worsening";
+  return "stable";
+}
+function classifyROI(rollup) {
+  if (rollup.applied_explicit_count > 0 && rollup.succeeded_after_shown_count > rollup.failed_after_shown_count) {
+    return "high";
+  }
+  if (rollup.applied_explicit_count > 0) {
+    return "medium";
+  }
+  if (rollup.shown_count > 0) {
+    return "low";
+  }
+  return "unused";
+}
+async function computeLearningMetrics(directory, options) {
+  const now = options?.now ?? new Date;
+  const nowMs = now.getTime();
+  const phasesThreshold = options?.currentPhase ?? DEFAULT_PHASES_ALIVE_THRESHOLD;
+  const [events, entries] = await Promise.all([
+    readKnowledgeEvents(directory),
+    readKnowledge(resolveSwarmKnowledgePath(directory))
+  ]);
+  if (events.length === 0 && entries.length === 0) {
+    return emptyMetrics();
+  }
+  const rollups = recomputeCounters(events);
+  const entryMap = new Map;
+  for (const entry of entries) {
+    entryMap.set(entry.id, entry);
+  }
+  const sessionIds = new Set;
+  for (const e of events) {
+    if ("session_id" in e && typeof e.session_id === "string") {
+      sessionIds.add(e.session_id);
+    }
+  }
+  const sessionCount = sessionIds.size;
+  const violationTrends = [];
+  for (const [entryId, rollup] of rollups) {
+    if (rollup.violated_count === 0)
+      continue;
+    const entry = entryMap.get(entryId);
+    const lesson = entry?.lesson ?? entryId;
+    const priority = entry?.directive_priority ?? "medium";
+    const w7 = countWindowedReceipts(events, entryId, SEVEN_DAYS_MS, nowMs);
+    const w30 = countWindowedReceipts(events, entryId, THIRTY_DAYS_MS, nowMs);
+    const rate7d = safeDivide(w7.violations, w7.totalReceipts);
+    const rate30d = safeDivide(w30.violations, w30.totalReceipts);
+    const hasData = w7.totalReceipts > 0 || w30.totalReceipts > 0;
+    violationTrends.push({
+      entryId,
+      lesson,
+      priority,
+      violationRate7d: rate7d,
+      violationRate30d: rate30d,
+      trend: determineTrend(rate7d, rate30d, hasData)
+    });
+  }
+  let totalViolations7d = 0;
+  let totalReceipts7d = 0;
+  let totalViolations30d = 0;
+  let totalReceipts30d = 0;
+  for (const e of events) {
+    if (!isReceiptType(e))
+      continue;
+    const t = Date.parse(e.timestamp);
+    if (Number.isNaN(t))
+      continue;
+    if (t >= nowMs - SEVEN_DAYS_MS) {
+      totalReceipts7d++;
+      if (e.type === "violated")
+        totalViolations7d++;
+    }
+    if (t >= nowMs - THIRTY_DAYS_MS) {
+      totalReceipts30d++;
+      if (e.type === "violated")
+        totalViolations30d++;
+    }
+  }
+  const overallViolationRate = {
+    window7d: safeDivide(totalViolations7d, totalReceipts7d),
+    window30d: safeDivide(totalViolations30d, totalReceipts30d)
+  };
+  const priorityGroups = new Map;
+  for (const entry of entries) {
+    const priority = entry.directive_priority ?? "medium";
+    const rollup = rollups.get(entry.id);
+    if (!rollup)
+      continue;
+    let group = priorityGroups.get(priority);
+    if (!group) {
+      group = { applied: 0, total: 0 };
+      priorityGroups.set(priority, group);
+    }
+    group.applied += rollup.applied_explicit_count;
+    group.total += rollup.shown_count;
+  }
+  const applicationRateByPriority = {};
+  for (const [priority, group] of priorityGroups) {
+    applicationRateByPriority[priority] = {
+      applied: group.applied,
+      total: group.total,
+      rate: safeDivide(group.applied, group.total)
+    };
+  }
+  const timeToLatestApplication = [];
+  for (const entry of entries) {
+    const rollup = rollups.get(entry.id);
+    let daysToApply = null;
+    if (rollup?.last_applied_at && entry.created_at) {
+      const appliedMs = Date.parse(rollup.last_applied_at);
+      const createdMs = Date.parse(entry.created_at);
+      if (!Number.isNaN(appliedMs) && !Number.isNaN(createdMs) && appliedMs >= createdMs) {
+        daysToApply = (appliedMs - createdMs) / MS_PER_DAY;
+      }
+    }
+    timeToLatestApplication.push({
+      entryId: entry.id,
+      lesson: entry.lesson,
+      daysToApply
+    });
+  }
+  const recentEscalations30d = await readRecentEscalations(directory, 30, now);
+  const last7dCutoff = nowMs - SEVEN_DAYS_MS;
+  const last7d = recentEscalations30d.filter((esc3) => {
+    const t = Date.parse(esc3.at);
+    return !Number.isNaN(t) && t >= last7dCutoff;
+  }).length;
+  let totalEscalations = 0;
+  for (const e of events) {
+    if (e.type === "escalation")
+      totalEscalations++;
+  }
+  const escalationFrequency = {
+    total: totalEscalations,
+    last7d,
+    last30d: recentEscalations30d.length
+  };
+  let unacknowledgedCriticalCount = 0;
+  for (const entry of entries) {
+    if (entry.directive_priority !== "critical")
+      continue;
+    const rollup = rollups.get(entry.id);
+    if (!rollup)
+      continue;
+    if (rollup.shown_count > 0 && rollup.acknowledged_count === 0 && rollup.applied_explicit_count === 0) {
+      unacknowledgedCriticalCount++;
+    }
+  }
+  const entryROI = [];
+  for (const entry of entries) {
+    const rollup = rollups.get(entry.id);
+    if (!rollup) {
+      entryROI.push({
+        entryId: entry.id,
+        lesson: entry.lesson,
+        appliedCount: 0,
+        shownCount: 0,
+        succeededCount: 0,
+        failedCount: 0,
+        roi: "unused"
+      });
+      continue;
+    }
+    entryROI.push({
+      entryId: entry.id,
+      lesson: entry.lesson,
+      appliedCount: rollup.applied_explicit_count,
+      shownCount: rollup.shown_count,
+      succeededCount: rollup.succeeded_after_shown_count,
+      failedCount: rollup.failed_after_shown_count,
+      roi: classifyROI(rollup)
+    });
+  }
+  const neverApplied = [];
+  for (const entry of entries) {
+    const rollup = rollups.get(entry.id);
+    const applied = rollup?.applied_explicit_count ?? 0;
+    const phasesAlive = entry.phases_alive ?? 0;
+    if (applied === 0 && phasesAlive >= phasesThreshold) {
+      neverApplied.push({
+        entryId: entry.id,
+        lesson: entry.lesson,
+        phasesAlive
+      });
+    }
+  }
+  const learningSummary = buildLearningSummary(overallViolationRate, violationTrends, sessionCount);
+  return {
+    violationTrends,
+    overallViolationRate,
+    applicationRateByPriority,
+    timeToLatestApplication,
+    escalationFrequency,
+    unacknowledgedCriticalCount,
+    entryROI,
+    neverApplied,
+    learningSummary,
+    sessionCount
+  };
+}
+function emptyMetrics() {
+  return {
+    violationTrends: [],
+    overallViolationRate: { window7d: 0, window30d: 0 },
+    applicationRateByPriority: {},
+    timeToLatestApplication: [],
+    escalationFrequency: { total: 0, last7d: 0, last30d: 0 },
+    unacknowledgedCriticalCount: 0,
+    entryROI: [],
+    neverApplied: [],
+    learningSummary: "No learning data yet",
+    sessionCount: 0
+  };
+}
+function buildLearningSummary(overallRate, trends, sessionCount) {
+  const overallTrend = overallRate.window7d < overallRate.window30d ? "improving" : overallRate.window7d > overallRate.window30d ? "worsening" : "stable";
+  const rate7dPct = (overallRate.window7d * 100).toFixed(1);
+  const rate30dPct = (overallRate.window30d * 100).toFixed(1);
+  const line1 = `Learning trend: ${overallTrend} \u2014 ${rate7dPct}% violation rate (7d), ${rate30dPct}% (30d) across ${sessionCount} sessions`;
+  let line2 = "No improvement data yet";
+  let bestDrop = 0;
+  let bestDropEntry;
+  for (const t of trends) {
+    if (t.trend !== "improving")
+      continue;
+    const drop = t.violationRate30d - t.violationRate7d;
+    if (drop > bestDrop) {
+      bestDrop = drop;
+      bestDropEntry = t;
+    }
+  }
+  if (bestDropEntry) {
+    line2 = `Top improvement: ${truncateLesson(bestDropEntry.lesson)}`;
+  }
+  let line3 = "No concerns detected";
+  let worstRise = 0;
+  let worstEntry;
+  for (const t of trends) {
+    if (t.trend !== "worsening")
+      continue;
+    const rise = t.violationRate7d - t.violationRate30d;
+    if (rise > worstRise) {
+      worstRise = rise;
+      worstEntry = t;
+    }
+  }
+  if (worstEntry) {
+    line3 = `Watch: ${truncateLesson(worstEntry.lesson)}`;
+  }
+  return `${line1}
+${line2}
+${line3}`;
+}
+function formatLearningMarkdown(metrics) {
+  const lines = [];
+  lines.push("## Learning Summary", "", metrics.learningSummary, "");
+  lines.push("## Violation Trends", "");
+  if (metrics.violationTrends.length === 0) {
+    lines.push("No violation trends recorded.", "");
+  } else {
+    lines.push("| Entry | Priority | 7d Rate | 30d Rate | Trend |");
+    lines.push("|-------|----------|---------|----------|-------|");
+    for (const t of metrics.violationTrends) {
+      lines.push(`| ${truncateLesson(t.lesson)} | ${t.priority} | ${(t.violationRate7d * 100).toFixed(1)}% | ${(t.violationRate30d * 100).toFixed(1)}% | ${t.trend} |`);
+    }
+    lines.push("");
+  }
+  lines.push("## Application Rates by Priority", "");
+  const priorities = Object.keys(metrics.applicationRateByPriority);
+  if (priorities.length === 0) {
+    lines.push("No application data recorded.", "");
+  } else {
+    lines.push("| Priority | Applied | Total | Rate |");
+    lines.push("|----------|---------|-------|------|");
+    for (const p of priorities) {
+      const g = metrics.applicationRateByPriority[p];
+      lines.push(`| ${p} | ${g.applied} | ${g.total} | ${(g.rate * 100).toFixed(1)}% |`);
+    }
+    lines.push("");
+  }
+  lines.push("## Escalation Activity", "");
+  lines.push(`- Total escalations: ${metrics.escalationFrequency.total}`);
+  lines.push(`- Last 7 days: ${metrics.escalationFrequency.last7d}`);
+  lines.push(`- Last 30 days: ${metrics.escalationFrequency.last30d}`);
+  lines.push("");
+  lines.push("## Entry ROI", "");
+  const sortedROI = [...metrics.entryROI].sort((a, b) => b.shownCount - a.shownCount);
+  const top10 = sortedROI.slice(0, 10);
+  const unused = metrics.entryROI.filter((r) => r.roi === "unused");
+  const roiEntries = [...top10];
+  for (const u of unused) {
+    if (!roiEntries.some((r) => r.entryId === u.entryId)) {
+      roiEntries.push(u);
+    }
+  }
+  if (roiEntries.length === 0) {
+    lines.push("No ROI data recorded.", "");
+  } else {
+    lines.push("| Entry | Applied | Shown | Succeeded | Failed | ROI |");
+    lines.push("|-------|---------|-------|-----------|--------|-----|");
+    for (const r of roiEntries) {
+      lines.push(`| ${truncateLesson(r.lesson)} | ${r.appliedCount} | ${r.shownCount} | ${r.succeededCount} | ${r.failedCount} | ${r.roi} |`);
+    }
+    lines.push("");
+  }
+  lines.push("## Never Applied", "");
+  if (metrics.neverApplied.length === 0) {
+    lines.push("All entries have been applied or are below the phase threshold.", "");
+  } else {
+    lines.push("| Entry | Phases Alive |");
+    lines.push("|-------|-------------|");
+    for (const n of metrics.neverApplied) {
+      lines.push(`| ${truncateLesson(n.lesson)} | ${n.phasesAlive} |`);
+    }
+    lines.push("");
+  }
+  lines.push("## Time to Latest Application", "");
+  const applied = metrics.timeToLatestApplication.filter((t) => t.daysToApply !== null).map((t) => t.daysToApply);
+  if (applied.length === 0) {
+    lines.push("No application timing data available.", "");
+  } else {
+    applied.sort((a, b) => a - b);
+    const median = applied.length % 2 === 0 ? (applied[applied.length / 2 - 1] + applied[applied.length / 2]) / 2 : applied[Math.floor(applied.length / 2)];
+    const min = applied[0];
+    const max = applied[applied.length - 1];
+    lines.push(`- Median: ${median.toFixed(1)} days`);
+    lines.push(`- Min: ${min.toFixed(1)} days`);
+    lines.push(`- Max: ${max.toFixed(1)} days`);
+    lines.push(`- Entries with data: ${applied.length}`);
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function formatLearningJSON(metrics) {
+  return metrics;
+}
+var SEVEN_DAYS_MS, THIRTY_DAYS_MS, MS_PER_DAY, DEFAULT_PHASES_ALIVE_THRESHOLD = 3, MAX_LESSON_DISPLAY_CHARS = 60;
+var init_learning_metrics = __esm(() => {
+  init_knowledge_escalator();
+  init_knowledge_events();
+  init_knowledge_store();
+  SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
+  THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1000;
+  MS_PER_DAY = 24 * 60 * 60 * 1000;
 });
 
 // src/hooks/knowledge-validator.ts
-import { appendFile as appendFile3, mkdir as mkdir3 } from "fs/promises";
-import * as path14 from "path";
+import { appendFile as appendFile4, mkdir as mkdir4 } from "fs/promises";
+import * as path15 from "path";
 function normalizeText(text) {
   return text.normalize("NFKC").toLowerCase().replace(/[^\w\s]/g, " ").replace(/\s+/g, " ").trim();
 }
@@ -37497,7 +38149,7 @@ function validateSkillPath(p) {
     return false;
   if (p.includes("\x00"))
     return false;
-  if (path14.isAbsolute(p))
+  if (path15.isAbsolute(p))
     return false;
   if (p.includes(".."))
     return false;
@@ -37599,15 +38251,15 @@ function validateActionability(entry) {
   return { actionable: false, reason };
 }
 function resolveUnactionablePath(directory) {
-  return path14.join(directory, ".swarm", "knowledge-unactionable.jsonl");
+  return path15.join(directory, ".swarm", "knowledge-unactionable.jsonl");
 }
 async function appendUnactionable(directory, entry, reason) {
   const filePath = resolveUnactionablePath(directory);
-  const dirPath = path14.dirname(filePath);
-  await mkdir3(dirPath, { recursive: true });
+  const dirPath = path15.dirname(filePath);
+  await mkdir4(dirPath, { recursive: true });
   let release = null;
   try {
-    release = await import_proper_lockfile4.default.lock(dirPath, {
+    release = await import_proper_lockfile5.default.lock(dirPath, {
       retries: { retries: 50, minTimeout: 10, maxTimeout: 100 },
       stale: 5000
     });
@@ -37617,7 +38269,7 @@ async function appendUnactionable(directory, entry, reason) {
       unactionable_reason: reason,
       quarantined_at: new Date().toISOString()
     };
-    await appendFile3(filePath, `${JSON.stringify(record3)}
+    await appendFile4(filePath, `${JSON.stringify(record3)}
 `, "utf-8");
     const existing = await readKnowledge(filePath);
     if (existing.length > 200) {
@@ -37646,14 +38298,14 @@ async function quarantineEntry(directory, entryId, reason, reportedBy) {
     return;
   }
   const sanitizedReason = reason.slice(0, 500).replace(/[\x00-\x08\x0b-\x0c\x0e-\x1f\x7f\x0d]/g, "");
-  const knowledgePath = path14.join(directory, ".swarm", "knowledge.jsonl");
-  const quarantinePath = path14.join(directory, ".swarm", "knowledge-quarantined.jsonl");
-  const rejectedPath = path14.join(directory, ".swarm", "knowledge-rejected.jsonl");
-  const swarmDir = path14.join(directory, ".swarm");
-  await mkdir3(swarmDir, { recursive: true });
+  const knowledgePath = path15.join(directory, ".swarm", "knowledge.jsonl");
+  const quarantinePath = path15.join(directory, ".swarm", "knowledge-quarantined.jsonl");
+  const rejectedPath = path15.join(directory, ".swarm", "knowledge-rejected.jsonl");
+  const swarmDir = path15.join(directory, ".swarm");
+  await mkdir4(swarmDir, { recursive: true });
   let release;
   try {
-    release = await import_proper_lockfile4.default.lock(swarmDir, {
+    release = await import_proper_lockfile5.default.lock(swarmDir, {
       retries: { retries: 5, minTimeout: 100, maxTimeout: 500 },
       stale: 5000
     });
@@ -37675,7 +38327,7 @@ async function quarantineEntry(directory, entryId, reason, reportedBy) {
 `)}
 ` : "";
     await atomicWriteFile(knowledgePath, jsonlContent);
-    await appendFile3(quarantinePath, `${JSON.stringify(quarantined)}
+    await appendFile4(quarantinePath, `${JSON.stringify(quarantined)}
 `, "utf-8");
     const quarantinedEntries = await readKnowledge(quarantinePath);
     if (quarantinedEntries.length > 100) {
@@ -37692,7 +38344,7 @@ async function quarantineEntry(directory, entryId, reason, reportedBy) {
       rejected_at: new Date().toISOString(),
       rejection_layer: 3
     };
-    await appendFile3(rejectedPath, `${JSON.stringify(rejectedRecord)}
+    await appendFile4(rejectedPath, `${JSON.stringify(rejectedRecord)}
 `, "utf-8");
   } finally {
     if (release) {
@@ -37710,14 +38362,14 @@ async function restoreEntry(directory, entryId) {
     warn("[knowledge-validator] restoreEntry: invalid entryId rejected");
     return;
   }
-  const knowledgePath = path14.join(directory, ".swarm", "knowledge.jsonl");
-  const quarantinePath = path14.join(directory, ".swarm", "knowledge-quarantined.jsonl");
-  const rejectedPath = path14.join(directory, ".swarm", "knowledge-rejected.jsonl");
-  const swarmDir = path14.join(directory, ".swarm");
-  await mkdir3(swarmDir, { recursive: true });
+  const knowledgePath = path15.join(directory, ".swarm", "knowledge.jsonl");
+  const quarantinePath = path15.join(directory, ".swarm", "knowledge-quarantined.jsonl");
+  const rejectedPath = path15.join(directory, ".swarm", "knowledge-rejected.jsonl");
+  const swarmDir = path15.join(directory, ".swarm");
+  await mkdir4(swarmDir, { recursive: true });
   let release;
   try {
-    release = await import_proper_lockfile4.default.lock(swarmDir, {
+    release = await import_proper_lockfile5.default.lock(swarmDir, {
       retries: { retries: 5, minTimeout: 100, maxTimeout: 500 },
       stale: 5000
     });
@@ -37749,7 +38401,7 @@ async function restoreEntry(directory, entryId) {
 `)}
 ` : "";
     await atomicWriteFile(quarantinePath, jsonlContent);
-    await appendFile3(knowledgePath, `${JSON.stringify(original)}
+    await appendFile4(knowledgePath, `${JSON.stringify(original)}
 `, "utf-8");
     const rejectedEntries = await readKnowledge(rejectedPath);
     const filtered = rejectedEntries.filter((e) => e.id !== entryId);
@@ -37763,12 +38415,12 @@ async function restoreEntry(directory, entryId) {
     }
   }
 }
-var import_proper_lockfile4, DANGEROUS_COMMAND_PATTERNS, SECURITY_DEGRADING_PATTERNS, INVISIBLE_FORMAT_CHARS, INJECTION_PATTERNS, VALID_CATEGORIES, TECH_REFERENCE_WORDS, ACTION_VERB_WORDS, NEGATION_PAIRS, ACTIONABLE_STRING_MAX = 200, ACTIONABLE_LIST_MAX = 20, NAME_PATTERN, SOURCE_REF_FORBIDDEN, ALLOWED_SKILL_PATH_PREFIXES, VALID_DIRECTIVE_PRIORITIES;
+var import_proper_lockfile5, DANGEROUS_COMMAND_PATTERNS, SECURITY_DEGRADING_PATTERNS, INVISIBLE_FORMAT_CHARS, INJECTION_PATTERNS, VALID_CATEGORIES, TECH_REFERENCE_WORDS, ACTION_VERB_WORDS, NEGATION_PAIRS, ACTIONABLE_STRING_MAX = 200, ACTIONABLE_LIST_MAX = 20, NAME_PATTERN, SOURCE_REF_FORBIDDEN, ALLOWED_SKILL_PATH_PREFIXES, VALID_DIRECTIVE_PRIORITIES;
 var init_knowledge_validator = __esm(() => {
   init_task_file();
   init_logger();
   init_knowledge_store();
-  import_proper_lockfile4 = __toESM(require_proper_lockfile(), 1);
+  import_proper_lockfile5 = __toESM(require_proper_lockfile(), 1);
   DANGEROUS_COMMAND_PATTERNS = [
     /\brm\s+-rf\b/,
     /\bsudo\s+rm\b/,
@@ -37885,10 +38537,15 @@ var init_knowledge_validator = __esm(() => {
   ]);
 });
 
+// src/services/skill-changelog.ts
+var init_skill_changelog = __esm(() => {
+  init_logger();
+});
+
 // src/services/skill-generator.ts
-import { existsSync as existsSync10, unlinkSync as unlinkSync5 } from "fs";
-import { mkdir as mkdir4, readFile as readFile3, rename as rename3, writeFile as writeFile3 } from "fs/promises";
-import * as path15 from "path";
+import { existsSync as existsSync11, unlinkSync as unlinkSync5 } from "fs";
+import { mkdir as mkdir5, readFile as readFile4, rename as rename3, writeFile as writeFile4 } from "fs/promises";
+import * as path16 from "path";
 function sanitizeSlug(input) {
   const lc = input.toLowerCase().trim();
   const mapped = lc.replace(/[^a-z0-9-]+/g, "-").replace(/-+/g, "-");
@@ -37899,10 +38556,10 @@ function isValidSlug(slug) {
   return SLUG_PATTERN.test(slug);
 }
 function proposalPath(directory, slug) {
-  return path15.join(directory, ".swarm", "skills", "proposals", `${slug}.md`);
+  return path16.join(directory, ".swarm", "skills", "proposals", `${slug}.md`);
 }
 function activePath(directory, slug) {
-  return path15.join(directory, ".opencode", "skills", "generated", slug, "SKILL.md");
+  return path16.join(directory, ".opencode", "skills", "generated", slug, "SKILL.md");
 }
 function activeRepoRelativePath(slug) {
   return `.opencode/skills/generated/${slug}/SKILL.md`;
@@ -37910,7 +38567,7 @@ function activeRepoRelativePath(slug) {
 async function selectCandidateEntries(directory, opts) {
   const swarm = await readKnowledge(resolveSwarmKnowledgePath(directory));
   const hivePath = resolveHiveKnowledgePath();
-  const hive = existsSync10(hivePath) ? await readKnowledge(hivePath) : [];
+  const hive = existsSync11(hivePath) ? await readKnowledge(hivePath) : [];
   const all = [...swarm, ...hive];
   return all.filter((e) => {
     if (e.status === "archived")
@@ -37993,10 +38650,12 @@ function clusterEntries(entries) {
 function uniqueStrings(arr) {
   return [...new Set(arr.filter((s) => typeof s === "string" && s.length > 0))];
 }
-function renderSkillMarkdown(cluster, mode = "active", generatedAt = new Date().toISOString()) {
+function renderSkillMarkdown(cluster, mode = "active", generatedAt = new Date().toISOString(), overrides) {
   const description = cluster.title.length > 200 ? `${cluster.title.slice(0, 197)}\u2026` : cluster.title;
   const ids = cluster.entries.map((e) => `  - ${e.id}`).join(`
 `);
+  const version3 = overrides?.version ?? 1;
+  const skillOrigin = overrides?.skillOrigin ?? "generated";
   const lines = [];
   lines.push("---");
   lines.push(`name: ${cluster.slug}`);
@@ -38008,6 +38667,8 @@ function renderSkillMarkdown(cluster, mode = "active", generatedAt = new Date().
   lines.push(`generated_at: ${generatedAt}`);
   lines.push(`confidence: ${cluster.avgConfidence.toFixed(2)}`);
   lines.push(`status: ${mode === "active" ? "active" : "draft"}`);
+  lines.push(`version: ${version3}`);
+  lines.push(`skill_origin: ${skillOrigin}`);
   lines.push("---");
   lines.push("");
   lines.push("<!-- generated by opencode-swarm skill-generator. Do not edit by hand; edits will be preserved on regeneration only with controlled update mode. -->");
@@ -38080,9 +38741,9 @@ function escapeMarkdown(s) {
   return s.replace(/[\r\n]+/g, " ").slice(0, 280);
 }
 async function atomicWrite(p, content) {
-  await mkdir4(path15.dirname(p), { recursive: true });
+  await mkdir5(path16.dirname(p), { recursive: true });
   const tmp = `${p}.tmp-${process.pid}-${Date.now()}`;
-  await writeFile3(tmp, content, "utf-8");
+  await writeFile4(tmp, content, "utf-8");
   await rename3(tmp, p);
 }
 async function generateSkills(req) {
@@ -38097,7 +38758,7 @@ async function generateSkills(req) {
     const idSet = new Set(req.sourceKnowledgeIds);
     const swarm = await readKnowledge(resolveSwarmKnowledgePath(req.directory));
     const hivePath = resolveHiveKnowledgePath();
-    const hive = existsSync10(hivePath) ? await readKnowledge(hivePath) : [];
+    const hive = existsSync11(hivePath) ? await readKnowledge(hivePath) : [];
     pool = [...swarm, ...hive].filter((e) => idSet.has(e.id) && e.status !== "archived");
   } else {
     pool = candidates;
@@ -38125,7 +38786,7 @@ async function generateSkills(req) {
       continue;
     }
     const targetPath = req.mode === "active" ? activePath(req.directory, cluster.slug) : proposalPath(req.directory, cluster.slug);
-    const repoRel = path15.relative(req.directory, targetPath).replace(/\\/g, "/");
+    const repoRel = path16.relative(req.directory, targetPath).replace(/\\/g, "/");
     if (!validateSkillPath(repoRel)) {
       result.skipped.push({
         slug: cluster.slug,
@@ -38134,8 +38795,8 @@ async function generateSkills(req) {
       continue;
     }
     let preserved = false;
-    if (req.mode === "active" && existsSync10(targetPath) && !req.force) {
-      const existing = await readFile3(targetPath, "utf-8");
+    if (req.mode === "active" && existsSync11(targetPath) && !req.force) {
+      const existing = await readFile4(targetPath, "utf-8");
       if (!existing.includes("generated by opencode-swarm skill-generator")) {
         preserved = true;
         result.skipped.push({
@@ -38179,7 +38840,7 @@ async function stampSourceEntries(directory, slug, ids) {
   if (touched)
     await rewriteKnowledge(swarmPath, swarm);
   const hivePath = resolveHiveKnowledgePath();
-  if (!existsSync10(hivePath))
+  if (!existsSync11(hivePath))
     return;
   const hive = await readKnowledge(hivePath);
   let touchedHive = false;
@@ -38239,6 +38900,16 @@ function parseDraftFrontmatter(content) {
       out.generatedAt = ga[1];
       continue;
     }
+    const vm = line.match(/^version:\s*(\d+)\s*$/);
+    if (vm) {
+      out.version = parseInt(vm[1], 10);
+      continue;
+    }
+    const so = line.match(/^skill_origin:\s*(\S+)\s*$/);
+    if (so) {
+      out.skillOrigin = so[1];
+      continue;
+    }
     if (/^generated_from_knowledge:\s*$/.test(line)) {
       inLegacyIdsList = true;
       continue;
@@ -38255,10 +38926,10 @@ async function listSkills(directory) {
     proposals: [],
     active: []
   };
-  const proposalsDir = path15.join(directory, ".swarm", "skills", "proposals");
-  const activeDir = path15.join(directory, ".opencode", "skills", "generated");
+  const proposalsDir = path16.join(directory, ".swarm", "skills", "proposals");
+  const activeDir = path16.join(directory, ".opencode", "skills", "generated");
   const fs9 = await import("fs/promises");
-  if (existsSync10(proposalsDir)) {
+  if (existsSync11(proposalsDir)) {
     const entries = await fs9.readdir(proposalsDir);
     for (const f of entries) {
       if (!f.endsWith(".md"))
@@ -38266,20 +38937,20 @@ async function listSkills(directory) {
       const slug = f.replace(/\.md$/, "");
       result.proposals.push({
         slug,
-        path: path15.join(proposalsDir, f)
+        path: path16.join(proposalsDir, f)
       });
     }
   }
-  if (existsSync10(activeDir)) {
+  if (existsSync11(activeDir)) {
     const entries = await fs9.readdir(activeDir, { withFileTypes: true });
     for (const e of entries) {
       if (!e.isDirectory())
         continue;
-      const retiredMarker = path15.join(activeDir, e.name, "retired.marker");
-      if (existsSync10(retiredMarker))
+      const retiredMarker = path16.join(activeDir, e.name, "retired.marker");
+      if (existsSync11(retiredMarker))
         continue;
-      const skillPath = path15.join(activeDir, e.name, "SKILL.md");
-      if (existsSync10(skillPath)) {
+      const skillPath = path16.join(activeDir, e.name, "SKILL.md");
+      if (existsSync11(skillPath)) {
         result.active.push({
           slug: e.name,
           path: skillPath
@@ -38294,13 +38965,155 @@ var init_skill_generator = __esm(() => {
   init_knowledge_store();
   init_knowledge_validator();
   init_logger();
+  init_skill_changelog();
   SLUG_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/;
 });
 
+// src/services/skill-improver-quota.ts
+import { existsSync as existsSync12 } from "fs";
+import { mkdir as mkdir6, readFile as readFile5, rename as rename4, writeFile as writeFile5 } from "fs/promises";
+import * as path17 from "path";
+async function acquireLock(dir) {
+  const acquire = import_proper_lockfile6.default.lock(dir, LOCK_RETRY_OPTS);
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      reject(new Error(`SKILL_IMPROVER_QUOTA_LOCK_TIMEOUT: failed to acquire lock on ${dir} within ${LOCK_ACQUIRE_TIMEOUT_MS}ms`));
+    }, LOCK_ACQUIRE_TIMEOUT_MS);
+  });
+  try {
+    const release = await Promise.race([acquire, timeout]);
+    return release;
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+  }
+}
+function resolveQuotaPath(directory) {
+  return path17.join(directory, ".swarm", "skill-improver-quota.json");
+}
+function todayKey(window, now = new Date) {
+  if (window === "utc") {
+    return now.toISOString().slice(0, 10);
+  }
+  const yr = now.getFullYear();
+  const m = String(now.getMonth() + 1).padStart(2, "0");
+  const d = String(now.getDate()).padStart(2, "0");
+  return `${yr}-${m}-${d}`;
+}
+async function readState(filePath) {
+  if (!existsSync12(filePath))
+    return null;
+  try {
+    const raw = await readFile5(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.date !== "string" || typeof parsed.calls_used !== "number" || typeof parsed.max_calls !== "number" || parsed.window !== "utc" && parsed.window !== "local") {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function writeState(filePath, state) {
+  await mkdir6(path17.dirname(filePath), { recursive: true });
+  const tmp = `${filePath}.tmp-${process.pid}`;
+  await writeFile5(tmp, JSON.stringify(state, null, 2), "utf-8");
+  await rename4(tmp, filePath);
+}
+async function getQuotaState(directory, opts) {
+  const filePath = resolveQuotaPath(directory);
+  const today = todayKey(opts.window, opts.now);
+  const existing = await readState(filePath);
+  if (!existing || existing.date !== today || existing.window !== opts.window) {
+    const fresh = {
+      date: today,
+      calls_used: 0,
+      max_calls: opts.maxCalls,
+      window: opts.window
+    };
+    await writeState(filePath, fresh);
+    return fresh;
+  }
+  return { ...existing, max_calls: opts.maxCalls };
+}
+async function reserveQuota(directory, opts) {
+  const filePath = resolveQuotaPath(directory);
+  await mkdir6(path17.dirname(filePath), { recursive: true });
+  let release = null;
+  try {
+    release = await acquireLock(path17.dirname(filePath));
+    const state = await getQuotaState(directory, opts);
+    if (state.calls_used + opts.nCalls > opts.maxCalls) {
+      return {
+        allowed: false,
+        state,
+        reason: `daily quota exhausted: used=${state.calls_used} requested=${opts.nCalls} max=${opts.maxCalls}`
+      };
+    }
+    const next = {
+      ...state,
+      calls_used: state.calls_used + opts.nCalls,
+      max_calls: opts.maxCalls,
+      last_run_at: (opts.now ?? new Date).toISOString()
+    };
+    await writeState(filePath, next);
+    return { allowed: true, state: next };
+  } finally {
+    if (release) {
+      try {
+        await release();
+      } catch {}
+    }
+  }
+}
+async function releaseQuota(directory, opts) {
+  const filePath = resolveQuotaPath(directory);
+  await mkdir6(path17.dirname(filePath), { recursive: true });
+  let release = null;
+  try {
+    release = await acquireLock(path17.dirname(filePath));
+    const state = await getQuotaState(directory, opts);
+    const next = {
+      ...state,
+      calls_used: Math.max(0, state.calls_used - opts.nCalls),
+      max_calls: opts.maxCalls
+    };
+    await writeState(filePath, next);
+    return next;
+  } finally {
+    if (release) {
+      try {
+        await release();
+      } catch {}
+    }
+  }
+}
+var import_proper_lockfile6, LOCK_ACQUIRE_TIMEOUT_MS = 1e4, LOCK_RETRY_OPTS;
+var init_skill_improver_quota = __esm(() => {
+  import_proper_lockfile6 = __toESM(require_proper_lockfile(), 1);
+  LOCK_RETRY_OPTS = {
+    retries: {
+      retries: 30,
+      minTimeout: 50,
+      maxTimeout: 200,
+      factor: 1.5
+    },
+    stale: 5000
+  };
+});
+
+// src/services/skill-reviser.ts
+var init_skill_reviser = __esm(() => {
+  init_logger();
+  init_skill_changelog();
+  init_skill_improver_quota();
+});
+
 // src/hooks/skill-usage-log.ts
 import * as crypto3 from "crypto";
 import * as fs9 from "fs";
-import * as path16 from "path";
+import * as path18 from "path";
 function resolveLogPath(directory) {
   return validateSwarmPath(directory, "skill-usage.jsonl");
 }
@@ -38312,7 +39125,8 @@ function appendSkillUsageEntry(directory, entry) {
     timestamp,
     complianceVerdict,
     sessionID,
-    reviewerNotes
+    reviewerNotes,
+    skillVersion
   } = entry;
   if (!skillPath || typeof skillPath !== "string") {
     throw new Error("skillPath is required and must be a non-empty string");
@@ -38336,7 +39150,7 @@ function appendSkillUsageEntry(directory, entry) {
     throw new Error("sessionID is required and must be a non-empty string");
   }
   const resolved = validateSwarmPath(directory, "skill-usage.jsonl");
-  const dir = path16.dirname(resolved);
+  const dir = path18.dirname(resolved);
   if (!_internals12.existsSync(dir)) {
     _internals12.mkdirSync(dir, { recursive: true });
   }
@@ -38348,7 +39162,8 @@ function appendSkillUsageEntry(directory, entry) {
     timestamp,
     complianceVerdict,
     sessionID,
-    ...reviewerNotes !== undefined && { reviewerNotes }
+    ...reviewerNotes !== undefined && { reviewerNotes },
+    ...skillVersion !== undefined && { skillVersion }
   };
   _internals12.appendFileSync(resolved, `${JSON.stringify(fullEntry)}
 `, "utf-8");
@@ -38445,6 +39260,34 @@ function readSkillUsageEntriesTail(directory, filters, maxBytes = TAIL_BYTES_DEF
     return [];
   }
 }
+function computeComplianceByVersion(entries, skillPath) {
+  const map3 = new Map;
+  const normalizedTarget = skillPath.replace(/^file:/, "").replace(/\\/g, "/");
+  for (const e of entries) {
+    let p = e.skillPath;
+    if (p.startsWith("file:"))
+      p = p.slice(5);
+    const normalized = p.replace(/\\/g, "/");
+    if (normalized !== normalizedTarget && !normalizedTarget.endsWith(`/${normalized}`) && !normalized.endsWith(`/${normalizedTarget}`)) {
+      continue;
+    }
+    const version3 = e.skillVersion;
+    let stats = map3.get(version3);
+    if (!stats) {
+      stats = { compliant: 0, violation: 0, total: 0, rate: 0 };
+      map3.set(version3, stats);
+    }
+    stats.total += 1;
+    if (e.complianceVerdict === "compliant")
+      stats.compliant += 1;
+    if (e.complianceVerdict === "violation")
+      stats.violation += 1;
+  }
+  for (const stats of map3.values()) {
+    stats.rate = stats.total === 0 ? 0 : stats.compliant / stats.total;
+  }
+  return map3;
+}
 function pruneSkillUsageLog(directory, maxEntriesPerSkill = 500) {
   const resolved = resolveLogPath(directory);
   if (!_internals12.existsSync(resolved)) {
@@ -38477,8 +39320,8 @@ function pruneSkillUsageLog(directory, maxEntriesPerSkill = 500) {
   if (pruned === 0) {
     return { pruned: 0, remaining: allEntries.length };
   }
-  const dir = path16.dirname(resolved);
-  const tmpPath = path16.join(dir, `skill-usage-${Date.now()}.tmp`);
+  const dir = path18.dirname(resolved);
+  const tmpPath = path18.join(dir, `skill-usage-${Date.now()}.tmp`);
   const content = surviving.map((e) => JSON.stringify(e)).join(`
 `).concat(`
 `);
@@ -38505,9 +39348,9 @@ async function resolveSourceKnowledgeIds(directory, skillPath) {
     if (/\.\.[/\\]/.test(cleanPath)) {
       return [];
     }
-    const absolute = path16.normalize(path16.isAbsolute(cleanPath) ? cleanPath : path16.resolve(directory, cleanPath));
-    const baseDir = path16.normalize(path16.resolve(directory));
-    const isContained = process.platform === "win32" ? absolute.toLowerCase().startsWith((baseDir + path16.sep).toLowerCase()) : absolute.startsWith(baseDir + path16.sep);
+    const absolute = path18.normalize(path18.isAbsolute(cleanPath) ? cleanPath : path18.resolve(directory, cleanPath));
+    const baseDir = path18.normalize(path18.resolve(directory));
+    const isContained = process.platform === "win32" ? absolute.toLowerCase().startsWith((baseDir + path18.sep).toLowerCase()) : absolute.startsWith(baseDir + path18.sep);
     if (!isContained) {
       return [];
     }
@@ -38626,7 +39469,8 @@ var init_skill_usage_log = __esm(() => {
     pruneSkillUsageLog,
     resolveSourceKnowledgeIds,
     applySkillUsageFeedback,
-    parseGeneratedFromKnowledge
+    parseGeneratedFromKnowledge,
+    computeComplianceByVersion
   };
   TAIL_BYTES_DEFAULT = 64 * 1024;
   MAX_TAIL_BYTES = TAIL_BYTES_DEFAULT;
@@ -38638,7 +39482,9 @@ var init_curator = __esm(() => {
   init_event_bus();
   init_schema();
   init_manager();
+  init_learning_metrics();
   init_skill_generator();
+  init_skill_reviser();
   init_state();
   init_bun_compat();
   init_logger();
@@ -38649,7 +39495,7 @@ var init_curator = __esm(() => {
 });
 
 // src/hooks/hive-promoter.ts
-import path17 from "path";
+import path19 from "path";
 function carryActionableFields(source) {
   const out = {};
   if (source.triggers?.length)
@@ -38845,7 +39691,7 @@ async function promoteToHive(directory, lesson, category) {
     schema_version: 1,
     created_at: new Date().toISOString(),
     updated_at: new Date().toISOString(),
-    source_project: path17.basename(directory) || "unknown",
+    source_project: path19.basename(directory) || "unknown",
     encounter_score: 1
   };
   await appendKnowledge(resolveHiveKnowledgePath(), newHiveEntry);
@@ -38901,150 +39747,16 @@ var init_hive_promoter = __esm(() => {
   init_utils2();
 });
 
-// src/services/skill-improver-quota.ts
-import { existsSync as existsSync12 } from "fs";
-import { mkdir as mkdir5, readFile as readFile4, rename as rename4, writeFile as writeFile4 } from "fs/promises";
-import * as path18 from "path";
-async function acquireLock(dir) {
-  const acquire = import_proper_lockfile5.default.lock(dir, LOCK_RETRY_OPTS);
-  let timer;
-  const timeout = new Promise((_, reject) => {
-    timer = setTimeout(() => {
-      reject(new Error(`SKILL_IMPROVER_QUOTA_LOCK_TIMEOUT: failed to acquire lock on ${dir} within ${LOCK_ACQUIRE_TIMEOUT_MS}ms`));
-    }, LOCK_ACQUIRE_TIMEOUT_MS);
-  });
-  try {
-    const release = await Promise.race([acquire, timeout]);
-    return release;
-  } finally {
-    if (timer)
-      clearTimeout(timer);
-  }
-}
-function resolveQuotaPath(directory) {
-  return path18.join(directory, ".swarm", "skill-improver-quota.json");
-}
-function todayKey(window, now = new Date) {
-  if (window === "utc") {
-    return now.toISOString().slice(0, 10);
-  }
-  const yr = now.getFullYear();
-  const m = String(now.getMonth() + 1).padStart(2, "0");
-  const d = String(now.getDate()).padStart(2, "0");
-  return `${yr}-${m}-${d}`;
-}
-async function readState(filePath) {
-  if (!existsSync12(filePath))
-    return null;
-  try {
-    const raw = await readFile4(filePath, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (typeof parsed.date !== "string" || typeof parsed.calls_used !== "number" || typeof parsed.max_calls !== "number" || parsed.window !== "utc" && parsed.window !== "local") {
-      return null;
-    }
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-async function writeState(filePath, state) {
-  await mkdir5(path18.dirname(filePath), { recursive: true });
-  const tmp = `${filePath}.tmp-${process.pid}`;
-  await writeFile4(tmp, JSON.stringify(state, null, 2), "utf-8");
-  await rename4(tmp, filePath);
-}
-async function getQuotaState(directory, opts) {
-  const filePath = resolveQuotaPath(directory);
-  const today = todayKey(opts.window, opts.now);
-  const existing = await readState(filePath);
-  if (!existing || existing.date !== today || existing.window !== opts.window) {
-    const fresh = {
-      date: today,
-      calls_used: 0,
-      max_calls: opts.maxCalls,
-      window: opts.window
-    };
-    await writeState(filePath, fresh);
-    return fresh;
-  }
-  return { ...existing, max_calls: opts.maxCalls };
-}
-async function reserveQuota(directory, opts) {
-  const filePath = resolveQuotaPath(directory);
-  await mkdir5(path18.dirname(filePath), { recursive: true });
-  let release = null;
-  try {
-    release = await acquireLock(path18.dirname(filePath));
-    const state = await getQuotaState(directory, opts);
-    if (state.calls_used + opts.nCalls > opts.maxCalls) {
-      return {
-        allowed: false,
-        state,
-        reason: `daily quota exhausted: used=${state.calls_used} requested=${opts.nCalls} max=${opts.maxCalls}`
-      };
-    }
-    const next = {
-      ...state,
-      calls_used: state.calls_used + opts.nCalls,
-      max_calls: opts.maxCalls,
-      last_run_at: (opts.now ?? new Date).toISOString()
-    };
-    await writeState(filePath, next);
-    return { allowed: true, state: next };
-  } finally {
-    if (release) {
-      try {
-        await release();
-      } catch {}
-    }
-  }
-}
-async function releaseQuota(directory, opts) {
-  const filePath = resolveQuotaPath(directory);
-  await mkdir5(path18.dirname(filePath), { recursive: true });
-  let release = null;
-  try {
-    release = await acquireLock(path18.dirname(filePath));
-    const state = await getQuotaState(directory, opts);
-    const next = {
-      ...state,
-      calls_used: Math.max(0, state.calls_used - opts.nCalls),
-      max_calls: opts.maxCalls
-    };
-    await writeState(filePath, next);
-    return next;
-  } finally {
-    if (release) {
-      try {
-        await release();
-      } catch {}
-    }
-  }
-}
-var import_proper_lockfile5, LOCK_ACQUIRE_TIMEOUT_MS = 1e4, LOCK_RETRY_OPTS;
-var init_skill_improver_quota = __esm(() => {
-  import_proper_lockfile5 = __toESM(require_proper_lockfile(), 1);
-  LOCK_RETRY_OPTS = {
-    retries: {
-      retries: 30,
-      minTimeout: 50,
-      maxTimeout: 200,
-      factor: 1.5
-    },
-    stale: 5000
-  };
-});
-
 // src/services/synonym-map.ts
 import {
-  mkdir as mkdir6,
-  readFile as readFile5,
+  mkdir as mkdir7,
+  readFile as readFile6,
   rename as rename5,
   stat as stat2,
   unlink as unlink2,
-  writeFile as writeFile5
+  writeFile as writeFile6
 } from "fs/promises";
-import * as path19 from "path";
+import * as path20 from "path";
 function emptySynonymMap() {
   return { version: 1, cursor: 0, pairs: {} };
 }
@@ -39186,17 +39898,17 @@ async function readSynonymMap(directory, maxPairs = DEFAULT_MAX_PAIRS) {
     const st = await stat2(filePath);
     if (st.size > ceiling)
       return emptySynonymMap();
-    const raw = await readFile5(filePath, "utf-8");
+    const raw = await readFile6(filePath, "utf-8");
     return coerceSynonymMap(JSON.parse(raw), maxPairs);
   } catch {
     return emptySynonymMap();
   }
 }
 async function writeSynonymMapAtomic(filePath, map3) {
-  await mkdir6(path19.dirname(filePath), { recursive: true });
+  await mkdir7(path20.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
   try {
-    await writeFile5(tmp, JSON.stringify(map3, null, 2), "utf-8");
+    await writeFile6(tmp, JSON.stringify(map3, null, 2), "utf-8");
     await rename5(tmp, filePath);
   } finally {
     try {
@@ -39206,11 +39918,11 @@ async function writeSynonymMapAtomic(filePath, map3) {
 }
 async function rebuildSynonymMap(directory, entries, maxPairs = DEFAULT_MAX_PAIRS) {
   const filePath = resolveSynonymMapPath(directory);
-  const dir = path19.dirname(filePath);
-  await mkdir6(dir, { recursive: true });
+  const dir = path20.dirname(filePath);
+  await mkdir7(dir, { recursive: true });
   let release = null;
   try {
-    release = await import_proper_lockfile6.default.lock(dir, {
+    release = await import_proper_lockfile7.default.lock(dir, {
       retries: { retries: 5, minTimeout: 100, maxTimeout: 500 },
       stale: 5000
     });
@@ -39225,217 +39937,14 @@ async function rebuildSynonymMap(directory, entries, maxPairs = DEFAULT_MAX_PAIR
     }
   }
 }
-var import_proper_lockfile6, SYNONYM_MAP_FILENAME = "synonym-map.json", MAX_TOKEN_LENGTH = 64, DEFAULT_MAX_PAIRS = 500, PAIR_SEP, APPROX_BYTES_PER_PAIR = 512, MIN_READ_CEILING_BYTES;
+var import_proper_lockfile7, SYNONYM_MAP_FILENAME = "synonym-map.json", MAX_TOKEN_LENGTH = 64, DEFAULT_MAX_PAIRS = 500, PAIR_SEP, APPROX_BYTES_PER_PAIR = 512, MIN_READ_CEILING_BYTES;
 var init_synonym_map = __esm(() => {
   init_utils2();
-  import_proper_lockfile6 = __toESM(require_proper_lockfile(), 1);
+  import_proper_lockfile7 = __toESM(require_proper_lockfile(), 1);
   PAIR_SEP = String.fromCharCode(0);
   MIN_READ_CEILING_BYTES = 64 * 1024;
 });
 
-// src/hooks/knowledge-events.ts
-import { existsSync as existsSync13 } from "fs";
-import { appendFile as appendFile4, mkdir as mkdir7, readFile as readFile6, writeFile as writeFile6 } from "fs/promises";
-import * as path20 from "path";
-function resolveKnowledgeEventsPath(directory) {
-  return path20.join(directory, ".swarm", "knowledge-events.jsonl");
-}
-function resolveLegacyApplicationLogPath(directory) {
-  return path20.join(directory, ".swarm", "knowledge-application.jsonl");
-}
-async function readKnowledgeEvents(directory) {
-  const filePath = resolveKnowledgeEventsPath(directory);
-  if (!existsSync13(filePath))
-    return [];
-  const content = await readFile6(filePath, "utf-8");
-  const out = [];
-  for (const line of content.split(`
-`)) {
-    const trimmed = line.trim();
-    if (!trimmed)
-      continue;
-    try {
-      out.push(JSON.parse(trimmed));
-    } catch {
-      warn(`[knowledge-events] Skipping corrupted JSONL line in ${filePath}: ${trimmed.slice(0, 80)}`);
-    }
-  }
-  return out;
-}
-async function readLegacyApplicationRecords(directory) {
-  const filePath = resolveLegacyApplicationLogPath(directory);
-  if (!existsSync13(filePath))
-    return [];
-  const content = await readFile6(filePath, "utf-8");
-  const out = [];
-  for (const line of content.split(`
-`)) {
-    const trimmed = line.trim();
-    if (!trimmed)
-      continue;
-    try {
-      out.push(JSON.parse(trimmed));
-    } catch {
-      warn(`[knowledge-events] Skipping corrupted JSONL line in ${filePath}: ${trimmed.slice(0, 80)}`);
-    }
-  }
-  return out;
-}
-function emptyRollup() {
-  return {
-    shown_count: 0,
-    acknowledged_count: 0,
-    applied_explicit_count: 0,
-    ignored_count: 0,
-    violated_count: 0,
-    contradicted_count: 0,
-    n_a_count: 0,
-    succeeded_after_shown_count: 0,
-    failed_after_shown_count: 0,
-    partial_after_shown_count: 0,
-    violation_timestamps: []
-  };
-}
-function get(map3, id) {
-  let r = map3.get(id);
-  if (!r) {
-    r = emptyRollup();
-    map3.set(id, r);
-  }
-  return r;
-}
-function maxIso(current, candidate) {
-  if (!current)
-    return candidate;
-  return candidate > current ? candidate : current;
-}
-function recomputeCounters(events, legacyRecords = []) {
-  const map3 = new Map;
-  const retrievedIds = new Set;
-  for (const e of events) {
-    switch (e.type) {
-      case "retrieved": {
-        for (const id of e.result_ids) {
-          retrievedIds.add(id);
-          get(map3, id).shown_count += 1;
-        }
-        break;
-      }
-      case "acknowledged": {
-        const r = get(map3, e.knowledge_id);
-        r.acknowledged_count += 1;
-        r.last_acknowledged_at = maxIso(r.last_acknowledged_at, e.timestamp);
-        break;
-      }
-      case "applied": {
-        const r = get(map3, e.knowledge_id);
-        r.applied_explicit_count += 1;
-        r.last_applied_at = maxIso(r.last_applied_at, e.timestamp);
-        break;
-      }
-      case "ignored":
-        get(map3, e.knowledge_id).ignored_count += 1;
-        break;
-      case "violated": {
-        const r = get(map3, e.knowledge_id);
-        r.violated_count += 1;
-        r.violation_timestamps.push(e.timestamp);
-        break;
-      }
-      case "contradicted":
-        get(map3, e.knowledge_id).contradicted_count += 1;
-        break;
-      case "n_a":
-        get(map3, e.knowledge_id).n_a_count += 1;
-        break;
-      case "outcome": {
-        if (!e.knowledge_id)
-          break;
-        const r = get(map3, e.knowledge_id);
-        if (e.outcome === "success")
-          r.succeeded_after_shown_count += 1;
-        else if (e.outcome === "failure")
-          r.failed_after_shown_count += 1;
-        else if (e.outcome === "partial")
-          r.partial_after_shown_count += 1;
-        break;
-      }
-    }
-  }
-  for (const rec of legacyRecords) {
-    const r = get(map3, rec.knowledgeId);
-    switch (rec.result) {
-      case "shown":
-        if (!retrievedIds.has(rec.knowledgeId))
-          r.shown_count += 1;
-        break;
-      case "acknowledged":
-        r.acknowledged_count += 1;
-        r.last_acknowledged_at = maxIso(r.last_acknowledged_at, rec.timestamp);
-        break;
-      case "applied":
-        r.applied_explicit_count += 1;
-        r.last_applied_at = maxIso(r.last_applied_at, rec.timestamp);
-        break;
-      case "ignored":
-        r.ignored_count += 1;
-        break;
-      case "violated":
-        r.violated_count += 1;
-        r.violation_timestamps.push(rec.timestamp);
-        break;
-    }
-  }
-  for (const r of map3.values()) {
-    if (r.violation_timestamps.length > 1) {
-      r.violation_timestamps.sort((a, b) => a < b ? 1 : a > b ? -1 : 0);
-    }
-    if (r.violation_timestamps.length > MAX_VIOLATION_TIMESTAMPS) {
-      r.violation_timestamps = r.violation_timestamps.slice(0, MAX_VIOLATION_TIMESTAMPS);
-    }
-  }
-  return map3;
-}
-async function readKnowledgeCounterRollups(directory) {
-  try {
-    const [events, legacyRecords] = await Promise.all([
-      readKnowledgeEvents(directory),
-      readLegacyApplicationRecords(directory)
-    ]);
-    return recomputeCounters(events, legacyRecords);
-  } catch (err) {
-    warn(`[knowledge-events] readKnowledgeCounterRollups failed: ${err instanceof Error ? err.message : String(err)}`);
-    return new Map;
-  }
-}
-function effectiveRetrievalOutcomes(stored, rollup) {
-  const base = stored ?? {
-    applied_count: 0,
-    succeeded_after_count: 0,
-    failed_after_count: 0
-  };
-  if (!rollup)
-    return base;
-  return {
-    ...base,
-    ...rollup
-  };
-}
-var import_proper_lockfile7, RECEIPT_EVENT_TYPES, MAX_VIOLATION_TIMESTAMPS = 10;
-var init_knowledge_events = __esm(() => {
-  init_logger();
-  import_proper_lockfile7 = __toESM(require_proper_lockfile(), 1);
-  RECEIPT_EVENT_TYPES = new Set([
-    "acknowledged",
-    "applied",
-    "ignored",
-    "contradicted",
-    "violated",
-    "n_a",
-    "override"
-  ]);
-});
-
 // src/hooks/skill-scoring.ts
 import * as fs10 from "fs";
 import * as path21 from "path";
@@ -44221,7 +44730,7 @@ async function computeKnowledgeDebug(directory) {
   try {
     const events = await readKnowledgeEvents(directory);
     eventCount = events.length;
-    const cutoff = Date.now() - SEVEN_DAYS_MS;
+    const cutoff = Date.now() - SEVEN_DAYS_MS2;
     for (const ev of events) {
       eventsByType[ev.type] = (eventsByType[ev.type] ?? 0) + 1;
       if (ev.type !== "retrieved")
@@ -44331,7 +44840,7 @@ async function checkKnowledgeHealth(directory) {
   }
   return { name: "Knowledge health", status: "\u2705", detail: summary };
 }
-var version3, SEVEN_DAYS_MS, UNACTIONABLE_BACKLOG_WARN = 100, INSIGHT_BACKLOG_WARN = 50;
+var version3, SEVEN_DAYS_MS2, UNACTIONABLE_BACKLOG_WARN = 100, INSIGHT_BACKLOG_WARN = 50;
 var init_knowledge_diagnostics = __esm(() => {
   init_package();
   init_knowledge_events();
@@ -44341,7 +44850,7 @@ var init_knowledge_diagnostics = __esm(() => {
   init_synonym_map();
   init_version_check();
   ({ version: version3 } = package_default);
-  SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
+  SEVEN_DAYS_MS2 = 7 * 24 * 60 * 60 * 1000;
 });
 
 // src/services/diagnose-service.ts
@@ -47958,7 +48467,7 @@ function formatEvidenceEntry(index, entry) {
     type: entry.type,
     verdict: entry.verdict,
     verdictIcon: getVerdictEmoji(entry.verdict),
-    agent: entry.agent,
+    agent: entry.agent ?? "",
     summary: entry.summary,
     timestamp: entry.timestamp,
     details
@@ -49439,6 +49948,7 @@ var KNOWLEDGE_SCHEMA_VERSION = 2;
 import { randomUUID as randomUUID3 } from "crypto";
 import { existsSync as existsSync25, readFileSync as readFileSync15 } from "fs";
 import { mkdir as mkdir12, readFile as readFile12, writeFile as writeFile10 } from "fs/promises";
+import * as os8 from "os";
 import * as path37 from "path";
 async function migrateKnowledgeToExternal(_directory, _config) {
   return {
@@ -49550,6 +50060,123 @@ async function migrateContextToKnowledge(directory, config3) {
     entriesTotal: rawEntries.length
   };
 }
+async function migrateHiveKnowledgeLegacy(config3) {
+  const legacyHivePath = _internals23.resolveLegacyHiveKnowledgePath();
+  const canonicalHivePath = resolveHiveKnowledgePath();
+  const sentinelPath = path37.join(path37.dirname(canonicalHivePath), ".hive-knowledge-migrated");
+  if (existsSync25(sentinelPath)) {
+    return {
+      migrated: false,
+      entriesMigrated: 0,
+      entriesDropped: 0,
+      entriesTotal: 0,
+      skippedReason: "sentinel-exists"
+    };
+  }
+  if (!existsSync25(legacyHivePath)) {
+    return {
+      migrated: false,
+      entriesMigrated: 0,
+      entriesDropped: 0,
+      entriesTotal: 0,
+      skippedReason: "no-context-file"
+    };
+  }
+  const legacyEntries = await readKnowledge(legacyHivePath);
+  if (legacyEntries.length === 0) {
+    await _internals23.writeSentinel(sentinelPath, 0, 0);
+    return {
+      migrated: true,
+      entriesMigrated: 0,
+      entriesDropped: 0,
+      entriesTotal: 0
+    };
+  }
+  const existingHiveEntries = await readKnowledge(canonicalHivePath);
+  let migrated = 0;
+  let dropped = 0;
+  const entryErrors = [];
+  for (const legacyEntry of legacyEntries) {
+    try {
+      const lesson = legacyEntry.lesson;
+      if (!lesson || typeof lesson !== "string" || lesson.length < 15) {
+        dropped++;
+        continue;
+      }
+      const dup = findNearDuplicate(lesson, existingHiveEntries, config3.dedup_threshold ?? 0.6);
+      if (dup) {
+        dropped++;
+        continue;
+      }
+      const category = legacyEntry.category || "process";
+      const validationResult = validateLesson(lesson, existingHiveEntries.map((e) => e.lesson), {
+        category,
+        scope: "global",
+        confidence: 0.3
+      });
+      if (!validationResult.valid) {
+        const errorMsg = `Validation failed for legacy entry: ${validationResult.reason}`;
+        entryErrors.push(errorMsg);
+        warn(`[knowledge-migrator] ${errorMsg}`);
+        dropped++;
+        continue;
+      }
+      const confidence = legacyEntry.confidence ?? 0.8;
+      const scopeTag = legacyEntry.scope_tag || "global";
+      const legacyId = legacyEntry.id;
+      const existingIds = new Set(existingHiveEntries.map((e) => e.id));
+      const resolvedId = legacyId && existingIds.has(legacyId) ? randomUUID3() : legacyId || randomUUID3();
+      if (legacyId && existingIds.has(legacyId)) {
+        warn(`[knowledge-migrator] Legacy entry ID collision for "${legacyId}", generating new UUID`);
+      }
+      const newHiveEntry = {
+        id: resolvedId,
+        tier: "hive",
+        lesson: _internals23.truncateLesson(lesson),
+        category,
+        tags: ["migration:legacy-hive"],
+        scope: scopeTag,
+        confidence: Math.min(Math.max(confidence, 0), 1),
+        status: "established",
+        confirmed_by: [],
+        retrieval_outcomes: {
+          applied_count: 0,
+          succeeded_after_count: 0,
+          failed_after_count: 0
+        },
+        schema_version: KNOWLEDGE_SCHEMA_VERSION,
+        created_at: legacyEntry.created_at || new Date().toISOString(),
+        updated_at: legacyEntry.updated_at || new Date().toISOString(),
+        source_project: "legacy-promotion",
+        encounter_score: 1
+      };
+      try {
+        await _internals23.appendKnowledge(canonicalHivePath, newHiveEntry);
+        existingHiveEntries.push(newHiveEntry);
+        migrated++;
+      } catch (appendError) {
+        const errorMsg = `Failed to append entry: ${appendError instanceof Error ? appendError.message : String(appendError)}`;
+        entryErrors.push(errorMsg);
+        warn(`[knowledge-migrator] ${errorMsg}`);
+        dropped++;
+      }
+    } catch (entryError) {
+      const errorMsg = `Unexpected error processing legacy entry: ${entryError instanceof Error ? entryError.message : String(entryError)}`;
+      entryErrors.push(errorMsg);
+      warn(`[knowledge-migrator] ${errorMsg}`);
+      dropped++;
+    }
+  }
+  await _internals23.writeSentinel(sentinelPath, migrated, dropped);
+  log(`[knowledge-migrator] Migrated ${migrated} legacy hive entries, dropped ${dropped}`);
+  return {
+    migrated: true,
+    entriesMigrated: migrated,
+    entriesDropped: dropped,
+    entriesTotal: legacyEntries.length,
+    ...entryErrors.length > 0 && { entryErrors }
+  };
+}
 function parseContextMd(content) {
   const sections = _internals23.splitIntoSections(content);
   const entries = [];
@@ -49641,7 +50268,7 @@ function inferCategoryFromText(text) {
     return "process";
   return "other";
 }
-function truncateLesson(text) {
+function truncateLesson2(text) {
   if (text.length <= 280)
     return text;
   return `${text.slice(0, 277)}...`;
@@ -49671,21 +50298,37 @@ async function writeSentinel(sentinelPath, migrated, dropped) {
   await mkdir12(path37.dirname(sentinelPath), { recursive: true });
   await writeFile10(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
 }
+function resolveLegacyHiveKnowledgePath() {
+  const platform = process.platform;
+  const home = process.env.HOME || os8.homedir();
+  let dataDir;
+  if (platform === "win32") {
+    dataDir = path37.join(process.env.LOCALAPPDATA || path37.join(home, "AppData", "Local"), "opencode-swarm", "Data");
+  } else if (platform === "darwin") {
+    dataDir = path37.join(home, "Library", "Application Support", "opencode-swarm");
+  } else {
+    dataDir = path37.join(process.env.XDG_DATA_HOME || path37.join(home, ".local", "share"), "opencode-swarm");
+  }
+  return path37.join(dataDir, "hive-knowledge.jsonl");
+}
 var _internals23;
 var init_knowledge_migrator = __esm(() => {
   init_logger();
   init_knowledge_store();
   init_knowledge_validator();
   _internals23 = {
+    appendKnowledge,
     migrateContextToKnowledge,
     migrateKnowledgeToExternal,
+    migrateHiveKnowledgeLegacy,
     parseContextMd,
     splitIntoSections,
     extractBullets,
     inferCategoryFromText,
-    truncateLesson,
+    truncateLesson: truncateLesson2,
     inferProjectName,
-    writeSentinel
+    writeSentinel,
+    resolveLegacyHiveKnowledgePath
   };
 });
 
@@ -49757,24 +50400,43 @@ async function handleKnowledgeRestoreCommand(directory, args) {
 }
 async function handleKnowledgeMigrateCommand(directory, args) {
   const targetDir = args[0] || directory;
+  const config3 = KnowledgeConfigSchema.parse({});
   try {
-    const result = await migrateContextToKnowledge(targetDir, KnowledgeConfigSchema.parse({}));
-    if (result.skippedReason) {
-      switch (result.skippedReason) {
+    const contextResult = await migrateContextToKnowledge(targetDir, config3);
+    const hiveResult = await migrateHiveKnowledgeLegacy(config3);
+    const messages = [];
+    if (contextResult.skippedReason) {
+      switch (contextResult.skippedReason) {
         case "sentinel-exists":
-          return "\u23ED Migration already completed for this project. Delete .swarm/.knowledge-migrated to re-run.";
+          messages.push("\u23ED Context migration already completed. Delete .swarm/.knowledge-migrated to re-run.");
+          break;
         case "no-context-file":
-          return "\u2139\uFE0F No .swarm/context.md found \u2014 nothing to migrate.";
+          messages.push("\u2139\uFE0F No .swarm/context.md found \u2014 nothing to migrate.");
+          break;
         case "empty-context":
-          return "\u2139\uFE0F .swarm/context.md is empty \u2014 nothing to migrate.";
-        default:
-          return "\u26A0\uFE0F Migration skipped for an unknown reason.";
+          messages.push("\u2139\uFE0F .swarm/context.md is empty \u2014 nothing to migrate.");
+          break;
+      }
+    } else {
+      messages.push(`\u2705 Context migration: ${contextResult.entriesMigrated} entries added, ${contextResult.entriesDropped} dropped`);
+    }
+    if (hiveResult.skippedReason) {
+      switch (hiveResult.skippedReason) {
+        case "sentinel-exists":
+          messages.push("\u23ED Hive legacy migration already completed. Delete the sentinel in the hive data dir to re-run.");
+          break;
+        case "no-context-file":
+          messages.push("\u2139\uFE0F No legacy hive-knowledge.jsonl found \u2014 nothing to migrate.");
+          break;
       }
+    } else if (hiveResult.migrated) {
+      messages.push(`\u2705 Hive legacy migration: ${hiveResult.entriesMigrated} entries added, ${hiveResult.entriesDropped} dropped`);
     }
-    return `\u2705 Migration complete: ${result.entriesMigrated} entries added, ${result.entriesDropped} dropped (validation/dedup), ${result.entriesTotal} total processed.`;
+    return messages.join(`
+`);
   } catch (error93) {
-    console.warn("[knowledge-command] migrateContextToKnowledge error:", error93 instanceof Error ? error93.message : String(error93));
-    return "\u274C Migration failed. Check .swarm/context.md is readable.";
+    console.warn("[knowledge-command] migration error:", error93 instanceof Error ? error93.message : String(error93));
+    return "\u274C Migration failed. Check that knowledge source files are readable.";
   }
 }
 async function handleKnowledgeListCommand(directory, _args) {
@@ -49811,6 +50473,34 @@ var init_knowledge = __esm(() => {
   init_knowledge_validator();
 });
 
+// src/commands/learning.ts
+async function handleLearningCommand(directory, args) {
+  try {
+    const jsonMode = args.includes("--json");
+    let currentPhase;
+    const phaseIdx = args.indexOf("--phase");
+    if (phaseIdx !== -1 && phaseIdx + 1 < args.length) {
+      const parsed = Number(args[phaseIdx + 1]);
+      if (Number.isFinite(parsed)) {
+        currentPhase = parsed;
+      }
+    }
+    const metrics = await computeLearningMetrics(directory, { currentPhase });
+    if (jsonMode) {
+      return `[LEARNING_JSON]
+${JSON.stringify(formatLearningJSON(metrics), null, 2)}
+[/LEARNING_JSON]`;
+    }
+    return formatLearningMarkdown(metrics);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return `Error computing learning metrics: ${message}. Run /swarm diagnose to check .swarm/ health.`;
+  }
+}
+var init_learning = __esm(() => {
+  init_learning_metrics();
+});
+
 // src/memory/config.ts
 function resolveMemoryConfig(input) {
   return {
@@ -52299,7 +52989,7 @@ var init_gateway = __esm(() => {
 
 // src/memory/evaluation.ts
 import * as fs16 from "fs/promises";
-import * as os8 from "os";
+import * as os9 from "os";
 import * as path41 from "path";
 async function evaluateMemoryRecallFixtures(options) {
   const fixtureDirectory = path41.resolve(options.fixtureDirectory);
@@ -52311,7 +53001,7 @@ async function evaluateMemoryRecallFixtures(options) {
   for (const fixture of fixtures) {
     const materialized = materializeFixture(fixture);
     for (const providerName of providers) {
-      const tempRoot = await fs16.realpath(await fs16.mkdtemp(path41.join(os8.tmpdir(), "swarm-memory-eval-")));
+      const tempRoot = await fs16.realpath(await fs16.mkdtemp(path41.join(os9.tmpdir(), "swarm-memory-eval-")));
       const provider = createEvaluationProvider(providerName, tempRoot);
       try {
         await provider.initialize?.();
@@ -61127,38 +61817,6 @@ async function handleSpecifyCommand(_directory, args) {
   return "[MODE: SPECIFY] Please enter MODE: SPECIFY and generate a spec for this project.";
 }
 
-// src/hooks/knowledge-escalator.ts
-async function readRecentEscalations(directory, windowDays = ESCALATION_DISPLAY_WINDOW_DAYS, now = new Date) {
-  try {
-    const cutoff = now.getTime() - windowDays * 24 * 60 * 60 * 1000;
-    const events = await readKnowledgeEvents(directory);
-    const out = [];
-    for (const e of events) {
-      if (e.type !== "escalation")
-        continue;
-      const t = Date.parse(e.timestamp);
-      if (Number.isNaN(t) || t < cutoff)
-        continue;
-      out.push({
-        entry_id: e.entry_id,
-        from: e.from,
-        to: e.to,
-        reason: e.reason,
-        at: e.timestamp
-      });
-    }
-    out.sort((a, b) => a.at < b.at ? 1 : a.at > b.at ? -1 : 0);
-    return out;
-  } catch {
-    return [];
-  }
-}
-var ESCALATION_DISPLAY_WINDOW_DAYS = 7;
-var init_knowledge_escalator = __esm(() => {
-  init_knowledge_events();
-  init_knowledge_store();
-});
-
 // src/turbo/lean/state.ts
 import * as fs34 from "fs";
 import * as path61 from "path";
@@ -62304,6 +62962,7 @@ __export(exports_commands, {
   handleMemoryImportCommand: () => handleMemoryImportCommand,
   handleMemoryExportCommand: () => handleMemoryExportCommand,
   handleMemoryCommand: () => handleMemoryCommand,
+  handleLearningCommand: () => handleLearningCommand,
   handleKnowledgeRestoreCommand: () => handleKnowledgeRestoreCommand,
   handleKnowledgeQuarantineCommand: () => handleKnowledgeQuarantineCommand,
   handleKnowledgeMigrateCommand: () => handleKnowledgeMigrateCommand,
@@ -62603,6 +63262,7 @@ var init_commands = __esm(() => {
   init_handoff();
   init_history();
   init_knowledge();
+  init_learning();
   init_memory2();
   init_plan();
   init_preflight();
@@ -62836,6 +63496,7 @@ var init_registry = __esm(() => {
   init_history();
   init_issue();
   init_knowledge();
+  init_learning();
   init_memory2();
   init_plan();
   init_pr_feedback();
@@ -62956,6 +63617,13 @@ var init_registry = __esm(() => {
       args: "--cumulative, --ci-gate",
       category: "diagnostics"
     },
+    learning: {
+      handler: (ctx) => handleLearningCommand(ctx.directory, ctx.args),
+      description: "Show learning metrics and violation trends",
+      args: "--json, --phase <N>",
+      details: "Computes aggregate learning metrics from knowledge events: violation-rate trends, directive application rates, escalation frequency, per-entry ROI, and never-applied entries. Surfaces a learning summary for the curator digest.",
+      category: "diagnostics"
+    },
     export: {
       handler: (ctx) => handleExportCommand(ctx.directory, ctx.args),
       description: "Export plan and context as JSON",
@@ -63465,7 +64133,7 @@ init_registry();
 init_cache_paths();
 init_constants();
 import * as fs36 from "fs";
-import * as os9 from "os";
+import * as os10 from "os";
 import * as path64 from "path";
 var { version: version5 } = package_default;
 var CONFIG_DIR = getPluginConfigDir();
@@ -63476,7 +64144,7 @@ var OPENCODE_PLUGIN_CACHE_PATHS = getPluginCachePaths();
 var OPENCODE_PLUGIN_LOCK_FILE_PATHS = getPluginLockFilePaths();
 function isSafeCachePath(p) {
   const resolved = path64.resolve(p);
-  const home = path64.resolve(os9.homedir());
+  const home = path64.resolve(os10.homedir());
   if (resolved === "/" || resolved === home || resolved.length <= home.length) {
     return false;
   }
@@ -63500,7 +64168,7 @@ function isSafeCachePath(p) {
 }
 function isSafeLockFilePath(p) {
   const resolved = path64.resolve(p);
-  const home = path64.resolve(os9.homedir());
+  const home = path64.resolve(os10.homedir());
   if (resolved === "/" || resolved === home || resolved.length <= home.length) {
     return false;
   }