@theglitchking/semantic-memory 1.6.0 → 1.7.0

package/dist/core/features.d.ts

@@ -0,0 +1,38 @@
+type Feature = "skill_loop" | "jev";
+interface FeatureState {
+    feature: Feature;
+    on: boolean;
+    /** Where the on/off came from. */
+    why: "default" | "env" | "repo";
+    /** jev only: whether jev-loop, the key and python are present. Always true for the skill loop. */
+    available: boolean;
+    /** Why it is unavailable, when it is on but cannot run. */
+    reason?: string;
+}
+declare const ENV: Record<Feature, string>;
+declare const repoConfigPath: (projectRoot: string) => string;
+/** `<repo>/.claude/.semantic-memory/config` as an object ({} when missing or unparseable). */
+declare function readRepoConfig(projectRoot: string): Record<string, unknown>;
+declare const jevLoopDir: (env?: NodeJS.ProcessEnv) => string;
+declare const claudeSettingsPath: (env?: NodeJS.ProcessEnv) => string;
+/** Whether jev mode could run: jev-loop's router, the TypeSafe key (env or settings, never read out), python3. */
+declare function jevAvailable(env?: NodeJS.ProcessEnv): {
+    available: boolean;
+    reason?: string;
+};
+declare function featureState(feature: Feature, projectRoot?: string, env?: NodeJS.ProcessEnv): FeatureState;
+/** On and able to run. The check every hook path makes first. */
+declare const featureOn: (feature: Feature, projectRoot?: string, env?: NodeJS.ProcessEnv) => boolean;
+/**
+ * Set (true / false) or clear (undefined) one env key in ~/.claude/settings.json, touching nothing else.
+ * Keeps a `.bak` of the previous file. Refuses (throws, writes nothing) when the file is not valid JSON.
+ */
+declare function setSettingsEnv(key: string, value: string | undefined, env?: NodeJS.ProcessEnv): {
+    path: string;
+    backup?: string;
+};
+/** Set or clear `<key>: <value>` in the repo config, keeping the other keys. */
+declare function setRepoConfig(projectRoot: string, key: string, value: string | boolean | undefined): string;
+declare function describeFeature(s: FeatureState): string;
+
+export { ENV, type Feature, type FeatureState, claudeSettingsPath, describeFeature, featureOn, featureState, jevAvailable, jevLoopDir, readRepoConfig, repoConfigPath, setRepoConfig, setSettingsEnv };

package/dist/core/features.js

@@ -0,0 +1,28 @@
+import {
+  ENV,
+  claudeSettingsPath,
+  describeFeature,
+  featureOn,
+  featureState,
+  jevAvailable,
+  jevLoopDir,
+  readRepoConfig,
+  repoConfigPath,
+  setRepoConfig,
+  setSettingsEnv
+} from "../chunk-VQCNWRTL.js";
+import "../chunk-PZ5AY32C.js";
+export {
+  ENV,
+  claudeSettingsPath,
+  describeFeature,
+  featureOn,
+  featureState,
+  jevAvailable,
+  jevLoopDir,
+  readRepoConfig,
+  repoConfigPath,
+  setRepoConfig,
+  setSettingsEnv
+};
+//# sourceMappingURL=features.js.map

package/dist/core/index.d.ts

@@ -2,6 +2,14 @@ import Graph from 'graphology';
 import { EventEmitter } from 'node:events';
 export { REDACTED, RedactMode, RedactResult, redact, redactDeep } from './redact.js';
 export { commandVerbs, errorSignal, failureQuery } from './failure-query.js';
