@yagni-app/code 0.2.1 → 0.3.1

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
@@ -26,10 +26,12 @@
  * this module is the I/O.
  */
 import type { ExtensionAPI, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { type Component } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import { type AdvisorLimits, type AdvisorStateHandle } from "./advisor.js";
 import { runStage as defaultRunStage } from "./pipeline/runner.js";
-import type { PipelineStage } from "./pipeline/types.js";
+import { type PipelineStage } from "./pipeline/types.js";
+import { type RenderTheme, type SubagentTaskProgress } from "./subagentRender.js";
 /**
  * Read-only recon plus grounding. Mirrors the `plan` stage's allowlist for the
  * reason documented there: enough tools to navigate instead of flailing on a
@@ -66,10 +68,18 @@ export declare function buildConsultBrief(params: {
  * persona, and that is the advisor's own.
  */
 export declare function advisorStage(): PipelineStage;
-export declare function makeAskAdvisorTool(opts: MakeAskAdvisorToolOptions): ToolDefinition<typeof parameters, {
+/** The ask_advisor result details: consult accounting plus the live progress
+ * record the subagent renderers paint (one task, the consult itself). */
+export interface AdvisorToolDetails {
     consults: number;
     cost: number;
-}>;
+    tasks?: SubagentTaskProgress[];
+}
+/** Title painted the moment the ask_advisor call streams in. */
+export declare function renderAdvisorCall(args: {
+    question?: string;
+} | undefined, theme: RenderTheme, _context: unknown): Component;
+export declare function makeAskAdvisorTool(opts: MakeAskAdvisorToolOptions): ToolDefinition<typeof parameters, AdvisorToolDetails>;
 /**
  * `/advise <question>` — the manual escalation lever.
  *
@@ -77,6 +87,11 @@ export declare function makeAskAdvisorTool(opts: MakeAskAdvisorToolOptions): Too
  * consult draws on the same cap rather than opening a side channel around it.
  * The advice is sent into the conversation (like /go-compare's report) so the
  * driver sees it in context and can act on it.
+ *
+ * A command has no tool row for pi to render, so the live view is an
+ * aboveEditor widget painted from the tool's partial updates: the same
+ * two-line `agent — task` / `↳ current tool` status the subagent tool shows,
+ * driven by a spinner ticker so it visibly moves between child events.
  */
 export declare function registerAdviseCommand(pi: ExtensionAPI, tool: ReturnType<typeof makeAskAdvisorTool>): void;
 export {};

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
@@ -25,9 +25,14 @@
  * The gate, the cap and the spend ceiling live in `advisor.ts` and are pure;
  * this module is the I/O.
  */
+import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import { ADVISOR_MODEL_TIER, DEFAULT_ADVISOR_LIMITS, decideConsult, formatConsultCost, } from "./advisor.js";
+import { SPINNER_FRAMES } from "./pipeline/activityFeed.js";
+import { withResilience } from "./pipeline/resilience.js";
 import { runStage as defaultRunStage } from "./pipeline/runner.js";
+import { DEFAULT_RESILIENCE_POLICY } from "./pipeline/types.js";
+import { applyChildEvent, finalizeTask, formatWorkingMessage, newTaskProgress, progressSummaryText, receiptLine, renderSubagentResult, runningLines, } from "./subagentRender.js";
 /**
  * Read-only recon plus grounding. Mirrors the `plan` stage's allowlist for the
  * reason documented there: enough tools to navigate instead of flailing on a
@@ -71,15 +76,39 @@ export function advisorStage() {
         taskTemplate: "{ticket}",
     };
 }
+/** Spinner cadence for the advisor's live views; matches subagentRender. */
+const SPINNER_TICK_MS = 120;
+/** Question preview width on the call title line. */
+const QUESTION_PREVIEW_MAX = 128;
+function clip(text, max) {
+    const collapsed = text.replace(/\s+/g, " ").trim();
+    if (collapsed.length <= max)
+        return collapsed;
+    return `${collapsed.slice(0, max - 1)}…`;
+}
+/** Title painted the moment the ask_advisor call streams in. */
+export function renderAdvisorCall(args, theme, _context) {
+    const title = theme.fg("toolTitle", theme.bold("advisor"));
+    let text = `${title} ${theme.fg("accent", "peak-tier consult")}`;
+    if (args?.question)
+        text += `\n  ${theme.fg("dim", clip(args.question, QUESTION_PREVIEW_MAX))}`;
+    return new Text(text, 0, 0);
+}
 export function makeAskAdvisorTool(opts) {
     const limits = opts.limits ?? DEFAULT_ADVISOR_LIMITS;
-    const runStage = opts.runStage ?? defaultRunStage;
+    // The default runner rides the /go pipeline's resilience wrapper, exactly
+    // like the subagent tool: idle + wall-clock ceilings and transient-only
+    // retry, so a stalled consult child aborts honestly instead of hanging the
+    // driver's tool call until the user presses Esc. The synthetic stage id is
+    // "plan" (read-only tools, no bash), so the wrapper's write-gate never
+    // blocks a retry — re-running a consult cannot double-apply anything.
+    const runStage = opts.runStage ?? withResilience(defaultRunStage, DEFAULT_RESILIENCE_POLICY);
     return {
         name: "ask_advisor",
         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 +116,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.",
@@ -95,6 +124,8 @@ export function makeAskAdvisorTool(opts) {
             "The advice comes back as plain text: act on it, and call record_decision when it settles a product-intent call so the next agent inherits it.",
         ],
         parameters,
+        renderCall: renderAdvisorCall,
+        renderResult: renderSubagentResult,
         async execute(_toolCallId, params, signal, onUpdate, ctx) {
             // Read the LIVE session model: pi's picker can change it after this tool
             // was registered, in both directions.
@@ -109,19 +140,51 @@ export function makeAskAdvisorTool(opts) {
                     details: { consults: opts.state.read().consults, cost: 0 },
                 };
             }
-            onUpdate?.({
-                content: [{ type: "text", text: "Consulting the advisor…" }],
-                details: { consults: opts.state.read().consults, cost: 0 },
-            });
-            const result = await runStage(advisorStage(), { ticket: buildConsultBrief(params) }, {
-                cwd: ctx?.cwd ?? process.cwd(),
-                ...(signal ? { signal } : {}),
-                // YAG-471: attribute the consult's completions to the advisor, not
-                // the "plan" stage id advisorStage() borrows (see its docblock).
-                callerLabel: "advisor",
-            });
+            // Live progress, exactly the subagent tool's shape: the folded record
+            // rides every partial update's `details.tasks` (painted by
+            // renderSubagentResult), the plain-text summary rides `content` for
+            // headless consumers, and the harness "Working…" line mirrors it.
+            const progress = newTaskProgress("advisor", params.question, Date.now());
+            const ui = ctx?.hasUI ? ctx.ui : undefined;
+            let lastWorking;
+            const emit = () => {
+                const now = Date.now();
+                onUpdate?.({
+                    content: [{ type: "text", text: progressSummaryText([progress], now) }],
+                    details: {
+                        consults: opts.state.read().consults,
+                        cost: progress.usage.cost,
+                        tasks: [{ ...progress, actions: [...progress.actions], usage: { ...progress.usage } }],
+                    },
+                });
+                const working = formatWorkingMessage([progress], now);
+                if (ui && working !== lastWorking) {
+                    lastWorking = working;
+                    ui.setWorkingMessage?.(working);
+                }
+            };
+            emit();
+            let result;
+            try {
+                result = await runStage(advisorStage(), { ticket: buildConsultBrief(params) }, {
+                    cwd: ctx?.cwd ?? process.cwd(),
+                    ...(signal ? { signal } : {}),
+                    // YAG-471: attribute the consult's completions to the advisor, not
+                    // the "plan" stage id advisorStage() borrows (see its docblock).
+                    callerLabel: "advisor",
+                    onEvent: (ev) => {
+                        if (applyChildEvent(progress, ev))
+                            emit();
+                    },
+                });
+            }
+            finally {
+                // Restore the default "Working…" text whether we resolved or threw.
+                ui?.setWorkingMessage?.();
+            }
             const cost = result.usage?.cost ?? 0;
             const state = opts.state.record(cost);
+            finalizeTask(progress, result, Date.now());
             if (result.exitCode !== 0 && !result.finalOutput.trim()) {
                 // Fail honestly rather than returning an empty recommendation. The
                 // consult still counts: it spawned, and it may well have spent.
@@ -134,7 +197,7 @@ export function makeAskAdvisorTool(opts) {
                                 `Decide this one yourself.`,
                         },
                     ],
-                    details: { consults: state.consults, cost },
+                    details: { consults: state.consults, cost, tasks: [progress] },
                 };
             }
             return {
@@ -144,11 +207,13 @@ export function makeAskAdvisorTool(opts) {
                         text: `${result.finalOutput.trim()}\n\n${formatConsultCost({ cost, consults: state.consults, limits })}`,
                     },
                 ],
-                details: { consults: state.consults, cost },
+                details: { consults: state.consults, cost, tasks: [progress] },
             };
         },
     };
 }
