artshelf 0.10.1 → 0.10.2

package/dist/src/commands/cleanup.js

@@ -0,0 +1,52 @@
+import { createCleanupPlan, executeCleanupPlan } from "../ledger.js";
+import { normalizeRegistryPath } from "../registry.js";
+import { printJson } from "../renderers/json.js";
+import { boolFlag, requiredStringFlag, stringFlag } from "../shared/flags.js";
+import { printPlan, printPlans, registeredLedgersOrThrow, validateRegisteredLedger } from "./shared.js";
+export function handleCleanup(parsed, ledgerPath, json) {
+    const dryRun = boolFlag(parsed, "dry-run");
+    const execute = boolFlag(parsed, "execute");
+    if (dryRun && execute)
+        throw new Error("cleanup accepts either --dry-run or --execute, not both");
+    if (boolFlag(parsed, "all") && execute)
+        throw new Error("cleanup --all is dry-run only; execute requires an explicit --ledger and reviewed --plan-id");
+    if (dryRun) {
+        if (boolFlag(parsed, "all")) {
+            const registryPath = normalizeRegistryPath(stringFlag(parsed, "registry"));
+            const ledgers = registeredLedgersOrThrow(registryPath);
+            const validations = ledgers.map((ledger) => ({ ledger, result: validateRegisteredLedger(ledger) }));
+            const ok = validations.every((entry) => entry.result.ok);
+            if (!ok) {
+                if (json) {
+                    printJson({ ok, registryPath, ledgers: validations });
+                    return 1;
+                }
+                for (const entry of validations.filter((item) => !item.result.ok)) {
+                    process.stdout.write(`invalid ${entry.ledger.name}: ${entry.result.errors.join("; ")}\nledger: ${entry.ledger.path}\n`);
+                }
+                process.stdout.write(`registry: ${registryPath}\n`);
+                return 1;
+            }
+            const plans = ledgers.map((ledger) => ({ ledger, plan: createCleanupPlan(ledger.path) }));
+            if (json)
+                return printJson({ ok: true, registryPath, plans });
+            printPlans(plans);
+            process.stdout.write(`registry: ${registryPath}\n`);
+            return 0;
+        }
+        const plan = createCleanupPlan(ledgerPath);
+        if (json)
+            return printJson({ ok: true, plan });
+        printPlan(plan, ledgerPath);
+        return 0;
+    }
+    if (execute) {
+        const planId = requiredStringFlag(parsed, "plan-id");
+        const receipt = executeCleanupPlan(ledgerPath, planId);
+        if (json)
+            return printJson({ ok: true, receipt });
+        process.stdout.write(`receipt ${receipt.planId}: ${receipt.results.length} results\nreceipt: ${receipt.receiptPath}\nledger: ${ledgerPath}\n`);
+        return 0;
+    }
+    throw new Error("cleanup requires --dry-run or --execute");
+}

package/dist/src/commands/doctor.js

@@ -0,0 +1,79 @@
+import { existsSync } from "node:fs";
+import { listRegisteredLedgers, normalizeRegistryPath } from "../registry.js";
+import { VERSION } from "../config/package.js";
+import { buildDoctorAgentPacket, printDoctor } from "../renderers/doctor.js";
+import { printCompactJson, printJson } from "../renderers/json.js";
+import { boolFlag, stringFlag } from "../shared/flags.js";
+import { validateRegisteredLedger } from "./shared.js";
+export function handleDoctor(parsed, ledgerPath, json) {
+    const report = buildDoctorReport(ledgerPath, normalizeRegistryPath(stringFlag(parsed, "registry")));
+    if (boolFlag(parsed, "agent")) {
+        printCompactJson(buildDoctorAgentPacket(report));
+        return report.ok ? 0 : 1;
+    }
+    if (json) {
+        printJson(report);
+        return report.ok ? 0 : 1;
+    }
+    printDoctor(report);
+    return report.ok ? 0 : 1;
+}
+function buildDoctorReport(ledgerPath, registryPath) {
+    const errors = [];
+    let registryOk = true;
+    let registryError = null;
+    let entries = [];
+    try {
+        entries = listRegisteredLedgers(registryPath);
+    }
+    catch (error) {
+        registryOk = false;
+        registryError = error.message;
+        errors.push(`registry could not be read: ${registryPath} (${registryError})`);
+    }
+    const ledgers = entries.map((entry) => {
+        const result = validateRegisteredLedger(entry);
+        const status = result.ok ? "ok" : existsSync(entry.path) ? "invalid" : "missing";
+        if (!result.ok) {
+            for (const message of result.errors)
+                errors.push(`${entry.name}: ${message}`);
+        }
+        return {
+            name: entry.name,
+            path: entry.path,
+            scope: entry.scope,
+            status,
+            ok: result.ok,
+            entries: result.entries,
+            errors: result.errors,
+            warnings: result.warnings
+        };
+    });
+    const summary = {
+        ledgers: ledgers.length,
+        ok: ledgers.filter((ledger) => ledger.status === "ok").length,
+        stale: ledgers.filter((ledger) => ledger.status === "missing").length,
+        invalid: ledgers.filter((ledger) => ledger.status === "invalid").length,
+        warnings: ledgers.reduce((count, ledger) => count + ledger.warnings.length, 0)
+    };
+    return {
+        ok: registryOk && summary.stale === 0 && summary.invalid === 0,
+        version: VERSION,
+        node: process.version,
+        ledgerPath,
+        ledgerExists: existsSync(ledgerPath),
+        registryPath,
+        registryExists: existsSync(registryPath),
+        registryOk,
+        registryError,
+        ledgers,
+        summary,
+        cleanupSafety: {
+            executeRequiresLedgerAndPlanId: true,
+            globalExecuteRefused: true,
+            deleteRefusedInV1: true,
+            dryRunBeforeMutation: true
+        },
+        errors
+    };
+}

