@theglitchking/semantic-memory 1.6.1 → 1.7.0

package/dist/cli/index.js

@@ -1,10 +1,34 @@
 #!/usr/bin/env node
+import {
+  tuneDescription
+} from "../chunk-OT3MV7XF.js";
+import {
+  buildEvalSet,
+  runTrigger
+} from "../chunk-MQS7JEBD.js";
+import {
+  runTaskEval
+} from "../chunk-DBFD3MTT.js";
+import "../chunk-IEZVFKUT.js";
+import {
+  parseSkill
+} from "../chunk-ZSWI3Y4Y.js";
+import "../chunk-J7LYDRML.js";
+import {
+  ENV,
+  describeFeature,
+  featureState,
+  setRepoConfig,
+  setSettingsEnv
+} from "../chunk-VQCNWRTL.js";
+import "../chunk-GYR7U6KA.js";
+import "../chunk-H2BES6FU.js";
 import "../chunk-PZ5AY32C.js";
 
 // src/cli/index.ts
 import { program } from "commander";
-import { resolve as resolve2, join as join3, dirname, relative } from "path";
-import { existsSync as existsSync3, readFileSync, writeFileSync, rmSync } from "fs";
+import { resolve as resolve4, join as join3, dirname, relative } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync, rmSync } from "fs";
 import { createRequire } from "module";
 import { spawnSync } from "child_process";
 import { pathToFileURL } from "url";
@@ -71,15 +95,15 @@ async function listShippedSkills(sourceRoot) {
   const skillsDir = join(sourceRoot, "skills");
   if (!existsSync(skillsDir)) return [];
   const entries = await readdir(skillsDir, { withFileTypes: true });
-  const out = [];
+  const out2 = [];
   for (const e of entries) {
     if (!e.isDirectory()) continue;
     const dir = join(skillsDir, e.name);
     const skillFile = join(dir, "SKILL.md");
     if (!existsSync(skillFile)) continue;
-    out.push({ name: e.name, dir });
+    out2.push({ name: e.name, dir });
   }
-  return out;
+  return out2;
 }
 async function sha256OfFile(path) {
   const buf = await readFile(path);
@@ -305,6 +329,240 @@ function safeMtime(path) {
   }
 }
 