+/** The widget key the /advise live panel paints under. */
+const ADVISE_WIDGET_KEY = "yagni-advise";
 /**
  * `/advise <question>` — the manual escalation lever.
  *
@@ -156,10 +221,15 @@ export function makeAskAdvisorTool(opts) {
  * consult draws on the same cap rather than opening a side channel around it.
  * The advice is sent into the conversation (like /go-compare's report) so the
  * driver sees it in context and can act on it.
+ *
+ * A command has no tool row for pi to render, so the live view is an
+ * aboveEditor widget painted from the tool's partial updates: the same
+ * two-line `agent — task` / `↳ current tool` status the subagent tool shows,
+ * driven by a spinner ticker so it visibly moves between child events.
  */
 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)
@@ -175,8 +245,41 @@ export function registerAdviseCommand(pi, tool) {
                 return;
             }
             notify("Consulting the peak-tier advisor. This reads the repo, so it takes a moment.", "info");
+            // Live panel state: the newest folded progress record from the tool's
+            // partial updates, repainted on a spinner tick until the consult ends.
+            let progress;
+            let paintTimer;
+            const theme = ctx.hasUI ? ctx.ui.theme : undefined;
+            const paint = () => {
+                if (!ctx.hasUI || !theme || !progress)
+                    return;
+                const now = Date.now();
+                const lines = progress.status === "running"
+                    ? runningLines(progress, theme, now, SPINNER_FRAMES[Math.floor(now / SPINNER_TICK_MS) % SPINNER_FRAMES.length])
+                    : [receiptLine(progress, theme)];
+                ctx.ui.setWidget?.(ADVISE_WIDGET_KEY, lines, { placement: "aboveEditor" });
+            };
+            const onUpdate = (update) => {
+                const task = update.details?.tasks?.[0];
+                if (!task)
+                    return;
+                progress = task;
+                if (ctx.hasUI && theme && !paintTimer) {
+                    paintTimer = setInterval(paint, SPINNER_TICK_MS);
+                    paintTimer.unref?.();
+                }
+                paint();
+            };
+            const clearPanel = () => {
+                if (paintTimer) {
+                    clearInterval(paintTimer);
+                    paintTimer = undefined;
+                }
+                if (ctx.hasUI)
+                    ctx.ui.setWidget?.(ADVISE_WIDGET_KEY, undefined);
+            };
             try {
-                const out = await tool.execute("advise", { question }, ctx.signal, undefined, ctx);
+                const out = await tool.execute("advise", { question }, ctx.signal, onUpdate, ctx);
                 const text = out.content
                     .map((c) => c.text ?? "")
                     .join("\n")
@@ -188,6 +291,9 @@ export function registerAdviseCommand(pi, tool) {
                 notify(`/advise failed: ${message}`, "error");
                 await pi.sendUserMessage(`/advise failed: ${message}`);
             }
+            finally {
+                clearPanel();
+            }
         },
     });
 }