+export { Feature, FeatureState, describeFeature, featureOn, featureState, jevAvailable } from './features.js';
+import { P as ParsedSkill, D as DraftRecord, S as SkillLoopMeta } from '../skill-review-BaW5n0Zg.js';
+export { a as SKILL_SCOPES, b as SKILL_SECTIONS, c as SKILL_STATUSES, d as SkillFile, e as SkillFinding, f as SkillScope, g as SkillStatus, h as buildBrief, i as decideScope, j as draftsDir, k as findSkills, l as lintSkill, m as lintSkills, n as listDrafts, p as parseSkill, r as renderSkill, o as reviewSession } from '../skill-review-BaW5n0Zg.js';
+import { L as LedgerEntry } from '../skill-curator-D7HHZaUI.js';
+export { c as curate, r as readLedger, a as restore, b as rollback, v as verifySkills } from '../skill-curator-D7HHZaUI.js';
+export { JEV_BAR, JevAnswer, JevCaller, JevQuestion, askJev, failureState, jevSpendToday, jevVerdict, relevanceQuestion } from './jev.js';
+import './skill-queue.js';
+import './skill-worker.js';
 
 interface IndexedDocument {
     path: string;
@@ -261,7 +269,7 @@ interface VaultSchema {
 type Severity$1 = "warn" | "error";
 interface LintFinding {
     path: string;
-    rule: "missing_provenance" | "stale" | "schema_violations" | "broken_links" | "code_symbols" | "decay_candidates" | "alias_conflicts" | "decoys" | "secrets";
+    rule: "missing_provenance" | "stale" | "schema_violations" | "broken_links" | "code_symbols" | "decay_candidates" | "alias_conflicts" | "decoys" | "secrets" | "skills";
     severity: Severity$1;
     message: string;
 }
@@ -543,6 +551,8 @@ interface LintReport {
         decoys: LintFinding[];
         /** only present when the opt-in secrets check ran */
         secrets?: LintFinding[];
+        /** only present when the opt-in skills check ran */
+        skills?: LintFinding[];
     };
     counts: {
         errors: number;
@@ -593,6 +603,8 @@ declare function lintVault(notesPath: string, opts?: {
      * git history if the note was ever committed.
      */
     checkSecrets?: boolean;
+    /** When true, lint the skill loop's learned skills this repo loads (v1.7): format, evidence, cites, clashes. Opt-in. */
+    checkSkills?: boolean;
 }): Promise<LintReport>;
 declare function formatLintReport(report: LintReport, opts?: {
     rule?: keyof LintReport["byRule"];
@@ -874,5 +886,276 @@ declare function evaluateFailures(results: CaseResult[], judgments: Judgment[],
     thresholds?: number[];
 }): FailureEvalReport;
 declare function formatFailureEval(report: FailureEvalReport, label?: string): string;
+/** jev-loop's adoption bar: right >= 95% of the time over >= 40 picks, with at most 2 wrong. */
+declare const meetsBar: (picks: number, wrong: number) => boolean;
+interface JevJudgment {
+    case: string;
+    path: string;
+    p: number | null;
+}
+interface JudgeCalibration {
+    /** labelled pairs Jev answered */
+    pairs: number;
+    /** label relevant / not relevant: picks Jev made (>= bar yes, <= 1-bar no), how many disagree, unsure */
+    relevant: {
+        pairs: number;
+        yes: number;
+        no: number;
+        unsure: number;
+    };
+    notRelevant: {
+        pairs: number;
+        yes: number;
+        no: number;
+        unsure: number;
+    };
+    /** every pick (yes or no): agreement with the labels */
+    picks: number;
+    wrong: number;
+    agreement: number | null;
+    unsureRate: number;
+    /** yes picks alone (the side that would inject) */
+    yesPicks: number;
+    yesWrong: number;
+    /** no picks alone (the side that would filter) */
+    noPicks: number;
+    noWrong: number;
+    /**
+     * "jev": Jev alone may judge (its yes picks and its no picks each meet the bar);
+     * "hybrid": its no picks meet the bar — Jev filters, the rest (yes and unsure) go to Claude;
+     * "claude": neither side does.
+     */
+    verdict: "jev" | "hybrid" | "claude";
+}
+declare function calibrateJudge(labels: Judgment[], jev: JevJudgment[], bar?: number): JudgeCalibration;
+interface GateRow {
+    threshold: number;
+    /** cases with a candidate fact (first fact in the top hits scoring >= threshold) */
+    candidates: number;
+    /** candidates Jev has not answered yet (ask, then re-run) */
+    missing: number;
+    /** candidates Jev said yes to at >= the bar: would be injected */
+    injected: number;
+    judged: number;
+    correct: number;
+    precision: number | null;
+    coverage: number;
+    meetsBar: boolean;
+}
+/**
+ * The failure hook's Jev gate, replayed: per threshold T, the candidate is the first fact among the top
+ * `topK` hits scoring >= T. `confirm` injects it only when Jev scores it >= the bar; `veto` injects it unless
+ * Jev scores it <= 1 - bar (a confident no). Precision is measured on the injected candidates that carry a label.
+ */
+declare function evaluateGate(results: CaseResult[], judgments: Judgment[], jev: JevJudgment[], opts?: {
+    thresholds?: number[];
+    topK?: number;
+    bar?: number;
+    isCandidate?: (path: string) => boolean;
+    mode?: "confirm" | "veto";
+}): {
+    rows: GateRow[];
+    missing: {
+        case: string;
+        path: string;
+    }[];
+};
+declare function formatGate(rows: GateRow[], mode?: "confirm" | "veto"): string;
+
+/**
+ * Adoption gate for learned skills (v1.7): turns eval scores into adopt / keep-draft / reject. Pure — no I/O.
+ * A new skill must trigger on its own evidence, stay quiet on near-misses and beat doing the task without it;
+ * a patch must not make any score worse. A failing draft stays a draft with its scores.
+ */
+/** A skill that fires on fewer than half its own held-out prompts is not findable. */
+declare const GATE_MIN_POSITIVE_RATE = 0.5;
+/** More than a quarter false triggers on near-misses means it would hijack unrelated work. */
+declare const GATE_MAX_FALSE_TRIGGER_RATE = 0.25;
+/** Held-out trigger rates and task pass rates, each 0..1 or null when not measured. */
+interface SkillScores {
+    positiveRate: number | null;
+    falseTriggerRate: number | null;
+    taskWith: number | null;
+    taskWithout: number | null;
+}
+interface GateVerdict {
+    verdict: "adopt" | "keep-draft" | "reject";
+    reasons: string[];
+}
+declare function gateSkill(candidate: SkillScores, current?: SkillScores): GateVerdict;
+
+interface CandidatePrompt {
+    session: string;
+    text: string;
+}
+interface EvalPrompt {
+    text: string;
+    should_trigger: boolean;
+    split: "train" | "heldout";
+}
+/** Same prompt, same side of the split, on every machine. */
+declare const splitOf: (text: string) => EvalPrompt["split"];
+declare function buildEvalSet(skill: ParsedSkill, candidates: CandidatePrompt[], opts?: {
+    maxNegatives?: number;
+}): EvalPrompt[];
+
+type Verify = {
+    kind: "command";
+    command: string;
+} | {
+    kind: "prose";
+    text: string;
+} | {
+    kind: "none";
+};
+/** The `## Verify` section as a command (fenced block, or a leading inline-backtick span) or as prose. */
+declare function parseVerify(body: string): Verify;
+interface TaskArm {
+    passed: boolean;
+    evidence: string;
+    /** the run's final text */
+    finalText: string;
+    error?: string;
+}
+interface TaskReport {
+    skill: string;
+    verify: Verify;
+    with: TaskArm;
+    without: TaskArm;
+}
+interface TaskOptions {
+    repoRoot: string;
+    skillRaw: string;
+    prompt: string;
+    env?: NodeJS.ProcessEnv;
+    maxTurns?: number;
+    timeoutMs?: number;
+    verifyTimeoutMs?: number;
+}
+declare function runTaskEval(o: TaskOptions): Promise<TaskReport>;
+
+interface DraftView {
+    id: string;
+    kind: DraftRecord["kind"];
+    name: string;
+    scope: string;
+    destination: string;
+    scope_why?: string;
+    provenance: SkillLoopMeta["provenance"] | null;
+    warnings: string[];
+    evals?: Record<string, unknown>;
+    promotion?: DraftRecord["promotion"];
+    global_candidate?: boolean;
+    /** the Verify command a task eval would run, shown before anyone runs it */
+    verify: ReturnType<typeof parseVerify>;
+    text: string;
+    diff?: string;
+}
+declare function describeDrafts(repo: string, env?: NodeJS.ProcessEnv): DraftView[];
+declare function approveDraft(repo: string, id: string, opts?: {
+    promote?: boolean;
+    override?: string;
+    env?: NodeJS.ProcessEnv;
+}): LedgerEntry;
+declare function rejectDraft(repo: string, id: string, why?: string): LedgerEntry;
+/** Run the evals on a draft and store the scores and the gate's verdict in its record. */
+declare function evalDraft(repo: string, id: string, opts?: {
+    task?: boolean;
+    env?: NodeJS.ProcessEnv;
+}): Promise<{
+    at: string;
+    prompts: number;
+    runs: number;
+    heldout: Rates;
+    train: Rates;
+    task: unknown;
+    gate: GateVerdict;
+}>;
+
+declare function proposeMerges(repo: string, env?: NodeJS.ProcessEnv): Promise<{
+    drafted: string[];
+    skipped: string[];
+}>;
+
+declare const MAX_TRIGGER_RUNS = 3;
+declare const evalCachePath: (env?: NodeJS.ProcessEnv) => string;
+interface PromptTrigger extends EvalPrompt {
+    triggers: number;
+    runs: number;
+    /** a majority of the runs called the skill */
+    triggered: boolean;
+    cached: boolean;
+    error?: string;
+}
+interface Rates {
+    n: number;
+    /** share of should-trigger prompts that triggered; null when there are none */
+    positiveRate: number | null;
+    /** share of near-miss prompts that triggered; null when there are none */
+    falseTriggerRate: number | null;
+    /** prompts that behaved as expected / n */
+    accuracy: number | null;
+}
+interface TriggerReport {
+    skill: string;
+    results: PromptTrigger[];
+    train: Rates;
+    heldout: Rates;
+    /** claude runs started (0 when everything was cached) */
+    runs: number;
+}
+declare function ratesOf(rs: PromptTrigger[]): Rates;
+/** A scratch dir with the skill under test and copies of the repo's other project skills. The caller removes it. */
+declare function makeScratch(repoRoot: string, name: string, skillRaw: string): string;
+interface TriggerOptions {
+    repoRoot: string;
+    /** the skill file as it is on disk (or a candidate version of it) */
+    skillRaw: string;
+    env?: NodeJS.ProcessEnv;
+    timeoutMs?: number;
+}
+declare function runTrigger(prompts: EvalPrompt[], o: TriggerOptions): Promise<TriggerReport>;
+
+declare const MAX_TUNE_ITERATIONS = 3;
+interface TuneCandidate {
+    description: string;
+    train: number | null;
+    heldout: number | null;
+}
+interface TuneReport {
+    original: TuneCandidate;
+    best: TuneCandidate;
+    /** the best candidate is not the original */
+    improved: boolean;
+    candidates: TuneCandidate[];
+}
+/** The skill file with its frontmatter description replaced and nothing else changed. */
+declare function withDescription(raw: string, description: string): string;
+declare function tuneDescription(o: {
+    repoRoot: string;
+    skillRaw: string;
+    prompts: EvalPrompt[];
+    env?: NodeJS.ProcessEnv;
+    maxIterations?: number;
+}): Promise<TuneReport>;
+
+/**
+ * Skill-creator's `evals/evals.json` (references/schemas.md), read and written as-is so evals made here
+ * open in skill-creator and the other way round.
+ */
+interface EvalCase {
+    id: number;
+    prompt: string;
+    expected_output: string;
+    /** input file paths, relative to the skill root */
+    files?: string[];
+    expectations: string[];
+}
+interface EvalsFile {
+    skill_name: string;
+    evals: EvalCase[];
+}
+declare function parseEvals(text: string): EvalsFile;
+declare const renderEvals: (f: EvalsFile) => string;
 
-export { type ApplyPatchOptions, type ApplyPatchResult, type CaseResult, type ChangeSet, type DriftFinding, Embedder, type FailureCase, type FailureEvalReport, FrontmatterManager, GraphBuilder, type GraphEdge, type GraphNode, type HealthcheckOptions, type HealthcheckResult, type Severity as HealthcheckSeverity, type Tier as HealthcheckTier, INDEX_FILE, INDEX_OVERFLOW_THRESHOLD, type IndexEntry, type IndexedDocument, Indexer, type IngestInput, type IngestPreview, type IngestSource, type IngestUnit, type Judgment, type LintFinding, type LintReport, type LogEntry, type LogEventInput, type LogQueryOptions, type ModeSummary, NoteCrud, type PromoteInput, type PromotePreview, type RegenResult, type RegenerateContractOptions, type RegenerateContractResult, type SearchResult, type SessionFinishInput, SessionManager, type SessionStartOptions, type SessionState, type SessionStatus, type Severity$1 as Severity, type SynthesizeNoteInput, type SynthesizePreview, TagManager, TextSearch, type ThresholdRow, type ToolSummary, type VaultSchema, type VaultStats, VectorIndex, type VerificationRecord, Watcher, applyPatch, buildIngestChangeSet, buildPromoteChangeSet, buildSynthesizeChangeSet, deriveProjectRoot, deriveSessionDir, evaluateFailures, filterToDrift, formatDriftBanner, formatFailureEval, formatLintReport, inspectAgentsContract, installDefaultSchema, lintVault, loadSchema, logEvent, logQuery, regenDirectoryIndex, regenIndexesForPaths, regenerateAgentsContract, runHealthcheck, validateNote };
+export { type ApplyPatchOptions, type ApplyPatchResult, type CandidatePrompt, type CaseResult, type ChangeSet, DraftRecord, type DriftFinding, Embedder, type EvalCase, type EvalPrompt, type EvalsFile, type FailureCase, type FailureEvalReport, FrontmatterManager, GATE_MAX_FALSE_TRIGGER_RATE, GATE_MIN_POSITIVE_RATE, type GateRow, type GateVerdict, GraphBuilder, type GraphEdge, type GraphNode, type HealthcheckOptions, type HealthcheckResult, type Severity as HealthcheckSeverity, type Tier as HealthcheckTier, INDEX_FILE, INDEX_OVERFLOW_THRESHOLD, type IndexEntry, type IndexedDocument, Indexer, type IngestInput, type IngestPreview, type IngestSource, type IngestUnit, type JevJudgment, type JudgeCalibration, type Judgment, type LintFinding, type LintReport, type LogEntry, type LogEventInput, type LogQueryOptions, MAX_TRIGGER_RUNS, MAX_TUNE_ITERATIONS, type ModeSummary, NoteCrud, ParsedSkill, type PromoteInput, type PromotePreview, type PromptTrigger, type Rates, type RegenResult, type RegenerateContractOptions, type RegenerateContractResult, type SearchResult, type SessionFinishInput, SessionManager, type SessionStartOptions, type SessionState, type SessionStatus, type Severity$1 as Severity, SkillLoopMeta, type SkillScores, type SynthesizeNoteInput, type SynthesizePreview, TagManager, type TaskArm, type TaskOptions, type TaskReport, TextSearch, type ThresholdRow, type ToolSummary, type TriggerOptions, type TriggerReport, type TuneCandidate, type TuneReport, type VaultSchema, type VaultStats, VectorIndex, type VerificationRecord, type Verify, Watcher, applyPatch, approveDraft, buildEvalSet, buildIngestChangeSet, buildPromoteChangeSet, buildSynthesizeChangeSet, calibrateJudge, deriveProjectRoot, deriveSessionDir, describeDrafts, evalCachePath, evalDraft, evaluateFailures, evaluateGate, filterToDrift, formatDriftBanner, formatFailureEval, formatGate, formatLintReport, gateSkill, inspectAgentsContract, installDefaultSchema, lintVault, loadSchema, logEvent, logQuery, makeScratch, meetsBar, parseEvals, parseVerify, proposeMerges, ratesOf, regenDirectoryIndex, regenIndexesForPaths, regenerateAgentsContract, rejectDraft, renderEvals, runHealthcheck, runTaskEval, runTrigger, splitOf, tuneDescription, validateNote, withDescription };

package/dist/core/index.js

@@ -1,17 +1,46 @@
+import {
+  calibrateJudge,
+  evaluateFailures,
+  evaluateGate,
+  formatFailureEval,
+  formatGate,
+  meetsBar
+} from "../chunk-PJXYCCI2.js";
+import {
+  GATE_MAX_FALSE_TRIGGER_RATE,
+  GATE_MIN_POSITIVE_RATE,
+  approveDraft,
+  describeDrafts,
+  evalDraft,
+  gateSkill,
+  rejectDraft
+} from "../chunk-BEACL25M.js";
+import {
+  proposeMerges
+} from "../chunk-NCGM36NX.js";
 import {
   filterToDrift,
   formatDriftBanner,
   runHealthcheck
-} from "../chunk-7PNF3AP2.js";
+} from "../chunk-34VN47IW.js";
 import {
-  evaluateFailures,
-  formatFailureEval
-} from "../chunk-5F5ZIAW2.js";
+  buildBrief,
+  draftsDir,
+  listDrafts,
+  reviewSession
+} from "../chunk-P3GLY42T.js";
 import {
-  commandVerbs,
-  errorSignal,
-  failureQuery
-} from "../chunk-5LQIWCLK.js";
+  curate,
+  restore,
+  verifySkills
+} from "../chunk-CATPGINC.js";
+import {
+  readLedger,
+  rollback
+} from "../chunk-TKHWVISV.js";
+import {
+  decideScope
+} from "../chunk-3FPUBAEW.js";
 import {
   FrontmatterManager,
   INDEX_FILE,
@@ -27,84 +56,205 @@ import {
   regenDirectoryIndex,
   regenIndexesForPaths,
   regenerateAgentsContract
-} from "../chunk-BBP3DG2U.js";
+} from "../chunk-AIXQFTSB.js";
 import {
   Embedder,
   GraphBuilder,
   TextSearch,
   VectorIndex
-} from "../chunk-44BQDRXD.js";
+} from "../chunk-SHSOCFJH.js";
 import {
   formatLintReport,
   lintVault
-} from "../chunk-CAX46XLY.js";
+} from "../chunk-VBLCUWT4.js";
 import {
   installDefaultSchema,
   loadSchema,
   validateNote
-} from "../chunk-FURCIJBO.js";
+} from "../chunk-Y7H76Q7F.js";
 import "../chunk-5ZKNO6ZD.js";
