@vibe-agent-toolkit/cli 0.2.0-rc.11 → 0.2.0-rc.12

package/dist/commands/orchestrator-schema.js

@@ -0,0 +1,91 @@
+/**
+ * The document `vat build`, `vat validate` and `vat verify` publish, apart from
+ * the commands.
+ *
+ * A sibling module because the published-shape registry imports it and the
+ * commands import the writer that imports the registry: a schema declared in a
+ * command module itself would be an import cycle, read before it is initialised.
+ *
+ * 🔑 **One envelope over every phase.** `findings` is every phase's findings,
+ * flat and with their `location` unchanged; `examined` is the sum of the
+ * phases' own `examined`; `data.phases` carries each phase's status, count,
+ * summary and its own `data` — which that phase's registered schema describes,
+ * so this schema holds it as `unknown` rather than keeping a second copy of
+ * five shapes. `runPhase` holds each phase's report to that schema before the
+ * fold. A phase that did not finish carries its own `error`, and the
+ * orchestrator's envelope is then `error` / `RUN_INCOMPLETE` over the phases
+ * that did.
+ *
+ * `vat verify`'s `packaged-content` phase is no verb of its own, so its report
+ * schema — the published contract for its `data` — is declared here.
+ */
+import { FindingSchema, RefusalCodeSchema, ReportStatusSchema, reportSchema, SeverityCountsSchema, } from '@vibe-agent-toolkit/schema';
+import { z } from 'zod';
+/**
+ * What `examined` counts for an orchestrator, and the remedy when it is zero.
+ *
+ * The sum of the phases' own denominators — files, skills, bundles, plugins —
+ * so the unit is "whatever each phase examined". This judges the run in which
+ * no phase ran, or none had anything to examine. A CONFIGURED phase that
+ * examined nothing is refused before the fold, by its own declaration
+ * (`phaseVerdict` in `phase-utils.ts`), so a healthy phase beside it hides nothing.
+ */
+export const ORCHESTRATOR_EXAMINED = {
+    unit: 'items across every phase',
+    whenZero: 'No phase examined anything, so the run is not a verdict: vibe-agent-toolkit.config.yaml'
+        + ' declares no surface this command runs (`vat build` runs `skills:` and `claude.marketplaces:`;'
+        + ' `vat validate` runs `resources:` (and, with it, the project\'s checks) and `skills:`;'
+        + ' `vat verify` runs `resources:` (without the checks), `skills:` and `claude.marketplaces:`), or every'
+        + ' configured surface matched nothing — usually a typo in a glob or a config key. Each phase'
+        + ' entry under `data.phases` shows what it examined.',
+};
+/** One phase of the run, as the orchestrator folds it. */
+const PhaseEntrySchema = z.object({
+    /** The phase's name, e.g. `skills`, `marketplace:<name>`, `packaged-content`. */
+    name: z.string(),
+    /** The phase's own envelope status. */
+    status: ReportStatusSchema,
+    /** What the phase examined, in its own unit. */
+    examined: z.number().int().nonnegative(),
+    /** The phase's findings, by severity — the findings themselves are on the envelope. */
+    summary: SeverityCountsSchema,
+    /** Why the phase did not finish, when it did not. */
+    error: z.object({ code: RefusalCodeSchema, message: z.string() }).strict().optional(),
+    /** The phase's own `data`, as its own registered schema describes it. */
+    data: z.unknown(),
+}).strict();
+const OrchestratorDataSchema = z.object({
+    /** Every phase that ran, finished or not, in execution order. */
+    phases: z.array(PhaseEntrySchema),
+}).strict();
+/** The document the three orchestrators publish. */
+export const ORCHESTRATOR_REPORT_SCHEMA = reportSchema(OrchestratorDataSchema, FindingSchema);
+/**
+ * `vat verify`'s `packaged-content` phase `data`: what the crawl should have
+ * found. What it DID crawl is the phase's own `examined` (the built bundles on
+ * disk), so it is not repeated here.
+ */
+const PackagedContentDataSchema = z.object({
+    /** Bundles `vat build` produces for the skills this run discovered. */
+    bundlesExpected: z.number().int().nonnegative(),
+    /** Discovered skills that are in place (`publish: false`, not plugin-local): no bundle is expected. */
+    bundlesInPlace: z.number().int().nonnegative(),
+    /** Expected bundles absent from `dist/`, project-relative. Non-empty means the phase is not a verdict. */
+    bundlesMissing: z.array(z.string()),
+}).strict();
+/**
+ * What `examined` counts for `vat verify`'s `packaged-content` phase, and the remedy when it is
+ * zero. `vat verify` exists to check the BUILT tree: a phase that crawled none of it is not a
+ * verdict on it.
+ */
+export const PACKAGED_CONTENT_EXAMINED = {
+    unit: 'built skill bundles',
+    whenZero: 'The packaged-content phase is not a verdict: nothing was crawled for files that must not'
+        + ' ship, and the document reads the same as a run over clean bundles. Either `vat build` has not'
+        + ' run (or wrote somewhere other than dist/), or `skills.include` in vibe-agent-toolkit.config.yaml'
+        + ' matched no SKILL.md — usually a typo in the glob. Run `vat build` first; `vat skills validate`'
+        + ' lists what the globs discover.',
+};
+/** The report `vat verify`'s `packaged-content` phase hands back. */
+export const PACKAGED_CONTENT_REPORT_SCHEMA = reportSchema(PackagedContentDataSchema, FindingSchema);
+//# sourceMappingURL=orchestrator-schema.js.map