package/dist/extension/askYagniTool.d.ts

@@ -1,11 +1,20 @@
 import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
+import { type FlywheelState } from "./flywheel.js";
 import { type RepoDocSnippet } from "./repoDocs.js";
 /** A single source citation returned by the YAGNI `ask` endpoint. */
 export interface Citation {
     title: string;
     url: string;
 }
+/**
+ * How hard the answer may be leaned on (mirror of `@yagni/shared`'s
+ * AskStanding — mirrored locally by this extension's no-workspace-imports
+ * convention, see costHud.ts).
+ */
+export type AskStanding = "confirmed" | "asserted" | "inferred" | "no_position";
+/** One line the TUI shows above the answer, per standing. */
+export declare const STANDING_LINES: Record<AskStanding, string>;
 /** Options for {@link makeAskYagniTool}. */
 export interface MakeAskYagniToolOptions {
     baseUrl: string;
@@ -19,6 +28,19 @@ export interface MakeAskYagniToolOptions {
      * checkout's own era, since the docs are read from the tree being edited.
      */
     collectDocs?: (cwd: string, query: string) => RepoDocSnippet[];
+    /**
+     * Shared flywheel session state (Run 7): caps how many no-position
+     * recordSuggestions reach the model per session and attributes the
+     * follow-up record_decision for dedupe. Absent → suggestions always
+     * surface, nothing is attributed (tests, older wiring).
+     */
+    flywheel?: FlywheelState;
+    /**
+     * The session repo (`owner/name`), for the backend's soft-scoped decision
+     * read (workspace-level decisions plus this repo's own — never another
+     * repo's conventions). Absent keeps the workspace-wide read.
+     */
+    getRepo?: () => string | undefined;
 }
 declare const parameters: Type.TObject<{
     question: Type.TString;
@@ -34,6 +56,7 @@ declare const parameters: Type.TObject<{
  */
 export declare function makeAskYagniTool(opts: MakeAskYagniToolOptions): ToolDefinition<typeof parameters, {
     citations: Citation[];
+    standing?: AskStanding;
 }>;
 export {};
 //# sourceMappingURL=askYagniTool.d.ts.map

package/dist/extension/askYagniTool.js

@@ -1,10 +1,37 @@
+import { Container, Spacer, Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
+import { canSurfaceSuggestion, noteSuggestionSurfaced } from "./flywheel.js";
 import { collectRepoDocs } from "./repoDocs.js";
 import { friendlyFetchError, METERED_POST_FETCH_POLICY, resilientFetch } from "./resilientFetch.js";
+import { markdownOrPlain } from "./subagentRender.js";
+/** One line the TUI shows above the answer, per standing. */
+export const STANDING_LINES = {
+    confirmed: "Grounded in a confirmed decision",
+    asserted: "Grounded in a recorded assumption, not yet verified",
+    inferred: "Inferred from workspace context, not a recorded decision",
+    no_position: "No recorded position in this workspace",
+};
+function standingLine(value) {
+    return typeof value === "string" && value in STANDING_LINES
+        ? STANDING_LINES[value]
+        : undefined;
+}
 const parameters = Type.Object({
     question: Type.String(),
     context: Type.Optional(Type.String()),
 });
+/** Collapsed answer preview length, in lines. */
+const ANSWER_PREVIEW_LINES = 4;
+/** Collapse whitespace and clip to `max`, appending an ellipsis when cut. */
+function clipLine(text, max) {
+    const collapsed = text.replace(/\s+/g, " ").trim();
+    if (collapsed.length <= max)
+        return collapsed;
+    return `${collapsed.slice(0, max - 1)}…`;
+}
+function citationCount(n) {
+    return n === 1 ? "1 citation" : `${n} citations`;
+}
 /**
  * Build the `ask_yagni` tool definition.
  *
@@ -26,8 +53,49 @@ export function makeAskYagniTool(opts) {
             "Call ask_yagni BEFORE guessing about anything organization- or codebase-specific (conventions, policies, architecture, ownership, product decisions).",
             "Pass the user's actual question; add relevant local context (file paths, snippets) in the optional `context` field.",
             "When you use an answer, quote or reference its citations so the user can verify the source.",
+            "Answers carry a standing: treat a confirmed decision as settled; when you lean on an unverified assumption or an inference, say so where the work is reviewed; when there is no recorded position, follow the answer's instruction to record the assumption you proceed on.",
         ],
         parameters,
+        renderCall(args, theme) {
+            const t = theme;
+            let text = `${t.fg("toolTitle", t.bold("ask_yagni"))} ${t.fg("dim", clipLine(args?.question ?? "…", 100))}`;
+            if (args?.context)
+                text += t.fg("muted", " (+context)");
+            return new Text(text, 0, 0);
+        },
+        renderResult(result, { expanded, isPartial }, theme) {
+            const t = theme;
+            const answer = result.content.find((c) => c.type === "text")?.text ?? "";
+            const citations = result.details?.citations ?? [];
+            if (isPartial)
+                return new Text(t.fg("muted", answer || "Asking YAGNI…"), 0, 0);
+            const standing = standingLine(result.details?.standing);
+            if (expanded) {
+                const container = new Container();
+                if (standing)
+                    container.addChild(new Text(t.fg("muted", standing), 0, 0));
+                container.addChild(markdownOrPlain(answer || "(no answer)", t));
+                if (citations.length > 0) {
+                    container.addChild(new Spacer(1));
+                    for (const c of citations) {
+                        container.addChild(new Text(`  ${t.fg("muted", "•")} ${t.fg("accent", c.title)} ${t.fg("dim", c.url)}`, 0, 0));
+                    }
+                }
+                return container;
+            }
+            const lines = answer.trim().split("\n");
+            const out = lines.slice(0, ANSWER_PREVIEW_LINES).map((l) => t.fg("toolOutput", l));
+            const meta = [];
+            if (standing)
+                meta.push(standing);
+            if (citations.length > 0)
+                meta.push(citationCount(citations.length));
+            if (lines.length > ANSWER_PREVIEW_LINES || citations.length > 0)
+                meta.push("(ctrl+o to expand)");
+            if (meta.length > 0)
+                out.push(t.fg("muted", `  ${meta.join(" · ")}`));
+            return new Text(out.join("\n"), 0, 0);
+        },
         async execute(_toolCallId, params, signal, onUpdate, ctx) {
             onUpdate?.({ content: [{ type: "text", text: "Asking YAGNI…" }], details: { citations: [] } });
             // Era-correct repo grounding: gather the working tree's most relevant docs
@@ -46,6 +114,7 @@ export function makeAskYagniTool(opts) {
                     question: params.question,
                     context: params.context,
                     cwd: ctx?.cwd,
+                    ...(opts.getRepo?.() ? { repo: opts.getRepo() } : {}),
                     ...(repoDocs.length > 0 ? { repoDocs } : {}),
                 }),
             }, { fetchImpl: opts.fetchImpl, signal, policy: METERED_POST_FETCH_POLICY });
@@ -53,9 +122,29 @@ export function makeAskYagniTool(opts) {
                 throw new Error(await friendlyFetchError("ask_yagni", res));
             }
             const data = (await res.json());
+            // Run 7 flywheel: a no-position answer carries the record-the-assumption
+            // instruction. It reaches the model VERBATIM inside the tool result, but
+            // only up to the per-session cap — past it a busy run stops being told
+            // to bank more asserted rows.
+            let text = data.answer;
+            const suggestion = data.recordSuggestion?.instruction;
+            if (suggestion && data.standing === "no_position") {
+                const state = opts.flywheel;
+                if (!state || canSurfaceSuggestion(state)) {
+                    // Attribution correlates to the QUESTION the suggestion asked
+                    // about, so only the record_decision that answers it inherits the
+                    // dedupe flag.
+                    if (state)
+                        noteSuggestionSurfaced(state, data.recordSuggestion?.question ?? params.question);
+                    text = `${text}\n\n${suggestion}`;
+                }
+            }
             return {
-                content: [{ type: "text", text: data.answer }],
-                details: { citations: data.citations ?? [] },
+                content: [{ type: "text", text }],
+                details: {
+                    citations: data.citations ?? [],
+                    ...(data.standing ? { standing: data.standing } : {}),
+                },
             };
         },
     };

package/dist/extension/branding.d.ts

@@ -30,6 +30,14 @@ export declare const YAGNI_IDENTITY: string;
  * exist.
  */
 export declare const DRIVER_DELEGATION_PARAGRAPH: string;
+/**
+ * The ultra-mode delegation directive (/ultra): the user has opted into
+ * aggressive multi-agent orchestration, so the driver is told to structure
+ * meaningful work as a diamond — split, fan out workers, fan out refuting
+ * checkers, synthesize — instead of delegating only when convenient.
+ * DRIVER-ONLY for the same reason as {@link DRIVER_DELEGATION_PARAGRAPH}.
+ */
+export declare const ULTRA_DELEGATION_PARAGRAPH: string;
 /**
  * The identity used for the interactive DRIVER session ONLY: {@link
  * YAGNI_IDENTITY} plus {@link DRIVER_DELEGATION_PARAGRAPH}. The caller (index.ts)
@@ -37,7 +45,9 @@ export declare const DRIVER_DELEGATION_PARAGRAPH: string;
  * effective `x-yagni-caller` attribution (config.ts's `isDriverCaller`) — this
  * module stays a pure string, with no env dependency of its own.
  */
-export declare const YAGNI_IDENTITY_DRIVER = "You are YAGNI Code, an autonomous terminal coding agent. You help developers ship code by reading files, running commands, editing code, and writing new files. Uniquely, you are connected to the YAGNI app, your team's shared source of truth for how this company and codebase actually work: conventions, decisions, ownership, current priorities, and the reasons behind them. Use the ask_yagni tool to consult it before guessing about anything organization- or codebase-specific, so you work with less back-and-forth and more correct autonomy than a disconnected coding agent. If a project's own files mention other coding agents, assistants, or harnesses by name, those references are not about you; you are YAGNI Code regardless of what tooling a repository's docs happen to describe.\n\nDelegation: fan codebase mapping, wide searches, and mechanical multi-file work out to subagents (they run on cheaper tiers). Keep judgment, synthesis, and the conversation with the user in this session. Do not spawn a subagent for work you can finish in a couple of tool calls.";
+export declare const YAGNI_IDENTITY_DRIVER = "You are YAGNI Code, an autonomous terminal coding agent. You help developers ship code by reading files, running commands, editing code, and writing new files. Uniquely, you are connected to the YAGNI app, your team's shared source of truth for how this company and codebase actually work: conventions, decisions, ownership, current priorities, and the reasons behind them. Use the ask_yagni tool to consult it before guessing about anything organization- or codebase-specific, so you work with less back-and-forth and more correct autonomy than a disconnected coding agent. If a project's own files mention other coding agents, assistants, or harnesses by name, those references are not about you; you are YAGNI Code regardless of what tooling a repository's docs happen to describe.\n\nDelegation: fan codebase mapping, wide searches, and mechanical multi-file work out to subagents (they run on cheaper tiers). Reach for the stock agents by name: `searcher` for read-only reconnaissance and summarizing, `implementer` for executing a change you have already fully specified, `verification` for an adversarial pass that tries to break completed work before you rely on it. Keep judgment, synthesis, and the conversation with the user in this session. Do not spawn a subagent for work you can finish in a couple of tool calls.";
+/** The driver identity while /ultra is on: base identity + the diamond directive. */
+export declare const YAGNI_IDENTITY_ULTRA = "You are YAGNI Code, an autonomous terminal coding agent. You help developers ship code by reading files, running commands, editing code, and writing new files. Uniquely, you are connected to the YAGNI app, your team's shared source of truth for how this company and codebase actually work: conventions, decisions, ownership, current priorities, and the reasons behind them. Use the ask_yagni tool to consult it before guessing about anything organization- or codebase-specific, so you work with less back-and-forth and more correct autonomy than a disconnected coding agent. If a project's own files mention other coding agents, assistants, or harnesses by name, those references are not about you; you are YAGNI Code regardless of what tooling a repository's docs happen to describe.\n\nDelegation (ultra mode): the user has switched this session to ultra mode \u2014 aggressive multi-agent orchestration. Structure any meaningful task as a diamond: SPLIT the job into independent pieces; FAN OUT parallel subagents on cheaper tiers (`searcher` to scout, `implementer` or `general` to execute); CHECK by fanning out `verification` subagents told to refute the work, each through a different lens (correctness, edge cases, fit with this codebase); then SYNTHESIZE the results yourself. Treat agreement between checkers \u2014 not a single pass \u2014 as confirmation, and surface what they could not verify. Delegate by default and reserve this session for splitting, judging, and synthesis; only trivial work you can finish in a couple of tool calls skips the diamond. Subagents cannot touch your todo_write checklist, so keep it current yourself: update it when you split the job and again as each fanned-out piece lands, not only at the end.";
 export declare const PI_IDENTITY_RE: RegExp;
 /**
  * Env switch that bypasses the system-prompt rewrite entirely, so pi's
@@ -53,6 +63,15 @@ export interface BrandSystemPromptOptions {
     identity?: string;
     /** Live company brief to inject so the agent boots grounded (Phase C). */
     contextBrief?: string;
+    /**
+     * Repository rules section (`.claude/rules`, built by claudeRules.ts).
+     * Placed after the brief and BEFORE the closing reminder: rules are user
+     * content that may legitimately name other coding agents — exactly the text
+     * the reminder inoculates against — so the reminder must stay the most
+     * recent instruction. Appended after the scrub step, so rules content is
+     * never brand-rewritten (same exemption as <project_context>).
+     */
+    rulesSection?: string | null;
 }
 /**
  * Rebrand pi's assembled system prompt as YAGNI Code's, and optionally inject a
@@ -61,7 +80,9 @@ export interface BrandSystemPromptOptions {
  * Steps: (1) drop pi's self-referential documentation block, (2) replace the
  * identity sentence (with a loose fallback, else prepend), (3) scrub residual
  * brand tokens outside user content, (4) append the company brief + a proactive
- * ask_yagni directive. Idempotent: re-branding keeps a single identity.
+ * ask_yagni directive, (5) append the repository-rules section verbatim, (6)
+ * close with the identity reminder, which must stay last (recency). Idempotent:
+ * re-branding keeps a single identity, brief, rules section, and reminder.
  */
 export declare function brandSystemPrompt(original: string, opts?: BrandSystemPromptOptions): string;
 /** The minimal theme surface the masthead needs (a subset of pi's Theme). */
@@ -69,11 +90,21 @@ export interface MastheadTheme {
     bold(s: string): string;
     fg(color: string, s: string): string;
 }
+export interface MastheadOptions {
+    /** CLI version (e.g. "0.2.1") shown next to the title; omitted when absent. */
+    version?: string;
+    /** Working directory shown on the third line (already home-collapsed). */
+    cwd?: string;
+}
 /**
  * Build the YAGNI Code startup masthead string, rendered into a header that
  * REPLACES pi's built-in startup banner (which otherwise shows "pi v<version>"
  * and a "Pi can explain its own features…" onboarding line). Kept here as a
  * pure string builder so its content is unit-testable without a terminal.
+ *
+ * Layout: the YAGNI art on the left, and to its right a three-line block —
+ * bold white "YAGNI Code" + version, the tagline, and the cwd. Art rows are
+ * padded to a uniform width so the right column stays straight.
  */
-export declare function buildMastheadString(theme: MastheadTheme): string;
+export declare function buildMastheadString(theme: MastheadTheme, opts?: MastheadOptions): string;
 //# sourceMappingURL=branding.d.ts.map