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

package/dist/extension/pipeline/continuation.js

@@ -34,16 +34,24 @@ export function parseContinuation(raw) {
     const obj = data;
     if (obj.version !== 1)
         return { ok: false, reason: `unknown version ${JSON.stringify(obj.version)}` };
-    const stage = obj.stageAtStop;
+    // The cloud lane's `continue.json` names the same facts `stage` and
+    // `roundsDone`; either spelling reads the same.
+    const stage = "stage" in obj ? obj.stage : obj.stageAtStop;
     if (stage !== null && !CONTINUATION_STAGES.includes(stage)) {
         return { ok: false, reason: `unknown stageAtStop ${JSON.stringify(stage)}` };
     }
-    const rounds = obj.reviewRoundsDone;
+    const rounds = "roundsDone" in obj ? obj.roundsDone : obj.reviewRoundsDone;
     if (typeof rounds !== "number" || !Number.isInteger(rounds) || rounds < 0) {
-        return { ok: false, reason: `reviewRoundsDone is not a whole number (${JSON.stringify(rounds)})` };
+        return {
+            ok: false,
+            reason: `reviewRoundsDone is not a whole number (${JSON.stringify(rounds)})`,
+        };
     }
     const priorStop = typeof obj.priorStop === "string" ? obj.priorStop.trim() : "";
-    return { ok: true, value: { stageAtStop: stage, reviewRoundsDone: rounds, priorStop } };
+    return {
+        ok: true,
+        value: { stageAtStop: stage, reviewRoundsDone: rounds, priorStop },
+    };
 }
 /** True when the earlier attempt got past implement, so the run re-enters the review loop. */
 export function continuesInLoop(continuation) {
@@ -56,27 +64,35 @@ export function continuesInLoop(continuation) {
  * continuation has no summary, so it says where the change is instead and pins
  * the same design context.
  */
-export function continuationReviewInput(continuation, mission) {
+export function continuationReviewInput(continuation, mission, committed = false) {
     const why = continuation.priorStop ? ` (${continuation.priorStop})` : "";
-    const summary = `No implement summary: this build continues an earlier attempt that stopped during its ${continuation.stageAtStop ?? "unknown"} stage${why}. ` +
-        "That attempt's change is already in the working tree as uncommitted edits on top of HEAD. " +
-        "Review the whole change against HEAD (`git diff HEAD`, plus any untracked files `git status` lists).";
+    const stopped = `this build continues an earlier attempt that stopped during its ${continuation.stageAtStop ?? "unknown"} stage${why}. `;
+    // A cloud execution starts from the attempt's pushed branch: the earlier
+    // work is in its commits, not in the working tree.
+    const summary = committed
+        ? `No implement summary: ${stopped}` +
+            "That attempt's change is committed on this branch. Review the whole change against the base commit the ticket names " +
+            "(`git diff <base>...HEAD`), plus anything `git status` lists."
+        : `No implement summary: ${stopped}` +
+            "That attempt's change is already in the working tree as uncommitted edits on top of HEAD. " +
+            "Review the whole change against HEAD (`git diff HEAD`, plus any untracked files `git status` lists).";
     const design = missionDesignContext(mission);
     return design ? `${summary}\n\n${design}` : summary;
 }
 /**
  * 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 function continuationResumePlan(continuation, ctx) {
+export function continuationResumePlan(continuation, ctx, opts = {}) {
     if (!continuesInLoop(continuation))
         return undefined;
     return {
         mode: "resume_loop",
-        round: Math.min(continuation.reviewRoundsDone + 1, MAX_REVIEW_ROUNDS),
-        reviewInput: continuationReviewInput(continuation, ctx.mission),
+        round: Math.min(continuation.reviewRoundsDone + 1, opts.maxRounds ?? MAX_REVIEW_ROUNDS),
+        reviewInput: continuationReviewInput(continuation, ctx.mission, opts.committed),
         priorRounds: [],
         ticket: ctx.ticket,
         ...(ctx.runId ? { runId: ctx.runId } : {}),

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

@@ -24,9 +24,13 @@ export declare function extractFindingsBlock(raw: string): string | null;
 /**
  * Parse a reviewer's raw output into structured findings. Tries the JSON-array
  * form first, then the fenced ```findings block, then a tolerant scan of every
- * line. Never throws; never fabricates a finding from prose.
+ * line. Never throws; never fabricates a finding from prose. `lensColumn` reads
+ * the one reviewer's per-finding lens; `lens` is then the default for a line
+ * that names none.
  */
-export declare function parseFindings(raw: string, lens?: ReviewLens): Finding[];
+export declare function parseFindings(raw: string, lens?: ReviewLens, opts?: {
+    lensColumn?: boolean;
+}): Finding[];
 /** Concatenate per-lens findings, preserving order and each lens tag. */
 export declare function unionFindings(perLens: Finding[][]): Finding[];
 /** True when this one finding blocks: Critical or High on a blocking lens. */
@@ -38,9 +42,10 @@ export declare function hasBlockingFindings(findings: Finding[]): boolean;
  * blocks, else stop 'round_cap' once the round hits MAX_REVIEW_ROUNDS, else
  * keep going. Always returns an explicit reason (no silent truncation). So a
  * second round runs only when round one found a blocker; nits, needs-person
- * findings and business-fit findings alone never start it.
+ * findings and business-fit findings alone never start it. `maxRounds` is the
+ * lane's cap (`PipelineLane.maxReviewRounds`).
  */
-export declare function shouldStop(findings: Finding[], round: number): {
+export declare function shouldStop(findings: Finding[], round: number, maxRounds?: number): {
     stop: boolean;
     reason: "clean" | "round_cap" | null;
 };

package/dist/extension/pipeline/findings.js

@@ -18,7 +18,10 @@ const SEVERITIES = ["critical", "high", "medium", "low", "needs_person"];
 const DEFAULT_LENS = "correctness";
 /** `NEEDS PERSON`, `needs-person` and `needs_person` all read as `needs_person`. */
 function normalizeSeverity(value) {
-    return value.trim().toLowerCase().replace(/[\s-]+/g, "_");
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[\s-]+/g, "_");
 }
 function isSeverity(value) {
     return SEVERITIES.includes(value);
@@ -33,14 +36,23 @@ function parseLocation(loc) {
         return { file: m[1], line: Number(m[2]) };
     return { file: trimmed };
 }
-/** Parse one `SEVERITY | file:line | message` line, or null if it is not one. */
-function parsePipeLine(line, lens) {
-    const parts = line.split("|").map((p) => p.trim());
+/**
+ * Parse one `SEVERITY | file:line | message` line, or null if it is not one.
+ * With `lensColumn` (the one reviewer of the cloud lane), a lens name after the
+ * severity (`SEVERITY | LENS | file:line | message`) tags the finding.
+ */
+function parsePipeLine(line, lens, lensColumn = false) {
+    let parts = line.split("|").map((p) => p.trim());
     if (parts.length < 2)
         return null;
     const severity = normalizeSeverity(parts[0]);
     if (!isSeverity(severity))
         return null;
+    const named = lensColumn && parts.length >= 3 ? normalizeSeverity(parts[1]) : "";
+    if (isLens(named)) {
+        lens = named;
+        parts = [parts[0], ...parts.slice(2)];
+    }
     let finding;
     if (parts.length >= 3) {
         const { file, line: lineNo } = parseLocation(parts[1]);
@@ -108,9 +120,11 @@ function isLens(value) {
 /**
  * Parse a reviewer's raw output into structured findings. Tries the JSON-array
  * form first, then the fenced ```findings block, then a tolerant scan of every
- * line. Never throws; never fabricates a finding from prose.
+ * line. Never throws; never fabricates a finding from prose. `lensColumn` reads
+ * the one reviewer's per-finding lens; `lens` is then the default for a line
+ * that names none.
  */
-export function parseFindings(raw, lens = DEFAULT_LENS) {
+export function parseFindings(raw, lens = DEFAULT_LENS, opts = {}) {
     if (!raw || !raw.trim())
         return [];
     const json = parseJsonFindings(raw, lens);
@@ -120,7 +134,7 @@ export function parseFindings(raw, lens = DEFAULT_LENS) {
     const source = block ?? raw;
     const findings = [];
     for (const line of source.split("\n")) {
-        const parsed = parsePipeLine(line, lens);
+        const parsed = parsePipeLine(line, lens, opts.lensColumn === true);
         if (parsed)
             findings.push(parsed);
     }
@@ -152,12 +166,13 @@ export function hasBlockingFindings(findings) {
  * blocks, else stop 'round_cap' once the round hits MAX_REVIEW_ROUNDS, else
  * keep going. Always returns an explicit reason (no silent truncation). So a
  * second round runs only when round one found a blocker; nits, needs-person
- * findings and business-fit findings alone never start it.
+ * findings and business-fit findings alone never start it. `maxRounds` is the
+ * lane's cap (`PipelineLane.maxReviewRounds`).
  */
-export function shouldStop(findings, round) {
+export function shouldStop(findings, round, maxRounds = MAX_REVIEW_ROUNDS) {
     if (!hasBlockingFindings(findings))
         return { stop: true, reason: "clean" };
-    if (round >= MAX_REVIEW_ROUNDS)
+    if (round >= maxRounds)
         return { stop: true, reason: "round_cap" };
     return { stop: false, reason: null };
 }

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

@@ -85,6 +85,8 @@ export interface FinishResult {
     /** Honest skip/failure notes, surfaced verbatim in the /go handoff. */
     notes: string[];
 }
+/** FINISH's own git seam, for the cloud session's reads of what it committed. */
+export declare const finishExec: WorktreeExec;
 /** `fix` when the ticket brief (or, blind, the raw arg) says bug; else `feat` (spec §3c). */
 export declare function commitType(ticket: string, ticketBrief?: string): "fix" | "feat";
 /**
@@ -93,6 +95,12 @@ export declare function commitType(ticket: string, ticketBrief?: string): "fix"
  * already carries the identifier), falling back to the raw arg. Capped.
  */
 export declare function commitTitle(ticket: string, ticketBrief?: string): string;
+/**
+ * The title a run with a plan and no ticket title commits under (the cloud
+ * session reads its ticket from a file): the line under the plan's Goal
+ * heading, else its first line of prose. Undefined when the plan has neither.
+ */
+export declare function planTitle(planText: string | undefined): string | undefined;
 /**
  * A conventional-commit scope from the run's changed paths: the package name
  * when every changed path agrees on one (`packages/<name>/…`, `apps/…`,
@@ -111,11 +119,13 @@ export declare function summarizePlan(planText: string | undefined, ticket: stri
 /**
  * The trailer's YAGNI-Verify value, derived honestly from the pipeline result:
  * `passed (<cmds>)` when the final round's verify gate ran (verify-FAILED can't
- * reach `clean` by construction), else `skipped (<reason>)`.
+ * reach `clean` by construction), else `skipped (<reason>)`. A run that did not
+ * stop `clean` (the cloud lane commits every run's work) is `not passed (<stop>)`.
  */
 export declare function verifyTrailerValue(result: {
     verifyCommand?: string;
     verifyNote?: string;
+    stopReason?: string;
 }): string;
 /** The exact provenance trailer block (spec §3c), closed by the org's commit attribution. */
 export declare function provenanceTrailer(t: TrailerInputs): string;

package/dist/extension/pipeline/finish.js

@@ -58,6 +58,8 @@ const defaultExec = (argv, cwd, signal) => new Promise((resolve, reject) => {
     // so quitting pi mid-FINISH never leaves it running in the background.
     trackChild(child);
 });
+/** FINISH's own git seam, for the cloud session's reads of what it committed. */
+export const finishExec = defaultExec;
 // ---------------------------------------------------------------------------
 // Pure message derivation
 // ---------------------------------------------------------------------------
@@ -71,12 +73,30 @@ export function commitType(ticket, ticketBrief) {
  * already carries the identifier), falling back to the raw arg. Capped.
  */
 export function commitTitle(ticket, ticketBrief) {
-    let title = ticketBrief?.split("\n").find((l) => l.trim().length > 0)?.trim() ?? ticket;
+    let title = ticketBrief
+        ?.split("\n")
+        .find((l) => l.trim().length > 0)
+        ?.trim() ?? ticket;
     const echo = `${ticket.toLowerCase()}:`;
     if (title.toLowerCase().startsWith(echo))
         title = title.slice(echo.length).trim() || ticket;
     return title.length > TITLE_MAX ? title.slice(0, TITLE_MAX).trimEnd() : title;
 }
+/**
+ * The title a run with a plan and no ticket title commits under (the cloud
+ * session reads its ticket from a file): the line under the plan's Goal
+ * heading, else its first line of prose. Undefined when the plan has neither.
+ */
+export function planTitle(planText) {
+    const lines = (planText ?? "").split("\n").map((line) => line.trim());
+    const prose = (from) => lines.slice(from).find((line) => line && !line.startsWith("#") && !line.startsWith("```"));
+    const goal = lines.findIndex((line) => /^#+\s*goal\b/i.test(line));
+    const line = (goal >= 0 ? prose(goal + 1) : undefined) ?? prose(0);
+    return (line
+        ?.replace(/^(?:[-*+]|\d+[.)])\s+/, "")
+        .replace(/`/g, "")
+        .trim() || undefined);
+}
 /**
  * A conventional-commit scope from the run's changed paths: the package name
  * when every changed path agrees on one (`packages/<name>/…`, `apps/…`,
@@ -125,9 +145,14 @@ export function summarizePlan(planText, ticket) {
 /**
  * The trailer's YAGNI-Verify value, derived honestly from the pipeline result:
  * `passed (<cmds>)` when the final round's verify gate ran (verify-FAILED can't
- * reach `clean` by construction), else `skipped (<reason>)`.
+ * reach `clean` by construction), else `skipped (<reason>)`. A run that did not
+ * stop `clean` (the cloud lane commits every run's work) is `not passed (<stop>)`.
  */
 export function verifyTrailerValue(result) {
+    if (result.stopReason && result.stopReason !== "clean") {
+        const ran = result.verifyCommand ? `; ran ${oneLine(result.verifyCommand)}` : "";
+        return `not passed (${result.stopReason}${ran})`;
+    }
     if (result.verifyCommand)
         return `passed (${oneLine(result.verifyCommand)})`;
     return `skipped (${oneLine(result.verifyNote ?? "verify did not run")})`;
@@ -204,7 +229,13 @@ export function parsePrUrl(output) {
  * delivered as the durable /go handoff, landing in permanent scrollback.
  */
 function tail(output) {
-    const t = scrubSecrets(output).trim().split("\n").slice(-3).join(" ").slice(0, NOTE_TAIL_MAX).trim();
+    const t = scrubSecrets(output)
+        .trim()
+        .split("\n")
+        .slice(-3)
+        .join(" ")
+        .slice(0, NOTE_TAIL_MAX)
+        .trim();
     return t;
 }
 /**
@@ -311,7 +342,15 @@ export async function runFinish(opts) {
             notes.push(`Committed locally; push failed: ${tail(push.output) || "git push failed"}.`);
             return result;
         }
-        const pr = await run(["gh", "pr", "create", "--title", subject, "--body", buildPrBody(summary, trailer, opts.remainingFindings, opts.prAttribution)]);
+        const pr = await run([
+            "gh",
+            "pr",
+            "create",
+            "--title",
+            subject,
+            "--body",
+            buildPrBody(summary, trailer, opts.remainingFindings, opts.prAttribution),
+        ]);
         if (pr.code !== 0) {
             notes.push(`Committed and pushed ${opts.branch}; PR creation failed: ${tail(pr.output) || "gh failed"}.`);
             return result;
@@ -327,7 +366,14 @@ export async function runFinish(opts) {
         // Belt and braces: nothing above should throw, but the invariant (§0.1)
         // outranks tidiness — a FINISH failure must never fail a clean run.
         const msg = scrubSecrets(err instanceof Error ? err.message : String(err));
-        return { committed: false, ...(opts.branch ? { branch: opts.branch } : {}), notes: [...notes, `FINISH failed: ${msg}. The run itself is still clean; the changes are left in ${opts.cwd}.`] };
+        return {
+            committed: false,
+            ...(opts.branch ? { branch: opts.branch } : {}),
+            notes: [
+                ...notes,
+                `FINISH failed: ${msg}. The run itself is still clean; the changes are left in ${opts.cwd}.`,
+            ],
+        };
     }
 }
 //# sourceMappingURL=finish.js.map

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

@@ -24,6 +24,17 @@
  * run ends at the reviewed candidate and never commits, pushes, opens a PR, or
  * reports one. The mission's own prHandoff owns all of that.
  *
+ * CLOUD (`--cloud`, the one-attempt lane; cloud.ts): the session runs the
+ * cloud lane (stages.ts `cloudLane`: plan, implement, review, fix, then verify
+ * and finish; one writer, one reviewer, four rounds) on the host's input
+ * folder beside the ticket and its env (`YAGNI_ATTEMPT_ID`, `YAGNI_EXECUTION_ID`,
+ * `YAGNI_GENERATION`, `YAGNI_MISSION_OUT_DIR`, `YAGNI_GO_STAGE_TIERS`). A fresh
+ * attempt plans and stops, writing `plan.md` and `plan.json`; a plan file
+ * starts implement; a continue file names its stage. Every execution but a
+ * plan commits its work locally on the branch the host checked out, whatever
+ * its stop, and never pushes. Its last act is `result.json`, mirrored on the
+ * last `pipeline_result` line. Mission mode below is untouched by it.
+ *
  * CONTINUATION (`--continue-file`, mission mode only): the run continues an
  * earlier attempt whose change is already in the tree as uncommitted edits. The
  * build baselines the clean base, and an attempt that stopped in review, fix or
@@ -59,13 +70,15 @@
  * cannot finish, rather than being killed partway through one (see budget.ts). Such a run gets the sandbox lane's
  * ceilings (`SANDBOX_RUN_BUDGET`), not interactive /go's.
  */
+import { snapshotWorkspace } from "./workspace.js";
+import type { WorktreeExec } from "./worktree.js";
 import { type TreeSnapshotDeps } from "./treeSnapshot.js";
 import { runPipeline as defaultRunPipeline } from "./orchestrator.js";
 import { makeRunVerify, type VerifyBaselineResult } from "./verify.js";
 import { type RunBudget } from "./budget.js";
 import type { Finding, JsonEvent, ModelTier, PipelineStage, StageId, StageTag, StageUsage, StopReason } from "./types.js";
 /** One-line usage copy, shared by every argument error. */
-export declare const HEADLESS_GO_USAGE = "Usage: yagni go --headless --ticket-file <path> [--plan-file <path>] [--memo-file <path>] [--continue-file <path>] [--run-id <id>] [--cwd <path>] [--json]";
+export declare const HEADLESS_GO_USAGE = "Usage: yagni go --headless [--cloud] --ticket-file <path> [--plan-file <path>] [--memo-file <path>] [--continue-file <path>] [--run-id <id>] [--cwd <path>] [--json]";
 /**
  * Exit codes. `verified` is deliberately narrow: only a `clean` stop means the
  * run produced a reviewed candidate, so a round_cap / no_changes / failed run
@@ -80,6 +93,8 @@ export declare const HEADLESS_GO_EXIT: {
 export interface HeadlessGoArgs {
     headless: boolean;
     json: boolean;
+    /** The one-attempt lane's session (cloud.ts): its own stage list and outputs. */
+    cloud: boolean;
     ticketFile?: string;
     planFile?: string;
     memoFile?: string;
@@ -184,6 +199,10 @@ export interface HeadlessGoDeps {
     logger?: (event: string, data?: unknown) => void;
     /** Mission runs' working-tree snapshots (see treeSnapshot.ts); injected in tests. */
     startTreeSnapshots?: (cwd: string, snapshotDeps: TreeSnapshotDeps) => () => Promise<void>;
+    /** A cloud session's git seam: its commit and the reads behind `result.json`. Defaults to FINISH's. */
+    exec?: WorktreeExec;
+    /** A cloud session's tree reads (HEAD and porcelain status). Defaults to a real `git`. */
+    snapshotWorkspace?: typeof snapshotWorkspace;
 }
 /**
  * Parse the argv remainder after `go`. Accepts both `--flag value` and