@shahimat/harness 0.1.0 → 0.3.0

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/dist/prompt-index.d.ts

@@ -8,6 +8,8 @@ export interface IndexEntry {
     applicableTo: string[];
     patterns: string[];
     title?: string;
+    /** Чем заменён устаревший промпт: ключ или путь замены. */
+    deprecated?: string;
     /** Блок `feature` модуля-возможности — то, что нужно для чеклиста. */
     feature?: FeatureInfo;
     /** Файлы skill: `path` от корня репозитория и SHA-256 каждого. */