package/dist/src/commands/due.js

@@ -0,0 +1,32 @@
+import { dueEntries, readLedger } from "../ledger.js";
+import { normalizeRegistryPath } from "../registry.js";
+import { printJson } from "../renderers/json.js";
+import { boolFlag, stringFlag } from "../shared/flags.js";
+import { printDueEntries, printRegisteredLedgerValidation, validateRegisteredLedgersOrThrow } from "./shared.js";
+export function handleDue(parsed, ledgerPath, json) {
+    if (boolFlag(parsed, "all")) {
+        const registryPath = normalizeRegistryPath(stringFlag(parsed, "registry"));
+        const validation = validateRegisteredLedgersOrThrow(registryPath);
+        if (!validation.ok)
+            return printRegisteredLedgerValidation(registryPath, validation.results, json);
+        const results = validation.results.map(({ ledger }) => ({ ledger, entries: dueEntries(readLedger(ledger.path)) }));
+        if (json)
+            return printJson({ ok: true, registryPath, ledgers: results });
+        printDueEntries(results);
+        process.stdout.write(`registry: ${registryPath}\n`);
+        return 0;
+    }
+    const entries = dueEntries(readLedger(ledgerPath));
+    const visible = entries.filter((entry) => entry.dueStatus !== "kept");
+    if (json)
+        return printJson({ ok: true, ledgerPath, entries });
+    if (visible.length === 0) {
+        process.stdout.write(`nothing due\nledger: ${ledgerPath}\n`);
+        return 0;
+    }
+    for (const entry of visible) {
+        process.stdout.write(`${entry.dueStatus} ${entry.id} ${entry.cleanup} ${entry.path} :: ${entry.reason}\n`);
+    }
+    process.stdout.write(`ledger: ${ledgerPath}\n`);
+    return 0;
+}

package/dist/src/commands/find.js

@@ -0,0 +1,44 @@
+import { findRecords, readLedger } from "../ledger.js";
+import { normalizeRegistryPath } from "../registry.js";
+import { printJson } from "../renderers/json.js";
+import { arrayFlag, boolFlag, stringFlag } from "../shared/flags.js";
+import { printLedgerEntries, printRegisteredLedgerValidation, validateRegisteredLedgersOrThrow } from "./shared.js";
+export function handleFind(parsed, ledgerPath, json) {
+    if (boolFlag(parsed, "all")) {
+        const registryPath = normalizeRegistryPath(stringFlag(parsed, "registry"));
+        const validation = validateRegisteredLedgersOrThrow(registryPath);
+        if (!validation.ok)
+            return printRegisteredLedgerValidation(registryPath, validation.results, json);
+        const results = validation.results.map(({ ledger }) => ({
+            ledger,
+            entries: findRecords(readLedger(ledger.path), {
+                path: stringFlag(parsed, "path"),
+                owner: stringFlag(parsed, "owner"),
+                labels: arrayFlag(parsed, "label"),
+                status: stringFlag(parsed, "status")
+            })
+        }));
+        if (json)
+            return printJson({ ok: true, registryPath, ledgers: results });
+        printLedgerEntries(results);
+        process.stdout.write(`registry: ${registryPath}\n`);
+        return 0;
+    }
+    const records = findRecords(readLedger(ledgerPath), {
+        path: stringFlag(parsed, "path"),
+        owner: stringFlag(parsed, "owner"),
+        labels: arrayFlag(parsed, "label"),
+        status: stringFlag(parsed, "status")
+    });
+    if (json)
+        return printJson({ ok: true, ledgerPath, entries: records });
+    if (records.length === 0) {
+        process.stdout.write(`no matching artshelf entries\nledger: ${ledgerPath}\n`);
+        return 0;
+    }
+    for (const record of records) {
+        process.stdout.write(`${record.id} ${record.kind} ${record.status} ${record.cleanup} ${record.path} :: ${record.reason}\n`);
+    }
+    process.stdout.write(`ledger: ${ledgerPath}\n`);
+    return 0;
+}

