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

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

@@ -37,6 +37,8 @@ export declare const PERSONA_BODIES: Record<string, string>;
  * measurement.
  */
 export declare const BLIND_PERSONA_BODIES: Record<string, string>;
+/** The findings contract with the lens column the one reviewer writes (`parseFindings` `lensColumn`). */
+export declare const ONE_REVIEWER_FINDINGS_CONTRACT: string;
 /**
  * The per-workstream clause appended to a fan-out builder's (or fixer's) persona:
  * the files it owns, what its siblings own, and the shared-tree discipline. With
@@ -46,9 +48,12 @@ export declare const BLIND_PERSONA_BODIES: Record<string, string>;
 export declare function builderPersonaClause(workstream?: PartitionWorkstream, siblings?: PartitionWorkstream[]): string;
 /**
  * Resolve the system-prompt body for a stage. For non-review stages this is the
- * role body; for the review stage it appends the lens-specific clause and the
- * required findings output contract so the reviewer's output parses. A stage
- * carrying a `personaClause` (the fan-out builders) gets it appended last.
+ * role body; for the review stage it appends the lens-specific clause (or, with
+ * no lens, the one-reviewer clause covering all three) and the required
+ * findings output contract so the reviewer's output parses. A stage carrying a
+ * `personaClause` (the fan-out builders) gets it appended last, and one
+ * carrying a `persona` (the cloud plan stage's host persona) runs with that in
+ * place of its agent's body.
  *
  * `grounded` defaults true (every real /go stage). The M6 eval passes
  * `grounded: false` to select the grounding-free bodies + lens clauses for the

package/dist/extension/pipeline/personas.js

@@ -62,6 +62,15 @@ Complete the task fully — do not gold-plate, but do not leave it half-done. Fi
 Budget discipline: you have a hard output budget, and a plan that gets cut off mid-thought is worth less than a short plan that ships. Explore only until you can name the files and the steps — do not read broadly for completeness, and do not re-verify what you have already established. Aim for 5-10 short steps; the worker fills small gaps from the ticket. When in doubt, write the plan NOW.
 
 Keep it concrete; the worker executes it verbatim.`;
+/**
+ * The cloud plan stage's default body, used when the host sent no
+ * `plan-persona.md`. Its output contract rides the stage's task, so a host
+ * persona that replaces this body keeps it.
+ */
+const CLOUD_PLANNER_ROLE = `You are a planning specialist. You plan one ticket in the repository checked out in your working directory: it is installed, and its commands run. Your plan is what a builder executes, and your questions are what a person answers before anything is built. You do not change files. A fact you can settle by reading or running code is settled, not asked.`;
+const CLOUD_PLANNER_GROUNDING = `You are grounded. Call ask_yagni before inferring a convention or making any organization- or codebase-specific assumption. To check a fact outside this repository (what is deployed, what the data holds, what a ticket or page says), call team_read with the Team's connected tools before you ask a person.`;
+const CLOUD_PLANNER_FINISH = `Complete the task fully: do not gold-plate, but do not leave it half-done. Finish the job in ONE turn: do not end your turn on an interstitial like "now let me check X". Your FINAL message MUST be the complete plan in the format the task gives. Explore until you can name the files and the steps, then write the plan.`;
+const CLOUD_PLANNER_BODY = [CLOUD_PLANNER_ROLE, CLOUD_PLANNER_GROUNDING, CLOUD_PLANNER_FINISH].join("\n\n");
 const WORKER_BODY = `You are a worker with full capabilities, operating in an isolated context to implement a plan. Work autonomously and use the tools as needed.
 
 You are grounded. Call ask_yagni before guessing about anything organization- or codebase-specific. To check a fact outside this repository (what is deployed, what the data holds, what a ticket or page says), call team_read with the Team's connected tools before you assume or stop. Treat a confirmed answer as settled; when an answer is an unverified assumption or an inference and your change leans on it, say so in your Notes so the reviewer knows what to check. When the plan did not settle a consequential call you are forced to make (product intent, architecture, or a team convention another engineer would need to know), call record_decision so the company's decision corpus captures it and the next agent inherits the call instead of re-litigating it. Recorded decisions are shared across the whole organization, so the bar is consequence: never record taste, styling, naming, formatting, or a restatement of the code change; when in doubt, do not record. When ask_yagni reports no recorded position, follow its instruction and record the assumption you proceed on only if it meets that bar.
@@ -224,6 +233,7 @@ Bad (too long): Investigate and fix the login button not responding on mobile de
 export const PERSONA_BODIES = {
     scout: SCOUT_BODY,
     planner: PLANNER_BODY,
+    cloud_planner: CLOUD_PLANNER_BODY,
     worker: WORKER_BODY,
     reviewer: REVIEWER_BODY,
     advisor: ADVISOR_BODY,
@@ -320,6 +330,7 @@ export const BLIND_PERSONA_BODIES = {
     scout: SCOUT_BLIND,
     prefix: PREFIX_BODY, // grounding-free by construction (no grounding text at all)
     planner: PLANNER_BLIND,
+    cloud_planner: [CLOUD_PLANNER_ROLE, CLOUD_PLANNER_FINISH].join("\n\n"),
     worker: WORKER_BLIND,
     reviewer: REVIEWER_BLIND,
     advisor: ADVISOR_BLIND,
@@ -350,6 +361,21 @@ SEVERITY | file:line | message
 SEVERITY is one of: critical, high, medium, low, needs_person. needs_person means only a person can do it (a named sign-off, an account, a credential, a call outside the code); it does not block, and the person sees it on the pull request. Use \`file:line\` when you can point to a location; otherwise give a short location or omit it. Put one finding per line and nothing else inside the block. If you found no problems, emit an empty \`\`\`findings block. Only critical and high findings block the change.
 
 Be terse. Do not narrate your process, restate the diff, or quote code back at length — spend your output on the findings themselves, at most a few short paragraphs before the block. Cap the block at the 12 most important findings, most severe first; a review cut off by its own length limit helps nobody.`;
