@yagni-app/code-staging 0.1.0-staging.997.1 → 0.2.0-staging.1025.1

package/dist/extension/pipeline/orchestrator.js

@@ -177,12 +177,21 @@ export async function runPipeline(ticket, deps) {
     // stay attributed to review/<lens>. The tap is ALWAYS installed (the
     // decisionsRecorded count must not depend on a caller wiring onEvent);
     // forwarding to the caller's onEvent stays optional.
+    // YAG-471 attribution: the tracked run's server-assigned id (a UUID, set once
+    // `runSession.start` returns) rides every child spawn from here on, so every
+    // stage's completions attribute to this run in `llm_usage` — the stage loop,
+    // the review lens fan-out, AND the format-recovery reask (it goes through
+    // this same seam). Absent when the run isn't tracked (flag off, unauthorized,
+    // backend unreachable) — attribution then degrades to the caller label alone,
+    // never blocking the pipeline.
+    const runId = deps.checkpointMeta?.runId;
     const stageDepsFor = (tag) => {
         const onEvent = deps.onEvent;
         return {
             cwd: deps.cwd,
             signal: deps.signal,
             ...(deps.childEnv ? { env: deps.childEnv } : {}),
+            ...(runId ? { attribution: { runId } } : {}),
             onEvent: (ev) => {
                 if (ev.type === "tool_execution_end" && ev.toolName === "record_decision" && !ev.isError) {
                     decisionsRecorded += 1;

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

@@ -0,0 +1,37 @@
+/**
+ * Task 8 (/go summary prints a per-stage, server-priced cost table): a pure
+ * formatter over `GET /api/yagni-code/spend?runId=`'s response (see
+ * costHud.ts's SpendResponse/SpendRow mirror for the shape this reads).
+ *
+ * Kept out of costHud.ts deliberately: that module's `formatServerCostLines`
+ * renders a SESSION's spend grouped by rate tier (for /cost); this renders ONE
+ * RUN's spend grouped by PIPELINE STAGE (for /go's end-of-run summary), and the
+ * grouping/merge rules below (fold the three review lenses into one line,
+ * mixed-tier tie-break) are specific enough to this call site that sharing a
+ * module would just make costHud.ts harder to read for its own surface.
+ *
+ * Caller labels are minted by runner.ts as `go:<stage.id>` (or
+ * `go:<stage.id>:<lens>` for the fanned-out review stage) — see
+ * `callerLabel` in runner.ts. This module's `stageKeyForCaller` is the inverse
+ * mapping back to a display row.
+ */
+import type { SpendResponse } from "../costHud.js";
+/**
+ * Render /go's end-of-run, server-priced cost table. Pure, no em-dashes,
+ * multi-line (joined with "\n"), leading space on the header/total lines so it
+ * reads as a continuation of the preceding recap sentence (matches
+ * runCostNote's own leading-space convention in goCommand.ts).
+ *
+ * Example:
+ * ```
+ *  Run cost (server):
+ *    map        standard    $0.05
+ *    plan       peak        $0.31
+ *    implement  standard    $0.12
+ *    review     peak        $0.34
+ *    fix        standard    $0.04
+ *  Run: $0.84 billed. $2.71 at frontier list. 69% saved.
+ * ```
+ */
+export declare function formatRunCostTable(spend: SpendResponse): string;
+//# sourceMappingURL=runCostTable.d.ts.map

package/dist/extension/pipeline/runCostTable.js

@@ -0,0 +1,165 @@
+/**
+ * Task 8 (/go summary prints a per-stage, server-priced cost table): a pure
+ * formatter over `GET /api/yagni-code/spend?runId=`'s response (see
+ * costHud.ts's SpendResponse/SpendRow mirror for the shape this reads).
+ *
+ * Kept out of costHud.ts deliberately: that module's `formatServerCostLines`
+ * renders a SESSION's spend grouped by rate tier (for /cost); this renders ONE
+ * RUN's spend grouped by PIPELINE STAGE (for /go's end-of-run summary), and the
+ * grouping/merge rules below (fold the three review lenses into one line,
+ * mixed-tier tie-break) are specific enough to this call site that sharing a
+ * module would just make costHud.ts harder to read for its own surface.
+ *
+ * Caller labels are minted by runner.ts as `go:<stage.id>` (or
+ * `go:<stage.id>:<lens>` for the fanned-out review stage) — see
+ * `callerLabel` in runner.ts. This module's `stageKeyForCaller` is the inverse
+ * mapping back to a display row.
+ */
+import { usd } from "../costHud.js";
+import { PIPELINE_V1 } from "./stages.js";
+/**
+ * Pipeline stages in the order /go actually runs them, DERIVED from
+ * PIPELINE_V1 (stages.ts's single source of truth) rather than a hand-copied
+ * list — a future stage added there self-registers here in order, with
+ * nothing in this file to update or drift out of sync.
+ */
+const STAGE_ORDER = PIPELINE_V1.map((s) => s.id);
+/**
+ * Map a `GET /spend` caller label onto its display stage, or undefined for a
+ * caller this table does not recognize (surfaced instead as its own row,
+ * verbatim, after the known stages — see {@link buildRows}). `go:review` and
+ * every `go:review:<lens>` caller fold onto the single "review" row: the three
+ * adversarial lenses are one conceptual review pass, and a per-lens
+ * breakdown would just be noise in an end-of-run summary.
+ *
+ * Derives the mapping from STAGE_ORDER (advisor is the one non-pipeline
+ * exception, matched exactly) rather than hand-listing each `go:<id>`
+ * caller, so a stage added to PIPELINE_V1 needs no update here either: strip
+ * the `go:` prefix, take the first `:`-delimited segment (folds `go:review`
+ * and every `go:review:<lens>` onto the same "review" segment), and check it
+ * against the known stage ids.
+ */
+function stageKeyForCaller(caller) {
+    if (caller === "advisor")
+        return "advisor";
+    if (!caller.startsWith("go:"))
+        return undefined;
+    const segment = caller.slice(3).split(":")[0];
+    return STAGE_ORDER.includes(segment) ? segment : undefined;
+}
+const sumSell = (rows) => rows.reduce((acc, r) => acc + r.sellMillicents, 0);
+/**
+ * The tier shown for a (possibly multi-row) line: the rows' COMMON tier when
+ * they all billed under the same one, else the tier of whichever contributing
+ * row spent the most (a re-ask retry on `efficient`, or a server-side reroute,
+ * can leave one caller split across two tiers — the biggest-spend tier is the
+ * more honest single label than an arbitrary first-seen one).
+ */
+function bucketTier(rows) {
+    const first = rows[0];
+    if (!first)
+        return "";
+    if (rows.every((r) => r.rateTier === first.rateTier))
+        return first.rateTier;
+    let biggest = first;
+    for (const r of rows) {
+        if (r.sellMillicents > biggest.sellMillicents)
+            biggest = r;
+    }
+    return biggest.rateTier;
+}
+/**
+ * Group spend rows into display rows: known pipeline stages (in pipeline
+ * order, review merged), then advisor when present, then every unrecognized
+ * caller (e.g. `subagent:foo`, `unattributed`, a bare `driver`) as its own
+ * row, sorted by spend descending (ties broken alphabetically, so output is
+ * deterministic). A stage with zero recorded dispatches is omitted rather
+ * than shown at $0.00: /go always runs map/plan/implement, but review/fix are
+ * absent on a run that stopped before reaching them (e.g. `no_changes`).
+ */
+function buildRows(spendRows) {
+    const known = new Map();
+    const unknown = new Map();
+    for (const row of spendRows) {
+        const key = stageKeyForCaller(row.caller);
+        const bucket = key ?? row.caller;
+        const target = key ? known : unknown;
+        const list = target.get(bucket) ?? [];
+        list.push(row);
+        target.set(bucket, list);
+    }
+    const rows = [];
+    for (const stage of STAGE_ORDER) {
+        const stageRows = known.get(stage);
+        if (!stageRows || stageRows.length === 0)
+            continue;
+        rows.push({ label: stage, tier: bucketTier(stageRows), sellMillicents: sumSell(stageRows) });
+    }
+    const advisorRows = known.get("advisor");
+    if (advisorRows && advisorRows.length > 0) {
+        rows.push({ label: "advisor", tier: bucketTier(advisorRows), sellMillicents: sumSell(advisorRows) });
+    }
+    const unknownRows = [...unknown.entries()]
+        .map(([caller, r]) => ({ label: caller, tier: bucketTier(r), sellMillicents: sumSell(r) }))
+        .sort((a, b) => b.sellMillicents - a.sellMillicents || a.label.localeCompare(b.label));
+    rows.push(...unknownRows);
+    return rows;
+}
+/**
+ * `Run: $A billed. $B at frontier list. NN% saved.` — the "at frontier
+ * list" + savings clause only renders when `savingsPercent` resolved (typeof
+ * guard, matching formatServerCostLines's own malformed-response caution: a
+ * network response is untyped at runtime).
+ *
+ * `counterfactualIncomplete` and a numeric `savingsPercent` are MUTUALLY
+ * EXCLUSIVE by construction on the server (yagniCodeSpend.ts sets
+ * `savingsPercent` null whenever `counterfactualIncomplete` is true — there is
+ * no honest percentage to report when some billed spend fell on a tier with no
+ * Anthropic list-price counterfactual). So `counterfactualIncomplete` is
+ * checked on the non-number branch, not as a caveat appended to the number
+ * branch (that would be unreachable dead code, and would silently drop the
+ * whole savings clause on a partial counterfactual with no explanation).
+ */
+function totalLine(spend) {
+    const billed = `$${usd(spend.totalSellMillicents)} billed.`;
+    if (typeof spend.savingsPercent !== "number") {
+        return spend.counterfactualIncomplete
+            ? ` Run: ${billed} Savings not shown: some spend billed on an unpriced tier.`
+            : ` Run: ${billed}`;
+    }
+    return ` Run: ${billed} $${usd(spend.totalCounterfactualMillicents)} at frontier list. ${spend.savingsPercent}% saved.`;
+}
+/**
+ * Render /go's end-of-run, server-priced cost table. Pure, no em-dashes,
+ * multi-line (joined with "\n"), leading space on the header/total lines so it
+ * reads as a continuation of the preceding recap sentence (matches
+ * runCostNote's own leading-space convention in goCommand.ts).
+ *
+ * Example:
+ * ```
+ *  Run cost (server):
+ *    map        standard    $0.05
+ *    plan       peak        $0.31
+ *    implement  standard    $0.12
+ *    review     peak        $0.34
+ *    fix        standard    $0.04
+ *  Run: $0.84 billed. $2.71 at frontier list. 69% saved.
+ * ```
+ */
+export function formatRunCostTable(spend) {
+    const rows = buildRows(spend.rows);
+    const labelWidth = rows.reduce((m, r) => Math.max(m, r.label.length), 0);
+    const tierWidth = rows.reduce((m, r) => Math.max(m, r.tier.length), 0);
+    const lines = [" Run cost (server):"];
+    for (const r of rows) {
+        lines.push(`   ${r.label.padEnd(labelWidth + 2)}${r.tier.padEnd(tierWidth + 2)}$${usd(r.sellMillicents)}`);
+    }
+    lines.push(totalLine(spend));
+    if (spend.unbilledSellMillicents > 0) {
+        // Matches formatServerCostLines' + YagniCodeUsageView.tsx's wording for
+        // the same figure.
+        lines.push(`   Includes $${usd(spend.unbilledSellMillicents)} not yet billed (insufficient credits or a billing error).`);
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=runCostTable.js.map

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

@@ -92,6 +92,17 @@ export interface GoRunState {
     endedAt?: number;
     stopReason?: StopReason;
     agents: AgentNode[];
+    /**
+     * The backend's run UUID (`handle.runId` from `POST /runs`, goCommand.ts's
+     * `openFreshRun`) — NOT `runId` above, which is the local 8-char short id
+     * (`runId.slice(0, 8)`) used for widget/status keys. `/api/yagni-code/spend`
+     * joins on the server UUID, so the desktop needs this to ever widen its
+     * spend query with a /go run's own dispatches. Absent until `openFreshRun`
+     * resolves (a beat after the run starts), and absent for good on an
+     * untracked run (flag off, unauthorized, or unreachable — see
+     * `UNTRACKED_NOTICE` in goCommand.ts): there is no server id to give it.
+     */
+    serverRunId?: string;
 }
 /**
  * Stable agent id: a lens child is keyed by its lens AND round, and fix — the
@@ -113,6 +124,7 @@ export declare class RunState {
     private readonly startedAt;
     private endedAt;
     private stopReason;
+    private serverRunId;
     private round;
     private findingsTotal;
     private findingsBlocking;
@@ -139,6 +151,13 @@ export declare class RunState {
     applyUsage(ev: JsonEvent, tag: StageTag, at?: number): void;
     /** Stamp the run's end. Separate from `done` because FINISH runs after the pipeline returns. */
     markEnded(at: number): void;
+    /**
+     * Record the backend's run UUID once `openFreshRun` resolves (goCommand.ts,
+     * a beat after the run starts — never known at construction). The caller is
+     * responsible for repainting immediately after this so the desktop learns
+     * it as soon as possible rather than on the next debounced paint.
+     */
+    setServerRunId(id: string): void;
     /**
      * Stage rows for the panel: one row per stage, in order. Lens children are the
      * desktop's business alone, and a looped stage that re-executes per round

package/dist/extension/pipeline/runState.js

@@ -54,6 +54,7 @@ export class RunState {
     startedAt;
     endedAt;
     stopReason;
+    serverRunId;
     round = 0;
     findingsTotal = 0;
     findingsBlocking = 0;
@@ -221,6 +222,15 @@ export class RunState {
     markEnded(at) {
         this.endedAt = at;
     }
+    /**
+     * Record the backend's run UUID once `openFreshRun` resolves (goCommand.ts,
+     * a beat after the run starts — never known at construction). The caller is
+     * responsible for repainting immediately after this so the desktop learns
+     * it as soon as possible rather than on the next debounced paint.
+     */
+    setServerRunId(id) {
+        this.serverRunId = id;
+    }
     // ---- Terminal renderer accessors (never serialized) ----------------------
     /**
      * Stage rows for the panel: one row per stage, in order. Lens children are the
@@ -258,6 +268,7 @@ export class RunState {
             ...(this.endedAt !== undefined ? { endedAt: this.endedAt } : {}),
             ...(this.stopReason ? { stopReason: this.stopReason } : {}),
             agents: this.agents,
+            ...(this.serverRunId !== undefined ? { serverRunId: this.serverRunId } : {}),
         };
     }
 }

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

@@ -35,6 +35,25 @@ export interface RunStageDeps {
     };
     /** Optional environment for spawned child stages. Defaults to Node's inherited env. */
     env?: NodeJS.ProcessEnv;
+    /**
+     * YAG-471 attribution: the tracked run's server-assigned id (a UUID), sent to
+     * the child as `YAGNI_RUN_ID` so the model proxy's `x-yagni-run-id` header
+     * wins over the session id for `llm_usage.session_id`. Absent when the run is
+     * untracked (recording disabled/failed) — the child still gets a caller
+     * label, just not a run id; attribution degrades gracefully rather than
+     * blocking anything.
+     */
+    attribution?: {
+        runId?: string;
+    };
+    /**
+     * YAG-471 attribution: the child's caller label, sent as `YAGNI_CALLER` (the
+     * model proxy's `x-yagni-caller` header). Defaults to `go:<stage.id>` (or
+     * `go:<stage.id>:<lens>` for a fanned-out review lens) when absent, so the
+     * /go pipeline's own stage loop never has to set this explicitly. The
+     * subagent tool and the advisor pass their own label through this seam.
+     */
+    callerLabel?: string;
     /**
      * Additive live tap: invoked once per parsed NDJSON event, in stream order,
      * right after it is buffered for the reducers. PURE side-channel for the

package/dist/extension/pipeline/runner.js

@@ -132,10 +132,22 @@ export async function runStage(stage, ctx, deps) {
             }
             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.
+        // The caller label defaults from the stage/lens being run; a run id is
+        // included only when the caller (the orchestrator, once its run is tracked)
+        // supplied one — its absence just means this child's completions attribute
+        // to the session id alone.
+        const callerLabel = deps.callerLabel ?? (ctx.lens ? `go:${stage.id}:${ctx.lens}` : `go:${stage.id}`);
+        const childEnv = {
+            ...(deps.env ?? process.env),
+            YAGNI_CALLER: callerLabel,
+            ...(deps.attribution?.runId ? { YAGNI_RUN_ID: deps.attribution.runId } : {}),
+        };
         const exitCode = await new Promise((resolve) => {
             const proc = spawnFn(process.execPath, argv, {
                 cwd: deps.cwd,
-                ...(deps.env ? { env: deps.env } : {}),
+                env: childEnv,
                 shell: false,
                 stdio: ["ignore", "pipe", "pipe"],
             });

package/dist/extension/pipeline/scrubSecrets.js

@@ -16,8 +16,8 @@ const PATTERNS = [
     // (the password segment has no secret-named key and is usually too short for the
     // base64 rule, so it would otherwise survive — common in config/env diffs).
     [/\b([a-z][a-z0-9+.\-]*:\/\/[^\s:@/]+):[^\s:@/]+@/gi, "$1:[REDACTED]@"],
-    // Provider key prefixes (OpenAI, GitHub, Slack, Stripe, AWS access key id, etc.)
-    [/\b(sk-[A-Za-z0-9]{16,}|gh[pousr]_[A-Za-z0-9]{20,}|xox[baprs]-[A-Za-z0-9-]{10,}|AKIA[0-9A-Z]{16}|AIza[0-9A-Za-z_\-]{20,})\b/g, "[REDACTED]"],
+    // Provider key prefixes (OpenAI, Stripe secret/restricted, GitHub, Slack, AWS access key id, etc.)
+    [/\b(sk-[A-Za-z0-9]{16,}|sk_(?:live|test)_[A-Za-z0-9]{16,}|rk_(?:live|test)_[A-Za-z0-9]{16,}|gh[pousr]_[A-Za-z0-9]{20,}|xox[baprs]-[A-Za-z0-9-]{10,}|AKIA[0-9A-Z]{16}|AIza[0-9A-Za-z_\-]{20,})\b/g, "[REDACTED]"],
     // key = "value" / key: value for secret-named keys
     [/\b([A-Za-z0-9_]*(?:secret|password|passwd|api[_-]?key|token|private[_-]?key|access[_-]?key)[A-Za-z0-9_]*)\b(\s*[:=]\s*)("[^"]+"|'[^']+'|`[^`]+`|[^\s"']+)/gi, "$1$2[REDACTED]"],
     // Long base64-ish blobs (likely keys/JWTs)

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

@@ -6,7 +6,9 @@
  * Routing follows the judgment, not the typing: the strongest `peak` tier on the
  * steps that decide-what / catch-wrong (Plan, Review); the `standard` tier on the
  * execution steps (Map, Implement, Fix). The cheaper `efficient` tier stays a
- * selectable catalog tier but is intentionally not wired into a stage here.
+ * candidate for Map (its job is compression, not judgment) — the Task 13
+ * `/go-compare --map-tier` eval lane exists to settle that; map moves down-tier
+ * only once a live eval run clears it.
  *
  * Peak on judgment is affordable precisely BECAUSE the judgment stages are short
  * (YAG-380): plan plus the three review lenses is roughly 21c per round on

package/dist/extension/pipeline/stages.js

@@ -6,7 +6,9 @@
  * Routing follows the judgment, not the typing: the strongest `peak` tier on the
  * steps that decide-what / catch-wrong (Plan, Review); the `standard` tier on the
  * execution steps (Map, Implement, Fix). The cheaper `efficient` tier stays a
- * selectable catalog tier but is intentionally not wired into a stage here.
+ * candidate for Map (its job is compression, not judgment) — the Task 13
+ * `/go-compare --map-tier` eval lane exists to settle that; map moves down-tier
+ * only once a live eval run clears it.
  *
  * Peak on judgment is affordable precisely BECAUSE the judgment stages are short
  * (YAG-380): plan plus the three review lenses is roughly 21c per round on

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

@@ -14,11 +14,14 @@ import type { RunUsage } from "./budget.js";
  * `efficient` for the format-recovery re-ask; `advanced` is not wired into a
  * stage but is the Balanced session's driver tier, so it stays valid here.
  *
- * `balanced` is deliberately NOT a member: it is a session strategy the picker
- * offers, not something a pipeline stage can request. A stage names the tier it
- * actually runs on.
+ * `balanced` IS a member of this union — but only as a "router-decide" landing
+ * spot for agent frontmatter that names the session policy rather than a
+ * concrete tier: `subagents.ts`'s `mapModelTier` maps a `balanced` frontmatter
+ * value to the concrete tier `"standard"` (see its comment), so a stage or
+ * subagent never actually RUNS "balanced" as a resolved tier. A pipeline stage
+ * otherwise names the concrete tier it runs on.
  */
-export type ModelTier = "peak" | "advanced" | "standard" | "efficient";
+export type ModelTier = "peak" | "advanced" | "standard" | "efficient" | "balanced";
 /** The fixed v1 pipeline stages, in order. */
 export type StageId = "map" | "plan" | "implement" | "review" | "fix";
 /**

package/dist/extension/pipeline/verify.js

@@ -46,7 +46,12 @@
  */
 import { execFile } from "node:child_process";
 import { readFileSync } from "node:fs";
-import { basename, dirname, join } from "node:path";
+// posix path math on purpose, on every platform: the rel paths here come from
+// git porcelain output, which is forward-slash even on Windows, and Windows fs
+// APIs accept forward-slash paths — while win32 join/dirname would emit
+// backslashed strings that no longer compare equal to the git-derived repoRoot
+// and would break the walk-up termination check.
+import { basename, dirname, join } from "node:path/posix";
 import { composeAbortSignal } from "./resilience.js";
 import { scrubSecrets } from "./scrubSecrets.js";
 import { snapshotWorkspace } from "./workspace.js";

package/dist/extension/pipeline/worktree.js

@@ -25,7 +25,9 @@
  */
 import { execFile } from "node:child_process";
 import { mkdirSync, readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+// posix join on purpose (see verify.ts): worktree paths are composed from
+// git output and compared as strings; Windows fs APIs accept forward slashes.
+import { dirname, join } from "node:path/posix";
 import { composeAbortSignal } from "./resilience.js";
 import { buildVerifyEnv, detectPackageManager } from "./verify.js";
 /** Wall-clock cap on the best-effort worktree bootstrap install (spec §3b). */

package/dist/extension/provider.d.ts

@@ -6,6 +6,12 @@ import type { ModelEntry } from "./config.js";
  * The provider speaks the `openai-completions` API against `${baseUrl}/v1` and
  * authenticates with the `$YAGNI_TOKEN` env var (resolved by pi at request time).
  * pi — not this extension — performs the actual model calls.
+ *
+ * `headers` (optional) carries the YAG-471 attribution labels — session id, run
+ * id, caller, boost — as plain header values; pi forwards them verbatim on
+ * every completion request this provider makes. They are labels only: the
+ * model proxy uses them to attribute `llm_usage` rows and never rejects a
+ * request over a missing or malformed one.
  */
-export declare function buildYagniProvider(catalog: ModelEntry[], baseUrl: string): ProviderConfig;
+export declare function buildYagniProvider(catalog: ModelEntry[], baseUrl: string, headers?: Record<string, string>): ProviderConfig;
 //# sourceMappingURL=provider.d.ts.map

package/dist/extension/provider.js

@@ -4,8 +4,14 @@
  * The provider speaks the `openai-completions` API against `${baseUrl}/v1` and
  * authenticates with the `$YAGNI_TOKEN` env var (resolved by pi at request time).
  * pi — not this extension — performs the actual model calls.
+ *
+ * `headers` (optional) carries the YAG-471 attribution labels — session id, run
+ * id, caller, boost — as plain header values; pi forwards them verbatim on
+ * every completion request this provider makes. They are labels only: the
+ * model proxy uses them to attribute `llm_usage` rows and never rejects a
+ * request over a missing or malformed one.
  */
-export function buildYagniProvider(catalog, baseUrl) {
+export function buildYagniProvider(catalog, baseUrl, headers) {
     const models = catalog.map((m) => ({
         id: m.id,
         name: m.name,
@@ -21,6 +27,7 @@ export function buildYagniProvider(catalog, baseUrl) {
         apiKey: "$YAGNI_TOKEN",
         api: "openai-completions",
         models,
+        ...(headers ? { headers } : {}),
     };
 }
 //# sourceMappingURL=provider.js.map

package/dist/extension/recall.js

@@ -22,7 +22,7 @@
  *  - skipped entirely when the corpus is thin (<3 active decisions) or eval mode.
  *  - any failure degrades to no injection.
  */
-import { isAbsolute, relative } from "node:path";
+import { isAbsolute, relative, sep } from "node:path";
 import { composeAbortSignal } from "./pipeline/resilience.js";
 /** Recall must never block a read beyond this (spec §4). */
 export const RECALL_TIMEOUT_MS = 1500;
@@ -60,7 +60,10 @@ export function normalizeRecall(data) {
 export function toRepoRelativePath(readPath, cwd) {
     let p = readPath.trim();
     if (isAbsolute(p)) {
-        const rel = relative(cwd, p);
+        // The backend keys judgments by forward-slash repo paths, so the rebased
+        // form must not carry win32 separators (also keeps the per-path session
+        // cache keyed identically across platforms).
+        const rel = relative(cwd, p).split(sep).join("/");
         if (rel && !rel.startsWith("..") && !isAbsolute(rel))
             p = rel;
     }

package/dist/extension/rerouteNotice.d.ts

@@ -0,0 +1,42 @@
+/**
+ * YAG-471 - client-side acknowledgment of a vision-triggered model reroute.
+ *
+ * The backend sets `x-yagni-model-reroute: <requested>-><effective>:vision` on
+ * every response it silently upgrades for image content (yagniCodeV1.ts). pi's
+ * `after_provider_response` event is the only client-side seam that sees raw
+ * response headers (verified against pi 0.83.0's AfterProviderResponseEvent:
+ * `{ type: "after_provider_response", status: number, headers: Record<string,
+ * string> }` in dist/core/extensions/types.d.ts). Its docs (extensions.md,
+ * "after_provider_response") describe `event.headers` as "normalized response
+ * headers" and the shipped example reads `event.headers["retry-after"]` in
+ * lowercase, so header names always arrive lowercase-normalized; this module
+ * matches the header name as given rather than re-normalizing case.
+ */
+/** A parsed reroute: the tier the caller requested vs the tier that actually served it. */
+export interface Reroute {
+    from: string;
+    to: string;
+    reason: string;
+}
+/** pi's AfterProviderResponseEvent types headers as Record<string, string>. */
+export type HeaderMap = Record<string, string | undefined>;
+/**
+ * Parse the `x-yagni-model-reroute` header. Returns null when the header is
+ * absent, does not match `<from>-><to>:<reason>`, or the reason is not
+ * "vision" (the notice copy says "Your image", which only a vision reroute
+ * can honestly claim).
+ */
+export declare function parseReroute(headers: HeaderMap): Reroute | null;
+/**
+ * Dedupe wrapper around {@link parseReroute}: `observe` returns the notice
+ * message at most once per distinct from->to pair for the life of the
+ * instance (i.e. per session), and null otherwise (absent, malformed, or
+ * already-seen). Returning the message rather than taking a notify callback
+ * keeps the caller in charge of the ctx it has on hand at call time, instead
+ * of this class holding a stale reference across calls.
+ */
+export declare class RerouteNotifier {
+    private readonly seen;
+    observe(headers: HeaderMap): string | null;
+}
+//# sourceMappingURL=rerouteNotice.d.ts.map

package/dist/extension/rerouteNotice.js

@@ -0,0 +1,67 @@
+/**
+ * YAG-471 - client-side acknowledgment of a vision-triggered model reroute.
+ *
+ * The backend sets `x-yagni-model-reroute: <requested>-><effective>:vision` on
+ * every response it silently upgrades for image content (yagniCodeV1.ts). pi's
+ * `after_provider_response` event is the only client-side seam that sees raw
+ * response headers (verified against pi 0.83.0's AfterProviderResponseEvent:
+ * `{ type: "after_provider_response", status: number, headers: Record<string,
+ * string> }` in dist/core/extensions/types.d.ts). Its docs (extensions.md,
+ * "after_provider_response") describe `event.headers` as "normalized response
+ * headers" and the shipped example reads `event.headers["retry-after"]` in
+ * lowercase, so header names always arrive lowercase-normalized; this module
+ * matches the header name as given rather than re-normalizing case.
+ */
+const REROUTE_HEADER = "x-yagni-model-reroute";
+const REROUTE_PATTERN = /^(.+?)->(.+?):(\w+)$/;
+/**
+ * Parse the `x-yagni-model-reroute` header. Returns null when the header is
+ * absent, does not match `<from>-><to>:<reason>`, or the reason is not
+ * "vision" (the notice copy says "Your image", which only a vision reroute
+ * can honestly claim).
+ */
+export function parseReroute(headers) {
+    const value = headers[REROUTE_HEADER];
+    if (!value)
+        return null;
+    const match = REROUTE_PATTERN.exec(value);
+    if (!match)
+        return null;
+    const [, from, to, reason] = match;
+    if (reason !== "vision")
+        return null;
+    return { from, to, reason };
+}
+/**
+ * Dedupe wrapper around {@link parseReroute}: `observe` returns the notice
+ * message at most once per distinct from->to pair for the life of the
+ * instance (i.e. per session), and null otherwise (absent, malformed, or
+ * already-seen). Returning the message rather than taking a notify callback
+ * keeps the caller in charge of the ctx it has on hand at call time, instead
+ * of this class holding a stale reference across calls.
+ */
+export class RerouteNotifier {
+    seen = new Set();
+    observe(headers) {
+        const reroute = parseReroute(headers);
+        if (!reroute)
+            return null;
+        const key = `${reroute.from}->${reroute.to}`;
+        if (this.seen.has(key))
+            return null;
+        this.seen.add(key);
+        // balanced is a ROUTING POLICY, never a price (rateCard.ts's
+        // assertBillableTier throws if it ever reaches pricing) — for a balanced
+        // reroute the bill IS the resolved tier (`reroute.to`; yagniCodeV1.ts's
+        // `billedTier` takes its `effectiveModel` arm here), so a "Billed as
+        // balanced" clause would name a non-price. Only a CONCRETE from-tier
+        // still bills at its own pre-reroute rate (Task 3's invariant: a re-route
+        // never moves anyone's price), so only then is a distinct "Billed as X"
+        // line honest.
+        if (reroute.from === "balanced") {
+            return `Your image was handled on the ${reroute.to} tier.`;
+        }
+        return `Your image was handled on the ${reroute.to} tier. Billed as ${reroute.from}.`;
+    }
+}
+//# sourceMappingURL=rerouteNotice.js.map

package/dist/extension/sessionRuns.d.ts

@@ -0,0 +1,45 @@
+/**
+ * YAG-383: tracks the `/go` run ids a driver session has launched, so /cost's
+ * server-authoritative spend fetch can widen its query to include them.
+ *
+ * The backend writes a run-attributed dispatch's `llm_usage.session_id` as
+ * the RUN id, not the driver session id (see attributionHeaders in
+ * config.ts: a `/go` child's completions carry `x-yagni-run-id`, and the
+ * proxy stores THAT in `session_id` — the run id wins, by design, so a
+ * per-run query works on its own). A plain `GET /api/yagni-code/spend?
+ * sessionId=<driver>` therefore never sees a single `/go` run's spend: it is
+ * real spend, billed under this session's work, but invisible to that query.
+ * `/cost` (index.ts's `fetchSpend`) closes that gap by also asking for every
+ * run id this process has launched, via `runIds=`.
+ *
+ * Module-level state is the right shape here: one CLI process IS one driver
+ * session, so "run ids this process has launched" and "run ids this session
+ * has launched" are the same list. Capped at the most recent
+ * `MAX_TRACKED_RUN_IDS` so an extremely long-lived session's /cost call never
+ * grows an unbounded query string (the backend independently caps `runIds` at
+ * the same number — see MAX_SPEND_RUN_IDS in routes/yagniCode.ts — capping
+ * symmetrically here keeps a stable, useful most-recent set instead of
+ * trailing off into a 400 from the server).
+ */
+/**
+ * Record a `/go` run id once it is known (the goCommand.ts seam right after
+ * `runSession.start()` resolves). Ignores anything that is not UUID-shaped
+ * and de-dupes a repeat call for the same run (a resumed/re-adopted run can
+ * report the same id twice) — both defensive, since a malformed value here
+ * must never corrupt /cost's query string.
+ */
+export declare function recordSessionRun(runId: string): void;
+/** The run ids recorded so far this process, oldest first, capped. */
+export declare function sessionRunIds(): string[];
+/**
+ * How many run ids this session has ever dropped off the front of the
+ * `MAX_TRACKED_RUN_IDS` cap. Zero for the overwhelming majority of sessions
+ * (20 `/go` runs in one process is a lot); /cost's server rendering
+ * (costHud.ts's `formatServerCostLines`) surfaces this as an "Excludes N
+ * earlier /go runs." note when it is nonzero, so a long session's spend total
+ * is never silently missing runs with no explanation.
+ */
+export declare function droppedSessionRuns(): number;
+/** Test-only reset: module-level state otherwise leaks across test files/cases. */
+export declare function _resetSessionRunsForTest(): void;
+//# sourceMappingURL=sessionRuns.d.ts.map