@theglitchking/semantic-memory 1.6.1 → 1.7.0

package/dist/chunk-NIZLBNH4.js

@@ -0,0 +1,165 @@
+import {
+  readEvidence,
+  stateDir
+} from "./chunk-R6GNP7DS.js";
+
+// src/core/skill-queue.ts
+import { appendFileSync, existsSync, mkdirSync, openSync, writeSync, closeSync, readFileSync, readdirSync, renameSync, unlinkSync, writeFileSync, statSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var smHome = (env = process.env) => env.SEMANTIC_MEMORY_STATE_HOME || join(env.HOME || homedir(), ".semantic-memory");
+var queueDir = (env = process.env) => join(smHome(env), "review-queue");
+var runsPath = (env = process.env) => join(smHome(env), "skill-loop-runs.jsonl");
+var lockPath = (repo) => join(stateDir(repo), "skill-loop.lock");
+var logPath = (repo) => join(stateDir(repo), "skill-loop.log");
+var dailyRunCap = (env = process.env) => Math.max(0, Number(env.SEMANTIC_MEMORY_SKILL_LOOP_DAILY_RUNS ?? 10) || 0);
+var minToolCalls = (env = process.env) => Number(env.SEMANTIC_MEMORY_SKILL_LOOP_MIN_TOOL_CALLS) || 20;
+var TRANSCRIPT_SCAN_MAX = 50 * 1024 * 1024;
+var safeName = (s) => s.replace(/[^A-Za-z0-9_.-]/g, "_").slice(0, 120);
+function countToolCalls(transcript) {
+  if (!transcript) return 0;
+  try {
+    if (statSync(transcript).size > TRANSCRIPT_SCAN_MAX) return 0;
+    return readFileSync(transcript, "utf8").split('"type":"tool_use"').length - 1;
+  } catch {
+    return 0;
+  }
+}
+function sessionJob(repo, input, env = process.env) {
+  const session_id = typeof input.session_id === "string" ? input.session_id : "";
+  if (!session_id) return null;
+  const failures = readEvidence(repo, "failures").filter((f) => f.session_id === session_id);
+  const corrections = readEvidence(repo, "corrections").filter((c) => c.session_id === session_id).length;
+  const skills_used = [...new Set(readEvidence(repo, "usage").filter((u) => u.session_id === session_id).map((u) => String(u.skill)))];
+  const transcript_path = typeof input.transcript_path === "string" ? input.transcript_path : null;
+  const tool_calls = failures.length || corrections ? 0 : countToolCalls(transcript_path);
+  const why = failures.length ? `${failures.length} failure(s)` : corrections ? `${corrections} correction(s)` : tool_calls >= minToolCalls(env) ? `${tool_calls} tool calls` : "";
+  if (!why) return null;
+  return {
+    session_id,
+    repo,
+    transcript_path,
+    reason: `${why}; ended: ${input.reason ?? "unknown"}`,
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    evidence: { failures: failures.map((f) => String(f.id ?? "")).filter(Boolean), corrections, skills_used, tool_calls }
+  };
+}
+function enqueue(job, env = process.env) {
+  mkdirSync(queueDir(env), { recursive: true });
+  const path = join(queueDir(env), `${safeName(job.session_id)}.json`);
+  if (["done", "failed"].some((d) => existsSync(join(queueDir(env), d, `${safeName(job.session_id)}.json`)))) return path;
+  writeFileSync(path, JSON.stringify(job, null, 1));
+  return path;
+}
+function pendingJobs(repo, env = process.env) {
+  let files = [];
+  try {
+    files = readdirSync(queueDir(env)).filter((f) => f.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  const jobs = [];
+  for (const f of files) {
+    try {
+      const path = join(queueDir(env), f);
+      const job = JSON.parse(readFileSync(path, "utf8"));
+      if (job.repo === repo) jobs.push({ path, job });
+    } catch {
+    }
+  }
+  return jobs.sort((a, b) => a.job.ts.localeCompare(b.job.ts));
+}
+function finishJob(path, outcome, result, env = process.env) {
+  const dir = join(queueDir(env), outcome);
+  mkdirSync(dir, { recursive: true });
+  const job = JSON.parse(readFileSync(path, "utf8"));
+  writeFileSync(path, JSON.stringify({ ...job, finished: (/* @__PURE__ */ new Date()).toISOString(), result }, null, 1));
+  renameSync(path, join(dir, path.split("/").pop()));
+}
+function bumpAttempts(path) {
+  const job = JSON.parse(readFileSync(path, "utf8"));
+  job.attempts = (job.attempts ?? 0) + 1;
+  writeFileSync(path, JSON.stringify(job, null, 1));
+  return job.attempts;
+}
+var localDay = (d = /* @__PURE__ */ new Date()) => `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+function runsToday(env = process.env, now = /* @__PURE__ */ new Date()) {
+  try {
+    const day = localDay(now);
+    return readFileSync(runsPath(env), "utf8").split("\n").filter((l) => l.includes(`"day":"${day}"`)).length;
+  } catch {
+    return 0;
+  }
+}
+function recordRun(repo, session_id, env = process.env, now = /* @__PURE__ */ new Date()) {
+  mkdirSync(smHome(env), { recursive: true });
+  appendFileSync(runsPath(env), JSON.stringify({ day: localDay(now), ts: now.toISOString(), repo, session_id }) + "\n");
+}
+var alive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+};
+function lockHolder(repo) {
+  try {
+    const pid = Number(readFileSync(lockPath(repo), "utf8").trim());
+    return pid && alive(pid) ? pid : null;
+  } catch {
+    return null;
+  }
+}
+function takeLock(repo) {
+  mkdirSync(stateDir(repo), { recursive: true });
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const fd = openSync(lockPath(repo), "wx");
+      writeSync(fd, `${process.pid}
+`);
+      closeSync(fd);
+      return () => {
+        try {
+          if (Number(readFileSync(lockPath(repo), "utf8").trim()) === process.pid) unlinkSync(lockPath(repo));
+        } catch {
+        }
+      };
+    } catch (e) {
+      if (e.code !== "EEXIST") throw e;
+      if (lockHolder(repo) !== null) return null;
+      try {
+        unlinkSync(lockPath(repo));
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function log(repo, line) {
+  try {
+    mkdirSync(stateDir(repo), { recursive: true });
+    appendFileSync(logPath(repo), `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
+`);
+  } catch {
+  }
+}
+
+export {
+  smHome,
+  queueDir,
+  lockPath,
+  logPath,
+  dailyRunCap,
+  sessionJob,
+  enqueue,
+  pendingJobs,
+  finishJob,
+  bumpAttempts,
+  runsToday,
+  recordRun,
+  lockHolder,
+  takeLock,
+  log
+};
+//# sourceMappingURL=chunk-NIZLBNH4.js.map

package/dist/chunk-NIZLBNH4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/skill-queue.ts"],"sourcesContent":["/**\n * The skill loop's review queue (v1.7). SessionEnd writes one job per session that has signal and starts\n * the worker detached; the worker drains this repo's jobs oldest first, inside a global daily cap. The\n * session never waits: SessionEnd hooks get 1.5 s by default, so the hook only writes and spawns.\n *\n *   ~/.semantic-memory/review-queue/<session>.json        pending jobs (all repos)\n *   ~/.semantic-memory/review-queue/{done,failed}/         finished jobs, never re-reviewed\n *   ~/.semantic-memory/skill-loop-runs.jsonl               one line per review run (the daily cap)\n *   <repo>/.claude/.semantic-memory/skill-loop.lock        the repo's worker (pid)\n *   <repo>/.claude/.semantic-memory/skill-loop.log         what the worker did\n *\n * Standalone for hooks (no embedder).\n */\nimport { appendFileSync, existsSync, mkdirSync, openSync, writeSync, closeSync, readFileSync, readdirSync, renameSync, unlinkSync, writeFileSync, statSync } from \"node:fs\";\nimport { homedir } from \"node:os\";\nimport { join } from \"node:path\";\nimport { readEvidence, stateDir } from \"./skill-evidence.js\";\n\nexport interface ReviewJob {\n  session_id: string;\n  repo: string;\n  transcript_path: string | null;\n  reason: string;\n  ts: string;\n  evidence: { failures: string[]; corrections: number; skills_used: string[]; tool_calls: number };\n  attempts?: number;\n}\n\nexport const smHome = (env = process.env) => env.SEMANTIC_MEMORY_STATE_HOME || join(env.HOME || homedir(), \".semantic-memory\");\nexport const queueDir = (env = process.env) => join(smHome(env), \"review-queue\");\nconst runsPath = (env = process.env) => join(smHome(env), \"skill-loop-runs.jsonl\");\nexport const lockPath = (repo: string) => join(stateDir(repo), \"skill-loop.lock\");\nexport const logPath = (repo: string) => join(stateDir(repo), \"skill-loop.log\");\n\nexport const dailyRunCap = (env = process.env) => Math.max(0, Number(env.SEMANTIC_MEMORY_SKILL_LOOP_DAILY_RUNS ?? 10) || 0);\nconst minToolCalls = (env = process.env) => Number(env.SEMANTIC_MEMORY_SKILL_LOOP_MIN_TOOL_CALLS) || 20;\n// shortcut: counts tool calls by scanning the transcript text; above this size the count is skipped (signal then\n// needs a failure or a correction). Upgrade if long tool-only sessions should qualify.\nconst TRANSCRIPT_SCAN_MAX = 50 * 1024 * 1024;\n\nconst safeName = (s: string) => s.replace(/[^A-Za-z0-9_.-]/g, \"_\").slice(0, 120);\n\nfunction countToolCalls(transcript: string | null): number {\n  if (!transcript) return 0;\n  try {\n    if (statSync(transcript).size > TRANSCRIPT_SCAN_MAX) return 0;\n    return readFileSync(transcript, \"utf8\").split('\"type\":\"tool_use\"').length - 1;\n  } catch {\n    return 0;\n  }\n}\n\n/** The job SessionEnd would write for this session, or null when the session has nothing to learn from. */\nexport function sessionJob(repo: string, input: { session_id?: string; transcript_path?: string; reason?: string }, env = process.env): ReviewJob | null {\n  const session_id = typeof input.session_id === \"string\" ? input.session_id : \"\";\n  if (!session_id) return null;\n  const failures = readEvidence(repo, \"failures\").filter((f) => f.session_id === session_id);\n  const corrections = readEvidence(repo, \"corrections\").filter((c) => c.session_id === session_id).length;\n  const skills_used = [...new Set(readEvidence(repo, \"usage\").filter((u) => u.session_id === session_id).map((u) => String(u.skill)))];\n  const transcript_path = typeof input.transcript_path === \"string\" ? input.transcript_path : null;\n  const tool_calls = failures.length || corrections ? 0 : countToolCalls(transcript_path);\n  const why = failures.length ? `${failures.length} failure(s)` : corrections ? `${corrections} correction(s)` : tool_calls >= minToolCalls(env) ? `${tool_calls} tool calls` : \"\";\n  if (!why) return null;\n  return {\n    session_id,\n    repo,\n    transcript_path,\n    reason: `${why}; ended: ${input.reason ?? \"unknown\"}`,\n    ts: new Date().toISOString(),\n    evidence: { failures: failures.map((f) => String(f.id ?? \"\")).filter(Boolean), corrections, skills_used, tool_calls },\n  };\n}\n\nexport function enqueue(job: ReviewJob, env = process.env): string {\n  mkdirSync(queueDir(env), { recursive: true });\n  const path = join(queueDir(env), `${safeName(job.session_id)}.json`);\n  // a session that ends twice (e.g. /clear then exit) is one job, and one already reviewed stays done\n  if ([\"done\", \"failed\"].some((d) => existsSync(join(queueDir(env), d, `${safeName(job.session_id)}.json`)))) return path;\n  writeFileSync(path, JSON.stringify(job, null, 1));\n  return path;\n}\n\nexport function pendingJobs(repo: string, env = process.env): { path: string; job: ReviewJob }[] {\n  let files: string[] = [];\n  try {\n    files = readdirSync(queueDir(env)).filter((f) => f.endsWith(\".json\"));\n  } catch {\n    return [];\n  }\n  const jobs: { path: string; job: ReviewJob }[] = [];\n  for (const f of files) {\n    try {\n      const path = join(queueDir(env), f);\n      const job = JSON.parse(readFileSync(path, \"utf8\")) as ReviewJob;\n      if (job.repo === repo) jobs.push({ path, job });\n    } catch {}\n  }\n  return jobs.sort((a, b) => a.job.ts.localeCompare(b.job.ts));\n}\n\nexport function finishJob(path: string, outcome: \"done\" | \"failed\", result: Record<string, unknown>, env = process.env): void {\n  const dir = join(queueDir(env), outcome);\n  mkdirSync(dir, { recursive: true });\n  const job = JSON.parse(readFileSync(path, \"utf8\"));\n  writeFileSync(path, JSON.stringify({ ...job, finished: new Date().toISOString(), result }, null, 1));\n  renameSync(path, join(dir, path.split(\"/\").pop()!));\n}\n\nexport function bumpAttempts(path: string): number {\n  const job = JSON.parse(readFileSync(path, \"utf8\")) as ReviewJob;\n  job.attempts = (job.attempts ?? 0) + 1;\n  writeFileSync(path, JSON.stringify(job, null, 1));\n  return job.attempts;\n}\n\nconst localDay = (d = new Date()) => `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, \"0\")}-${String(d.getDate()).padStart(2, \"0\")}`;\n\nexport function runsToday(env = process.env, now = new Date()): number {\n  try {\n    const day = localDay(now);\n    return readFileSync(runsPath(env), \"utf8\").split(\"\\n\").filter((l) => l.includes(`\"day\":\"${day}\"`)).length;\n  } catch {\n    return 0;\n  }\n}\n\nexport function recordRun(repo: string, session_id: string, env = process.env, now = new Date()): void {\n  mkdirSync(smHome(env), { recursive: true });\n  appendFileSync(runsPath(env), JSON.stringify({ day: localDay(now), ts: now.toISOString(), repo, session_id }) + \"\\n\");\n}\n\nconst alive = (pid: number) => {\n  try {\n    process.kill(pid, 0);\n    return true;\n  } catch (e) {\n    return (e as NodeJS.ErrnoException).code === \"EPERM\";\n  }\n};\n\nexport function lockHolder(repo: string): number | null {\n  try {\n    const pid = Number(readFileSync(lockPath(repo), \"utf8\").trim());\n    return pid && alive(pid) ? pid : null;\n  } catch {\n    return null;\n  }\n}\n\n/** Take the repo's worker lock (reclaiming a dead holder's). Returns a release function, or null if held. */\nexport function takeLock(repo: string): (() => void) | null {\n  mkdirSync(stateDir(repo), { recursive: true });\n  for (let attempt = 0; attempt < 2; attempt++) {\n    try {\n      const fd = openSync(lockPath(repo), \"wx\");\n      writeSync(fd, `${process.pid}\\n`);\n      closeSync(fd);\n      return () => {\n        try {\n          if (Number(readFileSync(lockPath(repo), \"utf8\").trim()) === process.pid) unlinkSync(lockPath(repo));\n        } catch {}\n      };\n    } catch (e) {\n      if ((e as NodeJS.ErrnoException).code !== \"EEXIST\") throw e;\n      if (lockHolder(repo) !== null) return null;\n      try {\n        unlinkSync(lockPath(repo));\n      } catch {}\n    }\n  }\n  return null;\n}\n\nexport function log(repo: string, line: string): void {\n  try {\n    mkdirSync(stateDir(repo), { recursive: true });\n    appendFileSync(logPath(repo), `${new Date().toISOString()} ${line}\\n`);\n  } catch {}\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-OT3MV7XF.js

@@ -0,0 +1,123 @@
+import {
+  runTrigger
+} from "./chunk-MQS7JEBD.js";
+import {
+  runClaude
+} from "./chunk-IEZVFKUT.js";
+import {
+  parseSkill
+} from "./chunk-ZSWI3Y4Y.js";
+import {
+  matter_default
+} from "./chunk-J7LYDRML.js";
+
+// src/core/skill-eval/prompts/improve-description.ts
+var DESCRIPTION_LIMIT = 1024;
+var list = (rs) => rs.map((r) => `  - "${r.text}" (triggered ${r.triggers}/${r.runs} times)
+`).join("");
+function improveDescriptionPrompt(a) {
+  let p = `You are optimizing a skill description for a Claude Code skill called "${a.name}". A "skill" is sort of like a prompt, but with progressive disclosure -- there's a title and description that Claude sees when deciding whether to use the skill, and then if it does use the skill, it reads the .md file which has lots more details.
+
+The description appears in Claude's "available_skills" list. When a user sends a query, Claude decides whether to invoke the skill based solely on the title and on this description. Your goal is to write a description that triggers for relevant queries, and doesn't trigger for irrelevant ones.
+
+Here's the current description:
+<current_description>
+"${a.description}"
+</current_description>
+
+Current scores (train ${a.score}):
+<scores_summary>
+`;
+  if (a.missed.length) p += `FAILED TO TRIGGER (should have triggered but didn't):
+${list(a.missed)}
+`;
+  if (a.falseTriggers.length) p += `FALSE TRIGGERS (triggered but shouldn't have):
+${list(a.falseTriggers)}
+`;
+  if (a.history.length) {
+    p += "PREVIOUS ATTEMPTS (do NOT repeat these -- try something structurally different):\n\n";
+    for (const h of a.history) p += `<attempt train=${h.score}>
+Description: "${h.description}"
+</attempt>
+
+`;
+  }
+  return p + `</scores_summary>
+
+Skill content (for context on what the skill does):
+<skill_content>
+${a.skillContent}
+</skill_content>
+
+Based on the failures, write a new and improved description that is more likely to trigger correctly. Do not overfit: don't produce an ever-expanding list of specific queries. Generalize from the failures to broader categories of user intent and situations where this skill would be useful or not useful. The description is injected into ALL queries, so keep it to about 100-200 words. There is a hard limit of ${DESCRIPTION_LIMIT} characters -- stay comfortably under it.
+
+Tips:
+- Phrase it in the imperative -- "Use this skill for" rather than "this skill does".
+- Focus on the user's intent, what they are trying to achieve, vs. the implementation details.
+- The description competes with other skills for Claude's attention -- make it distinctive and immediately recognizable.
+- If you're getting lots of failures after repeated attempts, change things up: different sentence structures or wordings.
+
+Please respond with only the new description text in <new_description> tags, nothing else.`;
+}
+var shortenPrompt = (base, tooLong) => `${base}
+
+---
+
+A previous attempt produced this description, which at ${tooLong.length} characters is over the ${DESCRIPTION_LIMIT}-character hard limit:
+
+"${tooLong}"
+
+Rewrite it to be under ${DESCRIPTION_LIMIT} characters while keeping the most important trigger words and intent coverage. Respond with only the new description in <new_description> tags.`;
+var parseNewDescription = (text) => (text.match(/<new_description>([\s\S]*?)<\/new_description>/)?.[1] ?? text).trim().replace(/^"|"$/g, "").trim();
+
+// src/core/skill-eval/tune.ts
+var MAX_TUNE_ITERATIONS = 3;
+function withDescription(raw, description) {
+  const p = matter_default(raw);
+  return matter_default.stringify(p.content, { ...p.data, description });
+}
+var score = (r) => r.train.accuracy;
+var frac = (r) => `${r.results.filter((x) => x.split === "train" && x.triggered === x.should_trigger).length}/${r.train.n}`;
+async function tuneDescription(o) {
+  const skill = parseSkill(o.skillRaw);
+  const tr = (raw) => runTrigger(o.prompts, { repoRoot: o.repoRoot, skillRaw: raw, env: o.env });
+  const cand = (description, r) => ({ description, train: score(r), heldout: r.heldout.accuracy });
+  let last = await tr(o.skillRaw);
+  const original = cand(skill.description, last);
+  const candidates = [original];
+  const history = [];
+  for (let i = 0; i < Math.min(o.maxIterations ?? MAX_TUNE_ITERATIONS, MAX_TUNE_ITERATIONS); i++) {
+    const prev = candidates.at(-1);
+    history.push({ description: prev.description, score: frac(last) });
+    const train = last.results.filter((r2) => r2.split === "train");
+    const prompt = improveDescriptionPrompt({
+      name: skill.name,
+      skillContent: skill.body,
+      description: prev.description,
+      score: frac(last),
+      missed: train.filter((r2) => r2.should_trigger && !r2.triggered),
+      falseTriggers: train.filter((r2) => !r2.should_trigger && r2.triggered),
+      history: history.slice(0, -1)
+    });
+    const env = o.env;
+    let r = await runClaude({ prompt, cwd: o.repoRoot, tools: [], maxTurns: 1, env });
+    if (!r.ok) break;
+    let description = parseNewDescription(r.result);
+    if (description.length > DESCRIPTION_LIMIT) {
+      r = await runClaude({ prompt: shortenPrompt(prompt, description), cwd: o.repoRoot, tools: [], maxTurns: 1, env });
+      if (r.ok) description = parseNewDescription(r.result);
+    }
+    if (!description || description.length > DESCRIPTION_LIMIT || candidates.some((c) => c.description === description)) continue;
+    last = await tr(withDescription(o.skillRaw, description));
+    candidates.push(cand(description, last));
+  }
+  const best = candidates.reduce((b, c) => (c.heldout ?? -1) > (b.heldout ?? -1) || (c.heldout ?? -1) === (b.heldout ?? -1) && (c.train ?? -1) > (b.train ?? -1) ? c : b);
+  return { original, best, improved: best !== original, candidates };
+}
+
+export {
+  MAX_TUNE_ITERATIONS,
+  withDescription,
+  tuneDescription
+};
+//# sourceMappingURL=chunk-OT3MV7XF.js.map

package/dist/chunk-OT3MV7XF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/skill-eval/prompts/improve-description.ts","../src/core/skill-eval/tune.ts"],"sourcesContent":["/**\n * Adapted from Anthropic's skill-creator (https://github.com/anthropics/claude-plugins-official, Apache License 2.0); modified for semantic-memory.\n */\n\nexport interface DescriptionAttempt {\n  description: string;\n  /** \"passed/total\" on the train prompts */\n  score: string;\n}\n\nexport interface PromptResult {\n  text: string;\n  triggers: number;\n  runs: number;\n}\n\nexport const DESCRIPTION_LIMIT = 1024;\n\nconst list = (rs: PromptResult[]) => rs.map((r) => `  - \"${r.text}\" (triggered ${r.triggers}/${r.runs} times)\\n`).join(\"\");\n\n/** Ask for a better description from the train failures only (held-out results never reach the proposer). */\nexport function improveDescriptionPrompt(a: {\n  name: string;\n  skillContent: string;\n  description: string;\n  score: string;\n  missed: PromptResult[];\n  falseTriggers: PromptResult[];\n  history: DescriptionAttempt[];\n}): string {\n  let p = `You are optimizing a skill description for a Claude Code skill called \"${a.name}\". A \"skill\" is sort of like a prompt, but with progressive disclosure -- there's a title and description that Claude sees when deciding whether to use the skill, and then if it does use the skill, it reads the .md file which has lots more details.\n\nThe description appears in Claude's \"available_skills\" list. When a user sends a query, Claude decides whether to invoke the skill based solely on the title and on this description. Your goal is to write a description that triggers for relevant queries, and doesn't trigger for irrelevant ones.\n\nHere's the current description:\n<current_description>\n\"${a.description}\"\n</current_description>\n\nCurrent scores (train ${a.score}):\n<scores_summary>\n`;\n  if (a.missed.length) p += `FAILED TO TRIGGER (should have triggered but didn't):\\n${list(a.missed)}\\n`;\n  if (a.falseTriggers.length) p += `FALSE TRIGGERS (triggered but shouldn't have):\\n${list(a.falseTriggers)}\\n`;\n  if (a.history.length) {\n    p += \"PREVIOUS ATTEMPTS (do NOT repeat these -- try something structurally different):\\n\\n\";\n    for (const h of a.history) p += `<attempt train=${h.score}>\\nDescription: \"${h.description}\"\\n</attempt>\\n\\n`;\n  }\n  return (\n    p +\n    `</scores_summary>\n\nSkill content (for context on what the skill does):\n<skill_content>\n${a.skillContent}\n</skill_content>\n\nBased on the failures, write a new and improved description that is more likely to trigger correctly. Do not overfit: don't produce an ever-expanding list of specific queries. Generalize from the failures to broader categories of user intent and situations where this skill would be useful or not useful. The description is injected into ALL queries, so keep it to about 100-200 words. There is a hard limit of ${DESCRIPTION_LIMIT} characters -- stay comfortably under it.\n\nTips:\n- Phrase it in the imperative -- \"Use this skill for\" rather than \"this skill does\".\n- Focus on the user's intent, what they are trying to achieve, vs. the implementation details.\n- The description competes with other skills for Claude's attention -- make it distinctive and immediately recognizable.\n- If you're getting lots of failures after repeated attempts, change things up: different sentence structures or wordings.\n\nPlease respond with only the new description text in <new_description> tags, nothing else.`\n  );\n}\n\n/** The follow-up for a description over the limit. */\nexport const shortenPrompt = (base: string, tooLong: string) =>\n  `${base}\\n\\n---\\n\\nA previous attempt produced this description, which at ${tooLong.length} characters is over the ${DESCRIPTION_LIMIT}-character hard limit:\\n\\n\"${tooLong}\"\\n\\n` +\n  `Rewrite it to be under ${DESCRIPTION_LIMIT} characters while keeping the most important trigger words and intent coverage. Respond with only the new description in <new_description> tags.`;\n\n/** The description inside <new_description> tags, or the whole reply when untagged. */\nexport const parseNewDescription = (text: string): string =>\n  (text.match(/<new_description>([\\s\\S]*?)<\\/new_description>/)?.[1] ?? text).trim().replace(/^\"|\"$/g, \"\").trim();\n","/**\n * Description tuning (v1.7): propose better descriptions from the train failures, score every candidate\n * with the trigger eval, keep the best by held-out score. At most 3 iterations. Returns the proposal and the\n * scores — it never writes the skill file.\n */\nimport { runClaude } from \"../claude-run.js\";\nimport matter from \"../matter.js\";\nimport { parseSkill } from \"../skill-schema.js\";\nimport { DESCRIPTION_LIMIT, improveDescriptionPrompt, parseNewDescription, shortenPrompt, type DescriptionAttempt } from \"./prompts/improve-description.js\";\nimport type { EvalPrompt } from \"./sets.js\";\nimport { runTrigger, type TriggerReport } from \"./trigger.js\";\n\nexport const MAX_TUNE_ITERATIONS = 3;\n\nexport interface TuneCandidate {\n  description: string;\n  train: number | null;\n  heldout: number | null;\n}\n\nexport interface TuneReport {\n  original: TuneCandidate;\n  best: TuneCandidate;\n  /** the best candidate is not the original */\n  improved: boolean;\n  candidates: TuneCandidate[];\n}\n\n/** The skill file with its frontmatter description replaced and nothing else changed. */\nexport function withDescription(raw: string, description: string): string {\n  const p = matter(raw);\n  return matter.stringify(p.content, { ...p.data, description });\n}\n\nconst score = (r: TriggerReport): TuneCandidate[\"train\"] => r.train.accuracy;\nconst frac = (r: TriggerReport) => `${r.results.filter((x) => x.split === \"train\" && x.triggered === x.should_trigger).length}/${r.train.n}`;\n\nexport async function tuneDescription(o: { repoRoot: string; skillRaw: string; prompts: EvalPrompt[]; env?: NodeJS.ProcessEnv; maxIterations?: number }): Promise<TuneReport> {\n  const skill = parseSkill(o.skillRaw);\n  const tr = (raw: string) => runTrigger(o.prompts, { repoRoot: o.repoRoot, skillRaw: raw, env: o.env });\n  const cand = (description: string, r: TriggerReport): TuneCandidate => ({ description, train: score(r), heldout: r.heldout.accuracy });\n  let last = await tr(o.skillRaw);\n  const original = cand(skill.description, last);\n  const candidates = [original];\n  const history: DescriptionAttempt[] = [];\n  for (let i = 0; i < Math.min(o.maxIterations ?? MAX_TUNE_ITERATIONS, MAX_TUNE_ITERATIONS); i++) {\n    const prev = candidates.at(-1)!;\n    history.push({ description: prev.description, score: frac(last) });\n    // only train results go to the proposer; held-out stays unseen so it can judge\n    const train = last.results.filter((r) => r.split === \"train\");\n    const prompt = improveDescriptionPrompt({\n      name: skill.name,\n      skillContent: skill.body,\n      description: prev.description,\n      score: frac(last),\n      missed: train.filter((r) => r.should_trigger && !r.triggered),\n      falseTriggers: train.filter((r) => !r.should_trigger && r.triggered),\n      history: history.slice(0, -1),\n    });\n    const env = o.env;\n    let r = await runClaude({ prompt, cwd: o.repoRoot, tools: [], maxTurns: 1, env });\n    if (!r.ok) break;\n    let description = parseNewDescription(r.result);\n    if (description.length > DESCRIPTION_LIMIT) {\n      r = await runClaude({ prompt: shortenPrompt(prompt, description), cwd: o.repoRoot, tools: [], maxTurns: 1, env });\n      if (r.ok) description = parseNewDescription(r.result);\n    }\n    if (!description || description.length > DESCRIPTION_LIMIT || candidates.some((c) => c.description === description)) continue;\n    last = await tr(withDescription(o.skillRaw, description));\n    candidates.push(cand(description, last));\n  }\n  // best by held-out, ties by train, then the earlier candidate (the original wins a full tie)\n  const best = candidates.reduce((b, c) => ((c.heldout ?? -1) > (b.heldout ?? -1) || ((c.heldout ?? -1) === (b.heldout ?? -1) && (c.train ?? -1) > (b.train ?? -1)) ? c : b));\n  return { original, best, improved: best !== original, candidates };\n}\n\n"],"mappings":"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","names":["r"]}

package/dist/chunk-P3GLY42T.js

@@ -0,0 +1,291 @@
+import {
+  decideScope,
+  indexSkill,
+  promotionPeers
+} from "./chunk-3FPUBAEW.js";
+import {
+  runClaude
+} from "./chunk-IEZVFKUT.js";
+import {
+  factIds,
+  findSkills,
+  lintSkill,
+  renderSkill
+} from "./chunk-ZSWI3Y4Y.js";
+import {
+  readEvidence,
+  stateDir
+} from "./chunk-R6GNP7DS.js";
+import {
+  redact
+} from "./chunk-H2BES6FU.js";
+
+// src/core/skill-review.ts
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { basename, join } from "path";
+
+// src/core/skill-review-prompt.ts
+var REVIEW_PROMPT = `You review one finished Claude Code session in this repository and decide whether it taught a
+reusable procedure worth saving as a skill \u2014 a short, step-by-step playbook a future session should follow.
+
+Draft only from the evidence in the brief below: a command that failed and the fix that worked, a correction
+the user gave, or a learned skill that was used and then failed or was corrected. Never invent steps, commands,
+paths or facts that the brief or the repository does not show. Most sessions teach nothing reusable: then
+answer with no drafts. A draft is worth it only when the same situation is likely to come up again here.
+
+Kinds of draft:
+- "new": a procedure no existing skill covers. Check the existing skills in the brief first.
+- "patch": an existing learned skill (listed with "learned: true") was used in this session and then failed or
+  was corrected: give its full revised body. Never patch a skill that is pinned or not learned.
+
+Each draft:
+- name: kebab-case, specific ("restart-vite-dev-server", not "dev-helper").
+- description: what it does and when to use it, one or two sentences, starting with the action; include
+  "Use when ..." with the literal error, command or request that should load it. Under 300 characters.
+- scope: "project" (about this repository) or "directory" (only about one subdirectory; give it in applies_to.paths).
+- applies_to: { paths: [repo-relative paths that exist], commands: [program names the steps run] }.
+- triggers: the literal error strings, commands or user phrases from the brief that this skill answers.
+- provenance: { sessions: [the session id], failures: [failure ids from the brief it came from], corrections: [correction
+  numbers from the brief, as strings] } \u2014 at least one failure or correction.
+- cites: knowledge-base fact ids from the brief's list that the steps rely on (only ids that are listed).
+- body: markdown with exactly these sections, in order:
+  ## When to use \u2014 the situation, in two or three lines.
+  ## Steps \u2014 numbered, concrete commands or actions as the session finally did them.
+  ## Pitfalls \u2014 what went wrong in the session and why; each line names the failure id or fact id it comes from.
+  ## Verify \u2014 one command whose exit code proves it worked, in a fenced code block; or, if none exists, one
+     sentence a reviewer can check.
+
+Hard rules:
+- No secrets, tokens, passwords, keys, personal data, customer data, names of people or money amounts, even if
+  the brief shows them. Use placeholders like <token>.
+- At most 2 drafts. No duplicates of existing skills.
+- Do not write or change any file. You may read files in this repository to get paths and commands right.
+
+Answer with one JSON object and nothing else:
+{"drafts": [{"kind": "new" | "patch", "target": "<existing skill name, patch only>", "name": "...",
+  "description": "...", "scope": "project" | "directory", "applies_to": {"paths": [], "commands": []},
+  "triggers": [], "provenance": {"sessions": [], "failures": [], "corrections": []}, "cites": [], "body": "..."}],
+ "none_reason": "<when drafts is empty: one line on why>"}
+`;
+
+// src/core/skill-review.ts
+var draftsDir = (repo) => join(stateDir(repo), "skill-drafts");
+var BRIEF_MAX = 4e4;
+var TIMELINE_MAX = 120;
+function transcriptTimeline(path, max = TIMELINE_MAX) {
+  if (!path) return [];
+  let raw = "";
+  try {
+    if (statSync(path).size > 200 * 1024 * 1024) return ["(transcript too large to read)"];
+    raw = readFileSync(path, "utf8");
+  } catch {
+    return [];
+  }
+  const out = [];
+  const calls = /* @__PURE__ */ new Map();
+  for (const line of raw.split("\n")) {
+    let e;
+    try {
+      e = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const content = e?.message?.content;
+    if (e?.type === "user" && typeof content === "string" && !e.isMeta) {
+      if (!content.trimStart().startsWith("<")) out.push(`USER: ${content.slice(0, 600)}`);
+    } else if (e?.type === "assistant" && Array.isArray(content)) {
+      for (const c of content) {
+        if (c?.type !== "tool_use") continue;
+        const input = c.input ?? {};
+        const what = typeof input.command === "string" ? input.command : typeof input.file_path === "string" ? input.file_path : typeof input.skill === "string" ? input.skill : JSON.stringify(input);
+        calls.set(c.id, `${c.name}: ${String(what).slice(0, 300)}`);
+      }
+    } else if (e?.type === "user" && Array.isArray(content)) {
+      for (const c of content) {
+        if (c?.type !== "tool_result") continue;
+        const call = calls.get(c.tool_use_id) ?? "tool";
+        const text = typeof c.content === "string" ? c.content : Array.isArray(c.content) ? c.content.map((x) => x?.text ?? "").join(" ") : "";
+        out.push(c.is_error ? `TOOL ${call}
+  \u2192 ERROR (${c.tool_use_id}): ${text.slice(0, 500)}` : `TOOL ${call} \u2192 ok`);
+      }
+    }
+  }
+  if (out.length <= max) return out;
+  const errors = out.filter((l) => l.includes("\u2192 ERROR")).slice(-Math.floor(max / 2));
+  const tail = out.slice(-(max - errors.length)).filter((l) => !errors.includes(l));
+  return [`(${out.length - errors.length - tail.length} earlier entries omitted)`, ...errors, ...tail];
+}
+function topLevel(repo) {
+  try {
+    return readdirSync(repo).filter((f) => !f.startsWith(".") || f === ".claude" || f === ".documentation").slice(0, 60);
+  } catch {
+    return [];
+  }
+}
+function buildBrief(job, skills = findSkills(job.repo)) {
+  const repo = job.repo;
+  const failures = readEvidence(repo, "failures").filter((f) => f.session_id === job.session_id);
+  const corrections = readEvidence(repo, "corrections").filter((c) => c.session_id === job.session_id);
+  const used = new Set(job.evidence.skills_used);
+  const r = (t) => redact(t, "broad").text;
+  const lines = [
+    `# Session ${job.session_id}`,
+    `Repository: ${basename(repo)} \u2014 top level: ${topLevel(repo).join(", ")}`,
+    `Why reviewed: ${job.reason}`,
+    "",
+    "## Failures (from the evidence log)",
+    ...failures.length ? failures.map((f) => `- id ${f.id}: \`${r(String(f.command))}\`
+  error: ${r(String(f.error).slice(0, 500))}`) : ["(none)"],
+    "",
+    "## Corrections the user gave",
+    ...corrections.length ? corrections.map((c, i) => `- correction ${i + 1} (${c.cue}): ${r(String(c.excerpt))}`) : ["(none)"],
+    "",
+    "## Skills this repository loads",
+    ...skills.length ? skills.map((s) => `- ${s.skill.name || basename(s.dir)} (${s.scope}; learned: ${s.learned}${s.skill.meta?.pinned ? "; pinned" : ""}${used.has(s.skill.name) ? "; USED this session" : ""}): ${r(s.skill.description.slice(0, 200))}`) : ["(none)"],
+    ...skills.filter((s) => s.learned && used.has(s.skill.name)).flatMap((s) => ["", `### Current text of the learned skill ${s.skill.name} (used this session)`, r(s.skill.body.slice(0, 4e3))]),
+    "",
+    "## Knowledge-base fact ids (for cites)",
+    [...factIds(repo)].slice(0, 200).join(", ") || "(none)",
+    "",
+    "## Timeline (prompts, tool calls, errors)",
+    ...transcriptTimeline(job.transcript_path).map(r)
+  ];
+  let brief = lines.join("\n");
+  if (brief.length > BRIEF_MAX) brief = brief.slice(0, BRIEF_MAX) + "\n(brief cut at its size cap)";
+  return brief;
+}
+function parseReviewerJson(text) {
+  const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+  const candidates = [fenced?.[1], text, text.slice(text.indexOf("{"), text.lastIndexOf("}") + 1)].filter(Boolean);
+  for (const c of candidates) {
+    try {
+      const v = JSON.parse(c.trim());
+      if (v && Array.isArray(v.drafts)) return v;
+    } catch {
+    }
+  }
+  return null;
+}
+var strs = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string" && !x.includes("[REDACTED]")) : [];
+var sha256 = (s) => createHash("sha256").update(s).digest("hex");
+async function materializeDraft(repo, job, d, skills, resolveScope = (x) => decideScope(repo, x), env = process.env, merge) {
+  if (!d || typeof d.name !== "string" || typeof d.body !== "string" || typeof d.description !== "string") return { rejected: "malformed draft" };
+  let target;
+  if (d.kind === "patch") {
+    target = skills.find((s) => s.skill.name === d.target);
+    if (!target) return { rejected: `patch target "${d.target}" not found` };
+    if (!target.learned) return { rejected: `"${d.target}" was not written by the skill loop: never patched` };
+    if (target.skill.meta?.pinned) return { rejected: `"${d.target}" is pinned` };
+  }
+  const prov = {
+    sessions: [.../* @__PURE__ */ new Set([job.session_id, ...strs(d.provenance?.sessions)])],
+    failures: strs(d.provenance?.failures),
+    corrections: strs(d.provenance?.corrections)
+  };
+  if (prov.failures.length + prov.corrections.length === 0 && job.evidence.failures.length + job.evidence.corrections === 0) {
+    return { rejected: "no failure or correction behind it" };
+  }
+  const decision = target ? { scope: target.scope === "directory" ? "directory" : "project", globalCandidate: false, why: "patch: the skill's own scope" } : await resolveScope(d);
+  const scope = target?.scope ?? decision.scope;
+  const paths = strs(d.applies_to?.paths);
+  if (decision.directory && !paths.includes(decision.directory)) paths.unshift(decision.directory);
+  const name = d.kind === "patch" ? target.skill.name : d.name;
+  const meta = {
+    schema: 1,
+    scope,
+    status: "draft",
+    pinned: false,
+    triggers: strs(d.triggers),
+    applies_to: { paths, commands: strs(d.applies_to?.commands) },
+    provenance: prov,
+    cites: strs(d.cites),
+    supersedes: merge ? merge.supersedes.map((p) => basename(join(p, ".."))) : target?.skill.meta?.supersedes ?? []
+  };
+  const text = redact(renderSkill({ name, description: d.description, meta, body: d.body }), "precise").text;
+  const findings = lintSkill(join(draftsDir(repo), name, "SKILL.md"), text, { projectRoot: repo, others: skills.filter((s) => s.path !== target?.path) }, name);
+  const errors = findings.filter((f) => f.severity === "error");
+  if (errors.length) return { rejected: `lint: ${errors.map((f) => `${f.rule}: ${f.message}`).join("; ")}` };
+  const id = `${name}-${sha256(text).slice(0, 8)}`;
+  const dir = join(draftsDir(repo), id);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "SKILL.md"), text);
+  const record = {
+    id,
+    kind: merge ? "merge" : d.kind === "patch" ? "patch" : "new",
+    name,
+    scope,
+    ...target ? { target: target.path, base_sha256: sha256(readFileSync(target.path, "utf8")) } : {},
+    session_id: job.session_id,
+    created: (/* @__PURE__ */ new Date()).toISOString(),
+    warnings: findings.filter((f) => f.severity === "warn").map((f) => `${f.rule}: ${f.message}`),
+    ...decision.directory ? { directory: decision.directory } : {},
+    scope_why: decision.why,
+    ...decision.globalCandidate ? { global_candidate: true } : {},
+    ...merge ? { supersedes: merge.supersedes } : {}
+  };
+  if (!target && !merge) {
+    const peers = promotionPeers(repo, name, env);
+    if (peers.length) record.promotion = peers.map((p) => ({ repo: p.repo, path: p.path }));
+    indexSkill({ repo, name, path: join(dir, "SKILL.md"), status: "draft", ...decision.globalCandidate ? { global_candidate: true } : {} }, env);
+  }
+  writeFileSync(join(dir, "draft.json"), JSON.stringify(record, null, 1));
+  return { id };
+}
+function listDrafts(repo) {
+  let ids = [];
+  try {
+    ids = readdirSync(draftsDir(repo));
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const id of ids) {
+    const dir = join(draftsDir(repo), id);
+    try {
+      if (existsSync(join(dir, "SKILL.md"))) out.push({ dir, record: JSON.parse(readFileSync(join(dir, "draft.json"), "utf8")) });
+    } catch {
+    }
+  }
+  return out.sort((a, b) => a.record.created.localeCompare(b.record.created));
+}
+async function reviewSession(job, opts = {}) {
+  const skills = findSkills(job.repo);
+  const brief = buildBrief(job, skills);
+  const run = await runClaude({
+    prompt: `${REVIEW_PROMPT}
+
+---
+
+${brief}`,
+    cwd: job.repo,
+    tools: ["Read", "Grep", "Glob"],
+    maxTurns: opts.maxTurns ?? 8,
+    output: "json",
+    timeoutMs: 10 * 6e4,
+    env: opts.env
+  });
+  if (!run.ok && !run.result) throw new Error(run.error ?? "reviewer run failed");
+  const answer = parseReviewerJson(run.result);
+  if (!answer) return { drafts: [], rejected: [{ reason: "reviewer answer was not JSON" }], costUsd: run.costUsd };
+  const drafts = [];
+  const rejected = [];
+  for (const d of answer.drafts.slice(0, 2)) {
+    const env = opts.env ?? process.env;
+    const r = await materializeDraft(job.repo, job, d, skills, opts.resolveScope ?? ((x) => decideScope(job.repo, x, env)), env);
+    if (r.id) drafts.push(r.id);
+    else rejected.push({ reason: `${d?.name ?? "?"}: ${r.rejected}` });
+  }
+  return { drafts, rejected, costUsd: run.costUsd, note: answer.drafts.length ? void 0 : answer.none_reason?.slice(0, 200) };
+}
+
+export {
+  draftsDir,
+  transcriptTimeline,
+  buildBrief,
+  parseReviewerJson,
+  materializeDraft,
+  listDrafts,
+  reviewSession
+};
+//# sourceMappingURL=chunk-P3GLY42T.js.map