@yagni-app/code-staging 0.0.0 → 0.1.0-staging.997.1

package/dist/extension/askAdvisorTool.js

@@ -0,0 +1,188 @@
+/**
+ * `ask_advisor` — the peak-tier escalation available to Balanced sessions (YAG-380).
+ *
+ * Cheap driver, expensive consultant: a Balanced 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
+ * `record_decision` can bank it into the corpus afterwards.
+ *
+ * Two deliberate design calls, both of which cost money and buy quality:
+ *
+ *   1. The advisor gets REAL read-only recon (read/grep/find/ls), the same set
+ *      the plan stage uses. An advisor limited to what the driver pre-digested
+ *      rubber-stamps the driver's framing; half the value of escalation is
+ *      looking where the driver did not think to look. This makes a consult an
+ *      agentic loop, so a thorough one on a large repo runs $0.40-$1.00 rather
+ *      than the ~4c a single-shot completion would cost. That is the price of
+ *      the advisor being useful. It gets NO bash: a consultant reasons and
+ *      reads, it must not build, run, or write.
+ *   2. The input schema is NARROW on purpose — question, what was tried,
+ *      relevant excerpts. There is deliberately no field a conversation
+ *      transcript fits into, because passing the transcript is how a consult
+ *      silently becomes more expensive than just running peak.
+ *
+ * The gate, the cap and the spend ceiling live in `advisor.ts` and are pure;
+ * this module is the I/O.
+ */
+import { Type } from "typebox";
+import { ADVISOR_MODEL_TIER, DEFAULT_ADVISOR_LIMITS, decideConsult, formatConsultCost, } from "./advisor.js";
+import { runStage as defaultRunStage } from "./pipeline/runner.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
+ * single `read`. No `bash`.
+ */
+export const ADVISOR_TOOLS = ["read", "grep", "find", "ls", "ask_yagni"];
+const parameters = Type.Object({
+    question: Type.String({
+        description: "The single judgment call you want a second opinion on. Be specific.",
+    }),
+    tried: Type.Optional(Type.String({ description: "What you have already tried or ruled out, and why." })),
+    excerpts: Type.Optional(Type.String({ description: "Relevant code excerpts or file paths. Not a transcript." })),
+});
+/**
+ * Assemble the consult brief. The advisor's persona already tells it not to take
+ * this framing on trust, so the brief orients rather than constrains.
+ */
+export function buildConsultBrief(params) {
+    const parts = [`Question: ${params.question}`];
+    if (params.tried?.trim())
+        parts.push(`Already tried / ruled out:\n${params.tried.trim()}`);
+    if (params.excerpts?.trim())
+        parts.push(`Relevant excerpts:\n${params.excerpts.trim()}`);
+    parts.push("Read the code yourself before answering. Do not assume the framing above is complete.");
+    return parts.join("\n\n");
+}
+/**
+ * The synthetic stage a consult runs as.
+ *
+ * `id` reuses the existing `plan` StageId rather than adding an advisor member:
+ * the advisor is NOT a pipeline stage, and a new StageId would ripple into the
+ * feed/activity reducers that switch over it. `agent` is what selects the
+ * persona, and that is the advisor's own.
+ */
+export function advisorStage() {
+    return {
+        id: "plan",
+        agent: "advisor",
+        model: ADVISOR_MODEL_TIER,
+        tools: ADVISOR_TOOLS,
+        taskTemplate: "{ticket}",
+    };
+}
+export function makeAskAdvisorTool(opts) {
+    const limits = opts.limits ?? DEFAULT_ADVISOR_LIMITS;
+    const runStage = opts.runStage ?? defaultRunStage;
+    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 " +
+            "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 " +
+            "committing to an approach you would have to unwind. Do NOT use it for " +
+            "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).",
+        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.",
+            "Consults are capped per session. Spend them on the calls you would otherwise get wrong.",
+            "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,
+        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.
+            const decision = decideConsult({
+                model: ctx?.model?.id,
+                state: opts.state.read(),
+                limits,
+            });
+            if (!decision.allow) {
+                return {
+                    content: [{ type: "text", text: decision.reason ?? "ask_advisor is unavailable." }],
+                    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 } : {}) });
+            const cost = result.usage?.cost ?? 0;
+            const state = opts.state.record(cost);
+            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.
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `The advisor consult failed (exit ${result.exitCode}). ` +
+                                `${formatConsultCost({ cost, consults: state.consults, limits })} ` +
+                                `Decide this one yourself.`,
+                        },
+                    ],
+                    details: { consults: state.consults, cost },
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `${result.finalOutput.trim()}\n\n${formatConsultCost({ cost, consults: state.consults, limits })}`,
+                    },
+                ],
+                details: { consults: state.consults, cost },
+            };
+        },
+    };
+}
+/**
+ * `/advise <question>` — the manual escalation lever.
+ *
+ * Runs the SAME tool the model calls, sharing one state handle, so a manual
+ * 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.
+ */
+export function registerAdviseCommand(pi, tool) {
+    pi.registerCommand("advise", {
+        description: "Escalate one hard call to the peak-tier advisor (Balanced sessions only, capped per session).",
+        handler: async (args, ctx) => {
+            const notify = (message, type) => {
+                if (ctx.hasUI)
+                    ctx.ui.notify(message, type);
+            };
+            const question = args.trim();
+            if (!question) {
+                notify("Usage: /advise <the judgment call you want a second opinion on>", "warning");
+                return;
+            }
+            if (!ctx.isIdle()) {
+                notify("YAGNI Code is busy; wait for the current turn to finish before /advise.", "warning");
+                return;
+            }
+            notify("Consulting the peak-tier advisor. This reads the repo, so it takes a moment.", "info");
+            try {
+                const out = await tool.execute("advise", { question }, ctx.signal, undefined, ctx);
+                const text = out.content
+                    .map((c) => c.text ?? "")
+                    .join("\n")
+                    .trim();
+                await pi.sendUserMessage(text || "The advisor returned nothing.");
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                notify(`/advise failed: ${message}`, "error");
+                await pi.sendUserMessage(`/advise failed: ${message}`);
+            }
+        },
+    });
+}
+//# sourceMappingURL=askAdvisorTool.js.map