+/**
+ * A review stage with no lens is the round's only reviewer (the cloud lane):
+ * it judges through all three angles and names each finding's angle, so the
+ * full lane's rule holds per finding (a business-fit finding never blocks).
+ */
+function oneReviewerClause(clauses) {
+    return [
+        "You are this change's only reviewer, so judge it through all three angles below.",
+        clauses.correctness,
+        clauses.business_fit,
+        clauses.does_it_hold,
+    ].join("\n");
+}
+/** The findings contract with the lens column the one reviewer writes (`parseFindings` `lensColumn`). */
+export const ONE_REVIEWER_FINDINGS_CONTRACT = FINDINGS_CONTRACT.replace("SEVERITY | file:line | message", "SEVERITY | LENS | file:line | message").replace("Only critical and high findings block the change.", "LENS is the angle the finding is about: correctness, business_fit or does_it_hold. Only critical and high findings on correctness or does_it_hold block the change; a business_fit finding is left for the pull request's review.");
 /**
  * The blind lens clauses (M6): correctness + does_it_hold are not grounding
  * specific, so they are reused verbatim; business_fit drops review_business_match
@@ -383,7 +409,10 @@ export function builderPersonaClause(workstream, siblings = []) {
         return SHARED_TREE_RULES;
     const parts = [
         `You are building ONE workstream of a plan that was split across parallel builders: "${workstream.name}".`,
-        ["Files you own (path prefixes; a directory covers its whole subtree):", ...workstream.files.map((f) => `- ${f}`)].join("\n"),
+        [
+            "Files you own (path prefixes; a directory covers its whole subtree):",
+            ...workstream.files.map((f) => `- ${f}`),
+        ].join("\n"),
         "Create new files only inside the paths you own. Edit nothing outside them.",
     ];
     if (siblings.length > 0) {
@@ -397,9 +426,12 @@ export function builderPersonaClause(workstream, siblings = []) {
 }
 /**
  * Resolve the system-prompt body for a stage. For non-review stages this is the
- * role body; for the review stage it appends the lens-specific clause and the
- * required findings output contract so the reviewer's output parses. A stage
- * carrying a `personaClause` (the fan-out builders) gets it appended last.
+ * role body; for the review stage it appends the lens-specific clause (or, with
+ * no lens, the one-reviewer clause covering all three) and the required
+ * findings output contract so the reviewer's output parses. A stage carrying a
+ * `personaClause` (the fan-out builders) gets it appended last, and one
+ * carrying a `persona` (the cloud plan stage's host persona) runs with that in
+ * place of its agent's body.
  *
  * `grounded` defaults true (every real /go stage). The M6 eval passes
  * `grounded: false` to select the grounding-free bodies + lens clauses for the
@@ -408,13 +440,16 @@ export function builderPersonaClause(workstream, siblings = []) {
 export function personaBody(stage, opts = {}) {
     const grounded = opts.grounded !== false;
     const bodies = grounded ? PERSONA_BODIES : BLIND_PERSONA_BODIES;
-    const base = bodies[stage.agent];
+    const base = stage.persona?.trim() || bodies[stage.agent];
     if (!base)
         throw new Error(`No persona body for agent "${stage.agent}"`);
     const parts = [base];
     if (stage.id === "review") {
-        const lens = stage.lens ?? "correctness";
-        parts.push((grounded ? LENS_CLAUSES : BLIND_LENS_CLAUSES)[lens], FINDINGS_CONTRACT);
+        const clauses = grounded ? LENS_CLAUSES : BLIND_LENS_CLAUSES;
+        if (stage.lens)
+            parts.push(clauses[stage.lens], FINDINGS_CONTRACT);
+        else
+            parts.push(oneReviewerClause(clauses), ONE_REVIEWER_FINDINGS_CONTRACT);
     }
     if (stage.personaClause?.trim())
         parts.push(stage.personaClause.trim());

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

@@ -0,0 +1,42 @@
+/**
+ * The cloud plan stage's outputs (one-attempt lane, spec decision 4): the plan
+ * as `plan.md` and its ```plan-json block as `plan.json`, the two files the
+ * host collects and takes to the plan gate. The block's contract is
+ * `PLAN_JSON_CONTRACT` in stages.ts.
+ *
+ * The session only shapes the file. The questions pass through as the model
+ * wrote them: the host normalizes, settles and grounds them with the same
+ * functions it runs on its own plan (`groundSessionPlan` in the backend's
+ * builder/planQuestions.ts), so there is one normalizer, on the host.
+ */
+/** `plan.json`, version 1, as the host reads it. */
+export interface PlanFile {
+    version: 1;
+    /** Each the shape `packages/shared/src/planQuestions.ts` reads, unchanged. */
+    questions: unknown[];
+    decisionsCited: Array<{
+        id: string;
+        why: string;
+    }>;
+    checks: Array<{
+        name: string;
+        command: string;
+        cwd: string;
+    }>;
+    /** The package folders the plan touches, repo-relative. */
+    paths: string[];
+}
+/** The plan's ```plan-json block as an object, or null when it has none that parses. */
+export declare function extractPlanJson(text: string): Record<string, unknown> | null;
+/** The plan for a person to read: the text without its machine-readable block. */
+export declare function planMarkdown(text: string): string;
+/**
+ * `plan.json` from the plan's text. `found` is false when the plan carried no
+ * block that parses: the file then holds no questions, and `paths` falls back
+ * to the package folders read off the plan's own text.
+ */
+export declare function buildPlanFile(planText: string, fallbackPaths: () => string[]): {
+    file: PlanFile;
+    found: boolean;
+};
+//# sourceMappingURL=planOutput.d.ts.map