package/dist/src/commands/get.js

@@ -0,0 +1,31 @@
+import { getRecord, readLedger } from "../ledger.js";
+import { normalizeRegistryPath } from "../registry.js";
+import { printJson } from "../renderers/json.js";
+import { boolFlag, stringFlag } from "../shared/flags.js";
+import { printRegisteredLedgerValidation, validateRegisteredLedgersOrThrow } from "./shared.js";
+export function handleGet(parsed, ledgerPath, json) {
+    const id = parsed.positionals[0];
+    if (!id)
+        throw new Error("get requires <id>");
+    if (boolFlag(parsed, "all")) {
+        const registryPath = normalizeRegistryPath(stringFlag(parsed, "registry"));
+        const validation = validateRegisteredLedgersOrThrow(registryPath);
+        if (!validation.ok)
+            return printRegisteredLedgerValidation(registryPath, validation.results, json);
+        for (const { ledger } of validation.results) {
+            const record = readLedger(ledger.path).find((entry) => entry.id === id);
+            if (record) {
+                if (json)
+                    return printJson({ ok: true, registryPath, ledger, record });
+                process.stdout.write(`${record.id} ${record.kind} ${record.status} ${record.cleanup} ${record.path}\nreason: ${record.reason}\nledger: ${ledger.path}\nregistry: ${registryPath}\n`);
+                return 0;
+            }
+        }
+        throw new Error(`Artshelf record not found: ${id}`);
+    }
+    const record = getRecord(readLedger(ledgerPath), id);
+    if (json)
+        return printJson({ ok: true, ledgerPath, record });
+    process.stdout.write(`${record.id} ${record.kind} ${record.status} ${record.cleanup} ${record.path}\nreason: ${record.reason}\nledger: ${ledgerPath}\n`);
+    return 0;
+}

package/dist/src/commands/index.js

@@ -0,0 +1,69 @@
+import { normalizeLedgerPath } from "../ledger.js";
+import { boolFlag, stringFlag } from "../shared/flags.js";
+import { handleCleanup } from "./cleanup.js";
+import { handleDoctor } from "./doctor.js";
+import { handleDue } from "./due.js";
+import { handleFind } from "./find.js";
+import { handleGet } from "./get.js";
+import { handleLedgers } from "./ledgers.js";
+import { handleList } from "./list.js";
+import { handlePut } from "./put.js";
+import { handleResolve } from "./resolve.js";
+import { handleReview } from "./review.js";
+import { handleStatus } from "./status.js";
+import { handleTrash } from "./trash.js";
+import { handleUpdate, maybeNotifyAvailableUpdate } from "./update.js";
+import { handleValidate } from "./validate.js";
+export { maybeNotifyAvailableUpdate };
+export async function runCommand(parsed) {
+    let status = 0;
+    let shouldCheckForUpdate = true;
+    switch (parsed.command) {
+        case "put":
+            status = handlePut(parsed, normalizeLedgerPath(stringFlag(parsed, "ledger")), boolFlag(parsed, "json"));
+            break;
+        case "ledgers":
+            status = handleLedgers(parsed, boolFlag(parsed, "json"));
+            break;
+        case "list":
+            status = handleList(parsed, normalizeLedgerPath(stringFlag(parsed, "ledger")), boolFlag(parsed, "json"));
+            break;
+        case "find":
+            status = handleFind(parsed, normalizeLedgerPath(stringFlag(parsed, "ledger")), boolFlag(parsed, "json"));
+            break;
+        case "get":
+            status = handleGet(parsed, normalizeLedgerPath(stringFlag(parsed, "ledger")), boolFlag(parsed, "json"));
+            break;
+        case "due":
+            status = handleDue(parsed, normalizeLedgerPath(stringFlag(parsed, "ledger")), boolFlag(parsed, "json"));
+            break;
+        case "validate":
+            status = handleValidate(parsed, normalizeLedgerPath(stringFlag(parsed, "ledger")), boolFlag(parsed, "json"));
+            break;
+        case "cleanup":
+            status = handleCleanup(parsed, normalizeLedgerPath(stringFlag(parsed, "ledger")), boolFlag(parsed, "json"));
+            break;
+        case "trash":
+            status = handleTrash(parsed, normalizeLedgerPath(stringFlag(parsed, "ledger")), boolFlag(parsed, "json"));
+            break;
+        case "review":
+            status = handleReview(parsed, normalizeLedgerPath(stringFlag(parsed, "ledger")), boolFlag(parsed, "json"));
+            break;
+        case "doctor":
+            status = handleDoctor(parsed, normalizeLedgerPath(stringFlag(parsed, "ledger")), boolFlag(parsed, "json"));
+            break;
+        case "status":
+            status = handleStatus(parsed, normalizeLedgerPath(stringFlag(parsed, "ledger")), boolFlag(parsed, "json"));
+            break;
+        case "resolve":
+            status = handleResolve(parsed, normalizeLedgerPath(stringFlag(parsed, "ledger")), boolFlag(parsed, "json"));
+            break;
+        case "update":
+            shouldCheckForUpdate = false;
+            status = await handleUpdate(parsed, boolFlag(parsed, "json"));
+            break;
+        default:
+            throw new Error(`Unknown command: ${parsed.command}`);
+    }
+    return { status, shouldCheckForUpdate };
+}

