@crvouga/atlas 1.20.0 → 1.22.0

package/dist/schema/src/cli-results.d.ts

@@ -1,7 +1,7 @@
 /**
  * @module Command results (`--format json`)
  *
- * What `atlas report publish`, `stream`, `merge`, `doctor` and `verify-recordings` print on standard output with `--format json` (alias
+ * What `atlas report publish`, `stream`, `merge`, `doctor` and `verify-recordings`, `atlas ui-catalog plan`, `publish`, `status`, `diff` and `export`, and `atlas critic list`, `setup`, `doctor` and `run`, print on standard output with `--format json` (alias
  * `--json`), and what any `atlas` command prints on standard error for a command that was wrong: one JSON document,
  * so an agent or a script never has to parse prose. (`status` and `policy` already print documents:
  * `ReportStatusSchema`, and an IAM policy.) Each is also published as a JSON Schema.
@@ -289,6 +289,530 @@ export declare const InitPlanSchema: z.ZodObject<{
     nextSteps: z.ZodArray<z.ZodString>;
     warnings: z.ZodArray<z.ZodString>;
 }, z.core.$loose>;
+/** One critic as `atlas critic list` shows it. */
+export declare const CriticListEntrySchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodString;
+    kind: z.ZodNullable<z.ZodString>;
+    version: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        ready: "ready";
+        "needs-setup": "needs-setup";
+        misconfigured: "misconfigured";
+        "not-configured": "not-configured";
+    }>;
+    sendsImagesTo: z.ZodNullable<z.ZodString>;
+    model: z.ZodNullable<z.ZodString>;
+    detail: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+/** What `atlas critic list --format json` prints. */
+export declare const CriticListResultSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    config: z.ZodNullable<z.ZodString>;
+    critics: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        kind: z.ZodNullable<z.ZodString>;
+        version: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            ready: "ready";
+            "needs-setup": "needs-setup";
+            misconfigured: "misconfigured";
+            "not-configured": "not-configured";
+        }>;
+        sendsImagesTo: z.ZodNullable<z.ZodString>;
+        model: z.ZodNullable<z.ZodString>;
+        detail: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+/** What `atlas critic setup --format json` prints. */
+export declare const CriticSetupResultSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    critic: z.ZodString;
+    type: z.ZodString;
+    details: z.ZodArray<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+/** One thing `atlas critic doctor` checked. */
+export declare const CriticDoctorCheckSchema: z.ZodObject<{
+    name: z.ZodString;
+    status: z.ZodEnum<{
+        ok: "ok";
+        problem: "problem";
+        warning: "warning";
+    }>;
+    detail: z.ZodString;
+    fix: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+/** What `atlas critic doctor --format json` prints. */
+export declare const CriticDoctorResultSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    server: z.ZodNullable<z.ZodString>;
+    role: z.ZodNullable<z.ZodString>;
+    open: z.ZodNullable<z.ZodBoolean>;
+    checks: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        status: z.ZodEnum<{
+            ok: "ok";
+            problem: "problem";
+            warning: "warning";
+        }>;
+        detail: z.ZodString;
+        fix: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+/** What `atlas critic run` did for one critic. */
+export declare const CriticRunCriticSchema: z.ZodObject<{
+    critic: z.ZodString;
+    version: z.ZodString;
+    sendsImagesTo: z.ZodNullable<z.ZodString>;
+    entries: z.ZodNumber;
+    judged: z.ZodNumber;
+    skipped: z.ZodNumber;
+    failed: z.ZodNumber;
+    waiting: z.ZodNumber;
+    stoppedBy: z.ZodOptional<z.ZodEnum<{
+        budget: "budget";
+        aborted: "aborted";
+    }>>;
+    failures: z.ZodArray<z.ZodObject<{
+        entry: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$loose>>;
+    spent: z.ZodObject<{
+        images: z.ZodNumber;
+        tokens: z.ZodNumber;
+        costUsd: z.ZodNumber;
+    }, z.core.$loose>;
+    published: z.ZodObject<{
+        layer: z.ZodNullable<z.ZodString>;
+        critiques: z.ZodNumber;
+    }, z.core.$loose>;
+    gate: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
+            report: "report";
+            warn: "warn";
+            gate: "gate";
+        }>;
+        exitCode: z.ZodNumber;
+        below: z.ZodNumber;
+        warnings: z.ZodArray<z.ZodString>;
+        refusal: z.ZodArray<z.ZodString>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+/** What `atlas critic run --format json` prints. A dry run publishes and sends nothing. */
+export declare const CriticRunResultSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    dryRun: z.ZodBoolean;
+    server: z.ZodString;
+    scope: z.ZodRecord<z.ZodString, z.ZodString>;
+    critics: z.ZodArray<z.ZodObject<{
+        critic: z.ZodString;
+        version: z.ZodString;
+        sendsImagesTo: z.ZodNullable<z.ZodString>;
+        entries: z.ZodNumber;
+        judged: z.ZodNumber;
+        skipped: z.ZodNumber;
+        failed: z.ZodNumber;
+        waiting: z.ZodNumber;
+        stoppedBy: z.ZodOptional<z.ZodEnum<{
+            budget: "budget";
+            aborted: "aborted";
+        }>>;
+        failures: z.ZodArray<z.ZodObject<{
+            entry: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$loose>>;
+        spent: z.ZodObject<{
+            images: z.ZodNumber;
+            tokens: z.ZodNumber;
+            costUsd: z.ZodNumber;
+        }, z.core.$loose>;
+        published: z.ZodObject<{
+            layer: z.ZodNullable<z.ZodString>;
+            critiques: z.ZodNumber;
+        }, z.core.$loose>;
+        gate: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodEnum<{
+                report: "report";
+                warn: "warn";
+                gate: "gate";
+            }>;
+            exitCode: z.ZodNumber;
+            below: z.ZodNumber;
+            warnings: z.ZodArray<z.ZodString>;
+            refusal: z.ZodArray<z.ZodString>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>;
+    spool: z.ZodObject<{
+        flushed: z.ZodNumber;
+        spooled: z.ZodNumber;
+        pending: z.ZodNumber;
+    }, z.core.$loose>;
+    warnings: z.ZodArray<z.ZodString>;
+}, z.core.$loose>;
+/** What `atlas critic watch` did for one critic. */
+export declare const CriticWatchCriticSchema: z.ZodObject<{
+    critic: z.ZodString;
+    version: z.ZodString;
+    sendsImagesTo: z.ZodNullable<z.ZodString>;
+    entries: z.ZodNumber;
+    judged: z.ZodNumber;
+    skipped: z.ZodNumber;
+    failed: z.ZodNumber;
+    failures: z.ZodArray<z.ZodObject<{
+        entry: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$loose>>;
+    spent: z.ZodObject<{
+        images: z.ZodNumber;
+        tokens: z.ZodNumber;
+        costUsd: z.ZodNumber;
+    }, z.core.$loose>;
+    published: z.ZodObject<{
+        layers: z.ZodNumber;
+        critiques: z.ZodNumber;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+/** What `atlas critic watch --format json` prints, once, when the watch ends. */
+export declare const CriticWatchResultSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    dryRun: z.ZodBoolean;
+    server: z.ZodString;
+    scope: z.ZodRecord<z.ZodString, z.ZodString>;
+    stoppedBy: z.ZodEnum<{
+        interrupted: "interrupted";
+        budget: "budget";
+        "max-batches": "max-batches";
+        "dry-run": "dry-run";
+    }>;
+    batches: z.ZodNumber;
+    version: z.ZodNullable<z.ZodString>;
+    critics: z.ZodArray<z.ZodObject<{
+        critic: z.ZodString;
+        version: z.ZodString;
+        sendsImagesTo: z.ZodNullable<z.ZodString>;
+        entries: z.ZodNumber;
+        judged: z.ZodNumber;
+        skipped: z.ZodNumber;
+        failed: z.ZodNumber;
+        failures: z.ZodArray<z.ZodObject<{
+            entry: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$loose>>;
+        spent: z.ZodObject<{
+            images: z.ZodNumber;
+            tokens: z.ZodNumber;
+            costUsd: z.ZodNumber;
+        }, z.core.$loose>;
+        published: z.ZodObject<{
+            layers: z.ZodNumber;
+            critiques: z.ZodNumber;
+        }, z.core.$loose>;
+    }, z.core.$loose>>;
+    spool: z.ZodObject<{
+        flushed: z.ZodNumber;
+        spooled: z.ZodNumber;
+        pending: z.ZodNumber;
+    }, z.core.$loose>;
+    warnings: z.ZodArray<z.ZodString>;
+}, z.core.$loose>;
+/** What reviewers decided about one opinion, as `atlas critic review` reports it. */
+export declare const CriticMarkStandingSchema: z.ZodObject<{
+    state: z.ZodEnum<{
+        accepted: "accepted";
+        dismissed: "dismissed";
+        disputed: "disputed";
+        unmarked: "unmarked";
+    }>;
+    accepted: z.ZodArray<z.ZodString>;
+    dismissed: z.ZodArray<z.ZodString>;
+    earlier: z.ZodNumber;
+    notes: z.ZodArray<z.ZodString>;
+}, z.core.$loose>;
+/** What `atlas critic review --format json` prints. */
+export declare const CriticReviewResultSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    server: z.ZodString;
+    critic: z.ZodNullable<z.ZodString>;
+    critics: z.ZodArray<z.ZodString>;
+    reviewer: z.ZodString;
+    rankedBy: z.ZodEnum<{
+        score: "score";
+        "standing-within-kind": "standing-within-kind";
+    }>;
+    summary: z.ZodObject<{
+        ranked: z.ZodNumber;
+        unranked: z.ZodNumber;
+        unjudged: z.ZodNumber;
+    }, z.core.$loose>;
+    entries: z.ZodArray<z.ZodObject<{
+        rank: z.ZodNullable<z.ZodNumber>;
+        key: z.ZodString;
+        title: z.ZodString;
+        state: z.ZodString;
+        imageSha256: z.ZodString;
+        score: z.ZodNullable<z.ZodNumber>;
+        percentile: z.ZodNullable<z.ZodNumber>;
+        label: z.ZodNullable<z.ZodString>;
+        currency: z.ZodEnum<{
+            current: "current";
+            "earlier-image": "earlier-image";
+        }>;
+        failure: z.ZodOptional<z.ZodString>;
+        marks: z.ZodObject<{
+            state: z.ZodEnum<{
+                accepted: "accepted";
+                dismissed: "dismissed";
+                disputed: "disputed";
+                unmarked: "unmarked";
+            }>;
+            accepted: z.ZodArray<z.ZodString>;
+            dismissed: z.ZodArray<z.ZodString>;
+            earlier: z.ZodNumber;
+            notes: z.ZodArray<z.ZodString>;
+        }, z.core.$loose>;
+        findings: z.ZodArray<z.ZodObject<{
+            id: z.ZodNullable<z.ZodString>;
+            category: z.ZodNullable<z.ZodString>;
+            severity: z.ZodNullable<z.ZodString>;
+            region: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodString;
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                w: z.ZodNumber;
+                h: z.ZodNumber;
+            }, z.core.$loose>>;
+            rationale: z.ZodNullable<z.ZodString>;
+            suggestion: z.ZodNullable<z.ZodString>;
+            marks: z.ZodNullable<z.ZodObject<{
+                state: z.ZodEnum<{
+                    accepted: "accepted";
+                    dismissed: "dismissed";
+                    disputed: "disputed";
+                    unmarked: "unmarked";
+                }>;
+                accepted: z.ZodArray<z.ZodString>;
+                dismissed: z.ZodArray<z.ZodString>;
+                earlier: z.ZodNumber;
+                notes: z.ZodArray<z.ZodString>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>;
+    marked: z.ZodOptional<z.ZodObject<{
+        dryRun: z.ZodBoolean;
+        reviewer: z.ZodString;
+        layer: z.ZodNullable<z.ZodString>;
+        marks: z.ZodArray<z.ZodObject<{
+            entry: z.ZodString;
+            critic: z.ZodString;
+            finding: z.ZodNullable<z.ZodString>;
+            decision: z.ZodEnum<{
+                accept: "accept";
+                dismiss: "dismiss";
+            }>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+/** What `atlas critic calibrate --format json` prints. A dry run measures nothing and writes nothing. */
+export declare const CriticCalibrateResultSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    dryRun: z.ZodBoolean;
+    critic: z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodNullable<z.ZodString>;
+    }, z.core.$loose>;
+    sendsImagesTo: z.ZodNullable<z.ZodString>;
+    examples: z.ZodObject<{
+        files: z.ZodNumber;
+        marks: z.ZodNumber;
+        used: z.ZodNumber;
+        skipped: z.ZodArray<z.ZodObject<{
+            source: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$loose>>;
+    }, z.core.$loose>;
+    calibration: z.ZodNullable<z.ZodObject<{
+        schema: z.ZodLiteral<1>;
+        critic: z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodString;
+            model: z.ZodOptional<z.ZodObject<{
+                id: z.ZodString;
+                provider: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>>;
+            parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$loose>;
+        createdAtMs: z.ZodOptional<z.ZodNumber>;
+        kinds: z.ZodArray<z.ZodObject<{
+            stateKind: z.ZodString;
+            threshold: z.ZodNullable<z.ZodNumber>;
+            samples: z.ZodNumber;
+            positives: z.ZodNumber;
+            negatives: z.ZodNumber;
+            precision: z.ZodNullable<z.ZodNumber>;
+            recall: z.ZodNullable<z.ZodNumber>;
+            inSample: z.ZodBoolean;
+            evaluatedOn: z.ZodEnum<{
+                fit: "fit";
+                "held-out": "held-out";
+            }>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>;
+    written: z.ZodNullable<z.ZodString>;
+    gate: z.ZodNullable<z.ZodObject<{
+        eligible: z.ZodBoolean;
+        reasons: z.ZodArray<z.ZodString>;
+    }, z.core.$loose>>;
+    warnings: z.ZodArray<z.ZodString>;
+}, z.core.$loose>;
+/** What `atlas ui-catalog plan --format json` and `atlas ui-catalog publish --format json` print: the one layer that was written. */
+export declare const UiCatalogPublishResultSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    store: z.ZodString;
+    layer: z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            "ui-state": "ui-state";
+            "ui-plan": "ui-plan";
+        }>;
+        producer: z.ZodString;
+        environment: z.ZodNullable<z.ZodString>;
+        parameters: z.ZodRecord<z.ZodString, z.ZodString>;
+        states: z.ZodNumber;
+        captured: z.ZodNumber;
+        failed: z.ZodNumber;
+        pictures: z.ZodNumber;
+        pictureBytes: z.ZodNumber;
+        shard: z.ZodNullable<z.ZodString>;
+    }, z.core.$loose>;
+    warnings: z.ZodArray<z.ZodString>;
+}, z.core.$loose>;
+/** One thing that keeps a UI catalog from being complete and good. */
+export declare const UiCatalogProblemSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        failed: "failed";
+        missing: "missing";
+        unavailable: "unavailable";
+        capturing: "capturing";
+        unreadable: "unreadable";
+        empty: "empty";
+    }>;
+    state: z.ZodOptional<z.ZodString>;
+    profile: z.ZodOptional<z.ZodString>;
+    detail: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+/** What `atlas ui-catalog status --format json` prints. */
+export declare const UiCatalogStatusSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    summary: z.ZodObject<{
+        states: z.ZodNumber;
+        profiles: z.ZodNumber;
+        cells: z.ZodNumber;
+        coverage: z.ZodRecord<z.ZodEnum<{
+            failed: "failed";
+            skipped: "skipped";
+            missing: "missing";
+            captured: "captured";
+            capturing: "capturing";
+        }>, z.ZodNumber>;
+        undeclared: z.ZodNumber;
+        planned: z.ZodBoolean;
+        surfaces: z.ZodNumber;
+        uncoveredSurfaces: z.ZodNumber;
+    }, z.core.$loose>;
+    profiles: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+    }, z.core.$loose>>;
+    problems: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            failed: "failed";
+            missing: "missing";
+            unavailable: "unavailable";
+            capturing: "capturing";
+            unreadable: "unreadable";
+            empty: "empty";
+        }>;
+        state: z.ZodOptional<z.ZodString>;
+        profile: z.ZodOptional<z.ZodString>;
+        detail: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    sources: z.ZodObject<{
+        layers: z.ZodNumber;
+        backends: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            available: z.ZodBoolean;
+        }, z.core.$loose>>;
+        notices: z.ZodArray<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+/** What `atlas ui-catalog diff --format json` prints. */
+export declare const UiCatalogDiffResultSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    from: z.ZodObject<{
+        sha: z.ZodString;
+        states: z.ZodNumber;
+        layers: z.ZodNumber;
+    }, z.core.$loose>;
+    to: z.ZodObject<{
+        sha: z.ZodString;
+        states: z.ZodNumber;
+        layers: z.ZodNumber;
+    }, z.core.$loose>;
+    summary: z.ZodObject<{
+        coverage: z.ZodNumber;
+        picture: z.ZodNumber;
+        unverified: z.ZodNumber;
+        added: z.ZodNumber;
+        removed: z.ZodNumber;
+        unchanged: z.ZodNumber;
+        total: z.ZodNumber;
+    }, z.core.$loose>;
+    changes: z.ZodArray<z.ZodObject<{
+        state: z.ZodString;
+        title: z.ZodString;
+        profile: z.ZodString;
+        change: z.ZodEnum<{
+            coverage: "coverage";
+            removed: "removed";
+            unverified: "unverified";
+            added: "added";
+            picture: "picture";
+        }>;
+        from: z.ZodNullable<z.ZodEnum<{
+            failed: "failed";
+            skipped: "skipped";
+            missing: "missing";
+            captured: "captured";
+            capturing: "capturing";
+        }>>;
+        to: z.ZodNullable<z.ZodEnum<{
+            failed: "failed";
+            skipped: "skipped";
+            missing: "missing";
+            captured: "captured";
+            capturing: "capturing";
+        }>>;
+    }, z.core.$loose>>;
+    notices: z.ZodArray<z.ZodString>;
+}, z.core.$loose>;
+/** What `atlas ui-catalog export --format json` prints. */
+export declare const UiCatalogExportResultSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    out: z.ZodString;
+    bytes: z.ZodNumber;
+    states: z.ZodNumber;
+    cells: z.ZodNumber;
+    pictures: z.ZodObject<{
+        embedded: z.ZodNumber;
+        embeddedBytes: z.ZodNumber;
+        left: z.ZodNumber;
+    }, z.core.$loose>;
+    manifest: z.ZodNullable<z.ZodString>;
+    warnings: z.ZodArray<z.ZodString>;
+}, z.core.$loose>;
 /**
  * JSON command contracts, shared by schema publication, agent documentation and executable command checks.
  * A new result needs an entry here and a runtime scenario in the documentation contract tests.
@@ -582,6 +1106,472 @@ export declare const CLI_RESULTS: {
             notices: z.ZodArray<z.ZodString>;
         }, z.core.$loose>;
     };
+    readonly criticList: {
+        readonly command: "atlas critic list";
+        readonly schemaName: "critic-list-result";
+        readonly schema: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+            config: z.ZodNullable<z.ZodString>;
+            critics: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodString;
+                kind: z.ZodNullable<z.ZodString>;
+                version: z.ZodNullable<z.ZodString>;
+                status: z.ZodEnum<{
+                    ready: "ready";
+                    "needs-setup": "needs-setup";
+                    misconfigured: "misconfigured";
+                    "not-configured": "not-configured";
+                }>;
+                sendsImagesTo: z.ZodNullable<z.ZodString>;
+                model: z.ZodNullable<z.ZodString>;
+                detail: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>;
+    };
+    readonly criticSetup: {
+        readonly command: "atlas critic setup";
+        readonly schemaName: "critic-setup-result";
+        readonly schema: z.ZodObject<{
+            ok: z.ZodBoolean;
+            critic: z.ZodString;
+            type: z.ZodString;
+            details: z.ZodArray<z.ZodString>;
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>;
+    };
+    readonly criticDoctor: {
+        readonly command: "atlas critic doctor";
+        readonly schemaName: "critic-doctor-result";
+        readonly schema: z.ZodObject<{
+            ok: z.ZodBoolean;
+            server: z.ZodNullable<z.ZodString>;
+            role: z.ZodNullable<z.ZodString>;
+            open: z.ZodNullable<z.ZodBoolean>;
+            checks: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                status: z.ZodEnum<{
+                    ok: "ok";
+                    problem: "problem";
+                    warning: "warning";
+                }>;
+                detail: z.ZodString;
+                fix: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>;
+    };
+    readonly criticRun: {
+        readonly command: "atlas critic run";
+        readonly schemaName: "critic-run-result";
+        readonly schema: z.ZodObject<{
+            ok: z.ZodBoolean;
+            dryRun: z.ZodBoolean;
+            server: z.ZodString;
+            scope: z.ZodRecord<z.ZodString, z.ZodString>;
+            critics: z.ZodArray<z.ZodObject<{
+                critic: z.ZodString;
+                version: z.ZodString;
+                sendsImagesTo: z.ZodNullable<z.ZodString>;
+                entries: z.ZodNumber;
+                judged: z.ZodNumber;
+                skipped: z.ZodNumber;
+                failed: z.ZodNumber;
+                waiting: z.ZodNumber;
+                stoppedBy: z.ZodOptional<z.ZodEnum<{
+                    budget: "budget";
+                    aborted: "aborted";
+                }>>;
+                failures: z.ZodArray<z.ZodObject<{
+                    entry: z.ZodString;
+                    reason: z.ZodString;
+                }, z.core.$loose>>;
+                spent: z.ZodObject<{
+                    images: z.ZodNumber;
+                    tokens: z.ZodNumber;
+                    costUsd: z.ZodNumber;
+                }, z.core.$loose>;
+                published: z.ZodObject<{
+                    layer: z.ZodNullable<z.ZodString>;
+                    critiques: z.ZodNumber;
+                }, z.core.$loose>;
+                gate: z.ZodOptional<z.ZodObject<{
+                    mode: z.ZodEnum<{
+                        report: "report";
+                        warn: "warn";
+                        gate: "gate";
+                    }>;
+                    exitCode: z.ZodNumber;
+                    below: z.ZodNumber;
+                    warnings: z.ZodArray<z.ZodString>;
+                    refusal: z.ZodArray<z.ZodString>;
+                }, z.core.$loose>>;
+            }, z.core.$loose>>;
+            spool: z.ZodObject<{
+                flushed: z.ZodNumber;
+                spooled: z.ZodNumber;
+                pending: z.ZodNumber;
+            }, z.core.$loose>;
+            warnings: z.ZodArray<z.ZodString>;
+        }, z.core.$loose>;
+    };
+    readonly criticWatch: {
+        readonly command: "atlas critic watch";
+        readonly schemaName: "critic-watch-result";
+        readonly schema: z.ZodObject<{
+            ok: z.ZodBoolean;
+            dryRun: z.ZodBoolean;
+            server: z.ZodString;
+            scope: z.ZodRecord<z.ZodString, z.ZodString>;
+            stoppedBy: z.ZodEnum<{
+                interrupted: "interrupted";
+                budget: "budget";
+                "max-batches": "max-batches";
+                "dry-run": "dry-run";
+            }>;
+            batches: z.ZodNumber;
+            version: z.ZodNullable<z.ZodString>;
+            critics: z.ZodArray<z.ZodObject<{
+                critic: z.ZodString;
+                version: z.ZodString;
+                sendsImagesTo: z.ZodNullable<z.ZodString>;
+                entries: z.ZodNumber;
+                judged: z.ZodNumber;
+                skipped: z.ZodNumber;
+                failed: z.ZodNumber;
+                failures: z.ZodArray<z.ZodObject<{
+                    entry: z.ZodString;
+                    reason: z.ZodString;
+                }, z.core.$loose>>;
+                spent: z.ZodObject<{
+                    images: z.ZodNumber;
+                    tokens: z.ZodNumber;
+                    costUsd: z.ZodNumber;
+                }, z.core.$loose>;
+                published: z.ZodObject<{
+                    layers: z.ZodNumber;
+                    critiques: z.ZodNumber;
+                }, z.core.$loose>;
+            }, z.core.$loose>>;
+            spool: z.ZodObject<{
+                flushed: z.ZodNumber;
+                spooled: z.ZodNumber;
+                pending: z.ZodNumber;
+            }, z.core.$loose>;
+            warnings: z.ZodArray<z.ZodString>;
+        }, z.core.$loose>;
+    };
+    readonly criticReview: {
+        readonly command: "atlas critic review";
+        readonly schemaName: "critic-review-result";
+        readonly schema: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+            server: z.ZodString;
+            critic: z.ZodNullable<z.ZodString>;
+            critics: z.ZodArray<z.ZodString>;
+            reviewer: z.ZodString;
+            rankedBy: z.ZodEnum<{
+                score: "score";
+                "standing-within-kind": "standing-within-kind";
+            }>;
+            summary: z.ZodObject<{
+                ranked: z.ZodNumber;
+                unranked: z.ZodNumber;
+                unjudged: z.ZodNumber;
+            }, z.core.$loose>;
+            entries: z.ZodArray<z.ZodObject<{
+                rank: z.ZodNullable<z.ZodNumber>;
+                key: z.ZodString;
+                title: z.ZodString;
+                state: z.ZodString;
+                imageSha256: z.ZodString;
+                score: z.ZodNullable<z.ZodNumber>;
+                percentile: z.ZodNullable<z.ZodNumber>;
+                label: z.ZodNullable<z.ZodString>;
+                currency: z.ZodEnum<{
+                    current: "current";
+                    "earlier-image": "earlier-image";
+                }>;
+                failure: z.ZodOptional<z.ZodString>;
+                marks: z.ZodObject<{
+                    state: z.ZodEnum<{
+                        accepted: "accepted";
+                        dismissed: "dismissed";
+                        disputed: "disputed";
+                        unmarked: "unmarked";
+                    }>;
+                    accepted: z.ZodArray<z.ZodString>;
+                    dismissed: z.ZodArray<z.ZodString>;
+                    earlier: z.ZodNumber;
+                    notes: z.ZodArray<z.ZodString>;
+                }, z.core.$loose>;
+                findings: z.ZodArray<z.ZodObject<{
+                    id: z.ZodNullable<z.ZodString>;
+                    category: z.ZodNullable<z.ZodString>;
+                    severity: z.ZodNullable<z.ZodString>;
+                    region: z.ZodOptional<z.ZodObject<{
+                        unit: z.ZodString;
+                        x: z.ZodNumber;
+                        y: z.ZodNumber;
+                        w: z.ZodNumber;
+                        h: z.ZodNumber;
+                    }, z.core.$loose>>;
+                    rationale: z.ZodNullable<z.ZodString>;
+                    suggestion: z.ZodNullable<z.ZodString>;
+                    marks: z.ZodNullable<z.ZodObject<{
+                        state: z.ZodEnum<{
+                            accepted: "accepted";
+                            dismissed: "dismissed";
+                            disputed: "disputed";
+                            unmarked: "unmarked";
+                        }>;
+                        accepted: z.ZodArray<z.ZodString>;
+                        dismissed: z.ZodArray<z.ZodString>;
+                        earlier: z.ZodNumber;
+                        notes: z.ZodArray<z.ZodString>;
+                    }, z.core.$loose>>;
+                }, z.core.$loose>>;
+            }, z.core.$loose>>;
+            marked: z.ZodOptional<z.ZodObject<{
+                dryRun: z.ZodBoolean;
+                reviewer: z.ZodString;
+                layer: z.ZodNullable<z.ZodString>;
+                marks: z.ZodArray<z.ZodObject<{
+                    entry: z.ZodString;
+                    critic: z.ZodString;
+                    finding: z.ZodNullable<z.ZodString>;
+                    decision: z.ZodEnum<{
+                        accept: "accept";
+                        dismiss: "dismiss";
+                    }>;
+                }, z.core.$loose>>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>;
+    };
+    readonly criticCalibrate: {
+        readonly command: "atlas critic calibrate";
+        readonly schemaName: "critic-calibrate-result";
+        readonly schema: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+            dryRun: z.ZodBoolean;
+            critic: z.ZodObject<{
+                name: z.ZodString;
+                version: z.ZodNullable<z.ZodString>;
+            }, z.core.$loose>;
+            sendsImagesTo: z.ZodNullable<z.ZodString>;
+            examples: z.ZodObject<{
+                files: z.ZodNumber;
+                marks: z.ZodNumber;
+                used: z.ZodNumber;
+                skipped: z.ZodArray<z.ZodObject<{
+                    source: z.ZodString;
+                    reason: z.ZodString;
+                }, z.core.$loose>>;
+            }, z.core.$loose>;
+            calibration: z.ZodNullable<z.ZodObject<{
+                schema: z.ZodLiteral<1>;
+                critic: z.ZodObject<{
+                    name: z.ZodString;
+                    version: z.ZodString;
+                    model: z.ZodOptional<z.ZodObject<{
+                        id: z.ZodString;
+                        provider: z.ZodOptional<z.ZodString>;
+                    }, z.core.$loose>>;
+                    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.core.$loose>;
+                createdAtMs: z.ZodOptional<z.ZodNumber>;
+                kinds: z.ZodArray<z.ZodObject<{
+                    stateKind: z.ZodString;
+                    threshold: z.ZodNullable<z.ZodNumber>;
+                    samples: z.ZodNumber;
+                    positives: z.ZodNumber;
+                    negatives: z.ZodNumber;
+                    precision: z.ZodNullable<z.ZodNumber>;
+                    recall: z.ZodNullable<z.ZodNumber>;
+                    inSample: z.ZodBoolean;
+                    evaluatedOn: z.ZodEnum<{
+                        fit: "fit";
+                        "held-out": "held-out";
+                    }>;
+                }, z.core.$loose>>;
+            }, z.core.$loose>>;
+            written: z.ZodNullable<z.ZodString>;
+            gate: z.ZodNullable<z.ZodObject<{
+                eligible: z.ZodBoolean;
+                reasons: z.ZodArray<z.ZodString>;
+            }, z.core.$loose>>;
+            warnings: z.ZodArray<z.ZodString>;
+        }, z.core.$loose>;
+    };
+    readonly uiCatalogPlan: {
+        readonly command: "atlas ui-catalog plan";
+        readonly schemaName: "ui-catalog-publish-result";
+        readonly schema: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+            store: z.ZodString;
+            layer: z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodEnum<{
+                    "ui-state": "ui-state";
+                    "ui-plan": "ui-plan";
+                }>;
+                producer: z.ZodString;
+                environment: z.ZodNullable<z.ZodString>;
+                parameters: z.ZodRecord<z.ZodString, z.ZodString>;
+                states: z.ZodNumber;
+                captured: z.ZodNumber;
+                failed: z.ZodNumber;
+                pictures: z.ZodNumber;
+                pictureBytes: z.ZodNumber;
+                shard: z.ZodNullable<z.ZodString>;
+            }, z.core.$loose>;
+            warnings: z.ZodArray<z.ZodString>;
+        }, z.core.$loose>;
+    };
+    readonly uiCatalogPublish: {
+        readonly command: "atlas ui-catalog publish";
+        readonly schemaName: "ui-catalog-publish-result";
+        readonly schema: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+            store: z.ZodString;
+            layer: z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodEnum<{
+                    "ui-state": "ui-state";
+                    "ui-plan": "ui-plan";
+                }>;
+                producer: z.ZodString;
+                environment: z.ZodNullable<z.ZodString>;
+                parameters: z.ZodRecord<z.ZodString, z.ZodString>;
+                states: z.ZodNumber;
+                captured: z.ZodNumber;
+                failed: z.ZodNumber;
+                pictures: z.ZodNumber;
+                pictureBytes: z.ZodNumber;
+                shard: z.ZodNullable<z.ZodString>;
+            }, z.core.$loose>;
+            warnings: z.ZodArray<z.ZodString>;
+        }, z.core.$loose>;
+    };
+    readonly uiCatalogStatus: {
+        readonly command: "atlas ui-catalog status";
+        readonly schemaName: "ui-catalog-status";
+        readonly schema: z.ZodObject<{
+            ok: z.ZodBoolean;
+            summary: z.ZodObject<{
+                states: z.ZodNumber;
+                profiles: z.ZodNumber;
+                cells: z.ZodNumber;
+                coverage: z.ZodRecord<z.ZodEnum<{
+                    failed: "failed";
+                    skipped: "skipped";
+                    missing: "missing";
+                    captured: "captured";
+                    capturing: "capturing";
+                }>, z.ZodNumber>;
+                undeclared: z.ZodNumber;
+                planned: z.ZodBoolean;
+                surfaces: z.ZodNumber;
+                uncoveredSurfaces: z.ZodNumber;
+            }, z.core.$loose>;
+            profiles: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$loose>>;
+            problems: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    failed: "failed";
+                    missing: "missing";
+                    unavailable: "unavailable";
+                    capturing: "capturing";
+                    unreadable: "unreadable";
+                    empty: "empty";
+                }>;
+                state: z.ZodOptional<z.ZodString>;
+                profile: z.ZodOptional<z.ZodString>;
+                detail: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>>;
+            sources: z.ZodObject<{
+                layers: z.ZodNumber;
+                backends: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    available: z.ZodBoolean;
+                }, z.core.$loose>>;
+                notices: z.ZodArray<z.ZodString>;
+            }, z.core.$loose>;
+        }, z.core.$loose>;
+    };
+    readonly uiCatalogDiff: {
+        readonly command: "atlas ui-catalog diff";
+        readonly schemaName: "ui-catalog-diff-result";
+        readonly schema: z.ZodObject<{
+            ok: z.ZodBoolean;
+            from: z.ZodObject<{
+                sha: z.ZodString;
+                states: z.ZodNumber;
+                layers: z.ZodNumber;
+            }, z.core.$loose>;
+            to: z.ZodObject<{
+                sha: z.ZodString;
+                states: z.ZodNumber;
+                layers: z.ZodNumber;
+            }, z.core.$loose>;
+            summary: z.ZodObject<{
+                coverage: z.ZodNumber;
+                picture: z.ZodNumber;
+                unverified: z.ZodNumber;
+                added: z.ZodNumber;
+                removed: z.ZodNumber;
+                unchanged: z.ZodNumber;
+                total: z.ZodNumber;
+            }, z.core.$loose>;
+            changes: z.ZodArray<z.ZodObject<{
+                state: z.ZodString;
+                title: z.ZodString;
+                profile: z.ZodString;
+                change: z.ZodEnum<{
+                    coverage: "coverage";
+                    removed: "removed";
+                    unverified: "unverified";
+                    added: "added";
+                    picture: "picture";
+                }>;
+                from: z.ZodNullable<z.ZodEnum<{
+                    failed: "failed";
+                    skipped: "skipped";
+                    missing: "missing";
+                    captured: "captured";
+                    capturing: "capturing";
+                }>>;
+                to: z.ZodNullable<z.ZodEnum<{
+                    failed: "failed";
+                    skipped: "skipped";
+                    missing: "missing";
+                    captured: "captured";
+                    capturing: "capturing";
+                }>>;
+            }, z.core.$loose>>;
+            notices: z.ZodArray<z.ZodString>;
+        }, z.core.$loose>;
+    };
+    readonly uiCatalogExport: {
+        readonly command: "atlas ui-catalog export";
+        readonly schemaName: "ui-catalog-export-result";
+        readonly schema: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+            out: z.ZodString;
+            bytes: z.ZodNumber;
+            states: z.ZodNumber;
+            cells: z.ZodNumber;
+            pictures: z.ZodObject<{
+                embedded: z.ZodNumber;
+                embeddedBytes: z.ZodNumber;
+                left: z.ZodNumber;
+            }, z.core.$loose>;
+            manifest: z.ZodNullable<z.ZodString>;
+            warnings: z.ZodArray<z.ZodString>;
+        }, z.core.$loose>;
+    };
     readonly error: {
         readonly command: "a command that was wrong (standard error)";
         readonly schemaName: "command-error";