@shahimat/harness 0.2.0 → 0.3.0

package/README.md

@@ -25,6 +25,16 @@ npx -y @shahimat/harness@<version> <команда> --root .
 - `harness adapters sync` — файлы под Claude Code и Codex из
   `AGENTS.md` и `.agents/`: `CLAUDE.md`, копии skills, субагенты,
   выключенная memory агента.
+- `harness expect init` — каркас ожиданий в проекте: конфиг vitest,
+  пример файла с бюджетом, npm-скрипты, `.gitignore`.
+- `harness expect report | lint | judge [--apply]` — ожидания в форме
+  vitest (`expectations/*.expect.ts`): дерево со статусами, проверка
+  заголовков, пакетная смысловая проверка судьёй-агентом с кэшем
+  вердиктов. Помощники для проверок — `@shahimat/harness/expect`
+  (нужен vitest в проекте): `crit` / `warn` / `note` / `budget`,
+  `expectAtMost` (info при > 90% порога), зонды по репозиторию,
+  `judged`, проверка JSON Schema (`expectSchema`, `dataFiles`,
+  `frontmatters`).
 - `harness index build | check --raw-base <url>` — индекс
   `prompts/index.yml` репозитория промптов.
 
@@ -34,7 +44,7 @@ npx -y @shahimat/harness@<version> <команда> --root .
 ## `context/harness.yml`
 
 ```yaml
-version: 0.2.0
+version: 0.3.0
 adapters: [claude-code, codex]
 checks:
   changelog:

package/dist/cli.js

@@ -4,6 +4,7 @@ import { runAdapters } from './commands/adapters.js';
 import { runChangelog } from './commands/changelog.js';
 import { runCheck } from './commands/check.js';
 import { runContext } from './commands/context.js';
+import { runExpect } from './commands/expect.js';
 import { runIndex } from './commands/prompt-index.js';
 import { UsageError } from './diagnostics.js';
 const USAGE = `Использование:
@@ -11,6 +12,7 @@ const USAGE = `Использование:
   harness adapters sync [--root <dir>]
   harness changelog lint [--root <dir>]
   harness context index [--root <dir>]
+  harness expect init | report | lint | judge [--apply] [--root <dir>]
   harness index build --raw-base <url> [--root <dir>] [--out <file>]
   harness index check --raw-base <url> [--root <dir>]
 
@@ -23,6 +25,7 @@ export async function main(argv, now = new Date()) {
             root: { type: 'string', default: '.' },
             out: { type: 'string' },
             'raw-base': { type: 'string' },
+            apply: { type: 'boolean' },
             help: { type: 'boolean', short: 'h' },
         },
     });
@@ -35,6 +38,8 @@ export async function main(argv, now = new Date()) {
         args.out = values.out;
     if (values['raw-base'] !== undefined)
         args.rawBase = values['raw-base'];
+    if (values.apply === true)
+        args.apply = true;
     const [group, command] = positionals;
     switch (group) {
         case 'adapters':
@@ -45,6 +50,8 @@ export async function main(argv, now = new Date()) {
             return runChangelog(command, args);
         case 'context':
             return runContext(command, args);
+        case 'expect':
+            return runExpect(command, args);
         case 'index':
             return runIndex(command, args);
         default:

package/dist/commands/expect.d.ts

@@ -0,0 +1,3 @@
+import type { CommandArgs } from './types.ts';
+export declare const EXPECT_CONFIG = "expectations/vitest.config.ts";
+export declare function runExpect(command: string | undefined, args: CommandArgs): Promise<number>;

package/dist/commands/expect.js

@@ -0,0 +1,303 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync, rmSync } from 'node:fs';
+import { mkdir, readdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { UsageError } from '../diagnostics.js';
+import { applyAnswers, applyLintAnswer, planBatches, renderBatch, renderLintBatch } from '../expect/batch.js';
+import { readEvidence, shaOf } from '../expect/evidence.js';
+import { COLLECT_ENV, idOf } from '../expect/judge.js';
+import { BUDGET_TITLE } from '../expect/levels.js';
+import { lintTitles } from '../expect/lint.js';
+import { loadVerdicts, saveVerdicts, VERDICTS_PATH } from '../expect/verdicts.js';
+export const EXPECT_CONFIG = 'expectations/vitest.config.ts';
+const JUDGE_DIR = 'expectations/.judge';
+/** Запускает vitest проекта на файлах ожиданий и возвращает результаты. */
+function runVitest(root, env = {}) {
+    if (!existsSync(path.join(root, EXPECT_CONFIG)))
+        throw new UsageError(`нет ${EXPECT_CONFIG}`);
+    const require = createRequire(path.join(root, 'package.json'));
+    let vitestPkg;
+    try {
+        vitestPkg = require.resolve('vitest/package.json');
+    }
+    catch {
+        throw new UsageError('vitest не установлен в проекте: npm i -D vitest');
+    }
+    const bin = JSON.parse(readFileSync(vitestPkg, 'utf8')).bin['vitest'] ?? '';
+    const out = path.join(tmpdir(), `harness-expect-${process.pid}-${Date.now()}.json`);
+    spawnSync(process.execPath, [path.join(path.dirname(vitestPkg), bin), 'run', '--root', root, '--config', EXPECT_CONFIG, '--reporter=json', `--outputFile=${out}`], { cwd: root, env: { ...process.env, ...env, HARNESS_EXPECT_ROOT: root }, stdio: ['ignore', 'ignore', 'inherit'] });
+    if (!existsSync(out))
+        throw new Error('vitest не записал отчёт');
+    const data = JSON.parse(readFileSync(out, 'utf8'));
+    rmSync(out, { force: true });
+    return data.testResults.flatMap((file) => file.assertionResults.map((a) => {
+        const result = {
+            file: path.relative(root, file.name).split(path.sep).join('/'),
+            path: a.ancestorTitles,
+            title: a.title,
+            status: a.status,
+            message: (a.failureMessages[0] ?? '').split('\n')[0] ?? '',
+            // Обычный it() без обёртки — crit: формальная проверка по умолчанию.
+            level: a.meta?.level ?? 'crit',
+            notes: a.meta?.notes ?? [],
+        };
+        if (a.meta?.budget !== undefined)
+            result.budget = a.meta.budget;
+        return result;
+    }));
+}
+const fullName = (t) => [...t.path, t.title].join(' > ');
+function byFile(results) {
+    const files = new Map();
+    for (const r of results)
+        files.set(r.file, [...(files.get(r.file) ?? []), r]);
+    return files;
+}
+const titlesSha = (tests) => shaOf(tests.map(fullName).sort().join('\n'));
+const isPending = (t) => t.status === 'failed' && t.message.includes('нет свежего вердикта');
+async function report(args) {
+    const all = runVitest(args.root);
+    const store = await loadVerdicts();
+    const titleIssues = lintTitles(all.filter((r) => r.title !== BUDGET_TITLE).map((r) => ({ file: r.file, path: r.path, title: r.title })));
+    let blocked = false;
+    let total = { tests: 0, crit: 0, warn: 0, info: 0, pending: 0 };
+    for (const [file, tests] of byFile(all)) {
+        const budget = tests.find((t) => t.title === BUDGET_TITLE)?.budget ?? { crit: 0, warn: 0 };
+        const items = tests.filter((t) => t.title !== BUDGET_TITLE);
+        const count = { crit: 0, warn: 0, info: 0, pending: 0 };
+        console.log(file);
+        let prev = [];
+        for (const t of items) {
+            t.path.forEach((p, i) => {
+                if (prev[i] !== p)
+                    console.log(`${'  '.repeat(i + 1)}${p}`);
+            });
+            prev = t.path;
+            const pad = '  '.repeat(t.path.length + 1);
+            if (isPending(t)) {
+                count.pending++;
+                console.log(`${pad}? ${t.title}  — нужен вердикт судьи`);
+            }
+            else if (t.status === 'failed') {
+                count[t.level === 'warn' ? 'warn' : 'crit']++;
+                console.log(`${pad}${t.level === 'warn' ? '⚠' : '✗'} ${t.title}  — ${t.message}`);
+            }
+            else {
+                console.log(`${pad}${t.status === 'todo' ? '○' : t.status === 'passed' ? '✓' : '-'} ${t.title}`);
+            }
+            for (const n of t.notes)
+                console.log(`${pad}  ℹ ${n}`);
+            count.info += t.notes.length;
+        }
+        for (const d of titleIssues.filter((i) => i.title.file === file)) {
+            count[d.level]++;
+            console.log(`  ${d.level === 'crit' ? '✗' : '⚠'} заголовок «${d.title.title}» — ${d.message}`);
+        }
+        const lint = store.lint[file];
+        if (lint === undefined || lint.titles !== titlesSha(items)) {
+            count.pending++;
+            console.log('  ? смысловая проверка заголовков устарела — harness expect judge');
+        }
+        else {
+            const name = new Map(items.map((t) => [idOf(fullName(t)), t.title]));
+            for (const c of lint.contradictions)
+                console.log(`  ⚠ противоречие: «${name.get(c.a)}» ↔ «${name.get(c.b)}» — ${c.reason}`);
+            for (const u of lint.unmeasurable)
+                console.log(`  ⚠ неизмеримо: «${name.get(u.id)}» — ${u.reason}`);
+            count.warn += lint.contradictions.length + lint.unmeasurable.length;
+        }
+        const over = count.crit > budget.crit || count.warn > budget.warn || count.pending > 0;
+        blocked ||= over;
+        console.log(`  ${over ? '✗' : '✓'} crit ${count.crit}/${budget.crit} · warn ${count.warn}/${budget.warn} · info ${count.info}` +
+            (count.pending > 0 ? ` · ? ${count.pending} без вердикта` : ''));
+        total = {
+            tests: total.tests + items.length,
+            crit: total.crit + count.crit,
+            warn: total.warn + count.warn,
+            info: total.info + count.info,
+            pending: total.pending + count.pending,
+        };
+    }
+    console.log(`\nожиданий ${total.tests}: crit ${total.crit} · warn ${total.warn} · info ${total.info} · ? ${total.pending} — ${blocked ? 'бюджет превышен' : 'в бюджете'}`);
+    return blocked ? 1 : 0;
+}
+async function lint(args) {
+    const titles = runVitest(args.root)
+        .filter((r) => r.title !== BUDGET_TITLE)
+        .map((r) => ({ file: r.file, path: r.path, title: r.title }));
+    const diags = lintTitles(titles);
+    for (const d of diags)
+        console.error(`${d.level} ${d.title.file}: «${d.title.title}» — ${d.message}`);
+    console.log(diags.length === 0 ? `expect lint: ok (${titles.length})` : `expect lint: нарушений ${diags.length}`);
+    return diags.length === 0 ? 0 : 1;
+}
+async function judgePrepare(args) {
+    const dir = path.join(args.root, JUDGE_DIR);
+    await rm(dir, { recursive: true, force: true });
+    const pendingDir = path.join(dir, 'pending');
+    const results = runVitest(args.root, { [COLLECT_ENV]: pendingDir });
+    const items = [];
+    if (existsSync(pendingDir)) {
+        for (const f of (await readdir(pendingDir)).sort())
+            items.push(JSON.parse(await readFile(path.join(pendingDir, f), 'utf8')));
+        await rm(pendingDir, { recursive: true, force: true });
+    }
+    const plan = { batches: [], lint: [] };
+    for (const [i, batch] of planBatches(items).entries()) {
+        const task = `${JUDGE_DIR}/batch-${i + 1}.md`;
+        const answer = `${JUDGE_DIR}/batch-${i + 1}.answer.json`;
+        await mkdir(dir, { recursive: true });
+        await writeFile(path.join(args.root, task), renderBatch(batch, answer), 'utf8');
+        plan.batches.push({ task, answer, items: batch.items });
+    }
+    const store = await loadVerdicts();
+    for (const [file, all] of byFile(results)) {
+        const tests = all.filter((t) => t.title !== BUDGET_TITLE);
+        const sha = titlesSha(tests);
+        if (store.lint[file]?.titles === sha)
+            continue;
+        const n = plan.lint.length + 1;
+        const task = `${JUDGE_DIR}/lint-${n}.md`;
+        const answer = `${JUDGE_DIR}/lint-${n}.answer.json`;
+        const titles = tests.map((t) => ({ id: idOf(fullName(t)), title: fullName(t) }));
+        await mkdir(dir, { recursive: true });
+        await writeFile(path.join(args.root, task), renderLintBatch(file, titles, answer), 'utf8');
+        plan.lint.push({ task, answer, file, titles: sha, ids: titles.map((t) => t.id) });
+    }
+    if (plan.batches.length === 0 && plan.lint.length === 0) {
+        console.log('expect judge: всё свежее, судья не нужен');
+        return 0;
+    }
+    await writeFile(path.join(dir, 'plan.json'), JSON.stringify(plan, null, 2), 'utf8');
+    console.log(`expect judge: вопросов ${items.length} в пакетах ${plan.batches.length}, проверок заголовков ${plan.lint.length}`);
+    for (const t of [...plan.batches, ...plan.lint])
+        console.log(`  ${t.task} → ${t.answer}`);
+    console.log('Каждый файл — задание судье (субагенту), ответ — в указанный JSON. Затем: harness expect judge --apply');
+    return 1;
+}
+async function judgeApply(args) {
+    const planFile = path.join(args.root, JUDGE_DIR, 'plan.json');
+    if (!existsSync(planFile))
+        throw new UsageError('нет плана: сначала harness expect judge');
+    const plan = JSON.parse(await readFile(planFile, 'utf8'));
+    const store = await loadVerdicts();
+    const rejected = [];
+    const readJson = async (rel) => {
+        try {
+            return JSON.parse(await readFile(path.join(args.root, rel), 'utf8'));
+        }
+        catch {
+            return undefined;
+        }
+    };
+    for (const b of plan.batches) {
+        const answers = await readJson(b.answer);
+        if (answers === undefined) {
+            rejected.push(`${b.answer}: нет ответа`);
+            continue;
+        }
+        const texts = new Map();
+        for (const ref of new Set(b.items.flatMap((i) => i.evidence.map((e) => e.ref))))
+            texts.set(ref, await readEvidence(ref));
+        const result = applyAnswers(b.items, answers, texts, args.now);
+        Object.assign(store.verdicts, result.accepted);
+        for (const r of result.rejected)
+            rejected.push(`${b.answer}: ${r.id} — ${r.reason}`);
+    }
+    for (const l of plan.lint) {
+        const answer = await readJson(l.answer);
+        const { verdict, error } = applyLintAnswer(l.titles, new Set(l.ids), answer, args.now);
+        if (verdict === null)
+            rejected.push(`${l.answer}: ${error ?? 'нет ответа'}`);
+        else
+            store.lint[l.file] = verdict;
+    }
+    await saveVerdicts(store);
+    for (const r of rejected)
+        console.error(r);
+    if (rejected.length > 0) {
+        console.error(`expect judge --apply: отклонено ${rejected.length}; принятое сохранено в ${VERDICTS_PATH}`);
+        return 1;
+    }
+    await rm(path.join(args.root, JUDGE_DIR), { recursive: true, force: true });
+    console.log(`expect judge --apply: вердикты сохранены в ${VERDICTS_PATH}`);
+    return 0;
+}
+const INIT_CONFIG = `import { defineConfig } from 'vitest/config';
+
+// Ожидания: заголовки crit/warn — для человека, проверки — класс Check ниже в файле.
+// Отчёт: npm run expect. Вердикты судьи: npm run expect:judge → expect:apply.
+export default defineConfig({
+  test: {
+    include: ['expectations/**/*.expect.ts'],
+    testTimeout: 30_000,
+  },
+});
+`;
+const initExample = (name) => `import { describe, it } from 'vitest';
+import { budget } from '@shahimat/harness/expect';
+
+budget({ crit: 0, warn: 0 });
+
+describe('${name}', () => {
+  it.todo('первое ожидание: одно утверждение до 200 символов, да/нет или число');
+});
+
+// ─────────────────────────────── проверки ───────────────────────────────
+
+class Check {}
+void Check;
+`;
+/** Каркас ожиданий в проекте; существующие файлы не трогаются. */
+async function init(args) {
+    const done = [];
+    const put = async (rel, content) => {
+        const abs = path.join(args.root, rel);
+        if (existsSync(abs))
+            return;
+        await mkdir(path.dirname(abs), { recursive: true });
+        await writeFile(abs, content, 'utf8');
+        done.push(`создан ${rel}`);
+    };
+    const name = path.basename(args.root);
+    await put(EXPECT_CONFIG, INIT_CONFIG);
+    await put(`expectations/${name}.expect.ts`, initExample(name));
+    const gitignore = path.join(args.root, '.gitignore');
+    const ignored = existsSync(gitignore) ? await readFile(gitignore, 'utf8') : '';
+    if (!ignored.split('\n').includes(`${JUDGE_DIR}/`)) {
+        await writeFile(gitignore, `${ignored}${ignored === '' || ignored.endsWith('\n') ? '' : '\n'}${JUDGE_DIR}/\n`, 'utf8');
+        done.push(`.gitignore: ${JUDGE_DIR}/`);
+    }
+    const pkgFile = path.join(args.root, 'package.json');
+    if (existsSync(pkgFile)) {
+        const pkg = JSON.parse(await readFile(pkgFile, 'utf8'));
+        const scripts = { expect: 'harness expect report --root .', 'expect:judge': 'harness expect judge --root .', 'expect:apply': 'harness expect judge --apply --root .' };
+        const added = Object.entries(scripts).filter(([k]) => pkg.scripts?.[k] === undefined);
+        if (added.length > 0) {
+            pkg.scripts = { ...pkg.scripts, ...Object.fromEntries(added) };
+            await writeFile(pkgFile, `${JSON.stringify(pkg, null, 2)}\n`, 'utf8');
+            done.push(`package.json: скрипты ${added.map(([k]) => k).join(', ')}`);
+        }
+    }
+    for (const line of done)
+        console.log(line);
+    console.log(done.length === 0 ? 'expect init: всё уже на месте' : 'expect init: готово');
+    console.log('Зависимости: npm i -D vitest @shahimat/harness [@shahimat/expectations]');
+    return 0;
+}
+export async function runExpect(command, args) {
+    switch (command) {
+        case 'init':
+            return init(args);
+        case 'report':
+            return report(args);
+        case 'lint':
+            return lint(args);
+        case 'judge':
+            return args.apply === true ? judgeApply(args) : judgePrepare(args);
+        default:
+            throw new UsageError(`неизвестная команда: expect ${command ?? ''}`.trimEnd());
+    }
+}

package/dist/commands/types.d.ts

@@ -3,6 +3,8 @@ export interface CommandArgs {
     root: string;
     out?: string;
     rawBase?: string;
+    /** `expect judge --apply`: применить ответы судьи. */
+    apply?: boolean;
     /** Текущий момент; подменяется в тестах. */
     now: Date;
 }

package/dist/expect/batch.d.ts

@@ -0,0 +1,44 @@
+import type { PendingItem } from './judge.ts';
+import type { LintVerdict, Verdict } from './verdicts.ts';
+export interface BatchLimits {
+    maxItems: number;
+    maxBytes: number;
+}
+export declare const DEFAULT_LIMITS: BatchLimits;
+export interface Batch {
+    items: PendingItem[];
+    /** Уникальные доказательства пакета — судья читает каждое один раз. */
+    refs: string[];
+    bytes: number;
+}
+/**
+ * Пакеты для судьи: ожидания с одинаковыми доказательствами — вместе,
+ * группы складываются в пакеты до лимита вопросов и объёма доказательств.
+ */
+export declare function planBatches(items: PendingItem[], limits?: BatchLimits): Batch[];
+export declare function renderBatch(batch: Batch, answerFile: string): string;
+export interface Answer {
+    id: string;
+    verdict: boolean;
+    ref: string;
+    quote: string;
+    reason: string;
+}
+export interface ApplyResult {
+    accepted: Record<string, Verdict>;
+    rejected: {
+        id: string;
+        reason: string;
+    }[];
+}
+/** Проверяет ответы судьи; цитата должна дословно встречаться в доказательстве. */
+export declare function applyAnswers(items: PendingItem[], answers: unknown, evidenceText: Map<string, string>, now: Date): ApplyResult;
+/** Смысловая проверка заголовков одного файла ожиданий — один проход. */
+export declare function renderLintBatch(file: string, titles: {
+    id: string;
+    title: string;
+}[], answerFile: string): string;
+export declare function applyLintAnswer(titlesSha: string, ids: Set<string>, answer: unknown, now: Date): {
+    verdict: LintVerdict | null;
+    error: string | null;
+};

package/dist/expect/batch.js

@@ -0,0 +1,157 @@
+import { containsQuote } from './evidence.js';
+export const DEFAULT_LIMITS = { maxItems: 25, maxBytes: 80_000 };
+/**
+ * Пакеты для судьи: ожидания с одинаковыми доказательствами — вместе,
+ * группы складываются в пакеты до лимита вопросов и объёма доказательств.
+ */
+export function planBatches(items, limits = DEFAULT_LIMITS) {
+    const groups = new Map();
+    for (const item of [...items].sort((a, b) => (a.id < b.id ? -1 : 1))) {
+        const key = item.evidence.map((e) => e.ref).sort().join('\n');
+        groups.set(key, [...(groups.get(key) ?? []), item]);
+    }
+    const batches = [];
+    const sizes = new Map();
+    const bytesOf = (refs) => [...refs].reduce((n, r) => n + (sizes.get(r) ?? 0), 0);
+    let current = { items: [], refs: new Set() };
+    const flush = () => {
+        if (current.items.length === 0)
+            return;
+        batches.push({ items: current.items, refs: [...current.refs].sort(), bytes: bytesOf(current.refs) });
+        current = { items: [], refs: new Set() };
+    };
+    for (const group of groups.values()) {
+        for (const e of group[0]?.evidence ?? [])
+            sizes.set(e.ref, e.bytes);
+        for (const item of group) {
+            const refs = new Set([...current.refs, ...item.evidence.map((e) => e.ref)]);
+            if (current.items.length >= limits.maxItems || (current.items.length > 0 && bytesOf(refs) > limits.maxBytes))
+                flush();
+            current.items.push(item);
+            for (const e of item.evidence)
+                current.refs.add(e.ref);
+        }
+    }
+    flush();
+    return batches;
+}
+export function renderBatch(batch, answerFile) {
+    const lines = [
+        '# Пакет для судьи ожиданий',
+        '',
+        'Ты — судья. Прочитай доказательства (каждое один раз) и ответь на',
+        'каждый вопрос: выполнено ли утверждение — да (true) или нет (false).',
+        'Отвечай только по доказательствам, без догадок.',
+        '',
+        'Для каждого ответа — дословная цитата (8–300 символов) из одного',
+        'доказательства и его ссылка (`ref`). Цитата проверяется программно:',
+        'не найдена в тексте — ответ отклоняется. Для «нет» — цитата того, что',
+        'противоречит или ближе всего к утверждению, и причина.',
+        '',
+        `Ответ — JSON-массив в файл \`${answerFile}\`:`,
+        '',
+        '```json',
+        '[{"id": "<id>", "verdict": true, "ref": "<ref>", "quote": "<цитата>", "reason": "<одна строка>"}]',
+        '```',
+        '',
+        '## Доказательства',
+        '',
+        'Ссылка `path#Заголовок` — раздел markdown с этим заголовком.',
+        '',
+        ...batch.refs.map((r) => `- \`${r}\``),
+        '',
+        '## Вопросы',
+        '',
+    ];
+    for (const item of batch.items) {
+        lines.push(`- \`${item.id}\` — ${item.question.split(' > ').join(' → ')}`);
+        lines.push(`  доказательства: ${item.evidence.map((e) => `\`${e.ref}\``).join(', ')}`);
+    }
+    return `${lines.join('\n')}\n`;
+}
+/** Проверяет ответы судьи; цитата должна дословно встречаться в доказательстве. */
+export function applyAnswers(items, answers, evidenceText, now) {
+    const result = { accepted: {}, rejected: [] };
+    if (!Array.isArray(answers)) {
+        result.rejected.push({ id: '*', reason: 'ответ — не JSON-массив' });
+        return result;
+    }
+    const byId = new Map(items.map((i) => [i.id, i]));
+    for (const raw of answers) {
+        const id = String(raw.id ?? '');
+        const item = byId.get(id);
+        if (item === undefined) {
+            result.rejected.push({ id, reason: 'неизвестный id' });
+            continue;
+        }
+        if (typeof raw.verdict !== 'boolean') {
+            result.rejected.push({ id, reason: 'verdict — не true/false' });
+            continue;
+        }
+        const ref = String(raw.ref ?? '');
+        if (!item.evidence.some((e) => e.ref === ref)) {
+            result.rejected.push({ id, reason: `ref «${ref}» не из доказательств вопроса` });
+            continue;
+        }
+        const quote = String(raw.quote ?? '');
+        if (quote.length > 300 || !containsQuote(evidenceText.get(ref) ?? '', quote)) {
+            result.rejected.push({ id, reason: 'цитата не найдена в доказательстве дословно' });
+            continue;
+        }
+        result.accepted[id] = {
+            question: item.question,
+            evidence: Object.fromEntries(item.evidence.map((e) => [e.ref, e.sha])),
+            verdict: raw.verdict,
+            quote,
+            ref,
+            reason: String(raw.reason ?? ''),
+            at: now.toISOString().slice(0, 10),
+        };
+    }
+    for (const item of items) {
+        if (!(item.id in result.accepted) && !result.rejected.some((r) => r.id === item.id)) {
+            result.rejected.push({ id: item.id, reason: 'нет ответа' });
+        }
+    }
+    return result;
+}
+/** Смысловая проверка заголовков одного файла ожиданий — один проход. */
+export function renderLintBatch(file, titles, answerFile) {
+    return [
+        '# Проверка заголовков ожиданий',
+        '',
+        `Файл: \`${file}\`. Каждая строка — ожидание человека к реализации.`,
+        'Найди:',
+        '',
+        '1. Противоречия — пары ожиданий, которые не могут быть выполнены',
+        '   одновременно.',
+        '2. Неизмеримые — ожидания, на которые нельзя ответить «да/нет» или',
+        '   числом (размыто, оценочно, без порога).',
+        '',
+        'Ничего не нашёл — пустые массивы. Не выдумывай проблем.',
+        '',
+        `Ответ — JSON в файл \`${answerFile}\`:`,
+        '',
+        '```json',
+        '{"contradictions": [{"a": "<id>", "b": "<id>", "reason": "<строка>"}], "unmeasurable": [{"id": "<id>", "reason": "<строка>"}]}',
+        '```',
+        '',
+        '## Ожидания',
+        '',
+        ...titles.map((t) => `- \`${t.id}\` — ${t.title}`),
+        '',
+    ].join('\n');
+}
+export function applyLintAnswer(titlesSha, ids, answer, now) {
+    const a = answer;
+    if (a === null || typeof a !== 'object' || !Array.isArray(a.contradictions) || !Array.isArray(a.unmeasurable)) {
+        return { verdict: null, error: 'ответ — не {contradictions: [], unmeasurable: []}' };
+    }
+    const bad = [...a.contradictions.flatMap((c) => [c.a, c.b]), ...a.unmeasurable.map((u) => u.id)].filter((id) => !ids.has(id));
+    if (bad.length > 0)
+        return { verdict: null, error: `неизвестные id: ${bad.join(', ')}` };
+    return {
+        verdict: { titles: titlesSha, contradictions: a.contradictions, unmeasurable: a.unmeasurable, at: now.toISOString().slice(0, 10) },
+        error: null,
+    };
+}

