@yagni-app/code-staging 1.2.6-staging.1951.1 → 1.2.6-staging.1956.1

package/dist/extension/pipeline/types.d.ts

@@ -67,6 +67,33 @@ export interface PipelineStage {
      * claimed files, sibling claims, and the shared-worktree discipline rules.
      */
     personaClause?: string;
+    /**
+     * The persona body this stage runs with, in place of its agent's. The cloud
+     * plan stage takes the host's `plan-persona.md` (Reeve's persona) here.
+     */
+    persona?: string;
+}
+/**
+ * A stage list and the loop rules that go with it. The `full` lane is what
+ * interactive /go and mission builds run; the `cloud` lane is the one-attempt
+ * session (`yagni go --headless --cloud`).
+ */
+export interface PipelineLane {
+    stages: PipelineStage[];
+    /** The review angles fanned out each round; empty is one reviewer covering every angle. */
+    reviewLenses: readonly ReviewLens[];
+    /** Review rounds before the loop stops `round_cap`. */
+    maxReviewRounds: number;
+    /** Whether implement may fan out into parallel builders (the diamond). */
+    fanout: boolean;
+    /** The plan stage ends the run: the plan goes to its gate before anything is built. */
+    stopAfterPlan: boolean;
+    /**
+     * Every stage loads the Team's skills (the launcher's `--skill` /
+     * `--prompt-template` flags), not only the ones that write code: the
+     * cloud session plans and reviews with them too (spec decision 4).
+     */
+    skillsEveryStage: boolean;
 }
 /** A single structured review finding parsed from a reviewer's output. */
 export interface Finding {
@@ -210,6 +237,8 @@ export interface PipelineResult {
      * orchestrator never sets it — commit/push live outside the LLM pipeline).
      */
     finish?: FinishInfo;
+    /** The plan the run wrote, on a lane whose plan stage ends the run (`stopAfterPlan`). */
+    plan?: string;
 }
 /**
  * The append-only resilience journal (spec: 2026-06-29-yagni-code-go-resilience).
@@ -512,6 +541,8 @@ export type PipelineProgress = {
  *  - Round two runs only when round one found a blocker (`shouldStop`); what is
  *    still open after the cap is written into the pull request body under
  *    "Left for review" for Proctor, never a third round.
+ * This is the `full` lane's cap. The cloud lane carries its own
+ * (`PipelineLane.maxReviewRounds`): one reviewer per round, so four rounds.
  */
 export declare const MAX_REVIEW_ROUNDS = 2;
 /**

package/dist/extension/pipeline/types.js

@@ -17,6 +17,8 @@
  *  - Round two runs only when round one found a blocker (`shouldStop`); what is
  *    still open after the cap is written into the pull request body under
  *    "Left for review" for Proctor, never a third round.
+ * This is the `full` lane's cap. The cloud lane carries its own
+ * (`PipelineLane.maxReviewRounds`): one reviewer per round, so four rounds.
  */
 export const MAX_REVIEW_ROUNDS = 2;
 /**

package/dist/extension/pipeline/verify.d.ts

@@ -94,7 +94,35 @@ export interface VerifyOutcome {
     reason?: string;
     /** Critical findings parsed from a failing run; empty otherwise. */
     findings: Finding[];
+    /** Failures the clean tree already had (YAG-1003): named in `reason`, never findings. */
+    preexisting?: number;
+    /** Every command the gate ran, with how it exited (the cloud session's `result.json` checks). */
+    checks?: VerifyCheckRun[];
 }