package/dist/extension/askYagniTool.d.ts

@@ -0,0 +1,39 @@
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { type RepoDocSnippet } from "./repoDocs.js";
+/** A single source citation returned by the YAGNI `ask` endpoint. */
+export interface Citation {
+    title: string;
+    url: string;
+}
+/** Options for {@link makeAskYagniTool}. */
+export interface MakeAskYagniToolOptions {
+    baseUrl: string;
+    getToken: () => string | undefined;
+    fetchImpl?: typeof fetch;
+    /**
+     * Repo-doc grounding seam (default: the real bounded collector). The tool
+     * sends the working tree's most relevant docs (ADRs, CONTEXT.md, AGENTS.md,
+     * docs/*.md) alongside the question so the backend can ground its answer in
+     * repo-level knowledge the workspace corpus does not hold — always at the
+     * checkout's own era, since the docs are read from the tree being edited.
+     */
+    collectDocs?: (cwd: string, query: string) => RepoDocSnippet[];
+}
+declare const parameters: Type.TObject<{
+    question: Type.TString;
+    context: Type.TOptional<Type.TString>;
+}>;
+/**
+ * Build the `ask_yagni` tool definition.
+ *
+ * The tool asks the YAGNI app a question grounded in the company's business and
+ * codebase context, returning a grounded answer plus source citations. It is the
+ * preferred way for the agent to learn anything org- or codebase-specific
+ * (conventions, policies, architecture, ownership) before guessing.
+ */
+export declare function makeAskYagniTool(opts: MakeAskYagniToolOptions): ToolDefinition<typeof parameters, {
+    citations: Citation[];
+}>;
+export {};
+//# sourceMappingURL=askYagniTool.d.ts.map