+// src/cli/features.ts
+var NEXT = "takes effect in the next Claude Code session (settings env is read at session start)";
+function toggle(feature, on, opts) {
+  const cwd = process.cwd();
+  try {
+    if (opts.repo) {
+      const path = setRepoConfig(cwd, "skill_loop", opts.clear ? void 0 : on ? "on" : "off");
+      console.log(`\u2713 ${opts.clear ? "cleared" : "set"} skill_loop${opts.clear ? "" : `: ${on ? "on" : "off"}`} in ${path}`);
+    } else {
+      const { path, backup } = setSettingsEnv(ENV[feature], on ? "1" : void 0);
+      console.log(`\u2713 ${on ? "set" : "removed"} ${ENV[feature]}${on ? "=1" : ""} in ${path}${backup ? ` (previous file: ${backup})` : ""}`);
+      console.log(`  ${NEXT}`);
+    }
+  } catch (e) {
+    console.error(`\u2717 ${e.message}`);
+    process.exit(1);
+  }
+  const env = { ...process.env };
+  if (!opts.repo) {
+    if (on) env[ENV[feature]] = "1";
+    else delete env[ENV[feature]];
+  }
+  console.log(`  now: ${describeFeature(featureState(feature, cwd, env))}`);
+}
+function registerFeatureCommands(program2, extraStatus = {}) {
+  for (const [feature, name, what] of [
+    ["skill_loop", "skill-loop", "the skill loop (learned skills between sessions)"],
+    ["jev", "jev-mode", "jev mode (Jev through jev-loop for closed-set decisions)"]
+  ]) {
+    const cmd = program2.commands.find((c) => c.name() === name) ?? program2.command(name).description(`Turn ${what} on or off, or show its state.`);
+    const on = cmd.command("on").description(`Turn ${what} on (sets ${ENV[feature]}=1 in ~/.claude/settings.json env).`);
+    const off = cmd.command("off").description(`Turn ${what} off (removes ${ENV[feature]} from ~/.claude/settings.json env).`);
+    if (feature === "skill_loop") {
+      for (const c of [on, off]) {
+        c.option("--repo", "Write the per-repo override in .claude/.semantic-memory/config instead (beats the global switch)");
+        c.option("--clear", "With --repo: remove the override so the global switch applies");
+      }
+    }
+    on.action((opts) => toggle(feature, true, opts));
+    off.action((opts) => toggle(feature, false, opts));
+    cmd.command("status").description(`Show whether ${what} is on, and why.`).option("--json", "JSON output").action(async (opts) => {
+      const cwd = process.cwd();
+      const s = featureState(feature, cwd);
+      const extra = await extraStatus[feature]?.(cwd) ?? [];
+      if (opts.json) console.log(JSON.stringify({ ...s, details: extra }, null, 2));
+      else for (const line of [describeFeature(s), ...extra.map((l) => `  ${l}`)]) console.log(line);
+      process.exit(0);
+    });
+  }
+}
+
+// src/cli/skill-loop.ts
+import { resolve as resolve2 } from "path";
+function registerSkillLoopCommands(program2) {
+  const cmd = program2.commands.find((c) => c.name() === "skill-loop");
+  registerReviewCommands(cmd);
+  registerCuratorCommands(cmd);
+  cmd.command("worker").description("Drain this repo's review queue (started detached by the SessionEnd hook; safe to run by hand).").option("--repo <dir>", "Repo root (default: cwd)").action(async (opts) => {
+    const repo = resolve2(opts.repo ?? process.cwd());
+    const { featureOn } = await import("../core/features.js");
+    const { log } = await import("../core/skill-queue.js");
+    if (!featureOn("skill_loop", repo)) {
+      log(repo, "worker: skill loop is off \u2014 queue left as it is");
+      process.exit(0);
+    }
+    const { drain } = await import("../core/skill-worker.js");
+    const { reviewSession } = await import("../core/skill-review.js");
+    const r = await drain(repo, (job) => reviewSession(job));
+    console.log(r.locked ? "another worker holds this repo's lock" : `reviewed ${r.reviewed} session(s)${r.capped ? "; daily cap reached" : ""}${r.failed ? `; ${r.failed} set aside` : ""}`);
+    process.exit(0);
+  });
+}
+function registerReviewCommands(cmd) {
+  cmd.command("review").description("List skill drafts with their evidence (and diff, for patches); approve, reject or evaluate one.").option("--json", "JSON output").option("--approve <id>", "Land a draft (writes the skill and a ledger entry)").option("--promote", "With --approve: land it as a global skill replacing the project copies (needs a promotion)").option("--override <why>", "With --approve: land it although its eval gate did not adopt it (the reason is ledgered)").option("--reject <id>", "Drop a draft (ledgered)").option("--eval <id>", "Run the trigger eval on a draft and record the scores and the gate's verdict").option("--task", "With --eval: also replay the task with and without the skill (runs the draft's Verify command)").action(async (opts) => {
+    const { repoRoot } = await import("../core/skill-evidence.js");
+    const land = await import("../skill-land-XU2APPBJ.js");
+    const repo = repoRoot(process.cwd());
+    try {
+      if (opts.approve) {
+        const e = land.approveDraft(repo, opts.approve, { promote: opts.promote, override: opts.override });
+        console.log(`\u2713 ${e.action}: ${e.files.map((f) => f.path).join(", ")} (ledger ${e.id}; undo: skill-loop rollback ${e.id})`);
+      } else if (opts.reject) {
+        const e = land.rejectDraft(repo, opts.reject);
+        console.log(`\u2713 rejected ${e.skill} (ledger ${e.id})`);
+      } else if (opts.eval) {
+        const ev = await land.evalDraft(repo, opts.eval, { task: opts.task });
+        console.log(opts.json ? JSON.stringify(ev, null, 2) : `gate: ${ev.gate.verdict} \u2014 ${ev.gate.reasons.join("; ")} (${ev.prompts} prompts, ${ev.runs} claude runs)`);
+      } else {
+        const drafts = land.describeDrafts(repo);
+        if (opts.json) console.log(JSON.stringify(drafts, null, 2));
+        else if (!drafts.length) console.log("no skill drafts waiting");
+        else
+          for (const d of drafts) {
+            console.log(`
+${d.id}  ${d.kind} ${d.name} \u2192 ${d.destination}`);
+            console.log(`  scope: ${d.scope}${d.scope_why ? ` (${d.scope_why})` : ""}${d.promotion?.length ? `; also in ${d.promotion.map((p) => p.repo).join(", ")}: --promote offers one global skill` : ""}`);
+            console.log(`  evidence: sessions ${d.provenance?.sessions.join(", ")}; failures ${d.provenance?.failures.join(", ") || "-"}; corrections ${d.provenance?.corrections.join(", ") || "-"}`);
+            if (d.verify.kind === "command") console.log(`  verify command (a --task eval runs it): ${d.verify.command}`);
+            if (d.evals) console.log(`  evals: ${JSON.stringify(d.evals.gate)}`);
+            for (const w of d.warnings) console.log(`  ! ${w}`);
+          }
+      }
+    } catch (e) {
+      console.error(`\u2717 ${e.message}`);
+      process.exit(1);
+    }
+    process.exit(0);
+  });
+  cmd.command("rollback <ledger-id>").description("Undo one ledgered change exactly (refuses if a file changed since).").action(async (id) => {
+    const { repoRoot } = await import("../core/skill-evidence.js");
+    const { rollback } = await import("../skill-ledger-AYXVNFX7.js");
+    try {
+      const e = rollback(repoRoot(process.cwd()), id);
+      console.log(`\u2713 ${e.why} (ledger ${e.id})`);
+    } catch (err) {
+      console.error(`\u2717 ${err.message}`);
+      process.exit(1);
+    }
+    process.exit(0);
+  });
+}
+function registerCuratorCommands(cmd) {
+  const repoOf = async () => (await import("../core/skill-evidence.js")).repoRoot(process.cwd());
+  cmd.command("curate").description("Mark learned skills unused 14 days stale and archive those unused 30 days (pinned / cited / new ones skipped).").option("--dry-run", "Show what would change, change nothing").option("--merge", "Also propose merges of overlapping learned skills as review drafts (opt-in)").option("--auto", "Started by SessionStart: quiet, logs to skill-loop.log").action(async (opts) => {
+    const repo = await repoOf();
+    const { curate } = await import("../core/skill-curator.js");
+    const { log } = await import("../core/skill-queue.js");
+    const r = curate(repo, { dryRun: opts.dryRun });
+    const changes = r.actions.filter((a) => a.action !== "skip" && a.action !== "keep");
+    if (opts.auto) log(repo, `curator: ${changes.map((a) => `${a.action} ${a.skill} (${a.why})`).join(", ") || "nothing to do"}`);
+    else for (const a of r.actions) console.log(`${opts.dryRun ? "would " : ""}${a.action.padEnd(10)} ${a.skill} \u2014 ${a.why}`);
+    if (!opts.auto && !r.actions.length) console.log("no learned skills here");
+    const { consolidateOn, proposeMerges } = await import("../skill-merge-GXBQLBZA.js");
+    if (!opts.dryRun && (opts.merge || consolidateOn(repo))) {
+      const m = await proposeMerges(repo);
+      const line = `merge: ${m.drafted.length} draft(s) for review${m.skipped.length ? `; ${m.skipped.join("; ")}` : ""}`;
+      if (opts.auto) log(repo, line);
+      else console.log(line);
+    }
+    process.exit(0);
+  });
+  cmd.command("restore <name>").description("Bring an archived learned skill back, active.").action(async (name) => {
+    const { restore } = await import("../core/skill-curator.js");
+    try {
+      const e = restore(await repoOf(), name);
+      console.log(`\u2713 restored ${name} \u2192 ${e.files[0].path} (ledger ${e.id}). Pin it (skill_loop.pinned: true) to keep the curator away.`);
+    } catch (err) {
+      console.error(`\u2717 ${err.message}`);
+      process.exit(1);
+    }
+    process.exit(0);
+  });
+  cmd.command("verify").description("Run each landed learned skill's ## Verify command here; failures are flagged, nothing is archived.").action(async () => {
+    const { verifySkills } = await import("../core/skill-curator.js");
+    const r = verifySkills(await repoOf());
+    for (const x of r) console.log(`${x.result === "pass" ? "\u2713" : x.result === "fail" ? "\u2717" : "\xB7"} ${x.skill}: ${x.result} \u2014 ${x.detail}`);
+    if (!r.length) console.log("no learned skills here");
+    process.exit(r.some((x) => x.result === "fail") ? 1 : 0);
+  });
+}
+async function skillLoopStatus(cwd) {
+  const { repoRoot } = await import("../core/skill-evidence.js");
+  const { listDrafts } = await import("../core/skill-review.js");
+  const { runsToday, dailyRunCap, pendingJobs, lockHolder } = await import("../core/skill-queue.js");
+  const repo = repoRoot(cwd);
+  const lines = [
+    `drafts waiting: ${listDrafts(repo).length}${listDrafts(repo).length ? " (/skill-loop review)" : ""}`,
+    `queued sessions for this repo: ${pendingJobs(repo).length}${lockHolder(repo) ? ` (worker running, pid ${lockHolder(repo)})` : ""}`,
+    `reviews today (all repos): ${runsToday()} of ${dailyRunCap()} (SEMANTIC_MEMORY_SKILL_LOOP_DAILY_RUNS)`
+  ];
+  const { curatorState } = await import("../core/skill-curator.js");
+  const st = curatorState(repo);
+  lines.push(`curator: ${st.last_run ? `last run ${st.last_run.slice(0, 16)} \u2014 ${st.last_report}` : "not run yet (first run 7 days after the loop first sees a repo)"}`);
+  if (st.flagged?.length) lines.push(`verify failures flagged: ${st.flagged.map((f) => f.name).join(", ")}`);
+  return lines;
+}
+
+// src/cli/skill-eval.ts
+import { readFileSync } from "fs";
+import { resolve as resolve3 } from "path";
+var pct = (n) => n === null ? "n/a" : `${Math.round(n * 100)}%`;
+function load(file, promptsFile) {
+  const skillRaw = readFileSync(resolve3(file), "utf8");
+  const candidates = readFileSync(resolve3(promptsFile), "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l));
+  return { skillRaw, prompts: buildEvalSet(parseSkill(skillRaw), candidates) };
+}
+var out = (json, data, text) => console.log(json ? JSON.stringify(data, null, 2) : text());
+function registerSkillEvalCommands(program2) {
+  const ev = program2.command("skill-eval").description("Evaluate a learned skill: does it trigger, does it help, can its description be better (v1.7)");
+  const repoRoot = process.cwd();
+  const fail = (e) => {
+    console.error(`\u2717 ${e.message}`);
+    process.exit(1);
+  };
+  ev.command("trigger <skill-md>").description("Run the trigger eval; --prompts is JSONL of {session, text}").requiredOption("--prompts <jsonl>", "candidate prompts, one {session, text} per line").option("--json", "machine-readable output").action(async (file, opts) => {
+    try {
+      const { skillRaw, prompts } = load(file, opts.prompts);
+      const r = await runTrigger(prompts, { repoRoot, skillRaw });
+      out(
+        opts.json,
+        r,
+        () => [
+          `${r.skill}: ${prompts.length} prompts, ${r.runs} claude run(s)`,
+          ...["train", "heldout"].map((s) => `  ${s}: triggers on ${pct(r[s].positiveRate)} of positives, false-triggers on ${pct(r[s].falseTriggerRate)} of near-misses (n=${r[s].n})`)
+        ].join("\n")
+      );
+    } catch (e) {
+      fail(e);
+    }
+  });
+  ev.command("task <skill-md>").description("Replay a task with and without the skill and check its ## Verify").requiredOption("--prompt <text>", "the task prompt").option("--json", "machine-readable output").action(async (file, opts) => {
+    try {
+      const r = await runTaskEval({ repoRoot, skillRaw: readFileSync(resolve3(file), "utf8"), prompt: opts.prompt });
+      out(opts.json, r, () => `${r.skill}: with skill ${r.with.passed ? "PASS" : "FAIL"} (${r.with.evidence}); without ${r.without.passed ? "PASS" : "FAIL"} (${r.without.evidence})`);
+    } catch (e) {
+      fail(e);
+    }
+  });
+  ev.command("tune <skill-md>").description("Propose a better description (never writes the skill file)").requiredOption("--prompts <jsonl>", "candidate prompts, one {session, text} per line").option("--json", "machine-readable output").action(async (file, opts) => {
+    try {
+      const { skillRaw, prompts } = load(file, opts.prompts);
+      const r = await tuneDescription({ repoRoot, skillRaw, prompts });
+      out(
+        opts.json,
+        r,
+        () => r.improved ? `proposed (held-out ${pct(r.original.heldout)} -> ${pct(r.best.heldout)}):
+${r.best.description}` : `no better description found (held-out ${pct(r.original.heldout)}); ${r.candidates.length - 1} tried`
+      );
+    } catch (e) {
+      fail(e);
+    }
+  });
+}
+
 // src/cli/index.ts
 var require_ = createRequire(import.meta.url);
 var { version } = require_("../../package.json");
@@ -314,7 +572,7 @@ function runRelink(cwd) {
   const candidates = [
     join3(cwd, "node_modules", "@theglitchking", "semantic-memory", "scripts", "link-skills.js"),
     join3(cwd, "node_modules", "@theglitchking", "semantic-sidekick", "scripts", "link-skills.js"),
-    resolve2(process.cwd(), "scripts", "link-skills.js")
+    resolve4(process.cwd(), "scripts", "link-skills.js")
   ];
   const script = candidates.find((p) => existsSync3(p));
   if (!script) {
@@ -400,7 +658,7 @@ function localBinArg(cwd) {
 }
 function readJsonSafe(path) {
   try {
-    const raw = readFileSync(path, "utf8");
+    const raw = readFileSync2(path, "utf8");
     return raw.trim() ? JSON.parse(raw) : null;
   } catch {
     return null;
@@ -636,38 +894,81 @@ program.command("search <query>").description("Run a vault search and print top
     process.exit(1);
   }
 });
-program.command("eval-failures").description("Replay failed tool calls through search and measure how often the top hit answers them (v1.6 failure lookup)").requiredOption("--cases <file>", "JSONL of {id, notes, error, command}").requiredOption("--judgments <file>", "JSONL of {case, path, relevant}").option("--limit <n>", "Hits per search", (v) => parseInt(v, 10), 5).option("--query <mode>", "raw (error + command as-is) or normalized (failureQuery)", "normalized").option("--target <p>", "Target precision for the recommended threshold", (v) => parseFloat(v), 0.95).option("--min-judged <n>", "Judged injections needed before a threshold can be recommended", (v) => parseInt(v, 10), 20).option("--unjudged-out <file>", "Write unlabelled top hits here (JSONL) for labelling").option("--hits-out <file>", "Write every case's hits here (JSONL) for analysis").option("--json", "Print the report as JSON").action(async (opts) => {
+program.command("eval-failures").description("Replay failed tool calls through search and measure how often the top hit answers them (v1.6 failure lookup)").requiredOption("--cases <file>", "JSONL of {id, notes, error, command}").requiredOption("--judgments <file>", "JSONL of {case, path, relevant}").option("--limit <n>", "Hits per search", (v) => parseInt(v, 10), 5).option("--query <mode>", "raw (error + command as-is) or normalized (failureQuery)", "normalized").option("--target <p>", "Target precision for the recommended threshold", (v) => parseFloat(v), 0.95).option("--min-judged <n>", "Judged injections needed before a threshold can be recommended", (v) => parseInt(v, 10), 20).option("--unjudged-out <file>", "Write unlabelled top hits here (JSONL) for labelling").option("--hits-out <file>", "Write every case's hits here (JSONL) for analysis").option("--json", "Print the report as JSON").option("--hits-in <file>", "Reuse hits from an earlier --hits-out instead of searching").option("--gate <kind>", "Also replay the failure hook's gate: 'jev' (needs --jev-scores)").option("--jev-scores <files...>", "JSONL of {case, path, p} from scripts/eval-failures/judge-jev.mjs").option("--gate-batch-out <file>", "With --gate jev: write the candidates Jev has not scored as a judge batch (set B format)").action(async (opts) => {
   const { openSearch } = await import("../search-325ULY57.js");
-  const { evaluateFailures, formatFailureEval } = await import("../failure-eval-37JRNTIW.js");
+  const { evaluateFailures, formatFailureEval } = await import("../failure-eval-IUJO47UC.js");
   const { failureQuery } = await import("../core/failure-query.js");
   const toQuery = (c) => opts.query === "raw" ? `${c.error}
 ${c.command}` : failureQuery(c.error, c.command);
-  const readJsonl = (p) => readFileSync(resolve2(p), "utf-8").split("\n").filter(Boolean).map((l) => JSON.parse(l));
+  const readJsonl = (p) => readFileSync2(resolve4(p), "utf-8").split("\n").filter(Boolean).map((l) => JSON.parse(l));
   const cases = readJsonl(opts.cases);
   const judgments = readJsonl(opts.judgments);
   const searchers = /* @__PURE__ */ new Map();
   const results = [];
-  for (const c of cases) {
-    if (!searchers.has(c.notes)) searchers.set(c.notes, await openSearch(c.notes));
-    const hits = await searchers.get(c.notes).search(toQuery(c), opts.limit);
-    results.push({ case: c.id, hits: hits.map((h) => ({ path: h.path, score: h.score })) });
+  if (opts.hitsIn) {
+    const ids = new Set(cases.map((c) => c.id));
+    results.push(...readJsonl(opts.hitsIn).filter((r) => ids.has(r.case)));
+  } else {
+    for (const c of cases) {
+      if (!searchers.has(c.notes)) searchers.set(c.notes, await openSearch(c.notes));
+      const hits = await searchers.get(c.notes).search(toQuery(c), opts.limit);
+      results.push({ case: c.id, hits: hits.map((h) => ({ path: h.path, score: h.score })) });
+    }
   }
   const report = evaluateFailures(results, judgments, { targetPrecision: opts.target, minJudged: opts.minJudged });
+  if (opts.gate) {
+    if (opts.gate !== "jev" || !opts.jevScores) {
+      console.error("--gate jev needs --jev-scores <file...>");
+      process.exit(2);
+    }
+    const { evaluateGate, formatGate } = await import("../failure-eval-IUJO47UC.js");
+    const jev = opts.jevScores.flatMap((f) => readJsonl(f));
+    const gate = evaluateGate(results, judgments, jev);
+    const veto = evaluateGate(results, judgments, jev, { mode: "veto", thresholds: [0.3, 0.35, 0.4, 0.45, 0.5] });
+    if (opts.gateBatchOut) {
+      const { default: matter } = await import("../matter-SNJ2WDL6.js");
+      const byId = new Map(cases.map((c) => [c.id, c]));
+      const missing = [...new Map([...gate.missing, ...veto.missing].map((m) => [`${m.case}\0${m.path}`, m])).values()];
+      const batch = missing.map((m) => {
+        const c = byId.get(m.case);
+        let title = m.path, excerpt = "";
+        try {
+          const doc = matter(readFileSync2(join3(c.notes, m.path), "utf-8"));
+          title = String(doc.data.title ?? m.path);
+          excerpt = doc.content.replace(/^#.*$/m, "").trim().slice(0, 600);
+        } catch {
+        }
+        return { case: m.case, path: m.path, command: c.command, error: c.error, doc_title: title, doc_excerpt: excerpt };
+      });
+      writeFileSync(resolve4(opts.gateBatchOut), JSON.stringify(batch, null, 1));
+      console.error(`${batch.length} unscored candidates \u2192 ${opts.gateBatchOut} (judge them with judge-jev.mjs, then re-run)`);
+    }
+    if (opts.json) {
+      console.log(JSON.stringify({ ...report, gate: gate.rows, veto: veto.rows }, null, 2));
+      process.exit(0);
+    }
+    console.log(formatFailureEval(report, `query: ${opts.query}`));
+    console.log("");
+    console.log(formatGate(gate.rows));
+    console.log("");
+    console.log(formatGate(veto.rows, "veto"));
+    process.exit(0);
+  }
   if (opts.hitsOut) {
-    writeFileSync(resolve2(opts.hitsOut), results.map((r) => JSON.stringify(r)).join("\n") + "\n");
+    writeFileSync(resolve4(opts.hitsOut), results.map((r) => JSON.stringify(r)).join("\n") + "\n");
   }
   if (opts.unjudgedOut) {
-    writeFileSync(resolve2(opts.unjudgedOut), report.unjudged.map((u) => JSON.stringify(u)).join("\n") + "\n");
+    writeFileSync(resolve4(opts.unjudgedOut), report.unjudged.map((u) => JSON.stringify(u)).join("\n") + "\n");
   }
   console.log(opts.json ? JSON.stringify(report, null, 2) : formatFailureEval(report, `query: ${opts.query}`));
   process.exit(0);
 });
 program.command("lint").description("Lint the vault against vault.schema.yml (schema violations + missing provenance + stale)").requiredOption("--notes <path>", "Path to markdown notes directory").option("--rule <name>", "Limit output to one rule: schema_violations | missing_provenance | stale").option("--json", "Emit JSON instead of the human-readable report").option("--strict", "Exit non-zero on warnings too (default: exit non-zero only on errors)").action(async (opts) => {
-  const { lintVault, formatLintReport } = await import("../lint-O4RQ47NX.js");
-  const report = await lintVault(resolve2(opts.notes));
+  const { lintVault, formatLintReport } = await import("../lint-3JNLRM5U.js");
+  const report = await lintVault(resolve4(opts.notes));
   if (opts.json) {
-    const out = opts.rule ? report.byRule[opts.rule] : report;
-    console.log(JSON.stringify(out, null, 2));
+    const out2 = opts.rule ? report.byRule[opts.rule] : report;
+    console.log(JSON.stringify(out2, null, 2));
   } else {
     console.log(formatLintReport(report, { rule: opts.rule }));
   }
@@ -687,7 +988,7 @@ program.command("log-event").description("Append a structured event to the vault
     }
   }
   try {
-    const entry = await logEvent(resolve2(opts.notes), {
+    const entry = await logEvent(resolve4(opts.notes), {
       kind: opts.kind,
       summary: opts.summary,
       payload
@@ -701,7 +1002,7 @@ program.command("log-event").description("Append a structured event to the vault
 program.command("log-query").description("Read structured log entries from log.md \u2014 filters by kind, date range, limit").requiredOption("--notes <path>", "Path to markdown notes directory").option("--kind <name>", "Filter by kind (ingest, synthesis, error, mode_change, etc.)").option("--after <iso>", "ISO timestamp \u2014 only entries on or after").option("--before <iso>", "ISO timestamp \u2014 only entries on or before").option("--limit <n>", "Max entries (most recent)", (v) => parseInt(v, 10)).action(async (opts) => {
   const { logQuery } = await import("../log-RM2NDNPH.js");
   try {
-    const entries = await logQuery(resolve2(opts.notes), {
+    const entries = await logQuery(resolve4(opts.notes), {
       kind: opts.kind,
       after: opts.after,
       before: opts.before,
@@ -714,8 +1015,8 @@ program.command("log-query").description("Read structured log entries from log.m
   }
 });
 program.command("install-schema").description("Bootstrap vault.schema.yml in the vault root with the default schema").requiredOption("--notes <path>", "Path to markdown notes directory").option("--force", "Overwrite existing schema file").action(async (opts) => {
-  const { installDefaultSchema } = await import("../schema-UJNYYRZZ.js");
-  const r = await installDefaultSchema(resolve2(opts.notes), opts.force);
+  const { installDefaultSchema } = await import("../schema-RDYUK6CC.js");
+  const r = await installDefaultSchema(resolve4(opts.notes), opts.force);
   console.log(r.written ? `Installed default schema: ${r.path}` : `Schema already exists: ${r.path} (use --force to overwrite)`);
   process.exit(0);
 });
@@ -728,7 +1029,7 @@ program.command("tools [name]").description("List all MCP tools, or show details
   process.exit(0);
 });
 program.command("serve", { isDefault: true }).description("Start the MCP server (default command)").requiredOption("--notes <path>", "Path to markdown notes directory").option("--reindex", "Force full reindex and exit").option("--stats", "Show vault statistics and exit").option("--wait-for-ready", "Block startup until index is fully built before serving (default: index in background; tools return 'Indexing in progress' until ready)").option("--read-only", "Suppress write tools (create_note, update_note, delete_note, move_note, update_frontmatter, manage_tags, rename_tag, log_event, ...) \u2014 use for shared docs vaults owned by another tool").option("--model <name>", "Embedding model to use (default: all-MiniLM-L6-v2, fast; use nomic-ai/nomic-embed-text-v1.5 for higher quality)").option("--workers <n>", "Number of worker threads for parallel embedding", parseInt).option("--batch-size <n>", "Texts per ONNX forward pass (default: 8)", parseInt).option("--no-quantized", "Use full-precision model instead of quantized (slower, slightly higher quality)").option("--no-watch", "Disable file watcher").action(async (opts) => {
-  const notesPath = resolve2(opts.notes);
+  const notesPath = resolve4(opts.notes);
   if (!existsSync3(notesPath)) {
     console.error(`Error: notes directory not found: ${notesPath}`);
     process.exit(1);
@@ -824,7 +1125,7 @@ run 'npm install --save @theglitchking/semantic-memory' first, then re-run this
   }
   const bakPath = join3(dirname(mcpPath), ".mcp.json.bak");
   try {
-    writeFileSync(bakPath, readFileSync(mcpPath, "utf8"));
+    writeFileSync(bakPath, readFileSync2(mcpPath, "utf8"));
     console.log(`backup written: ${bakPath}`);
   } catch (err) {
     console.error(`could not write backup: ${err.message}`);
@@ -836,7 +1137,7 @@ run 'npm install --save @theglitchking/semantic-memory' first, then re-run this
     console.error(`verification failed (exit ${verify.status}):
 ${verify.stderr?.toString() || ""}`);
     console.error(`rolling back from ${bakPath}`);
-    writeFileSync(mcpPath, readFileSync(bakPath, "utf8"));
+    writeFileSync(mcpPath, readFileSync2(bakPath, "utf8"));
     process.exit(1);
   }
   console.log(`\u2713 .mcp.json normalized and verified. Toggle the MCPs in /mcp to reconnect.`);
@@ -895,7 +1196,7 @@ ${r2.stderr?.toString() || ""}`);
     }
   }
   if (smokeOk && !opts.json) console.log(`\u2713 local install starts cleanly (v${smokeVersion})`);
-  const { runHealthcheck, formatDriftBanner, filterToDrift } = await import("../healthcheck-53OVXUQQ.js");
+  const { runHealthcheck, formatDriftBanner, filterToDrift } = await import("../healthcheck-S7D6YNTA.js");
   const vaultCandidate = join3(cwd, ".claude", ".vault");
   const vaultPath = existsSync3(vaultCandidate) ? vaultCandidate : void 0;
   let result = await runHealthcheck({ projectRoot: cwd, vaultPath, tier: opts.fast ? "fast" : "all", force: true });
@@ -909,7 +1210,8 @@ ${r2.stderr?.toString() || ""}`);
     }
   }
   if (opts.json) {
-    console.log(JSON.stringify({ smoke: { ok: smokeOk, version: smokeVersion }, result, fix: opts.fix ? { plan, outcomes: fixOutcomes } : void 0 }, null, 2));
+    const features = { skill_loop: featureState("skill_loop", cwd), jev: featureState("jev", cwd) };
+    console.log(JSON.stringify({ smoke: { ok: smokeOk, version: smokeVersion }, result, features, fix: opts.fix ? { plan, outcomes: fixOutcomes } : void 0 }, null, 2));
   } else {
     if (opts.fix) {
       if (fixOutcomes.length === 0 && plan.skipped.length === 0) {
@@ -930,6 +1232,9 @@ ${r2.stderr?.toString() || ""}`);
       console.log(`
 \u2713 no drift detected (${result.findings.length} checks ran in ${result.duration_ms}ms)`);
     }
+    console.log(`
+${describeFeature(featureState("skill_loop", cwd))}
+${describeFeature(featureState("jev", cwd))}`);
   }
   process.exit(smokeOk ? 0 : 1);
 });
@@ -953,15 +1258,15 @@ function findSourceRoot() {
     const installed = join3(process.cwd(), "node_modules", "@theglitchking", pkg);
     if (existsSync3(installed)) return installed;
   }
-  const dev = resolve2(new URL("../../", import.meta.url).pathname);
+  const dev = resolve4(new URL("../../", import.meta.url).pathname);
   return dev;
 }
 var skillsCmd = program.command("skills").description("Install, target, or uninstall skill bundles for non-Claude agents (codex, copilot, pi). Claude installs continue to use the npm postinstall flow.");
 skillsCmd.command("targets").description("Preview where skill bundles would be installed for one or more agents.").option("--agent <name...>", "One or more agents (default: all). Repeatable.", void 0).option("--scope <scope>", "global or local (default: local)", "local").option("--project <path>", "Project root for local-scope paths (default: cwd)", process.cwd()).action((opts) => {
   const scope = parseScope(opts.scope);
   const agents = (opts.agent && opts.agent.length > 0 ? opts.agent : SKILL_BUNDLER_AGENTS).map(parseAgent);
-  const out = agents.map((a) => resolveTarget(a, scope, opts.project));
-  console.log(JSON.stringify(out, null, 2));
+  const out2 = agents.map((a) => resolveTarget(a, scope, opts.project));
+  console.log(JSON.stringify(out2, null, 2));
 });
 skillsCmd.command("install").description("Install skill bundles into an agent's skill directory. Non-destructive by default; --force to overwrite.").requiredOption("--agent <name>", "Agent runtime (claude, codex, copilot, pi)").option("--scope <scope>", "global or local (default: local)", "local").option("--project <path>", "Project root for local-scope paths (default: cwd)", process.cwd()).option("--only <names...>", "Restrict to specific skill names (default: all shipped)").option("--force", "Overwrite even if drift is detected against an existing manifest", false).action(async (opts) => {
   const agent = parseAgent(opts.agent);
@@ -1023,7 +1328,7 @@ ${result.conflicts.length} conflict${result.conflicts.length === 1 ? "" : "s"} d
 });
 program.command("decay-config").description("Print the active confidence-decay config (shipped defaults + any vault.schema.yml override).").requiredOption("--notes <path>", "Path to markdown notes directory").action(async (opts) => {
   const { loadDecayConfig, DEFAULT_DECAY_CONFIG } = await import("../decay-ELJUKVQG.js");
-  const cfg = loadDecayConfig(resolve2(opts.notes));
+  const cfg = loadDecayConfig(resolve4(opts.notes));
   const source = JSON.stringify(cfg) === JSON.stringify(DEFAULT_DECAY_CONFIG) ? "defaults" : "vault.schema.yml (overridden)";
   console.log(JSON.stringify({ source, config: cfg }, null, 2));
   process.exit(0);
@@ -1031,18 +1336,18 @@ program.command("decay-config").description("Print the active confidence-decay c
 program.command("decay-trace <notePath>").description("Show the decay calculation for one note: type, last_verified, age, half-life, evergreen, multiplier.").requiredOption("--notes <path>", "Path to markdown notes directory").action(async (notePath, opts) => {
   const { loadDecayConfig, computeDecay, normalizeVerifiedDate } = await import("../decay-ELJUKVQG.js");
   const matter = (await import("../matter-SNJ2WDL6.js")).default;
-  const abs = resolve2(opts.notes, notePath);
+  const abs = resolve4(opts.notes, notePath);
   if (!existsSync3(abs)) {
     console.error(`note not found: ${abs}`);
     process.exit(1);
   }
-  const { data: fm } = matter(readFileSync(abs, "utf8"));
+  const { data: fm } = matter(readFileSync2(abs, "utf8"));
   const lastVerified = normalizeVerifiedDate(fm.last_verified);
   const d = computeDecay({
     type: typeof fm.type === "string" ? fm.type : void 0,
     last_verified: lastVerified,
     evergreen: fm.evergreen === true,
-    config: loadDecayConfig(resolve2(opts.notes))
+    config: loadDecayConfig(resolve4(opts.notes))
   });
   console.log(
     JSON.stringify(
@@ -1064,55 +1369,55 @@ program.command("decay-trace <notePath>").description("Show the decay calculatio
 });
 var lexiconCmd = program.command("lexicon").description("Manage the learned human\u2192artifact lexicon (aliases).");
 lexiconCmd.command("list").description("List all aliases in the lexicon.").requiredOption("--notes <path>", "Path to markdown notes directory").action(async (opts) => {
-  const { loadLexiconCache } = await import("../lexicon-XNA5IFIA.js");
-  console.log(JSON.stringify(await loadLexiconCache(resolve2(opts.notes)), null, 2));
+  const { loadLexiconCache } = await import("../lexicon-SEJSLBHO.js");
+  console.log(JSON.stringify(await loadLexiconCache(resolve4(opts.notes)), null, 2));
   process.exit(0);
 });
 lexiconCmd.command("compile").description("Rebuild the derived lexicon cache from the lexicon/ notes.").requiredOption("--notes <path>", "Path to markdown notes directory").action(async (opts) => {
-  const { compileLexicon } = await import("../lexicon-XNA5IFIA.js");
-  const entries = await compileLexicon(resolve2(opts.notes));
+  const { compileLexicon } = await import("../lexicon-SEJSLBHO.js");
+  const entries = await compileLexicon(resolve4(opts.notes));
   console.log(`compiled ${entries.length} alias(es)`);
   process.exit(0);
 });
 lexiconCmd.command("add <canonical> <phrases...>").description("Upsert an alias: a canonical target and the human phrases that refer to it.").requiredOption("--notes <path>", "Path to markdown notes directory").option("--authored", "Mark as human-authored (default: learned)").action(async (canonical, phrases, opts) => {
-  const { addAlias } = await import("../lexicon-XNA5IFIA.js");
-  const r = await addAlias(resolve2(opts.notes), { canonical, phrases, source: opts.authored ? "authored" : "learned" });
+  const { addAlias } = await import("../lexicon-SEJSLBHO.js");
+  const r = await addAlias(resolve4(opts.notes), { canonical, phrases, source: opts.authored ? "authored" : "learned" });
   console.log(JSON.stringify(r, null, 2));
   process.exit(0);
 });
 var dossierCmd = program.command("dossier").description("Manage entity dossiers \u2014 per-component living notes (purpose / failure modes / knobs / incident log / current state).");
 dossierCmd.command("init <entity>").description("Scaffold a dossier for an entity (no-op if one already exists). Optionally seed aliases and provenance.").requiredOption("--notes <path>", "Path to markdown notes directory").option("--alias <phrase...>", "Human phrase(s) for this entity \u2014 fed to the lexicon compiler").option("--seeded-from <ref>", "Provenance of the scaffold (e.g. a babel-fish project-map entry)").action(async (entity, opts) => {
-  const { initDossier } = await import("../dossier-EN26WDKC.js");
-  const r = await initDossier(resolve2(opts.notes), entity, { aliases: opts.alias, seeded_from: opts.seededFrom });
+  const { initDossier } = await import("../dossier-RXBLQOXC.js");
+  const r = await initDossier(resolve4(opts.notes), entity, { aliases: opts.alias, seeded_from: opts.seededFrom });
   console.log(JSON.stringify(r, null, 2));
   process.exit(0);
 });
 dossierCmd.command("list").description("List all dossiers with their entity, aliases, and current state.").requiredOption("--notes <path>", "Path to markdown notes directory").action(async (opts) => {
-  const { listDossiers } = await import("../dossier-EN26WDKC.js");
-  console.log(JSON.stringify(await listDossiers(resolve2(opts.notes)), null, 2));
+  const { listDossiers } = await import("../dossier-RXBLQOXC.js");
+  console.log(JSON.stringify(await listDossiers(resolve4(opts.notes)), null, 2));
   process.exit(0);
 });
 var profileCmd = program.command("profile").description("Manage the speaker profile \u2014 how THIS human communicates (severity calibration, chronic omissions, verbosity, shorthand).");
 profileCmd.command("init").description("Scaffold profile/speaker.md with the fixed sections (no-op if it exists).").requiredOption("--notes <path>", "Path to markdown notes directory").action(async (opts) => {
-  const { initSpeakerProfile } = await import("../profile-SIWAVD7O.js");
-  const r = await initSpeakerProfile(resolve2(opts.notes));
+  const { initSpeakerProfile } = await import("../profile-SNULTJ27.js");
+  const r = await initSpeakerProfile(resolve4(opts.notes));
   console.log(JSON.stringify(r, null, 2));
   process.exit(0);
 });
 profileCmd.command("show").description("Print the speaker profile's injection head (the capped, placeholder-stripped view).").requiredOption("--notes <path>", "Path to markdown notes directory").action(async (opts) => {
-  const { readSpeakerProfile } = await import("../profile-SIWAVD7O.js");
-  const p = await readSpeakerProfile(resolve2(opts.notes));
+  const { readSpeakerProfile } = await import("../profile-SNULTJ27.js");
+  const p = await readSpeakerProfile(resolve4(opts.notes));
   console.log(p ? p.head || "(profile is empty \u2014 only placeholders)" : "(no speaker profile \u2014 run `profile init`)");
   process.exit(0);
 });
 program.command("selection-stats").description("Summarize the local selection log: searches, selections, most-cited notes, and retrieved-but-never-cited notes.").requiredOption("--notes <path>", "Path to markdown notes directory").option("--json", "Emit raw JSON instead of a human summary").action(async (opts) => {
   const { computeSelectionStats, selectionLogPath } = await import("../telemetry-YAG3VA4Y.js");
-  const stats = await computeSelectionStats(resolve2(opts.notes));
+  const stats = await computeSelectionStats(resolve4(opts.notes));
   if (opts.json) {
     console.log(JSON.stringify(stats, null, 2));
     process.exit(0);
   }
-  console.log(`Selection log: ${selectionLogPath(resolve2(opts.notes))}`);
+  console.log(`Selection log: ${selectionLogPath(resolve4(opts.notes))}`);
   console.log(`  searches:   ${stats.searches}`);
   console.log(`  selections: ${stats.selections}`);
   const topCited = Object.entries(stats.citedPaths).sort((a, b) => b[1] - a[1]).slice(0, 10);
@@ -1125,5 +1430,29 @@ program.command("selection-stats").description("Summarize the local selection lo
   }
   process.exit(0);
 });
+skillsCmd.command("lint").description("Lint the skill loop's learned skills this repo loads (v1.7): format, description, evidence, sections, cites, applies_to, secrets, name clashes.").option("--root <dir>", "Repo root (default: cwd)").option("--json", "JSON output").action(async (opts) => {
+  const { lintSkills } = await import("../skill-schema-RVB3EHEF.js");
+  const root = resolve4(opts.root ?? process.cwd());
+  const r = lintSkills(root);
+  if (opts.json) console.log(JSON.stringify(r, null, 2));
+  else {
+    for (const f of r.findings) console.log(`${f.severity === "error" ? "\u2717" : "!"} ${relative(root, f.path)}: ${f.rule}: ${f.message}`);
+    const errors = r.findings.filter((f) => f.severity === "error").length;
+    console.log(`${r.files} learned skill(s), ${errors} error(s), ${r.findings.length - errors} warning(s)`);
+  }
+  process.exit(r.findings.some((f) => f.severity === "error") ? 1 : 0);
+});
+registerFeatureCommands(program, {
+  skill_loop: skillLoopStatus,
+  jev: async () => {
+    const { jevSpendToday } = await import("../core/jev.js");
+    const { jevLoopDir } = await import("../core/features.js");
+    const spend = jevSpendToday(jevLoopDir());
+    const total = Object.values(spend).reduce((a, b) => a + b, 0);
+    return [`Jev today (semantic-memory callers): ${total.toLocaleString()} tokens${total ? ` \u2014 ${Object.entries(spend).map(([c, n]) => `${c} ${n.toLocaleString()}`).join(", ")}` : ""}`];
+  }
+});
+registerSkillLoopCommands(program);
+registerSkillEvalCommands(program);
 program.parse();
 //# sourceMappingURL=index.js.map