package/dist/expect/evidence.d.ts

@@ -0,0 +1,5 @@
+/** Ссылка на доказательство: `path` или `path#Заголовок` (раздел markdown). */
+export declare function readEvidence(ref: string): Promise<string>;
+export declare const shaOf: (text: string) => string;
+/** Сравнение цитаты с текстом без учёта пробелов, переносов и маркеров markdown. */
+export declare function containsQuote(text: string, quote: string): boolean;

package/dist/expect/evidence.js

@@ -0,0 +1,21 @@
+import { createHash } from 'node:crypto';
+import { readRepo, extractSection } from './repo.js';
+/** Ссылка на доказательство: `path` или `path#Заголовок` (раздел markdown). */
+export async function readEvidence(ref) {
+    const hash = ref.indexOf('#');
+    const file = hash === -1 ? ref : ref.slice(0, hash);
+    const text = await readRepo(file);
+    if (hash === -1)
+        return text;
+    const section = extractSection(text, ref.slice(hash + 1));
+    if (section === null)
+        throw new Error(`${ref}: раздел не найден`);
+    return section;
+}
+export const shaOf = (text) => createHash('sha256').update(text, 'utf8').digest('hex');
+/** Сравнение цитаты с текстом без учёта пробелов, переносов и маркеров markdown. */
+export function containsQuote(text, quote) {
+    const norm = (s) => s.replace(/[`*_>]/g, '').replace(/\s+/g, ' ').trim().toLowerCase();
+    const q = norm(quote);
+    return q.length >= 8 && norm(text).includes(q);
+}

package/dist/expect/index.d.ts

@@ -0,0 +1,4 @@
+export { judged } from './judge.ts';
+export { codeBlock, contract, doc, extractSection, indexEntries, module, modules, presets, readRepo, repoRoot, skill, skills, type ContractDoc, type Doc, type ModuleDoc, type PresetDoc, type SkillDoc, } from './repo.ts';
+export { dataFiles, expectSchema, frontmatters, schemaErrors, type Instance } from './schema.ts';
+export { budget, crit, expectAtMost, note, warn, type Budget, type Level } from './levels.ts';

package/dist/expect/index.js

@@ -0,0 +1,4 @@
+export { judged } from './judge.js';
+export { codeBlock, contract, doc, extractSection, indexEntries, module, modules, presets, readRepo, repoRoot, skill, skills, } from './repo.js';
+export { dataFiles, expectSchema, frontmatters, schemaErrors } from './schema.js';
+export { budget, crit, expectAtMost, note, warn } from './levels.js';

package/dist/expect/judge.d.ts

@@ -0,0 +1,24 @@
+/** Каталог, куда в режиме сбора пишутся ожидания без свежего вердикта. */
+export declare const COLLECT_ENV = "HARNESS_EXPECT_COLLECT";
+/** Ожидание, которому нужен вердикт судьи. */
+export interface PendingItem {
+    id: string;
+    question: string;
+    evidence: {
+        ref: string;
+        sha: string;
+        bytes: number;
+    }[];
+}
+/**
+ * Ключ вердикта: заголовок + доказательства. Один и тот же набор ожиданий
+ * (например, из @shahimat/expectations) проверяет разные файлы — вердикты
+ * не должны затирать друг друга.
+ */
+export declare const idOf: (question: string, refs?: string[]) => string;
+/**
+ * Смысловая проверка: вопрос — заголовок текущего `it`, доказательства —
+ * файлы или разделы (`path#Заголовок`). Вердикт берётся из кэша; нет
+ * свежего — тест падает с подсказкой `harness expect judge`.
+ */
+export declare function judged(evidence: string[]): Promise<void>;

package/dist/expect/judge.js

@@ -0,0 +1,50 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { expect } from 'vitest';
+import { readEvidence, shaOf } from './evidence.js';
+import { loadVerdicts } from './verdicts.js';
+/** Каталог, куда в режиме сбора пишутся ожидания без свежего вердикта. */
+export const COLLECT_ENV = 'HARNESS_EXPECT_COLLECT';
+/**
+ * Ключ вердикта: заголовок + доказательства. Один и тот же набор ожиданий
+ * (например, из @shahimat/expectations) проверяет разные файлы — вердикты
+ * не должны затирать друг друга.
+ */
+export const idOf = (question, refs = []) => shaOf([question, ...[...refs].sort()].join('\n')).slice(0, 12);
+let store = null;
+/**
+ * Смысловая проверка: вопрос — заголовок текущего `it`, доказательства —
+ * файлы или разделы (`path#Заголовок`). Вердикт берётся из кэша; нет
+ * свежего — тест падает с подсказкой `harness expect judge`.
+ */
+export async function judged(evidence) {
+    const question = expect.getState().currentTestName ?? '';
+    if (question === '')
+        throw new Error('judged() вызывается только внутри it()');
+    if (evidence.length === 0)
+        throw new Error('judged(): нужен хотя бы один файл-доказательство');
+    const id = idOf(question, evidence);
+    const refs = await Promise.all(evidence.map(async (ref) => {
+        const text = await readEvidence(ref);
+        return { ref, sha: shaOf(text), bytes: Buffer.byteLength(text, 'utf8') };
+    }));
+    store ??= loadVerdicts();
+    const cached = (await store).verdicts[id];
+    const fresh = cached !== undefined &&
+        cached.question === question &&
+        Object.keys(cached.evidence).length === refs.length &&
+        refs.every((r) => cached.evidence[r.ref] === r.sha);
+    if (!fresh) {
+        const dir = process.env[COLLECT_ENV];
+        if (dir !== undefined) {
+            await mkdir(dir, { recursive: true });
+            const item = { id, question, evidence: refs };
+            await writeFile(path.join(dir, `${id}.json`), JSON.stringify(item), 'utf8');
+            return;
+        }
+        throw new Error(`нет свежего вердикта судьи — запусти harness expect judge [${id}]`);
+    }
+    if (!cached.verdict) {
+        throw new Error(`судья: нет — ${cached.reason} (${cached.ref}: «${cached.quote}»)`);
+    }
+}

package/dist/expect/levels.d.ts

@@ -0,0 +1,25 @@
+/** Уровень ожидания: crit и warn считаются в бюджет файла, info — никогда. */
+export type Level = 'crit' | 'warn' | 'info';
+export interface Budget {
+    crit: number;
+    warn: number;
+}
+/** Заголовок служебного теста с бюджетом файла; в отчёт не попадает. */
+export declare const BUDGET_TITLE = "__budget__";
+/** Доля порога, после которой формальная метрика оставляет info. */
+export declare const NEAR_LIMIT = 0.9;
+type Body = () => unknown;
+/** Ожидание уровня crit: формальная метрика, нарушение блокирует при бюджете 0. */
+export declare const crit: (title: string, fn: Body) => void;
+/** Ожидание уровня warn: как правило — проверка судьёй. */
+export declare const warn: (title: string, fn: Body) => void;
+/** Пояснение для исполнителя в отчёте (уровень info, не блокирует). */
+export declare function note(text: string): void;
+/** Бюджет файла: сколько нарушений crit и warn допустимо. По умолчанию 0 / 0. */
+export declare function budget(value: Budget): void;
+/**
+ * Числовой порог: больше `limit` — нарушение; больше 90% порога —
+ * info «близко к порогу».
+ */
+export declare function expectAtMost(value: number, limit: number, label: string): void;
+export {};

package/dist/expect/levels.js

@@ -0,0 +1,43 @@
+import { expect, it } from 'vitest';
+/** Заголовок служебного теста с бюджетом файла; в отчёт не попадает. */
+export const BUDGET_TITLE = '__budget__';
+/** Доля порога, после которой формальная метрика оставляет info. */
+export const NEAR_LIMIT = 0.9;
+let notes = [];
+function levelled(level, title, fn) {
+    it(title, async (ctx) => {
+        const meta = ctx.task.meta;
+        meta['level'] = level;
+        notes = [];
+        try {
+            await fn();
+        }
+        finally {
+            meta['notes'] = notes;
+            notes = [];
+        }
+    });
+}
+/** Ожидание уровня crit: формальная метрика, нарушение блокирует при бюджете 0. */
+export const crit = (title, fn) => levelled('crit', title, fn);
+/** Ожидание уровня warn: как правило — проверка судьёй. */
+export const warn = (title, fn) => levelled('warn', title, fn);
+/** Пояснение для исполнителя в отчёте (уровень info, не блокирует). */
+export function note(text) {
+    notes.push(text);
+}
+/** Бюджет файла: сколько нарушений crit и warn допустимо. По умолчанию 0 / 0. */
+export function budget(value) {
+    it(BUDGET_TITLE, (ctx) => {
+        ctx.task.meta['budget'] = value;
+    });
+}
+/**
+ * Числовой порог: больше `limit` — нарушение; больше 90% порога —
+ * info «близко к порогу».
+ */
+export function expectAtMost(value, limit, label) {
+    if (value > limit * NEAR_LIMIT && value <= limit)
+        note(`${label}: ${value} из ${limit} — ${Math.round((value / limit) * 100)}% порога`);
+    expect(value, label).toBeLessThanOrEqual(limit);
+}

package/dist/expect/lint.d.ts

@@ -0,0 +1,15 @@
+/** Ожидание — заголовок `it` с путём `describe`. */
+export interface Title {
+    file: string;
+    path: string[];
+    title: string;
+}
+export declare const MAX_TITLE = 200;
+export interface TitleIssue {
+    title: Title;
+    message: string;
+    /** Длина и дубли — crit; размытые слова — warn. */
+    level: 'crit' | 'warn';
+}
+/** Механическая проверка заголовков: длина, размытые слова, дубли. */
+export declare function lintTitles(titles: Title[]): TitleIssue[];

package/dist/expect/lint.js

@@ -0,0 +1,38 @@
+export const MAX_TITLE = 200;
+/** Слова, после которых ожидание нельзя проверить «да/нет» или числом. */
+const VAGUE = [
+    'удобно',
+    'удобный',
+    'быстро',
+    'достаточно',
+    'при необходимости',
+    'по возможности',
+    'и т.п',
+    'и т.д',
+    'стараться',
+    'желательно',
+    'хорошо',
+    'красиво',
+    'понятно',
+    'оптимально',
+    'как можно',
+];
+/** Механическая проверка заголовков: длина, размытые слова, дубли. */
+export function lintTitles(titles) {
+    const out = [];
+    const seen = new Set();
+    for (const t of titles) {
+        const full = `${t.file} :: ${[...t.path, t.title].join(' > ')}`;
+        const length = [...t.title].length;
+        if (length > MAX_TITLE)
+            out.push({ title: t, message: `длина ${length} > ${MAX_TITLE} символов — раздели ожидание`, level: 'crit' });
+        const lower = t.title.toLowerCase();
+        const vague = VAGUE.filter((w) => new RegExp(`(^|[^а-яё])${w.replace('.', '\\.')}($|[^а-яё])`).test(lower));
+        if (vague.length > 0)
+            out.push({ title: t, message: `размыто: ${vague.join(', ')} — нужен порог, число или да/нет`, level: 'warn' });
+        if (seen.has(full))
+            out.push({ title: t, message: 'дубль', level: 'crit' });
+        seen.add(full);
+    }
+    return out;
+}

package/dist/expect/repo.d.ts

@@ -0,0 +1,60 @@
+import { type Frontmatter } from '../frontmatter.ts';
+import { type IndexEntry } from '../prompt-index.ts';
+/** Корень репозитория для зондов: HARNESS_EXPECT_ROOT или cwd. */
+export declare function repoRoot(): string;
+export declare function readRepo(rel: string): Promise<string>;
+/** Markdown-документ репозитория с удобными зондами. */
+export interface Doc {
+    path: string;
+    text: string;
+    frontmatter: Frontmatter | null;
+    lines: number;
+    bytes: number;
+    headings: string[];
+    /** Текст раздела с заголовком `heading` (любого уровня) до следующего заголовка того же или более высокого уровня. */
+    section(heading: string): string | null;
+}
+/** Раздел markdown по тексту заголовка; заголовки внутри ``` не считаются. */
+export declare function extractSection(text: string, heading: string): string | null;
+export declare function doc(rel: string): Promise<Doc>;
+/** Записи индекса источника (собираются из файлов, не из prompts/index.yml). */
+export declare function indexEntries(): Promise<IndexEntry[]>;
+/** Первый ```-блок языка `lang` (в том числе с отступом — в списке), текст которого начинается с `prefix`; отступ снимается. */
+export declare function codeBlock(text: string, lang: string, prefix?: string): string | null;
+export interface ContractDoc extends Doc {
+    key: string;
+    /** Шаблон AGENTS.md из раздела «Шаблон `AGENTS.md`». */
+    agentsMdTemplate: string | null;
+}
+export declare function contract(key: string): Promise<ContractDoc>;
+export interface ModuleDoc extends Doc {
+    key: string;
+    /** Блок модуля для AGENTS.md между маркерами, с маркерами. */
+    agentsMdBlock: string | null;
+    /** Первый yaml-блок `provides:` модуля. */
+    provides: Record<string, unknown> | null;
+}
+export declare function module(key: string): Promise<ModuleDoc>;
+export declare function modules(): Promise<ModuleDoc[]>;
+export interface SkillDoc extends Doc {
+    name: string;
+    description: string;
+}
+export declare function skill(name: string): Promise<SkillDoc>;
+export declare function skills(): Promise<SkillDoc[]>;
+export interface PresetDoc {
+    key: string;
+    title: string;
+    contract: string;
+    modules: {
+        key: string;
+        answers: Record<string, unknown>;
+    }[];
+    /** AGENTS.md, собранный как при установке: шаблон ядра + блоки модулей. */
+    agentsMd(): Promise<{
+        text: string;
+        lines: number;
+        bytes: number;
+    }>;
+}
+export declare function presets(): Promise<PresetDoc[]>;

package/dist/expect/repo.js

@@ -0,0 +1,139 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { parse } from 'yaml';
+import { normalizeEol, parseFrontmatter } from '../frontmatter.js';
+import { collectEntries } from '../prompt-index.js';
+/** Корень репозитория для зондов: HARNESS_EXPECT_ROOT или cwd. */
+export function repoRoot() {
+    return path.resolve(process.env['HARNESS_EXPECT_ROOT'] ?? process.cwd());
+}
+export async function readRepo(rel) {
+    return normalizeEol(await readFile(path.join(repoRoot(), rel), 'utf8'));
+}
+const HEADING = /^(#{1,6}) (.+)$/;
+/** Раздел markdown по тексту заголовка; заголовки внутри ``` не считаются. */
+export function extractSection(text, heading) {
+    const lines = text.split('\n');
+    let inFence = false;
+    let start = -1;
+    let level = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? '';
+        if (line.startsWith('```'))
+            inFence = !inFence;
+        if (inFence)
+            continue;
+        const m = HEADING.exec(line);
+        if (m === null)
+            continue;
+        const depth = (m[1] ?? '').length;
+        if (start === -1) {
+            if ((m[2] ?? '').trim() === heading) {
+                start = i;
+                level = depth;
+            }
+        }
+        else if (depth <= level) {
+            return lines.slice(start, i).join('\n').trimEnd();
+        }
+    }
+    return start === -1 ? null : lines.slice(start).join('\n').trimEnd();
+}
+function headingsOf(text) {
+    const out = [];
+    let inFence = false;
+    for (const line of text.split('\n')) {
+        if (line.startsWith('```'))
+            inFence = !inFence;
+        const m = inFence ? null : HEADING.exec(line);
+        if (m !== null)
+            out.push((m[2] ?? '').trim());
+    }
+    return out;
+}
+export async function doc(rel) {
+    const text = await readRepo(rel);
+    return {
+        path: rel,
+        text,
+        frontmatter: text.startsWith('---\n') ? parseFrontmatter(text) : null,
+        lines: text.replace(/\n$/, '').split('\n').length,
+        bytes: Buffer.byteLength(text, 'utf8'),
+        headings: headingsOf(text),
+        section: (heading) => extractSection(text, heading),
+    };
+}
+let entriesCache = null;
+/** Записи индекса источника (собираются из файлов, не из prompts/index.yml). */
+export function indexEntries() {
+    entriesCache ??= collectEntries(repoRoot()).then((r) => r.entries);
+    return entriesCache;
+}
+async function entry(kind, key) {
+    const found = (await indexEntries()).find((e) => e.kind === kind && e.key === key);
+    if (found === undefined)
+        throw new Error(`${kind} «${key}» нет в индексе`);
+    return found;
+}
+/** Первый ```-блок языка `lang` (в том числе с отступом — в списке), текст которого начинается с `prefix`; отступ снимается. */
+export function codeBlock(text, lang, prefix = '') {
+    const re = new RegExp('^([ \\t]*)(`{3,4})' + lang + '\\n([\\s\\S]*?)\\n\\1\\2$', 'gm');
+    for (const m of text.matchAll(re)) {
+        const indent = (m[1] ?? '').length;
+        const body = (m[3] ?? '')
+            .split('\n')
+            .map((l) => l.slice(Math.min(indent, l.length - l.trimStart().length)))
+            .join('\n');
+        if (body.startsWith(prefix))
+            return body;
+    }
+    return null;
+}
+export async function contract(key) {
+    const e = await entry('contract', key);
+    const d = await doc(e.path);
+    return { ...d, key, agentsMdTemplate: codeBlock(d.text, 'markdown', '# ') };
+}
+export async function module(key) {
+    const e = await entry('module', key);
+    const d = await doc(e.path);
+    const block = new RegExp(`<!-- module:${key} -->[\\s\\S]*?<!-- /module:${key} -->`).exec(d.text);
+    const provides = codeBlock(d.text, 'yaml', 'provides:');
+    return {
+        ...d,
+        key,
+        agentsMdBlock: block === null ? null : block[0],
+        provides: provides === null ? null : (parse(provides).provides ?? null),
+    };
+}
+export async function modules() {
+    const keys = (await indexEntries()).filter((e) => e.kind === 'module').map((e) => e.key);
+    return Promise.all(keys.map((k) => module(k)));
+}
+export async function skill(name) {
+    await entry('skill', name);
+    const d = await doc(`skills/${name}/SKILL.md`);
+    return { ...d, name, description: String(d.frontmatter?.['description'] ?? '') };
+}
+export async function skills() {
+    const names = (await indexEntries()).filter((e) => e.kind === 'skill').map((e) => e.key);
+    return Promise.all(names.map((n) => skill(n)));
+}
+export async function presets() {
+    const list = (await indexEntries()).filter((e) => e.kind === 'preset');
+    return Promise.all(list.map(async (e) => {
+        const data = parse(await readRepo(e.path));
+        return {
+            key: data.key,
+            title: data.title,
+            contract: data.contract,
+            modules: data.modules.map((m) => ({ key: m.key, answers: m.answers ?? {} })),
+            agentsMd: async () => {
+                const template = (await contract(data.contract)).agentsMdTemplate ?? '';
+                const blocks = await Promise.all(data.modules.map(async (m) => (await module(m.key)).agentsMdBlock ?? ''));
+                const text = `${[template.trimEnd(), ...blocks].join('\n\n')}\n`;
+                return { text, lines: text.replace(/\n$/, '').split('\n').length, bytes: Buffer.byteLength(text, 'utf8') };
+            },
+        };
+    }));
+}

package/dist/expect/schema.d.ts

@@ -0,0 +1,13 @@
+/** Экземпляр для проверки: имя (для сообщения) и данные. */
+export interface Instance {
+    name: string;
+    data: unknown;
+}
+/** Ошибки валидации по JSON Schema; пустой массив — всё соответствует. */
+export declare function schemaErrors(instances: Instance[], schemaPath: string): Promise<string[]>;
+/** Утверждение для ожиданий: все экземпляры соответствуют схеме. */
+export declare function expectSchema(instances: Instance[], schemaPath: string): Promise<void>;
+/** YAML- или JSON-файлы репозитория как экземпляры. */
+export declare function dataFiles(paths: string[]): Promise<Instance[]>;
+/** Frontmatter markdown-файлов как экземпляры. */
+export declare function frontmatters(paths: string[]): Promise<Instance[]>;

package/dist/expect/schema.js

@@ -0,0 +1,47 @@
+import { Ajv2020 } from 'ajv/dist/2020.js';
+import { readdir } from 'node:fs/promises';
+import path from 'node:path';
+import { parse } from 'yaml';
+import { parseFrontmatter } from '../frontmatter.js';
+import { readRepo, repoRoot } from './repo.js';
+let ajv = null;
+/**
+ * Все `*.schema.json` из каталога схемы — в одном Ajv: схемы ссылаются
+ * друг на друга по имени файла (`$ref: provides.schema.json`).
+ */
+async function validator(schemaPath) {
+    ajv ??= (async () => {
+        const dir = path.posix.dirname(schemaPath);
+        const instance = new Ajv2020({ allErrors: true, strict: false });
+        for (const name of (await readdir(path.join(repoRoot(), dir))).filter((n) => n.endsWith('.schema.json')).sort()) {
+            instance.addSchema(JSON.parse(await readRepo(`${dir}/${name}`)), name);
+        }
+        return instance;
+    })();
+    const v = (await ajv).getSchema(path.posix.basename(schemaPath));
+    if (v === undefined)
+        throw new Error(`схема ${schemaPath} не найдена`);
+    return v;
+}
+const describeError = (e) => `${e.instancePath === '' ? '(корень)' : e.instancePath} ${e.message ?? ''}${e.keyword === 'additionalProperties' ? `: ${String(e.params.additionalProperty)}` : ''}`.trim();
+/** Ошибки валидации по JSON Schema; пустой массив — всё соответствует. */
+export async function schemaErrors(instances, schemaPath) {
+    const validate = await validator(schemaPath);
+    return instances.flatMap((i) => (validate(i.data) ? [] : (validate.errors ?? []).map((e) => `${i.name}: ${describeError(e)}`)));
+}
+/** Утверждение для ожиданий: все экземпляры соответствуют схеме. */
+export async function expectSchema(instances, schemaPath) {
+    if (instances.length === 0)
+        throw new Error(`нет экземпляров для схемы ${schemaPath}`);
+    const errors = await schemaErrors(instances, schemaPath);
+    if (errors.length > 0)
+        throw new Error(`не по схеме ${schemaPath}:\n${errors.join('\n')}`);
+}
+/** YAML- или JSON-файлы репозитория как экземпляры. */
+export async function dataFiles(paths) {
+    return Promise.all(paths.map(async (p) => ({ name: p, data: parse(await readRepo(p)) })));
+}
+/** Frontmatter markdown-файлов как экземпляры. */
+export async function frontmatters(paths) {
+    return Promise.all(paths.map(async (p) => ({ name: p, data: parseFrontmatter(await readRepo(p)) ?? {} })));
+}

package/dist/expect/verdicts.d.ts

@@ -0,0 +1,35 @@
+export declare const VERDICTS_PATH = "expectations/.verdicts.json";
+/** Вердикт судьи по одному ожиданию. */
+export interface Verdict {
+    question: string;
+    /** Ссылка на доказательство → SHA-256 его содержимого на момент вердикта. */
+    evidence: Record<string, string>;
+    verdict: boolean;
+    /** Дословная цитата из доказательства, на которой держится ответ. */
+    quote: string;
+    ref: string;
+    reason: string;
+    at: string;
+}
+/** Результат смысловой проверки заголовков одного файла ожиданий. */
+export interface LintVerdict {
+    /** SHA-256 списка заголовков файла. */
+    titles: string;
+    contradictions: {
+        a: string;
+        b: string;
+        reason: string;
+    }[];
+    unmeasurable: {
+        id: string;
+        reason: string;
+    }[];
+    at: string;
+}
+export interface VerdictStore {
+    verdicts: Record<string, Verdict>;
+    lint: Record<string, LintVerdict>;
+}
+export declare function loadVerdicts(): Promise<VerdictStore>;
+/** Ключи отсортированы: diff кэша в PR читается и не конфликтует без нужды. */
+export declare function saveVerdicts(store: VerdictStore): Promise<void>;

package/dist/expect/verdicts.js

@@ -0,0 +1,23 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { repoRoot } from './repo.js';
+export const VERDICTS_PATH = 'expectations/.verdicts.json';
+export async function loadVerdicts() {
+    try {
+        const data = JSON.parse(await readFile(path.join(repoRoot(), VERDICTS_PATH), 'utf8'));
+        return { verdicts: data.verdicts ?? {}, lint: data.lint ?? {} };
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return { verdicts: {}, lint: {} };
+        throw error;
+    }
+}
+const sortKeys = (obj) => Object.fromEntries(Object.entries(obj).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)));
+/** Ключи отсортированы: diff кэша в PR читается и не конфликтует без нужды. */
+export async function saveVerdicts(store) {
+    const file = path.join(repoRoot(), VERDICTS_PATH);
+    await mkdir(path.dirname(file), { recursive: true });
+    const data = { verdicts: sortKeys(store.verdicts), lint: sortKeys(store.lint) };
+    await writeFile(file, `${JSON.stringify(data, null, 2)}\n`, 'utf8');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shahimat/harness",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Harness для проектов на контрактах ai-prompts: генераторы и проверки",
   "license": "MIT",
   "author": "Gevorg Nakhapetyan",
@@ -33,6 +33,10 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./expect": {
+      "types": "./dist/expect/index.d.ts",
+      "import": "./dist/expect/index.js"
     }
   },
   "files": [
@@ -46,6 +50,7 @@
     "prepublishOnly": "npm run typecheck && npm test && npm run build"
   },
   "dependencies": {
+    "ajv": "^8.20.0",
     "yaml": "^2.9.1"
   },
   "devDependencies": {
@@ -55,5 +60,13 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "peerDependencies": {
+    "vitest": ">=4"
+  },
+  "peerDependenciesMeta": {
+    "vitest": {
+      "optional": true
+    }
   }
 }