package/dist/src/commands/ledgers.js

@@ -0,0 +1,111 @@
+import { existsSync } from "node:fs";
+import { normalizeLedgerPath } from "../ledger.js";
+import { listRegisteredLedgers, normalizeRegistryPath, registerLedger } from "../registry.js";
+import { printJson } from "../renderers/json.js";
+import { boolFlag, requiredStringFlag, stringFlag } from "../shared/flags.js";
+import { LEDGERS_HELP } from "../shared/help-text.js";
+import { validateRegisteredLedger } from "./shared.js";
+export function handleLedgers(parsed, json) {
+    const action = parsed.positionals[0] ?? "list";
+    const registryPath = normalizeRegistryPath(stringFlag(parsed, "registry"));
+    if (action === "help") {
+        process.stdout.write(LEDGERS_HELP);
+        return 0;
+    }
+    if (action === "add") {
+        const ledgerPath = normalizeLedgerPath(requiredStringFlag(parsed, "ledger"));
+        if (!existsSync(ledgerPath))
+            throw new Error(`Ledger does not exist: ${ledgerPath}`);
+        const entry = registerLedger({
+            ledgerPath,
+            name: stringFlag(parsed, "name"),
+            scope: stringFlag(parsed, "scope"),
+            registryPath
+        });
+        if (json)
+            return printJson({ ok: true, registryPath, ledger: entry });
+        process.stdout.write(`registered ${entry.name}\nledger: ${entry.path}\nregistry: ${registryPath}\n`);
+        return 0;
+    }
+    if (action === "list") {
+        if (boolFlag(parsed, "plain")) {
+            const ledgers = listRegisteredLedgers(registryPath);
+            if (json)
+                return printJson({ ok: true, registryPath, ledgers });
+            if (ledgers.length === 0) {
+                process.stdout.write(`no registered Artshelf ledgers\nregistry: ${registryPath}\n`);
+                return 0;
+            }
+            for (const ledger of ledgers)
+                process.stdout.write(`${ledger.name} ${ledger.scope} ${ledger.path}\n`);
+            process.stdout.write(`registry: ${registryPath}\n`);
+            return 0;
+        }
+        const report = buildLedgersReport(registryPath);
+        if (json) {
+            printJson(report);
+            return report.ok ? 0 : 1;
+        }
+        printLedgersList(report);
+        return report.ok ? 0 : 1;
+    }
+    throw new Error(`Unknown ledgers action: ${action}`);
+}
+function buildLedgersReport(registryPath) {
+    let registryOk = true;
+    let registryError = null;
+    let entries = [];
+    try {
+        entries = listRegisteredLedgers(registryPath);
+    }
+    catch (error) {
+        registryOk = false;
+        registryError = error.message;
+    }
+    const ledgers = entries.map((entry) => {
+        const result = validateRegisteredLedger(entry);
+        const status = result.ok ? "ok" : existsSync(entry.path) ? "invalid" : "missing";
+        return {
+            ...entry,
+            status,
+            ok: result.ok,
+            entries: result.entries,
+            errors: result.errors,
+            warnings: result.warnings
+        };
+    });
+    const summary = {
+        ledgers: ledgers.length,
+        ok: ledgers.filter((ledger) => ledger.status === "ok").length,
+        stale: ledgers.filter((ledger) => ledger.status === "missing").length,
+        invalid: ledgers.filter((ledger) => ledger.status === "invalid").length,
+        warnings: ledgers.reduce((count, ledger) => count + ledger.warnings.length, 0)
+    };
+    return {
+        ok: registryOk && summary.stale === 0 && summary.invalid === 0,
+        registryPath,
+        registryExists: existsSync(registryPath),
+        registryOk,
+        registryError,
+        ledgers,
+        summary
+    };
+}
+function printLedgersList(report) {
+    process.stdout.write(`artshelf ledgers: ${report.ok ? "ok" : "needs attention"}\n`);
+    process.stdout.write(`registry: ${report.registryPath}${report.registryExists ? "" : " (absent)"} — ${report.summary.ledgers} ledgers (${report.summary.ok} ok, ${report.summary.stale} stale, ${report.summary.invalid} invalid)\n`);
+    if (report.registryError)
+        process.stdout.write(`registry error: ${report.registryError}\n`);
+    if (report.ledgers.length === 0) {
+        process.stdout.write("no registered Artshelf ledgers\n");
+        return;
+    }
+    for (const ledger of report.ledgers) {
+        if (ledger.status === "ok") {
+            process.stdout.write(`[${ledger.name}] ok ${ledger.scope}: ${ledger.entries} entries, ${ledger.warnings.length} warnings — ${ledger.path}\n`);
+        }
+        else {
+            process.stdout.write(`[${ledger.name}] ${ledger.status} ${ledger.scope}: ${ledger.errors.join("; ")} — ${ledger.path}\n`);
+        }
+    }
+}