package/dist/commands/orchestrator-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator-schema.js","sourceRoot":"","sources":["../../src/commands/orchestrator-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,kBAAkB,EAClB,YAAY,EACZ,oBAAoB,GACrB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAwB;IACxD,IAAI,EAAE,0BAA0B;IAChC,QAAQ,EAAE,yFAAyF;UAC/F,gGAAgG;UAChG,wFAAwF;UACxF,uGAAuG;UACvG,4FAA4F;UAC5F,oDAAoD;CACzD,CAAC;AAEF,0DAA0D;AAC1D,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC;IAChC,iFAAiF;IACjF,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,uCAAuC;IACvC,MAAM,EAAE,kBAAkB;IAC1B,gDAAgD;IAChD,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;IACxC,uFAAuF;IACvF,OAAO,EAAE,oBAAoB;IAC7B,qDAAqD;IACrD,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,iBAAiB,EAAE,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACrF,yEAAyE;IACzE,IAAI,EAAE,CAAC,CAAC,OAAO,EAAE;CAClB,CAAC,CAAC,MAAM,EAAE,CAAC;AAEZ,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC;IACtC,iEAAiE;IACjE,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,gBAAgB,CAAC;CAClC,CAAC,CAAC,MAAM,EAAE,CAAC;AAMZ,oDAAoD;AACpD,MAAM,CAAC,MAAM,0BAA0B,GAAG,YAAY,CAAC,sBAAsB,EAAE,aAAa,CAAC,CAAC;AAE9F;;;;GAIG;AACH,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAAC;IACzC,uEAAuE;IACvE,eAAe,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;IAC/C,uGAAuG;IACvG,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;IAC9C,0GAA0G;IAC1G,cAAc,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;CACpC,CAAC,CAAC,MAAM,EAAE,CAAC;AAIZ;;;;GAIG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAwB;IAC5D,IAAI,EAAE,qBAAqB;IAC3B,QAAQ,EAAE,0FAA0F;UAChG,gGAAgG;UAChG,mGAAmG;UACnG,iGAAiG;UACjG,iCAAiC;CACtC,CAAC;AAEF,qEAAqE;AACrE,MAAM,CAAC,MAAM,8BAA8B,GAAG,YAAY,CAAC,yBAAyB,EAAE,aAAa,CAAC,CAAC"}

package/dist/commands/phase-utils.d.ts

