@yagni-app/code-staging 0.0.0 → 0.1.0-staging.997.1

package/dist/extension/pipeline/invocation.js

@@ -0,0 +1,64 @@
+/**
+ * PURE child-invocation builder — the direct analogue of yagni-code-cli's
+ * `buildLaunch` (no spawn, no fs).
+ *
+ * `buildStageInvocation` produces the per-stage pi PASSTHROUGH argv exactly as
+ * the subagent example assembles it (runSingleAgent L294-330):
+ *   --mode json -p --no-session --model <tier> --tools <csv>
+ *   --append-system-prompt <file> 'Task: <rendered>'
+ *
+ * `groundedChildArgv` prepends the grounding pi-args the yagni-code launcher
+ * would otherwise add (`-e <self> --provider yagni`) because v1 spawns pi
+ * directly, NOT the yagni-code bin, to avoid a yagni-code-cli ↔ pi-extension-yagni
+ * circular dependency (token / base-url / agent-dir are inherited from the
+ * parent's env, not re-built here).
+ *
+ * `renderTemplate` does the {ticket}/{previous} substitution, mirroring the
+ * chain's `step.task.replace(/{previous}/g, …)`.
+ */
+/** Fill {ticket}/{previous}; an absent var renders as empty string. */
+export function renderTemplate(tmpl, vars) {
+    return tmpl
+        .replace(/\{ticket\}/g, vars.ticket ?? "")
+        .replace(/\{previous\}/g, vars.previous ?? "");
+}
+/**
+ * Build the pi passthrough argv for one stage (from `--mode` onward). The
+ * positional rendered prompt is always the last arg, prefixed `Task: `.
+ */
+export function buildStageInvocation(stage, ctx) {
+    const task = renderTemplate(stage.taskTemplate, {
+        ticket: ctx.ticket,
+        previous: ctx.previous,
+    });
+    return [
+        "--mode",
+        "json",
+        "-p",
+        "--no-session",
+        "--model",
+        stage.model,
+        "--tools",
+        stage.tools.join(","),
+        "--append-system-prompt",
+        ctx.promptFilePath,
+        `Task: ${task}`,
+    ];
+}
+/**
+ * Prepend the grounding args (the pi cli script, our extension, and the default
+ * `yagni` provider) before a stage passthrough. Mirrors buildLaunch's
+ * `userChoseProvider` guard so a passthrough that already chose a provider is
+ * left untouched.
+ */
+export function groundedChildArgv(stageArgv, opts) {
+    const userChoseProvider = stageArgv.includes("--provider");
+    return [
+        opts.piCli,
+        "-e",
+        opts.extensionPath,
+        ...(userChoseProvider ? [] : ["--provider", "yagni"]),
+        ...stageArgv,
+    ];
+}
+//# sourceMappingURL=invocation.js.map

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