-import "../chunk-NBY4TRP7.js";
-import "../chunk-FTRXH2WC.js";
-import "../chunk-XAXK7NM4.js";
+import "../chunk-7M34JDTH.js";
+import "../chunk-7UAVDOI6.js";
+import "../chunk-EXAUVIGW.js";
 import {
   SessionManager,
   deriveProjectRoot,
   deriveSessionDir
-} from "../chunk-LGQPP5FQ.js";
+} from "../chunk-EYVFC745.js";
+import {
+  MAX_TUNE_ITERATIONS,
+  tuneDescription,
+  withDescription
+} from "../chunk-OT3MV7XF.js";
+import {
+  MAX_TRIGGER_RUNS,
+  buildEvalSet,
+  evalCachePath,
+  makeScratch,
+  ratesOf,
+  runTrigger,
+  splitOf
+} from "../chunk-MQS7JEBD.js";
+import {
+  parseVerify,
+  runTaskEval
+} from "../chunk-DBFD3MTT.js";
+import "../chunk-IEZVFKUT.js";
+import {
+  SKILL_SCOPES,
+  SKILL_SECTIONS,
+  SKILL_STATUSES,
+  findSkills,
+  lintSkill,
+  lintSkills,
+  parseSkill,
+  renderSkill
+} from "../chunk-ZSWI3Y4Y.js";
 import {
   Indexer
-} from "../chunk-IGHCVAAL.js";
+} from "../chunk-CJUY55GG.js";
+import "../chunk-J7LYDRML.js";
 import {
   logEvent,
   logQuery
-} from "../chunk-SX427M2R.js";
+} from "../chunk-XKGK643R.js";
+import {
+  commandVerbs,
+  errorSignal,
+  failureQuery
+} from "../chunk-5LQIWCLK.js";
+import {
+  describeFeature,
+  featureOn,
+  featureState,
+  jevAvailable
+} from "../chunk-VQCNWRTL.js";
+import {
+  JEV_BAR,
+  askJev,
+  failureState,
+  jevSpendToday,
+  jevVerdict,
+  relevanceQuestion
+} from "../chunk-GYR7U6KA.js";
+import "../chunk-NIZLBNH4.js";
+import "../chunk-R6GNP7DS.js";
 import {
   REDACTED,
   redact,
   redactDeep
-} from "../chunk-OEF5U5GV.js";
+} from "../chunk-H2BES6FU.js";
 import "../chunk-PZ5AY32C.js";