@@ -1,44 +1,86 @@
 /**
- * Shared utilities for top-level phase orchestration commands (vat build, vat verify, vat validate).
+ * Shared machinery for the phase orchestrators: `vat build`, `vat verify` and
+ * `vat validate`.
+ *
+ * 🔑 **Each phase hands back its report; the orchestrator publishes ONE.** A
+ * phase function returns `{ report }` — the `Report<T>` its own command would
+ * publish, BEFORE the writer's run-integrity pass — and the orchestrator folds
+ * every phase into {@link orchestratorReport}: findings flat on the envelope,
+ * `examined` the sum, each phase's status, count, summary and `data` under
+ * `data.phases`.
+ *
+ * 🔑 **A configured phase that examined nothing is a refusal of THAT phase**
+ * ({@link phaseVerdict}), by the declaration its verb's writer is given when the
+ * verb runs alone — so an orchestrated phase and its verb cannot disagree. Judged
+ * on the sum alone, a `skills.include` matching nothing beside a healthy
+ * `resources:` surface was `status: ok`, exit 0. What is NOT refused is a phase
+ * for which zero is an answer, and each one says why ({@link ZeroIsAnAnswer}): a
+ * phase that ran with no config block of its own (`vat build`'s `skills` phase in a
+ * project with no `skills:` block), a `skills` phase whose pool is empty in a project
+ * that ships plugin-local skills ({@link skillsPhaseExamined} — refusing that failed
+ * `claude plugin install --build`, which trusts `vat build`'s exit), or one that
+ * checks what another phase discovered. The writer still judges the sum, for the
+ * run in which no phase ran at all.
+ *
+ * Each phase's report is held to its OWN schema before the fold ({@link Phase}
+ * `schema`, parsed by {@link runPhase}): the orchestrator's schema carries a
+ * phase's `data` as `unknown`, so nothing downstream could catch a phase
+ * publishing data its verb does not describe.
+ *
+ * There is no second status vocabulary. A phase's status is its envelope's
+ * (`ok | findings | error`), the orchestrator's exit derives from its own
+ * published document, and a phase that did not finish makes the run `error` /
+ * `RUN_INCOMPLETE` with the finished phases still in `data.phases`.
  */
-import { type ExitCodeValue, type SeverityCounts } from '@vibe-agent-toolkit/schema';
+import type { ProjectConfig } from '@vibe-agent-toolkit/resources';
+import { type Gate, type RefusalCode, type Report, type ReportZodSchema } from '@vibe-agent-toolkit/schema';
 import { type Command } from 'commander';
+import { type ZodTypeAny } from 'zod';
+import type { DocumentFormat } from '../report-schemas.js';
 import { createLogger } from '../utils/logger.js';
+import { type ExaminedDeclaration } from '../utils/run-integrity.js';
+import type { OrchestratorData } from './orchestrator-schema.js';
 /**
- * What one phase produced: the document it publishes, and the exit code it
- * claims for itself.
- *
- * This pair is the whole of what an orchestrator needs from a phase: an exit
- * code, and the document the phase publishes. Naming it as a value is what lets
- * a phase run in the orchestrator's own process — stderr streams directly either
- * way, so nothing else has to cross.
- *
- * `document` is the object the phase PRINTS, not the internal summary it is
- * built from. The distinction is load-bearing: `vat skills build` renders its
- * summary in two pieces and publishes `skillsWithErrors` as a COUNT while the
- * summary object holds an ARRAY under that name.
- *
- * ⚠️ This field is `unknown`, so nothing typechecks it. Handing back the summary
- * object instead of the printed document changes the emitted contract silently.
+ * What one phase produced: the report its own command would publish, before
+ * the run-integrity pass — which {@link runPhase} applies, by the phase's own
+ * declaration ({@link Phase} `examined`), exactly as that command's writer does.
  */
 export interface PhaseOutcome {
-    document: unknown;
-    exitCode: ExitCodeValue;
-    /**
-     * The phase failed UNEXPECTEDLY, so `document` is the shared error envelope
-     * (`{status, error, duration}`) rather than the command's own report.
-     *
-     * The orchestrated lane does not need this — it folds any document under
-     * `phases[].report` the same way. The command-line lane does: each command
-     * renders its own report with its own renderer (streamed YAML, `--format
-     * json`, a hand-built header), and none of those renderers understand an
-     * envelope. Handing one to them silently changes both the channel and the
-     * shape of the failure document every `vat … | jq` consumer depends on.
-     */
-    failed?: boolean;
+    report: Report<unknown>;
 }
