@yagni-app/code-staging 1.2.6-staging.1952.1 → 1.2.6-staging.1958.1

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

@@ -0,0 +1,205 @@
+/**
+ * The one-attempt lane's session contract (spec decisions 2 and 3): what
+ * `yagni go --headless --cloud` reads besides its flags, and the `result.json`
+ * it leaves for the host.
+ *
+ * The host (PR A's `startSessionActivity`) writes the input folder beside the
+ * ticket file and sets the env below; the session reads them and writes its
+ * outputs under `YAGNI_MISSION_OUT_DIR`. The session commits locally and never
+ * pushes: the host collects the commits as a bundle and pushes as the GitHub
+ * App. `result.json` is the agent's report, written as the session's last act
+ * (`completeCloudSession`) and mirrored on the last `pipeline_result` line of
+ * the NDJSON stream. headlessGo.ts runs the pipeline between the two halves
+ * here: `prepareCloudLane` before it, `completeCloudSession` after it.
+ *
+ * The extension does not depend on `@yagni/shared`, where the host's parser
+ * lives (`packages/shared/src/attempts.ts`): the two meet only at this JSON.
+ */
+import type { ContinuationStage } from "./continuation.js";
+import type { VerifyCheckRun, VerifyOutcome } from "./verify.js";
+import type { WorktreeExec } from "./worktree.js";
+import type { Finding, PipelineLane, PipelineResult, StopReason } from "./types.js";
+/** Set on every stage child of a cloud session, so its prompt describes the cloud sandbox. */
+export declare const CLOUD_SESSION_ENV = "YAGNI_GO_CLOUD";
+/** Where the session writes `plan.md`, `plan.json` and `result.json`. */
+export declare const MISSION_OUT_DIR_ENV = "YAGNI_MISSION_OUT_DIR";
+/** Reeve's persona body, beside the ticket, which the plan stage runs with when present. */
+export declare const PLAN_PERSONA_FILE_NAME = "plan-persona.md";
+export declare const RESULT_FILE_NAME = "result.json";
+export declare const PLAN_MARKDOWN_FILE_NAME = "plan.md";
+export declare const PLAN_JSON_FILE_NAME = "plan.json";
+/** Which stage this execution started at: the attempt's record of it. */
+export type CloudStage = "plan" | "implement" | "fix" | "verify";
+/** The execution's identity, echoed verbatim from the host's env. The session never invents it. */
+export interface CloudIdentity {
+    attemptId: string;
+    executionId: string;
+    generation: number;
+}
+/** The identity and the output folder, or what is missing. */
+export declare function readCloudEnv(env: NodeJS.ProcessEnv): {
+    identity: CloudIdentity;
+    outDir: string;
+} | {
+    problem: string;
+};
+/**
+ * The stage this execution starts at: a fresh attempt plans; a continue file
+ * names its stage; a plan file alone starts implement. A continue file that
+ * names review (the legacy spelling of a stop in the loop) re-enters the loop
+ * as a fix execution does.
+ */
+export declare function cloudStartStage(continuation: {
+    stageAtStop: ContinuationStage | null;
+} | undefined, hasPlan: boolean): CloudStage;
+/**
+ * The lane a cloud execution runs and the stage it starts at: the host's
+ * per-stage tiers applied, and Reeve's persona (`plan-persona.md`) on the plan
+ * stage when the host sent one. The host wrote every file here, so one the
+ * session cannot use is the host's to fix, never a reason to plan a ticket
+ * the attempt is building: that is a `problem`, and nothing runs.
+ */
+export declare function prepareCloudLane(input: {
+    inputDir: string;
+    env: NodeJS.ProcessEnv;
+    continueFile?: string;
+    continuation?: {
+        stageAtStop: ContinuationStage | null;
+    };
+    hasPlan: boolean;
+    readFile: (path: string) => string;
+    writeErr: (line: string) => void;
+}): {
+    stage: CloudStage;
+    lane: PipelineLane;
+} | {
+    problem: string;
+};
+/** The stop reasons `result.json` carries. */
+export type ResultStopReason = "clean" | "round_cap" | "no_changes" | "budget_exceeded" | "failed" | "aborted";
+/**
+ * The pipeline's stop as the result names it. `partial` (a write stage cut off
+ * after it began editing) is `failed` here; its change is still committed, and
+ * the result's notes say so.
+ */
+export declare function resultStopReason(stop: StopReason): ResultStopReason;
+/** One finding the session's own review left open. */
+export interface OpenFinding {
+    file?: string;
+    line?: number;
+    message: string;
+    severity: "blocking" | "advisory";
+}
+/** `result.json`, version 1. */
+export interface AttemptResult extends CloudIdentity {
+    version: 1;
+    stage: CloudStage;
+    headSha: string;
+    branch: string | null;
+    baseSha: string;
+    stopReason: ResultStopReason;
+    rounds: number;
+    checks: VerifyCheckRun[];
+    findingsOpen: OpenFinding[];
+    filesChanged: string[];
+    commits: string[];
+    notes: string[];
+    blockingKey: string | null;
+    usage: {
+        tokens: number;
+        costMillicents: number;
+        byStage: Array<{
+            stage: string;
+            tokens: number;
+            costMillicents: number;
+        }>;
+    };
+}
+/** The findings the result reports, blocking first. */
+export declare function openFindings(findings: readonly Finding[]): OpenFinding[];
+/**
+ * What the review's blocking findings are, as one key two executions can
+ * compare (the no-progress rule, #2669), or null when none blocks. The same
+ * fold as `blockingFindingsKey` in the backend's
+ * integrations/e2b/missionPipelineStream.ts: each finding's file and the head
+ * of its message without any output tail, lowercased; repeats count, and so
+ * does the blocking total. A change there is a change here.
+ */
+export declare function blockingFindingsKey(findings: readonly Finding[]): string | null;
+/** The run's spend, in all and by stage. */
+export declare function resultUsage(result: Pick<PipelineResult, "stages" | "rounds">): AttemptResult["usage"];
+/** What git says about the execution's work: its head and what it committed since `baseSha`. */
+export interface GitFacts {
+    headSha: string;
+    commits: string[];
+    filesChanged: string[];
+    /** One line per git read that failed, so a report of nothing committed is never a silent guess. */
+    notes: string[];
+}
+/**
+ * The branch the session commits on: the one the host checked out before it
+ * started (`yagni/<ticket>`). The session never names or creates a branch.
+ * Null on a detached HEAD.
+ */
+export declare function currentBranch(cwd: string, exec: WorktreeExec): Promise<string | null>;
+/** The ticket a branch named `yagni/<ticket>` is for, for the commit's provenance trailer. */
+export declare function ticketOfBranch(branch: string | null): string | undefined;
+/**
+ * Whether the branch carries a commit this attempt made, in this execution or
+ * an earlier one: each carries the attempt's `YAGNI-Run` trailer (finish.ts).
+ * Null when git cannot say.
+ */
+export declare function attemptCommitted(cwd: string, exec: WorktreeExec, attemptId: string): Promise<boolean | null>;
+/** Read the execution's work off git. Never throws: a read that fails is a note. */
+export declare function gitFacts(cwd: string, exec: WorktreeExec, baseSha: string): Promise<GitFacts>;
+/** What the session's last act needs, gathered once the pipeline has stopped. */
+export interface CloudCompletion {
+    identity: CloudIdentity;
+    outDir: string;
+    stage: CloudStage;
+    cwd: string;
+    /** The commit the execution started from. */
+    baseSha: string;
+    /** The tree's pre-run dirt, never committed. */
+    preRunDirt: string[];
+    /** The approved plan: the commit's title and summary. */
+    plan?: string;
+    /** Review rounds earlier executions finished. */
+    roundsDone: number;
+    /** The gate's last verdict, and the tree it judged; absent when it never ran. */
+    lastVerify?: {
+        outcome: VerifyOutcome;
+        tree: string;
+    };
+    /** The tree as the gate's verdict is compared against it. */
+    tree: () => Promise<string>;
+    /** The gate taken again on the final tree, or null when the run has no time left for it. */
+    reverify?: () => Promise<VerifyOutcome | null>;
+    /** The secret and binary scan of what the execution added, or null when git cannot say. */
+    scan: () => Promise<Finding[] | null>;
+    /** The plan's package folders, read off its text, when its block names none. */
+    planPaths: (planText: string) => string[];
+    exec: WorktreeExec;
+    writeFile: (path: string, text: string) => void;
+}
+/**
+ * The cloud session's last act. A plan execution writes `plan.md` and
+ * `plan.json`. Any other runs the secret and binary scan on what it added,
+ * whatever its stop (it runs no model, so no deadline skips it), takes the
+ * checks again when the gate's last verdict judged an earlier tree, and
+ * commits its work locally on the branch the host checked out, so nothing is
+ * lost when the sandbox goes. `result.json` is written last; the caller mirrors
+ * it on the stream. `ok` is a written plan, or a clean candidate whose branch
+ * carries this attempt's committed work, from this execution or an earlier
+ * one: a clean stop with nothing committed at all delivered nothing.
+ */
+export declare function completeCloudSession(c: CloudCompletion, ran: {
+    result: PipelineResult;
+} | {
+    error: string;
+    partial: PipelineResult["stages"];
+}): Promise<{
+    attempt: AttemptResult;
+    ok: boolean;
+}>;
+//# sourceMappingURL=cloud.d.ts.map