+
+// src/core/skill-eval/evals-json.ts
+function parseEvals(text) {
+  const j = JSON.parse(text);
+  if (typeof j?.skill_name !== "string" || !Array.isArray(j.evals)) throw new Error("evals.json needs skill_name and an evals array");
+  const ids = /* @__PURE__ */ new Set();
+  for (const e of j.evals) {
+    if (!Number.isInteger(e?.id) || typeof e.prompt !== "string" || typeof e.expected_output !== "string" || !Array.isArray(e.expectations) || e.expectations.some((x) => typeof x !== "string"))
+      throw new Error(`evals.json: bad eval ${JSON.stringify(e?.id)}: id (integer), prompt, expected_output and expectations (strings) are required`);
+    if (e.files !== void 0 && (!Array.isArray(e.files) || e.files.some((x) => typeof x !== "string"))) throw new Error(`evals.json: eval ${e.id}: files must be strings`);
+    if (ids.has(e.id)) throw new Error(`evals.json: duplicate id ${e.id}`);
+    ids.add(e.id);
+  }
+  return j;
+}
+var renderEvals = (f) => JSON.stringify(f, null, 2) + "\n";
 export {
   Embedder,
   FrontmatterManager,
+  GATE_MAX_FALSE_TRIGGER_RATE,
+  GATE_MIN_POSITIVE_RATE,
   GraphBuilder,
   INDEX_FILE,
   INDEX_OVERFLOW_THRESHOLD,
   Indexer,
+  JEV_BAR,
+  MAX_TRIGGER_RUNS,
+  MAX_TUNE_ITERATIONS,
   NoteCrud,
   REDACTED,
+  SKILL_SCOPES,
+  SKILL_SECTIONS,
+  SKILL_STATUSES,
   SessionManager,
   TagManager,
   TextSearch,
   VectorIndex,
   Watcher,
   applyPatch,
+  approveDraft,
+  askJev,
+  buildBrief,
+  buildEvalSet,
   buildIngestChangeSet,
   buildPromoteChangeSet,
   buildSynthesizeChangeSet,
+  calibrateJudge,
   commandVerbs,
+  curate,
+  decideScope,
   deriveProjectRoot,
   deriveSessionDir,
+  describeDrafts,
+  describeFeature,
+  draftsDir,
   errorSignal,
+  evalCachePath,
+  evalDraft,
   evaluateFailures,
+  evaluateGate,
   failureQuery,
+  failureState,
+  featureOn,
+  featureState,
   filterToDrift,
+  findSkills,
   formatDriftBanner,
   formatFailureEval,
+  formatGate,
   formatLintReport,
+  gateSkill,
   inspectAgentsContract,
   installDefaultSchema,
+  jevAvailable,
+  jevSpendToday,
+  jevVerdict,
+  lintSkill,
+  lintSkills,
   lintVault,
+  listDrafts,
   loadSchema,
   logEvent,
   logQuery,
+  makeScratch,
+  meetsBar,
+  parseEvals,
+  parseSkill,
+  parseVerify,
+  proposeMerges,
+  ratesOf,
+  readLedger,
   redact,
   redactDeep,
   regenDirectoryIndex,
   regenIndexesForPaths,
   regenerateAgentsContract,
+  rejectDraft,
+  relevanceQuestion,
+  renderEvals,
+  renderSkill,
+  restore,
+  reviewSession,
+  rollback,
   runHealthcheck,
-  validateNote
+  runTaskEval,
+  runTrigger,
+  splitOf,
+  tuneDescription,
+  validateNote,
+  verifySkills,
+  withDescription
 };
 //# sourceMappingURL=index.js.map