+/** A phase for which examining nothing IS an answer, and the reason it is. */
+export interface ZeroIsAnAnswer {
+    readonly zeroIsAnAnswer: string;
+}
+/**
+ * What a phase's `examined` counts and the remedy when it is zero — the declaration its verb's
+ * writer is given when that verb runs alone — or the reason zero is an answer for it.
+ */
+export type PhaseExamined = ExaminedDeclaration | ZeroIsAnAnswer;
+/** The schema a phase's report is held to: its own verb's registered report schema. */
+export type PhaseReportSchema = ReportZodSchema<ZodTypeAny, ZodTypeAny>;
 /**
- * One orchestrated phase: a name, and the work to run for it.
+ * The report schema of a phase that publishes no `data` of its own — verify's
+ * `files-config-dests` and `consistency`, build's `shipped-links`: no verb of
+ * their own registers one, and their `data` is `null`.
+ */
+export declare const DATALESS_PHASE_REPORT_SCHEMA: PhaseReportSchema;
+/**
+ * One orchestrated phase: a name, the schema its report is held to, and the
+ * work to run for it.
+ *
+ * `schema` is REQUIRED: the orchestrator's own schema holds a phase's `data`
+ * as `unknown` (it would otherwise be a second copy of every phase verb's
+ * shape), so {@link runPhase} parsing each report against the phase's own
+ * schema is the only thing standing between a phase and publishing `data` its
+ * verb's schema does not describe. A delegated phase names its verb's
+ * registered `<VERB>_REPORT_SCHEMA`; an in-process one names its own.
+ *
+ * `examined` is REQUIRED, for the same reason every writer's is: a phase that
+ * examined nothing and says nothing about it folds into the run as a clean one.
+ * A delegated phase names its verb's registered `<VERB>_EXAMINED`; a phase for
+ * which zero is an answer says so, with its reason. A function of the report for
+ * the one phase whose own `data` decides which of the two a zero is.
  *
  * `run` is a bound closure rather than an argv array because the phase executes
  * in this process. An argv array would mean re-entering Commander to
@@ -48,8 +90,39 @@ export interface PhaseOutcome {
  */
 export interface Phase {
     name: string;
+    schema: PhaseReportSchema;
+    examined: PhaseExamined | ((report: Report<unknown>) => PhaseExamined);
     run: () => Promise<PhaseOutcome>;
 }
+/**
+ * Whether the project ships at least one plugin-local skill — by the ONE answer to that question
+ * (`indexPluginLocalSkills`: what the claude phase packages), never a path prefix.
+ *
+ * @param config - The project's config, or `undefined` when none loaded
+ * @param configDir - The directory the config was loaded from
+ */
+export declare function shipsPluginLocalSkills(config: ProjectConfig | undefined, configDir: string): boolean;
+/**
+ * The declaration of a `skills` phase (`vat build`, `vat validate`, `vat verify`): zero pool
+ * skills is the verb's own refusal — unless the project ships a plugin-local skill.
+ *
+ * `skills.include` is required by the schema, and a plugin-local skill reads its packaging
+ * config from `skills.config` / `skills.defaults`, so a project whose skills are all plugin-local
+ * MUST carry a `skills:` block whose include legitimately matches nothing in the pool. Refusing
+ * that stopped `vat build` before the `claude` phase that builds those very skills. With no pool
+ * match AND no plugin-local skill, the run examined no skill at all, and it is the refusal.
+ *
+ * @param declared - What the phase's verb declares its `examined` counts
+ * @param pluginLocal - Asked only when the phase examined nothing: it lists the project's plugins
+ */
+export declare function skillsPhaseExamined(declared: ExaminedDeclaration, pluginLocal: () => boolean): (report: Report<unknown>) => PhaseExamined;
+/** One phase that ran: its name and its report. */
+export interface PhaseResult {
+    name: string;
+    report: Report<unknown>;
+}
+/** No orchestrator offers `--strict`: warnings never fail a run. */
+export declare const ORCHESTRATOR_GATE: Gate;
 /**
  * Declare `--only` on a command that has RETIRED it, solely so the command can
  * explain itself instead of emitting Commander's bare `error: unknown option
@@ -57,7 +130,7 @@ export interface Phase {
  *
  * This is **not** a backward-compatibility shim — the pre-1.0 policy forbids
  * those and this obeys it. The flag does not work: {@link rejectRetiredOnly}
- * fails the run before any phase is selected, so no caller can keep depending
+ * refuses the run before any phase is selected, so no caller can keep depending
  * on the old behaviour. What it buys is a diagnosis. An unknown-option error
  * names the flag and nothing else; the reader cannot tell a typo from a removal
  * and has no way to learn what replaced it, so the next move is a bug report or
@@ -69,104 +142,49 @@ export interface Phase {
  */
 export declare function addRetiredOnlyOption(command: Command): Command;
 /**
- * Fail the run when a caller passed the retired `--only`, naming what changed.
+ * Refuse the run when a caller passed the retired `--only`, naming what changed.
  *
- * Exit 1, matching both Commander's usage-error convention and the exit code an
- * unroutable `--only` already produced on these commands, so a CI gate that was
- * failing on a bad `--only` keeps failing rather than flipping to green.
+ * `USAGE_INVALID` (exit 2): the invocation is the mistake, and nothing was
+ * examined.
  *
  * @param only - The parsed `--only` value; `undefined` when it was not passed.
  * @param command - Command name for the message, e.g. `vat validate`.
  * @param seconds - The measured full-run duration that made the flag not worth
  *   its coverage risk. Cited so the removal reads as a decision with evidence
  *   rather than a preference.
+ * @throws CommandRefusalError `USAGE_INVALID` when `--only` was passed
  */
 export declare function rejectRetiredOnly(only: string | undefined, command: string, seconds: number): void;