package/dist/extension/pipeline/cloud.js

@@ -0,0 +1,382 @@
+/**
+ * The one-attempt lane's session contract (spec decisions 2 and 3): what
+ * `yagni go --headless --cloud` reads besides its flags, and the `result.json`
+ * it leaves for the host.
+ *
+ * The host (PR A's `startSessionActivity`) writes the input folder beside the
+ * ticket file and sets the env below; the session reads them and writes its
+ * outputs under `YAGNI_MISSION_OUT_DIR`. The session commits locally and never
+ * pushes: the host collects the commits as a bundle and pushes as the GitHub
+ * App. `result.json` is the agent's report, written as the session's last act
+ * (`completeCloudSession`) and mirrored on the last `pipeline_result` line of
+ * the NDJSON stream. headlessGo.ts runs the pipeline between the two halves
+ * here: `prepareCloudLane` before it, `completeCloudSession` after it.
+ *
+ * The extension does not depend on `@yagni/shared`, where the host's parser
+ * lives (`packages/shared/src/attempts.ts`): the two meet only at this JSON.
+ */
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+import { isBlockingFinding } from "./findings.js";
+import { planTitle, runFinish, verifyTrailerValue } from "./finish.js";
+import { buildPlanFile, planMarkdown } from "./planOutput.js";
+import { cloudLane } from "./stages.js";
+import { applyStageTiers, parseStageTiers, STAGE_TIERS_ENV } from "./tierCap.js";
+/** Set on every stage child of a cloud session, so its prompt describes the cloud sandbox. */
+export const CLOUD_SESSION_ENV = "YAGNI_GO_CLOUD";
+/** Where the session writes `plan.md`, `plan.json` and `result.json`. */
+export const MISSION_OUT_DIR_ENV = "YAGNI_MISSION_OUT_DIR";
+/** Reeve's persona body, beside the ticket, which the plan stage runs with when present. */
+export const PLAN_PERSONA_FILE_NAME = "plan-persona.md";
+export const RESULT_FILE_NAME = "result.json";
+export const PLAN_MARKDOWN_FILE_NAME = "plan.md";
+export const PLAN_JSON_FILE_NAME = "plan.json";
+/** The identity and the output folder, or what is missing. */
+export function readCloudEnv(env) {
+    const attemptId = env.YAGNI_ATTEMPT_ID?.trim();
+    const executionId = env.YAGNI_EXECUTION_ID?.trim();
+    const rawGeneration = env.YAGNI_GENERATION?.trim();
+    const generation = rawGeneration && /^\d+$/.test(rawGeneration) ? Number(rawGeneration) : Number.NaN;
+    const outDir = env[MISSION_OUT_DIR_ENV]?.trim();
+    const missing = [
+        ...(attemptId ? [] : ["YAGNI_ATTEMPT_ID"]),
+        ...(executionId ? [] : ["YAGNI_EXECUTION_ID"]),
+        ...(Number.isSafeInteger(generation) ? [] : ["YAGNI_GENERATION"]),
+        ...(outDir ? [] : [MISSION_OUT_DIR_ENV]),
+    ];
+    if (missing.length > 0 || !attemptId || !executionId || !outDir) {
+        return { problem: `A cloud session needs ${missing.join(", ")} from the host.` };
+    }
+    return { identity: { attemptId, executionId, generation }, outDir };
+}
+/**
+ * The stage this execution starts at: a fresh attempt plans; a continue file
+ * names its stage; a plan file alone starts implement. A continue file that
+ * names review (the legacy spelling of a stop in the loop) re-enters the loop
+ * as a fix execution does.
+ */
+export function cloudStartStage(continuation, hasPlan) {
+    if (continuation) {
+        const stage = continuation.stageAtStop;
+        if (stage === "review" || stage === "fix")
+            return "fix";
+        if (stage === "verify")
+            return "verify";
+        return "implement";
+    }
+    return hasPlan ? "implement" : "plan";
+}
+/**
+ * The lane a cloud execution runs and the stage it starts at: the host's
+ * per-stage tiers applied, and Reeve's persona (`plan-persona.md`) on the plan
+ * stage when the host sent one. The host wrote every file here, so one the
+ * session cannot use is the host's to fix, never a reason to plan a ticket
+ * the attempt is building: that is a `problem`, and nothing runs.
+ */
+export function prepareCloudLane(input) {
+    const stage = cloudStartStage(input.continuation, input.hasPlan);
+    if (input.continueFile && !input.continuation) {
+        return { problem: `A cloud session cannot run on the continue file ${input.continueFile}.` };
+    }
+    if (stage === "implement" && !input.hasPlan) {
+        return { problem: "A cloud implement execution needs the approved plan (--plan-file)." };
+    }
+    const { tiers, ignored } = parseStageTiers(input.env[STAGE_TIERS_ENV]);
+    if (ignored.length > 0) {
+        input.writeErr(`Ignoring ${STAGE_TIERS_ENV} entries that name no stage or tier: ${ignored.join(", ")}.`);
+    }
+    let persona = "";
+    const personaPath = join(input.inputDir, PLAN_PERSONA_FILE_NAME);
+    try {
+        persona = input.readFile(personaPath).trim();
+    }
+    catch (err) {
+        const code = err?.code;
+        if (code !== "ENOENT") {
+            input.writeErr(`Could not read ${personaPath} (${err instanceof Error ? err.message : String(err)}); the plan stage runs on its default persona.`);
+        }
+    }
+    const base = cloudLane(input.inputDir);
+    return {
+        stage,
+        lane: {
+            ...base,
+            stages: applyStageTiers(base.stages, tiers).map((s) => s.id === "plan" && persona ? { ...s, persona } : s),
+        },
+    };
+}
+/**
+ * The pipeline's stop as the result names it. `partial` (a write stage cut off
+ * after it began editing) is `failed` here; its change is still committed, and
+ * the result's notes say so.
+ */
+export function resultStopReason(stop) {
+    return stop === "partial" ? "failed" : stop;
+}
+const MAX_OPEN_FINDINGS = 50;
+const MAX_FINDING_MESSAGE = 1000;
+/** The findings the result reports, blocking first. */
+export function openFindings(findings) {
+    return [...findings]
+        .sort((a, b) => Number(isBlockingFinding(b)) - Number(isBlockingFinding(a)))
+        .slice(0, MAX_OPEN_FINDINGS)
+        .map((finding) => ({
+        ...(finding.file ? { file: finding.file } : {}),
+        ...(finding.line !== undefined ? { line: finding.line } : {}),
+        message: finding.message.slice(0, MAX_FINDING_MESSAGE),
+        severity: isBlockingFinding(finding) ? "blocking" : "advisory",
+    }));
+}
+/**
+ * What the review's blocking findings are, as one key two executions can
+ * compare (the no-progress rule, #2669), or null when none blocks. The same
+ * fold as `blockingFindingsKey` in the backend's
+ * integrations/e2b/missionPipelineStream.ts: each finding's file and the head
+ * of its message without any output tail, lowercased; repeats count, and so
+ * does the blocking total. A change there is a change here.
+ */
+export function blockingFindingsKey(findings) {
+    const parts = findings
+        .filter(isBlockingFinding)
+        .map((finding) => {
+        const head = finding.message.split(/\bOutput tail\b|\n/)[0] ?? "";
+        const words = head.toLowerCase().replace(/\s+/g, " ").trim().slice(0, 160);
+        return `${finding.file ?? ""}\u0000${words}`;
+    })
+        .sort();
+    if (parts.length === 0)
+        return null;
+    return createHash("sha256")
+        .update(`${parts.length}\u0001${parts.join("\u0001")}`)
+        .digest("hex")
+        .slice(0, 32);
+}
+const tokensOf = (usage) => usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+/** Dollars, as the model proxy reports them, to millicents. */
+const millicents = (dollars) => Math.round(dollars * 100_000);
+/** The run's spend, in all and by stage. */
+export function resultUsage(result) {
+    const byStage = new Map();
+    const rows = [...result.stages, ...result.rounds.flatMap((round) => round.lensResults)];
+    for (const row of rows) {
+        const entry = byStage.get(row.stageId) ?? { tokens: 0, cost: 0 };
+        entry.tokens += tokensOf(row.usage);
+        entry.cost += row.usage.cost;
+        byStage.set(row.stageId, entry);
+    }
+    const stages = [...byStage].map(([stage, entry]) => ({
+        stage,
+        tokens: entry.tokens,
+        costMillicents: millicents(entry.cost),
+    }));
+    return {
+        tokens: stages.reduce((sum, entry) => sum + entry.tokens, 0),
+        costMillicents: millicents([...byStage.values()].reduce((sum, entry) => sum + entry.cost, 0)),
+        byStage: stages,
+    };
+}
+/** One git read: its lines, or null when it failed (a non-zero exit or a spawn error). */
+async function gitLines(cwd, exec, args) {
+    const result = await exec(["git", ...args], cwd).catch(() => ({
+        code: -1,
+        output: "",
+    }));
+    if (result.code !== 0)
+        return null;
+    return result.output
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+}
+/**
+ * The branch the session commits on: the one the host checked out before it
+ * started (`yagni/<ticket>`). The session never names or creates a branch.
+ * Null on a detached HEAD.
+ */
+export async function currentBranch(cwd, exec) {
+    return (await gitLines(cwd, exec, ["branch", "--show-current"]))?.[0] ?? null;
+}
+/** The ticket a branch named `yagni/<ticket>` is for, for the commit's provenance trailer. */
+export function ticketOfBranch(branch) {
+    const ticket = branch?.startsWith("yagni/") ? branch.slice("yagni/".length).trim() : "";
+    return ticket || undefined;
+}
+/**
+ * Whether the branch carries a commit this attempt made, in this execution or
+ * an earlier one: each carries the attempt's `YAGNI-Run` trailer (finish.ts).
+ * Null when git cannot say.
+ */
+export async function attemptCommitted(cwd, exec, attemptId) {
+    const found = await gitLines(cwd, exec, [
+        "log",
+        "-1",
+        "--format=%H",
+        "--fixed-strings",
+        `--grep=YAGNI-Run: ${attemptId}`,
+    ]);
+    return found === null ? null : found.length > 0;
+}
+/** Read the execution's work off git. Never throws: a read that fails is a note. */
+export async function gitFacts(cwd, exec, baseSha) {
+    const notes = [];
+    const read = async (args) => {
+        const found = await gitLines(cwd, exec, args);
+        if (found === null)
+            notes.push(`git ${args.join(" ")} failed, so the result cannot say what it lists.`);
+        return found ?? [];
+    };
+    const head = (await read(["rev-parse", "HEAD"]))[0] || baseSha;
+    if (!baseSha || head === baseSha)
+        return { headSha: head, commits: [], filesChanged: [], notes };
+    return {
+        headSha: head,
+        commits: await read(["rev-list", "--reverse", `${baseSha}..${head}`]),
+        filesChanged: await read(["diff", "--name-only", baseSha, head]),
+        notes,
+    };
+}
+/** A finding as the result dedupes it: where it is and what it says. */
+function findingKey(finding) {
+    return `${finding.file ?? ""}:${finding.line ?? ""}:${finding.message}`;
+}
+/**
+ * The cloud session's last act. A plan execution writes `plan.md` and
+ * `plan.json`. Any other runs the secret and binary scan on what it added,
+ * whatever its stop (it runs no model, so no deadline skips it), takes the
+ * checks again when the gate's last verdict judged an earlier tree, and
+ * commits its work locally on the branch the host checked out, so nothing is
+ * lost when the sandbox goes. `result.json` is written last; the caller mirrors
+ * it on the stream. `ok` is a written plan, or a clean candidate whose branch
+ * carries this attempt's committed work, from this execution or an earlier
+ * one: a clean stop with nothing committed at all delivered nothing.
+ */
+export async function completeCloudSession(c, ran) {
+    const notes = "error" in ran ? [ran.error] : [];
+    const writeOut = (name, text) => {
+        try {
+            c.writeFile(join(c.outDir, name), text);
+            return true;
+        }
+        catch (err) {
+            notes.push(`${name} could not be written: ${err instanceof Error ? err.message : String(err)}`);
+            return false;
+        }
+    };
+    const result = "result" in ran ? ran.result : undefined;
+    let stop = result?.stopReason ?? "failed";
+    if (stop === "partial")
+        notes.push("A build stage stopped partway; its change is committed as it was left.");
+    if (result?.verifyNote)
+        notes.push(result.verifyNote);
+    let outputsWritten = true;
+    let committed = false;
+    let checks = c.lastVerify?.outcome;
+    const extra = [];
+    const branch = await currentBranch(c.cwd, c.exec);
+    if (c.stage === "plan") {
+        const planText = result?.plan ?? "";
+        const plan = buildPlanFile(planText, () => c.planPaths(planText));
+        if (planText.trim() && !plan.found) {
+            notes.push("The plan carried no plan-json block, even after one re-ask: plan.json holds no questions.");
+        }
+        if (planText.trim()) {
+            outputsWritten =
+                writeOut(PLAN_MARKDOWN_FILE_NAME, planMarkdown(planText)) &&
+                    writeOut(PLAN_JSON_FILE_NAME, `${JSON.stringify(plan.file, null, 2)}\n`);
+        }
+    }
+    else {
+        const hits = await c.scan().catch(() => null);
+        if (hits === null) {
+            notes.push("The secret and binary scan could not read the change before the commit; the host still scans it.");
+        }
+        else {
+            extra.push(...hits);
+        }
+        if (c.reverify && c.lastVerify?.tree !== (await c.tree())) {
+            try {
+                const again = await c.reverify();
+                if (again === null) {
+                    notes.push("The checks were not run on the final tree: the run had no time left for them.");
+                }
+                else {
+                    checks = again;
+                    extra.push(...again.findings);
+                    if (again.reason)
+                        notes.push(again.reason);
+                }
+            }
+            catch (err) {
+                notes.push(`The checks could not run on the final tree: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        // The loop judged the tree it last verified; what the final scan or checks
+        // found blocking in the tree being committed means it did not stop clean.
+        if (stop === "clean" && extra.some(isBlockingFinding)) {
+            stop = "failed";
+            notes.push("The review loop stopped clean, but the final scan or checks found a blocker in what is committed.");
+        }
+        const title = c.plan ? planTitle(c.plan) : undefined;
+        const finish = await runFinish({
+            cwd: c.cwd,
+            worktreeMode: true,
+            hereBaseline: "unknown",
+            ticket: ticketOfBranch(branch) ?? c.identity.attemptId,
+            ...(c.plan ? { planText: c.plan } : {}),
+            ...(title ? { ticketBrief: title } : {}),
+            runId: c.identity.attemptId,
+            verify: verifyTrailerValue({
+                stopReason: stop,
+                ...(checks?.ran && checks.command ? { verifyCommand: checks.command } : {}),
+                ...(checks?.reason ? { verifyNote: checks.reason } : {}),
+            }),
+            decisionsRecorded: result?.decisionsRecorded ?? 0,
+            rounds: result?.rounds.length ?? 0,
+            openPr: false,
+            ...(c.preRunDirt.length > 0 ? { baselinePaths: c.preRunDirt } : {}),
+            exec: c.exec,
+        });
+        committed = finish.committed;
+        notes.push(...finish.notes);
+    }
+    let delivered = outputsWritten;
+    if (c.stage !== "plan") {
+        const onBranch = committed || (await attemptCommitted(c.cwd, c.exec, c.identity.attemptId));
+        if (onBranch === null) {
+            notes.push("git log failed, so the result cannot say whether the branch carries this attempt's work.");
+        }
+        delivered = onBranch === true;
+    }
+    const facts = await gitFacts(c.cwd, c.exec, c.baseSha);
+    notes.push(...facts.notes);
+    // What the final scan and checks found beside the last round's findings; a
+    // finding both report is listed once.
+    const seen = new Set((result?.findings ?? []).map(findingKey));
+    const findings = [...(result?.findings ?? [])];
+    for (const finding of extra) {
+        if (seen.has(findingKey(finding)))
+            continue;
+        seen.add(findingKey(finding));
+        findings.push(finding);
+    }
+    const attempt = {
+        version: 1,
+        ...c.identity,
+        stage: c.stage,
+        headSha: c.stage === "plan" ? c.baseSha : facts.headSha,
+        branch,
+        baseSha: c.baseSha,
+        stopReason: outputsWritten ? resultStopReason(stop) : "failed",
+        rounds: result?.rounds.at(-1)?.round ?? c.roundsDone,
+        checks: checks?.checks ?? [],
+        findingsOpen: openFindings(findings),
+        filesChanged: c.stage === "plan" ? [] : facts.filesChanged,
+        commits: c.stage === "plan" ? [] : facts.commits,
+        notes,
+        blockingKey: blockingFindingsKey(findings),
+        usage: resultUsage(result ?? { stages: "partial" in ran ? ran.partial : [], rounds: [] }),
+    };
+    const resultWritten = writeOut(RESULT_FILE_NAME, `${JSON.stringify(attempt, null, 2)}\n`);
+    return { attempt, ok: resultWritten && attempt.stopReason === "clean" && delivered };
+}
+//# sourceMappingURL=cloud.js.map

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

@@ -46,16 +46,20 @@ export declare function continuesInLoop(continuation: ContinuationInputs): boole
  * continuation has no summary, so it says where the change is instead and pins
  * the same design context.
  */
-export declare function continuationReviewInput(continuation: ContinuationInputs, mission: MissionInputs | undefined): string;
+export declare function continuationReviewInput(continuation: ContinuationInputs, mission: MissionInputs | undefined, committed?: boolean): string;
 /**
  * The resume plan that re-enters the review→fix loop for a continuation that
  * stopped in review, fix or verify; undefined when implement must run again.
- * The round continues the earlier attempt's count, capped at the last round so
- * a continuation always gets one review.
+ * The round continues the earlier attempt's count, capped at the lane's last
+ * round so a continuation always gets one review. `committed` is the cloud
+ * lane's resume, whose earlier work is on the branch.
  */
 export declare function continuationResumePlan(continuation: ContinuationInputs, ctx: {
     ticket: string;
     runId?: string;
     mission?: MissionInputs;
+}, opts?: {
+    maxRounds?: number;
+    committed?: boolean;
 }): ResumePlan | undefined;
 //# sourceMappingURL=continuation.d.ts.map