bilmem 0.1.0

package/dist/stats/index.js

@@ -0,0 +1,1373 @@
+// src/storage/canonical.ts
+import * as fs3 from "fs/promises";
+import * as path3 from "path";
+
+// src/rules/loader.ts
+import YAML from "yaml";
+import * as fs from "fs/promises";
+import * as path from "path";
+function validateRuleDefinition(rule, index = 0) {
+  const errors = [];
+  if (!rule || typeof rule !== "object") {
+    errors.push(`Rule at index ${index} must be an object.`);
+    return errors;
+  }
+  const r = rule;
+  if (!r.id || typeof r.id !== "string" || !r.id.trim()) {
+    errors.push(`Rule at index ${index} requires a non-empty string 'id'.`);
+  }
+  if (!r.statement || typeof r.statement !== "string" || !r.statement.trim()) {
+    errors.push(`Rule '${r.id || index}' requires a non-empty string 'statement'.`);
+  }
+  if (r.type) {
+    const validTypes = [
+      "rule",
+      "convention",
+      "decision",
+      "lesson",
+      "architecture",
+      "fact"
+    ];
+    if (!validTypes.includes(r.type)) {
+      errors.push(`Rule '${r.id || index}' has invalid type '${r.type}'. Allowed: ${validTypes.join(", ")}.`);
+    }
+  }
+  if (r.confidence !== void 0) {
+    if (typeof r.confidence !== "number" || r.confidence < 0 || r.confidence > 1) {
+      errors.push(`Rule '${r.id || index}' confidence must be a number between 0.0 and 1.0.`);
+    }
+  }
+  if (r.positive !== void 0 && !Array.isArray(r.positive)) {
+    errors.push(`Rule '${r.id || index}' positive cues must be an array of strings.`);
+  }
+  if (r.negative !== void 0 && !Array.isArray(r.negative)) {
+    errors.push(`Rule '${r.id || index}' negative cues must be an array of strings.`);
+  }
+  return errors;
+}
+function validateRuleSet(data) {
+  const errors = [];
+  if (!data || typeof data !== "object") {
+    return { valid: false, errors: ["RuleSet content must be an object or an array of rules."] };
+  }
+  let rules = [];
+  if (Array.isArray(data)) {
+    rules = data;
+  } else if ("rules" in data && Array.isArray(data.rules)) {
+    rules = data.rules;
+  } else if ("id" in data && "statement" in data) {
+    rules = [data];
+  } else {
+    return { valid: false, errors: ['RuleSet must contain a "rules" array or be a list of rule definitions.'] };
+  }
+  if (rules.length === 0) {
+    errors.push("RuleSet contains no rules.");
+  }
+  rules.forEach((rule, idx) => {
+    errors.push(...validateRuleDefinition(rule, idx));
+  });
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function parseRuleSetYaml(content, sourcePath = "inline.yml") {
+  let parsed;
+  try {
+    parsed = YAML.parse(content);
+  } catch (err) {
+    throw new Error(`YAML syntax error in ${sourcePath}: ${err.message}`);
+  }
+  const validation = validateRuleSet(parsed);
+  if (!validation.valid) {
+    throw new Error(`Invalid RuleSet in ${sourcePath}:
+- ${validation.errors.join("\n- ")}`);
+  }
+  if (Array.isArray(parsed)) {
+    return {
+      name: path.basename(sourcePath, path.extname(sourcePath)),
+      rules: parsed
+    };
+  }
+  if ("id" in parsed && "statement" in parsed && !("rules" in parsed)) {
+    return {
+      name: parsed.id,
+      rules: [parsed]
+    };
+  }
+  const set = parsed;
+  return {
+    name: set.name ?? path.basename(sourcePath, path.extname(sourcePath)),
+    version: set.version ?? 1,
+    scope: set.scope ?? "project",
+    description: set.description,
+    rules: set.rules
+  };
+}
+function stringifyRuleSetYaml(ruleSet) {
+  const payload = {};
+  if (ruleSet.name) payload.name = ruleSet.name;
+  if (ruleSet.version !== void 0) payload.version = ruleSet.version;
+  if (ruleSet.scope) payload.scope = ruleSet.scope;
+  if (ruleSet.description) payload.description = ruleSet.description;
+  payload.rules = ruleSet.rules.map((r) => {
+    const ruleObj = {
+      id: r.id
+    };
+    if (r.name) ruleObj.name = r.name;
+    ruleObj.statement = r.statement;
+    if (r.type && r.type !== "rule") ruleObj.type = r.type;
+    if (r.confidence !== void 0 && r.confidence !== 0.95) ruleObj.confidence = r.confidence;
+    if (r.scope && r.scope !== "project") ruleObj.scope = r.scope;
+    if (r.positive && r.positive.length > 0) ruleObj.positive = r.positive;
+    if (r.negative && r.negative.length > 0) ruleObj.negative = r.negative;
+    if (r.tags && r.tags.length > 0) ruleObj.tags = r.tags;
+    if (r.when && Object.keys(r.when).length > 0) ruleObj.when = r.when;
+    if (r.details && Object.keys(r.details).length > 0) ruleObj.details = r.details;
+    return ruleObj;
+  });
+  return YAML.stringify(payload, { indent: 2, lineWidth: 100 });
+}
+async function loadRuleSetFile(filePath) {
+  const content = await fs.readFile(filePath, "utf-8");
+  return parseRuleSetYaml(content, filePath);
+}
+async function findRuleFiles(rootDir, storageRulesDir) {
+  const candidates = [];
+  const rulesDir = storageRulesDir || path.resolve(rootDir, ".bilmem", "rules");
+  try {
+    const entries = await fs.readdir(rulesDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && (entry.name.endsWith(".yml") || entry.name.endsWith(".yaml"))) {
+        candidates.push(path.join(rulesDir, entry.name));
+      }
+    }
+  } catch {
+  }
+  for (const name of ["rules.yml", "rules.yaml"]) {
+    const p = path.resolve(rootDir, ".bilmem", name);
+    try {
+      const st = await fs.stat(p);
+      if (st.isFile()) candidates.push(p);
+    } catch {
+    }
+  }
+  for (const name of ["bilmem.rules.yml", "bilmem.rules.yaml", "rules.yml", "rules.yaml"]) {
+    const p = path.resolve(rootDir, name);
+    try {
+      const st = await fs.stat(p);
+      if (st.isFile()) candidates.push(p);
+    } catch {
+    }
+  }
+  return Array.from(new Set(candidates));
+}
+
+// src/stats/events.ts
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+function getEventsFilePath(rootDir) {
+  return path2.join(rootDir, ".bilmem", "events.jsonl");
+}
+async function appendMetricEvent(rootDir, event) {
+  const filePath = getEventsFilePath(rootDir);
+  try {
+    await fs2.mkdir(path2.dirname(filePath), { recursive: true });
+    const line = JSON.stringify(event) + "\n";
+    await fs2.appendFile(filePath, line, "utf-8");
+  } catch {
+  }
+}
+async function readMetricEvents(rootDir, filter) {
+  const filePath = getEventsFilePath(rootDir);
+  let raw;
+  try {
+    raw = await fs2.readFile(filePath, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return [];
+    }
+    return [];
+  }
+  const lines = raw.split("\n");
+  const events = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (!parsed || typeof parsed !== "object" || typeof parsed.type !== "string") {
+        continue;
+      }
+      if (typeof parsed.timestamp !== "number") {
+        continue;
+      }
+      if (filter?.sinceTimestamp !== void 0 && parsed.timestamp < filter.sinceTimestamp) {
+        continue;
+      }
+      if (filter?.knowledgeId !== void 0) {
+        const kid = parsed.knowledgeId;
+        if (kid !== filter.knowledgeId) {
+          continue;
+        }
+      }
+      events.push(parsed);
+    } catch {
+      continue;
+    }
+  }
+  return events;
+}
+async function resetMetricEvents(rootDir) {
+  const filePath = getEventsFilePath(rootDir);
+  try {
+    await fs2.mkdir(path2.dirname(filePath), { recursive: true });
+    await fs2.writeFile(filePath, "", "utf-8");
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+}
+
+// src/storage/canonical.ts
+function sanitizeFileName(id) {
+  return encodeURIComponent(id).replace(/%/g, "_");
+}
+var Storage = class {
+  baseDir;
+  knowledgeDir;
+  evidenceDir;
+  observationDir;
+  unknownDir;
+  rulesDir;
+  configFile;
+  relationsFile;
+  outcomesFile;
+  metricsFile;
+  revisionsFile;
+  knowledgeJsonlFile;
+  evidenceJsonlFile;
+  observationJsonlFile;
+  unknownsJsonlFile;
+  receiptsDir;
+  receiptsJsonlFile;
+  eventsFile;
+  constructor(rootDir = process.cwd()) {
+    this.baseDir = path3.resolve(rootDir, ".bilmem");
+    this.knowledgeDir = path3.join(this.baseDir, "knowledge");
+    this.evidenceDir = path3.join(this.baseDir, "evidence");
+    this.observationDir = path3.join(this.baseDir, "observations");
+    this.unknownDir = path3.join(this.baseDir, "unknowns");
+    this.rulesDir = path3.join(this.baseDir, "rules");
+    this.receiptsDir = path3.join(this.baseDir, "receipts");
+    this.configFile = path3.join(this.baseDir, "config.json");
+    this.relationsFile = path3.join(this.baseDir, "relations.json");
+    this.outcomesFile = path3.join(this.baseDir, "outcomes.jsonl");
+    this.metricsFile = path3.join(this.baseDir, "metrics.json");
+    this.revisionsFile = path3.join(this.baseDir, "revisions.jsonl");
+    this.knowledgeJsonlFile = path3.join(this.baseDir, "knowledge.jsonl");
+    this.evidenceJsonlFile = path3.join(this.baseDir, "evidence.jsonl");
+    this.observationJsonlFile = path3.join(this.baseDir, "observations.jsonl");
+    this.unknownsJsonlFile = path3.join(this.baseDir, "unknowns.jsonl");
+    this.receiptsJsonlFile = path3.join(this.baseDir, "receipts.jsonl");
+    this.eventsFile = path3.join(this.baseDir, "events.jsonl");
+  }
+  getBaseDir() {
+    return this.baseDir;
+  }
+  async isInitialized() {
+    try {
+      await fs3.access(this.configFile);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async init(options = {}) {
+    await fs3.mkdir(this.knowledgeDir, { recursive: true });
+    await fs3.mkdir(this.evidenceDir, { recursive: true });
+    await fs3.mkdir(this.observationDir, { recursive: true });
+    await fs3.mkdir(this.unknownDir, { recursive: true });
+    await fs3.mkdir(this.rulesDir, { recursive: true });
+    await fs3.mkdir(this.receiptsDir, { recursive: true });
+    let config;
+    if (await this.isInitialized()) {
+      config = await this.getConfig();
+    } else {
+      config = {
+        schemaVersion: 1,
+        projectName: options.projectName ?? path3.basename(path3.dirname(this.baseDir)) ?? "project",
+        defaultScope: options.defaultScope ?? "project",
+        dataDir: this.baseDir
+      };
+      await this.saveConfig(config);
+    }
+    try {
+      await fs3.access(this.relationsFile);
+    } catch {
+      await fs3.writeFile(this.relationsFile, JSON.stringify([], null, 2), "utf-8");
+    }
+    try {
+      await fs3.access(this.metricsFile);
+    } catch {
+      const defaultMetrics = {
+        knowledgeHits: 0,
+        knowledgeMisses: 0,
+        knowledgeReused: 0,
+        unknownsResolved: 0,
+        repeatedInvestigationsPrevented: 0,
+        candidateKnowledgeMerged: 0,
+        staleKnowledgeDetected: 0,
+        contradictionsDetected: 0,
+        knowledgePromoted: 0,
+        knowledgeSuperseded: 0
+      };
+      await fs3.writeFile(this.metricsFile, JSON.stringify(defaultMetrics, null, 2), "utf-8");
+    }
+    return config;
+  }
+  // --- Config ---
+  async getConfig() {
+    const raw = await fs3.readFile(this.configFile, "utf-8");
+    return JSON.parse(raw);
+  }
+  async saveConfig(config) {
+    await fs3.writeFile(this.configFile, JSON.stringify(config, null, 2), "utf-8");
+  }
+  async updateConfig(updates) {
+    const current = await this.getConfig();
+    const updated = { ...current, ...updates };
+    await this.saveConfig(updated);
+    return updated;
+  }
+  // --- Knowledge ---
+  async saveKnowledge(knowledge) {
+    await fs3.mkdir(this.knowledgeDir, { recursive: true });
+    const filename = `${sanitizeFileName(knowledge.id)}.json`;
+    const filePath = path3.join(this.knowledgeDir, filename);
+    await fs3.writeFile(filePath, JSON.stringify(knowledge, null, 2), "utf-8");
+    await fs3.appendFile(this.knowledgeJsonlFile, JSON.stringify(knowledge) + "\n", "utf-8");
+  }
+  async getKnowledge(id) {
+    const filename = `${sanitizeFileName(id)}.json`;
+    const filePath = path3.join(this.knowledgeDir, filename);
+    try {
+      const raw = await fs3.readFile(filePath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  async getAllKnowledge() {
+    try {
+      const files = await fs3.readdir(this.knowledgeDir);
+      const items = [];
+      for (const file of files) {
+        if (!file.endsWith(".json")) continue;
+        const raw = await fs3.readFile(path3.join(this.knowledgeDir, file), "utf-8");
+        try {
+          items.push(JSON.parse(raw));
+        } catch {
+        }
+      }
+      return items;
+    } catch {
+      return [];
+    }
+  }
+  async deleteKnowledge(id) {
+    const filename = `${sanitizeFileName(id)}.json`;
+    const filePath = path3.join(this.knowledgeDir, filename);
+    try {
+      await fs3.unlink(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // --- Evidence ---
+  async saveEvidence(evidence) {
+    await fs3.mkdir(this.evidenceDir, { recursive: true });
+    const filename = `${sanitizeFileName(evidence.id)}.json`;
+    const filePath = path3.join(this.evidenceDir, filename);
+    await fs3.writeFile(filePath, JSON.stringify(evidence, null, 2), "utf-8");
+    await fs3.appendFile(this.evidenceJsonlFile, JSON.stringify(evidence) + "\n", "utf-8");
+  }
+  async getEvidence(id) {
+    const filename = `${sanitizeFileName(id)}.json`;
+    const filePath = path3.join(this.evidenceDir, filename);
+    try {
+      const raw = await fs3.readFile(filePath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  async getAllEvidence() {
+    try {
+      const files = await fs3.readdir(this.evidenceDir);
+      const items = [];
+      for (const file of files) {
+        if (!file.endsWith(".json")) continue;
+        const raw = await fs3.readFile(path3.join(this.evidenceDir, file), "utf-8");
+        try {
+          items.push(JSON.parse(raw));
+        } catch {
+        }
+      }
+      return items;
+    } catch {
+      return [];
+    }
+  }
+  // --- Observations ---
+  async saveObservation(obs) {
+    await fs3.mkdir(this.observationDir, { recursive: true });
+    const filename = `${sanitizeFileName(obs.id)}.json`;
+    const filePath = path3.join(this.observationDir, filename);
+    await fs3.writeFile(filePath, JSON.stringify(obs, null, 2), "utf-8");
+    await fs3.appendFile(this.observationJsonlFile, JSON.stringify(obs) + "\n", "utf-8");
+  }
+  async getObservation(id) {
+    const filename = `${sanitizeFileName(id)}.json`;
+    const filePath = path3.join(this.observationDir, filename);
+    try {
+      const raw = await fs3.readFile(filePath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  async getAllObservations() {
+    try {
+      const files = await fs3.readdir(this.observationDir);
+      const items = [];
+      for (const file of files) {
+        if (!file.endsWith(".json")) continue;
+        const raw = await fs3.readFile(path3.join(this.observationDir, file), "utf-8");
+        try {
+          items.push(JSON.parse(raw));
+        } catch {
+        }
+      }
+      return items;
+    } catch {
+      return [];
+    }
+  }
+  async deleteObservation(id) {
+    const filename = `${sanitizeFileName(id)}.json`;
+    const filePath = path3.join(this.observationDir, filename);
+    try {
+      await fs3.unlink(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // --- Unknowns ---
+  async saveUnknown(record) {
+    await fs3.mkdir(this.unknownDir, { recursive: true });
+    const filename = `${sanitizeFileName(record.id)}.json`;
+    const filePath = path3.join(this.unknownDir, filename);
+    await fs3.writeFile(filePath, JSON.stringify(record, null, 2), "utf-8");
+    await fs3.appendFile(this.unknownsJsonlFile, JSON.stringify(record) + "\n", "utf-8");
+  }
+  async getUnknown(id) {
+    const filename = `${sanitizeFileName(id)}.json`;
+    const filePath = path3.join(this.unknownDir, filename);
+    try {
+      const raw = await fs3.readFile(filePath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  async getAllUnknowns() {
+    try {
+      const files = await fs3.readdir(this.unknownDir);
+      const items = [];
+      for (const file of files) {
+        if (!file.endsWith(".json")) continue;
+        const raw = await fs3.readFile(path3.join(this.unknownDir, file), "utf-8");
+        try {
+          items.push(JSON.parse(raw));
+        } catch {
+        }
+      }
+      return items;
+    } catch {
+      return [];
+    }
+  }
+  async deleteUnknown(id) {
+    const filename = `${sanitizeFileName(id)}.json`;
+    const filePath = path3.join(this.unknownDir, filename);
+    try {
+      await fs3.unlink(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // --- Outcomes (Append-oriented log) ---
+  async appendOutcome(outcome) {
+    const line = JSON.stringify(outcome) + "\n";
+    await fs3.appendFile(this.outcomesFile, line, "utf-8");
+    if (outcome.knowledgeId) {
+      await this.appendMetricEvent({
+        type: "outcome",
+        knowledgeId: outcome.knowledgeId,
+        result: outcome.result,
+        timestamp: Date.now()
+      });
+      if (outcome.result === "success") {
+        await this.appendMetricEvent({
+          type: "question_resolved",
+          questionId: outcome.knowledgeId,
+          timestamp: Date.now()
+        });
+      }
+    }
+  }
+  async getAllOutcomes() {
+    try {
+      const raw = await fs3.readFile(this.outcomesFile, "utf-8");
+      const lines = raw.split("\n").filter((l) => l.trim().length > 0);
+      return lines.map((l) => JSON.parse(l));
+    } catch {
+      return [];
+    }
+  }
+  // --- Metric Events (Append-only local log) ---
+  async appendMetricEvent(event) {
+    try {
+      await fs3.mkdir(this.baseDir, { recursive: true });
+      await fs3.appendFile(this.eventsFile, JSON.stringify(event) + "\n", "utf-8");
+    } catch {
+    }
+  }
+  async getMetricEvents(filter) {
+    return readMetricEvents(path3.dirname(this.baseDir), filter);
+  }
+  async resetMetricEvents() {
+    return resetMetricEvents(path3.dirname(this.baseDir));
+  }
+  // --- Investigation Receipts ---
+  async saveReceipt(receipt) {
+    await fs3.mkdir(this.receiptsDir, { recursive: true });
+    const filename = `${sanitizeFileName(receipt.id)}.json`;
+    const filePath = path3.join(this.receiptsDir, filename);
+    await fs3.writeFile(filePath, JSON.stringify(receipt, null, 2), "utf-8");
+    await fs3.appendFile(this.receiptsJsonlFile, JSON.stringify(receipt) + "\n", "utf-8");
+  }
+  async getReceipt(id) {
+    const filename = `${sanitizeFileName(id)}.json`;
+    const filePath = path3.join(this.receiptsDir, filename);
+    try {
+      const raw = await fs3.readFile(filePath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  async getAllReceipts() {
+    try {
+      const files = await fs3.readdir(this.receiptsDir);
+      const items = [];
+      for (const file of files) {
+        if (!file.endsWith(".json")) continue;
+        const raw = await fs3.readFile(path3.join(this.receiptsDir, file), "utf-8");
+        try {
+          items.push(JSON.parse(raw));
+        } catch {
+        }
+      }
+      return items;
+    } catch {
+      return [];
+    }
+  }
+  // --- Relations ---
+  async getRelations() {
+    try {
+      const raw = await fs3.readFile(this.relationsFile, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return [];
+    }
+  }
+  async saveRelations(relations) {
+    await fs3.writeFile(this.relationsFile, JSON.stringify(relations, null, 2), "utf-8");
+  }
+  // --- Metrics ---
+  async getMetrics() {
+    try {
+      const raw = await fs3.readFile(this.metricsFile, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return {
+        knowledgeHits: 0,
+        knowledgeMisses: 0,
+        knowledgeReused: 0,
+        unknownsResolved: 0,
+        repeatedInvestigationsPrevented: 0,
+        candidateKnowledgeMerged: 0,
+        staleKnowledgeDetected: 0,
+        contradictionsDetected: 0,
+        knowledgePromoted: 0,
+        knowledgeSuperseded: 0
+      };
+    }
+  }
+  async saveMetrics(metrics) {
+    await fs3.writeFile(this.metricsFile, JSON.stringify(metrics, null, 2), "utf-8");
+  }
+  // --- Rules ---
+  getRulesDir() {
+    return this.rulesDir;
+  }
+  async loadRuleSets() {
+    const files = await findRuleFiles(path3.dirname(this.baseDir), this.rulesDir);
+    const sets = [];
+    for (const f of files) {
+      try {
+        sets.push(await loadRuleSetFile(f));
+      } catch {
+      }
+    }
+    return sets;
+  }
+  async saveRuleSet(ruleSet, fileName = "default.yml") {
+    await fs3.mkdir(this.rulesDir, { recursive: true });
+    const cleanName = fileName.endsWith(".yml") || fileName.endsWith(".yaml") ? fileName : `${fileName}.yml`;
+    const targetPath = path3.join(this.rulesDir, cleanName);
+    const yaml = stringifyRuleSetYaml(ruleSet);
+    await fs3.writeFile(targetPath, yaml, "utf-8");
+    return targetPath;
+  }
+  async addRule(rule, fileName = "default.yml") {
+    await fs3.mkdir(this.rulesDir, { recursive: true });
+    const cleanName = fileName.endsWith(".yml") || fileName.endsWith(".yaml") ? fileName : `${fileName}.yml`;
+    const targetPath = path3.join(this.rulesDir, cleanName);
+    let existingSet;
+    try {
+      existingSet = await loadRuleSetFile(targetPath);
+    } catch {
+      existingSet = {
+        name: path3.basename(cleanName, path3.extname(cleanName)),
+        rules: []
+      };
+    }
+    const existingIdx = existingSet.rules.findIndex((r) => r.id === rule.id);
+    if (existingIdx >= 0) {
+      existingSet.rules[existingIdx] = rule;
+    } else {
+      existingSet.rules.push(rule);
+    }
+    const yaml = stringifyRuleSetYaml(existingSet);
+    await fs3.writeFile(targetPath, yaml, "utf-8");
+    return targetPath;
+  }
+  // --- Revisions & Incremental Learning Diff ---
+  async appendRevision(snapshot) {
+    const line = JSON.stringify(snapshot) + "\n";
+    await fs3.appendFile(this.revisionsFile, line, "utf-8");
+  }
+  async getRevisions() {
+    try {
+      const raw = await fs3.readFile(this.revisionsFile, "utf-8");
+      const lines = raw.split("\n").filter((l) => l.trim().length > 0);
+      return lines.map((l) => JSON.parse(l));
+    } catch {
+      return [];
+    }
+  }
+  async getLatestRevision() {
+    const revs = await this.getRevisions();
+    return revs.length > 0 ? revs[revs.length - 1] : void 0;
+  }
+  async getDiff(sinceRef) {
+    const revisions = await this.getRevisions();
+    let baselineSnapshot;
+    let targetSnapshot;
+    if (sinceRef && sinceRef.includes("..")) {
+      const [startRef, endRef] = sinceRef.split("..").map((s) => s.trim().toLowerCase());
+      baselineSnapshot = revisions.find(
+        (r) => r.id.toLowerCase() === startRef || r.commit?.toLowerCase() === startRef || r.commit?.toLowerCase().startsWith(startRef) || r.id.toLowerCase().startsWith(startRef)
+      );
+      targetSnapshot = revisions.find(
+        (r) => r.id.toLowerCase() === endRef || r.commit?.toLowerCase() === endRef || r.commit?.toLowerCase().startsWith(endRef) || r.id.toLowerCase().startsWith(endRef)
+      );
+    } else if (sinceRef) {
+      const cleanRef = sinceRef.trim().toLowerCase();
+      baselineSnapshot = revisions.find(
+        (r) => r.id.toLowerCase() === cleanRef || r.commit?.toLowerCase() === cleanRef || r.commit?.toLowerCase().startsWith(cleanRef) || r.id.toLowerCase().startsWith(cleanRef)
+      );
+    } else {
+      if (revisions.length >= 2) {
+        baselineSnapshot = revisions[revisions.length - 2];
+      } else if (revisions.length === 1) {
+        baselineSnapshot = revisions[0];
+      }
+    }
+    const baselineTimestamp = baselineSnapshot?.timestamp ?? "1970-01-01T00:00:00.000Z";
+    const baselineTime = new Date(baselineTimestamp).getTime();
+    const targetTime = targetSnapshot ? new Date(targetSnapshot.timestamp).getTime() : Date.now();
+    const inWindow = (time) => time >= baselineTime && time <= targetTime;
+    const allObservations = await this.getAllObservations();
+    const allKnowledge = await this.getAllKnowledge();
+    const allUnknowns = await this.getAllUnknowns();
+    let observationsAdded = 0;
+    for (const obs of allObservations) {
+      const obsTime = new Date(obs.recordedAt || obs.provenance?.timestamp || 0).getTime();
+      if (inWindow(obsTime)) {
+        observationsAdded++;
+      }
+    }
+    let candidatesAdded = 0;
+    let strengthenedCount = 0;
+    let revisedCount = 0;
+    let contradictionCount = 0;
+    let invalidatedCount = 0;
+    let needsRevalidationCount = 0;
+    const strengthened = [];
+    const revised = [];
+    const contradictions = [];
+    const invalidated = [];
+    const needsRevalidation = [];
+    for (const k of allKnowledge) {
+      const createdTime = new Date(k.createdAt).getTime();
+      const updatedTime = new Date(k.updatedAt).getTime();
+      if ((k.status === "invalid" || k.status === "invalidated") && inWindow(updatedTime)) {
+        invalidatedCount++;
+        invalidated.push(k.id);
+        continue;
+      }
+      if (k.status === "contradicted" && inWindow(updatedTime)) {
+        contradictionCount++;
+        contradictions.push(k.id);
+        continue;
+      }
+      if ((k.status === "needs_revalidation" || k.status === "stale") && inWindow(updatedTime)) {
+        needsRevalidationCount++;
+        needsRevalidation.push(k.id);
+        continue;
+      }
+      if (inWindow(createdTime)) {
+        candidatesAdded++;
+      } else if (inWindow(updatedTime)) {
+        if (k.metrics.support_count > 1 || k.confidence >= 0.85 || k.metrics.successful_outcomes > 0) {
+          strengthenedCount++;
+          strengthened.push(k.id);
+        } else {
+          revisedCount++;
+          revised.push(k.id);
+        }
+      }
+    }
+    let unknownsCount = 0;
+    const unknownsList = [];
+    for (const u of allUnknowns) {
+      const uTime = new Date(u.createdAt || u.updatedAt || 0).getTime();
+      if (inWindow(uTime)) {
+        unknownsCount++;
+        unknownsList.push(u.id);
+      }
+    }
+    const refLabel = sinceRef ?? (baselineSnapshot ? baselineSnapshot.commit?.slice(0, 7) || baselineSnapshot.id.slice(0, 7) : void 0);
+    return {
+      sinceRef: refLabel,
+      observationsAdded,
+      candidatesAdded,
+      strengthenedCount,
+      revisedCount,
+      contradictionCount,
+      unknownsCount,
+      needsRevalidationCount,
+      invalidatedCount,
+      details: {
+        strengthened,
+        revised,
+        contradictions,
+        unknowns: unknownsList,
+        needsRevalidation,
+        invalidated
+      }
+    };
+  }
+};
+
+// src/stats/aggregator.ts
+function formatPercentage(ratio) {
+  if (ratio === void 0 || isNaN(ratio)) {
+    return "\u2014";
+  }
+  return `${(ratio * 100).toFixed(1)}%`;
+}
+function formatRelativeTime(dateStr) {
+  if (!dateStr) return void 0;
+  const ts = typeof dateStr === "number" ? dateStr : Date.parse(dateStr);
+  if (isNaN(ts)) return void 0;
+  const diffMs = Date.now() - ts;
+  const diffSec = Math.floor(diffMs / 1e3);
+  if (diffSec < 60) return `${diffSec}s ago`;
+  const diffMin = Math.floor(diffSec / 60);
+  if (diffMin < 60) return `${diffMin}m ago`;
+  const diffHr = Math.floor(diffMin / 60);
+  if (diffHr < 24) return `${diffHr}h ago`;
+  const diffDays = Math.floor(diffHr / 24);
+  return `${diffDays}d ago`;
+}
+function classifyKnowledgeHealth(knowledge, knowledgeEvents, independentSourcesCount) {
+  if (knowledge.status === "needs_revalidation" || knowledge.status === "stale") {
+    return {
+      category: "NEEDS_REVALIDATION",
+      reason: "Underlying source or dependency changed since last validation"
+    };
+  }
+  const outcomes = knowledgeEvents.filter((e) => e.type === "outcome");
+  const misleadingCount = outcomes.filter(
+    (o) => o.result === "failure" || o.result === "reverted" || o.result === "misleading"
+  ).length + (knowledge.outcomesSummary?.misleading ?? 0);
+  const successCount = outcomes.filter((o) => o.result === "success").length + (knowledge.metrics.successful_outcomes ?? 0);
+  if (misleadingCount > 0 && misleadingCount >= successCount) {
+    return {
+      category: "FREQUENTLY_MISLEADING",
+      reason: `${misleadingCount} negative or misleading outcome(s) recorded`
+    };
+  }
+  const jevEvents = knowledgeEvents.filter((e) => e.type === "jev_result");
+  const rejectCount = jevEvents.filter((j) => j.result === "REJECT").length;
+  if (jevEvents.length >= 3 && rejectCount / jevEvents.length >= 0.7) {
+    return {
+      category: "FREQUENTLY_REJECTED",
+      reason: `Rejected in ${rejectCount} of ${jevEvents.length} JEV evaluations`
+    };
+  }
+  if (independentSourcesCount < 2 && knowledge.confidence < 0.75) {
+    return {
+      category: "LOW_EVIDENCE",
+      reason: `Only ${independentSourcesCount} independent source(s) and confidence < 0.75`
+    };
+  }
+  const reuseCount = knowledge.metrics.reuse_count + knowledgeEvents.filter((e) => e.type === "knowledge_reused").length;
+  const createdAtMs = Date.parse(knowledge.createdAt);
+  const ageHours = !isNaN(createdAtMs) ? (Date.now() - createdAtMs) / (1e3 * 3600) : 0;
+  if (reuseCount === 0 && ageHours > 1) {
+    return {
+      category: "UNUSED",
+      reason: "No reuse recorded since creation"
+    };
+  }
+  return {
+    category: "HEALTHY",
+    reason: "Active with verified evidence and clean outcome history"
+  };
+}
+async function computeStats(storage, events, options) {
+  const allKnowledge = await storage.getAllKnowledge();
+  const allUnknowns = await storage.getAllUnknowns();
+  let active = 0;
+  let candidates = 0;
+  let conflicted = 0;
+  let needsRevalidation = 0;
+  let stale = 0;
+  for (const k of allKnowledge) {
+    if (k.status === "active") active++;
+    else if (k.status === "candidate" || k.stage === "candidate") candidates++;
+    else if (k.status === "contradicted") conflicted++;
+    else if (k.status === "needs_revalidation") needsRevalidation++;
+    else if (k.status === "stale") stale++;
+  }
+  const learning = {
+    observations: 0,
+    new: 0,
+    merged: 0,
+    strengthened: 0,
+    specialized: 0,
+    superseded: 0,
+    contradictions: 0,
+    ignoredDuplicates: 0
+  };
+  const resolution = {
+    resolveCalls: 0,
+    known: 0,
+    partiallyKnown: 0,
+    unknown: 0,
+    conflicted: 0,
+    stale: 0
+  };
+  const investigation = {
+    repeatedChecksAvoided: 0,
+    knowledgeReused: 0,
+    questionsSuggested: 0,
+    questionsResolved: 0,
+    broadSearchesAvoided: 0,
+    sourceReadsAvoided: 0,
+    investigationsReused: 0
+  };
+  const jev = {
+    candidates: 0,
+    match: 0,
+    possible: 0,
+    rejected: 0,
+    hardNegativeRejects: 0,
+    reasons: {
+      hardNegative: 0,
+      scopeMismatch: 0,
+      insufficientContext: 0,
+      staleKnowledge: 0
+    }
+  };
+  const actions = {};
+  for (const e of events) {
+    switch (e.type) {
+      case "knowledge_created":
+        learning.new++;
+        break;
+      case "knowledge_merged":
+        learning.merged++;
+        break;
+      case "knowledge_strengthened":
+        learning.strengthened++;
+        break;
+      case "knowledge_specialized":
+        learning.specialized++;
+        break;
+      case "knowledge_superseded":
+        learning.superseded++;
+        break;
+      case "contradiction_detected":
+        learning.contradictions++;
+        break;
+      case "duplicate_ignored":
+        learning.ignoredDuplicates++;
+        break;
+      case "resolve":
+        resolution.resolveCalls++;
+        if (e.state === "KNOWN") resolution.known++;
+        else if (e.state === "PARTIALLY_KNOWN") resolution.partiallyKnown++;
+        else if (e.state === "UNKNOWN") resolution.unknown++;
+        else if (e.state === "CONFLICTED") resolution.conflicted++;
+        else if (e.state === "STALE") resolution.stale++;
+        if (e.action) {
+          actions[e.action] = (actions[e.action] ?? 0) + 1;
+        }
+        break;
+      case "knowledge_reused":
+        investigation.knowledgeReused++;
+        break;
+      case "question_suggested":
+        investigation.questionsSuggested++;
+        break;
+      case "question_resolved":
+        investigation.questionsResolved++;
+        break;
+      case "broad_search_avoided":
+        investigation.broadSearchesAvoided++;
+        break;
+      case "source_read_avoided":
+        investigation.sourceReadsAvoided++;
+        investigation.repeatedChecksAvoided++;
+        break;
+      case "investigation_reused":
+        investigation.investigationsReused++;
+        investigation.repeatedChecksAvoided++;
+        break;
+      case "jev_result":
+        jev.candidates++;
+        if (e.result === "MATCH") jev.match++;
+        else if (e.result === "POSSIBLE") jev.possible++;
+        else if (e.result === "REJECT") {
+          jev.rejected++;
+          const reason = String(e.reason || "").toUpperCase();
+          if (reason.includes("HARD_NEGATIVE") || reason.includes("FORBIDS")) {
+            jev.hardNegativeRejects++;
+            jev.reasons.hardNegative++;
+          } else if (reason.includes("SCOPE")) {
+            jev.reasons.scopeMismatch++;
+          } else if (reason.includes("STALE")) {
+            jev.reasons.staleKnowledge++;
+          } else {
+            jev.reasons.insufficientContext++;
+          }
+        }
+        break;
+      case "jev_hard_negative":
+        break;
+    }
+  }
+  try {
+    const allObs = await storage.getAllObservations();
+    learning.observations = allObs.length;
+  } catch {
+    learning.observations = 0;
+  }
+  const reuseRatio = resolution.resolveCalls > 0 ? Math.min(1, (resolution.known + Math.min(resolution.partiallyKnown, investigation.knowledgeReused)) / resolution.resolveCalls) : void 0;
+  const knowledgeReuseRate = {
+    value: reuseRatio,
+    formatted: reuseRatio !== void 0 ? formatPercentage(reuseRatio) : "\u2014 (Not enough observations)",
+    formula: "resolve operations that reused existing applicable knowledge / all resolve operations"
+  };
+  const resolveSuccessRatio = resolution.resolveCalls > 0 ? Math.min(1, (resolution.known + investigation.questionsResolved) / resolution.resolveCalls) : void 0;
+  const resolveSuccessRate = {
+    value: resolveSuccessRatio,
+    formatted: resolveSuccessRatio !== void 0 ? formatPercentage(resolveSuccessRatio) : "\u2014 (Not enough observations)",
+    formula: "(KNOWN + successfully resolved PARTIALLY_KNOWN) / all completed resolve attempts"
+  };
+  const questionRatio = investigation.questionsSuggested > 0 ? Math.min(1, investigation.questionsResolved / investigation.questionsSuggested) : void 0;
+  const questionResolutionRate = {
+    value: questionRatio,
+    formatted: questionRatio !== void 0 ? formatPercentage(questionRatio) : "\u2014 (Not enough observations)",
+    formula: "questions resolved / questions suggested"
+  };
+  const jevRatio = jev.candidates > 0 ? jev.rejected / jev.candidates : void 0;
+  const jevRejectionRate = {
+    value: jevRatio,
+    formatted: jevRatio !== void 0 ? formatPercentage(jevRatio) : "\u2014 (Not enough observations)",
+    formula: "JEV rejected candidates / all JEV candidates evaluated"
+  };
+  const health = {
+    healthy: 0,
+    needsRevalidation: 0,
+    lowEvidence: 0,
+    frequentlyRejected: 0,
+    frequentlyMisleading: 0,
+    unused: 0
+  };
+  const eventsByKnowledge = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    const kid = e.knowledgeId;
+    if (kid) {
+      const list = eventsByKnowledge.get(kid) || [];
+      list.push(e);
+      eventsByKnowledge.set(kid, list);
+    }
+  }
+  for (const k of allKnowledge) {
+    const kEvents = eventsByKnowledge.get(k.id) || [];
+    const uniqueSources = new Set(k.evidence.map((ev) => ev.replace(/^(code|file|test|doc):/, "")));
+    const { category } = classifyKnowledgeHealth(k, kEvents, uniqueSources.size);
+    switch (category) {
+      case "HEALTHY":
+        health.healthy++;
+        break;
+      case "NEEDS_REVALIDATION":
+        health.needsRevalidation++;
+        break;
+      case "LOW_EVIDENCE":
+        health.lowEvidence++;
+        break;
+      case "FREQUENTLY_REJECTED":
+        health.frequentlyRejected++;
+        break;
+      case "FREQUENTLY_MISLEADING":
+        health.frequentlyMisleading++;
+        break;
+      case "UNUSED":
+        health.unused++;
+        break;
+    }
+  }
+  return {
+    since: options?.since,
+    sinceTimestamp: options?.sinceTimestamp,
+    knowledge: {
+      active,
+      candidates,
+      unknown: allUnknowns.length,
+      conflicted,
+      needsRevalidation,
+      stale,
+      total: allKnowledge.length
+    },
+    learning,
+    resolution,
+    investigation,
+    jev,
+    actions,
+    effectiveness: {
+      knowledgeReuseRate,
+      resolveSuccessRate,
+      questionResolutionRate,
+      jevRejectionRate
+    },
+    health
+  };
+}
+async function computeKnowledgeStats(storage, knowledgeId, events) {
+  const knowledge = await storage.getKnowledge(knowledgeId);
+  if (!knowledge) {
+    return void 0;
+  }
+  const kEvents = events.filter((e) => e.knowledgeId === knowledgeId);
+  const outcomes = kEvents.filter((e) => e.type === "outcome");
+  const successfulOutcomes = knowledge.metrics.successful_outcomes + outcomes.filter((o) => o.result === "success").length;
+  const neutralOutcomes = (knowledge.outcomesSummary?.neutral ?? 0) + outcomes.filter((o) => o.result === "neutral").length;
+  const misleadingOutcomes = (knowledge.outcomesSummary?.misleading ?? 0) + outcomes.filter((o) => o.result === "misleading").length;
+  const failedOutcomes = knowledge.metrics.failed_outcomes + outcomes.filter((o) => o.result === "failure" || o.result === "reverted").length;
+  const used = knowledge.metrics.reuse_count + kEvents.filter((e) => e.type === "knowledge_reused").length;
+  const jevEvents = kEvents.filter((e) => e.type === "jev_result");
+  const jevMatch = jevEvents.filter((j) => j.result === "MATCH").length;
+  const jevPossible = jevEvents.filter((j) => j.result === "POSSIBLE").length;
+  const jevRejected = jevEvents.filter((j) => j.result === "REJECT").length;
+  const jevHardNegativeRejects = jevEvents.filter(
+    (j) => String(j.reason || "").toUpperCase().includes("HARD_NEGATIVE")
+  ).length + kEvents.filter((e) => e.type === "jev_hard_negative").length;
+  const uniqueSources = new Set(knowledge.evidence.map((ev) => ev.replace(/^(code|file|test|doc):/, "")));
+  const revisions = knowledge.temporal?.revision || knowledge.history?.length || 1;
+  const strengthened = knowledge.metrics.support_count + kEvents.filter((e) => e.type === "knowledge_strengthened").length;
+  const contradictions = knowledge.metrics.contradiction_count + kEvents.filter((e) => e.type === "contradiction_detected").length;
+  const lastUsedStr = formatRelativeTime(knowledge.metrics.last_used);
+  const lastValidatedStr = formatRelativeTime(knowledge.updatedAt);
+  const { category: healthCategory, reason: healthReason } = classifyKnowledgeHealth(
+    knowledge,
+    kEvents,
+    uniqueSources.size
+  );
+  return {
+    id: knowledge.id,
+    status: knowledge.status,
+    stage: knowledge.stage,
+    statement: knowledge.statement,
+    usage: {
+      used,
+      successfulOutcomes,
+      neutralOutcomes,
+      misleadingOutcomes,
+      failedOutcomes
+    },
+    jev: {
+      match: jevMatch,
+      possible: jevPossible,
+      rejected: jevRejected,
+      hardNegativeRejects: jevHardNegativeRejects
+    },
+    evidence: {
+      sources: knowledge.evidence.length,
+      independentSources: uniqueSources.size,
+      sourcesList: knowledge.evidence
+    },
+    lifecycle: {
+      revisions,
+      strengthened,
+      contradictions,
+      lastUsed: lastUsedStr,
+      lastValidated: lastValidatedStr,
+      health: healthCategory,
+      healthReason
+    }
+  };
+}
+
+// src/stats/filter.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function resolveSinceTimestamp(since, projectDir = process.cwd()) {
+  const trimmed = since.trim();
+  const durationMatch = trimmed.match(/^(\d+)\s*([smhdw])$/i);
+  if (durationMatch) {
+    const value = parseInt(durationMatch[1], 10);
+    const unit = durationMatch[2].toLowerCase();
+    let ms = 0;
+    switch (unit) {
+      case "s":
+        ms = value * 1e3;
+        break;
+      case "m":
+        ms = value * 60 * 1e3;
+        break;
+      case "h":
+        ms = value * 3600 * 1e3;
+        break;
+      case "d":
+        ms = value * 86400 * 1e3;
+        break;
+      case "w":
+        ms = value * 7 * 86400 * 1e3;
+        break;
+    }
+    return Date.now() - ms;
+  }
+  const parsedDate = Date.parse(trimmed);
+  if (!isNaN(parsedDate) && trimmed.includes("-")) {
+    return parsedDate;
+  }
+  try {
+    const { stdout } = await execFileAsync(
+      "git",
+      ["log", "-1", "--format=%ct", trimmed],
+      { cwd: projectDir }
+    );
+    const epochSec = parseInt(stdout.trim(), 10);
+    if (!isNaN(epochSec) && epochSec > 0) {
+      return epochSec * 1e3;
+    }
+    throw new Error(`Invalid git output: ${stdout}`);
+  } catch {
+    throw new Error(`Unable to resolve Git revision: ${trimmed}`);
+  }
+}
+
+// src/stats/format.ts
+function padRow(label, value, width = 26) {
+  return `  ${label.padEnd(width)} ${String(value).padStart(5)}`;
+}
+function formatStatsReport(report) {
+  const lines = [];
+  if (report.since) {
+    lines.push(`Time range: since ${report.since}
+`);
+  }
+  lines.push("Knowledge");
+  lines.push(padRow("Active", report.knowledge.active));
+  lines.push(padRow("Candidates", report.knowledge.candidates));
+  lines.push(padRow("Unknown", report.knowledge.unknown));
+  lines.push(padRow("Conflicted", report.knowledge.conflicted));
+  lines.push(padRow("Needs revalidation", report.knowledge.needsRevalidation));
+  lines.push("");
+  lines.push("Learning");
+  lines.push(padRow("Observations", report.learning.observations));
+  lines.push(padRow("New", report.learning.new));
+  lines.push(padRow("Merged", report.learning.merged));
+  lines.push(padRow("Strengthened", report.learning.strengthened));
+  lines.push(padRow("Specialized", report.learning.specialized));
+  lines.push(padRow("Superseded", report.learning.superseded));
+  lines.push(padRow("Contradictions", report.learning.contradictions));
+  lines.push(padRow("Ignored duplicates", report.learning.ignoredDuplicates));
+  lines.push("");
+  lines.push("Resolution");
+  lines.push(padRow("Resolve calls", report.resolution.resolveCalls));
+  lines.push(padRow("Known", report.resolution.known));
+  lines.push(padRow("Partially known", report.resolution.partiallyKnown));
+  lines.push(padRow("Unknown", report.resolution.unknown));
+  lines.push(padRow("Conflicted", report.resolution.conflicted));
+  lines.push("");
+  lines.push("Investigation");
+  lines.push(padRow("Repeated checks avoided", report.investigation.repeatedChecksAvoided));
+  lines.push(padRow("Knowledge reused", report.investigation.knowledgeReused));
+  lines.push(padRow("Questions suggested", report.investigation.questionsSuggested));
+  lines.push(padRow("Questions resolved", report.investigation.questionsResolved));
+  lines.push(padRow("Broad searches avoided", report.investigation.broadSearchesAvoided));
+  lines.push("");
+  lines.push("JEV");
+  lines.push(padRow("Candidates", report.jev.candidates));
+  lines.push(padRow("Match", report.jev.match));
+  lines.push(padRow("Possible", report.jev.possible));
+  lines.push(padRow("Rejected", report.jev.rejected));
+  lines.push(padRow("Hard negative rejects", report.jev.hardNegativeRejects));
+  lines.push("");
+  const actionKeys = Object.keys(report.actions);
+  if (actionKeys.length > 0) {
+    const actionLabels = {
+      USE_KNOWLEDGE: "Use existing knowledge",
+      INSPECT_FILE: "Inspect single source",
+      INSPECT_TEST: "Inspect test",
+      INSPECT_SYMBOL: "Inspect symbol",
+      CHECK_GIT: "Check Git",
+      CHECK_DOCUMENTATION: "Check documentation",
+      SEARCH_REPOSITORY: "Search repository",
+      ASK_USER: "Ask user",
+      STOP: "Stop unresolved"
+    };
+    lines.push("Resolution Actions");
+    for (const key of actionKeys) {
+      const label = actionLabels[key] || key;
+      lines.push(padRow(label, report.actions[key]));
+    }
+    lines.push("");
+  }
+  lines.push("Effectiveness");
+  lines.push(padRow("Knowledge reuse rate", report.effectiveness.knowledgeReuseRate.formatted));
+  lines.push(padRow("Resolve success rate", report.effectiveness.resolveSuccessRate.formatted));
+  lines.push(padRow("Question resolution rate", report.effectiveness.questionResolutionRate.formatted));
+  lines.push(padRow("JEV rejection rate", report.effectiveness.jevRejectionRate.formatted));
+  lines.push("");
+  lines.push("Knowledge Health");
+  lines.push(padRow("Healthy", report.health.healthy));
+  lines.push(padRow("Needs revalidation", report.health.needsRevalidation));
+  lines.push(padRow("Low evidence", report.health.lowEvidence));
+  lines.push(padRow("Frequently rejected", report.health.frequentlyRejected));
+  lines.push(padRow("Frequently misleading", report.health.frequentlyMisleading));
+  lines.push(padRow("Unused", report.health.unused));
+  return lines.join("\n");
+}
+function formatKnowledgeStatsReport(report) {
+  const lines = [];
+  lines.push(report.id);
+  lines.push(`"${report.statement}"
+`);
+  lines.push("Status");
+  lines.push(`  ${report.status.toUpperCase()}${report.stage ? ` (${report.stage})` : ""}
+`);
+  lines.push("Usage");
+  lines.push(padRow("Used", report.usage.used));
+  lines.push(padRow("Successful outcomes", report.usage.successfulOutcomes));
+  lines.push(padRow("Neutral", report.usage.neutralOutcomes));
+  lines.push(padRow("Misleading", report.usage.misleadingOutcomes));
+  lines.push("");
+  lines.push("JEV");
+  lines.push(padRow("Match", report.jev.match));
+  lines.push(padRow("Possible", report.jev.possible));
+  lines.push(padRow("Rejected", report.jev.rejected));
+  lines.push(padRow("Hard negative rejects", report.jev.hardNegativeRejects));
+  lines.push("");
+  lines.push("Evidence");
+  lines.push(padRow("Sources", report.evidence.sources));
+  lines.push(padRow("Independent sources", report.evidence.independentSources));
+  lines.push("");
+  lines.push("Lifecycle");
+  lines.push(padRow("Revisions", report.lifecycle.revisions));
+  lines.push(padRow("Strengthened", report.lifecycle.strengthened));
+  lines.push(padRow("Contradictions", report.lifecycle.contradictions));
+  if (report.lifecycle.lastUsed) {
+    lines.push(padRow("Last used", report.lifecycle.lastUsed));
+  }
+  if (report.lifecycle.lastValidated) {
+    lines.push(padRow("Last validated", report.lifecycle.lastValidated));
+  }
+  lines.push(padRow("Health", `${report.lifecycle.health} (${report.lifecycle.healthReason})`));
+  return lines.join("\n");
+}
+
+// src/stats/index.ts
+async function runStats(options = {}) {
+  const rootDir = options.rootDir || process.cwd();
+  const storage = new Storage(rootDir);
+  if (options.reset) {
+    await resetMetricEvents(rootDir);
+    return { reset: true };
+  }
+  let sinceTimestamp;
+  if (options.since) {
+    sinceTimestamp = await resolveSinceTimestamp(options.since, rootDir);
+  }
+  const events = await readMetricEvents(rootDir, {
+    sinceTimestamp,
+    knowledgeId: options.knowledgeId
+  });
+  if (options.knowledgeId) {
+    const knowledgeReport = await computeKnowledgeStats(storage, options.knowledgeId, events);
+    return { knowledgeReport };
+  }
+  const report = await computeStats(storage, events, {
+    since: options.since,
+    sinceTimestamp
+  });
+  return { report };
+}
+export {
+  appendMetricEvent,
+  classifyKnowledgeHealth,
+  computeKnowledgeStats,
+  computeStats,
+  formatKnowledgeStatsReport,
+  formatStatsReport,
+  getEventsFilePath,
+  readMetricEvents,
+  resetMetricEvents,
+  resolveSinceTimestamp,
+  runStats
+};
+//# sourceMappingURL=index.js.map