+/** One command the gate ran, and how it went. */
+export interface VerifyCheckRun {
+    name: string;
+    command: string;
+    /** Where it ran, repo-relative ("." for the root). */
+    cwd: string;
+    /** Null when the command never exited: it timed out, was aborted, or was not found. */
+    exitCode: number | null;
+    durationMs: number;
+    /**
+     * How the check stands on the unchanged code: it already failed there
+     * (the YAG-1003 baseline, or `checks.json`), the sandbox cannot run it, or
+     * neither.
+     */
+    baseline: "runnable" | "fails_on_base" | "cannot_run";
+    /** Why it has no exit code: "timed out", "aborted", "not found" or "could not run". */
+    note?: string;
+}
+/**
+ * Why a command threw instead of exiting, as its check record says it. `run`
+ * is the run's own signal (a /stop or the run's end); `capped` is the one
+ * the command ran under, which also carries its time cap.
+ */
+export declare function unexitedNote(err: unknown, run?: AbortSignal, capped?: AbortSignal): string;
 /** Injectable fs seam so detection is unit-testable without a real repo. */
 export interface DetectOpts {
     readFile?: (path: string) => string;
@@ -228,15 +256,16 @@ export type TestFailureClassification = {
  * Callers scrub the output through {@link scrubSecrets} BEFORE classification
  * so findings/notes never carry secrets (§0.9).
  */
-export declare function classifyTestFailure(output: string, exitCode: number): TestFailureClassification;
+export declare function classifyTestFailure(output: string, exitCode: number, limit?: number): TestFailureClassification;
 /**
  * Turn a failing verify run into `critical` Findings. A clean (exit 0) run yields
- * none. Located diagnostics (TypeScript first, then a generic file:line form) are
- * parsed into per-error findings; if none parse, a single capped finding carries
+ * none. Located diagnostics (TypeScript first, then a generic file:line form, then
+ * ESLint's stylish error rows under their file header) are parsed into per-error
+ * findings, at most `limit` of them; if none parse, a single capped finding carries
  * the tail of the output so the fix stage still gets actionable signal. Never
  * throws; always emits at least one finding on a non-zero exit.
  */
-export declare function parseVerifyFailures(output: string, exitCode: number, label: string): Finding[];
+export declare function parseVerifyFailures(output: string, exitCode: number, label: string, limit?: number): Finding[];
 /**
  * One finding's file as the REPO ROOT sees it.
  *
@@ -253,6 +282,49 @@ export declare function parseVerifyFailures(output: string, exitCode: number, la
  * so a finding that passes through twice is not double-prefixed.
  */
 export declare function toRepoRelativePath(file: string, repoRoot: string, commandCwd: string): string;
+/**
+ * What the gate's own checks already failed on before the build changed
+ * anything (YAG-1003): per command, how many times each failure key was seen
+ * on the clean tree. A command with no entry was not run there (or could not
+ * run), and its failures all count, as before.
+ */
+export type VerifyBaseline = ReadonlyMap<string, ReadonlyMap<string, number>>;
+/** One command's identity across the baseline run and the build's runs: where it runs and what it runs. */
+export declare function verifyCommandKey(command: Pick<VerifyCommand, "cwd" | "argv">): string;
+/**
+ * One failure's key, the shape #2601's `failureKeyOf` gives a CI failure: the
+ * repo-relative file and the message, never the line, since a change above a
+ * failure moves it. A failure that is only the output's tail names nothing
+ * stable, so it has no key and is never excused. Pure.
+ */
+export declare function verifyFailureKey(finding: Finding): string | null;
+/** How many times each failure key occurs. Pure. */
+export declare function failureKeyCounts(findings: readonly Finding[]): Map<string, number>;
+/**
+ * The failures this change caused: each failure key is excused at most as many
+ * times as the clean tree had it, so a second copy of an old error is new. A
+ * failure in a file the build did not touch still counts when the baseline did
+ * not have it, since a change can break another file's types. No baseline for
+ * the command leaves every failure in place. Pure.
+ */
+export declare function subtractBaseline(findings: readonly Finding[], baseline: ReadonlyMap<string, number> | undefined): {
+    findings: Finding[];
+    excused: number;
+};
+/** The note for failures the clean tree already had, by command label. Pure. */
+export declare function preexistingNote(byLabel: ReadonlyMap<string, number>): string | null;
+/**
+ * The repo-relative paths an approved plan names (`src/flows/a.tsx`,
+ * `packages/web/`), which say which packages the build will change before it
+ * has changed anything. URLs and paths that leave the tree are dropped. Pure.
+ */
+export declare function planPaths(plan: string): string[];
+/**
+ * The package dirs the baseline runs in: those the plan's paths fall in. The
+ * repo root drops out when a package below it was named, since its check is
+ * not one the build's gate would run then. Pure (the `readFile` seam).
+ */
+export declare function baselineDirs(repoRoot: string, paths: string[], readFile: (path: string) => string): string[];
 /** Result of actually executing the resolved command. */
 export interface VerifyExecResult {
     code: number;
@@ -352,6 +424,19 @@ export interface MakeRunVerifyOpts {
     treeStatus?: (cwd: string, signal?: AbortSignal) => Promise<string>;
     /** Undo what the half wrote into the tree (default: `git clean` / `git checkout` of exactly those paths). */
     undoTreeWrites?: (cwd: string, entries: TreeEntry[]) => Promise<void>;
+    /**
+     * What the typecheck and test halves already failed on before the build
+     * (YAG-1003, {@link makeTakeVerifyBaseline}). Those failures are a note, not
+     * findings. Absent: every failure is a finding, as before.
+     */
+    baseline?: VerifyBaseline | null;
+    /**
+     * The host's secret and binary scans over what this run added
+     * (changeScan.ts, YAG-1000), given the tree's pre-run dirt to leave out;
+     * null when git could not say what changed. A hit is a finding the fix turn
+     * removes. Absent: no scan half, as before (the cloud session sets it).
+     */
+    scanChange?: (cwd: string, signal?: AbortSignal, baselinePaths?: string[]) => Promise<Finding[] | null>;
 }
 /**
  * One workstream as the scoped checker sees it: the name its findings are
@@ -391,6 +476,8 @@ export interface MakeWorkstreamCheckOpts {
     detect?: (cwd: string, claimDirs: string[]) => VerifyCommand[];
     exec?: VerifyExec;
     timeoutMs?: number;
+    /** What the clean tree already failed on (YAG-1003): those failures are not a workstream's. */
+    baseline?: VerifyBaseline | null;
 }
 /**
  * The per-workstream scoped check the implement diamond runs right after the fan
@@ -428,5 +515,42 @@ export declare function makeWorkstreamCheck(opts?: MakeWorkstreamCheckOpts): (cw
  * blocks a real change on its own failure.
  */
 export declare function makeRunVerify(opts?: MakeRunVerifyOpts): (cwd: string, signal?: AbortSignal, baselinePaths?: string[]) => Promise<VerifyOutcome>;
+/** The whole baseline run's cap, before the build starts: it costs minutes at most. */
+export declare const VERIFY_BASELINE_BUDGET_MS: number;
+export interface MakeTakeVerifyBaselineOpts {
+    detect?: (cwd: string, dirs: string[]) => VerifyCommand[];
+    detectTests?: (cwd: string, dirs: string[]) => VerifyCommand[];
+    exec?: VerifyExec;
+    timeoutMs?: number;
+    testTimeoutMs?: number;
+    testEnv?: NodeJS.ProcessEnv;
+    budgetMs?: number;
+    now?: () => number;
+    treeStatus?: (cwd: string, signal?: AbortSignal) => Promise<string>;
+    undoTreeWrites?: (cwd: string, entries: TreeEntry[]) => Promise<void>;
+}
+/** What the baseline run found, for the gate and for the run's log. */
+export interface VerifyBaselineResult {
+    baseline: VerifyBaseline;
+    /** Commands that gave a verdict on the clean tree, by label. */
+    ran: string[];
+    /** Keyed failures the clean tree already had, across those commands. */
+    failures: number;
+    /** Commands that gave no verdict, and why: their failures all count later. */
+    notes: string[];
+}
+/**
+ * Run the gate's own typecheck and test commands ONCE on the clean tree,
+ * before the build changes anything (YAG-1003), in the package dirs the
+ * approved plan names, and keep each command's failure keys. The build's gate
+ * then counts only the failures this change added ({@link subtractBaseline}).
+ *
+ * The same detection, exec seam and environments as {@link makeRunVerify}, so
+ * a command's key and its failures' keys match the build's runs. Fail-open per
+ * command: one that cannot run, times out, or is not reached in the budget
+ * has no baseline, and its failures all count, as before. What the commands
+ * write into the tree is undone, so none of it reaches the candidate.
+ */
+export declare function makeTakeVerifyBaseline(opts?: MakeTakeVerifyBaselineOpts): (cwd: string, dirs: string[], signal?: AbortSignal, budgetOverrideMs?: number) => Promise<VerifyBaselineResult>;
 export {};
 //# sourceMappingURL=verify.d.ts.map