package/dist/src/commands/list.js

@@ -0,0 +1,36 @@
+import { filterRecordsByStatus, readLedger } from "../ledger.js";
+import { normalizeRegistryPath } from "../registry.js";
+import { printJson } from "../renderers/json.js";
+import { boolFlag, stringFlag } from "../shared/flags.js";
+import { printLedgerEntries, printRegisteredLedgerValidation, validateRegisteredLedgersOrThrow } from "./shared.js";
+export function handleList(parsed, ledgerPath, json) {
+    if (boolFlag(parsed, "all")) {
+        const registryPath = normalizeRegistryPath(stringFlag(parsed, "registry"));
+        const status = stringFlag(parsed, "status");
+        const validation = validateRegisteredLedgersOrThrow(registryPath);
+        if (!validation.ok)
+            return printRegisteredLedgerValidation(registryPath, validation.results, json);
+        const results = validation.results.map(({ ledger }) => ({
+            ledger,
+            entries: filterRecordsByStatus(readLedger(ledger.path), status)
+        }));
+        if (json)
+            return printJson({ ok: true, registryPath, ...(status ? { status } : {}), ledgers: results });
+        printLedgerEntries(results, status);
+        process.stdout.write(`registry: ${registryPath}\n`);
+        return 0;
+    }
+    const status = stringFlag(parsed, "status");
+    const records = filterRecordsByStatus(readLedger(ledgerPath), status);
+    if (json)
+        return printJson({ ok: true, ledgerPath, ...(status ? { status } : {}), entries: records });
+    if (records.length === 0) {
+        process.stdout.write(`no artshelf entries${status ? ` with status ${status}` : ""}\nledger: ${ledgerPath}\n`);
+        return 0;
+    }
+    for (const record of records) {
+        process.stdout.write(`${record.id} ${record.kind} ${record.status} ${record.cleanup} ${record.path} :: ${record.reason}\n`);
+    }
+    process.stdout.write(`ledger: ${ledgerPath}\n`);
+    return 0;
+}

package/dist/src/commands/put.js

