@zenera/cli 1.1.24 → 1.1.26

package/dist/meta/finetune/improvements.js

@@ -0,0 +1,501 @@
+import { randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { writeApplyBrief } from "./apply-brief.js";
+import { costChanges, limits, measure, overLimits } from "./cost.js";
+import { errorIn, sizeOf } from "./failure.js";
+import { forProse } from "./feedback.js";
+import { patchFiles, writeApply } from "./report.js";
+import { readJson, Stopped } from "./tuning.js";
+import { applyTokens, spent } from "./usage.js";
+const pad = (n) => String(n).padStart(3, '0');
+const kept = (d) => d?.decision === 'applied' || d?.decision === 'merged';
+const DECIDED = new Set(['applied', 'merged', 'rejected', 'deferred', 'structural']);
+/** `<request> <improvement>` for each improvement of inputs.json that decisions.json gives no valid decision. */
+export function undecided(dir) {
+    const inputs = readJson(join(dir, 'inputs.json')) ?? [];
+    const decided = readJson(join(dir, 'decisions.json')) ?? {};
+    return inputs.flatMap((f) => forProse(f)
+        .filter((i) => !DECIDED.has(decided[f.id]?.[i.id]?.decision ?? ''))
+        .map((i) => `${f.id} ${i.id}`));
+}
+export class Improvements {
+    #t;
+    pending = [];
+    /** the batch an apply is working on */
+    inApply = [];
+    #applied = new Set();
+    /** cases parked right now */
+    parked = 0;
+    /** `zen run`s in flight */
+    runs = 0;
+    applying = false;
+    /** the apply under way; `name` once it has a folder, before that it waits for runs */
+    current;
+    /** applies started in this process */
+    started = 0;
+    /** applies finished in this process - an analysis spanning one may see edits */
+    count = 0;
+    constructor(t) {
+        this.#t = t;
+        this.reload();
+    }
+    /** Re-reads which requests the applies took - a recovery may have removed one. */
+    reload() {
+        this.#applied.clear();
+        for (const name of this.#names()) {
+            for (const id of readJson(join(this.dir, name, 'applied.json'))?.ids ??
+                []) {
+                this.#applied.add(id);
+            }
+        }
+    }
+    get dir() {
+        return join(this.#t.dir, 'applies');
+    }
+    #names() {
+        try {
+            return readdirSync(this.dir)
+                .filter((n) => /^\d{3}$/.test(n))
+                .sort();
+        }
+        catch {
+            return [];
+        }
+    }
+    isApplied(id) {
+        return this.#applied.has(id);
+    }
+    /**
+     * Every apply's decisions, later ones over earlier, per improvement. An edit
+     * that was undone kept nothing, so what it applied or merged reads `discarded`.
+     */
+    decisions() {
+        const all = {};
+        for (const a of this.applies()) {
+            const undone = a.applied?.discarded;
+            for (const [id, byImprovement] of Object.entries(readJson(join(a.dir, 'decisions.json')) ?? {})) {
+                for (const [i, d] of Object.entries(byImprovement ?? {})) {
+                    (all[id] ??= {})[i] =
+                        undone && kept(d)
+                            ? {
+                                ...d,
+                                decision: 'discarded',
+                                note: `${d.note ?? ''} - undone: ${undone}`.trim(),
+                            }
+                            : d;
+                }
+            }
+        }
+        return all;
+    }
+    /** Improvements held back for want of a second case, and not taken up since. */
+    deferred() {
+        const open = new Map();
+        for (const a of this.applies()) {
+            const inputs = new Map((a.inputs ?? []).map((f) => [f.id, f]));
+            const undone = Boolean(a.applied?.discarded);
+            for (const [id, byImprovement] of Object.entries(readJson(join(a.dir, 'decisions.json')) ?? {})) {
+                for (const [i, d] of Object.entries(byImprovement ?? {})) {
+                    const key = `${id} ${i}`;
+                    if (d?.decision === 'deferred') {
+                        const improvement = inputs.get(id)?.improvements.find((x) => x.id === i) ??
+                            open.get(key)?.improvement;
+                        if (improvement) {
+                            open.set(key, {
+                                request: id,
+                                case: inputs.get(id)?.case ?? open.get(key)?.case ?? id.split('@')[0],
+                                apply: a.name,
+                                improvement,
+                                ...(d.note ? { note: d.note } : {}),
+                            });
+                        }
+                    }
+                    else if (!undone) {
+                        open.delete(key);
+                    }
+                }
+            }
+        }
+        return [...open.values()];
+    }
+    /** The skills an apply made or changed for this request: the case's next run should load them. */
+    skillsFor(id) {
+        const mine = this.decisions()[id] ?? {};
+        return [
+            ...new Set(Object.values(mine)
+                .filter((d) => kept(d) && d.skill)
+                .map((d) => d.skill)),
+        ];
+    }
+    /** Nothing of this request was applied, merged or deferred, and some of it is structural: prose cannot fix it. */
+    #structural(id) {
+        const mine = Object.values(this.decisions()[id] ?? {});
+        const structural = mine.filter((d) => d.decision === 'structural');
+        if (structural.length === 0 ||
+            mine.some((d) => kept(d) || d.decision === 'deferred' || d.decision === 'discarded')) {
+            return undefined;
+        }
+        return structural.map((d) => d.note || 'structural').join('; ');
+    }
+    /**
+     * Parks until an apply has taken this feedback, the worker free meanwhile. Taken already - after a restart - returns at once.
+     * `structural` when the apply found nothing prose can fix.
+     */
+    async apply(feedback, s) {
+        if (this.#applied.has(feedback.id)) {
+            return this.#outcome(feedback.id);
+        }
+        if (!this.pending.some((f) => f.id === feedback.id)) {
+            this.pending.push(feedback);
+        }
+        this.parked++;
+        this.#t.event({
+            what: 'parked',
+            worker: s.worker?.slot,
+            case: feedback.case,
+            phase: feedback.phase,
+            attempt: feedback.attempt,
+            detail: `${forProse(feedback).length} improvement(s), worker freed`,
+        });
+        this.#t.unseat(s);
+        try {
+            while (!this.#applied.has(feedback.id)) {
+                if (this.#t.stopping) {
+                    throw new Stopped();
+                }
+                await this.#t.tick();
+            }
+        }
+        finally {
+            this.parked--;
+        }
+        const outcome = this.#outcome(feedback.id);
+        if (outcome.structural) {
+            return outcome;
+        }
+        await this.#t.seat(s, true);
+        return outcome;
+    }
+    #outcome(id) {
+        const structural = this.#structural(id);
+        return structural ? { structural } : {};
+    }
+    /** A recheck's request: queued like a parked case's, with no case waiting on it. */
+    regressed(feedback) {
+        if (!this.#applied.has(feedback.id) &&
+            !this.pending.some((f) => f.id === feedback.id) &&
+            !this.inApply.some((f) => f.id === feedback.id)) {
+            this.pending.push(feedback);
+        }
+    }
+    /** Before a run starts: wait out an apply, or stop. */
+    async notApplying() {
+        while (this.applying) {
+            this.#t.checkStopping();
+            await this.#t.tick();
+        }
+        this.#t.checkStopping();
+    }
+    /** The applier: runs until the tuning is finished. */
+    async loop() {
+        while (!this.#t.finished) {
+            await this.#t.tick();
+            if (this.#t.stopping) {
+                continue;
+            }
+            if (this.pending.length === 0) {
+                continue;
+            }
+            if (this.pending.length < this.#t.config.applyAt &&
+                (this.#t.busy() > 0 || !this.#t.drained)) {
+                continue;
+            }
+            try {
+                await this.#applyNow();
+            }
+            catch (err) {
+                this.#t.fatal = err;
+                this.#t.stop(`apply failed: ${err.message}`);
+            }
+        }
+    }
+    /** What the agents read when the tuning began - its first version, even for a tuning begun before this was kept. */
+    async baseline() {
+        const file = join(this.#t.dir, 'baseline.json');
+        const saved = readJson(file)?.cost;
+        if (saved) {
+            return saved;
+        }
+        const first = this.#t.system.rows()[0];
+        const at = first ? this.#t.system.snapshotDir(first.v) : undefined;
+        const cost = await measure(at && existsSync(at) ? at : this.#t.root);
+        mkdirSync(this.#t.dir, { recursive: true });
+        writeFileSync(file, `${JSON.stringify({ at: new Date().toISOString(), version: first?.v ?? 0, cost }, null, 2)}\n`);
+        return cost;
+    }
+    async #applyNow() {
+        const t = this.#t;
+        this.applying = true;
+        this.current = { since: Date.now() };
+        this.started++;
+        t.event({ what: 'apply waiting', detail: `${this.runs} run(s) to finish` });
+        try {
+            while (this.runs > 0) {
+                await t.tick();
+            }
+            const batch = this.pending.splice(0);
+            this.inApply = batch;
+            const name = pad(Math.max(0, ...this.#names().map(Number)) + 1);
+            const dir = join(this.dir, name);
+            const from = t.system.record('external').v;
+            await t.journal.step({ kind: 'apply', dir, from }, () => this.#applyBatch(batch, name, dir, from));
+        }
+        finally {
+            this.applying = false;
+            this.current = undefined;
+            this.inApply = [];
+        }
+    }
+    async #applyBatch(batch, name, dir, from) {
+        const t = this.#t;
+        const startedAt = new Date().toISOString();
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(join(dir, 'inputs.json'), `${JSON.stringify(batch.map((f) => {
+            const at = f.dir ?? t.attemptDir({ id: f.case, rev: f.caseRev }, f.phase, f.attempt);
+            const missed = readJson(join(at, 'run.json'))?.missedSkills;
+            const { dir: _, ...rest } = f;
+            return {
+                ...rest,
+                improvements: forProse(f),
+                file: join(at, 'feedback.json'),
+                ...(missed?.length ? { missedSkills: missed } : {}),
+            };
+        }), null, 2)}\n`);
+        writeFileSync(join(dir, 'deferred.json'), `${JSON.stringify(this.deferred(), null, 2)}\n`);
+        const total = batch.reduce((n, f) => n + forProse(f).length, 0);
+        this.current = { since: Date.now(), name, dir, requests: batch.length };
+        let to = from;
+        let discarded;
+        let bytes;
+        if (total > 0) {
+            t.event({
+                what: 'apply',
+                detail: `${name}: ${batch.length} request(s), ${total} improvement(s)`,
+            });
+            writeApply(t, dir);
+            try {
+                const done = await this.#edit(dir, from);
+                bytes = done.bytes;
+                if ('discarded' in done) {
+                    discarded = done.discarded;
+                }
+                else {
+                    to = done.to;
+                }
+            }
+            catch (err) {
+                writeFileSync(join(dir, 'failed.json'), `${JSON.stringify({ at: new Date().toISOString(), startedAt, error: err.message }, null, 2)}\n`);
+                writeApply(t, dir);
+                throw err;
+            }
+        }
+        const applied = {
+            ids: batch.map((f) => f.id),
+            from,
+            to,
+            at: new Date().toISOString(),
+            startedAt,
+            ...(total === 0 ? { skipped: true } : {}),
+            ...(discarded ? { discarded } : {}),
+            ...(bytes ? { bytes } : {}),
+        };
+        writeFileSync(join(dir, 'applied.json'), `${JSON.stringify(applied, null, 2)}\n`);
+        writeApply(t, dir);
+        for (const f of batch) {
+            this.#applied.add(f.id);
+        }
+        this.count++;
+        this.current = undefined;
+        t.event({
+            what: discarded ? 'apply undone' : 'applied',
+            detail: `${name}: ${discarded ? `undone - ${discarded}` : `v${from} -> v${to}`}, see applies/${name}/APPLY.md`,
+            result: total === 0 ? 'nothing to change' : discarded ? 'undone' : `v${from} → v${to}`,
+            took: Date.now() - Date.parse(startedAt),
+            tokens: spent(applyTokens(dir)),
+        });
+        if (!discarded && to !== from) {
+            t.rechecks.queue(name);
+        }
+    }
+    /** What an apply is handed about the prose: sizes, limits, and which files grew. */
+    async #writeBudget(dir, now) {
+        const start = await this.baseline();
+        const { files: _, ...rest } = now;
+        writeFileSync(join(dir, 'budget.json'), `${JSON.stringify({
+            ...rest,
+            start: { total: start.total, alwaysRead: start.alwaysRead },
+            ...limits(start, this.#t.config),
+        }, null, 2)}\n`);
+        const touched = new Map();
+        for (const a of this.applies()) {
+            if (!a.applied || a.applied.discarded || !existsSync(join(a.dir, 'diff.patch'))) {
+                continue;
+            }
+            for (const f of patchFiles(readFileSync(join(a.dir, 'diff.patch'), 'utf8'))) {
+                touched.set(f.file, [...(touched.get(f.file) ?? []), a.name]);
+            }
+        }
+        const growth = Object.keys(now.files)
+            .map((file) => ({
+            file,
+            start: start.files[file] ?? 0,
+            now: now.files[file],
+            changes: touched.get(file)?.length ?? 0,
+            recent: (touched.get(file) ?? []).slice(-5),
+        }))
+            .sort((a, b) => b.now - b.start - (a.now - a.start));
+        writeFileSync(join(dir, 'growth.json'), `${JSON.stringify(growth, null, 2)}\n`);
+    }
+    /**
+     * The meta agent edits, then two gates: `zen check` and the budget. A failed
+     * gate undoes the edit and the agent tries once more, told why. `zen check`
+     * failing twice is fatal - the agent cannot leave the project loadable; the
+     * budget failing twice only undoes it. What the edit broke elsewhere is the
+     * rechecks' to find, after it.
+     */
+    async #edit(dir, from) {
+        const t = this.#t;
+        const name = basename(dir);
+        const before = await measure(t.root);
+        await this.#writeBudget(dir, before);
+        const bound = limits(await this.baseline(), t.config);
+        const gate = { before, limits: bound };
+        writeFileSync(join(dir, 'gate.json'), `${JSON.stringify(gate)}\n`);
+        const unchanged = { before: before.total, after: before.total };
+        const at = (step) => {
+            if (this.current) {
+                this.current.step = step;
+            }
+        };
+        for (let attempt = 1;; attempt++) {
+            at('edit');
+            const session = randomUUID();
+            writeFileSync(join(dir, 'session'), `${session}\n`);
+            const applyLog = join(dir, 'apply.log');
+            const checkLog = join(dir, 'check.log');
+            const offset = { apply: sizeOf(applyLog), check: sizeOf(checkLog) };
+            // An undone attempt's record must not pass for this one's.
+            for (const f of ['decisions.json', 'changes.md']) {
+                rmSync(join(dir, f), { force: true });
+            }
+            const brief = await writeApplyBrief(t, dir, attempt);
+            const res = await t.zen([
+                'meta',
+                'run',
+                '--no-refresh',
+                '--json',
+                '--session-id',
+                session,
+                '--events',
+                join(dir, 'apply.events.jsonl'),
+                '--prompt-file',
+                brief,
+                '/finetune-apply',
+                dir,
+            ], applyLog);
+            writeFileSync(join(dir, attempt === 1 ? 'apply.json' : `apply-${attempt}.json`), res.stdout);
+            // An agent cut off by its provider can still exit 0, having decided nothing.
+            const missing = res.code === 0 ? undecided(dir) : [];
+            if (missing.length > 0) {
+                writeFileSync(join(dir, 'missing.md'), [
+                    `# Attempt ${attempt} was undone: decisions missing`,
+                    '',
+                    'Written by the tuning loop: the apply ended without a decision for these improvements, so the project was put back. This attempt must write `decisions.json` with every one of them, and `changes.md`.',
+                    '',
+                    ...missing.map((m) => `- ${m}`),
+                    '',
+                ].join('\n'));
+                t.error(`apply ${name}${attempt > 1 ? ` try ${attempt}` : ''}`, `the apply ended without a decision for ${missing.length} improvement(s)`, applyLog);
+                t.system.restore(from);
+                if (attempt === 2) {
+                    throw new Error(`apply ${dir} ended twice without deciding every improvement - see missing.md`);
+                }
+                t.event({
+                    what: 'apply retry',
+                    detail: `no decision for ${missing.length} improvement(s)`,
+                });
+                continue;
+            }
+            at('check');
+            const check = await t.zen(['check', '--no-models', '--no-sandbox'], checkLog);
+            if (res.code !== 0 || check.code !== 0) {
+                const e = res.code !== 0
+                    ? errorIn(applyLog, offset.apply)
+                    : errorIn(checkLog, offset.check);
+                t.error(`apply ${name}${attempt > 1 ? ` try ${attempt}` : ''}`, `${res.code !== 0 ? 'the apply failed' : 'zen check failed after the apply'}${e.message ? `: ${e.message}` : ''}`, e.log);
+                t.system.restore(from);
+                if (attempt === 2) {
+                    throw new Error(`apply ${dir} left the project broken twice - see check.log`);
+                }
+                t.event({
+                    what: 'apply retry',
+                    detail: res.code !== 0 ? 'the apply failed' : 'zen check failed',
+                });
+                continue;
+            }
+            const after = await measure(t.root);
+            const over = overLimits(before, after, bound);
+            if (over.length > 0) {
+                writeFileSync(join(dir, 'budget.md'), [
+                    `# Attempt ${attempt} was undone: over the limits`,
+                    '',
+                    'Written by the tuning loop: this edit grew what the agents read past a limit, so the project was put back. The next attempt reads this file to know what to cut.',
+                    '',
+                    ...over.map((o) => `- ${o}`),
+                    '',
+                    '## What moved',
+                    '',
+                    ...costChanges(before, after),
+                    '',
+                ].join('\n'));
+                t.system.restore(from);
+                if (attempt === 2) {
+                    return { discarded: `over the limits: ${over[0]}`, bytes: unchanged };
+                }
+                t.event({ what: 'apply retry', detail: `over the limits: ${over[0]}` });
+                continue;
+            }
+            const to = t.system.record('apply', name).v;
+            if (to === from) {
+                return { to, bytes: unchanged };
+            }
+            writeFileSync(join(dir, 'diff.patch'), t.system.diff(from, to));
+            const moved = costChanges(before, after);
+            writeFileSync(join(dir, 'cost.md'), [
+                '# What moved',
+                '',
+                'Written by the tuning loop once this apply passed its gates: bytes before and after it - what each agent reads on every call, each skill body, each file under agents/.',
+                '',
+                ...(moved.length > 0 ? moved : ['Nothing the agents read changed size.']),
+                '',
+            ].join('\n'));
+            return { to, bytes: { before: before.total, after: after.total } };
+        }
+    }
+    /** Requests every apply so far took, for the report. */
+    applies() {
+        return this.#names().map((name) => {
+            const dir = join(this.dir, name);
+            return {
+                name,
+                dir,
+                applied: readJson(join(dir, 'applied.json')),
+                inputs: existsSync(join(dir, 'inputs.json'))
+                    ? readJson(join(dir, 'inputs.json'))
+                    : undefined,
+            };
+        });
+    }
+}
+//# sourceMappingURL=improvements.js.map