package/dist/extension/askYagniTool.js

@@ -0,0 +1,63 @@
+import { Type } from "typebox";
+import { collectRepoDocs } from "./repoDocs.js";
+import { friendlyFetchError, METERED_POST_FETCH_POLICY, resilientFetch } from "./resilientFetch.js";
+const parameters = Type.Object({
+    question: Type.String(),
+    context: Type.Optional(Type.String()),
+});
+/**
+ * Build the `ask_yagni` tool definition.
+ *
+ * The tool asks the YAGNI app a question grounded in the company's business and
+ * codebase context, returning a grounded answer plus source citations. It is the
+ * preferred way for the agent to learn anything org- or codebase-specific
+ * (conventions, policies, architecture, ownership) before guessing.
+ */
+export function makeAskYagniTool(opts) {
+    return {
+        name: "ask_yagni",
+        label: "Ask YAGNI",
+        description: "Ask the YAGNI app a question grounded in this company's business and codebase context. " +
+            "Returns a grounded answer plus source citations. Use this BEFORE guessing about anything " +
+            "organization- or codebase-specific — conventions, policies, architecture, ownership, " +
+            "product decisions, or who/what/why. Prefer asking over assuming.",
+        promptSnippet: "ask_yagni: ask the YAGNI app a question grounded in company + codebase context (returns a cited answer).",
+        promptGuidelines: [
+            "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.",
+        ],
+        parameters,
+        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
+            // for this question. Never blocking and never fatal — an empty list sends
+            // nothing and the backend answers from workspace context alone.
+            const collect = opts.collectDocs ?? collectRepoDocs;
+            const repoQuery = params.context ? `${params.question}\n${params.context}` : params.question;
+            const repoDocs = ctx?.cwd ? collect(ctx.cwd, repoQuery) : [];
+            const res = await resilientFetch(`${opts.baseUrl}/api/yagni-code/ask`, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    authorization: `Bearer ${opts.getToken() ?? ""}`,
+                },
+                body: JSON.stringify({
+                    question: params.question,
+                    context: params.context,
+                    cwd: ctx?.cwd,
+                    ...(repoDocs.length > 0 ? { repoDocs } : {}),
+                }),
+            }, { fetchImpl: opts.fetchImpl, signal, policy: METERED_POST_FETCH_POLICY });
+            if (!res.ok) {
+                throw new Error(await friendlyFetchError("ask_yagni", res));
+            }
+            const data = (await res.json());
+            return {
+                content: [{ type: "text", text: data.answer }],
+                details: { citations: data.citations ?? [] },
+            };
+        },
+    };
+}
+//# sourceMappingURL=askYagniTool.js.map

package/dist/extension/bless.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Session-scoped bless store for review-mode "don't ask again" (spec §4, W4).
+ *
+ * A bless rule is (tool + directory prefix). It is created ONLY when the user
+ * picks "Yes, and don't ask again for <tool> in <dir>" at the review gate, and
+ * it is:
+ *   - SESSION-SCOPED: held in memory for the life of THIS process only.
+ *   - NEVER persisted (no disk, no backend) — a new session starts unblessed,
+ *     and (per the gate wiring) it is never consulted in plan mode.
+ *   - PATH-PREFIX-bound: a rule blesses a tool within one directory subtree, so
+ *     approving `write` under `src/api/` never auto-approves a `write` elsewhere.
+ *   - Only for path-bearing tools (read/write/edit expose `path`). `bash` carries
+ *     no path, so it is NOT blessable and always re-prompts (fail toward asking).
+ *
+ * Paths are resolved to absolute against the session cwd at BOTH bless-time and
+ * match-time, so a rule created from a relative `path` still matches an absolute
+ * one (and vice versa). Everything is pure except the in-memory rule list.
+ */
+/** One session bless: this tool is auto-approved within this directory subtree. */
+export interface BlessRule {
+    tool: string;
+    /** Absolute directory prefix the rule blesses (subtree-inclusive). */
+    prefix: string;
+}
+export interface BlessStore {
+    /** Can a bless rule be formed for this call? (path-bearing tools only.) */
+    canBless(params: Record<string, unknown>): boolean;
+    /**
+     * A short, cwd-relative directory label for the "don't ask again" option, or
+     * null when the call carries no path (bash). Absolute when outside the tree,
+     * "." at the repo root, otherwise the relative directory.
+     */
+    describeDir(params: Record<string, unknown>): string | null;
+    /** Add a (tool + dir-prefix) rule from a blessed call. Null if not blessable. */
+    add(tool: string, params: Record<string, unknown>): BlessRule | null;
+    /** Does an existing rule already bless this call? */
+    isBlessed(tool: string, params: Record<string, unknown>): boolean;
+    /** The current rules (test/debug visibility). */
+    rules(): BlessRule[];
+}
+/** The file path a call targets, or null for path-less tools (bash). */
+export declare function blessPath(params: Record<string, unknown>): string | null;
+/** Build a fresh, empty session bless store rooted at `cwd`. */
+export declare function makeBlessStore(cwd: string): BlessStore;
+//# sourceMappingURL=bless.d.ts.map