@@ -0,0 +1,36 @@
+import { appendPreparedRecord, prepareRecord } from "../ledger.js";
+import { normalizeRegistryPath, registerLedger } from "../registry.js";
+import { printJson } from "../renderers/json.js";
+import { arrayFlag, boolFlag, requiredStringFlag, stringFlag } from "../shared/flags.js";
+export function handlePut(parsed, ledgerPath, json) {
+    const path = parsed.positionals[0];
+    if (!path)
+        throw new Error("put requires <path>");
+    const record = prepareRecord({
+        path,
+        reason: requiredStringFlag(parsed, "reason"),
+        ttl: stringFlag(parsed, "ttl"),
+        retainUntil: stringFlag(parsed, "retain-until"),
+        manualReview: boolFlag(parsed, "manual-review"),
+        kind: stringFlag(parsed, "kind"),
+        cleanup: stringFlag(parsed, "cleanup"),
+        owner: stringFlag(parsed, "owner"),
+        labels: arrayFlag(parsed, "label")
+    });
+    const registryPath = normalizeRegistryPath(stringFlag(parsed, "registry"));
+    appendPreparedRecord(ledgerPath, record);
+    let ledger;
+    let registryError;
+    try {
+        ledger = registerLedger({ ledgerPath, registryPath });
+    }
+    catch (error) {
+        registryError = error.message;
+    }
+    if (json)
+        return printJson({ ok: true, record, ledgerPath, registryPath, ...(ledger ? { ledger } : {}), ...(registryError ? { registryError } : {}) });
+    process.stdout.write(`recorded ${record.id}\npath: ${record.path}\nretains until: ${record.retainUntil ?? "manual review"}\nledger: ${ledgerPath}\n`);
+    if (registryError)
+        process.stdout.write(`registry warning: ${registryError}\n`);
+    return 0;
+}

package/dist/src/commands/resolve.js

@@ -0,0 +1,17 @@
+import { resolveRecord } from "../ledger.js";
+import { printJson } from "../renderers/json.js";
+import { requiredStringFlag } from "../shared/flags.js";
+export function handleResolve(parsed, ledgerPath, json) {
+    const id = parsed.positionals[0];
+    if (!id)
+        throw new Error("resolve requires <id>");
+    const record = resolveRecord(ledgerPath, {
+        id,
+        status: requiredStringFlag(parsed, "status"),
+        reason: requiredStringFlag(parsed, "reason")
+    });
+    if (json)
+        return printJson({ ok: true, record, ledgerPath });
+    process.stdout.write(`resolved ${record.id}\nstatus: ${record.status}\nledger: ${ledgerPath}\n`);
+    return 0;
+}

package/dist/src/commands/review.js

@@ -0,0 +1,38 @@
+import { existsSync } from "node:fs";
+import { normalizeRegistryPath } from "../registry.js";
+import { printCompactJson, printJson } from "../renderers/json.js";
+import { buildReviewAgentPacketAll, buildReviewAgentPacketSingle, printReview, printReviewAll, reviewNextAction } from "../renderers/review.js";
+import { boolFlag, stringFlag } from "../shared/flags.js";
+import { registeredLedgersOrThrow, reviewJsonResult, reviewLedger, summarizeReview } from "./shared.js";
+export function handleReview(parsed, ledgerPath, json) {
+    const agent = boolFlag(parsed, "agent");
+    if (boolFlag(parsed, "all")) {
+        const registryPath = normalizeRegistryPath(stringFlag(parsed, "registry"));
+        const results = registeredLedgersOrThrow(registryPath).map((ledger) => reviewLedger(ledger));
+        const ok = results.every((entry) => entry.validate.ok);
+        const summary = summarizeReview(results);
+        if (agent) {
+            printCompactJson(buildReviewAgentPacketAll(results, summary, { path: registryPath, exists: existsSync(registryPath) }));
+            return ok ? 0 : 1;
+        }
+        const nextAction = reviewNextAction(summary, "all");
+        if (json) {
+            printJson({ ok, registryPath, summary, nextAction, ledgers: results.map(reviewJsonResult) });
+            return ok ? 0 : 1;
+        }
+        printReviewAll(results, summary, nextAction, registryPath);
+        return ok ? 0 : 1;
+    }
+    const result = reviewLedger({ name: "current", path: ledgerPath, scope: "other", createdAt: "", updatedAt: "" }, false);
+    const summary = summarizeReview([result]);
+    if (agent) {
+        printCompactJson(buildReviewAgentPacketSingle(result, summary, ledgerPath));
+        return result.validate.ok ? 0 : 1;
+    }
+    if (json) {
+        printJson({ ok: result.validate.ok, ledger: reviewJsonResult(result) });
+        return result.validate.ok ? 0 : 1;
+    }
+    printReview([result]);
+    return result.validate.ok ? 0 : 1;
+}