devcontour-harness 0.1.0-alpha.5 → 0.1.0-alpha.7

package/lib/integrations/connector/fake.js

@@ -0,0 +1,786 @@
+import { DatabaseSync } from 'node:sqlite';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { TransportError, } from "./transport.js";
+export const emptyFakeState = (provider, projectId) => ({
+    provider,
+    projectId,
+    generation: 1,
+    seq: 0,
+    tasks: {},
+    comments: {},
+    documents: {},
+    sessions: {},
+    checkpoints: {},
+    mutations: {},
+});
+export function memoryBackend(state) {
+    return {
+        with: (fn, write) => {
+            if (!write)
+                return fn(structuredClone(state));
+            const draft = structuredClone(state);
+            const out = fn(draft);
+            Object.assign(state, draft);
+            return out;
+        },
+        close: () => undefined,
+    };
+}
+/** Состояние в файле SQLite: каждая операция — транзакция `BEGIN IMMEDIATE`. */
+export function fileBackend(file, init) {
+    mkdirSync(dirname(file), { recursive: true });
+    const db = new DatabaseSync(file);
+    db.exec('PRAGMA journal_mode=WAL; PRAGMA busy_timeout=20000;');
+    db.exec('CREATE TABLE IF NOT EXISTS state (id INTEGER PRIMARY KEY CHECK(id=1), data TEXT NOT NULL)');
+    if (init)
+        db.prepare('INSERT OR IGNORE INTO state VALUES(1, ?)').run(JSON.stringify(init));
+    return {
+        with: (fn, write) => {
+            db.exec(write ? 'BEGIN IMMEDIATE' : 'BEGIN');
+            try {
+                const row = db.prepare('SELECT data FROM state WHERE id=1').get();
+                const state = JSON.parse(row.data);
+                const out = fn(state);
+                if (write)
+                    db.prepare('UPDATE state SET data=? WHERE id=1').run(JSON.stringify(state));
+                db.exec('COMMIT');
+                return out;
+            }
+            catch (error) {
+                if (db.isTransaction)
+                    db.exec('ROLLBACK');
+                throw error;
+            }
+        },
+        close: () => db.close(),
+    };
+}
+const tick = () => new Promise((r) => setImmediate(r));
+const columns = ['inbox', 'ready', 'in-progress', 'review', 'done', 'cancelled'];
+/** Транспорт поверх подделки — тот же договор, что у настоящих адаптеров. */
+export class FakeRelayTransport {
+    backend;
+    options;
+    provider;
+    /** Хук между страницами чтения задачи: тесты вносят здесь чужую запись. */
+    onPage;
+    projectId;
+    constructor(backend, options) {
+        this.backend = backend;
+        this.options = options;
+        this.provider = options.provider;
+        this.projectId = backend.with((s) => s.projectId, false);
+    }
+    fail(kind, operation, message, extra = {}) {
+        throw new TransportError(kind, operation, message, {
+            provider: this.provider,
+            projectId: this.projectId,
+            ...extra,
+        });
+    }
+    read(fn) {
+        return this.backend.with(fn, false);
+    }
+    write(operation, fn) {
+        return this.backend.with((s) => {
+            const out = fn(s);
+            s.generation++;
+            s.mutations[operation] = (s.mutations[operation] ?? 0) + 1;
+            return out;
+        }, true);
+    }
+    static resolve(s, ref) {
+        return s.tasks[ref] ?? Object.values(s.tasks).find((t) => t.key === ref);
+    }
+    taskOf(s, ref, operation) {
+        const task = FakeRelayTransport.resolve(s, ref);
+        if (!task)
+            this.fail('not-found', operation, 'Задача не найдена: ' + ref, { code: 'NOT_FOUND' });
+        return task;
+    }
+    /** Транзитивно завершена: done, все критерии, дети и зависимости. */
+    static finished(s, id, seen = new Set()) {
+        if (seen.has(id))
+            return false;
+        seen.add(id);
+        const t = s.tasks[id];
+        if (!t || t.column !== 'done' || t.criteria.some((c) => !c.completed))
+            return false;
+        const children = Object.values(s.tasks).filter((x) => x.parentId === id);
+        return (children.every((c) => FakeRelayTransport.finished(s, c.id, seen)) &&
+            t.dependencies.every((d) => FakeRelayTransport.finished(s, d, seen)));
+    }
+    static summary(s, t) {
+        return {
+            id: t.id,
+            key: t.key,
+            title: t.title,
+            column: t.column,
+            revision: t.revision,
+            finished: FakeRelayTransport.finished(s, t.id),
+        };
+    }
+    async identity() {
+        await tick();
+        return this.read((s) => ({
+            provider: this.provider,
+            projectId: s.projectId,
+            capabilities: [
+                'fake-task-v1',
+                ...(this.options.history === false ? [] : ['fake-work-history-v1']),
+            ],
+            build: { implementation: 'devcontour-harness fake relay (fixture)' },
+        }));
+    }
+    async readTask(ref) {
+        await tick();
+        const before = this.read((s) => String(s.generation));
+        const task = this.read((s) => structuredClone(this.taskOf(s, ref, 'task.read')));
+        await this.onPage?.('task', ref);
+        await tick();
+        const links = this.read((s) => ({
+            children: Object.values(s.tasks)
+                .filter((x) => x.parentId === task.id)
+                .map((x) => FakeRelayTransport.summary(s, x)),
+            dependencies: task.dependencies
+                .filter((d) => s.tasks[d])
+                .map((d) => FakeRelayTransport.summary(s, s.tasks[d])),
+        }));
+        await this.onPage?.('links', ref);
+        await tick();
+        const documents = this.read((s) => Object.values(s.documents)
+            .filter((d) => d.targets.includes(task.id))
+            .map(({ targets, ...d }) => (void targets, d)));
+        await this.onPage?.('documents', ref);
+        const after = this.read((s) => String(s.generation));
+        return { task, ...links, documents, consistency: { before, after } };
+    }
+    async listComments(ref) {
+        await tick();
+        return this.read((s) => structuredClone(s.comments[this.taskOf(s, ref, 'comment.list').id] ?? []));
+    }
+    async addComment(ref, input) {
+        await tick();
+        if (!input.body.trim())
+            this.fail('refused', 'comment.add', 'Пустой комментарий', {
+                code: 'INVALID_INPUT',
+                mutation: true,
+            });
+        return this.write('comment.add', (s) => {
+            const task = this.taskOf(s, ref, 'comment.add');
+            const id = String(++s.seq);
+            (s.comments[task.id] ??= []).push({
+                id,
+                title: input.title,
+                body: input.body,
+                actor: this.options.actor,
+                createdAt: new Date().toISOString(),
+            });
+            return { commentId: id };
+        });
+    }
+    async setCriterion(ref, input) {
+        await tick();
+        return this.write('task.criterion', (s) => {
+            const task = this.taskOf(s, ref, 'task.criterion');
+            if (task.column === 'done')
+                this.fail('refused', 'task.criterion', 'Задача в done', {
+                    code: 'TASK_ACCEPTANCE_LOCKED',
+                    mutation: true,
+                });
+            if (task.revision !== input.ifRevision)
+                this.fail('conflict', 'task.criterion', 'Ревизия изменилась', {
+                    code: 'REVISION_CONFLICT',
+                    actualRevision: task.revision,
+                    mutation: true,
+                });
+            const c = task.criteria.find((x) => x.id === input.criterionId);
+            if (!c)
+                this.fail('not-found', 'task.criterion', 'Критерий не найден', { code: 'NOT_FOUND' });
+            c.completed = input.completed;
+            task.revision++;
+            return { revision: task.revision };
+        });
+    }
+    async move(ref, input) {
+        await tick();
+        if (!columns.includes(input.column))
+            this.fail('refused', 'task.move', 'Колонка', { code: 'INVALID_INPUT' });
+        return this.write('task.move', (s) => {
+            const task = this.taskOf(s, ref, 'task.move');
+            if (task.revision !== input.ifRevision)
+                this.fail('conflict', 'task.move', 'Ревизия изменилась', {
+                    code: 'REVISION_CONFLICT',
+                    actualRevision: task.revision,
+                    mutation: true,
+                });
+            if (input.column === 'done') {
+                if (task.criteria.some((c) => !c.completed))
+                    this.fail('refused', 'task.move', 'Критерии не выполнены', {
+                        code: 'TASK_ACCEPTANCE_INCOMPLETE',
+                        mutation: true,
+                    });
+                const children = Object.values(s.tasks).filter((x) => x.parentId === task.id);
+                if (children.some((c) => !FakeRelayTransport.finished(s, c.id)) ||
+                    task.dependencies.some((d) => !FakeRelayTransport.finished(s, d)))
+                    this.fail('refused', 'task.move', 'Есть блокеры', {
+                        code: 'TASK_BLOCKED',
+                        mutation: true,
+                    });
+            }
+            task.column = input.column;
+            task.revision++;
+            return { revision: task.revision };
+        });
+    }
+    /* ---------------------------------------------------------------- */
+    /* История                                                           */
+    /* ---------------------------------------------------------------- */
+    requireHistory(operation) {
+        if (this.options.history === false)
+            this.fail('unsupported', operation, 'История не поддерживается', { code: 'UNSUPPORTED' });
+    }
+    sessionOf(s, ref, operation) {
+        const session = s.sessions[ref] ?? Object.values(s.sessions).find((x) => x.key === ref);
+        if (!session)
+            this.fail('not-found', operation, 'Сессия не найдена: ' + ref, { code: 'NOT_FOUND' });
+        return session;
+    }
+    view(session) {
+        const { runs, openIntents, accepted, ...record } = session;
+        void runs;
+        void openIntents;
+        void accepted;
+        return structuredClone(record);
+    }
+    /** CAS ревизии сессии и fencing по run. */
+    guard(session, operation, input, owner = true) {
+        if (session.status === 'completed' || session.status === 'cancelled')
+            this.fail('conflict', operation, 'Сессия закрыта', {
+                code: 'WORK_SESSION_CLOSED',
+                mutation: true,
+            });
+        if (session.revision !== input.ifRevision)
+            this.fail('conflict', operation, 'Ревизия сессии изменилась', {
+                code: 'REVISION_CONFLICT',
+                actualRevision: session.revision,
+                mutation: true,
+            });
+        if (owner &&
+            (session.status !== 'open' || !input.runId || input.runId !== session.currentRunId))
+            this.fail('conflict', operation, 'Run не владеет сессией', {
+                code: 'WORK_RUN_NOT_CURRENT',
+                mutation: true,
+            });
+    }
+    newRun(s, session) {
+        for (const r of session.runs)
+            r.state = 'ended';
+        const run = { id: 'run' + ++s.seq, state: 'active' };
+        session.runs.push(run);
+        session.currentRunId = run.id;
+        session.status = 'open';
+        return run.id;
+    }
+    async startSession(input) {
+        await tick();
+        this.requireHistory('history.start');
+        return this.write('history.start', (s) => {
+            const id = 's' + ++s.seq;
+            const session = {
+                id,
+                key: 'S-' + id,
+                status: 'open',
+                revision: 1,
+                currentRunId: null,
+                parentSessionId: null,
+                title: input.title,
+                description: input.description,
+                result: '',
+                runs: [],
+                openIntents: [],
+                accepted: [],
+            };
+            const runId = this.newRun(s, session);
+            s.sessions[id] = session;
+            return { session: this.view(session), runId };
+        });
+    }
+    async getSession(ref) {
+        await tick();
+        this.requireHistory('history.get');
+        return this.read((s) => this.view(this.sessionOf(s, ref, 'history.get')));
+    }
+    async findSessions(marker) {
+        await tick();
+        this.requireHistory('history.find');
+        return this.read((s) => Object.values(s.sessions)
+            .filter((x) => x.title.includes(marker) || x.description.includes(marker))
+            .map((x) => this.view(x)));
+    }
+    async checkpoints(sessionRef) {
+        await tick();
+        this.requireHistory('history.checkpoints');
+        return this.read((s) => {
+            const session = this.sessionOf(s, sessionRef, 'history.checkpoints');
+            return Object.values(s.checkpoints)
+                .filter((c) => c.sessionId === session.id)
+                .map(({ closed, children, acceptedSessionIds, ...c }) => (void closed,
+                void children,
+                void acceptedSessionIds,
+                structuredClone(c)));
+        });
+    }
+    async openIntent(sessionRef, input) {
+        await tick();
+        this.requireHistory('history.intent');
+        return this.write('history.intent', (s) => {
+            const session = this.sessionOf(s, sessionRef, 'history.intent');
+            this.guard(session, 'history.intent', input);
+            if (!input.body.trim())
+                this.fail('refused', 'history.intent', 'Пустое тело', { code: 'INVALID_INPUT' });
+            const id = 'cp' + ++s.seq;
+            const checkpoint = {
+                id,
+                key: 'CP-' + id,
+                sessionId: session.id,
+                runId: input.runId,
+                kind: 'intent',
+                intentId: null,
+                title: input.title,
+                body: input.body,
+                closed: false,
+                children: [],
+                acceptedSessionIds: [],
+            };
+            s.checkpoints[id] = checkpoint;
+            session.openIntents.push(id);
+            session.revision++;
+            return { session: this.view(session), checkpoint: structuredClone(checkpoint) };
+        });
+    }
+    async checkpoint(intentRef, kind, input) {
+        await tick();
+        this.requireHistory('history.checkpoint');
+        return this.write('history.checkpoint', (s) => {
+            const intent = s.checkpoints[intentRef] ?? Object.values(s.checkpoints).find((c) => c.key === intentRef);
+            if (!intent || intent.kind !== 'intent')
+                this.fail('not-found', 'history.checkpoint', 'Intent не найден', { code: 'NOT_FOUND' });
+            const session = s.sessions[intent.sessionId];
+            this.guard(session, 'history.checkpoint', input);
+            if (intent.closed)
+                this.fail('conflict', 'history.checkpoint', 'Intent закрыт', {
+                    code: 'WORK_INTENT_CLOSED',
+                    mutation: true,
+                });
+            if (kind !== 'progress') {
+                const accepted = [...intent.acceptedSessionIds, ...(input.acceptedSessionIds ?? [])];
+                for (const child of intent.children.map((c) => s.sessions[c])) {
+                    if (child.status !== 'completed' && child.status !== 'cancelled')
+                        this.fail('conflict', 'history.checkpoint', 'Дочерние сессии открыты', {
+                            code: 'WORK_CHILDREN_OPEN',
+                            mutation: true,
+                        });
+                    if (child.status === 'completed' && !accepted.includes(child.id))
+                        this.fail('conflict', 'history.checkpoint', 'Дочерний результат не принят', {
+                            code: 'WORK_CHILDREN_UNACCEPTED',
+                            mutation: true,
+                        });
+                }
+                intent.acceptedSessionIds = accepted;
+                intent.closed = true;
+                session.openIntents = session.openIntents.filter((x) => x !== intent.id);
+            }
+            const id = 'cp' + ++s.seq;
+            const checkpoint = {
+                id,
+                key: 'CP-' + id,
+                sessionId: session.id,
+                runId: input.runId,
+                kind,
+                intentId: intent.id,
+                title: input.title,
+                body: input.body,
+                closed: true,
+                children: [],
+                acceptedSessionIds: input.acceptedSessionIds ?? [],
+            };
+            s.checkpoints[id] = checkpoint;
+            session.revision++;
+            return { session: this.view(session), checkpoint: structuredClone(checkpoint) };
+        });
+    }
+    async fork(intentRef, input) {
+        await tick();
+        this.requireHistory('history.fork');
+        return this.write('history.fork', (s) => {
+            const intent = s.checkpoints[intentRef] ?? Object.values(s.checkpoints).find((c) => c.key === intentRef);
+            if (!intent || intent.kind !== 'intent' || intent.closed)
+                this.fail('conflict', 'history.fork', 'Нужен открытый intent', {
+                    code: 'WORK_INTENT_REQUIRED',
+                    mutation: true,
+                });
+            const parent = s.sessions[intent.sessionId];
+            this.guard(parent, 'history.fork', input);
+            const id = 's' + ++s.seq;
+            const child = {
+                id,
+                key: 'S-' + id,
+                status: 'pending',
+                revision: 1,
+                currentRunId: null,
+                parentSessionId: parent.id,
+                title: input.title,
+                description: input.description,
+                result: '',
+                runs: [],
+                openIntents: [],
+                accepted: [],
+            };
+            s.sessions[id] = child;
+            intent.children.push(id);
+            parent.revision++;
+            return { session: this.view(parent), childSession: this.view(child) };
+        });
+    }
+    async attach(sessionRef, input) {
+        await tick();
+        this.requireHistory('history.attach');
+        return this.write('history.attach', (s) => {
+            const session = this.sessionOf(s, sessionRef, 'history.attach');
+            this.guard(session, 'history.attach', input, false);
+            if (session.status !== 'pending')
+                this.fail('conflict', 'history.attach', 'Нужно состояние pending', {
+                    code: 'WORK_SESSION_STATE',
+                    mutation: true,
+                });
+            const runId = this.newRun(s, session);
+            session.revision++;
+            return { session: this.view(session), runId };
+        });
+    }
+    async takeover(sessionRef, input) {
+        await tick();
+        this.requireHistory('history.takeover');
+        return this.write('history.takeover', (s) => {
+            const session = this.sessionOf(s, sessionRef, 'history.takeover');
+            this.guard(session, 'history.takeover', input, false);
+            if (session.status !== 'open')
+                this.fail('conflict', 'history.takeover', 'Нужно состояние open', {
+                    code: 'WORK_SESSION_STATE',
+                    mutation: true,
+                });
+            const runId = this.newRun(s, session);
+            session.revision++;
+            return { session: this.view(session), runId };
+        });
+    }
+    async finishSession(sessionRef, outcome, input) {
+        await tick();
+        this.requireHistory('history.finish');
+        return this.write('history.finish', (s) => {
+            const session = this.sessionOf(s, sessionRef, 'history.finish');
+            const owner = session.status === 'open' || outcome === 'complete';
+            if (!owner && input.runId)
+                this.fail('conflict', 'history.finish', 'runId только для open', {
+                    code: 'WORK_RUN_NOT_CURRENT',
+                    mutation: true,
+                });
+            this.guard(session, 'history.finish', input, owner);
+            if (session.openIntents.length)
+                this.fail('conflict', 'history.finish', 'Есть открытые intent', {
+                    code: 'WORK_INTENTS_OPEN',
+                    mutation: true,
+                });
+            session.status = outcome === 'complete' ? 'completed' : 'cancelled';
+            session.result = input.result;
+            session.currentRunId = null;
+            for (const r of session.runs)
+                r.state = 'ended';
+            session.revision++;
+            return { session: this.view(session) };
+        });
+    }
+}
+/**
+ * Действия «другого участника» прямо в подделке: постановка задач, правки,
+ * перехват сессии. Ядро коннектора ими не пользуется.
+ */
+export class FakeAdmin {
+    backend;
+    constructor(backend) {
+        this.backend = backend;
+    }
+    write(fn) {
+        return this.backend.with((s) => {
+            const out = fn(s);
+            s.generation++;
+            return out;
+        }, true);
+    }
+    createTask(input) {
+        return this.write((s) => {
+            const n = Object.keys(s.tasks).length + 1;
+            const id = 't' + n;
+            s.tasks[id] = {
+                id,
+                key: 'PRODUCT-' + n,
+                title: input.title,
+                description: input.description,
+                column: input.column ?? 'ready',
+                revision: 1,
+                parentId: input.parentId ?? null,
+                dependencies: input.dependencies ?? [],
+                criteria: (input.criteria ?? []).map((c, i) => ({
+                    id: `${id}c${i + 1}`,
+                    title: c.title,
+                    summary: c.summary ?? '',
+                    description: '',
+                    completed: false,
+                })),
+            };
+            return { id, key: s.tasks[id].key, criteria: s.tasks[id].criteria.map((c) => c.id) };
+        });
+    }
+    task(id) {
+        return this.backend.with((s) => structuredClone(s.tasks[id]), false);
+    }
+    updateTask(id, patch) {
+        this.write((s) => {
+            Object.assign(s.tasks[id], patch);
+            s.tasks[id].revision++;
+        });
+    }
+    addCriterion(id, title) {
+        return this.write((s) => {
+            const task = s.tasks[id];
+            const cid = `${id}c${task.criteria.length + 1}`;
+            task.criteria.push({ id: cid, title, summary: '', description: '', completed: false });
+            task.revision++;
+            return cid;
+        });
+    }
+    updateCriterion(id, criterionId, title) {
+        this.write((s) => {
+            const c = s.tasks[id].criteria.find((x) => x.id === criterionId);
+            c.title = title;
+            c.completed = false;
+            s.tasks[id].revision++;
+        });
+    }
+    completeCriterion(id, criterionId, completed = true) {
+        this.write((s) => {
+            s.tasks[id].criteria.find((x) => x.id === criterionId).completed = completed;
+            s.tasks[id].revision++;
+        });
+    }
+    addDocument(taskId, doc) {
+        return this.write((s) => {
+            const n = Object.keys(s.documents).length + 1;
+            const id = 'd' + n;
+            s.documents[id] = {
+                id,
+                key: 'DOC-' + n,
+                name: doc.name,
+                body: doc.body,
+                revision: 1,
+                targets: [taskId],
+            };
+            return { id };
+        });
+    }
+    updateDocument(id, body) {
+        this.write((s) => {
+            s.documents[id].body = body;
+            s.documents[id].revision++;
+        });
+    }
+    addDependency(id, dependsOn) {
+        this.write((s) => {
+            s.tasks[id].dependencies.push(dependsOn);
+            s.tasks[id].revision++;
+        });
+    }
+    /** Перемещение с соблюдением done guards (как у человека в backend). */
+    move(id, column) {
+        this.write((s) => {
+            const task = s.tasks[id];
+            if (column === 'done' &&
+                (task.criteria.some((c) => !c.completed) ||
+                    Object.values(s.tasks).some((x) => x.parentId === id && !FakeRelayTransport.finished(s, x.id)) ||
+                    task.dependencies.some((d) => !FakeRelayTransport.finished(s, d))))
+                throw new Error('done guard: задача не может быть завершена');
+            task.column = column;
+            task.revision++;
+        });
+    }
+    comment(id, body, actor = 'someone-else') {
+        this.write((s) => {
+            (s.comments[id] ??= []).push({
+                id: String(++s.seq),
+                title: 'note',
+                body,
+                actor,
+                createdAt: new Date().toISOString(),
+            });
+        });
+    }
+    takeover(sessionId) {
+        this.write((s) => {
+            const session = s.sessions[sessionId];
+            for (const r of session.runs)
+                r.state = 'ended';
+            const run = { id: 'run' + ++s.seq, state: 'active' };
+            session.runs.push(run);
+            session.currentRunId = run.id;
+            session.revision++;
+        });
+    }
+    state() {
+        return this.backend.with((s) => structuredClone(s), false);
+    }
+}
+/** Барьер одного процесса. */
+export class LocalBarrier {
+    arrived;
+    released;
+    reached = new Promise((r) => (this.arrived = r));
+    gate = new Promise((r) => (this.released = r));
+    async arrive() {
+        this.arrived();
+        await this.gate;
+    }
+    release() {
+        this.released();
+    }
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** Барьер между процессами: файлы `<name>.reached` и `<name>.release` в общем каталоге. */
+export class FileBarrier {
+    dir;
+    name;
+    timeoutMs;
+    constructor(dir, name, timeoutMs = 30_000) {
+        this.dir = dir;
+        this.name = name;
+        this.timeoutMs = timeoutMs;
+    }
+    file(kind) {
+        return join(this.dir, `${this.name}.${kind}`);
+    }
+    async arrive() {
+        mkdirSync(this.dir, { recursive: true });
+        writeFileSync(this.file('reached'), String(process.pid));
+        const until = Date.now() + this.timeoutMs;
+        while (!existsSync(this.file('release'))) {
+            if (Date.now() > until)
+                throw new Error(`Барьер ${this.name}: нет разрешения за ${this.timeoutMs} мс`);
+            await sleep(20);
+        }
+    }
+    /** Ждать прибытия (конечный срок). */
+    async reached(timeoutMs = this.timeoutMs) {
+        const until = Date.now() + timeoutMs;
+        while (!existsSync(this.file('reached'))) {
+            if (Date.now() > until)
+                throw new Error(`Барьер ${this.name}: никто не прибыл за ${timeoutMs} мс`);
+            await sleep(20);
+        }
+        return Number(readFileSync(this.file('reached'), 'utf8'));
+    }
+    release() {
+        mkdirSync(this.dir, { recursive: true });
+        writeFileSync(this.file('release'), '1');
+    }
+}
+const mutating = new Set([
+    'addComment',
+    'setCriterion',
+    'move',
+    'startSession',
+    'openIntent',
+    'checkpoint',
+    'fork',
+    'attach',
+    'takeover',
+    'finishSession',
+]);
+/**
+ * Обёртка отказов вокруг **любого** транспорта (подделки или настоящего
+ * адаптера): управляемые точки отказа без случайных задержек.
+ */
+export function faultyTransport(inner, rules) {
+    const calls = {};
+    const wrap = (op) => async (...args) => {
+        const n = (calls[op] = (calls[op] ?? 0) + 1);
+        const rule = rules.find((r) => r.op === op && (r.nth === undefined || (n >= r.nth && n < r.nth + (r.times ?? 1))));
+        const call = () => inner[op].apply(inner, args);
+        const error = (kind, message) => new TransportError(kind, String(op), 'injected: ' + (rule?.message ?? message), {
+            provider: inner.provider,
+            mutation: mutating.has(op),
+        });
+        if (!rule)
+            return call();
+        switch (rule.action) {
+            case 'refuse': {
+                const refusal = rule.refusal ?? { kind: 'refused', code: 'VALIDATION_ERROR' };
+                throw new TransportError(refusal.kind, String(op), 'injected: ' + (rule.message ?? 'отказ получателя'), {
+                    provider: inner.provider,
+                    code: refusal.code,
+                    mutation: mutating.has(op),
+                });
+            }
+            case 'fail-before-send':
+                throw error('unavailable', 'запрос не отправлен');
+            case 'timeout':
+                throw error('uncertain', 'таймаут, исход неизвестен');
+            case 'drop-response':
+                await call();
+                // Чужая запись между фиксацией у получателя и read-back (гонка).
+                await rule.after?.();
+                throw error('uncertain', 'ответ потерян после выполнения');
+            case 'protocol-after':
+                await call();
+                throw error('protocol', 'ответ вне договора');
+            case 'barrier':
+                await rule.barrier.arrive();
+                return call();
+            case 'exit-before':
+                process.exit(rule.exitCode ?? 75);
+                break;
+            case 'exit-after': {
+                await call();
+                process.exit(rule.exitCode ?? 75);
+                break;
+            }
+            case 'after': {
+                const out = await call();
+                await rule.after?.();
+                return out;
+            }
+        }
+        return call();
+    };
+    const proxy = {
+        provider: inner.provider,
+        calls,
+        identity: wrap('identity'),
+        readTask: wrap('readTask'),
+        listComments: wrap('listComments'),
+        addComment: wrap('addComment'),
+        setCriterion: wrap('setCriterion'),
+        move: wrap('move'),
+        startSession: wrap('startSession'),
+        getSession: wrap('getSession'),
+        findSessions: wrap('findSessions'),
+        checkpoints: wrap('checkpoints'),
+        openIntent: wrap('openIntent'),
+        checkpoint: wrap('checkpoint'),
+        fork: wrap('fork'),
+        attach: wrap('attach'),
+        takeover: wrap('takeover'),
+        finishSession: wrap('finishSession'),
+    };
+    return proxy;
+}