package/dist/extension/bless.js

@@ -0,0 +1,74 @@
+/**
+ * Session-scoped bless store for review-mode "don't ask again" (spec §4, W4).
+ *
+ * A bless rule is (tool + directory prefix). It is created ONLY when the user
+ * picks "Yes, and don't ask again for <tool> in <dir>" at the review gate, and
+ * it is:
+ *   - SESSION-SCOPED: held in memory for the life of THIS process only.
+ *   - NEVER persisted (no disk, no backend) — a new session starts unblessed,
+ *     and (per the gate wiring) it is never consulted in plan mode.
+ *   - PATH-PREFIX-bound: a rule blesses a tool within one directory subtree, so
+ *     approving `write` under `src/api/` never auto-approves a `write` elsewhere.
+ *   - Only for path-bearing tools (read/write/edit expose `path`). `bash` carries
+ *     no path, so it is NOT blessable and always re-prompts (fail toward asking).
+ *
+ * Paths are resolved to absolute against the session cwd at BOTH bless-time and
+ * match-time, so a rule created from a relative `path` still matches an absolute
+ * one (and vice versa). Everything is pure except the in-memory rule list.
+ */
+import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
+/** The file path a call targets, or null for path-less tools (bash). */
+export function blessPath(params) {
+    const p = params.path;
+    return typeof p === "string" && p.trim().length > 0 ? p.trim() : null;
+}
+/** Build a fresh, empty session bless store rooted at `cwd`. */
+export function makeBlessStore(cwd) {
+    const rules = [];
+    const abs = (p) => (isAbsolute(p) ? p : resolve(cwd, p));
+    /** Absolute directory prefix a bless of this call would cover, or null. */
+    function prefixFor(params) {
+        const p = blessPath(params);
+        if (p === null)
+            return null;
+        return abs(dirname(p));
+    }
+    return {
+        canBless(params) {
+            return blessPath(params) !== null;
+        },
+        describeDir(params) {
+            const prefix = prefixFor(params);
+            if (prefix === null)
+                return null;
+            const rel = relative(cwd, prefix);
+            // Inside the tree → the relative dir (or "." for the repo root); outside →
+            // the absolute path so the user sees exactly what they are blessing.
+            if (rel === "")
+                return ".";
+            if (!rel.startsWith("..") && !isAbsolute(rel))
+                return rel;
+            return prefix;
+        },
+        add(tool, params) {
+            const prefix = prefixFor(params);
+            if (prefix === null)
+                return null;
+            if (!rules.some((r) => r.tool === tool && r.prefix === prefix)) {
+                rules.push({ tool, prefix });
+            }
+            return { tool, prefix };
+        },
+        isBlessed(tool, params) {
+            const p = blessPath(params);
+            if (p === null)
+                return false; // path-less (bash) never auto-approves
+            const target = abs(p);
+            return rules.some((r) => r.tool === tool && (target === r.prefix || target.startsWith(r.prefix + sep)));
+        },
+        rules() {
+            return rules.slice();
+        },
+    };
+}
+//# sourceMappingURL=bless.js.map