package/dist/extension/pipeline/planOutput.js

@@ -0,0 +1,94 @@
+/**
+ * The cloud plan stage's outputs (one-attempt lane, spec decision 4): the plan
+ * as `plan.md` and its ```plan-json block as `plan.json`, the two files the
+ * host collects and takes to the plan gate. The block's contract is
+ * `PLAN_JSON_CONTRACT` in stages.ts.
+ *
+ * The session only shapes the file. The questions pass through as the model
+ * wrote them: the host normalizes, settles and grounds them with the same
+ * functions it runs on its own plan (`groundSessionPlan` in the backend's
+ * builder/planQuestions.ts), so there is one normalizer, on the host.
+ */
+/** Matches every ```plan-json block; the last one that reads as an object wins. */
+const PLAN_JSON_BLOCK = /```plan-json[^\n]*\n([\s\S]*?)```/gi;
+/** The host keeps at most this many questions (`MAX_QUESTIONS`); the rest are noise. */
+const MAX_PLAN_QUESTIONS = 20;
+const MAX_LIST = 40;
+const MAX_TEXT = 500;
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** The plan's ```plan-json block as an object, or null when it has none that parses. */
+export function extractPlanJson(text) {
+    let found = null;
+    for (const match of text.matchAll(PLAN_JSON_BLOCK)) {
+        try {
+            const parsed = JSON.parse(match[1] ?? "");
+            if (isRecord(parsed))
+                found = parsed;
+        }
+        catch {
+            // A block that does not parse is skipped; an earlier or later one may.
+        }
+    }
+    return found;
+}
+/** The plan for a person to read: the text without its machine-readable block. */
+export function planMarkdown(text) {
+    return `${text.replace(PLAN_JSON_BLOCK, "").trim()}\n`;
+}
+function text(value, max = MAX_TEXT) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed ? trimmed.slice(0, max) : null;
+}
+function list(value) {
+    return Array.isArray(value) ? value : [];
+}
+/** A repo-relative folder the plan names, or null when it is not one. */
+function repoPath(value) {
+    const path = text(value)
+        ?.replace(/^\.\/+/, "")
+        .replace(/\/+$/, "");
+    if (!path || path.startsWith("/") || path.split("/").includes(".."))
+        return null;
+    return path;
+}
+/**
+ * `plan.json` from the plan's text. `found` is false when the plan carried no
+ * block that parses: the file then holds no questions, and `paths` falls back
+ * to the package folders read off the plan's own text.
+ */
+export function buildPlanFile(planText, fallbackPaths) {
+    const block = extractPlanJson(planText);
+    const questions = list(block?.questions)
+        .filter((entry) => typeof entry === "string" || isRecord(entry))
+        .slice(0, MAX_PLAN_QUESTIONS);
+    const decisionsCited = [];
+    for (const entry of list(block?.decisionsCited)) {
+        const id = isRecord(entry) ? text(entry.id, 100) : null;
+        if (!id || decisionsCited.some((cited) => cited.id === id))
+            continue;
+        decisionsCited.push({ id, why: (isRecord(entry) && text(entry.why)) || "" });
+        if (decisionsCited.length === MAX_LIST)
+            break;
+    }
+    const checks = [];
+    for (const entry of list(block?.checks)) {
+        const command = isRecord(entry) ? text(entry.command) : null;
+        if (!isRecord(entry) || !command)
+            continue;
+        checks.push({
+            name: text(entry.name, 100) ?? command.slice(0, 100),
+            command,
+            cwd: repoPath(entry.cwd) ?? ".",
+        });
+        if (checks.length === MAX_LIST)
+            break;
+    }
+    const named = list(block?.paths)
+        .map(repoPath)
+        .filter((path) => path !== null);
+    const paths = [...new Set(named.length > 0 ? named : fallbackPaths())].slice(0, MAX_LIST);
+    return { file: { version: 1, questions, decisionsCited, checks, paths }, found: block !== null };
+}
+//# sourceMappingURL=planOutput.js.map

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

