@yagni-app/code-staging 1.2.11-staging.2122.1 → 1.2.12-staging.2137.1

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

@@ -71,6 +71,7 @@
  * ceilings (`SANDBOX_RUN_BUDGET`), not interactive /go's.
  */
 import { measureOnBaseTree } from "./baseTree.js";
+import { runSessionTurn as defaultRunSessionTurn } from "./sessionLane.js";
 import { snapshotWorkspace } from "./workspace.js";
 import type { WorktreeExec } from "./worktree.js";
 import { type TreeSnapshotDeps } from "./treeSnapshot.js";
@@ -79,7 +80,7 @@ import { baseTargets, makeMeasureOnBase, makeRunVerify } 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 [--cloud] --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] [--session] --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
@@ -96,6 +97,11 @@ export interface HeadlessGoArgs {
     json: boolean;
     /** The one-attempt lane's session (cloud.ts): its own stage list and outputs. */
     cloud: boolean;
+    /**
+     * The session lane (`sessionLane.ts`, with `--cloud`): one turn of the run's
+     * one session in place of the stage graph, with the same outputs.
+     */
+    session: boolean;
     ticketFile?: string;
     planFile?: string;
     memoFile?: string;
@@ -210,6 +216,8 @@ export interface HeadlessGoDeps {
     exec?: WorktreeExec;
     /** A cloud session's tree reads (HEAD and porcelain status). Defaults to a real `git`. */
     snapshotWorkspace?: typeof snapshotWorkspace;
+    /** The session lane's turn (`--session`). Defaults to the real one; injected in tests. */
+    runSessionTurn?: typeof defaultRunSessionTurn;
 }
 /**
  * Parse the argv remainder after `go`. Accepts both `--flag value` and

package/dist/extension/pipeline/headlessGo.js

@@ -75,6 +75,7 @@ import { dirname, join, relative } from "node:path";
 import { baseCommitOf, BaseTreeRestoreError, measureOnBaseTree, pathsCommittedSince, } from "./baseTree.js";
 import { CLOUD_SESSION_ENV, completeCloudSession, prepareCloudLane, readCloudEnv, RESULT_FILE_NAME, unbuiltCloudResult, } from "./cloud.js";
 import { scanChange } from "./changeScan.js";
+import { runSessionTurn as defaultRunSessionTurn } from "./sessionLane.js";
 import { continuationResumePlan, parseContinuation, } from "./continuation.js";
 import { finishExec } from "./finish.js";
 import { snapshotWorkspace } from "./workspace.js";
@@ -93,7 +94,7 @@ import { codeStateHome } from "../stateHome.js";
 import { parseTierCap, TIER_CAP_ENV } from "./tierCap.js";
 import { parsePipelineTimeLeft, PIPELINE_TIME_LEFT_ENV, SANDBOX_RUN_BUDGET, } from "./budget.js";
 /** One-line usage copy, shared by every argument error. */
-export 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]";
+export const HEADLESS_GO_USAGE = "Usage: yagni go --headless [--cloud] [--session] --ticket-file <path> [--plan-file <path>] [--memo-file <path>] [--continue-file <path>] [--run-id <id>] [--cwd <path>] [--json]";
 /** With a deadline, the final verify of a cloud session needs at least this much of it left. */
 const FINAL_VERIFY_MIN_LEFT_MS = 5 * 60_000;
 /**
@@ -125,6 +126,7 @@ export function parseHeadlessGoArgs(argv) {
         headless: false,
         json: false,
         cloud: false,
+        session: false,
         unknownFlags: [],
         positionals: [],
         missingValues: [],
@@ -148,6 +150,10 @@ export function parseHeadlessGoArgs(argv) {
             args.cloud = true;
             continue;
         }
+        if (name === "--session") {
+            args.session = true;
+            continue;
+        }
         const key = VALUE_FLAGS[name];
         if (key) {
             const next = inlineValue ?? argv[i + 1];
@@ -183,6 +189,9 @@ export function validateHeadlessGoArgs(args) {
         return "yagni go is headless-only: pass --headless (use /go inside a session for the interactive run).";
     if (!args.ticketFile)
         return "Missing --ticket-file.";
+    if (args.session && !args.cloud) {
+        return "--session runs the one-attempt lane's session: pass it with --cloud.";
+    }
     return undefined;
 }
 const isBlocking = isBlockingFinding;
@@ -387,6 +396,33 @@ export async function runHeadlessGo(argv, deps = {}) {
         cloud = { ...cloudEnv, stage: prepared.stage };
         lane = prepared.lane;
     }
+    // The session lane: one turn of the run's one session, in place of the
+    // stage graph below, with the same outputs (sessionLane.ts).
+    if (cloud && args.session) {
+        const turn = await (deps.runSessionTurn ?? defaultRunSessionTurn)({
+            cwd,
+            inputDir: dirname(args.ticketFile ?? ""),
+            identity: cloud.identity,
+            outDir: cloud.outDir,
+            stage: cloud.stage,
+            ...(continuation ? { continuation } : {}),
+            ...(mission?.plan ? { plan: mission.plan } : {}),
+            childEnv,
+            ...(deps.extraArgs?.length ? { extraArgs: deps.extraArgs } : {}),
+            ...(budget?.deadlineMs !== undefined ? { deadlineMs: budget.deadlineMs } : {}),
+            ...(args.runId ? { runId: args.runId } : {}),
+            emit: stream ? emit : () => undefined,
+            writeErr,
+            ...(deps.signal ? { signal: deps.signal } : {}),
+        }, {
+            ...(deps.exec ? { exec: deps.exec } : {}),
+            ...(deps.snapshotWorkspace ? { snapshot: deps.snapshotWorkspace } : {}),
+            ...(deps.writeFile ? { writeFile: deps.writeFile } : {}),
+            readFile,
+            ...(deps.now ? { now: deps.now } : {}),
+        });
+        return { exitCode: turn.ok ? HEADLESS_GO_EXIT.verified : HEADLESS_GO_EXIT.unverified };
+    }
     const cloudStage = cloud?.stage;
     // The implement diamond's recording thread, per RUN. The beats ride the
     // NDJSON stream as `pipeline_fanout` records, and the mission collector

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

@@ -60,6 +60,15 @@ export declare function buildStageInvocation(stage: PipelineStage, ctx: {
     lens?: ReviewLens;
     tierCap?: ModelTier;
 }): string[];
+/**
+ * A stage passthrough moved onto a session file: `--no-session` becomes
+ * `--session <file>`, which pi creates when it is missing and resumes when it
+ * is not. The tools, the model and the system prompt stay this invocation's
+ * own (pi reads them from the command line on every launch, never from the
+ * file), so a resumed turn can carry more tools than the turn before it. The
+ * session lane's one session (`sessionLane.ts`).
+ */
+export declare function onSessionFile(passthrough: string[], sessionFile: string): string[];
 /**
  * Prepend the grounding args (the pi cli script, our extension, and the default
  * `yagni` provider) before a stage passthrough. Mirrors buildLaunch's

package/dist/extension/pipeline/invocation.js

@@ -39,7 +39,7 @@ import { clampTier } from "./tierCap.js";
  * with a `- ` bullet line, no emojis.
  */
 export const CHILD_HONESTY_PREAMBLE = "Never fabricate file paths, file contents, function signatures, enum values, or code. " +