package/dist/extension/branding.d.ts

@@ -0,0 +1,48 @@
+/**
+ * YAGNI Code branding.
+ *
+ * YAGNI Code IS the pi coding agent, but a developer running it should never see
+ * "pi" or "Earendil" — not in the agent's self-description, not in the chrome.
+ * pi stays an unmodified dependency; we rebrand entirely through its extension
+ * API. This module owns the one place that matters most: the system prompt
+ * identity. It is a pure function so it is fully unit-testable without pi.
+ */
+/** User-facing product name. */
+export declare const BRAND_NAME = "YAGNI Code";
+/**
+ * The YAGNI Code identity paragraph that replaces pi's default
+ * "You are an expert coding assistant operating inside pi..." opener. It states
+ * the differentiator (connected to the YAGNI app) and the working contract
+ * (consult ask_yagni before guessing) so the agent behaves more autonomously.
+ */
+export declare const YAGNI_IDENTITY: string;
+export declare const PI_IDENTITY_RE: RegExp;
+export interface BrandSystemPromptOptions {
+    /** Override the identity paragraph (defaults to {@link YAGNI_IDENTITY}). */
+    identity?: string;
+    /** Live company brief to inject so the agent boots grounded (Phase C). */
+    contextBrief?: string;
+}
+/**
+ * Rebrand pi's assembled system prompt as YAGNI Code's, and optionally inject a
+ * live company brief.
+ *
+ * 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.
+ */
+export declare function brandSystemPrompt(original: string, opts?: BrandSystemPromptOptions): string;
+/** The minimal theme surface the masthead needs (a subset of pi's Theme). */
+export interface MastheadTheme {
+    bold(s: string): string;
+    fg(color: string, s: string): 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.
+ */
+export declare function buildMastheadString(theme: MastheadTheme): string;
+//# sourceMappingURL=branding.d.ts.map

package/dist/extension/branding.js

@@ -0,0 +1,119 @@
+/**
+ * YAGNI Code branding.
+ *
+ * YAGNI Code IS the pi coding agent, but a developer running it should never see
+ * "pi" or "Earendil" — not in the agent's self-description, not in the chrome.
+ * pi stays an unmodified dependency; we rebrand entirely through its extension
+ * API. This module owns the one place that matters most: the system prompt
+ * identity. It is a pure function so it is fully unit-testable without pi.
+ */
+/** User-facing product name. */
+export const BRAND_NAME = "YAGNI Code";
+/**
+ * The YAGNI Code identity paragraph that replaces pi's default
+ * "You are an expert coding assistant operating inside pi..." opener. It states
+ * the differentiator (connected to the YAGNI app) and the working contract
+ * (consult ask_yagni before guessing) so the agent behaves more autonomously.
+ */
+export const YAGNI_IDENTITY = "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.";
+// pi 0.83.0's exact identity sentence (dist/core/system-prompt.js). Exported as
+// the identity anchor the CLI's pi-contract tripwire test reads back from pi's
+// built system prompt, so a pi bump that reworded the opener (silently defeating
+// our rebrand) fails CI loudly. Export-only: no behavior change here.
+export const PI_IDENTITY_RE = /You are an expert coding assistant operating inside pi, a coding agent harness\.\s*You help users by reading files, executing commands, editing code, and writing new files\./;
+// Looser fallback if pi rewords its opener in a future version.
+const PI_IDENTITY_LOOSE_RE = /You are [^\n.]*operating inside pi[^\n.]*\.(?:\s*You help[^\n.]*\.)?/i;
+// pi's self-referential "Pi documentation (...)" header plus its bullet list.
+// The block is a header line followed by consecutive "- " bullets; matching the
+// bullets explicitly keeps us safe regardless of what section pi appends next.
+const PI_DOCS_BLOCK_RE = /\n*Pi documentation \(read only[^\n]*(?:\n- [^\n]*)*/gi;
+/** Neutralize residual pi/Earendil brand tokens in pi-owned text. */
+function scrubPiHarness(text) {
+    return text
+        .replace(/\bEarendil(?:\s+Works)?\b/gi, "YAGNI")
+        // Whole-word "pi" only, so "api", "pip", "pipeline" are untouched.
+        .replace(/\bpi\b/gi, BRAND_NAME);
+}
+/**
+ * Scrub pi-brand tokens everywhere EXCEPT inside the user's <project_context>.
+ * The user's own AGENTS.md may legitimately mention "pi-extension-yagni"; a
+ * blanket scrub would corrupt their instructions. pi wraps project files in
+ * <project_context>…</project_context>, so we leave those segments verbatim.
+ */
+function scrubOutsideProjectContext(s) {
+    const parts = s.split(/(<project_context>[\s\S]*?<\/project_context>)/);
+    return parts
+        .map((p) => (p.startsWith("<project_context>") ? p : scrubPiHarness(p)))
+        .join("");
+}
+/**
+ * Rebrand pi's assembled system prompt as YAGNI Code's, and optionally inject a
+ * live company brief.
+ *
+ * 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.
+ */
+export function brandSystemPrompt(original, opts = {}) {
+    const identity = opts.identity ?? YAGNI_IDENTITY;
+    let s = original;
+    // 1. Drop pi's self-referential documentation block.
+    s = s.replace(PI_DOCS_BLOCK_RE, "");
+    // 2. Own the identity.
+    if (PI_IDENTITY_RE.test(s)) {
+        s = s.replace(PI_IDENTITY_RE, identity);
+    }
+    else if (PI_IDENTITY_LOOSE_RE.test(s)) {
+        s = s.replace(PI_IDENTITY_LOOSE_RE, identity);
+    }
+    else if (!s.trimStart().startsWith(identity)) {
+        s = `${identity}\n\n${s}`;
+    }
+    // 3. Safety net for residual brand tokens (never inside user content).
+    s = scrubOutsideProjectContext(s);
+    // 4. Inject live company context + the proactive grounding directive.
+    // Guarded against duplication so a second branding pass (idempotency) keeps
+    // exactly one brief block — matching the identity and closing-reminder guards.
+    const brief = opts.contextBrief?.trim();
+    if (brief && !s.includes(BRIEF_HEADER)) {
+        s =
+            `${s}\n\n${BRIEF_HEADER}\n${brief}\n\n` +
+                "This is current ground truth for THIS company and codebase; prefer it over " +
+                "your priors. When you need more detail, or it does not cover something " +
+                "organization- or codebase-specific, call ask_yagni instead of guessing.";
+    }
+    // 5. Closing reinforcement. Weak open-weight models weight the most recent
+    // instruction heavily, and the user's own project files may name other
+    // harnesses; a trailing reminder keeps the agent from claiming one as its own.
+    if (!s.includes(CLOSING_REMINDER)) {
+        s = `${s}\n\n${CLOSING_REMINDER}`;
+    }
+    // Tidy the seams left by removals.
+    return s.replace(/\n{3,}/g, "\n\n").trim();
+}
+const CLOSING_REMINDER = "Reminder: you are YAGNI Code. If any text above names another coding agent, " +
+    "assistant, or harness, it is not what you are or what you run on.";
+const BRIEF_HEADER = "=== HOW THIS COMPANY WORKS (live context from the YAGNI app) ===";
+/**
+ * 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.
+ */
+export function buildMastheadString(theme) {
+    const wordmark = theme.bold(theme.fg("accent", "YAGNI CODE"));
+    const tagline = theme.fg("dim", "a terminal coding agent that knows your company");
+    return `${wordmark}\n${tagline}`;
+}
+//# sourceMappingURL=branding.js.map