@@ -27,7 +27,7 @@
  * rail, and the tier cap treat the whole diamond as today's single stage.
  */
 import type { PartitionWorkstream } from "./fanout.js";
-import type { PipelineStage, ReviewLens } from "./types.js";
+import { type ModelTier, type PipelineLane, type PipelineStage, type ReviewLens } from "./types.js";
 /** The three adversarial review angles, fanned out per round (spec §3). */
 export declare const REVIEW_LENSES: ReviewLens[];
 /**
@@ -48,6 +48,34 @@ export declare function reviewStage(): PipelineStage;
  * the identity selector and the extension point for v2 complexity-lanes.
  */
 export declare function selectStages(_lane?: "full"): PipelineStage[];
+/** Interactive /go and mission builds: the diamond, three lenses, two rounds. */
+export declare const FULL_LANE: PipelineLane;
+/** The cloud lane's cap: one reviewer per round, so more rounds than the full lane. */
+export declare const CLOUD_MAX_REVIEW_ROUNDS = 4;
+/** The tool every cloud plan stage calls for the decisions a person already made on this repository. */
+export declare const DECISIONS_READ_TOOL = "yagni_decisions_read_for_repository";
+/**
+ * The plan contract the cloud plan stage ends on. The pipeline writes
+ * `plan.md` (the plan without this block) and `plan.json` (this block) for
+ * the host, which grounds the questions exactly as it grounds its own plan's
+ * (`groundSessionPlan` in the backend's builder/planQuestions.ts). Each
+ * question is the shape `packages/shared/src/planQuestions.ts` reads.
+ */
+export declare const PLAN_JSON_CONTRACT: string;
+/**
+ * The one-attempt lane's session (`yagni go --headless --cloud`): plan,
+ * implement, review, fix, then verify and finish, which run no model. One
+ * writer, one reviewer per round, up to four rounds. Execution runs on the
+ * strongest rung the contract allows, never a Flash model (the host's
+ * `YAGNI_GO_STAGE_TIERS` may move any stage; see tierCap.ts). The plan stage
+ * ends its own run: implement starts in a later run, on the approved plan.
+ */
+export declare function cloudLane(inputDir: string): PipelineLane;
+/**
+ * The plan contract re-ask: the same cheap format-recovery pass the review
+ * lenses get, pointed at the ```plan-json block. One attempt only.
+ */
+export declare function planJsonReaskStage(plan: PipelineStage): PipelineStage;
 /**
  * A fix round's map (fixRound.ts): the same scout on the same tier, limited to
  * the files the pull request touched and the files the round's findings name.
@@ -56,11 +84,12 @@ export declare function selectStages(_lane?: "full"): PipelineStage[];
  */
 export declare function fixRoundMapStage(files: readonly string[], base?: PipelineStage): PipelineStage;
 /**
- * A fix round's builder (fixRound.ts): ONE writer at the standard tier, no
- * partitioner, addressing the round's findings from the ticket against the map
- * brief. The approved plan rides along as pinned context, never as work to redo.
+ * A fix round's builder (fixRound.ts): ONE writer at the lane's fix tier
+ * (`standard` on the full lane), no partitioner, addressing the round's
+ * findings from the ticket against the map brief. The approved plan rides
+ * along as pinned context, never as work to redo.
  */
