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

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

@@ -1,12 +1,54 @@
 /**
  * Shared utilities for top-level phase orchestration commands (vat build, vat verify, vat validate).
  */
-import { type SeverityCounts } from '@vibe-agent-toolkit/agent-schema';
+import { type ExitCodeValue, type SeverityCounts } from '@vibe-agent-toolkit/schema';
 import { type Command } from 'commander';
 import { createLogger } from '../utils/logger.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.
+ */
+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;
+}
+/**
+ * One orchestrated phase: a name, and the work to run for it.
+ *
+ * `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
+ * parse arguments this process has already parsed — a second, weaker copy of the
+ * orchestrator's own options, and the exact seam through which `vat validate`'s
+ * `--verbose` could be forwarded to one phase and dropped by another.
+ */
 export interface Phase {
     name: string;
-    args: string[];
+    run: () => Promise<PhaseOutcome>;
 }
 /**
  * Declare `--only` on a command that has RETIRED it, solely so the command can
@@ -44,16 +86,18 @@ export declare function rejectRetiredOnly(only: string | undefined, command: str
  * 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.** Collapsing it into `error` (which is what
- * `result.status === 0 ? 'passed' : 'failed'` did) made the documented exit
- * code 2 unreachable from every orchestrator, so a CI script could not tell an
- * invalid config or a killed child from a broken link.
- *
- * `warning` reaches a subprocess phase through the child's 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 child said otherwise. In-process phases (e.g.
- * verify's consistency check) emit it directly.
+ * 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". */
@@ -61,58 +105,44 @@ export declare const SYSTEM_ERROR: PhaseStatus;
 export interface PhaseResult {
     name: string;
     status: PhaseStatus;
-    /** Child exit code, when the child ran and exited on its own. */
-    exitCode?: number;
-    /** POSIX signal that killed the child, when one did (then `exitCode` is absent). */
-    signal?: string;
-    /** Why the phase could not run at all (the spawn itself failed). */
+    /** 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 in-process phases that hold their own
-     * findings. Absent for subprocess phases: the child owns its own findings,
-     * and inventing counts here would be a second, weaker answer — the child's
-     * are carried verbatim in {@link PhaseResult.report} instead.
+     * 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 child's own YAML document, parsed and folded in.
+     * 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.
      *
-     * The child used to write this straight onto the parent's stdout (`stdio:
-     * 'inherit'`), which concatenated N documents with no `---` between them: two
-     * phases produced one map carrying `status:` and `durationSecs:` twice, and
-     * `YAML.parse()` threw "Map keys must be unique". Nesting each child's
-     * document under its own phase makes the parent's stdout one parseable
-     * document again and loses nothing.
+     * ⚠️ 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;
 }
-/** The subset of a `spawnSync` return that decides a phase's outcome. */
-export interface PhaseSpawnOutcome {
-    status: number | null;
-    signal: NodeJS.Signals | null;
-    error?: Error | undefined;
-    /** The child's captured stdout, when it was piped rather than inherited. */
-    stdout?: string | null | undefined;
-}
-/**
- * Resolve the absolute path to the vat binary.
- * This file lives in commands/, one level above bin/.
- */
-export declare function resolveBinPath(): string;
 export interface PhaseContext {
     logger: ReturnType<typeof createLogger>;
     startTime: number;
-    binPath: string;
 }
 /**
  * Create the shared phase command context: logger, startTime, and bin path.
  *
- * It used to THROW when the phase list came out empty — and it was called
- * before the command's try block, so an unroutable `--only` reached the user as
- * a raw Node stack trace with zero bytes of stdout and an exit 1 that looked
- * like "validation errors". `--only` routing is decided by
- * {@link decidePhaseSelection} and reported by {@link applyPhaseSelection} now,
- * which emit the command's normal structured document.
+ * 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.
  */
 export declare function createPhaseContext(debugFlag: boolean | undefined): PhaseContext;
 /**
@@ -156,30 +186,26 @@ export interface PhaseVocabulary {
  * Decide what an orchestrator should do with its `--only` value and the phase
  * list its config produced.
  *
- * Shared by all three orchestrators because they used to disagree: `vat verify`
- * built its phase list without consulting the config at all, so `vat verify
- * --only skills` in a project with no `skills:` block exited 0 while `vat
- * validate --only skills` on the same project exited 1 — opposite verdicts on
- * the same question. (`vat verify` has since retired `--only` entirely and now
- * always passes `only: undefined`; `vat validate` and `vat build` still route
- * their own `--only` through here.)
- *
- * There used to be a third option, `emptyIsValid`, which existed solely so
- * `vat verify --only consistency` could run with an empty SUBPROCESS list
- * (consistency runs in-process). It was checked BEFORE `unreadableConfig`, so
- * `vat verify --only consistency` against an unparseable config answered the
- * confidently-wrong "no skills: block" instead of reporting the config error.
- * `--only` is gone from verify, `emptyIsValid` went with it, and that ordering
- * hazard cannot recur: nothing short-circuits ahead of the config-error arm.
+ * 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.
+ *
+ * ⚠️ **Nothing may short-circuit ahead of the config-error arm.** A check
+ * evaluated before `unreadableConfig` answers a confident "not configured" for a
+ * tree whose config could not be parsed — which is the one answer this function
+ * 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
- *   phase builder pushes every subprocess phase when the config is unreadable
- *   (so the CHILD 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.
+ *   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.
  */
 export declare function decidePhaseSelection(only: string | undefined, phases: Phase[], vocab: PhaseVocabulary, options?: {
     unreadableConfig?: string | undefined;
@@ -188,46 +214,88 @@ export declare function decidePhaseSelection(only: string | undefined, phases: P
  * 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. A `--only`
- * failure used to be an uncaught throw, so the one output a scripted caller
- * parses — the YAML document on stdout — was never written at all.
+ * 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 a spawn outcome to a phase outcome. The pure core of {@link runPhase}.
- *
- * Every branch that is NOT "the child ran and told us what it found" is a
- * system error, because the orchestrator learned nothing about the artifact:
- *
- * | spawn outcome            | phase status   | why                                        |
- * |--------------------------|----------------|--------------------------------------------|
- * | `error` set              | `system-error` | the child never ran                        |
- * | killed by a signal       | `system-error` | the child was cut off mid-answer           |
- * | no exit code, no signal  | `system-error` | there is no answer to read                 |
- * | stdout not parseable     | `system-error` | the child's answer cannot be read          |
- * | exit 0                   | `success`      | ran, found nothing actionable              |
- * | exit 1                   | `error`        | ran, found validation errors               |
- * | exit 2 (or any other)    | `system-error` | the child itself reported a system error    |
- *
- * The exit code is then reconciled with the child's OWN reported `status`,
- * worst-wins. An exit code has three values and cannot express `warning`, so
- * `vat skills validate` — which exits 0 while reporting `status: warning` —
- * was being recorded as `success` by every orchestrator, including the one
- * VAT's CI dogfoods on VAT itself.
+ * 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.
+ *
+ * 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
  */
-export declare function phaseResultFromSpawn(name: string, outcome: PhaseSpawnOutcome): PhaseResult;
+export declare function finishCommand(outcome: PhaseOutcome, render: (document: unknown) => void, format: string | undefined): never;
 /**
- * Run a single phase by spawning the vat binary with the phase args.
+ * Run a single phase in THIS process and fold its outcome into a result.
+ *
+ * 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.
  *
- * stdout is CAPTURED, not inherited: the child's YAML document belongs in this
- * phase's `report`, and letting it stream onto the parent's stdout is what made
- * `vat validate`'s output a run of documents with no `---` between them.
- * stderr stays inherited — progress output is on stderr by design and must keep
- * streaming live rather than arriving in one lump at the end.
+ * 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.
  */
-export declare function runPhase(binPath: string, phase: Phase): PhaseResult;
+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".
@@ -236,33 +304,33 @@ export declare function aggregatePhaseStatus(results: readonly PhaseResult[]): P
 /**
  * One phase's per-severity distribution, wherever that phase keeps it.
  *
- * An in-process phase holds its own findings and publishes {@link
- * PhaseResult.issueCounts}. A subprocess phase deliberately does not — the child
- * owns its findings, and its document rides verbatim in {@link
- * PhaseResult.report}. Reading only the former is why an orchestrator's header
- * could report `{0, 0, 0}` over children that had just reported 12 warnings.
+ * 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}.
+ *
+ * ⚠️ Both places must be read. Reading only `issueCounts` makes an
+ * orchestrator's header report `{0, 0, 0}` over phases that just reported 12
+ * warnings.
  *
  * Absent or malformed counts read as zero rather than throwing: a phase that
- * published no distribution contributes nothing to the total, which is the same
- * answer as before this function existed — just no longer the answer for phases
- * that DID publish one.
+ * publishes no distribution contributes nothing to the total.
  */
 export declare function phaseIssueCounts(result: PhaseResult): SeverityCounts;
 /**
  * Sum every phase's distribution, so an orchestrator's header total reconciles
  * against the phases printed beneath it.
  *
- * The companion to {@link aggregatePhaseStatus}: status has always been
- * worst-wins ACROSS phases, and a header whose `status` can see the children
- * while its `issueCounts` cannot is the same contradiction in one document —
- * `status: warning` beside `warnings: 0`.
+ * 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`.
  */
 export declare function aggregatePhaseIssueCounts(results: readonly PhaseResult[]): SeverityCounts;
 /**
  * The process exit code for a set of phase outcomes, per the exit-code contract
- * every orchestrator's help text documents: 0 pass, 1 validation failure,
- * 2 system error. Warnings do not fail a run — they are published in the status
- * and counts instead.
+ * 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.
  */
-export declare function exitCodeForPhases(results: readonly PhaseResult[]): 0 | 1 | 2;
+export declare function exitCodeForPhases(results: readonly PhaseResult[]): ExitCodeValue;
 //# 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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"}