devcontour-harness 0.0.0-stage → 0.1.0-alpha.6

package/lib/storage/document.js

@@ -0,0 +1,80 @@
+import { STATE_VERSION, } from "../contracts/index.js";
+/**
+ * Пустой документ: очередь ещё не запускалась — пауза без причины. Причина
+ * появляется только у решения (оператор, штатная остановка, отказ, операция):
+ * так первый запуск отличим от паузы, которую поставил человек.
+ */
+export const emptyDocument = () => ({
+    stateVersion: STATE_VERSION,
+    graphs: [],
+    works: [],
+    attempts: [],
+    verifications: [],
+    control: { paused: true },
+    sequence: 0,
+});
+/** Чтение и запись записей модели поверх документа — общая часть адаптеров хранилища. */
+export class DocumentView {
+    doc;
+    constructor(doc) {
+        this.doc = doc;
+    }
+    control() {
+        return this.doc.control;
+    }
+    controller() {
+        return this.doc.controller;
+    }
+    graph(id) {
+        return this.doc.graphs.find((g) => g.id === id);
+    }
+    graphs() {
+        return this.doc.graphs;
+    }
+    work(id) {
+        return this.doc.works.find((w) => w.id === id);
+    }
+    works(graphId) {
+        return graphId ? this.doc.works.filter((w) => w.graphId === graphId) : this.doc.works;
+    }
+    attempt(id) {
+        return this.doc.attempts.find((a) => a.id === id);
+    }
+    attempts(workId) {
+        return workId ? this.doc.attempts.filter((a) => a.workId === workId) : this.doc.attempts;
+    }
+    verification(id) {
+        return this.doc.verifications.find((v) => v.id === id);
+    }
+    verifications() {
+        return this.doc.verifications;
+    }
+    putGraph(graph) {
+        upsert(this.doc.graphs, graph);
+    }
+    putWork(work) {
+        upsert(this.doc.works, work);
+    }
+    putAttempt(attempt) {
+        upsert(this.doc.attempts, attempt);
+    }
+    putVerification(verification) {
+        upsert(this.doc.verifications, verification);
+    }
+    setControl(control) {
+        this.doc.control = control;
+    }
+    setController(lease) {
+        if (lease)
+            this.doc.controller = lease;
+        else
+            delete this.doc.controller;
+    }
+}
+function upsert(list, item) {
+    const i = list.findIndex((x) => x.id === item.id);
+    if (i >= 0)
+        list[i] = item;
+    else
+        list.push(item);
+}

package/lib/storage/sqlite.d.ts

@@ -0,0 +1,35 @@
+import { type ExecutionStore, type ExecutionTransaction, type ExecutionView, type NotPromise, type RunEvent, type TransactionKind } from '../contracts/index.ts';
+/**
+ * Standalone ExecutionStore: нейтральный документ, события и локальные
+ * записи в одной SQLite. Транзакция — `BEGIN IMMEDIATE` (вложенная —
+ * SAVEPOINT); документ читается один раз на внешнюю транзакцию, вложенные
+ * работают с ним же и при отказе восстанавливают его снимок и свой буфер
+ * событий. Документ проверяется схемой при каждой фиксации: состояние вне
+ * договора не записывается.
+ *
+ * Версия: в `meta` записаны версия формата и версия писателя. Неизвестная
+ * версия формата отклоняется при открытии, до любой записи.
+ */
+export declare class SqliteExecutionStore implements ExecutionStore {
+    readonly file: string;
+    readonly writer: string;
+    readonly options: {
+        readOnly?: boolean;
+    };
+    readonly stateVersion: 1;
+    private db;
+    private frame?;
+    private savepoint;
+    constructor(file: string, writer: string, options?: {
+        readOnly?: boolean;
+    });
+    /** Проверка существующего файла без единой записи; отказ — HarnessError. */
+    private static preflight;
+    private load;
+    read<T>(fn: (view: ExecutionView) => NotPromise<T>): T;
+    transact<T>(kind: TransactionKind, fn: (tx: ExecutionTransaction) => NotPromise<T>): T;
+    private writeEvents;
+    events(after?: number, limit?: number): RunEvent[];
+    close(): void;
+    private view;
+}

package/lib/storage/sqlite.js