-export declare function fixRoundImplementStage(base?: PipelineStage): PipelineStage;
+export declare function fixRoundImplementStage(base?: PipelineStage, model?: ModelTier): PipelineStage;
 /**
  * The partitioner's caller label. Deliberately a `go:*` caller and never
  * `subagent:*`: the server clamps `subagent:*` callers to `advanced`, which would

package/dist/extension/pipeline/stages.js

@@ -28,6 +28,7 @@
  */
 import { sanitizeCallerSegment } from "../config.js";
 import { builderPersonaClause } from "./personas.js";
+import { MAX_REVIEW_ROUNDS, } from "./types.js";
 /** The three adversarial review angles, fanned out per round (spec §3). */
 export const REVIEW_LENSES = ["correctness", "business_fit", "does_it_hold"];
 /**
@@ -43,7 +44,18 @@ export const REQUIRED_LENSES = ["correctness"];
 /** Read-only recon + grounding tools shared by scout and reviewer. */
 const READ_TOOLS = ["read", "grep", "find", "ls", "bash", "prototype_read"];
 /** Full write tools for the worker stages. */
-const WRITE_TOOLS = ["read", "write", "edit", "bash", "grep", "find", "ls", "prototype_read", "prototype_verification", "prototype_verify"];
+const WRITE_TOOLS = [
+    "read",
+    "write",
+    "edit",
+    "bash",
+    "grep",
+    "find",
+    "ls",
+    "prototype_read",
+    "prototype_verification",
+    "prototype_verify",
+];
 const TICKET_CONTEXT = "Follow the approved plan and its explicit constraints, including approved answers. " +
     "Prior summaries and review findings do not authorize expanding scope or publication " +
     "permissions. Report conflicts requiring a scope change for approval.\n\n" +