package/dist/meta/finetune/index.d.ts

@@ -0,0 +1,2 @@
+export { FINETUNE_DETAILS, FINETUNE_HELP, FINETUNE_SUMMARY, FINETUNE_USAGE, finetuneProjectFlag, runFinetune, } from './command.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/meta/finetune/index.js

@@ -0,0 +1,2 @@
+export { FINETUNE_DETAILS, FINETUNE_HELP, FINETUNE_SUMMARY, FINETUNE_USAGE, finetuneProjectFlag, runFinetune, } from "./command.js";
+//# sourceMappingURL=index.js.map

package/dist/meta/finetune/journal.d.ts

@@ -0,0 +1,35 @@
+import type { Tuning } from './tuning.ts';
+export type Tx = {
+    kind: 'run';
+    dir: string;
+} | {
+    kind: 'analyze';
+    dir: string;
+} | {
+    kind: 'apply';
+    dir: string;
+    from: number;
+} | {
+    kind: 'merge';
+    dir: string;
+    log: string;
+};
+export declare class Journal {
+    #private;
+    readonly file: string;
+    constructor(file: string);
+    begin(tx: Tx): string;
+    end(id: string, op: 'commit' | 'failed' | 'rollback'): void;
+    /** Runs `fn` as one transaction. */
+    step<T>(tx: Tx, fn: () => Promise<T>): Promise<T>;
+    /** Transactions begun and never closed, oldest first. */
+    open(): {
+        id: string;
+        tx: Tx;
+    }[];
+    /** Every transaction closed: the history can go. */
+    clear(): void;
+}
+/** Rolls back what a kill cut off. Only under the loop's lock: a live step looks the same. */
+export declare function recover(t: Tuning): Promise<void>;
+//# sourceMappingURL=journal.d.ts.map