package/dist/core/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"sources":["../../src/core/skill-eval/evals-json.ts"],"sourcesContent":["/**\n * Skill-creator's `evals/evals.json` (references/schemas.md), read and written as-is so evals made here\n * open in skill-creator and the other way round.\n */\nexport interface EvalCase {\n  id: number;\n  prompt: string;\n  expected_output: string;\n  /** input file paths, relative to the skill root */\n  files?: string[];\n  expectations: string[];\n}\n\nexport interface EvalsFile {\n  skill_name: string;\n  evals: EvalCase[];\n}\n\nexport function parseEvals(text: string): EvalsFile {\n  const j = JSON.parse(text);\n  if (typeof j?.skill_name !== \"string\" || !Array.isArray(j.evals)) throw new Error(\"evals.json needs skill_name and an evals array\");\n  const ids = new Set<number>();\n  for (const e of j.evals) {\n    if (!Number.isInteger(e?.id) || typeof e.prompt !== \"string\" || typeof e.expected_output !== \"string\" || !Array.isArray(e.expectations) || e.expectations.some((x: unknown) => typeof x !== \"string\"))\n      throw new Error(`evals.json: bad eval ${JSON.stringify(e?.id)}: id (integer), prompt, expected_output and expectations (strings) are required`);\n    if (e.files !== undefined && (!Array.isArray(e.files) || e.files.some((x: unknown) => typeof x !== \"string\"))) throw new Error(`evals.json: eval ${e.id}: files must be strings`);\n    if (ids.has(e.id)) throw new Error(`evals.json: duplicate id ${e.id}`);\n    ids.add(e.id);\n  }\n  return j as EvalsFile;\n}\n\nexport const renderEvals = (f: EvalsFile): string => JSON.stringify(f, null, 2) + \"\\n\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkBO,SAAS,WAAW,MAAyB;AAClD,QAAM,IAAI,KAAK,MAAM,IAAI;AACzB,MAAI,OAAO,GAAG,eAAe,YAAY,CAAC,MAAM,QAAQ,EAAE,KAAK,EAAG,OAAM,IAAI,MAAM,gDAAgD;AAClI,QAAM,MAAM,oBAAI,IAAY;AAC5B,aAAW,KAAK,EAAE,OAAO;AACvB,QAAI,CAAC,OAAO,UAAU,GAAG,EAAE,KAAK,OAAO,EAAE,WAAW,YAAY,OAAO,EAAE,oBAAoB,YAAY,CAAC,MAAM,QAAQ,EAAE,YAAY,KAAK,EAAE,aAAa,KAAK,CAAC,MAAe,OAAO,MAAM,QAAQ;AAClM,YAAM,IAAI,MAAM,wBAAwB,KAAK,UAAU,GAAG,EAAE,CAAC,iFAAiF;AAChJ,QAAI,EAAE,UAAU,WAAc,CAAC,MAAM,QAAQ,EAAE,KAAK,KAAK,EAAE,MAAM,KAAK,CAAC,MAAe,OAAO,MAAM,QAAQ,GAAI,OAAM,IAAI,MAAM,oBAAoB,EAAE,EAAE,yBAAyB;AAChL,QAAI,IAAI,IAAI,EAAE,EAAE,EAAG,OAAM,IAAI,MAAM,4BAA4B,EAAE,EAAE,EAAE;AACrE,QAAI,IAAI,EAAE,EAAE;AAAA,EACd;AACA,SAAO;AACT;AAEO,IAAM,cAAc,CAAC,MAAyB,KAAK,UAAU,GAAG,MAAM,CAAC,IAAI;","names":[]}