@@ -0,0 +1,131 @@
+/**
+ * The pipeline driver.
+ *
+ * Sequences `runStage` for the build stages (map → plan → implement), threading
+ * each stage's `finalOutput` into the next as `{previous}` (mirrors the subagent
+ * example's chain). Then it runs the bounded review→fix LOOP: each round fans the
+ * review stage out across the 3 lenses (parallel, bounded by MAX_CONCURRENCY),
+ * parses each lens with `parseFindings` (with ONE cheap format-recovery re-ask
+ * for a healthy lens that broke the findings contract — spec §3e), unions them,
+ * and asks the PURE `shouldStop`. If not stopped it runs the fix stage against
+ * ONLY the blocking findings, increments the round, and re-reviews.
+ *
+ * ALL branching is delegated to the pure `shouldStop` / `parseFindings`; the
+ * orchestrator is just sequencing + an injectable `runStage`, so it is
+ * unit-tested with a fake `runStage`. The explicit stop reason is always logged
+ * (spec §7.3 — no silent truncation). An early build-stage failure short-circuits
+ * the pipeline by throwing (the /go handler catches and reports it). In the
+ * review→fix loop, a user abort or a crashed review/fix child is surfaced as an
+ * honest `aborted` / `failed` stopReason rather than being mis-read as `clean`
+ * (an aborted/crashed child has empty output, which otherwise parses to zero
+ * findings — i.e. a false "reviewed and clean").
+ */
+import { type RunBudget } from "./budget.js";
+import { runStage as defaultRunStage } from "./runner.js";
+import { type VerifyOutcome } from "./verify.js";
+import { snapshotWorkspace as defaultSnapshotWorkspace } from "./workspace.js";
+import { type CheckpointStore, type PipelineStage, type JsonEvent, type PipelineProgress, type PipelineResult, type ResumePlan, type StageId, type StageResult, type StageTag } from "./types.js";
+export interface RunPipelineDeps {
+    cwd: string;
+    signal?: AbortSignal;
+    runStage?: typeof defaultRunStage;
+    /**
+     * P4 deterministic verify gate (default = repo test/typecheck via bash, wrapped
+     * in R1's timeout). Runs each review round so a fix that breaks the build is
+     * caught; a non-zero exit becomes `critical` Findings fed through the same
+     * review -> fix loop, so the loop cannot stop `clean` while the build is broken.
+     * Fail-open: when no command is detectable or it cannot run, it adds no findings
+     * and records an honest note. Injected as a whole for unit testing.
+     */
+    runVerify?: (cwd: string, signal?: AbortSignal, baselinePaths?: string[]) => Promise<VerifyOutcome>;
+    /**
+     * The REAL ticket brief (verbatim title + description) resolved from the ticket
+     * reference, injected into every stage's `{ticket}` prompt slot so the agents plan
+     * on the actual ticket, not the bare "YAG-234". Absent => the raw arg is used (the
+     * honest blind fallback). Kept off the checkpoint records, which keep the raw ref.
+     */
+    ticketBrief?: string;
+    /**
+     * R3-b run-level budget / turn ceiling. Defaults to generous safety bounds
+     * (DEFAULT_RUN_BUDGET); when aggregate usage crosses one the run stops honestly
+     * with `budget_exceeded` rather than spending on. Tunable per lane / per caller.
+     */
+    budget?: RunBudget;
+    /**
+     * M6 eval: the stage list to run. Defaults to selectStages("full"); the blind
+     * lane passes a grounding-tool-stripped copy (see eval.ts#blindStages).
+     */
+    stages?: PipelineStage[];
+    /**
+     * M6 eval: when false, run the BLIND lane (grounding-free personas via
+     * personaBody's grounded flag, paired with grounding-stripped stages). Defaults
+     * true, so every real /go is grounded; nothing but the eval ever sets it false.
+     */
+    grounded?: boolean;
+    /** Environment inherited by spawned child stages. Defaults to the parent process env. */
+    childEnv?: NodeJS.ProcessEnv;
+    /**
+     * The no-op guard's git seam (injected for unit tests). Captures the repo
+     * HEAD + porcelain status so the orchestrator can tell whether the build half
+     * actually produced a change. Defaults to a real `git` shell-out.
+     */
+    snapshotWorkspace?: typeof defaultSnapshotWorkspace;
+    /** Structured progress signal driving the live feed's stage + header state. */
+    onProgress?: (p: PipelineProgress) => void;
+    /**
+     * Live tap on each child's NDJSON events, already attributed to the emitting
+     * stage (and review lens / round). The review fan-out runs lenses in parallel,
+     * so each lens gets its OWN tag closure to keep interleaved events attributed.
+     */
+    onEvent?: (ev: JsonEvent, tag: StageTag) => void;
+    logger?: (event: string, data?: unknown) => void;
+    /**
+     * Optional pipeline-stage boundary hook. Fired at the start of every stage and
+     * at the finish of each (review rounds also carry the round + finding count).
+     * Used by /go to stream a live map→plan→implement→review→fix tracker onto the
+     * Work page. Optional + fail-soft at the call site, so existing callers/tests
+     * are unaffected and a slow/failing recorder never blocks the pipeline.
+     *
+     * `output` carries a stage's `finalOutput` ONLY on the plan FINISH boundary, so
+     * /go can record the plan onto the work item without streaming every stage's
+     * full text. It is absent on every other boundary.
+     */
+    onStage?: (s: {
+        stage: StageId;
+        phase: "start" | "finish";
+        round?: number;
+        findings?: number;
+        output?: string;
+    }) => void;
+    /**
+     * Optional, fail-soft durable journal seam (spec: 2026-06-29-go-resilience).
+     * When present, the orchestrator appends a checkpoint at each completed
+     * boundary (run_start / build_done / round_done) so an interrupted /go can be
+     * resumed. Like `onStage`, it is optional + side-effect-only and stays OFF the
+     * `onProgress` channel, so absent it is byte-identical to today.
+     */
+    checkpoint?: CheckpointStore;
+    /**
+     * When the caller's `planResume` decided the run is resumable, this carries the
+     * loop re-entry point (round + reviewInput + reconstructed prior rounds). The
+     * orchestrator then SKIPS the build half entirely (the diff is already in the
+     * tree) and re-enters the bounded review→fix loop at `resumeFrom.round`.
+     */
+    resumeFrom?: ResumePlan;
+    /** Identity stamped onto every checkpoint record (run key + backend handle). */
+    checkpointMeta?: {
+        sessionKey: string;
+        runId?: string;
+        workItemId?: string;
+        repo?: string;
+        branch?: string;
+    };
+}
+/** Error thrown when a build stage fails; carries the partial run for the caller. */
+export declare class PipelineStageError extends Error {
+    readonly stageId: string;
+    readonly partial: StageResult[];
+    constructor(stageId: string, message: string, partial: StageResult[]);
+}
+export declare function runPipeline(ticket: string, deps: RunPipelineDeps): Promise<PipelineResult>;
+//# sourceMappingURL=orchestrator.d.ts.map