-/**
- * Outcome of one orchestrated phase.
- *
- * `system-error` is a value of its own because **a phase that could not RUN is
- * not a phase that found problems.**
- *
- * ⚠️ Any two-valued mapping — `status === 0 ? 'passed' : 'failed'` and its
- * relatives — collapses it into `error` and makes the documented exit code 2
- * unreachable from every orchestrator, leaving a CI script unable to tell an
- * invalid config from a broken link.
- *
- * `warning` reaches a phase through its own reported `status`, NOT through its
- * exit code — `vat skills validate` exits 0 while reporting `status: warning`,
- * so an exit-code-only mapping answered `success` on the very tree where the
- * phase said otherwise. Phases that hold their own findings (e.g. verify's
- * consistency check) emit it directly.
- */
-export type PhaseStatus = 'success' | 'warning' | 'error' | 'system-error';
-/** The phase outcome for "we did not learn what this phase would have said". */
-export declare const SYSTEM_ERROR: PhaseStatus;
-export interface PhaseResult {
-    name: string;
-    status: PhaseStatus;
-    /** The exit code the phase claimed for itself. */
-    exitCode?: ExitCodeValue;
-    /** Why the phase could not run at all (it threw past its own error handling). */
-    error?: string;
-    /**
-     * Per-severity distribution for phases that hold their own findings and
-     * publish no document of their own. Absent for phases that DO publish one:
-     * those own their findings, and inventing counts here would be a second,
-     * weaker answer — theirs are carried verbatim in {@link PhaseResult.report}.
-     */
-    issueCounts?: SeverityCounts;
-    /**
-     * The phase's own document, folded in under its name.
-     *
-     * Nested under the phase's own entry so the orchestrator's stdout stays ONE
-     * parseable document.
-     *
-     * ⚠️ Phase documents written onto a shared stdout concatenate with no `---`
-     * between them: two phases each carrying `status:` and `durationSecs:` become
-     * a single map with duplicate keys, and `YAML.parse()` throws "Map keys must
-     * be unique".
-     */
-    report?: unknown;
-}
 export interface PhaseContext {
     logger: ReturnType<typeof createLogger>;
-    startTime: number;
 }
 /**
- * Create the shared phase command context: logger, startTime, and bin path.
- *
- * Total by design: it builds the context and decides nothing.
- *
- * ⚠️ This runs BEFORE the command's try block, so anything that throws here
- * reaches the user as a raw Node stack trace with zero bytes of stdout and an
- * exit 1 indistinguishable from "validation errors". Phase routing therefore
- * belongs to {@link decidePhaseSelection} and {@link applyPhaseSelection}, which
- * emit the command's normal structured document.
+ * Create the shared phase command context. Total by design: it builds the
+ * context and decides nothing, because it runs outside the orchestrator's
+ * refusal handling.
  */
 export declare function createPhaseContext(debugFlag: boolean | undefined): PhaseContext;
 /**
  * The decision an orchestrator reaches about what `--only` asked for.
  *
- * Three arms, because the three answers carry different exit codes and none of
- * them may be collapsed into another:
  *   - `run`  — go ahead with these phases.
  *   - `fail` — the caller named a phase that is unrecognized, or recognized but
- *              not configured. Exit 1: a CI gate asked for coverage that cannot
- *              run and must not stay green.
- *   - `noop` — a bare run in a project that configures nothing. Exit 0, but
- *              WARNED, so a config typo is not indistinguishable from success.
+ *              not configured, or the config could not be read: a refusal,
+ *              carrying which one.
+ *   - `noop` — a bare run in a project that configures nothing. It runs no
+ *              phase; the writer refuses the zero-examined run, and the stderr
+ *              warning names the likely config typo.
  */
 export type PhaseSelection = {
     kind: 'run';
     phases: Phase[];
 } | {
     kind: 'fail';
+    code: RefusalCode;
     message: string;
 } | {
     kind: 'noop';
     warning: string;
-    note: string;
 };
 /** How one orchestrator names the things `--only` selects, for its messages. */
 export interface PhaseVocabulary {
@@ -176,10 +194,9 @@ export interface PhaseVocabulary {
     verb: string;
     /** Every name `--only` accepts, in help order. */
     validNames: readonly string[];
-    /** Stderr warning + stdout note for a bare run with nothing configured. */
+    /** Stderr warning for a bare run with nothing configured. */
     noop?: {
         warning: string;
-        note: string;
     };
 }
 /**
@@ -187,11 +204,9 @@ export interface PhaseVocabulary {
  * list its config produced.
  *
  * THE single decision site for all three orchestrators, so they cannot answer
- * the same question differently. An orchestrator that builds its phase list
- * without consulting the config exits 0 on `--only skills` in a project with no
- * `skills:` block while another exits 1 — opposite verdicts on one question.
- * `vat verify` has retired `--only` and always passes `only: undefined`;
- * `vat validate` and `vat build` route their own `--only` through here.
+ * the same question differently. `vat verify` and `vat validate` have retired
+ * `--only` and always pass `only: undefined`; `vat build` routes its own
+ * `--only` through here.
  *
  * ⚠️ **Nothing may short-circuit ahead of the config-error arm.** A check
  * evaluated before `unreadableConfig` answers a confident "not configured" for a
@@ -199,138 +214,91 @@ export interface PhaseVocabulary {
  * must never give, because it is indistinguishable from a correct one.
  *
  * @param unreadableConfig - The config-load error, when the config exists but
- *   could not be parsed. A broken config is NOT "the phase is unconfigured":
- *   we do not know what it declares, so we must not answer with a confident
- *   "not configured". Only `vat verify` passes it, and only defensively — its
+ *   could not be parsed. Only `vat verify` passes it, and only defensively — its
  *   phase builder pushes every configured phase when the config is unreadable
  *   (so the phase itself reports the real error), which makes the list non-empty
- *   and this arm unreachable by construction today. It is kept because the arm
- *   that would otherwise catch an empty list is the "not configured" lie.
+ *   and this arm unreachable by construction today.
  */
 export declare function decidePhaseSelection(only: string | undefined, phases: Phase[], vocab: PhaseVocabulary, options?: {
     unreadableConfig?: string | undefined;
 }): PhaseSelection;
 /**
- * Act on a {@link PhaseSelection}: return the phases to run, or emit the
- * command's normal structured document and exit.
- *
- * Both terminal arms go through `writeYamlOutput` deliberately: the YAML
- * document on stdout is the one output a scripted caller parses, so a routing
- * failure has to publish one rather than throw past it.
- */
-export declare function applyPhaseSelection(selection: PhaseSelection, logger: ReturnType<typeof createLogger>, startTime: number): Phase[];
-/** The worse of two phase statuses, per {@link PHASE_STATUS_ORDER}. */
-export declare function worseOf(a: PhaseStatus, b: PhaseStatus): PhaseStatus;
-/**
- * Map what a phase produced to its outcome. The pure core of {@link runPhase}.
- *
- * | exit code             | phase status   | why                                     |
- * |-----------------------|----------------|-----------------------------------------|
- * | `OK` (0)              | `success`      | ran, found nothing actionable           |
- * | `FINDINGS` (1)        | `error`        | ran, found validation errors            |
- * | `ERROR` (2)           | `system-error` | the phase itself reported a system error |
- * | anything else         | throws         | a defect in the phase, filed by `runPhase` as `system-error` |
- *
- * The exit code is then reconciled with the phase's OWN reported `status`,
- * worst-wins. An exit code has three values and cannot express `warning`:
- * `vat skills validate` exits 0 while reporting `status: warning`, so its exit
- * code alone reads as `success` — including on the tree VAT's CI dogfoods on
- * VAT itself.
- *
- * The table has no row for a signal kill, a missing status code, or a document
- * that fails to parse, and that is the design rather than an omission. A phase
- * runs in this process: there is no serialization step in which to lose a
- * document, and no signal that could take a phase without taking the
- * orchestrator with it.
- */
-export declare function phaseResultFromOutcome(name: string, outcome: PhaseOutcome): PhaseResult;
-/**
- * End a command-line run from a phase outcome: publish the document, then exit.
+ * Act on a {@link PhaseSelection}: the phases to run, or the refusal.
  *
- * THE single place the two lanes diverge, so they cannot diverge anywhere else.
- * A phase hands back the same `{ document, exitCode }` either way; this decides
- * what a *command* does with it, while an orchestrator folds it into
- * `phases[].report` instead.
- *
- * Three cases, and the middle one is the one to get right:
- *   - an unexpected failure publishes the shared envelope in the format the
- *     operator asked for, matching `handleCommandError`;
- *   - a command's own report goes through the command's own `render`;
- *   - no document at all (an unconfigured run, a dry run) publishes nothing.
- *
- * 🔑 **`format` is REQUIRED, and that is the whole point of it being a
- * parameter.** This arm hardcoded `writeYamlOutput`, and it is `vat resources
- * validate`'s ONLY error exit — so `--format json` silently produced YAML on the
- * one path a scripted consumer most needs to parse. The sibling
- * `handleCommandError` has the same parameter as an OPTIONAL one carrying a
- * docstring that says a caller with a `--format` option must pass it, and two
- * commands added in the same change dropped it anyway: a docstring is not a
- * mechanism. Here the type system asks, so a new caller cannot forget. A command
- * that offers no `--format` passes `undefined` and says so at its call site.
- *
- * ⚠️ It governs the FAILURE envelope only. A command's own report still goes
- * through `render`, which is what a `--format text` lane needs.
- *
- * @param outcome - What the phase produced
- * @param render - How this command publishes its OWN report shape
- * @param format - What the operator asked for: `json`, or anything else (and
- *   `undefined`) for YAML — the same two-branch switch `handleCommandError` and
- *   every success path use
+ * @throws CommandRefusalError for a `fail` selection, carrying its code —
+ *   the orchestrator's catch publishes it
  */
-export declare function finishCommand(outcome: PhaseOutcome, render: (document: unknown) => void, format: string | undefined): never;
+export declare function applyPhaseSelection(selection: PhaseSelection, logger: ReturnType<typeof createLogger>): Phase[];
 /**
- * Run a single phase in THIS process and fold its outcome into a result.
+ * Run a single phase in THIS process.
  *
  * In THIS process, because everything an orchestrator reads back from a phase is
- * the {@link PhaseOutcome} pair. A process per phase buys neither half of it and
- * charges, on every phase, a full Node startup and the whole module graph again
- * (~730 ms of remark per isolate), a parse cache whose miss counters restart
- * from zero, and a worker pool built and torn down before the next phase begins.
- * Phases run sequentially, so none of that cost is ever overlapped with work.
- *
- * The `catch` is a BACKSTOP, not the error path. Every phase function reports
- * its own failures through `reportCommandError` and returns them as a document.
- *
- * ⚠️ This arm exists for a throw that escaped that handling. Sharing the
- * orchestrator's process is what makes it load-bearing: an escaped throw aborts
- * the orchestrator itself and silently skips every later phase.
+ * its report. A process per phase charges, on every phase, a full Node startup
+ * and the whole module graph again (~730 ms of remark per isolate), a parse
+ * cache whose miss counters restart from zero, and a worker pool built and torn
+ * down before the next phase begins.
+ *
+ * The report is held to the phase's own {@link Phase.schema} before it is
+ * folded — the check its verb's writer applies when that verb runs alone. A
+ * report the schema rejects is VAT's defect: the `ZodError` carries no code, so
+ * it becomes the phase's `INTERNAL_ERROR`, never a finished phase.
+ *
+ * Then it is judged as its verb's writer judges it ({@link phaseVerdict}): a
+ * configured phase that examined nothing is refused, and the refusal is said on
+ * stderr as well as in the document.
+ *
+ * The `catch` is a BACKSTOP, not the error path: every phase function returns
+ * its own refusal as a report. A throw that escaped that becomes the phase's
+ * refusal — classified by its code, `INTERNAL_ERROR` when it carries none —
+ * rather than aborting the orchestrator and silently skipping every later phase.
  */
 export declare function runPhase(phase: Phase): Promise<PhaseResult>;
 /**
- * Worst-wins aggregate across phases. `system-error` outranks `error`: "we could
- * not determine the answer" must never be filed under "we determined it is bad".
- */
-export declare function aggregatePhaseStatus(results: readonly PhaseResult[]): PhaseStatus;
-/**
- * One phase's per-severity distribution, wherever that phase keeps it.
- *
- * A phase that holds its own findings publishes {@link PhaseResult.issueCounts}.
- * A phase that publishes its own document deliberately does not — it owns its
- * findings, and its document rides verbatim in {@link PhaseResult.report}.
+ * A phase's report as its own verb's writer would publish it: with the ONE
+ * `RESOURCE_CHECK_BROKEN` refusal added when it examined nothing — unless zero is
+ * an answer for this phase. `withRunIntegrity` is the same function every writer
+ * calls, so there is one contract for "a run that examined nothing", and an
+ * orchestrated phase gets the very finding its verb gives alone.
  *
- * ⚠️ Both places must be read. Reading only `issueCounts` makes an
- * orchestrator's header report `{0, 0, 0}` over phases that just reported 12
- * warnings.
+ * Pure: no I/O, no stderr.
  *
- * Absent or malformed counts read as zero rather than throwing: a phase that
- * publishes no distribution contributes nothing to the total.
+ * @param phase - The phase's `examined` declaration
+ * @param report - What the phase returned
+ * @returns `report` itself when nothing is added, so a caller can tell by identity
  */
-export declare function phaseIssueCounts(result: PhaseResult): SeverityCounts;
+export declare function phaseVerdict(phase: Pick<Phase, 'examined'>, report: Report<unknown>): Report<unknown>;
 /**
- * Sum every phase's distribution, so an orchestrator's header total reconciles
- * against the phases printed beneath it.
- *
- * The companion to {@link aggregatePhaseStatus}: status is worst-wins ACROSS
- * phases, so a header whose `status` can see the phases while its `issueCounts`
- * cannot publishes a contradiction in one document — `status: warning` beside
- * `warnings: 0`.
+ * Fold the phases into the orchestrator's ONE report.
+ *
+ * `findings` is every phase's findings with its `location` unchanged; `examined`
+ * is the sum of the phases' own; `data.phases` is one entry per phase. Any phase
+ * that did not finish makes the run `error` with `RUN_INCOMPLETE`, naming the
+ * phases that stopped, and the finished ones stay in `data.phases` — a failed
+ * phase never erases what the others found.
+ *
+ * Pure: each phase was judged as it ran ({@link runPhase}), and the writer judges
+ * the sum when it publishes — which refuses the run in which no phase ran.
+ *
+ * @param results - Every phase that ran, in execution order
+ * @param gate - The gate the run is judged by
+ * @param durationMs - Wall-clock milliseconds the run took; carried by a completed
+ *   run only, as no refusal document carries `durationMs`
+ * @returns The report, before the writer's run-integrity pass
  */
-export declare function aggregatePhaseIssueCounts(results: readonly PhaseResult[]): SeverityCounts;
+export declare function orchestratorReport(results: readonly PhaseResult[], gate: Gate, durationMs?: number): Report<OrchestratorData>;
 /**
- * The process exit code for a set of phase outcomes, per the exit-code contract
- * every orchestrator's help text documents: `OK` pass, `FINDINGS` validation
- * failure, `ERROR` system error. Warnings do not fail a run — they are
- * published in the status and counts instead.
+ * Run an orchestrator's body and fold it into its ONE report.
+ *
+ * `body` pushes each phase that ran onto `results`. A throw from it — the
+ * refused `--only`, a positional argument, no project root, discovery that
+ * could not see the tree — is classified by its code and becomes the
+ * envelope's error branch carrying every phase that already finished. The
+ * command publishes the result with `endWithReport`.
+ *
+ * @param body - The run; it records each phase's result as it finishes
+ * @returns The orchestrator's report, before the writer's run-integrity pass
  */
-export declare function exitCodeForPhases(results: readonly PhaseResult[]): ExitCodeValue;
+export declare function orchestrate(body: (results: PhaseResult[]) => Promise<void>): Promise<Report<unknown>>;
+/** No orchestrator offers `--format`: the document is YAML. */
+export declare const ORCHESTRATOR_FORMAT: DocumentFormat;
 //# sourceMappingURL=phase-utils.d.ts.map

package/dist/commands/phase-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"phase-utils.d.ts","sourceRoot":"","sources":["../../src/commands/phase-utils.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"phase-utils.d.ts","sourceRoot":"","sources":["../../src/commands/phase-utils.ts"],"names":[],"mappings":"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"}