package/dist/meta/finetune/journal.js

@@ -0,0 +1,135 @@
+import { randomUUID } from 'node:crypto';
+import { appendFileSync, mkdirSync, readFileSync, rmSync } from 'node:fs';
+import { basename, dirname, isAbsolute, join, relative } from 'node:path';
+import { reap } from "./children.js";
+/** What a step leaves in its attempt folder; the logs stay, they only grow. */
+const OUTPUTS = {
+    run: ['run.json', 'envelope.json', 'request.json', 'events.jsonl', 'memory', 'workspace'],
+    analyze: [
+        'feedback.json',
+        'analysis.md',
+        'analyze.json',
+        'analyze-2.json',
+        'analyze.events.jsonl',
+    ],
+};
+export class Journal {
+    file;
+    #base;
+    constructor(file) {
+        this.file = file;
+        this.#base = dirname(file);
+    }
+    #append(row) {
+        mkdirSync(this.#base, { recursive: true });
+        appendFileSync(this.file, `${JSON.stringify(row)}\n`);
+    }
+    // Paths are kept relative, so a project moved between sessions still recovers.
+    #paths(tx, to) {
+        return { ...tx, dir: to(tx.dir), ...('log' in tx ? { log: to(tx.log) } : {}) };
+    }
+    begin(tx) {
+        const id = randomUUID().slice(0, 8);
+        this.#append({
+            id,
+            at: new Date().toISOString(),
+            op: 'begin',
+            tx: this.#paths(tx, (p) => relative(this.#base, p)),
+        });
+        return id;
+    }
+    end(id, op) {
+        this.#append({ id, at: new Date().toISOString(), op });
+    }
+    /** Runs `fn` as one transaction. */
+    async step(tx, fn) {
+        const id = this.begin(tx);
+        let result;
+        try {
+            result = await fn();
+        }
+        catch (err) {
+            this.end(id, 'failed');
+            throw err;
+        }
+        this.end(id, 'commit');
+        return result;
+    }
+    /** Transactions begun and never closed, oldest first. */
+    open() {
+        let text = '';
+        try {
+            text = readFileSync(this.file, 'utf8');
+        }
+        catch {
+            return [];
+        }
+        const begun = new Map();
+        for (const line of text.split('\n')) {
+            let row;
+            try {
+                row = JSON.parse(line);
+            }
+            catch {
+                // A line torn by the kill itself.
+                continue;
+            }
+            if (row.op === 'begin') {
+                begun.set(row.id, row.tx);
+            }
+            else {
+                begun.delete(row.id);
+            }
+        }
+        return [...begun].map(([id, tx]) => ({
+            id,
+            tx: this.#paths(tx, (p) => (isAbsolute(p) ? p : join(this.#base, p))),
+        }));
+    }
+    /** Every transaction closed: the history can go. */
+    clear() {
+        rmSync(this.file, { force: true });
+    }
+}
+/** Rolls back what a kill cut off. Only under the loop's lock: a live step looks the same. */
+export async function recover(t) {
+    // Before anything is rolled back: a child still running would write into it again.
+    const reaped = await reap(t.dir);
+    if (reaped.length > 0) {
+        t.event({
+            what: 'stopped leftovers',
+            detail: `${reaped.length} process(es) the last loop left running`,
+        });
+    }
+    const open = t.journal.open().reverse();
+    for (const { id, tx } of open) {
+        rollback(t, tx);
+        t.journal.end(id, 'rollback');
+        t.event({ what: 'rolled back', detail: `${tx.kind} ${relative(t.dir, tx.dir)}` });
+    }
+    if (open.some(({ tx }) => tx.kind === 'apply')) {
+        t.improvements.reload();
+    }
+    t.journal.clear();
+}
+function rollback(t, tx) {
+    switch (tx.kind) {
+        case 'run':
+        case 'analyze':
+            for (const name of OUTPUTS[tx.kind]) {
+                rmSync(join(tx.dir, name), { recursive: true, force: true });
+            }
+            return;
+        case 'apply':
+            // Its edits never passed `zen check`: put back the version it started from.
+            t.system.restore(tx.from);
+            t.system.drop(basename(tx.dir));
+            rmSync(tx.dir, { recursive: true, force: true });
+            return;
+        case 'merge':
+            rmSync(tx.dir, { recursive: true, force: true });
+            rmSync(tx.log, { force: true });
+            return;
+    }
+}
+//# sourceMappingURL=journal.js.map