@@ -112,6 +124,121 @@ export function reviewStage() {
 export function selectStages(_lane = "full") {
     return PIPELINE_V1;
 }
+/** Interactive /go and mission builds: the diamond, three lenses, two rounds. */
+export const FULL_LANE = {
+    stages: PIPELINE_V1,
+    reviewLenses: REVIEW_LENSES,
+    maxReviewRounds: MAX_REVIEW_ROUNDS,
+    fanout: true,
+    stopAfterPlan: false,
+    skillsEveryStage: false,
+};
+/** The cloud lane's cap: one reviewer per round, so more rounds than the full lane. */
+export const CLOUD_MAX_REVIEW_ROUNDS = 4;
+/** The tool every cloud plan stage calls for the decisions a person already made on this repository. */
+export const DECISIONS_READ_TOOL = "yagni_decisions_read_for_repository";
+/**
+ * The plan contract the cloud plan stage ends on. The pipeline writes
+ * `plan.md` (the plan without this block) and `plan.json` (this block) for
+ * the host, which grounds the questions exactly as it grounds its own plan's
+ * (`groundSessionPlan` in the backend's builder/planQuestions.ts). Each
+ * question is the shape `packages/shared/src/planQuestions.ts` reads.
+ */
+export const PLAN_JSON_CONTRACT = "End your answer with a fenced ```plan-json block and nothing after it:\n" +
+    "```plan-json\n" +
+    "{\n" +
+    '  "questions": [{"text": "...", "kind": "fact|decision", "oneWay": false, ' +
+    '"recommendation": {"answer": "...", "why": "...", "planChange": {"addFiles": ["path"], ' +
+    '"addSteps": [{"title": "...", "description": "..."}], "editSteps": [{"step": 1, "description": "..."}], ' +
+    '"addChecks": ["command"], "addAcceptanceCriteria": ["..."]}}, ' +
+    '"alternatives": [{"answer": "...", "why": "...", "planChange": {}}], ' +
+    '"checked": [{"status": "checked|not_checked", "text": "..."}]}],\n' +
+    '  "decisionsCited": [{"id": "<the decision id the read returned>", "why": "one line"}],\n' +
+    '  "checks": [{"name": "lint", "command": "pnpm lint", "cwd": "apps/web"}],\n' +
+    '  "paths": ["apps/web"]\n' +
+    "}\n" +
+    "```\n" +
+    "Rules the host enforces, so getting them wrong loses the question:\n" +
+    '- "kind" is "fact" when the answer could be looked up and "decision" when it is a person\'s call. ' +
+    'A decision you would make yourself carries your recommendation and is stated, not asked; mark "oneWay": true only when it cannot be undone.\n' +
+    '- On a fact, "checked" says in at most 4 short lines what you read or ran for it and what it showed, and what you could not read. ' +
+    "A fact whose every answer plans the same work (no option carries a planChange) is stated as your assumption, not asked.\n" +
+    "- At most two alternatives per question. A planChange only adds or rewords; it never removes.\n" +
+    '- "checks" are the commands that prove the change, each run from "cwd" (repo-relative, "." for the root). ' +
+    '"paths" are the package folders the plan touches.\n' +
+    '- "decisionsCited" lists only decisions the read returned that the plan relies on. Omit what you do not use.';
+/**
+ * The cloud plan stage's task: the input folder the host wrote, read first,
+ * then a plan proven on the installed checkout. `inputDir` is the folder the
+ * ticket file sits in.
+ */
+function cloudPlanTask(inputDir) {
+    const at = (file) => `${inputDir.replace(/\/+$/, "")}/${file}`;
+    return ("Plan this ticket on the repository checked out in your working directory. It is installed and its " +
+        "commands run. Nothing is built until the plan is approved, so change nothing in the repository.\n\n" +
+        "Read first:\n" +
+        `- ${at("ticket.md")}: the ticket and the evidence behind it. Open every image it names with the read tool.\n` +
+        `- ${at("design.md")} and ${at("images")}: the linked design and its frames, when they exist.\n` +
+        `- ${at("memo.md")}: what runs in this repository.\n` +
+        `- ${at("checks.json")}: the repository's checks, and which already fail on the unchanged code.\n` +
+        `- ${at("playbook.md")}: the Team's planning rules, when it exists. Always follow them.\n` +
+        `- ${at("plan-line.md")}: this Team's instructions for planning, when it exists.\n\n` +
+        "Prove facts by running code here (a check, a test, a script) before you state what the code does. " +
+        "When the work depends on another repository the ticket's Other repositories section lists, clone it " +
+        "read-only on demand with `git clone --filter=blob:none --depth 1` into ~/context/<repo> and read it there.\n\n" +
+        `Call team_read with tool "${DECISIONS_READ_TOOL}" before you ask a person anything: a question an earlier ` +
+        "decision on this repository already answers is not a question. Cite the decisions the plan relies on.\n\n" +
+        "When the change shows in a page, plan a render check the build runs (open the page in the sandbox's " +
+        "browser and take a screenshot) instead of asking a person to look at it.\n\n" +
+        "Write the plan as ## Goal (one sentence), ## Plan (numbered steps, each naming the file or function), " +
+        "## Files to modify / create, ## Checks and ## Risks.\n\n" +
+        `${PLAN_JSON_CONTRACT}\n\n` +
+        "Ticket:\n{ticket}");
+}
+/**
+ * The one-attempt lane's session (`yagni go --headless --cloud`): plan,
+ * implement, review, fix, then verify and finish, which run no model. One
+ * writer, one reviewer per round, up to four rounds. Execution runs on the
+ * strongest rung the contract allows, never a Flash model (the host's
+ * `YAGNI_GO_STAGE_TIERS` may move any stage; see tierCap.ts). The plan stage
+ * ends its own run: implement starts in a later run, on the approved plan.
+ */
+export function cloudLane(inputDir) {
+    const fix = PIPELINE_V1.find((s) => s.id === "fix");
+    if (!fix)
+        throw new Error("PIPELINE_V1 is missing the fix stage");
+    return {
+        stages: [
+            {
+                id: "plan",
+                agent: "cloud_planner",
+                model: "peak",
+                tools: ["read", "grep", "find", "ls", "bash", "ask_yagni", "team_read", "prototype_read"],
+                taskTemplate: cloudPlanTask(inputDir),
+            },
+            { ...implementStage(), model: "advanced" },
+            reviewStage(),
+            { ...fix, model: "advanced" },
+        ],
+        reviewLenses: [],
+        maxReviewRounds: CLOUD_MAX_REVIEW_ROUNDS,
+        fanout: false,
+        stopAfterPlan: true,
+        skillsEveryStage: true,
+    };
+}
+/**
+ * The plan contract re-ask: the same cheap format-recovery pass the review
+ * lenses get, pointed at the ```plan-json block. One attempt only.
+ */
+export function planJsonReaskStage(plan) {
+    return {
+        ...plan,
+        model: "efficient",
+        tools: ["read"],
+        taskTemplate: "Re-emit ONLY the ```plan-json block for the plan you just wrote, and nothing else:\n{previous}",
+    };
+}
 /** The single map stage, as the lane defines it. */
 function mapStage() {
     const stage = PIPELINE_V1.find((s) => s.id === "map");
@@ -139,14 +266,15 @@ export function fixRoundMapStage(files, base = mapStage()) {
     };
 }
 /**
- * A fix round's builder (fixRound.ts): ONE writer at the standard tier, no
- * partitioner, addressing the round's findings from the ticket against the map
- * brief. The approved plan rides along as pinned context, never as work to redo.
+ * A fix round's builder (fixRound.ts): ONE writer at the lane's fix tier
+ * (`standard` on the full lane), no partitioner, addressing the round's
+ * findings from the ticket against the map brief. The approved plan rides
+ * along as pinned context, never as work to redo.
  */
-export function fixRoundImplementStage(base = implementStage()) {
+export function fixRoundImplementStage(base = implementStage(), model = "standard") {
     return {
         ...base,
-        model: "standard",
+        model,
         taskTemplate: TICKET_CONTEXT +
             "This is a fix round on an open pull request. The approved plan is already built on this " +
             "branch: do not re-plan it or rebuild it. Address every finding the ticket lists for this " +
@@ -195,7 +323,8 @@ function repoContextSection(ctx) {
     if (brief)
         sections.push(`Repo map (from this run's map stage):\n${brief}`);
     if (memo) {
-        sections.push("Repo context (cached scoping memo; this run entered at implement, so no map stage ran):\n" + memo);
+        sections.push("Repo context (cached scoping memo; this run entered at implement, so no map stage ran):\n" +
+            memo);
     }
     if (sections.length > 0)
         return sections.join("\n\n");

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

@@ -15,7 +15,7 @@
  * A cap only ever lowers a tier: naming a cap ABOVE a stage's own tier never
  * promotes it (the pipeline's routing is the judgment; the cap is a budget).
  */
-import type { ModelTier } from "./types.js";
+import type { ModelTier, PipelineStage } from "./types.js";
 /** The documented env var. Eval/smoke lanes only; unset everywhere else. */
 export declare const TIER_CAP_ENV = "YAGNI_GO_TIER_CAP";
 /**
@@ -29,4 +29,25 @@ export declare function parseTierCap(raw: string | undefined): ModelTier | undef
 export declare function clampTier(tier: ModelTier, cap: ModelTier | undefined): ModelTier;
 /** Resolve the run's cap from an environment (the child env, or process.env). */
 export declare function resolveTierCap(env: NodeJS.ProcessEnv): ModelTier | undefined;
+/**
+ * The host's per-stage tiers for a cloud session (spec decision 7): a JSON map
+ * `{ "plan": "peak", "implement": "advanced", "review": "peak", "fix": "advanced" }`
+ * the backend resolves per workspace (`resolveStageTiers` in the backend's
+ * llm/stageTiers.ts). A stage the map leaves out keeps its compiled tier;
+ * verify runs no model. The cap above still clamps the result.
+ */
+export declare const STAGE_TIERS_ENV = "YAGNI_GO_STAGE_TIERS";
+/** The stages the host may move. */
+export type TieredStage = "plan" | "implement" | "review" | "fix";
+/**
+ * Parse the env map. Unset or empty is no map. A value that is not a JSON
+ * object, or an entry that names an unknown stage or tier, is ignored and
+ * named in `ignored`, so a typo never moves a stage and the run says so.
+ */
+export declare function parseStageTiers(raw: string | undefined): {
+    tiers: Partial<Record<TieredStage, ModelTier>>;
+    ignored: string[];
+};
+/** The stages with the map's tiers applied; a stage the map leaves out is unchanged. */
+export declare function applyStageTiers(stages: readonly PipelineStage[], tiers: Partial<Record<TieredStage, ModelTier>>): PipelineStage[];
 //# sourceMappingURL=tierCap.d.ts.map

package/dist/extension/pipeline/tierCap.js

@@ -42,7 +42,9 @@ export function parseTierCap(raw) {
     const normalized = raw?.trim().toLowerCase();
     if (!normalized)
         return undefined;
-    return CAPPABLE.includes(normalized) ? normalized : undefined;
+    return CAPPABLE.includes(normalized)
+        ? normalized
+        : undefined;
 }
 /** The effective tier for a stage under a cap: never above it, never promoted. */
 export function clampTier(tier, cap) {
@@ -54,4 +56,49 @@ export function clampTier(tier, cap) {
 export function resolveTierCap(env) {
     return parseTierCap(env[TIER_CAP_ENV]);
 }
+/**
+ * The host's per-stage tiers for a cloud session (spec decision 7): a JSON map
+ * `{ "plan": "peak", "implement": "advanced", "review": "peak", "fix": "advanced" }`
+ * the backend resolves per workspace (`resolveStageTiers` in the backend's
+ * llm/stageTiers.ts). A stage the map leaves out keeps its compiled tier;
+ * verify runs no model. The cap above still clamps the result.
+ */
+export const STAGE_TIERS_ENV = "YAGNI_GO_STAGE_TIERS";
+const TIERED_STAGES = ["plan", "implement", "review", "fix"];
+/**
+ * Parse the env map. Unset or empty is no map. A value that is not a JSON
+ * object, or an entry that names an unknown stage or tier, is ignored and
+ * named in `ignored`, so a typo never moves a stage and the run says so.
+ */
+export function parseStageTiers(raw) {
+    const text = raw?.trim();
+    if (!text)
+        return { tiers: {}, ignored: [] };
+    let data;
+    try {
+        data = JSON.parse(text);
+    }
+    catch {
+        return { tiers: {}, ignored: [text] };
+    }
+    if (!data || typeof data !== "object" || Array.isArray(data))
+        return { tiers: {}, ignored: [text] };
+    const tiers = {};
+    const ignored = [];
+    for (const [stage, value] of Object.entries(data)) {
+        const tier = typeof value === "string" ? parseTierCap(value) : undefined;
+        if (TIERED_STAGES.includes(stage) && tier)
+            tiers[stage] = tier;
+        else
+            ignored.push(`${stage}=${JSON.stringify(value)}`);
+    }
+    return { tiers, ignored };
+}
+/** The stages with the map's tiers applied; a stage the map leaves out is unchanged. */
+export function applyStageTiers(stages, tiers) {
+    return stages.map((stage) => {
+        const tier = tiers[stage.id];
+        return tier ? { ...stage, model: tier } : stage;
+    });
+}
 //# sourceMappingURL=tierCap.js.map