@@ -0,0 +1,260 @@
+import { DatabaseSync } from 'node:sqlite';
+import { existsSync, mkdirSync, statSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { API_VERSION, HarnessError, STATE_VERSION, SUPPORTED_STATE_VERSIONS, WORKSPACE_OWNER, executionDocumentSchema, localSchemas, runEventSchema, } from "../contracts/index.js";
+import { DocumentView, emptyDocument } from "./document.js";
+/**
+ * Строгая схема: поле, которого эта версия не знает (например, записанное
+ * более новой версией), — отказ до любой записи и выдачи, а не молчаливая
+ * потеря при перезаписи документа.
+ */
+function parseDocument(data) {
+    const parsed = executionDocumentSchema.safeParse(JSON.parse(data));
+    if (!parsed.success)
+        throw new HarnessError('STATE_VERSION_UNSUPPORTED', 'Состояние не соответствует формату этой версии пакета (возможно, его записала более новая версия): обновите пакет или восстановите согласованную копию', parsed.error.issues.slice(0, 20).map((i) => ({
+            path: i.path.filter((k) => typeof k !== 'symbol'),
+            message: i.message,
+        })));
+    return parsed.data;
+}
+/** Сколько событий одной транзакции допускается (договор курсора адаптеров). */
+const MAX_EVENTS_PER_TRANSACTION = 1024;
+/**
+ * Standalone ExecutionStore: нейтральный документ, события и локальные
+ * записи в одной SQLite. Транзакция — `BEGIN IMMEDIATE` (вложенная —
+ * SAVEPOINT); документ читается один раз на внешнюю транзакцию, вложенные
+ * работают с ним же и при отказе восстанавливают его снимок и свой буфер
+ * событий. Документ проверяется схемой при каждой фиксации: состояние вне
+ * договора не записывается.
+ *
+ * Версия: в `meta` записаны версия формата и версия писателя. Неизвестная
+ * версия формата отклоняется при открытии, до любой записи.
+ */
+export class SqliteExecutionStore {
+    file;
+    writer;
+    options;
+    stateVersion = STATE_VERSION;
+    db;
+    frame;
+    savepoint = 0;
+    constructor(file, writer, options = {}) {
+        this.file = file;
+        this.writer = writer;
+        this.options = options;
+        // Существующее состояние сначала проверяется целиком через отдельное
+        // соединение только для чтения: версия формата и документ строгой схемой.
+        // Несовместимый вход отклоняется до DDL, записи автора и смены journal
+        // mode — файл остаётся байт в байт прежним.
+        const existing = file !== ':memory:' && existsSync(file) && statSync(file).size > 0;
+        if (existing)
+            SqliteExecutionStore.preflight(file);
+        else if (options.readOnly)
+            throw new HarnessError('STATE_VERSION_UNSUPPORTED', 'Состояние не найдено');
+        if (options.readOnly) {
+            // Диагностическое открытие: ни автор, ни PRAGMA, ни схема не меняются.
+            this.db = new DatabaseSync(file, { readOnly: true });
+            this.db.exec('PRAGMA busy_timeout=20000;');
+            return;
+        }
+        if (file !== ':memory:')
+            mkdirSync(dirname(file), { recursive: true });
+        this.db = new DatabaseSync(file);
+        try {
+            this.db.exec('PRAGMA journal_mode=WAL; PRAGMA busy_timeout=20000; PRAGMA synchronous=FULL;');
+            this.db.exec(`BEGIN IMMEDIATE;
+        CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT NOT NULL);
+        CREATE TABLE IF NOT EXISTS state (id INTEGER PRIMARY KEY CHECK(id=1), data TEXT NOT NULL);
+        CREATE TABLE IF NOT EXISTS events (seq INTEGER PRIMARY KEY AUTOINCREMENT, data TEXT NOT NULL);
+        CREATE TABLE IF NOT EXISTS local (namespace TEXT NOT NULL, owner TEXT NOT NULL, key TEXT NOT NULL, data TEXT NOT NULL, PRIMARY KEY(namespace, owner, key));`);
+            this.db
+                .prepare("INSERT OR IGNORE INTO meta VALUES('stateVersion', ?)")
+                .run(String(STATE_VERSION));
+            this.db.prepare("INSERT OR REPLACE INTO meta VALUES('writer', ?)").run(writer);
+            this.db
+                .prepare('INSERT OR IGNORE INTO state VALUES(1, ?)')
+                .run(JSON.stringify(emptyDocument()));
+            this.db.exec('COMMIT');
+        }
+        catch (error) {
+            if (this.db.isTransaction)
+                this.db.exec('ROLLBACK');
+            this.db.close();
+            throw error;
+        }
+    }
+    /** Проверка существующего файла без единой записи; отказ — HarnessError. */
+    static preflight(file) {
+        const db = new DatabaseSync(file, { readOnly: true });
+        try {
+            db.exec('PRAGMA busy_timeout=20000;');
+            const tables = new Set(db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all().map((t) => t.name));
+            if (!tables.has('meta')) {
+                if (tables.size)
+                    throw new HarnessError('STATE_VERSION_UNSUPPORTED', 'Файл содержит чужую базу, а не состояние harness');
+                return;
+            }
+            const row = db.prepare("SELECT value FROM meta WHERE key='stateVersion'").get();
+            const version = Number(row?.value);
+            if (!SUPPORTED_STATE_VERSIONS.includes(version))
+                throw new HarnessError('STATE_VERSION_UNSUPPORTED', `Формат состояния ${row?.value ?? 'неизвестен'} не поддерживается этой версией (${SUPPORTED_STATE_VERSIONS.join(', ')})`);
+            if (tables.has('state')) {
+                const state = db.prepare('SELECT data FROM state WHERE id=1').get();
+                if (state)
+                    parseDocument(state.data);
+            }
+        }
+        finally {
+            db.close();
+        }
+    }
+    load() {
+        const row = this.db.prepare('SELECT data FROM state WHERE id=1').get();
+        return parseDocument(row.data);
+    }
+    read(fn) {
+        if (this.frame)
+            return fn(this.view(this.frame));
+        this.db.exec('BEGIN');
+        try {
+            const value = fn(this.view({ doc: this.load(), drafts: [], depth: 0 }));
+            this.db.exec('COMMIT');
+            return value;
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    transact(kind, fn) {
+        if (this.options.readOnly)
+            throw new HarnessError('STATE_VERSION_UNSUPPORTED', 'Состояние открыто только для чтения');
+        const outer = this.frame;
+        const point = 'harness_' + ++this.savepoint;
+        this.db.exec(outer ? `SAVEPOINT ${point}` : 'BEGIN IMMEDIATE');
+        let loaded;
+        try {
+            if (!outer)
+                loaded = this.load();
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+        const frame = outer ?? { doc: loaded, drafts: [], depth: 0 };
+        const saved = outer ? structuredClone(frame.doc) : undefined;
+        const drafts = frame.drafts.length;
+        frame.depth++;
+        this.frame = frame;
+        try {
+            const value = fn(this.view(frame));
+            if (value && typeof value.then === 'function')
+                throw new Error('ExecutionStore.transact: внутри транзакции нельзя ждать внешней работы');
+            if (outer) {
+                this.db.exec(`RELEASE ${point}`);
+            }
+            else {
+                if (frame.drafts.length > MAX_EVENTS_PER_TRANSACTION)
+                    throw new Error('Слишком много событий в одной транзакции');
+                frame.doc.sequence++;
+                const doc = executionDocumentSchema.parse(frame.doc);
+                this.db.prepare('UPDATE state SET data=? WHERE id=1').run(JSON.stringify(doc));
+                if (kind !== 'heartbeat')
+                    this.writeEvents(frame.drafts);
+                this.db.exec('COMMIT');
+            }
+            return value;
+        }
+        catch (error) {
+            if (outer) {
+                this.db.exec(`ROLLBACK TO ${point}; RELEASE ${point}`);
+                for (const key of Object.keys(frame.doc))
+                    delete frame.doc[key];
+                Object.assign(frame.doc, saved);
+                frame.drafts.length = drafts;
+            }
+            else
+                this.db.exec('ROLLBACK');
+            throw error;
+        }
+        finally {
+            frame.depth--;
+            this.frame = outer;
+        }
+    }
+    writeEvents(drafts) {
+        const insert = this.db.prepare('INSERT INTO events(data) VALUES(?)');
+        const at = new Date().toISOString();
+        for (const draft of drafts) {
+            const result = insert.run('{}');
+            const seq = Number(result.lastInsertRowid);
+            const event = runEventSchema.parse({ apiVersion: API_VERSION, seq, at, ...draft });
+            this.db.prepare('UPDATE events SET data=? WHERE seq=?').run(JSON.stringify(event), seq);
+        }
+    }
+    events(after = 0, limit = 500) {
+        const rows = this.db
+            .prepare('SELECT data FROM events WHERE seq>? ORDER BY seq LIMIT ?')
+            .all(after, Math.min(Math.max(limit, 1), 500));
+        return rows.map((r) => runEventSchema.parse(JSON.parse(r.data)));
+    }
+    close() {
+        this.db.close();
+    }
+    view(frame) {
+        const doc = new DocumentView(frame.doc);
+        const db = this.db;
+        const inTx = () => this.frame === frame;
+        return {
+            control: () => doc.control(),
+            controller: () => doc.controller(),
+            graph: (id) => doc.graph(id),
+            graphs: () => doc.graphs(),
+            work: (id) => doc.work(id),
+            works: (graphId) => doc.works(graphId),
+            attempt: (id) => doc.attempt(id),
+            attempts: (workId) => doc.attempts(workId),
+            verification: (id) => doc.verification(id),
+            verifications: () => doc.verifications(),
+            local(namespace, owner, key) {
+                const row = db
+                    .prepare('SELECT data FROM local WHERE namespace=? AND owner=? AND key=?')
+                    .get(namespace, owner, key);
+                return row
+                    ? localSchemas[namespace].parse(JSON.parse(row.data))
+                    : undefined;
+            },
+            locals(namespace, owner) {
+                const rows = (owner === undefined
+                    ? db
+                        .prepare('SELECT owner,key,data FROM local WHERE namespace=? ORDER BY owner,key')
+                        .all(namespace)
+                    : db
+                        .prepare('SELECT owner,key,data FROM local WHERE namespace=? AND owner=? ORDER BY key')
+                        .all(namespace, owner));
+                return rows.map((r) => ({
+                    owner: r.owner,
+                    key: r.key,
+                    value: localSchemas[namespace].parse(JSON.parse(r.data)),
+                }));
+            },
+            putGraph: (g) => doc.putGraph(g),
+            putWork: (w) => doc.putWork(w),
+            putAttempt: (a) => doc.putAttempt(a),
+            putVerification: (v) => doc.putVerification(v),
+            setControl: (c) => doc.setControl(c),
+            setController: (l) => doc.setController(l),
+            putLocal(namespace, owner, key, value) {
+                if (!inTx())
+                    throw new Error('Локальная запись вне транзакции');
+                const parsed = localSchemas[namespace].parse(value);
+                db.prepare('INSERT OR REPLACE INTO local VALUES(?,?,?,?)').run(namespace, owner || WORKSPACE_OWNER, key, JSON.stringify(parsed));
+            },
+            emit(event) {
+                if (!inTx())
+                    throw new Error('Событие вне транзакции');
+                frame.drafts.push(event);
+            },
+        };
+    }
+}

package/lib/testing/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Вспомогательные проверки для адаптеров хоста. Не нужны в рабочем пути;
+ * используют `node:assert`.
+ */
+export { executionStoreContract } from './store-contract.ts';

package/lib/testing/index.js

@@ -0,0 +1,5 @@
+/**
+ * Вспомогательные проверки для адаптеров хоста. Не нужны в рабочем пути;
+ * используют `node:assert`.
+ */
+export { executionStoreContract } from "./store-contract.js";

package/lib/testing/store-contract.d.ts

@@ -0,0 +1,8 @@
+import { type ExecutionStore } from '../contracts/index.ts';
+/**
+ * Общий набор проверок договора `ExecutionStore`. Его проходят standalone
+ * SQLite и адаптер любого хоста: `open` открывает хранилище в каталоге,
+ * повторный вызов с тем же каталогом — то же хранилище другим экземпляром.
+ * Регистрация тестов — через переданную `test` (node:test).
+ */
+export declare function executionStoreContract(name: string, test: (title: string, fn: () => void | Promise<void>) => unknown, open: (dir: string) => ExecutionStore, tempDir: () => string): void;

package/lib/testing/store-contract.js

@@ -0,0 +1,167 @@
+import assert from 'node:assert/strict';
+import { WORKSPACE_OWNER, digestOf, } from "../contracts/index.js";
+/**
+ * Общий набор проверок договора `ExecutionStore`. Его проходят standalone
+ * SQLite и адаптер любого хоста: `open` открывает хранилище в каталоге,
+ * повторный вызов с тем же каталогом — то же хранилище другим экземпляром.
+ * Регистрация тестов — через переданную `test` (node:test).
+ */
+export function executionStoreContract(name, test, open, tempDir) {
+    const work = (id, status = 'ready') => ({
+        id,
+        graphId: 'g',
+        order: {
+            apiVersion: 'devcontour-harness/v1alpha1',
+            id,
+            source: { connector: 'files', ref: id, revision: '1' },
+            title: 'Поручение ' + id,
+            goal: 'Цель поручения ' + id,
+            acceptance: ['критерий'],
+            role: 'developer',
+            repositoryId: 'app',
+            relatedRepositories: [],
+            writeScope: ['src'],
+            dependsOn: [],
+            requirements: [],
+            contracts: [],
+            context: [],
+        },
+        status,
+        attempt: 0,
+    });
+    const phase = (runId, p = 'running') => ({
+        type: 'attempt.phase',
+        runId,
+        payload: { phase: p },
+    });
+    const call = (id) => ({
+        id,
+        stage: 'implementation',
+        runtime: 'fixture',
+        model: null,
+        runtimeVersion: null,
+        startedAt: '2026-01-01T00:00:00.000Z',
+        outcome: 'returned',
+        promptBytes: 1,
+        promptDigest: digestOf(id),
+        usage: {
+            inputTokens: 1,
+            outputTokens: 1,
+            cacheReadTokens: 0,
+            cacheWriteTokens: 0,
+            reportedUsd: null,
+            complete: true,
+            source: 'fixture',
+        },
+        costUsd: null,
+        costSource: 'unknown',
+    });
+    test(`${name}: запись видна следующей транзакции и другому экземпляру`, () => {
+        const dir = tempDir();
+        const a = open(dir);
+        a.transact('run.phase', (tx) => {
+            tx.putWork(work('w1'));
+            tx.emit(phase('r1'));
+        });
+        assert.equal(a.read((v) => v.work('w1')?.status), 'ready');
+        const b = open(dir);
+        assert.equal(b.read((v) => v.work('w1')?.status), 'ready');
+        b.transact('run.phase', (tx) => tx.putWork({ ...tx.work('w1'), status: 'running' }));
+        assert.equal(a.read((v) => v.work('w1')?.status), 'running', 'первый экземпляр видит запись второго');
+        const events = a.events();
+        assert.equal(events.length, 1);
+        assert.equal(events[0].type, 'attempt.phase');
+        a.close();
+        b.close();
+    });
+    test(`${name}: исключение откатывает записи, локальные записи и события`, () => {
+        const s = open(tempDir());
+        assert.throws(() => s.transact('run.phase', (tx) => {
+            tx.putWork(work('w1'));
+            tx.putLocal('usage', 'app', 'c1', call('c1'));
+            tx.emit(phase('r1'));
+            throw new Error('отказ');
+        }));
+        assert.equal(s.read((v) => v.work('w1')), undefined);
+        assert.equal(s.read((v) => v.local('usage', 'app', 'c1')), undefined);
+        assert.deepEqual(s.events(), []);
+        s.close();
+    });
+    test(`${name}: вложенная сохраняет оба изменения; её отказ откатывает только её часть`, () => {
+        const s = open(tempDir());
+        s.transact('run.claimed', (tx) => {
+            tx.putWork(work('outer'));
+            s.transact('run.phase', (inner) => {
+                assert.ok(inner.work('outer'), 'вложенная видит несохранённое внешней');
+                inner.putWork(work('inner'));
+                inner.emit(phase('r-inner'));
+            });
+            assert.throws(() => s.transact('run.phase', (inner) => {
+                inner.putWork(work('lost'));
+                inner.putLocal('usage', 'app', 'lost', call('lost'));
+                inner.emit(phase('r-lost'));
+                throw new Error('вложенный отказ');
+            }));
+            tx.emit(phase('r-outer'));
+        });
+        assert.ok(s.read((v) => v.work('outer')));
+        assert.ok(s.read((v) => v.work('inner')));
+        assert.equal(s.read((v) => v.work('lost')), undefined);
+        assert.equal(s.read((v) => v.local('usage', 'app', 'lost')), undefined);
+        assert.deepEqual(s.events().map((e) => e.runId), ['r-inner', 'r-outer']);
+        s.close();
+    });
+    test(`${name}: Promise внутри транзакции отклоняется, ничего не записано`, () => {
+        const s = open(tempDir());
+        assert.throws(() => s.transact('run.phase', (tx) => {
+            tx.putWork(work('w1'));
+            return Promise.resolve(1);
+        }));
+        assert.equal(s.read((v) => v.work('w1')), undefined);
+        s.close();
+    });
+    test(`${name}: heartbeat без события; транзакция только с событием его пишет`, () => {
+        const s = open(tempDir());
+        s.transact('run.phase', (tx) => tx.putWork(work('w1')));
+        s.transact('heartbeat', (tx) => tx.putWork({ ...tx.work('w1'), attempt: 1 }));
+        assert.equal(s.read((v) => v.work('w1')?.attempt), 1);
+        assert.deepEqual(s.events(), []);
+        s.transact('run.phase', (tx) => tx.emit(phase('r1')));
+        assert.equal(s.events().length, 1);
+        s.close();
+    });
+    test(`${name}: события закрыты схемой; курсор строго по возрастанию`, () => {
+        const s = open(tempDir());
+        assert.throws(() => s.transact('run.phase', (tx) => tx.emit({ type: 'attempt.phase', payload: { phase: 'running', token: 'x' } })));
+        assert.deepEqual(s.events(), [], 'событие вне договора не записано');
+        for (let i = 0; i < 5; i++)
+            s.transact('run.phase', (tx) => tx.emit(phase('r' + i)));
+        const all = s.events();
+        assert.deepEqual(all.map((e) => e.runId), ['r0', 'r1', 'r2', 'r3', 'r4']);
+        for (let i = 1; i < all.length; i++)
+            assert.ok(all[i].seq > all[i - 1].seq);
+        assert.deepEqual(s.events(all[1].seq).map((e) => e.runId), ['r2', 'r3', 'r4']);
+        assert.deepEqual(s.events(0, 2).map((e) => e.runId), ['r0', 'r1']);
+        s.close();
+    });
+    test(`${name}: локальные записи различаются владельцем и проверяются схемой`, () => {
+        const s = open(tempDir());
+        s.transact('run.phase', (tx) => {
+            tx.putLocal('usage', 'app', 'k', call('a'));
+            tx.putLocal('usage', WORKSPACE_OWNER, 'k', call('b'));
+        });
+        assert.equal(s.read((v) => v.local('usage', 'app', 'k')?.id), 'a');
+        assert.equal(s.read((v) => v.local('usage', WORKSPACE_OWNER, 'k')?.id), 'b');
+        assert.equal(s.read((v) => v.locals('usage').length), 2);
+        assert.equal(s.read((v) => v.locals('usage', 'app').length), 1);
+        assert.throws(() => s.transact('run.phase', (tx) => tx.putLocal('usage', 'app', 'bad', { id: 'bad' })));
+        assert.equal(s.read((v) => v.local('usage', 'app', 'bad')), undefined);
+        s.close();
+    });
+    test(`${name}: запись вне договора модели отклоняется целиком`, () => {
+        const s = open(tempDir());
+        assert.throws(() => s.transact('run.phase', (tx) => tx.putWork({ ...work('w1'), status: 'finished' })));
+        assert.equal(s.read((v) => v.work('w1')), undefined);
+        s.close();
+    });
+}

package/lib/toolchains/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Toolchains: диагностика (doctor/preflight) и рецепты композиции целевого
+ * репозитория — npm, pnpm, Turborepo, Go, Python/uv и их смешение в одном
+ * Git root. Opt-in entrypoint: корень пакета и `./contracts` его не
+ * импортируют.
+ */
+export { inspectPolicy, inspectRepository, assertToolchainReady, problemLines, toolchainProblemCodes, type InspectOptions, type PlanEntry, type ToolEntry, type ToolchainProblem, type ToolchainProblemCode, type ToolchainReport, } from './inspect.ts';
+export { defaultProbe, resolveExecutable, satisfies, versionOf as toolVersionOf, PROBE_TIMEOUT_MS, type ToolProbe, } from './probe.ts';
+export { composeRepository, installRecipes, type InstallRecipe, type ToolchainComponent, } from './recipes.ts';

package/lib/toolchains/index.js

@@ -0,0 +1,9 @@
+/**
+ * Toolchains: диагностика (doctor/preflight) и рецепты композиции целевого
+ * репозитория — npm, pnpm, Turborepo, Go, Python/uv и их смешение в одном
+ * Git root. Opt-in entrypoint: корень пакета и `./contracts` его не
+ * импортируют.
+ */
+export { inspectPolicy, inspectRepository, assertToolchainReady, problemLines, toolchainProblemCodes, } from "./inspect.js";
+export { defaultProbe, resolveExecutable, satisfies, versionOf as toolVersionOf, PROBE_TIMEOUT_MS, } from "./probe.js";
+export { composeRepository, installRecipes, } from "./recipes.js";