-    "If you cannot find something, say so explicitly — an honest \"not found\" is more valuable " +
+    'If you cannot find something, say so explicitly — an honest "not found" is more valuable ' +
     "than a plausible-sounding invention. Every file path you cite must be a path you actually " +
     "read with a tool. If you are uncertain whether something exists, say you are uncertain " +
     "rather than presenting a guess as a finding.";
@@ -77,6 +77,20 @@ export function buildStageInvocation(stage, ctx) {
         `Task: ${task}`,
     ];
 }
+/**
+ * A stage passthrough moved onto a session file: `--no-session` becomes
+ * `--session <file>`, which pi creates when it is missing and resumes when it
+ * is not. The tools, the model and the system prompt stay this invocation's
+ * own (pi reads them from the command line on every launch, never from the
+ * file), so a resumed turn can carry more tools than the turn before it. The
+ * session lane's one session (`sessionLane.ts`).
+ */
+export function onSessionFile(passthrough, sessionFile) {
+    const at = passthrough.indexOf("--no-session");
+    if (at < 0)
+        return [...passthrough.slice(0, -1), "--session", sessionFile, ...passthrough.slice(-1)];
+    return [...passthrough.slice(0, at), "--session", sessionFile, ...passthrough.slice(at + 1)];
+}
 /**
  * Prepend the grounding args (the pi cli script, our extension, and the default
  * `yagni` provider) before a stage passthrough. Mirrors buildLaunch's

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

@@ -26,6 +26,17 @@
  */
 import type { PartitionWorkstream } from "./fanout.js";
 import type { PipelineStage } from "./types.js";
+/**
+ * The session lane's one skill (`sessionLane.ts`): how YAGNI works a ticket
+ * in one session, from reading it to a committed, reported change. A
+ * playbook, not a contract: each turn's message says what the host needs
+ * back, and this says how to get there. Installed under the run user's home
+ * as `~/.yagni/skills/work-a-ticket/SKILL.md` and handed to every turn as its
+ * system prompt, so the model reads the same words at the plan, the build and
+ * each fix. Its words never name the harness (the branding scrub rewrites
+ * that word) and open with no bullet.
+ */
+export declare const WORK_A_TICKET_SKILL = "---\nname: work-a-ticket\ndescription: How YAGNI works a ticket in one session, from reading it to a committed, honestly reported change. Read, run and plan with options and a recommendation, stop for approval, build the smallest change with subagents, verify with a fresh one, commit and report.\n---\n\n# How YAGNI works a ticket\n\nYou work one ticket for a Team, in its repository, checked out in your working directory on a machine that is yours for the whole run. A person approves your plan before anything is built. YAGNI pushes your commits, opens the pull request, waits for CI and the review, and brings you back with what they asked. Each time YAGNI resumes you, its message says which turn this is and what it needs back. This is a playbook, not a contract: use your judgement, and say what you did.\n\n## 1. Understand the ticket\n\nRead the ticket, its evidence and every image it names, the design, the memo, the checks, the Team's playbook and the Plan line's instructions. Read the code the ticket touches, and send searcher subagents for wide reads, in parallel. Settle facts by running things rather than guessing: the tests, a type check, the app, Docker, a query. Installing what a check needs is fine. Read the decision ledger (team_read with yagni_decisions_read_for_repository) and ask_yagni before you ask a person anything.\n\n## 2. Plan, then stop\n\nName the files and the steps. Where there is a real choice of approach, give the options, each with what it changes and what it costs, and recommend one. End the turn with the plan in the format the message gives, and stop. You have no edit or write tool until the plan is approved, and anything you change in tracked files before then is put back.\n\n## 3. Build\n\nThe option the person approved is binding. The plan's steps are guidance: when the code shows a better step, take it, and record the departure and why. Prefer the smallest change that meets the ticket: no drive-by refactors and no files the ticket does not need. Hand fully specified chunks of work (the files, the change, the check that proves it) to the implementer subagent, and keep the judgement calls yourself. Run the checks that prove the change. A check that already failed on the unchanged code is not yours to fix; say so.\n\n## 4. Verify\n\nBefore you finish, dispatch a fresh verification subagent on your diff, with the ticket and the plan, and fix what it finds that is real. For a large change, send two or three with different lenses and treat their agreement as confirmation.\n\n## 5. Commit and report\n\nCommit on the branch you are on, with clear messages. Never push, never open or edit a pull request, and never change the git identity or config. Write the report the message asks for last, and honestly: each check you ran with its real exit code, what you could not verify and why, and every departure from the plan and why. A check you did not run is not a pass.\n\n## Rules that always hold\n\nNever fabricate a path, a result or a check: \"not found\" and \"not verified\" are answers. Never print, commit or send a token or a variable's value. If the disk fills (\"no space left on device\"), stop and say so; do not delete or prune to go on. Call record_decision only for a consequential product or architecture call the plan did not settle.\n";
 /** Persona body keyed by the agent name referenced in `stages.ts`. */
 export declare const PERSONA_BODIES: Record<string, string>;
 /**

package/dist/extension/pipeline/personas.js

@@ -70,6 +70,49 @@ Keep it concrete; the worker executes it verbatim.`;
 const CLOUD_PLANNER_ROLE = `You are a planning specialist. You plan one ticket in the repository checked out in your working directory, by reading it: you run none of its commands. 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 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.`;
+/**
+ * The session lane's one skill (`sessionLane.ts`): how YAGNI works a ticket
+ * in one session, from reading it to a committed, reported change. A
+ * playbook, not a contract: each turn's message says what the host needs
+ * back, and this says how to get there. Installed under the run user's home
+ * as `~/.yagni/skills/work-a-ticket/SKILL.md` and handed to every turn as its
+ * system prompt, so the model reads the same words at the plan, the build and
+ * each fix. Its words never name the harness (the branding scrub rewrites
+ * that word) and open with no bullet.
+ */
+export const WORK_A_TICKET_SKILL = `---
+name: work-a-ticket
+description: How YAGNI works a ticket in one session, from reading it to a committed, honestly reported change. Read, run and plan with options and a recommendation, stop for approval, build the smallest change with subagents, verify with a fresh one, commit and report.
+---
+
+# How YAGNI works a ticket
+
+You work one ticket for a Team, in its repository, checked out in your working directory on a machine that is yours for the whole run. A person approves your plan before anything is built. YAGNI pushes your commits, opens the pull request, waits for CI and the review, and brings you back with what they asked. Each time YAGNI resumes you, its message says which turn this is and what it needs back. This is a playbook, not a contract: use your judgement, and say what you did.
+
+## 1. Understand the ticket
+
+Read the ticket, its evidence and every image it names, the design, the memo, the checks, the Team's playbook and the Plan line's instructions. Read the code the ticket touches, and send searcher subagents for wide reads, in parallel. Settle facts by running things rather than guessing: the tests, a type check, the app, Docker, a query. Installing what a check needs is fine. Read the decision ledger (team_read with yagni_decisions_read_for_repository) and ask_yagni before you ask a person anything.
+
+## 2. Plan, then stop
+
+Name the files and the steps. Where there is a real choice of approach, give the options, each with what it changes and what it costs, and recommend one. End the turn with the plan in the format the message gives, and stop. You have no edit or write tool until the plan is approved, and anything you change in tracked files before then is put back.
+
+## 3. Build
+
+The option the person approved is binding. The plan's steps are guidance: when the code shows a better step, take it, and record the departure and why. Prefer the smallest change that meets the ticket: no drive-by refactors and no files the ticket does not need. Hand fully specified chunks of work (the files, the change, the check that proves it) to the implementer subagent, and keep the judgement calls yourself. Run the checks that prove the change. A check that already failed on the unchanged code is not yours to fix; say so.
+
+## 4. Verify
+
+Before you finish, dispatch a fresh verification subagent on your diff, with the ticket and the plan, and fix what it finds that is real. For a large change, send two or three with different lenses and treat their agreement as confirmation.
+
+## 5. Commit and report
+
+Commit on the branch you are on, with clear messages. Never push, never open or edit a pull request, and never change the git identity or config. Write the report the message asks for last, and honestly: each check you ran with its real exit code, what you could not verify and why, and every departure from the plan and why. A check you did not run is not a pass.
+
+## Rules that always hold
+
+Never fabricate a path, a result or a check: "not found" and "not verified" are answers. Never print, commit or send a token or a variable's value. If the disk fills ("no space left on device"), stop and say so; do not delete or prune to go on. Call record_decision only for a consequential product or architecture call the plan did not settle.
+`;
 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.
 
