@yagni-app/code-staging 0.2.1-staging.1027.1 → 0.2.1-staging.1032.1

package/dist/cli.js

@@ -161,7 +161,7 @@ export const HELP_TEXT = [
     "  yagni version            Print the CLI version.",
     "",
     "Common agent flags (passed straight through):",
-    "  --model <tier>           Pick the model tier (balanced by default).",
+    "  --model <tier>           Model tier (fixed to advanced).",
     "  --thinking <level>       off | minimal | low | medium | high | xhigh | max",
     "  --session <id>           Open a specific session; --fork <id> branches one.",
     "  --mode json              Emit machine-readable events (for scripts and CI).",

package/dist/extension/advisor.d.ts

@@ -22,8 +22,8 @@
  * State is held in a closure via {@link makeAdvisorState}; no module-level
  * mutable state, so two sessions in one process cannot bleed into each other.
  */
-/** The session tier that may escalate. Balanced only, by design. */
-export declare const ADVISOR_TIER = "balanced";
+/** The session tier that may escalate. Advanced only, by design. */
+export declare const ADVISOR_TIER = "advanced";
 /** The tier a consult itself runs on. */
 export declare const ADVISOR_MODEL_TIER = "peak";
 /** Bounds on escalation within a single session. */
@@ -64,8 +64,8 @@ export interface ConsultGateInput {
  * The tier check reads the model at CALL time rather than at registration time:
  * tools register once at activation but pi's picker can switch the session model
  * afterwards, so a registration-time check would both leave the tool live after
- * switching away from Balanced and hide it forever from a session that switched
- * to Balanced.
+ * switching away from Advanced and hide it forever from a session that switched
+ * to Advanced.
  */
 export declare function decideConsult(input: ConsultGateInput): ConsultDecision;
 /**

package/dist/extension/advisor.js

@@ -22,8 +22,8 @@
  * State is held in a closure via {@link makeAdvisorState}; no module-level
  * mutable state, so two sessions in one process cannot bleed into each other.
  */
-/** The session tier that may escalate. Balanced only, by design. */
-export const ADVISOR_TIER = "balanced";
+/** The session tier that may escalate. Advanced only, by design. */
+export const ADVISOR_TIER = "advanced";
 /** The tier a consult itself runs on. */
 export const ADVISOR_MODEL_TIER = "peak";
 export const DEFAULT_ADVISOR_LIMITS = {
@@ -49,17 +49,16 @@ export function makeAdvisorState() {
  * The tier check reads the model at CALL time rather than at registration time:
  * tools register once at activation but pi's picker can switch the session model
  * afterwards, so a registration-time check would both leave the tool live after
- * switching away from Balanced and hide it forever from a session that switched
- * to Balanced.
+ * switching away from Advanced and hide it forever from a session that switched
+ * to Advanced.
  */
 export function decideConsult(input) {
     const { model, state, limits } = input;
     if (model !== ADVISOR_TIER) {
         return {
             allow: false,
-            reason: `ask_advisor is only available on the Balanced tier (this session is on ` +
-                `"${model ?? "unknown"}"). Switch the model to Balanced to consult the ` +
-                `peak-tier advisor, or reason it through on the current tier.`,
+            reason: `ask_advisor is only available on the Advanced tier (this session is on ` +
+                `"${model ?? "unknown"}").`,
         };
     }
     if (state.consults >= limits.maxConsults) {

package/dist/extension/askAdvisorTool.d.ts

@@ -1,7 +1,7 @@
 /**
- * `ask_advisor` — the peak-tier escalation available to Balanced sessions (YAG-380).
+ * `ask_advisor` — the peak-tier escalation available to Advanced sessions (YAG-380).
  *
- * Cheap driver, expensive consultant: a Balanced session drives on `advanced` and
+ * Cheap driver, expensive consultant: an Advanced session drives on `advanced` and
  * calls this when it hits a judgment call worth the strongest model. The consult
  * spawns a child pi at `peak` through the same `runStage` seam `/go` uses, and
  * returns the advice as plain TEXT the driver acts on — text we own, so

package/dist/extension/askAdvisorTool.js

@@ -1,7 +1,7 @@
 /**
- * `ask_advisor` — the peak-tier escalation available to Balanced sessions (YAG-380).
+ * `ask_advisor` — the peak-tier escalation available to Advanced sessions (YAG-380).
  *
- * Cheap driver, expensive consultant: a Balanced session drives on `advanced` and
+ * Cheap driver, expensive consultant: an Advanced session drives on `advanced` and
  * calls this when it hits a judgment call worth the strongest model. The consult
  * spawns a child pi at `peak` through the same `runStage` seam `/go` uses, and
  * returns the advice as plain TEXT the driver acts on — text we own, so
@@ -79,7 +79,7 @@ export function makeAskAdvisorTool(opts) {
         label: "Ask the advisor",
         description: "Escalate ONE hard judgment call to the peak-tier advisor — the strongest " +
             "model available, which reads the code itself and returns a recommendation. " +
-            "Available only on the Balanced tier, and capped per session, so use it for " +
+            "Available only on the Advanced tier, and capped per session, so use it for " +
             "calls that are genuinely worth it: an architectural fork with no obvious " +
             "right answer, a subtle correctness question you cannot settle by reading, " +
             "a change whose blast radius you are unsure of, or a second opinion before " +
@@ -87,7 +87,7 @@ export function makeAskAdvisorTool(opts) {
             "lookups (use ask_yagni), for anything you can settle by reading the code, " +
             "or to review work you have already finished. Pass a sharp question plus the " +
             "relevant excerpts — never a conversation transcript.",
-        promptSnippet: "ask_advisor: escalate one hard judgment call to the peak-tier advisor (Balanced sessions, capped).",
+        promptSnippet: "ask_advisor: escalate one hard judgment call to the peak-tier advisor (Advanced sessions, capped).",
         promptGuidelines: [
             "Call ask_advisor only for a genuine judgment fork — an architectural choice, a subtle correctness question, or a second opinion before an approach you would have to unwind. Reading the code is cheaper; do that first.",
             "Ask ONE specific question per consult, and include the excerpts that matter. The advisor reads the repo itself, so point it at the right place rather than pasting everything.",
@@ -159,7 +159,7 @@ export function makeAskAdvisorTool(opts) {
  */
 export function registerAdviseCommand(pi, tool) {
     pi.registerCommand("advise", {
-        description: "Escalate one hard call to the peak-tier advisor (Balanced sessions only, capped per session).",
+        description: "Escalate one hard call to the peak-tier advisor (Advanced sessions only, capped per session).",
         handler: async (args, ctx) => {
             const notify = (message, type) => {
                 if (ctx.hasUI)

package/dist/extension/config.js

@@ -129,8 +129,6 @@ export function attributionHeaders(env = process.env) {
         headers["x-yagni-run-id"] = runId;
     const caller = env.YAGNI_CALLER ?? "";
     headers["x-yagni-caller"] = CALLER_LABEL_RE.test(caller) ? caller : "driver";
-    if (env.YAGNI_BOOST === "1")
-        headers["x-yagni-boost"] = "1";
     return headers;
 }
 /**

package/dist/extension/costHud.d.ts

@@ -52,7 +52,20 @@ export interface Headroom {
     remaining: number;
     unit: string;
 }
-export declare function formatCostLine(snap: CostSnapshot, headroom?: Headroom | null, advisorLine?: string, source?: string, boosted?: boolean): string;
+/**
+ * Render the /cost line. Pure, no em-dashes. `headroom` null means it was
+ * unavailable. `advisorLine` is the ask_advisor subtotal (empty when the session
+ * never escalated). `source`, when given, is parenthesized right after "Session
+ * usage", used to explicitly label this as the LOCAL, driver-only fallback when
+ * the server-authoritative spend fetch is unavailable (see
+ * {@link formatServerCostLines}, the preferred path).
+ *
+ * HONESTY NOTE: this counter can only see the DRIVER session, because it is fed
+ * by pi's `turn_end`. Work that runs in a child process — every /go stage, and
+ * every advisor consult — never emits a parent `turn_end`, so it is invisible
+ * here. The advisor subtotal is threaded in explicitly for exactly that reason.
+ */
+export declare function formatCostLine(snap: CostSnapshot, headroom?: Headroom | null, advisorLine?: string, source?: string): string;
 /**
  * One row of `GET /api/yagni-code/spend`'s per-caller x rate-tier breakdown.
  * Mirrored locally rather than importing `@yagni/shared`, since this extension
@@ -102,25 +115,15 @@ export declare const usd: (millicents: number) => string;
  * (joined with "\n").
  *
  * Line order: total spend, one line per rate tier (aggregated across callers,
- * sorted by spend descending), a boosted-spend subtotal per tier that has any
- * boosted rows, a live-toggle boost line (see below), the savings line (only
+ * sorted by spend descending), the savings line (only
  * when a counterfactual total resolved), an incomplete-counterfactual note,
  * an unbilled note, a dropped-run-ids note (carry-over from the /cost
  * re-review — see sessionRuns.ts's `droppedSessionRuns`), then headroom.
  *
  * `droppedRunCount` defaults to 0 (no note) so every existing direct caller
  * of this pure function keeps behaving identically without passing it.
- *
- * `boosted` (default false) is the LIVE client-side toggle from
- * `boostCommand.ts`'s `isBoosted()`, threaded in exactly like `advisorLine`
- * is for {@link formatCostLine}. It is independent of the per-tier "Boosted
- * (tier) spend" subtotal above: that subtotal only reflects server rows
- * carrying `x-yagni-boost`, which only `/go` children (and other spawned
- * processes) ever send — the driver's own turns never do (see
- * boostCommand.ts's KNOWN-asymmetry docblock). Without this flag, a session
- * that only chats while boosted would show no boost line at all.
  */
-export declare function formatServerCostLines(spend: SpendResponse, headroom?: Headroom | null, droppedRunCount?: number, boosted?: boolean): string;
+export declare function formatServerCostLines(spend: SpendResponse, headroom?: Headroom | null, droppedRunCount?: number): string;
 export interface RegisterCostDeps {
     /** Fetch remaining credit headroom; return null when unavailable. Fail-soft. */
     fetchHeadroom?: (signal?: AbortSignal) => Promise<Headroom | null>;
@@ -132,15 +135,6 @@ export interface RegisterCostDeps {
      * ordinary caller row.
      */
     advisorSubtotal?: () => string;
-    /**
-     * Whether the session is currently boosted to Peak (boostCommand.ts's
-     * `isBoosted()`, threaded in the same way as `advisorSubtotal`). Unlike
-     * `advisorSubtotal`, this is read on BOTH the server-authoritative and the
-     * local-fallback branch: the driver's own turns never carry a server-side
-     * boost marker (see boostCommand.ts's KNOWN-asymmetry docblock), so this is
-     * the only signal that would otherwise be missing from the server branch.
-     */
-    isBoosted?: () => boolean;
     /**
      * Fetch the server-authoritative session spend (YAG-383). Absent, throwing,
      * or resolving null all fall back to the local `turn_end` accumulator, with

package/dist/extension/costHud.js

@@ -75,21 +75,18 @@ const fmt = (n) => n.toLocaleString("en-US");
  * every advisor consult — never emits a parent `turn_end`, so it is invisible
  * here. The advisor subtotal is threaded in explicitly for exactly that reason.
  */
-/** The boost-active line appended to /cost, both branches (see boostCommand.ts's docblock for why). */
-const BOOST_LINE = "Boost is on. Driver turns bill at the peak tier.";
-export function formatCostLine(snap, headroom, advisorLine, source, boosted = false) {
+export function formatCostLine(snap, headroom, advisorLine, source) {
     const turns = `${snap.turns} turn${snap.turns === 1 ? "" : "s"}`;
     const cached = snap.cacheRead > 0 ? ` (${fmt(snap.cacheRead)} cached)` : "";
     const label = source ? `Session usage (${source})` : "Session usage";
     const base = `${label}: ${turns}, ${fmt(snap.input)} in / ${fmt(snap.output)} out tokens${cached}, ` +
         `$${snap.cost.toFixed(2)} this session.`;
     const advisor = advisorLine?.trim() ? ` ${advisorLine.trim()}` : "";
-    const boost = boosted ? ` ${BOOST_LINE}` : "";
     if (headroom)
-        return `${base}${advisor}${boost} Credit headroom: ${headroom.remaining} ${headroom.unit}.`;
+        return `${base}${advisor} Credit headroom: ${headroom.remaining} ${headroom.unit}.`;
     if (headroom === null)
-        return `${base}${advisor}${boost} Credit headroom unavailable right now.`;
-    return `${base}${advisor}${boost}`;
+        return `${base}${advisor} Credit headroom unavailable right now.`;
+    return `${base}${advisor}`;
 }
 /**
  * Millicents (1/1000 of a cent) -> dollars, 2 decimals. Guards against a
@@ -115,25 +112,15 @@ export const usd = (millicents) => {
  * (joined with "\n").
  *
  * Line order: total spend, one line per rate tier (aggregated across callers,
- * sorted by spend descending), a boosted-spend subtotal per tier that has any
- * boosted rows, a live-toggle boost line (see below), the savings line (only
+ * sorted by spend descending), the savings line (only
  * when a counterfactual total resolved), an incomplete-counterfactual note,
  * an unbilled note, a dropped-run-ids note (carry-over from the /cost
  * re-review — see sessionRuns.ts's `droppedSessionRuns`), then headroom.
  *
  * `droppedRunCount` defaults to 0 (no note) so every existing direct caller
  * of this pure function keeps behaving identically without passing it.
- *
- * `boosted` (default false) is the LIVE client-side toggle from
- * `boostCommand.ts`'s `isBoosted()`, threaded in exactly like `advisorLine`
- * is for {@link formatCostLine}. It is independent of the per-tier "Boosted
- * (tier) spend" subtotal above: that subtotal only reflects server rows
- * carrying `x-yagni-boost`, which only `/go` children (and other spawned
- * processes) ever send — the driver's own turns never do (see
- * boostCommand.ts's KNOWN-asymmetry docblock). Without this flag, a session
- * that only chats while boosted would show no boost line at all.
  */
-export function formatServerCostLines(spend, headroom, droppedRunCount = 0, boosted = false) {
+export function formatServerCostLines(spend, headroom, droppedRunCount = 0) {
     const lines = [`Session spend: $${usd(spend.totalSellMillicents)} (server).`];
     const tierTotals = new Map();
     for (const row of spend.rows) {
@@ -147,23 +134,6 @@ export function formatServerCostLines(spend, headroom, droppedRunCount = 0, boos
         const calls = `${fmt(agg.dispatches)} call${agg.dispatches === 1 ? "" : "s"}`;
         lines.push(`  ${tier}: $${usd(agg.sellMillicents)} over ${calls}.`);
     }
-    const boostTotals = new Map();
-    for (const row of spend.rows) {
-        if (!row.boost)
-            continue;
-        boostTotals.set(row.rateTier, (boostTotals.get(row.rateTier) ?? 0) + row.sellMillicents);
-    }
-    if (boostTotals.size > 0) {
-        for (const [tier] of tiersSorted) {
-            const tierBoosted = boostTotals.get(tier);
-            if (tierBoosted === undefined)
-                continue;
-            lines.push(`  Boosted (${tier}) spend: $${usd(tierBoosted)}.`);
-        }
-    }
-    if (boosted) {
-        lines.push(BOOST_LINE);
-    }
     // typeof guard (not just !== null): a network response is untyped at
     // runtime, and a stray string/boolean here must never sneak "NN%" into the
     // rendered line.
@@ -233,15 +203,6 @@ export function registerCostCommand(pi, deps = {}) {
                     : Promise.resolve(null),
             ]);
             const localSnap = acc.snapshot();
-            // Read fresh on every /cost call, both branches (see RegisterCostDeps's
-            // isBoosted doc comment for why the local fallback needs it too).
-            let boosted = false;
-            try {
-                boosted = deps.isBoosted?.() ?? false;
-            }
-            catch {
-                /* a diagnostic must never break /cost */
-            }
             // Quiet divergence check: both totals must be available, and it never
             // affects what the user sees. Scoped to `caller === "driver"` rows only
             // (like-for-like with the local `turn_end` accumulator, which can only
@@ -276,7 +237,7 @@ export function registerCostCommand(pi, deps = {}) {
                 catch {
                     /* a diagnostic must never break /cost */
                 }
-                await pi.sendUserMessage(formatServerCostLines(spend, headroom, dropped, boosted));
+                await pi.sendUserMessage(formatServerCostLines(spend, headroom, dropped));
                 return;
             }
             let advisorLine = "";
@@ -286,7 +247,7 @@ export function registerCostCommand(pi, deps = {}) {
             catch {
                 /* usage accounting must never break /cost */
             }
-            await pi.sendUserMessage(formatCostLine(localSnap, headroom, advisorLine, "local, driver only", boosted));
+            await pi.sendUserMessage(formatCostLine(localSnap, headroom, advisorLine, "local, driver only"));
         },
     });
 }

package/dist/extension/footer.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Custom footer for the YAGNI CLI — replaces pi's built-in footer.
+ *
+ * Renders three lines:
+ *   1. folder  ·  [worktree]  ·  branch        (git context; ~-path fallback off-repo)
+ *   2. model  ·  ↑in ↓out $cost  ·  ctx%        (session stats; context % is an integer)
+ *   3. extension statuses                       (branding, todo counter, mode) joined by " · "
+ *
+ * --- How to customize the status bar (for future tickets) ---
+ *
+ * LIFECYCLE: `ctx.ui.setFooter()` is NOT available at extension factory time.
+ * The `pi` (ExtensionAPI) object passed to the factory has no UI methods —
+ * they live on `ctx.ui` (ExtensionUIContext), which is only bound after
+ * `_applyExtensionBindings` runs, immediately before the `session_start`
+ * event. So the footer must be set inside a `pi.on("session_start", ...)`
+ * handler, guarded by `ctx.mode === "tui"` (no footer in RPC/print mode).
+ * See index.ts's session_start handler for the wiring, and pi's
+ * `docs/extensions.md` § "Widgets, Status, and Footer" + the `custom-header.ts`
+ * example for the canonical pattern.
+ *
+ * FACTORY SIGNATURE: `setFooter((tui, theme, footerData) => Component)` where:
+ *   - `tui` — the TUI instance (screen dimensions, focus)
+ *   - `theme` — the current Theme (use `theme.fg("dim", text)` etc.)
+ *   - `footerData` — ReadonlyFooterDataProvider: `getGitBranch()`,
+ *     `getExtensionStatuses()` (statuses set via `ctx.ui.setStatus(key, text)`),
+ *     `getAvailableProviderCount()`
+ * Model info, token stats, and context usage are NOT on `footerData` — they're
+ * on `ctx` (the ExtensionContext passed to the session_start handler):
+ * `ctx.model`, `ctx.sessionManager`, `ctx.getContextUsage()`. Thread them
+ * through a closure if the footer needs them (this module's
+ * `createYagniFooterFactory` does exactly that).
+ *
+ * COMPONENT CONTRACT: the returned object needs `render(width: number): string[]`
+ * (returns the lines to display, one string per row) and `invalidate()` (called
+ * when the component should re-render). Optionally `dispose()` for cleanup.
+ *
+ * REFERENCE: pi's built-in footer lives at
+ * `node_modules/@earendil-works/pi-coding-agent/dist/modes/interactive/components/footer.js`
+ * — useful reference for what data to replicate and how to format it.
+ */
+import type { ExtensionContext, ReadonlyFooterDataProvider, Theme } from "@earendil-works/pi-coding-agent";
+export declare const BRANCH_MAX_WIDTH = 60;
+/** Format token counts for compact footer display (mirrors pi's formatTokens). */
+export declare function formatTokens(count: number): string;
+/** Shorten cwd relative to home, like pi's built-in footer. */
+export declare function formatCwd(cwd: string, home: string | undefined): string;
+interface UsageTotals {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    cost: number;
+}
+/** Accumulate usage from all session entries (mirrors pi's built-in footer). */
+export declare function collectUsage(sessionManager: ExtensionContext["sessionManager"]): UsageTotals;
+export interface GitInfo {
+    /** Repo-root folder basename (the MAIN repo, stable across worktrees), or ~-path off-repo. */
+    folder: string;
+    inRepo: boolean;
+    /** Current branch, null off-repo. "detached" on detached HEAD. */
+    branch: string | null;
+    /** Linked-worktree label for [brackets], or null to hide. */
+    worktree: string | null;
+}
+/** Git probes `resolveWorktreeLabel` needs, injectable so the rules can be unit-tested. */
+export interface WorktreeProbes {
+    isLinkedWorktree(repoRoot: string): boolean;
+    worktrees(repoRoot: string): string[];
+}
+/**
+ * Show [worktree] only on a LINKED worktree (never the main checkout), when the repo has
+ * >1 worktree, AND the dir differs from the branch slug. The main checkout is the default
+ * context and earns no label; a [bracket] only disambiguates a secondary working tree.
+ */
+export declare function resolveWorktreeLabel(repoRoot: string, branch: string | null, probes?: WorktreeProbes): string | null;
+/**
+ * Detect git info for a cwd, gracefully. Never throws: non-git folders, missing git
+ * binary, and corrupt repos all degrade to a safe partial/empty result.
+ */
+export declare function detectGitInfo(cwd: string, home: string | undefined): GitInfo;
+/** Pure line-builder, exported for tests. All data injected; colors via theme. */
+export declare function renderFooterLines(input: {
+    git: GitInfo;
+    model: string;
+    usage: UsageTotals;
+    contextPercent: number | null;
+    statuses: string[];
+}, theme: Pick<Theme, "fg">, width: number): string[];
+/**
+ * Create a footer factory that captures the session `ctx` (for session data)
+ * and returns the component `setFooter` expects. Called from the
+ * `session_start` handler in index.ts.
+ */
+export declare function createYagniFooterFactory(ctx: ExtensionContext): (_tui: unknown, theme: Theme, footerData: ReadonlyFooterDataProvider) => {
+    render(width: number): string[];
+    invalidate(): void;
+    dispose(): void;
+};
+export {};
+//# sourceMappingURL=footer.d.ts.map

package/dist/extension/footer.js

@@ -0,0 +1,272 @@
+/**
+ * Custom footer for the YAGNI CLI — replaces pi's built-in footer.
+ *
+ * Renders three lines:
+ *   1. folder  ·  [worktree]  ·  branch        (git context; ~-path fallback off-repo)
+ *   2. model  ·  ↑in ↓out $cost  ·  ctx%        (session stats; context % is an integer)
+ *   3. extension statuses                       (branding, todo counter, mode) joined by " · "
+ *
+ * --- How to customize the status bar (for future tickets) ---
+ *
+ * LIFECYCLE: `ctx.ui.setFooter()` is NOT available at extension factory time.
+ * The `pi` (ExtensionAPI) object passed to the factory has no UI methods —
+ * they live on `ctx.ui` (ExtensionUIContext), which is only bound after
+ * `_applyExtensionBindings` runs, immediately before the `session_start`
+ * event. So the footer must be set inside a `pi.on("session_start", ...)`
+ * handler, guarded by `ctx.mode === "tui"` (no footer in RPC/print mode).
+ * See index.ts's session_start handler for the wiring, and pi's
+ * `docs/extensions.md` § "Widgets, Status, and Footer" + the `custom-header.ts`
+ * example for the canonical pattern.
+ *
+ * FACTORY SIGNATURE: `setFooter((tui, theme, footerData) => Component)` where:
+ *   - `tui` — the TUI instance (screen dimensions, focus)
+ *   - `theme` — the current Theme (use `theme.fg("dim", text)` etc.)
+ *   - `footerData` — ReadonlyFooterDataProvider: `getGitBranch()`,
+ *     `getExtensionStatuses()` (statuses set via `ctx.ui.setStatus(key, text)`),
+ *     `getAvailableProviderCount()`
+ * Model info, token stats, and context usage are NOT on `footerData` — they're
+ * on `ctx` (the ExtensionContext passed to the session_start handler):
+ * `ctx.model`, `ctx.sessionManager`, `ctx.getContextUsage()`. Thread them
+ * through a closure if the footer needs them (this module's
+ * `createYagniFooterFactory` does exactly that).
+ *
+ * COMPONENT CONTRACT: the returned object needs `render(width: number): string[]`
+ * (returns the lines to display, one string per row) and `invalidate()` (called
+ * when the component should re-render). Optionally `dispose()` for cleanup.
+ *
+ * REFERENCE: pi's built-in footer lives at
+ * `node_modules/@earendil-works/pi-coding-agent/dist/modes/interactive/components/footer.js`
+ * — useful reference for what data to replicate and how to format it.
+ */
+import { spawnSync } from "node:child_process";
+import { statSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+export const BRANCH_MAX_WIDTH = 60;
+const WORKTREE_MAX_WIDTH = 30;
+/** Section separator: single space + middle dot + single space. */
+const SEP = " · ";
+/** Format token counts for compact footer display (mirrors pi's formatTokens). */
+export function formatTokens(count) {
+    if (count < 1000)
+        return count.toString();
+    if (count < 10000)
+        return `${(count / 1000).toFixed(1)}k`;
+    if (count < 1000000)
+        return `${Math.round(count / 1000)}k`;
+    if (count < 10000000)
+        return `${(count / 1000000).toFixed(1)}M`;
+    return `${Math.round(count / 1000000)}M`;
+}
+/** Shorten cwd relative to home, like pi's built-in footer. */
+export function formatCwd(cwd, home) {
+    if (!home)
+        return cwd;
+    const resolvedCwd = resolve(cwd);
+    const resolvedHome = resolve(home);
+    const rel = relative(resolvedHome, resolvedCwd);
+    const inside = rel === "" ||
+        (rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel));
+    return inside ? (rel === "" ? "~" : `~/${rel}`) : cwd;
+}
+/** Accumulate usage from all session entries (mirrors pi's built-in footer). */
+export function collectUsage(sessionManager) {
+    const totals = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
+    for (const entry of sessionManager.getEntries()) {
+        let u;
+        if (entry.type === "message" && entry.message.role === "assistant") {
+            u = entry.message.usage;
+        }
+        else if (entry.type === "message" && entry.message.role === "toolResult" && entry.message.usage) {
+            u = entry.message.usage;
+        }
+        else if ((entry.type === "branch_summary" || entry.type === "compaction") && entry.usage) {
+            u = entry.usage;
+        }
+        if (u) {
+            totals.input += u.input;
+            totals.output += u.output;
+            totals.cacheRead += u.cacheRead;
+            totals.cacheWrite += u.cacheWrite;
+            totals.cost += u.cost.total;
+        }
+    }
+    return totals;
+}
+/** End-cut ellipsis truncation (ANSI-aware) so the branch prefix stays readable. */
+function truncateEnd(text, maxWidth) {
+    if (visibleWidth(text) <= maxWidth)
+        return text;
+    return truncateToWidth(text, maxWidth, "…");
+}
+function runGit(args, cwd) {
+    try {
+        const r = spawnSync("git", ["--no-optional-locks", ...args], {
+            cwd,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        if (r.error || r.status !== 0)
+            return null;
+        return r.stdout.trim();
+    }
+    catch {
+        return null;
+    }
+}
+function gitRepoRoot(cwd) {
+    return runGit(["rev-parse", "--show-toplevel"], cwd) || null;
+}
+function gitBranch(repoRoot) {
+    const out = runGit(["symbolic-ref", "--quiet", "--short", "HEAD"], repoRoot);
+    if (out)
+        return out;
+    // Detached HEAD, or repo with no commits yet.
+    return runGit(["rev-parse", "--verify", "HEAD"], repoRoot) ? "detached" : null;
+}
+function gitWorktrees(repoRoot) {
+    const out = runGit(["worktree", "list", "--porcelain"], repoRoot);
+    if (!out)
+        return [];
+    return out
+        .split("\n")
+        .filter((l) => l.startsWith("worktree "))
+        .map((l) => l.slice("worktree ".length).trim())
+        .filter(Boolean);
+}
+/** The MAIN repository root (stable across worktrees) — used for the folder name. */
+function gitMainRepoRoot(repoRoot) {
+    const common = runGit(["rev-parse", "--git-common-dir"], repoRoot);
+    if (!common)
+        return repoRoot;
+    const abs = isAbsolute(common) ? common : join(repoRoot, common);
+    return basename(abs) === ".git" ? dirname(abs) : repoRoot;
+}
+/** Main checkout: .git is a directory. Linked worktree: .git is a "gitdir:" file. */
+function isLinkedWorktree(repoRoot) {
+    try {
+        return statSync(join(repoRoot, ".git")).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+const liveWorktreeProbes = { isLinkedWorktree, worktrees: gitWorktrees };
+/**
+ * Show [worktree] only on a LINKED worktree (never the main checkout), when the repo has
+ * >1 worktree, AND the dir differs from the branch slug. The main checkout is the default
+ * context and earns no label; a [bracket] only disambiguates a secondary working tree.
+ */
+export function resolveWorktreeLabel(repoRoot, branch, probes = liveWorktreeProbes) {
+    if (!probes.isLinkedWorktree(repoRoot))
+        return null;
+    if (probes.worktrees(repoRoot).length < 2)
+        return null;
+    const currentDir = basename(repoRoot);
+    if (branch && currentDir === branch)
+        return null;
+    return truncateEnd(currentDir, WORKTREE_MAX_WIDTH);
+}
+/**
+ * Detect git info for a cwd, gracefully. Never throws: non-git folders, missing git
+ * binary, and corrupt repos all degrade to a safe partial/empty result.
+ */
+export function detectGitInfo(cwd, home) {
+    const root = gitRepoRoot(cwd);
+    if (!root) {
+        return { folder: formatCwd(cwd, home), inRepo: false, branch: null, worktree: null };
+    }
+    const branch = gitBranch(root);
+    const worktree = resolveWorktreeLabel(root, branch);
+    return { folder: basename(gitMainRepoRoot(root)), inRepo: true, branch, worktree };
+}
+/** Context color: dim below 70, warning 70-90, error above 90. */
+function contextColor(percent) {
+    if (percent === null)
+        return "dim";
+    if (percent > 90)
+        return "error";
+    if (percent > 70)
+        return "warning";
+    return "dim";
+}
+/** Pure line-builder, exported for tests. All data injected; colors via theme. */
+export function renderFooterLines(input, theme, width) {
+    const dim = (s) => theme.fg("dim", s);
+    const sep = dim(SEP);
+    // Line 1: folder · [worktree] · branch
+    const line1Parts = [theme.fg("accent", input.git.folder)];
+    if (input.git.inRepo) {
+        if (input.git.worktree)
+            line1Parts.push(theme.fg("warning", `[${input.git.worktree}]`));
+        if (input.git.branch)
+            line1Parts.push(theme.fg("border", truncateEnd(input.git.branch, BRANCH_MAX_WIDTH)));
+    }
+    const line1 = truncateToWidth(line1Parts.join(sep), width, dim("…"));
+    // Line 2: model · ↑in ↓out $cost · ctx%
+    const statParts = [];
+    if (input.usage.input)
+        statParts.push(`↑${formatTokens(input.usage.input)}`);
+    if (input.usage.output)
+        statParts.push(`↓${formatTokens(input.usage.output)}`);
+    if (input.usage.cost)
+        statParts.push(`$${input.usage.cost.toFixed(3)}`);
+    const stats = statParts.join(" ");
+    const percentText = input.contextPercent === null ? "?" : `${Math.round(input.contextPercent)}%`;
+    const line2Parts = [dim(input.model)];
+    if (stats)
+        line2Parts.push(dim(stats));
+    line2Parts.push(theme.fg(contextColor(input.contextPercent), percentText));
+    const line2 = truncateToWidth(line2Parts.join(sep), width, dim("…"));
+    // Line 3: extension statuses (branding, todo counter, mode), joined by " · ".
+    const statuses = input.statuses.map((s) => s.replace(/[\r\n\t]/g, " ").trim()).filter(Boolean);
+    const lines = [line1, line2];
+    if (statuses.length > 0) {
+        lines.push(truncateToWidth(dim(statuses.join(SEP)), width, dim("…")));
+    }
+    return lines;
+}
+/**
+ * Create a footer factory that captures the session `ctx` (for session data)
+ * and returns the component `setFooter` expects. Called from the
+ * `session_start` handler in index.ts.
+ */
+export function createYagniFooterFactory(ctx) {
+    return (_tui, theme, footerData) => {
+        // Recompute git/worktree info only when the branch actually changes. Optional-
+        // chained: onBranchChange is typed on ReadonlyFooterDataProvider, but the runtime
+        // provider is whatever pi version is installed — guard so a mismatch can't break
+        // footer construction (worst case, git info just doesn't auto-invalidate).
+        let gitCache;
+        const unsubscribeBranch = footerData.onBranchChange?.(() => {
+            gitCache = undefined;
+        });
+        const gitInfo = () => {
+            if (!gitCache) {
+                gitCache = detectGitInfo(ctx.sessionManager.getCwd(), process.env.HOME || process.env.USERPROFILE);
+            }
+            return gitCache;
+        };
+        return {
+            render(width) {
+                const statuses = [...footerData.getExtensionStatuses().entries()]
+                    .sort(([a], [b]) => a.localeCompare(b))
+                    .map(([, text]) => text);
+                return renderFooterLines({
+                    git: gitInfo(),
+                    model: ctx.model?.id ?? "no-model",
+                    usage: collectUsage(ctx.sessionManager),
+                    contextPercent: ctx.getContextUsage()?.percent ?? null,
+                    statuses,
+                }, theme, width);
+            },
+            invalidate() {
+                gitCache = undefined;
+            },
+            dispose() {
+                unsubscribeBranch?.();
+            },
+        };
+    };
+}
+//# sourceMappingURL=footer.js.map

package/dist/extension/index.js

@@ -3,7 +3,6 @@ import { dirname, join } from "node:path";
 import { Text } from "@earendil-works/pi-tui";
 import { DEFAULT_ADVISOR_LIMITS, formatAdvisorSubtotal, makeAdvisorState } from "./advisor.js";
 import { makeAskAdvisorTool, registerAdviseCommand } from "./askAdvisorTool.js";
-import { registerBoostCommand } from "./boostCommand.js";
 import { makeAskYagniTool } from "./askYagniTool.js";
 import { makeReviewBusinessMatchTool } from "./reviewTool.js";
 import { makeRecordEngineeringContextTool } from "./recordContextTool.js";
@@ -15,6 +14,7 @@ import { registerCostCommand } from "./costHud.js";
 import { isDebug } from "./diagnostics.js";
 import { droppedSessionRuns, sessionRunIds } from "./sessionRuns.js";
 import { codeStateHome } from "./stateHome.js";
+import { createYagniFooterFactory } from "./footer.js";
 import { RerouteNotifier } from "./rerouteNotice.js";
 import { isFreshWorkspace, registerTeamSetupCommand, runInitPass as defaultRunInitPass } from "./initPass.js";
 import { isInitDone as defaultIsInitDone, markInitDone as defaultMarkInitDone } from "./initDone.js";
@@ -111,7 +111,13 @@ export async function registerYagni(pi, deps = {}) {
     if (!evalMode) {
         installUncaughtExceptionMonitor({ baseUrl, getToken: getTokenFn, env: deps.env });
     }
-    const catalog = await fetchCatalog({ baseUrl, getToken: getTokenFn, fetchImpl: authedFetch });
+    const fullCatalog = await fetchCatalog({ baseUrl, getToken: getTokenFn, fetchImpl: authedFetch });
+    // Lock the interactive session to the `advanced` tier only. The backend
+    // catalog returns all tiers, but only `advanced` is registered with the
+    // `yagni` provider, so /model and Ctrl+P show a single entry. Child
+    // processes (/go, subagents, advisor) fetch their own catalog and register
+    // their own provider, so they are unaffected by this filter.
+    const catalog = fullCatalog.filter((m) => m.id === "advanced");
     // YAG-471: the driver's own completions carry attribution headers read from
     // this process's env (YAGNI_SESSION_ID minted by the launcher; YAGNI_CALLER
     // defaults to "driver" when unset, i.e. every session that is not a /go
@@ -119,11 +125,11 @@ export async function registerYagni(pi, deps = {}) {
     pi.registerProvider("yagni", buildYagniProvider(catalog, baseUrl, attributionHeaders(deps.env)));
     const toolOpts = { baseUrl, getToken: getTokenFn, fetchImpl: authedFetch };
     pi.registerTool(makeAskYagniTool(toolOpts));
-    // The peak-tier escalation for Balanced sessions (YAG-380). Registered
+    // The peak-tier escalation for Advanced sessions (YAG-380). Registered
     // UNCONDITIONALLY and gated at execute time on the live session model: pi's
     // picker can switch the model after activation, so a registration-time tier
-    // check would both leave the tool live after switching away from Balanced and
-    // hide it forever from a session that switched TO Balanced. One state handle
+    // check would both leave the tool live after switching away from Advanced and
+    // hide it forever from a session that switched TO Advanced. One state handle
     // per session, shared with /advise so they draw on the same cap.
     const advisorState = makeAdvisorState();
     const askAdvisorTool = makeAskAdvisorTool({ state: advisorState });
@@ -131,12 +137,6 @@ export async function registerYagni(pi, deps = {}) {
     // /advise runs the SAME tool, sharing the state handle, so a manual consult
     // draws on the same cap rather than opening a side channel around it.
     registerAdviseCommand(pi, askAdvisorTool);
-    // /boost — the sanctioned session-scoped escalation to Peak (spec §7,
-    // YAG-380 follow-on). Unlike /advise's per-call consult, this flips the
-    // DRIVER's own live model to peak until /boost off or the session ends.
-    // The returned handle threads isBoosted() into /cost below, the same way
-    // advisorState threads into advisorSubtotal.
-    const boostCommand = registerBoostCommand(pi, { env });
     // The differentiated business-grounded tools (loop bricks): review a change
     // for business fit, rank the next work by business priority, and record the
     // engineering rationale back onto the work-item.
@@ -248,11 +248,6 @@ export async function registerYagni(pi, deps = {}) {
         // fallback line; the server-authoritative line already counts advisor
         // spend as an ordinary caller row.
         advisorSubtotal: () => formatAdvisorSubtotal(advisorState.read(), DEFAULT_ADVISOR_LIMITS),
-        // YAG-380 follow-on: a boosted session that only chats never produces a
-        // server-side boosted row (see boostCommand.ts's KNOWN-asymmetry
-        // docblock), so /cost needs the live client-side toggle on top of
-        // whatever the server rows show.
-        isBoosted: () => boostCommand.isBoosted(),
         fetchHeadroom: async (signal) => {
             try {
                 const res = await resilientFetch(`${baseUrl}/api/yagni-code/credits`, { method: "GET", headers: { authorization: `Bearer ${getTokenFn() ?? ""}` } }, { fetchImpl: authedFetch, signal, policy: { maxAttempts: 1, backoffBaseMs: 0, backoffMaxMs: 0, timeoutMs: COST_FETCH_TIMEOUT_MS, jitterRatio: 0 } });
@@ -487,6 +482,12 @@ export async function registerYagni(pi, deps = {}) {
             // setHeader replaces the built-in header in place (verified against pi
             // 0.80.2 setExtensionHeader); the factory returns a simple Text component.
             ctx.ui?.setHeader?.((_tui, theme) => new Text(buildMastheadString(theme)));
+            // Replace the built-in footer with the YAGNI status bar: folder +
+            // [worktree] + branch on line 1, model + token/cost stats + integer
+            // context % on line 2, and extension statuses (brand, todos, mode) on
+            // line 3. The factory captures ctx so the footer can read session data
+            // (token stats, context usage) that isn't on the footerData provider.
+            ctx.ui?.setFooter?.((tui, theme, footerData) => createYagniFooterFactory(ctx)(tui, theme, footerData));
         }
         // Best-effort, once at session start: if the token is at or near expiry, say
         // so via a single notice so a long session does not silently start 401-ing

package/dist/launch.js

@@ -99,23 +99,16 @@ export function buildLaunch(creds, passthroughArgs, opts) {
     // Always load our extension. Default the provider to `yagni` unless the user
     // explicitly chose one (so power users can still point pi elsewhere).
     const userChoseProvider = passthroughArgs.some(arg => arg === "--provider" || arg.startsWith("--provider="));
-    // Default the model to the `balanced` tier (YAG-380). Balanced drives on the
-    // judgment-grade `advanced` model and additionally lets the session escalate
-    // hard calls to `peak` through the capped ask_advisor tool. So it is strictly
-    // additive: no session reasons worse than plain advanced, and the hard ones
-    // can reason better. A user `--model` (e.g. `standard` or `efficient`) still
-    // wins. Without this, pi's default-model heuristic could land an interactive
-    // session on a weaker tier.
-    // Detect if the user explicitly set a model, whether via "--model" as a separate
-    // argument or using the equals form "--model=efficient". The previous check only
-    // caught the separate form, causing a duplicate "--model balanced" to be added
-    // when the equals form was used.
+    // Default the model to the `advanced` tier. The model is locked: the
+    // catalog is filtered to only `advanced` (see index.ts), so the user
+    // cannot switch to a different tier via /model or Ctrl+P. The proxy still
+    // resolves the tier to the concrete backing model.
     const userChoseModel = passthroughArgs.some(arg => arg === "--model" || arg.startsWith("--model="));
     const argv = [
         "-e",
         opts.extensionPath,
         ...(userChoseProvider ? [] : ["--provider", "yagni"]),
-        ...(userChoseModel ? [] : ["--model", "balanced"]),
+        ...(userChoseModel ? [] : ["--model", "advanced"]),
         ...(opts.extraAgentArgs ?? []),
         ...passthroughArgs,
     ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "0.2.1-staging.1027.1",
+  "version": "0.2.1-staging.1032.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)",
@@ -38,5 +38,5 @@
     "@earendil-works/pi-tui": "0.83.0",
     "typebox": "^1.1.38"
   },
-  "yagniSourceSha": "33b62c8a01064f7681085e441aa00b02693b13c7"
+  "yagniSourceSha": "7629e1f12b3d8e06e68101daadd2d8258dd271e9"
 }

package/dist/extension/boostCommand.d.ts

@@ -1,144 +0,0 @@
-/**
- * `/boost` — the sanctioned session-scoped escalation to Peak (spec §7).
- *
- * The session default is the `balanced` tier. `/boost` flips the
- * DRIVER session's live model to `peak` until `/boost off` or the process
- * exits; `peak` stays directly pickable through pi's own model picker too,
- * this just adds a one-word lever plus an attribution flag.
- *
- * Two halves, same split as `advisor.ts` / `permission.ts`:
- *
- *   - `boostOn` / `boostOff` are PURE. They own every transition and the exact
- *     notice copy; no pi, no I/O, no env. That is what needs exhaustive tests.
- *   - `registerBoostCommand` is the wiring: it applies the pure result's
- *     `targetModelId` through pi's real model-switch API, toggles
- *     `process.env.YAGNI_BOOST`, and paints the notice + a status-bar chip.
- *
- * The model-switch API (verified against pi 0.83.0's typings, not guessed):
- * `ctx.modelRegistry.find(provider, modelId)` resolves a tier id to a
- * `Model`, and `pi.setModel(model)` (the top-level `ExtensionAPI` method, NOT
- * `ctx.setModel` — `ExtensionCommandContext` does not expose a setter) applies
- * it to the live session, resolving `false` when no API key is configured.
- * The `yagni` provider's catalog entries key `id` on the tier id itself (see
- * `provider.ts`), so `peak` is the pi model id for the peak tier.
- *
- * State lives in the registration closure — module/session-scoped, mirroring
- * `costHud.ts`'s accumulator — because a session's process exit is the only
- * "end" there is; nothing needs to persist across it. `registerBoostCommand`
- * returns a small `{ isBoosted() }` handle onto that same closure so other
- * registrations (currently just `/cost`, see below) can read the live flag
- * without a second source of truth.
- *
- * Picker-drift guard (spec review item 3): pi's OWN model picker (Ctrl+P,
- * `/model`) can change the live model independently of `/boost` in either
- * direction, so `state.active` can go stale relative to `ctx.model.id`. Both
- * halves read the live model and reconcile rather than trusting `state.active`
- * blindly:
- *
- *   - `boostOn` while already active but the live model has drifted OFF peak
- *     (the user cycled models mid-boost without `/boost off`): re-applies
- *     peak instead of a silent "Already boosted." that would leave the
- *     driver quietly running a cheaper tier under an attribution header that
- *     claims otherwise. The remembered `priorModelId` is left untouched — the
- *     tier to restore is still whatever was active before the ORIGINAL boost,
- *     not the tier the user happened to drift to.
- *   - `boostOff` while active but the live model is no longer peak (same
- *     drift, encountered from the other command): the user already left
- *     boost manually, so forcing a switch back to the remembered prior tier
- *     would clobber a choice they just made on purpose. Instead this clears
- *     `/boost`'s own bookkeeping (state, env, chip) without touching the
- *     model, and names where they actually landed.
- *
- * KNOWN asymmetry, documented rather than worked around: `YAGNI_BOOST=1`
- * while boosted makes every CHILD process spawned during the boost (a /go
- * run, a subagent, an advisor consult) inherit it, and those children's
- * completions carry `x-yagni-boost` because their provider is registered
- * fresh per child. The DRIVER's own completions do not gain that header
- * retroactively — `buildYagniProvider`'s headers are baked into the
- * `registerProvider` call once, at session start, from the env snapshot at
- * that moment (see `provider.ts` / `attributionHeaders`). Re-registering the
- * provider mid-session to pick up a new header is explicitly NOT the fix
- * here: it would race the in-flight request the switch itself triggers and
- * has no test coverage as a live-swap path.
- *
- * This is exactly why `/cost` cannot rely on server rows alone: the server's
- * per-tier "Boosted (tier) spend" subtotal (`formatServerCostLines`, Task 7)
- * only ever sees rows carrying `x-yagni-boost` — i.e. `/go` children, never
- * the driver's own turns. A session that only chats while boosted would
- * otherwise show no boost line at all. `registerCostCommand`'s `isBoosted`
- * dep (threaded from THIS module's return handle, the same way
- * `advisorSubtotal` is threaded from `advisor.ts`) closes that gap: `/cost`
- * appends a fixed "Boost is on. Driver turns bill at the peak tier." line
- * whenever the live toggle is on, on BOTH the server-authoritative and the
- * local-fallback branch, independent of what server rows happen to show.
- */
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-/** Session-scoped boost state, held in the registration closure. */
-export interface BoostState {
-    active: boolean;
-    /** The tier to restore on `/boost off`. Set only while `active`. */
-    priorModelId?: string;
-}
-/** The pure outcome of a `/boost` transition. */
-export interface BoostResult {
-    state: BoostState;
-    /** Exact notice text to surface to the user. */
-    notice: string;
-    /** The tier id to switch the session to, or undefined for a pure no-op. */
-    targetModelId?: string;
-}
-/**
- * Turn boost on. PURE.
- *
- * - Already active AND the live model is still `peak`: genuine no-op,
- *   "Already boosted." (no switch — nothing about the prior tier changes).
- * - Already active but the live model has drifted off `peak` (picker-drift
- *   guard 3b, see module docblock): re-applies `peak`, keeping the ORIGINAL
- *   `priorModelId` rather than adopting the drifted-to tier.
- * - Not active, current model IS already `peak`: activates anyway (so
- *   attribution and `/boost off` behave correctly) with a distinct notice,
- *   remembering `peak` itself as the tier to restore.
- * - Not active, otherwise: remembers the current tier, targets `peak`.
- */
-export declare function boostOn(state: BoostState, currentModelId: string | undefined): BoostResult;
-/**
- * Turn boost off. PURE.
- *
- * - Not active: no-op, "Boost is not on."
- * - Active but the live model is no longer `peak` (picker-drift guard 3a,
- *   see module docblock): the user already left boost manually. Clears
- *   `/boost`'s own bookkeeping WITHOUT a switch — forcing one back to the
- *   remembered prior tier would clobber a choice just made on purpose — and
- *   names the model they actually landed on.
- * - Active and still on `peak`: restores the remembered prior tier (falling
- *   back to the session default when none was recorded, which should not
- *   normally happen). When the prior tier is itself `peak` (the
- *   already-on-Peak activation path), the resulting switch is a no-op in
- *   effect — still applied, harmlessly.
- */
-export declare function boostOff(state: BoostState, currentModelId: string | undefined): BoostResult;
-/** Injectable seams for `registerBoostCommand`. */
-export interface RegisterBoostCommandDeps {
-    /** Environment `YAGNI_BOOST` is toggled on. Defaults to `process.env`. */
-    env?: NodeJS.ProcessEnv;
-}
-/** What `registerBoostCommand` hands back so other registrations (`/cost`) can read the live flag. */
-export interface BoostCommandHandle {
-    /** Whether the session is currently boosted, read fresh off the same closure `/boost` mutates. */
-    isBoosted(): boolean;
-}
-/**
- * Register the `/boost` command.
- *
- * `/boost` (no args) turns boost on; `/boost off` turns it off; any other
- * argument shows a usage notice and changes nothing. Every transition that
- * requires a model switch runs it through pi's real API and is guarded end to
- * end: state and `YAGNI_BOOST` are only ever committed together, AFTER the
- * switch succeeds (or is deliberately skipped — the picker-drift guards), so
- * a half-applied boost (env set but model unchanged, or vice versa) can never
- * happen. A failed ON reports "Boost failed."; a failed OFF reports a
- * DISTINCT message, because the failure mode is materially worse — the
- * driver is left still running (and billing) on Peak, not merely unchanged.
- */
-export declare function registerBoostCommand(pi: ExtensionAPI, deps?: RegisterBoostCommandDeps): BoostCommandHandle;
-//# sourceMappingURL=boostCommand.d.ts.map

package/dist/extension/boostCommand.js

@@ -1,263 +0,0 @@
-/**
- * `/boost` — the sanctioned session-scoped escalation to Peak (spec §7).
- *
- * The session default is the `balanced` tier. `/boost` flips the
- * DRIVER session's live model to `peak` until `/boost off` or the process
- * exits; `peak` stays directly pickable through pi's own model picker too,
- * this just adds a one-word lever plus an attribution flag.
- *
- * Two halves, same split as `advisor.ts` / `permission.ts`:
- *
- *   - `boostOn` / `boostOff` are PURE. They own every transition and the exact
- *     notice copy; no pi, no I/O, no env. That is what needs exhaustive tests.
- *   - `registerBoostCommand` is the wiring: it applies the pure result's
- *     `targetModelId` through pi's real model-switch API, toggles
- *     `process.env.YAGNI_BOOST`, and paints the notice + a status-bar chip.
- *
- * The model-switch API (verified against pi 0.83.0's typings, not guessed):
- * `ctx.modelRegistry.find(provider, modelId)` resolves a tier id to a
- * `Model`, and `pi.setModel(model)` (the top-level `ExtensionAPI` method, NOT
- * `ctx.setModel` — `ExtensionCommandContext` does not expose a setter) applies
- * it to the live session, resolving `false` when no API key is configured.
- * The `yagni` provider's catalog entries key `id` on the tier id itself (see
- * `provider.ts`), so `peak` is the pi model id for the peak tier.
- *
- * State lives in the registration closure — module/session-scoped, mirroring
- * `costHud.ts`'s accumulator — because a session's process exit is the only
- * "end" there is; nothing needs to persist across it. `registerBoostCommand`
- * returns a small `{ isBoosted() }` handle onto that same closure so other
- * registrations (currently just `/cost`, see below) can read the live flag
- * without a second source of truth.
- *
- * Picker-drift guard (spec review item 3): pi's OWN model picker (Ctrl+P,
- * `/model`) can change the live model independently of `/boost` in either
- * direction, so `state.active` can go stale relative to `ctx.model.id`. Both
- * halves read the live model and reconcile rather than trusting `state.active`
- * blindly:
- *
- *   - `boostOn` while already active but the live model has drifted OFF peak
- *     (the user cycled models mid-boost without `/boost off`): re-applies
- *     peak instead of a silent "Already boosted." that would leave the
- *     driver quietly running a cheaper tier under an attribution header that
- *     claims otherwise. The remembered `priorModelId` is left untouched — the
- *     tier to restore is still whatever was active before the ORIGINAL boost,
- *     not the tier the user happened to drift to.
- *   - `boostOff` while active but the live model is no longer peak (same
- *     drift, encountered from the other command): the user already left
- *     boost manually, so forcing a switch back to the remembered prior tier
- *     would clobber a choice they just made on purpose. Instead this clears
- *     `/boost`'s own bookkeeping (state, env, chip) without touching the
- *     model, and names where they actually landed.
- *
- * KNOWN asymmetry, documented rather than worked around: `YAGNI_BOOST=1`
- * while boosted makes every CHILD process spawned during the boost (a /go
- * run, a subagent, an advisor consult) inherit it, and those children's
- * completions carry `x-yagni-boost` because their provider is registered
- * fresh per child. The DRIVER's own completions do not gain that header
- * retroactively — `buildYagniProvider`'s headers are baked into the
- * `registerProvider` call once, at session start, from the env snapshot at
- * that moment (see `provider.ts` / `attributionHeaders`). Re-registering the
- * provider mid-session to pick up a new header is explicitly NOT the fix
- * here: it would race the in-flight request the switch itself triggers and
- * has no test coverage as a live-swap path.
- *
- * This is exactly why `/cost` cannot rely on server rows alone: the server's
- * per-tier "Boosted (tier) spend" subtotal (`formatServerCostLines`, Task 7)
- * only ever sees rows carrying `x-yagni-boost` — i.e. `/go` children, never
- * the driver's own turns. A session that only chats while boosted would
- * otherwise show no boost line at all. `registerCostCommand`'s `isBoosted`
- * dep (threaded from THIS module's return handle, the same way
- * `advisorSubtotal` is threaded from `advisor.ts`) closes that gap: `/cost`
- * appends a fixed "Boost is on. Driver turns bill at the peak tier." line
- * whenever the live toggle is on, on BOTH the server-authoritative and the
- * local-fallback branch, independent of what server rows happen to show.
- */
-/** The pi provider name the YAGNI catalog registers under (see `provider.ts`). */
-const YAGNI_PROVIDER = "yagni";
-/** The tier `/boost` escalates to. */
-const BOOST_TIER = "peak";
-/** The session default tier, restored when no prior tier is known. */
-const DEFAULT_TIER = "balanced";
-/** Tier ids are lowercase; every known tier's display name is just Title Case of the id. */
-function displayTierName(id) {
-    return id.length === 0 ? id : id.charAt(0).toUpperCase() + id.slice(1);
-}
-/**
- * Turn boost on. PURE.
- *
- * - Already active AND the live model is still `peak`: genuine no-op,
- *   "Already boosted." (no switch — nothing about the prior tier changes).
- * - Already active but the live model has drifted off `peak` (picker-drift
- *   guard 3b, see module docblock): re-applies `peak`, keeping the ORIGINAL
- *   `priorModelId` rather than adopting the drifted-to tier.
- * - Not active, current model IS already `peak`: activates anyway (so
- *   attribution and `/boost off` behave correctly) with a distinct notice,
- *   remembering `peak` itself as the tier to restore.
- * - Not active, otherwise: remembers the current tier, targets `peak`.
- */
-export function boostOn(state, currentModelId) {
-    if (state.active) {
-        if (currentModelId === BOOST_TIER) {
-            return { state, notice: "Already boosted." };
-        }
-        return {
-            state,
-            notice: `Re-boosted to Peak. /boost off to return to ${displayTierName(state.priorModelId ?? DEFAULT_TIER)}.`,
-            targetModelId: BOOST_TIER,
-        };
-    }
-    if (currentModelId === BOOST_TIER) {
-        return {
-            state: { active: true, priorModelId: BOOST_TIER },
-            notice: "Already on Peak. /boost off returns to Peak.",
-            targetModelId: BOOST_TIER,
-        };
-    }
-    return {
-        state: { active: true, priorModelId: currentModelId },
-        notice: `Boosted to Peak. /boost off to return to ${displayTierName(currentModelId ?? DEFAULT_TIER)}.`,
-        targetModelId: BOOST_TIER,
-    };
-}
-/**
- * Turn boost off. PURE.
- *
- * - Not active: no-op, "Boost is not on."
- * - Active but the live model is no longer `peak` (picker-drift guard 3a,
- *   see module docblock): the user already left boost manually. Clears
- *   `/boost`'s own bookkeeping WITHOUT a switch — forcing one back to the
- *   remembered prior tier would clobber a choice just made on purpose — and
- *   names the model they actually landed on.
- * - Active and still on `peak`: restores the remembered prior tier (falling
- *   back to the session default when none was recorded, which should not
- *   normally happen). When the prior tier is itself `peak` (the
- *   already-on-Peak activation path), the resulting switch is a no-op in
- *   effect — still applied, harmlessly.
- */
-export function boostOff(state, currentModelId) {
-    if (!state.active) {
-        return { state, notice: "Boost is not on." };
-    }
-    if (currentModelId !== BOOST_TIER) {
-        return {
-            state: { active: false, priorModelId: undefined },
-            notice: `Boost off. Leaving the model on ${displayTierName(currentModelId ?? DEFAULT_TIER)}.`,
-        };
-    }
-    const priorId = state.priorModelId ?? DEFAULT_TIER;
-    return {
-        state: { active: false, priorModelId: undefined },
-        notice: `Back to ${displayTierName(priorId)}.`,
-        targetModelId: priorId,
-    };
-}
-/**
- * Resolve `tierId` to a live `Model` and apply it via `pi.setModel`.
- *
- * On a registry lookup miss, `allowFallback` (true only on the OFF path —
- * MINOR 5) retries once against the session default tier rather than
- * stranding the user on Peak over one missing catalog entry. Returns the
- * tier id that was ACTUALLY applied, so the caller can tell whether the
- * fallback fired and adjust the notice to name it honestly.
- *
- * @throws when neither the requested tier nor (if allowed) the fallback
- * resolves, or when `pi.setModel` itself throws or resolves `false`.
- */
-async function applyTier(pi, ctx, tierId, allowFallback) {
-    let model = ctx.modelRegistry?.find(YAGNI_PROVIDER, tierId);
-    let applied = tierId;
-    if (!model && allowFallback && tierId !== DEFAULT_TIER) {
-        model = ctx.modelRegistry?.find(YAGNI_PROVIDER, DEFAULT_TIER);
-        applied = DEFAULT_TIER;
-    }
-    if (!model) {
-        throw new Error(`Unknown YAGNI tier "${tierId}".`);
-    }
-    const ok = await pi.setModel(model);
-    if (!ok) {
-        throw new Error("setModel reported no API key configured.");
-    }
-    return applied;
-}
-/**
- * Register the `/boost` command.
- *
- * `/boost` (no args) turns boost on; `/boost off` turns it off; any other
- * argument shows a usage notice and changes nothing. Every transition that
- * requires a model switch runs it through pi's real API and is guarded end to
- * end: state and `YAGNI_BOOST` are only ever committed together, AFTER the
- * switch succeeds (or is deliberately skipped — the picker-drift guards), so
- * a half-applied boost (env set but model unchanged, or vice versa) can never
- * happen. A failed ON reports "Boost failed."; a failed OFF reports a
- * DISTINCT message, because the failure mode is materially worse — the
- * driver is left still running (and billing) on Peak, not merely unchanged.
- */
-export function registerBoostCommand(pi, deps = {}) {
-    const env = deps.env ?? process.env;
-    let state = { active: false };
-    const paintStatus = (ctx, active) => {
-        try {
-            if (ctx.hasUI)
-                ctx.ui.setStatus?.("yagni-boost", active ? "⚡ Peak" : undefined);
-        }
-        catch {
-            // The chip is chrome; never let it break /boost.
-        }
-    };
-    pi.registerCommand("boost", {
-        description: "Escalate this session's model to Peak until /boost off or the session ends. /boost off returns to the prior tier.",
-        handler: async (args, ctx) => {
-            const notify = (message, type) => {
-                if (ctx.hasUI)
-                    ctx.ui.notify(message, type);
-            };
-            // MINOR 4: case-insensitive "off" match, mirroring /mode's arg handling.
-            const arg = args.trim().toLowerCase();
-            if (arg !== "" && arg !== "off") {
-                notify("Usage: /boost (turn on) or /boost off.", "warning");
-                return;
-            }
-            const isOff = arg === "off";
-            const wasActive = state.active;
-            const result = isOff ? boostOff(state, ctx.model?.id) : boostOn(state, ctx.model?.id);
-            try {
-                let notice = result.notice;
-                if (result.targetModelId) {
-                    const applied = await applyTier(pi, ctx, result.targetModelId, isOff);
-                    if (applied !== result.targetModelId) {
-                        // MINOR 5: the remembered/target tier no longer resolves in the
-                        // catalog; we landed on the session default instead of
-                        // stranding the user on Peak. Name the fallback so the notice
-                        // stays honest about what actually happened.
-                        notice = `Back to ${displayTierName(applied)} (could not restore ${displayTierName(result.targetModelId)}).`;
-                    }
-                }
-                state = result.state;
-                // MINOR 6: only touch the env on a real active/inactive flip. Both
-                // pure no-op paths ("Already boosted.", "Boost is not on.") return
-                // `state` unchanged, so this never fires for them — an inherited
-                // YAGNI_BOOST from outside this session is left exactly as found.
-                if (state.active !== wasActive) {
-                    if (state.active) {
-                        env.YAGNI_BOOST = "1";
-                    }
-                    else {
-                        delete env.YAGNI_BOOST;
-                    }
-                }
-                notify(notice, "info");
-                paintStatus(ctx, state.active);
-            }
-            catch {
-                // IMPORTANT 1: a failed OFF is materially worse than a failed ON —
-                // the driver is STILL on Peak, still billing at Peak rates, which a
-                // generic "Boost failed." does not convey. Neither `state` nor
-                // `YAGNI_BOOST` was touched above (the throw lands before both), so
-                // the chip is also left exactly as it was: still lit.
-                notify(isOff ? "Could not leave boost. Still on Peak; try /boost off again." : "Boost failed.", "error");
-            }
-        },
-    });
-    return { isBoosted: () => state.active };
-}
-//# sourceMappingURL=boostCommand.js.map