@@ -244,6 +287,7 @@ export const PERSONA_BODIES = {
     scout: SCOUT_BODY,
     planner: PLANNER_BODY,
     cloud_planner: CLOUD_PLANNER_BODY,
+    session: WORK_A_TICKET_SKILL,
     worker: WORKER_BODY,
     reviewer: REVIEWER_BODY,
     advisor: ADVISOR_BODY,

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

@@ -98,6 +98,13 @@ export interface RunStageDeps {
     }) => string;
     /** The clock a timed stage's deadline is read from; tests inject one. */
     now?: () => number;
+    /**
+     * The session lane's one pi session (`sessionLane.ts`): the child runs on
+     * this session file (`--session`, created when missing, resumed when not)
+     * instead of `--no-session`, so each turn continues the same conversation.
+     * Absent on every /go stage and subagent child.
+     */
+    sessionFile?: string;
 }
 /**
  * Default per-line stdout ceiling (16 MiB). A legitimate NDJSON event — even one

package/dist/extension/pipeline/runner.js

@@ -27,7 +27,7 @@ import { sessionExecArgv } from "../systemCa.js";
 import { trackChild } from "./childRegistry.js";
 import { finalOutputFrom, foldEvent, newEventAccumulator } from "./events.js";
 import { logEvent } from "../errorSink.js";
-import { buildStageInvocation, groundedChildArgv } from "./invocation.js";
+import { buildStageInvocation, groundedChildArgv, onSessionFile } from "./invocation.js";
 import { personaBody } from "./personas.js";
 import { STAGE_WRAP_UP_AT_ENV, STAGE_WRAP_UP_GRACE_MS } from "./stageClock.js";
 import { clampTier, resolveTierCap } from "./tierCap.js";
@@ -73,7 +73,14 @@ function defaultResolveChild() {
     const extensionPath = fileURLToPath(new URL("../index.js", import.meta.url));
     return { piCli, extensionPath };
 }
-const EMPTY_USAGE = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
+const EMPTY_USAGE = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    cost: 0,
+    turns: 0,
+};
 /** Truncate to PER_TASK_OUTPUT_CAP bytes, never exceeding the cap. */
 function capOutput(output) {
     if (Buffer.byteLength(output, "utf8") <= PER_TASK_OUTPUT_CAP)
@@ -101,7 +108,9 @@ export async function runStage(stage, ctx, deps) {
     const effectiveTier = clampTier(stage.model, tierCap);
     const personaStage = ctx.lens ? { ...stage, lens: ctx.lens } : stage;
     // grounded defaults true; only the M6 blind eval lane passes grounded: false.
-    const body = (deps.personaBody ?? personaBody)(personaStage, { grounded: ctx.grounded !== false });
+    const body = (deps.personaBody ?? personaBody)(personaStage, {
+        grounded: ctx.grounded !== false,
+    });
     const { filePath, cleanup } = await writePrompt(body);
     const result = {
         stageId: stage.id,
@@ -115,13 +124,14 @@ export async function runStage(stage, ctx, deps) {
         toolErrors: 0,
     };
     try {
-        const passthrough = buildStageInvocation(stage, {
+        const invocation = buildStageInvocation(stage, {
             ticket: ctx.ticket,
             previous: ctx.previous,
             promptFilePath: filePath,
             lens: ctx.lens,
             ...(tierCap ? { tierCap } : {}),
         });
+        const passthrough = deps.sessionFile ? onSessionFile(invocation, deps.sessionFile) : invocation;
         const { piCli, extensionPath } = resolveChild();
         const argv = groundedChildArgv(passthrough, {
             piCli,
@@ -151,7 +161,9 @@ export async function runStage(stage, ctx, deps) {
                 const m = process.memoryUsage();
                 fs.appendFileSync(path.join(DEBUG_DIR, `${dbgLabel}.stream.log`), `${new Date().toISOString()} ${note} bytes=${dbgTotalBytes} maxLineBytes=${dbgMaxLineBytes} lines=${dbgLineCount} events=${eventCount} heapUsedMB=${Math.round(m.heapUsed / 1048576)} rssMB=${Math.round(m.rss / 1048576)}\n`);
             }
-            catch { /* ignore */ }
+            catch {
+                /* ignore */
+            }
         };
         // YAG-471 attribution: every child builds its OWN provider config at init
         // (reading its own env), so a per-child env var becomes a per-child header.
@@ -337,10 +349,15 @@ export async function runStage(stage, ctx, deps) {
                 fs.mkdirSync(DEBUG_DIR, { recursive: true });
                 const finalOut = finalOutputFrom(acc);
                 fs.writeFileSync(path.join(DEBUG_DIR, `${dbgLabel}.summary.json`), JSON.stringify({
-                    stageId: stage.id, lens: ctx.lens, exitCode,
-                    stopReason: result.stopReason, usage: result.usage,
-                    events_count: eventCount, total_stream_bytes: dbgTotalBytes,
-                    max_line_bytes: dbgMaxLineBytes, line_count: dbgLineCount,
+                    stageId: stage.id,
+                    lens: ctx.lens,
+                    exitCode,
+                    stopReason: result.stopReason,
+                    usage: result.usage,
+                    events_count: eventCount,
+                    total_stream_bytes: dbgTotalBytes,
+                    max_line_bytes: dbgMaxLineBytes,
+                    line_count: dbgLineCount,
                     final_output_bytes: Buffer.byteLength(finalOut, "utf8"),
                     final_output: finalOut,
                 }, null, 2));
@@ -354,7 +371,9 @@ export async function runStage(stage, ctx, deps) {
                     });
                 }
             }
-            catch { /* ignore */ }
+            catch {
+                /* ignore */
+            }
         }
         return result;
     }

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

@@ -0,0 +1,160 @@
+/**
+ * The session lane (`yagni go --headless --cloud --session`, 2026-10-28): a
+ * ticket runs as ONE pi session, on the strongest tier, in one Machine the
+ * host keeps for the whole run, in place of the cloud lane's stage graph.
+ * The model works the ticket itself, with the `subagent` tool for what it
+ * hands off, and the host meets it at the same checkpoints the cloud lane
+ * has, by the same files.
+ *
+ * Each host execution is one TURN of that session: this process runs one pi
+ * child on the session file the run keeps under the run user's home
+ * (`~/.yagni/session-lane/<attempt>/session.jsonl`), with one message that
+ * says what the turn is, and ends when the model ends its turn. A file that
+ * exists is resumed (`--session <file>`: pi restores the conversation and
+ * takes the tools this turn names), so the plan, the build and each fix are
+ * one conversation; a Machine the host had to replace has none, and the turn
+ * starts a fresh session whose message points at everything on disk.
+ *
+ *   - Plan turn: read, search, run anything (tests, Docker, the app), no edit
+ *     or write tool. Its last message is the plan with the plan-json block,
+ *     asked for once more when the block is missing; this process writes
+ *     `plan.md`, `plan.json` and `result.json` as the cloud lane's plan stage
+ *     does (`completeCloudSession`). Anything the turn changed in tracked
+ *     files, or committed, is put back before the plan's gate, so nothing is
+ *     written before a person approves (the host also checks the checkout out
+ *     again before the build, `checkOutTurnStart`).
+ *   - Build, fix and verify turns: the write tools come on. The model builds,
+ *     verifies with a fresh `verification` subagent, commits and never
+ *     pushes, and writes its own account to `session-report.json`. This
+ *     process then runs what the cloud lane's finish runs (the secret and
+ *     binary scan, a commit of anything left, the git facts) and writes
+ *     `result.json` with the model's checks, what it could not verify and
+ *     where it departed from the plan folded in.
+ *
+ * Kept from the cloud lane: the run's clock (`YAGNI_PIPELINE_TIME_LEFT_MS`,
+ * the turn's tools refused once it is nearly spent), the tool-failure health
+ * gate on a turn that writes, and the report's contract with the host. Not
+ * kept: the review loop and its round cap, the fixer, and the plan stage's
+ * own clock.
+ */
+import { type AttemptResult, type CloudIdentity, type CloudStage } from "./cloud.js";
+import type { ContinuationInputs } from "./continuation.js";
+import { type RunStageDeps } from "./runner.js";
+import { type ModelTier, type PipelineStage, type StageResult, type StopReason } from "./types.js";
+import { type VerifyCheckRun } from "./verify.js";
+import { snapshotWorkspace } from "./workspace.js";
+import type { WorktreeExec } from "./worktree.js";
+/** The one tier the session's writer runs on; its subagents keep their own. */
+export declare const SESSION_TIER: ModelTier;
+/** The caller the model proxy attributes the session's own turns to. */
+export declare const SESSION_CALLER_LABEL = "go:session";
+/** The model's own account of a turn that builds, beside `result.json` in the output folder. */
+export declare const SESSION_REPORT_FILE_NAME = "session-report.json";
+/** What a plan turn may use: everything that reads or runs, nothing that edits. */
+export declare const PLAN_TURN_TOOLS: string[];
+/** What a turn that builds may use: the plan turn's tools and the writes. */
+export declare const BUILD_TURN_TOOLS: string[];
+/** The run's files under the run user's home: its one session, and the playbook it runs on. */
+export declare function sessionPaths(home: string, attemptId: string): {
+    sessionFile: string;
+    skillFile: string;
+};
+/** One plan answer as `plan-answers.json` carries it. */
+interface PlanAnswer {
+    answer: string;
+    question?: string;
+}
+/** The answers in `plan-answers.json`, or none when it is missing or does not read. */
+export declare function readPlanAnswers(text: string | null): PlanAnswer[];
+/** What a turn's message is built from. */
+export interface TurnFacts {
+    stage: CloudStage;
+    /** The session file existed: the model already holds the run so far. */
+    resumed: boolean;
+    inputDir: string;
+    outDir: string;
+    answers: readonly PlanAnswer[];
+    continuation?: ContinuationInputs;
+    /** The input folder has `hand-off-answer.md`: a person answered a stop. */
+    handOffAnswer: boolean;
+    /** The input folder has `fix-round.json`: a review or CI asks for changes. */
+    review: boolean;
+    /** The input folder has `sent-back-plan.md`: a person sent the plan back. */
+    sentBack: boolean;
+}
+/** The one message a turn sends the session. Pure. */
+export declare function turnMessage(facts: TurnFacts): string;
+/** The model's own account of a turn that builds (`session-report.json`). */
+export interface SessionReport {
+    summary: string | null;
+    checks: VerifyCheckRun[];
+    notVerified: string[];
+    departures: Array<{
+        from: string;
+        what: string;
+        why: string;
+    }>;
+}
+/**
+ * `session-report.json` as this process folds it, or null when it is missing
+ * or does not read. Each check keeps the shape the host reads; one with no
+ * command is dropped, and a baseline the model did not name is the one
+ * `checks.json` gives the same command, else `runnable`.
+ */
+export declare function parseSessionReport(text: string | null, known?: ReadonlyMap<string, VerifyCheckRun["baseline"]>): SessionReport | null;
+/** The report's checks and its words on `result.json`: the model's own account, never the host's proof. */
+export declare function withReport(attempt: AttemptResult, report: SessionReport | null): AttemptResult;
+/**
+ * The turn's stop as the result names it: aborted, its clock, a child that
+ * failed, a writing turn whose tools mostly errored (the cloud lane's health
+ * gate), else clean.
+ */
+export declare function turnStop(run: StageResult, writes: boolean, aborted: boolean): {
+    stop: StopReason;
+    note?: string;
+};
+export interface SessionTurnInput {
+    cwd: string;
+    /** The folder the ticket file sits in: the host's input folder. */
+    inputDir: string;
+    identity: CloudIdentity;
+    outDir: string;
+    stage: CloudStage;
+    continuation?: ContinuationInputs;
+    /** The approved plan's text, the commit's title and summary. */
+    plan?: string;
+    childEnv: NodeJS.ProcessEnv;
+    /** The launcher's `--skill` / `--prompt-template` paths (YAG-784): every turn reads them. */
+    extraArgs?: string[];
+    /** The run's deadline on this machine's clock, when the host gave one. */
+    deadlineMs?: number;
+    /** The run id the model proxy attributes the turn's spend to. */
+    runId?: string;
+    /** One NDJSON line on the stream, or nothing when the caller streams none. */
+    emit: (line: Record<string, unknown>) => void;
+    writeErr: (line: string) => void;
+    signal?: AbortSignal;
+}
+export interface SessionTurnDeps {
+    runStage?: (stage: PipelineStage, ctx: {
+        ticket: string;
+    }, deps: RunStageDeps) => Promise<StageResult>;
+    readFile?: (path: string) => string;
+    writeFile?: (path: string, text: string) => void;
+    exists?: (path: string) => boolean;
+    mkdir?: (path: string) => void;
+    exec?: WorktreeExec;
+    snapshot?: typeof snapshotWorkspace;
+    /** The run user's home; the Machine's `/home/user`. */
+    home?: string;
+    now?: () => number;
+}
+export interface SessionTurnOutcome {
+    /** A written plan, or a clean turn whose branch carries the attempt's committed work. */
+    ok: boolean;
+    attempt: AttemptResult;
+}
+/** Run one turn of the run's session and write what the host reads. Never throws for the model's sake. */
+export declare function runSessionTurn(input: SessionTurnInput, deps?: SessionTurnDeps): Promise<SessionTurnOutcome>;
+export {};
+//# sourceMappingURL=sessionLane.d.ts.map

package/dist/extension/pipeline/sessionLane.js

@@ -0,0 +1,576 @@
+/**
+ * The session lane (`yagni go --headless --cloud --session`, 2026-10-28): a
+ * ticket runs as ONE pi session, on the strongest tier, in one Machine the
+ * host keeps for the whole run, in place of the cloud lane's stage graph.
+ * The model works the ticket itself, with the `subagent` tool for what it
+ * hands off, and the host meets it at the same checkpoints the cloud lane
+ * has, by the same files.
+ *
+ * Each host execution is one TURN of that session: this process runs one pi
+ * child on the session file the run keeps under the run user's home
+ * (`~/.yagni/session-lane/<attempt>/session.jsonl`), with one message that
+ * says what the turn is, and ends when the model ends its turn. A file that
+ * exists is resumed (`--session <file>`: pi restores the conversation and
+ * takes the tools this turn names), so the plan, the build and each fix are
+ * one conversation; a Machine the host had to replace has none, and the turn
+ * starts a fresh session whose message points at everything on disk.
+ *
+ *   - Plan turn: read, search, run anything (tests, Docker, the app), no edit
+ *     or write tool. Its last message is the plan with the plan-json block,
+ *     asked for once more when the block is missing; this process writes
+ *     `plan.md`, `plan.json` and `result.json` as the cloud lane's plan stage
+ *     does (`completeCloudSession`). Anything the turn changed in tracked
+ *     files, or committed, is put back before the plan's gate, so nothing is
+ *     written before a person approves (the host also checks the checkout out
+ *     again before the build, `checkOutTurnStart`).
+ *   - Build, fix and verify turns: the write tools come on. The model builds,
+ *     verifies with a fresh `verification` subagent, commits and never
+ *     pushes, and writes its own account to `session-report.json`. This
+ *     process then runs what the cloud lane's finish runs (the secret and
+ *     binary scan, a commit of anything left, the git facts) and writes
+ *     `result.json` with the model's checks, what it could not verify and
+ *     where it departed from the plan folded in.
+ *
+ * Kept from the cloud lane: the run's clock (`YAGNI_PIPELINE_TIME_LEFT_MS`,
+ * the turn's tools refused once it is nearly spent), the tool-failure health
+ * gate on a turn that writes, and the report's contract with the host. Not
+ * kept: the review loop and its round cap, the fixer, and the plan stage's
+ * own clock.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, relative } from "node:path";
+import { scanChange } from "./changeScan.js";
+import { completeCloudSession, RESULT_FILE_NAME, } from "./cloud.js";
+import { finishExec } from "./finish.js";
+import { MISSION_CHECKS_FILE_NAME, readMissionChecksFile } from "./missionChecks.js";
+import { WORK_A_TICKET_SKILL } from "./personas.js";
+import { extractPlanJson } from "./planOutput.js";
+import { runStage as defaultRunStage } from "./runner.js";
+import { DECISIONS_READ_TOOL, PLAN_JSON_CONTRACT } from "./stages.js";
+import { STAGE_WRAP_UP_GRACE_MS } from "./stageClock.js";
+import { MIN_TOOL_CALLS_FOR_HEALTH, TOOL_ERROR_FAIL_RATE, } from "./types.js";
+import { baselineDirs, parseChangedPaths, planPaths } from "./verify.js";
+import { snapshotWorkspace } from "./workspace.js";
+/** The one tier the session's writer runs on; its subagents keep their own. */
+export const SESSION_TIER = "peak";
+/** The caller the model proxy attributes the session's own turns to. */
+export const SESSION_CALLER_LABEL = "go:session";
+/** The model's own account of a turn that builds, beside `result.json` in the output folder. */
+export const SESSION_REPORT_FILE_NAME = "session-report.json";
+/** What a plan turn may use: everything that reads or runs, nothing that edits. */
+export const PLAN_TURN_TOOLS = [
+    "read",
+    "grep",
+    "find",
+    "ls",
+    "bash",
+    "ask_yagni",
+    "team_read",
+    "prototype_read",
+    "subagent",
+];
+/** What a turn that builds may use: the plan turn's tools and the writes. */
+export const BUILD_TURN_TOOLS = [
+    ...PLAN_TURN_TOOLS,
+    "edit",
+    "write",
+    "record_decision",
+    "prototype_verification",
+    "prototype_verify",
+];
+/**
+ * How long before the run's deadline a turn's tools are refused: the
+ * runner's grace for its last message, and the finish after it.
+ */
+const TURN_FINISH_RESERVE_MS = STAGE_WRAP_UP_GRACE_MS + 5 * 60_000;
+/** The run's files under the run user's home: its one session, and the playbook it runs on. */
+export function sessionPaths(home, attemptId) {
+    const root = join(home, ".yagni");
+    return {
+        sessionFile: join(root, "session-lane", attemptId, "session.jsonl"),
+        skillFile: join(root, "skills", "work-a-ticket", "SKILL.md"),
+    };
+}
+/** The stage boundary a turn draws on the Live stream: a build or verify turn is the implement stage. */
+function feedStage(stage) {
+    if (stage === "plan")
+        return "plan";
+    if (stage === "fix")
+        return "fix";
+    return "implement";
+}
+/** The answers in `plan-answers.json`, or none when it is missing or does not read. */
+export function readPlanAnswers(text) {
+    if (!text)
+        return [];
+    try {
+        const data = JSON.parse(text);
+        if (!Array.isArray(data.answers))
+            return [];
+        return data.answers.flatMap((entry) => {
+            if (!entry || typeof entry !== "object")
+                return [];
+            const { answer, question } = entry;
+            if (typeof answer !== "string" || !answer.trim())
+                return [];
+            return [
+                {
+                    answer: answer.trim().slice(0, 1_000),
+                    ...(typeof question === "string" && question.trim()
+                        ? { question: question.trim().slice(0, 500) }
+                        : {}),
+                },
+            ];
+        });
+    }
+    catch {
+        return [];
+    }
+}
+const REPORT_CONTRACT = (outDir) => `Last, write ${join(outDir, SESSION_REPORT_FILE_NAME)} as JSON, honestly: ` +
+    '{"summary": "<what you changed, in two or three sentences>", ' +
+    '"checks": [{"name": "lint", "command": "pnpm lint", "cwd": ".", "exitCode": 0, "durationMs": 41000, ' +
+    '"baseline": "runnable | fails_on_base | cannot_run"}], ' +
+    '"notVerified": ["<what you could not verify, and why>"], ' +
+    '"departures": [{"from": "<the plan step>", "what": "<what you did instead>", "why": "<why>"}]}. ' +
+    "List every check you ran on the final tree with its real exit code; a check you did not run is " +
+    'not a pass, and goes in "notVerified". "baseline" is "fails_on_base" only when the check already ' +
+    "failed on the unchanged code. Then end your turn.";
+const BUILD_RULES = (outDir) => [
+    "Write tools are on now. Work as your playbook says:",
+    "- Prefer the smallest change that meets the ticket.",
+    "- Hand fully specified chunks to the implementer subagent and wide reads to searcher subagents, in parallel where they touch different files; keep the judgement calls yourself.",
+    "- Run the checks that prove the change (checks.json, the plan's checks) and fix what your change breaks.",
+    "- Before you finish, dispatch a fresh verification subagent on your diff with the ticket and the plan, and fix what it finds that is real.",
+    "- Commit on the branch you are on. Never push and never open or edit a pull request: YAGNI pushes your commits and opens it.",
+    `- ${REPORT_CONTRACT(outDir)}`,
+].join("\n");
+const INPUTS = (inputDir) => [
+    `Your inputs are in ${inputDir}:`,
+    "- ticket.md: the ticket and the evidence behind it. Open every image it names with the read tool.",
+    "- design.md and images/: the linked design and its frames, when they exist.",
+    "- memo.md: what runs in this repository.",
+    "- checks.json: the repository's checks, and which already fail on the unchanged code.",
+    "- playbook.md: the Team's planning rules. Always follow them.",
+    "- plan-line.md: this Team's instructions for planning.",
+].join("\n");
+const PLAN_RULES = [
+    "This turn you have read, grep, find, ls, bash, ask_yagni, team_read, prototype_read and subagent, and no edit or write tool.",
+    "Run whatever settles a fact: the tests, a type check, the app, Docker, a query. Change no tracked file and commit nothing: anything this turn changes in the repository is put back before the plan's gate.",
+    `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.`,
+    "End the turn with the plan as your last message: ## Goal (one sentence), ## Plan (numbered steps, each naming the file or function), ## Files to modify / create, ## Checks and ## Risks, then the plan-json block. Where there is a real choice of approach, ask it as a decision question with your recommendation and its alternatives; the plan's steps follow your recommendation.",
+    PLAN_JSON_CONTRACT,
+    "Then stop: a person approves the plan before anything is built.",
+].join("\n\n");
+/** The one message a turn sends the session. Pure. */
+export function turnMessage(facts) {
+    const at = (file) => join(facts.inputDir, file);
+    const parts = [];
+    if (facts.stage === "plan") {
+        if (facts.resumed && facts.sentBack) {
+            parts.push(`A person sent your plan back. What they asked is in ${at("ticket.md")}, and the plan they sent back is ${at("sent-back-plan.md")}. Plan again: keep what they did not ask to change.`);
+        }
+        else if (facts.resumed) {
+            parts.push(`Plan this ticket again from ${at("ticket.md")}.`);
+        }
+        else {
+            parts.push("This is the plan turn of a YAGNI attempt. Work the ticket as your playbook says, up to the plan: nothing is built until a person approves it.", INPUTS(facts.inputDir));
+            if (facts.sentBack) {
+                parts.push(`A person sent an earlier plan back: what they asked is in ${at("ticket.md")}, and that plan is ${at("sent-back-plan.md")}.`);
+            }
+        }
+        parts.push(PLAN_RULES);
+        return parts.join("\n\n");
+    }
+    const answers = facts.answers.length > 0
+        ? [
+            "Their answers:",
+            ...facts.answers.map((entry) => entry.question ? `- ${entry.question}: ${entry.answer}` : `- ${entry.answer}`),
+        ].join("\n")
+        : "";
+    if (facts.stage === "implement" && facts.resumed && !facts.continuation) {
+        parts.push(`The person approved your plan. The plan as approved is ${at("plan.md")}, and their answers are in ${at("plan-answers.json")}; ${at("ticket.md")} lists any answer that changes the plan.`);
+        if (answers)
+            parts.push(answers);
+        parts.push(`The option they picked is binding. If it is not the one you recommended, re-plan in place first: write the plan you will build to ${join(facts.outDir, "plan.md")}, then build that. The steps are guidance; record every departure from them and why.`);
+    }
+    else if (facts.stage === "fix" && facts.review) {
+        parts.push(`A review or the CI on this attempt's pull request asks for changes. They are in ${at("ticket.md")}, under "Review on this attempt's pull request", each with its id; the branch may hold a person's commits since your last turn, so read the code as it is now. Address every item with the smallest change that does it, write the outcomes file that section names, and commit.`);
+    }
+    else {
+        const why = facts.continuation?.priorStop
+            ? ` The last turn stopped (${facts.continuation.priorStop}) before it finished.`
+            : "";
+        parts.push(facts.resumed
+            ? `Pick up the attempt where it stands on this branch.${why}`
+            : `You are building an approved plan for this ticket, on a branch that holds whatever this attempt committed so far.${why}`);
+        if (!facts.resumed) {
+            parts.push(INPUTS(facts.inputDir), `- plan.md: the plan a person approved, and plan-answers.json, their answers. The option they picked is binding; the steps are guidance.`);
+        }
+        if (answers && !facts.resumed)
+            parts.push(answers);
+        if (facts.stage === "verify") {
+            parts.push("Check the work on this branch against the plan: run the checks, fix only what this change broke, and commit any fix.");
+        }
+        if (facts.review) {
+            parts.push(`A review or the CI on this attempt's pull request asks for changes: they are in ${at("ticket.md")}, under "Review on this attempt's pull request". Address every item and write the outcomes file that section names.`);
+        }
+    }
+    if (facts.handOffAnswer) {
+        parts.push(`Read ${at("hand-off-answer.md")} before you go on: why the attempt stopped, and what a person answered.`);
+    }
+    parts.push(BUILD_RULES(facts.outDir));
+    return parts.join("\n\n");
+}
+const MAX_REPORTED_CHECKS = 40;
+const MAX_REPORT_LINES = 20;
+function line(value, max = 500) {
+    if (typeof value !== "string")
+        return null;
+    const text = value.replace(/\s+/g, " ").trim();
+    return text ? text.slice(0, max) : null;
+}
+const BASELINES = new Set(["runnable", "fails_on_base", "cannot_run"]);
+/**
+ * `session-report.json` as this process folds it, or null when it is missing
+ * or does not read. Each check keeps the shape the host reads; one with no
+ * command is dropped, and a baseline the model did not name is the one
+ * `checks.json` gives the same command, else `runnable`.
+ */
+export function parseSessionReport(text, known = new Map()) {
+    if (!text)
+        return null;
+    let data;
+    try {
+        const parsed = JSON.parse(text);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return null;
+        data = parsed;
+    }
+    catch {
+        return null;
+    }
+    const list = (value) => (Array.isArray(value) ? value : []);
+    const checks = [];
+    for (const entry of list(data.checks).slice(0, MAX_REPORTED_CHECKS)) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const check = entry;
+        const command = line(check.command, 1_000);
+        if (!command)
+            continue;
+        const exitCode = typeof check.exitCode === "number" && Number.isInteger(check.exitCode)
+            ? check.exitCode
+            : null;
+        const baseline = BASELINES.has(String(check.baseline))
+            ? check.baseline
+            : (known.get(command.replace(/\s+/g, " ")) ?? "runnable");
+        const note = line(check.note);
+        checks.push({
+            name: line(check.name, 120) ?? command.slice(0, 120),
+            command,
+            cwd: line(check.cwd, 300) ?? ".",
+            exitCode,
+            durationMs: typeof check.durationMs === "number" && check.durationMs >= 0
+                ? Math.round(check.durationMs)
+                : 0,
+            baseline,
+            ...(note ? { note } : exitCode === null ? { note: "the session gave no exit code" } : {}),
+        });
+    }
+    const notVerified = list(data.notVerified)
+        .map((entry) => line(entry))
+        .filter((entry) => entry !== null)
+        .slice(0, MAX_REPORT_LINES);
+    const departures = list(data.departures)
+        .flatMap((entry) => {
+        if (!entry || typeof entry !== "object")
+            return [];
+        const record = entry;
+        const what = line(record.what);
+        if (!what)
+            return [];
+        return [{ from: line(record.from, 200) ?? "the plan", what, why: line(record.why) ?? "" }];
+    })
+        .slice(0, MAX_REPORT_LINES);
+    return { summary: line(data.summary, 1_500), checks, notVerified, departures };
+}
+/** The checks the host named in `checks.json`, by their command, with how each stands on the base. */
+function knownBaselines(inputDir, readFile) {
+    const read = readMissionChecksFile(join(inputDir, MISSION_CHECKS_FILE_NAME), readFile);
+    return new Map((read.file?.checks ?? []).map((check) => [check.command.replace(/\s+/g, " "), check.status]));
+}
+/** The report's checks and its words on `result.json`: the model's own account, never the host's proof. */
+export function withReport(attempt, report) {
+    if (!report) {
+        return {
+            ...attempt,
+            notes: [
+                ...attempt.notes,
+                `The session wrote no readable ${SESSION_REPORT_FILE_NAME}, so it reports no checks of its own.`,
+            ],
+        };
+    }
+    const notes = [
+        ...(report.summary ? [report.summary] : []),
+        ...attempt.notes,
+        ...report.notVerified.map((entry) => `Not verified: ${entry}`),
+        ...report.departures.map((entry) => `Departed from ${entry.from}: ${entry.what}${entry.why ? `, because ${entry.why}` : ""}`),
+    ];
+    return {
+        ...attempt,
+        checks: report.checks.length > 0 ? report.checks : attempt.checks,
+        notes,
+    };
+}
+/**
+ * The turn's stop as the result names it: aborted, its clock, a child that
+ * failed, a writing turn whose tools mostly errored (the cloud lane's health
+ * gate), else clean.
+ */
+export function turnStop(run, writes, aborted) {
+    if (aborted || run.stopReason === "aborted")
+        return { stop: "aborted" };
+    if (run.timedOut) {
+        return { stop: "budget_exceeded", note: "The turn ran out of the run's time and was stopped." };
+    }
+    if (run.exitCode !== 0 || run.stopReason === "error") {
+        const why = run.errorMessage ? `: ${run.errorMessage.slice(0, 300)}` : "";
+        return { stop: "failed", note: `The session's turn ended on an error${why}.` };
+    }
+    if (writes &&
+        run.toolCalls >= MIN_TOOL_CALLS_FOR_HEALTH &&
+        run.toolErrors / run.toolCalls > TOOL_ERROR_FAIL_RATE) {
+        return {
+            stop: "failed",
+            note: `Tool failures: ${run.toolErrors} of ${run.toolCalls} tool calls errored, so its edits likely did not land.`,
+        };
+    }
+    return { stop: "clean" };
+}
+/** Run one turn of the run's session and write what the host reads. Never throws for the model's sake. */
+export async function runSessionTurn(input, deps = {}) {
+    const readFile = deps.readFile ?? ((path) => readFileSync(path, "utf8"));
+    const writeFile = deps.writeFile ?? ((path, text) => writeFileSync(path, text));
+    const exists = deps.exists ?? existsSync;
+    const mkdir = deps.mkdir ?? ((path) => void mkdirSync(path, { recursive: true }));
+    const exec = deps.exec ?? finishExec;
+    const snapshot = deps.snapshot ?? snapshotWorkspace;
+    const runStage = deps.runStage ?? defaultRunStage;
+    const now = deps.now ?? Date.now;
+    const readOrNull = (path) => {
+        try {
+            return readFile(path);
+        }
+        catch {
+            return null;
+        }
+    };
+    const paths = sessionPaths(deps.home ?? homedir(), input.identity.attemptId);
+    const resumed = exists(paths.sessionFile);
+    mkdir(join(paths.sessionFile, ".."));
+    mkdir(join(paths.skillFile, ".."));
+    // The playbook, installed where the session (and anything it runs) can
+    // read it again, and handed to every turn as its system prompt.
+    writeFile(paths.skillFile, WORK_A_TICKET_SKILL);
+    const start = await snapshot(input.cwd, input.signal);
+    const baseSha = start.head;
+    const preRunDirt = parseChangedPaths(start.status);
+    const writes = input.stage !== "plan";
+    const stageId = feedStage(input.stage);
+    const timeBudgetMs = input.deadlineMs === undefined
+        ? undefined
+        : Math.max(60_000, input.deadlineMs - now() - TURN_FINISH_RESERVE_MS);
+    const turnStage = {
+        id: stageId,
+        agent: "session",
+        model: SESSION_TIER,
+        tools: writes ? BUILD_TURN_TOOLS : PLAN_TURN_TOOLS,
+        taskTemplate: "{ticket}",
+        ...(timeBudgetMs !== undefined ? { timeBudgetMs } : {}),
+    };
+    let decisionsRecorded = 0;
+    const runDeps = {
+        cwd: input.cwd,
+        env: input.childEnv,
+        sessionFile: paths.sessionFile,
+        callerLabel: SESSION_CALLER_LABEL,
+        ...(input.runId ? { attribution: { runId: input.runId } } : {}),
+        ...(input.signal ? { signal: input.signal } : {}),
+        ...(input.extraArgs?.length ? { extraArgs: input.extraArgs } : {}),
+        stageWriteCapable: writes,
+        personaBody: () => WORK_A_TICKET_SKILL,
+        // The installed playbook is the system prompt's file: kept, never cleaned up.
+        writePrompt: async () => ({ filePath: paths.skillFile, cleanup: () => undefined }),
+        onEvent: (event) => {
+            if (event.type === "tool_execution_end" &&
+                event.toolName === "record_decision" &&
+                !event.isError) {
+                decisionsRecorded += 1;
+            }
+            input.emit({ ...event, yagni: { stage: stageId } });
+        },
+        now,
+    };
+    const turn = async (message) => {
+        input.emit({ type: "pipeline_stage", stage: stageId, phase: "start", at: now() });
+        try {
+            return await runStage(turnStage, { ticket: message }, runDeps);
+        }
+        finally {
+            input.emit({ type: "pipeline_stage", stage: stageId, phase: "finish", at: now() });
+        }
+    };
+    const message = turnMessage({
+        stage: input.stage,
+        resumed,
+        inputDir: input.inputDir,
+        outDir: input.outDir,
+        answers: readPlanAnswers(readOrNull(join(input.inputDir, "plan-answers.json"))),
+        ...(input.continuation ? { continuation: input.continuation } : {}),
+        handOffAnswer: exists(join(input.inputDir, "hand-off-answer.md")),
+        review: exists(join(input.inputDir, "fix-round.json")),
+        sentBack: exists(join(input.inputDir, "sent-back-plan.md")),
+    });
+    const notes = [];
+    const stages = [];
+    let planText = "";
+    let ran;
+    try {
+        let run = await turn(message);
+        stages.push(run);
+        if (input.stage === "plan") {
+            const planned = await planWithBlock(run, turn, input.signal);
+            stages.push(...planned.asked);
+            run = planned.run;
+            planText = run.finalOutput;
+            notes.push(...(await putBackPlanTurn(input.cwd, start, exec, snapshot, input.signal)));
+        }
+        const stop = turnStop(run, writes, input.signal?.aborted === true);
+        if (stop.note)
+            notes.push(stop.note);
+        const planned = input.stage !== "plan" || planText.trim().length > 0;
+        ran = {
+            result: {
+                stages,
+                rounds: [],
+                findings: [],
+                stopReason: stop.stop === "clean" && !planned ? "failed" : stop.stop,
+                decisionsRecorded,
+                ...(input.stage === "plan" ? { plan: planText } : {}),
+            },
+        };
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        input.writeErr(error);
+        ran = { error, partial: stages };
+    }
+    const sessionSecrets = [input.childEnv.YAGNI_TOKEN, input.childEnv.GH_ENTERPRISE_TOKEN].filter((value) => Boolean(value));
+    const done = await completeCloudSession({
+        identity: input.identity,
+        outDir: input.outDir,
+        stage: input.stage,
+        cwd: input.cwd,
+        baseSha,
+        preRunDirt,
+        ...(input.plan ? { plan: input.plan } : {}),
+        roundsDone: input.continuation?.reviewRoundsDone ?? 0,
+        tree: async () => {
+            const tree = await snapshot(input.cwd, input.signal);
+            return `${tree.head}\n${tree.status}`;
+        },
+        scan: () => scanChange(input.cwd, { exec, sessionSecrets, ...(baseSha ? { base: baseSha } : {}) }, preRunDirt),
+        planPaths: (text) => baselineDirs(input.cwd, planPaths(text), readFile).map((dir) => relative(input.cwd, dir) || "."),
+        exec,
+        writeFile,
+    }, ran);
+    const noted = { ...done.attempt, notes: [...notes, ...done.attempt.notes] };
+    const attempt = writes
+        ? withSessionAccount(noted, parseSessionReport(readOrNull(join(input.outDir, SESSION_REPORT_FILE_NAME)), knownBaselines(input.inputDir, readFile)))
+        : noted;
+    // The cloud lane's finish wrote `result.json`; it is written again when
+    // this turn adds to it (the model's account, the plan turn's put-back).
+    if (writes || notes.length > 0)
+        rewriteResult(input.outDir, attempt, writeFile);
+    input.emit({ type: "pipeline_result", ...attempt });
+    const ok = writes ? done.ok && attempt.stopReason === "clean" : done.ok;
+    return { ok, attempt };
+}
+/** The re-ask that recovers a plan whose plan-json block did not read. */
+const PLAN_BLOCK_REASK = "Your last message did not end with a plan-json block that reads. Send the whole plan again as " +
+    "your last message, ending with the plan-json block exactly as the contract says.";
+/**
+ * A plan turn's contract is its block: a plan without one that reads is
+ * asked for once more in the same session, and the answer stands only when
+ * it carries the block. Not asked of a turn that was stopped or ran out of
+ * time, or that wrote no plan at all.
+ */
+async function planWithBlock(run, turn, signal) {
+    const text = run.finalOutput;
+    if (!text.trim() || extractPlanJson(text) || signal?.aborted || run.timedOut) {
+        return { run, asked: [] };
+    }
+    const again = await turn(PLAN_BLOCK_REASK);
+    const took = again.exitCode === 0 && extractPlanJson(again.finalOutput) !== null;
+    return { run: took ? again : run, asked: [again] };
+}
+/**
+ * A writing turn's result with the model's own account folded in, and a
+ * clean turn that committed nothing read as having found nothing to change:
+ * the host's `no_changes`, which it finishes as a clean one when the turn
+ * verified work an earlier turn pushed.
+ */
+function withSessionAccount(attempt, report) {
+    const folded = withReport(attempt, report);
+    return folded.stopReason === "clean" && folded.commits.length === 0
+        ? { ...folded, stopReason: "no_changes" }
+        : folded;
+}
+/** `result.json` written again; one that cannot be written says so in its own notes, which the stream carries. */
+function rewriteResult(outDir, attempt, writeFile) {
+    try {
+        writeFile(join(outDir, RESULT_FILE_NAME), `${JSON.stringify(attempt, null, 2)}\n`);
+    }
+    catch (err) {
+        attempt.notes.push(`${RESULT_FILE_NAME} could not be written: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+/**
+ * Nothing a plan turn writes outlives it (its subagents and its shell can
+ * write, though the turn has no edit or write tool): when its HEAD moved or
+ * its tracked files differ from how it started, the checkout is put back to
+ * its start (the tree's own dirt from before the turn with it), and a file it
+ * added that git would track is removed. Ignored files stay, as installs do.
+ * The result says what was put back, and when it could not be.
+ */
+async function putBackPlanTurn(cwd, start, exec, snapshot, signal) {
+    if (!start.head)
+        return [];
+    const after = await snapshot(cwd, signal);
+    const entries = (status) => status.split("\n").filter((entry) => entry.trim());
+    const tracked = (status) => entries(status)
+        .filter((entry) => !entry.startsWith("??"))
+        .sort()
+        .join("\n");
+    const untrackedBefore = new Set(entries(start.status).filter((entry) => entry.startsWith("??")));
+    const added = entries(after.status)
+        .filter((entry) => entry.startsWith("??") && !untrackedBefore.has(entry))
+        .map((entry) => entry.slice(3).trim())
+        .filter(Boolean);
+    const moved = after.head !== start.head || tracked(after.status) !== tracked(start.status);
+    if (!moved && added.length === 0)
+        return [];
+    const run = (argv) => exec(argv, cwd, signal).catch(() => ({ code: -1, output: "" }));
+    const reset = moved ? await run(["git", "reset", "--hard", start.head]) : { code: 0 };
+    const clean = added.length > 0 ? await run(["git", "clean", "-fdq", "--", ...added]) : { code: 0 };
+    return reset.code === 0 && clean.code === 0
+        ? [
+            "The plan turn changed the repository; the checkout was put back to where it started before the plan's gate.",
+        ]
+        : [
+            "The plan turn changed the repository, and the checkout could not be put back in full; the host checks it out again before the build.",
+        ];
+}
+//# sourceMappingURL=sessionLane.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "1.2.11-staging.2122.1",
+  "version": "1.2.12-staging.2137.1",
   "description": "YAGNI Code: a terminal coding agent that already knows your company. One YAGNI login routes the model and grounds the agent in your team's context.",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "YAGNI, Inc. <jack@yagni.app> (https://yagni.app)",
@@ -58,5 +58,5 @@
     "turndown": "^7.2.4",
     "typebox": "^1.3.15"
   },
-  "yagniSourceSha": "4908d4b0b629a93a80da2015219b81ee9000b1e7"
+  "yagniSourceSha": "1cd3160a45a7677093048e44164f72e7038d4232"
 }