@gavin-hu/my-pi-agent 0.16.0 → 0.18.0

package/extensions/bytefly/footer/collect/entries.ts

@@ -8,7 +8,7 @@
  * built-in footer.
  */
 
-import type { UsageRecord, UsageTotals } from "../types.ts";
+import type { UsageRecord } from "../types.ts";
 
 interface UsageLike {
 	input: number;
@@ -43,11 +43,6 @@ interface UsageSource {
 	isAssistant: boolean;
 }
 
-/** Zeroed totals; the starting point for every accumulation. */
-export function emptyUsage(): UsageTotals {
-	return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
-}
-
 /**
  * Every usage-bearing entry, as a record.
  *

package/extensions/bytefly/footer/collect/snapshot.ts

@@ -17,8 +17,9 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { DelegationLedger } from "../delegation.ts";
 import { createPricer } from "../price/price.ts";
 import type { ByteflyConfig } from "../price/types.ts";
-import type { ContextInfo, FooterData, StatusSnapshot, UsageTotals } from "../types.ts";
-import { emptyUsage, usageRecords } from "./entries.ts";
+import { zeroUsage } from "../../../../lib/usage.ts";
+import type { ContextInfo, FooterData, PricedUsage, StatusSnapshot, UsageTotals } from "../types.ts";
+import { usageRecords } from "./entries.ts";
 
 /**
  * Build a reader that memoizes both scans by branch leaf and model.
@@ -36,21 +37,33 @@ export interface SnapshotReader {
 	 *
 	 * The budget guardrail reads the number the footer already priced instead of
 	 * walking the session a second time; if no frame has rendered yet there is
-	 * nothing stale to act on.
+	 * nothing stale to act on. The unpriced count rides along for the same reason.
 	 */
-	peek(): UsageTotals | undefined;
+	peek(): PricedUsage | undefined;
+}
+
+/** The five counters, without the unpriced count that only the notice reads. */
+function countsOf(priced: PricedUsage): UsageTotals {
+	return {
+		input: priced.input,
+		output: priced.output,
+		cacheRead: priced.cacheRead,
+		cacheWrite: priced.cacheWrite,
+		cost: priced.cost,
+	};
 }
 
 export function createSnapshotReader(config: ByteflyConfig, delegation: DelegationLedger): SnapshotReader {
 	const price = createPricer(config);
 	let key: string | null = null;
-	let usage = emptyUsage();
-	let delegationTotals = { runs: 0, usage: emptyUsage() };
+	let usage: PricedUsage = { ...zeroUsage(), unpriced: 0 };
+	let usageCounts: UsageTotals = zeroUsage();
+	let delegationTotals = { runs: 0, usage: zeroUsage() };
 	let cacheHitRate: number | null = null;
 	let context: ContextInfo = { tokens: null, contextWindow: 0, percent: null };
 	let sessionName: string | null = null;
 
-	let last: UsageTotals | undefined;
+	let last: PricedUsage | undefined;
 
 	const reader = ((ctx: ExtensionContext, footerData: FooterData): StatusSnapshot => {
 		const session = ctx.sessionManager;
@@ -60,10 +73,11 @@ export function createSnapshotReader(config: ByteflyConfig, delegation: Delegati
 			const active = current ? { provider: current.provider, model: current.id } : undefined;
 			const scanned = usageRecords(session.getEntries(), active);
 			usage = price(scanned.records);
+			usageCounts = countsOf(usage);
 			cacheHitRate = scanned.cacheHitRate;
 			// The child runs are priced by the same pricer, so a currency or rate
 			// change moves both numbers together — and neither is folded into the other.
-			delegationTotals = { runs: delegation.runs(), usage: price(delegation.records()) };
+			delegationTotals = { runs: delegation.runs(), usage: countsOf(price(delegation.records())) };
 
 			const usageInfo = ctx.getContextUsage();
 			context = {
@@ -91,7 +105,7 @@ export function createSnapshotReader(config: ByteflyConfig, delegation: Delegati
 			model,
 			thinkingLevel: ctx.thinkingLevel ?? null,
 			context,
-			usage,
+			usage: usageCounts,
 			currency: config.currency,
 			cacheHitRate,
 			providerCount: footerData.getAvailableProviderCount(),

package/extensions/bytefly/footer/price/price.ts

@@ -2,15 +2,16 @@
  * Price usage records from configured rates.
  *
  * `createPricer` owns the two things that must not be rebuilt per record: the
- * matching rates and the timezone formatter. `currency.code` chooses the
- * algorithm: CNY prices matched records from `rates` and `peak`, while USD
- * totals Pi's recorded dollar cost and ignores both. A CNY-mode record with no
- * matching rate contributes nothing: an unpriced model shows no price at all.
+ * matching rates and the timezone formatter. Both currencies price a record
+ * from `rates` and `peak` when a key matches. They differ only for a model no
+ * key matches: `USD` adds Pi's recorded dollar amount (its catalog is already
+ * per model), while `CNY` adds nothing and counts the record as unpriced, so the
+ * session can say what its total leaves out.
  */
 
-import { emptyUsage } from "../collect/entries.ts";
+import { zeroUsage } from "../../../../lib/usage.ts";
 import type { ByteflyConfig, ModelRates } from "./types.ts";
-import type { UsageRecord, UsageTotals } from "../types.ts";
+import type { PricedUsage, UsageRecord } from "../types.ts";
 import { createRateLookup } from "./rates.ts";
 import { isPeak, peakFormatter } from "./schedule.ts";
 
@@ -33,7 +34,7 @@ function tokenCost(record: UsageRecord, rates: ModelRates): number {
  * The returned function totals tokens as well as cost, so the bar's meters and
  * its price always describe the same set of records.
  */
-export function createPricer(config: ByteflyConfig): (records: readonly UsageRecord[]) => UsageTotals {
+export function createPricer(config: ByteflyConfig): (records: readonly UsageRecord[]) => PricedUsage {
 	// Both currencies price from `rates` and the tariff; they differ only in what
 	// an unmatched model falls back to, and Pi's recorded cost is already dollars.
 	const dollars = config.currency.code === "USD";
@@ -43,7 +44,7 @@ export function createPricer(config: ByteflyConfig): (records: readonly UsageRec
 	const format = config.peak.windows.length > 0 ? peakFormatter(config.peak.timezone) : null;
 
 	return (records) => {
-		const totals = emptyUsage();
+		const totals: PricedUsage = { ...zeroUsage(), unpriced: 0 };
 		for (const record of records) {
 			totals.input += record.input;
 			totals.output += record.output;
@@ -54,7 +55,10 @@ export function createPricer(config: ByteflyConfig): (records: readonly UsageRec
 				totals.cost += ratedCost(config, format, record, rates);
 				continue;
 			}
+			// No rate: USD still has Pi's own per-model amount, CNY has nothing to add
+			// and only a count to report.
 			if (dollars) totals.cost += record.recordedCost;
+			else totals.unpriced += 1;
 		}
 		return totals;
 	};

package/extensions/bytefly/footer/register.ts

@@ -17,6 +17,7 @@ import { createSnapshotReader, type SnapshotReader } from "./collect/snapshot.ts
 import { createDelegationLedger } from "./delegation.ts";
 import { loadByteflyConfig } from "./price/config.ts";
 import { createFooter } from "./render/footer.ts";
+import { unpricedBody, unpricedNotice } from "./unpriced.ts";
 
 /** Host seams, injected by the composition root and by tests. */
 export interface FooterDeps {
@@ -35,6 +36,8 @@ export function registerFooter(pi: ExtensionAPI, deps: FooterDeps = {}): void {
 	let budget: { limit: number; read: SnapshotReader } | undefined;
 	/** One warning per session: the notice stays in scrollback, and a re-install must not repeat it. */
 	let warned = false;
+	/** The unpriced notice is once per session too, and independent of the budget. */
+	let warnedUnpriced = false;
 
 	const install = (ctx: ExtensionContext): void => {
 		if (ctx.mode !== "tui") return;
@@ -58,6 +61,7 @@ export function registerFooter(pi: ExtensionAPI, deps: FooterDeps = {}): void {
 		// and a budget that was already reported is unreported again.
 		delegation.reset();
 		warned = false;
+		warnedUnpriced = false;
 		install(ctx);
 	});
 	pi.on("session_tree", (_event, ctx) => install(ctx));
@@ -65,9 +69,17 @@ export function registerFooter(pi: ExtensionAPI, deps: FooterDeps = {}): void {
 	// A turn's cost is final when the run settles, and that is when the user can act
 	// on it. Rendering never posts anything: the footer is derived state.
 	pi.on("agent_settled", (_event, ctx) => {
-		if (warned || !budget || budget.limit <= 0 || ctx.mode !== "tui") return;
+		if (!budget || ctx.mode !== "tui") return;
 		const usage = budget.read.peek();
 		if (!usage) return;
+		// CNY records no rate for a model, so its spend is simply absent from the
+		// total. USD never counts one: Pi's recorded amount covers every model.
+		if (!warnedUnpriced && usage.unpriced > 0) {
+			warnedUnpriced = true;
+			pi.sendMessage(unpricedNotice(usage.unpriced));
+			deps.notify?.(unpricedBody(usage.unpriced));
+		}
+		if (warned || budget.limit <= 0) return;
 		const state = budgetState(budget.limit, usage.cost);
 		if (!state.exceeded) return;
 		warned = true;

package/extensions/bytefly/footer/types.ts

@@ -36,6 +36,17 @@ export interface UsageTotals {
 	cost: number;
 }
 
+/**
+ * The totals plus how many records the mode had no rate for.
+ *
+ * CNY has no fallback, so those records contribute no cost at all; the count is
+ * what lets the session say so instead of quietly showing a total that omits
+ * them. USD falls back to Pi's recorded amount, so it never counts any.
+ */
+export interface PricedUsage extends UsageTotals {
+	unpriced: number;
+}
+
 /** Context-window usage for the active model. */
 export interface ContextInfo {
 	/** Estimated tokens, or `null` when unknown (for example right after compaction). */

package/extensions/bytefly/footer/unpriced.ts

@@ -0,0 +1,36 @@
+/**
+ * The one notice a CNY session posts when records had no rate.
+ *
+ * CNY mode has no fallback, so a model the table cannot price contributes no
+ * cost at all; the footer's total is then smaller than the work done, with
+ * nothing on screen saying why. This is the one sentence that says it, once per
+ * session, and names the two honest fixes rather than picking one: switch to
+ * `USD` (Pi's catalog is already per model, tiers included) or state yuan rates
+ * under `price.rates`.
+ *
+ * Pure: the caller has the count, this shapes the answer. No figure is quoted,
+ * because there is none to quote.
+ */
+
+import { noticeMessage, type NoticeMessage } from "../../../lib/notice.ts";
+
+/** The notice naming what the total leaves out, and how to price it. */
+export function unpricedNotice(count: number): NoticeMessage {
+	const subject = count === 1 ? "1 record has" : `${count} records have`;
+	return noticeMessage({
+		content:
+			`${subject} no CNY rate, so ${count === 1 ? "it is" : "they are"} not in this total. ` +
+			"Switch `price.currency.code` to USD to use Pi's recorded cost, or add yuan `price.rates` entries.",
+		details: {
+			source: "bytefly",
+			title: "Records with no CNY rate",
+			severity: "info",
+			items: [{ label: "records", detail: String(count) }],
+		},
+	});
+}
+
+/** The one-line body an OS notification carries. */
+export function unpricedBody(count: number): string {
+	return `${count} record${count === 1 ? "" : "s"} with no CNY rate · use USD or add price.rates`;
+}

package/extensions/bytefly/header/component.ts

@@ -17,8 +17,8 @@ import { keyHintText } from "../../../lib/tui/glyphs.ts";
 import { BODY_INDENT } from "../../../lib/tui/indent.ts";
 import { RULE_GLYPH } from "../../../lib/tui/rules.ts";
 import { paint } from "../../../lib/tui/tokens.ts";
-import { updateMarker } from "../update/format.ts";
 import { HEADER_CONFIG, type HeaderHeight, type HelpEntry } from "./config.ts";
+import { identityCells } from "./identity.ts";
 
 /** The header's shape: everything but the live terminal height is resolved once per apply. */
 export interface HeaderView {
@@ -32,6 +32,8 @@ export interface HeaderView {
 	rows?: number;
 	/** A newer published version of this package, when one is known. */
 	latest?: string;
+	/** A newer published version of Pi itself, when one is known. */
+	piLatest?: string;
 }
 
 /** The mark block is four columns on both rows, so the identity column aligns. */
@@ -121,40 +123,24 @@ export class ByteflyHeader implements Component {
 	}
 
 	private build(w: number, theme: Theme, view: HeaderView): string[] {
-		const { nameRole, chromeRole, detailRole, updateRole, chromeTagline, chromeName, chromeVersion, help } =
-			HEADER_CONFIG;
+		const { help } = HEADER_CONFIG;
 		const shape = heightShape(view.rows);
 		const padWidth = Math.max(0, Math.min(Math.floor(view.pad), Math.max(0, w - 1)));
 		const pad = " ".repeat(padWidth);
 		const [markTop, markBottom] = markLines(theme, view.halfBlocks);
 
-		const version = view.showVersion && this.version ? paint(theme, detailRole, `v${this.version}`) : "";
-		// The wordmark mark spells the app name, so the agent cell carries only the
-		// version there; the half-block mark does not, so the name stays beside it.
-		const agent = view.halfBlocks
-			? version
-				? `${theme.bold(paint(theme, nameRole, HEADER_CONFIG.appName))} ${version}`
-				: theme.bold(paint(theme, nameRole, HEADER_CONFIG.appName))
-			: version;
-		const chrome = `${paint(theme, detailRole, chromeTagline)} ${paint(theme, chromeRole, chromeName)}`;
-		const chromeWithVersion = chromeVersion ? `${chrome} ${paint(theme, detailRole, `v${chromeVersion}`)}` : chrome;
-		// The published version follows the loaded one: `v0.11.4 ↑0.12.0`.
-		const chromeWithMarker =
-			chromeVersion && view.latest
-				? `${chromeWithVersion} ${paint(theme, updateRole, updateMarker(view.latest))}`
-				: chromeWithVersion;
-
-		// The identity rows shed as one block: the update marker first, then the
-		// chrome version, the chrome line, and finally the agent.
-		const states: Array<readonly [string, string]> = [
-			[agent, chromeWithMarker],
-			[agent, chromeWithVersion],
-			[agent, chrome],
-			[agent, ""],
-			["", ""],
-		];
+		// The identity rows shed as one block, widest pair first: see `identity.ts`.
 		const lineWidth = (cell: string): number => pad.length + MARK_WIDTH + (cell ? 1 + visibleWidth(cell) : 0);
-		const [agentCell, chromeCell] = states.find(([a, c]) => Math.max(lineWidth(a), lineWidth(c)) <= w) ?? ["", ""];
+		const [agentCell, chromeCell] = identityCells(
+			{
+				halfBlocks: view.halfBlocks,
+				showVersion: view.showVersion,
+				version: this.version,
+				piLatest: view.piLatest,
+				latest: view.latest,
+			},
+			theme,
+		).find(([a, c]) => Math.max(lineWidth(a), lineWidth(c)) <= w) ?? ["", ""];
 
 		// The header owns its leading blank: Pi mounts the built-in header inside
 		// `Spacer(1)`s, but the `quietStartup: true` branch that hands this header the

package/extensions/bytefly/header/identity.ts

@@ -0,0 +1,71 @@
+/**
+ * The header's two identity cells and the ladder that sheds them.
+ *
+ * The nameplate's first row names Pi and its version, the second the tagline,
+ * bytefly, and its version, and either row may end with the `↑<version>` marker
+ * of a newer published release. The cells shed as one block when the terminal
+ * narrows, so the order is data here rather than a state table inside `build()`:
+ * the widest pair first, then the chrome marker, the chrome version, the chrome
+ * line, and finally the agent's own marker with the agent row itself.
+ *
+ * Pure: the theme is passed in and every returned string is painted, so a caller
+ * only measures and mounts them.
+ */
+
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { paint } from "../../../lib/tui/tokens.ts";
+import { updateMarker } from "../update/format.ts";
+import { HEADER_CONFIG } from "./config.ts";
+
+/** What the cells are built from: the live view's switches and the known versions. */
+export interface IdentityInput {
+	/** Whether the terminal renders half blocks; the wordmark mark spells the app name. */
+	halfBlocks: boolean;
+	/** Print Pi's version on the agent line. */
+	showVersion: boolean;
+	/** Pi's running version. */
+	version: string;
+	/** Pi's newer published version, when one is known. */
+	piLatest?: string;
+	/** This package's newer published version, when one is known. */
+	latest?: string;
+}
+
+/** A marker cell suffix, or nothing when no newer version is known. */
+function markerSuffix(theme: Theme, version: string | undefined): string {
+	return version ? ` ${paint(theme, HEADER_CONFIG.updateRole, updateMarker(version))}` : "";
+}
+
+/**
+ * The identity pairs, widest first, with each pair that repeats its predecessor
+ * dropped so the ladder names a state only when it is actually narrower.
+ */
+export function identityCells(input: IdentityInput, theme: Theme): Array<readonly [string, string]> {
+	const { nameRole, chromeRole, detailRole, appName, chromeTagline, chromeName, chromeVersion } = HEADER_CONFIG;
+	const version = input.showVersion && input.version ? paint(theme, detailRole, `v${input.version}`) : "";
+	// The wordmark mark spells the app name, so the agent cell carries only the
+	// version there; the half-block mark does not, so the name stays beside it.
+	const agent = input.halfBlocks
+		? version
+			? `${theme.bold(paint(theme, nameRole, appName))} ${version}`
+			: theme.bold(paint(theme, nameRole, appName))
+		: version;
+	const chrome = `${paint(theme, detailRole, chromeTagline)} ${paint(theme, chromeRole, chromeName)}`;
+	const chromeWithVersion = chromeVersion ? `${chrome} ${paint(theme, detailRole, `v${chromeVersion}`)}` : chrome;
+	const chromeWithMarker = `${chromeWithVersion}${markerSuffix(theme, input.latest)}`;
+	const agentWithMarker = `${agent}${markerSuffix(theme, input.piLatest)}`;
+
+	const states: Array<readonly [string, string]> = [];
+	const shed = (agentCell: string, chromeCell: string): void => {
+		const last = states.at(-1);
+		if (last && last[0] === agentCell && last[1] === chromeCell) return;
+		states.push([agentCell, chromeCell]);
+	};
+	shed(agentWithMarker, chromeWithMarker);
+	shed(agentWithMarker, chromeWithVersion);
+	shed(agentWithMarker, chrome);
+	shed(agentWithMarker, "");
+	shed(agent, "");
+	shed("", "");
+	return states;
+}

package/extensions/bytefly/header/register.ts

@@ -32,10 +32,15 @@ export interface HeaderHandle {
 /**
  * Register the install/restore lifecycle for the custom header.
  *
- * `updates` is the store the update check writes, so the marker appears when a
- * newer version is known. A test that does not exercise the marker may omit it.
+ * `updates` is the store the package-update check writes and `piUpdates` the one
+ * Pi's own release notice writes, so either marker appears when a newer version
+ * is known. A test that does not exercise a marker may omit its store.
  */
-export function registerHeader(pi: ExtensionAPI, updates: UpdateSource = createUpdateState()): HeaderHandle {
+export function registerHeader(
+	pi: ExtensionAPI,
+	updates: UpdateSource = createUpdateState(),
+	piUpdates?: UpdateSource,
+): HeaderHandle {
 	// Half blocks misalign in Apple Terminal, so the mark falls back to a wordmark
 	// there, mirroring Pi's own built-in header.
 	const halfBlocks = !isAppleTerminalSession();
@@ -60,6 +65,7 @@ export function registerHeader(pi: ExtensionAPI, updates: UpdateSource = createU
 			halfBlocks,
 			pad,
 			latest: updates.latest(),
+			piLatest: piUpdates?.latest(),
 			rows,
 		});
 		ctx.ui.setHeader(createHeader(() => ctx.ui.theme, view));

package/extensions/bytefly/index.ts

@@ -10,9 +10,9 @@
  * probe runtime), `notify/` (OS notifications for unattended runs), and
  * `update/` (Pi's package list, the host suppression, and the header marker).
  *
- * The header, footer, turn rule, and working line are installed only in
- * interactive (`tui`) sessions, and are always on; the user-message marker,
- * notice, and tool blocks register at load and take effect wherever a
+ * The header, footer, turn rule, and working line are installed
+ * only in interactive (`tui`) sessions, and are always on; the user-message
+ * marker, notice, and tool blocks register at load and take effect wherever a
  * transcript renders. `pi config` turns bytefly's chrome off. The panel and doctor work
  * in every mode, and notify works wherever the environment can deliver it. The
  * footer is priced from DeepSeek's published rates by default and from
@@ -35,6 +35,7 @@ import { type NotifyDeps, registerNotify } from "./notify/register.ts";
 import { createPadStore } from "./pad.ts";
 import { type PanelCommandDeps, registerPanel } from "./panel/commands.ts";
 import { registerTurnSeparator } from "./separator/register.ts";
+import { registerPiRelease, type ReleaseDeps } from "./update/release.ts";
 import { registerUpdate, type UpdateDeps } from "./update/register.ts";
 import { createUpdateState } from "./update/state.ts";
 import { registerWorkingTimer } from "./working/register.ts";
@@ -49,6 +50,8 @@ export interface ByteflyDeps {
 	notify?: NotifyDeps;
 	/** Seams for the package-update surface. */
 	update?: UpdateDeps;
+	/** Seams for Pi's own release notice. */
+	release?: ReleaseDeps;
 }
 
 /** Register every bytefly surface; the factory only registers. */
@@ -56,9 +59,11 @@ export default function bytefly(pi: ExtensionAPI, deps: ByteflyDeps = {}): void
 	if (!isExtensionEnabled("bytefly")) return;
 
 	// One store per load: the update check writes this package's new version and
-	// the header reads it, so the marker and every re-install agree.
+	// the header reads it, so the marker and every re-install agree. Pi's own
+	// release notice writes the second store the same way.
 	const updates = createUpdateState();
-	const header = registerHeader(pi, updates);
+	const piUpdates = createUpdateState();
+	const header = registerHeader(pi, updates, piUpdates);
 	// Notify first, so the footer's budget guardrail can raise one OS notification
 	// through the same capability the triggers use instead of a second dispatch path.
 	const notifications = registerNotify(pi, deps.notify);
@@ -78,5 +83,8 @@ export default function bytefly(pi: ExtensionAPI, deps: ByteflyDeps = {}): void
 	// The returned handle is what `/bytefly update` re-runs, so the update surface is
 	// registered before the panel that offers the command.
 	const update = registerUpdate(pi, updates, { ...deps.update, onUpdate: () => header.refresh() });
+	// Pi's own release notice is the second source of a header marker, so it shares
+	// the one repaint hook rather than installing a header of its own.
+	registerPiRelease(pi, piUpdates, { ...deps.release, onUpdate: () => header.refresh() });
 	registerPanel(pi, { doctor, update, discover: deps.extensions?.discover });
 }

package/extensions/bytefly/message/format.ts

@@ -1,18 +1,17 @@
 /**
- * The user-message nameplate: a two-row heading, the `You` label over a rule
- * that spans the width, above the message.
+ * The message transformer: the user-message nameplate.
  *
- * Pi's user message component parses the transformed string as Markdown and
- * owns its colors, so shaping text is the only lever: the surface can add no
- * component and no color of its own. The nameplate is a level-2 heading, which
- * Pi renders bold in `mdHeading` and prints without its `#` prefix; the bytefly
- * themes point `mdHeading` at the accent, so the label and rule carry the accent
- * while the message itself stays in the default text color. Markdown cannot
- * express a two-line heading, and Pi puts a blank line after a heading block,
- * so the label is padded to the width and the rule is appended: the heading's
- * text wraps, putting the rule on its own row with no blank between. A blank
- * line separates the nameplate from the message, so the message's own Markdown
- * (a fence, a list, a second paragraph) parses exactly as it would without it.
+ * Pi's message components parse the transformed string as Markdown and own their
+ * colors, so shaping text is the only lever: this surface adds no component and
+ * no color of its own. The nameplate is a level-2 heading, which Pi renders
+ * bold in `mdHeading` and prints without its `#` prefix; the bytefly themes point
+ * `mdHeading` at the accent, so the label and rule carry the accent while the
+ * message itself stays in the default text color. Markdown cannot express a
+ * two-line heading, and Pi puts a blank line after a heading block, so the label
+ * is padded to the width and the rule is appended: the heading's text wraps,
+ * putting the rule on its own row with no blank between. A blank line separates
+ * the nameplate from the message, so the message's own Markdown (a fence, a list,
+ * a second paragraph) parses exactly as it would without it.
  */
 
 import type { MarkdownTransformContext } from "@earendil-works/pi-coding-agent";
@@ -40,3 +39,11 @@ export function styleUserMessage(markdown: string, context: MarkdownTransformCon
 	const head = nameplate(context.availableWidth);
 	return head ? `${head}\n\n${markdown}` : markdown;
 }
+
+/**
+ * Dispatch the single transformer Pi keeps per extension on the message type: a
+ * user message gains the nameplate, and every other message passes through.
+ */
+export function styleMessage(markdown: string, context: MarkdownTransformContext): string {
+	return context.messageType === "user" ? styleUserMessage(markdown, context) : markdown;
+}

package/extensions/bytefly/message/register.ts

@@ -1,15 +1,16 @@
 /**
- * Registers bytefly's user-message markdown transformer.
+ * Registers bytefly's single Markdown transformer.
  *
- * Registration happens at extension load, like the turn separator's entry
- * renderer: the transformer only matters where a transcript renders, and Pi
- * calls it for every message, so no session lifecycle is needed.
+ * Pi keeps one transformer per extension (`loader.js`), and the extension
+ * spends it on the user-message nameplate. A second
+ * `registerMarkdownTransformer` call would silently replace the first, so there
+ * is exactly one, here.
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { styleUserMessage } from "./format.ts";
+import { styleMessage } from "./format.ts";
 
-/** Register the transformer that marks each user message. */
+/** Register the transformer that marks user messages. */
 export function registerUserMessage(pi: ExtensionAPI): void {
-	pi.registerMarkdownTransformer((markdown, context) => styleUserMessage(markdown, context));
+	pi.registerMarkdownTransformer((markdown, context) => styleMessage(markdown, context));
 }

package/extensions/bytefly/notify/types.ts

@@ -21,7 +21,7 @@ export interface NotifyConfig {
 	needsInput: boolean;
 	/** Notify when a background `job` finishes. */
 	jobFinished: boolean;
-	/** Notify when a `watch` wake match fires while the agent is idle. */
+	/** Notify when a `watch` wake match fires, once the agent is idle. */
 	matchFound: boolean;
 	/** Delivery method; `auto` chooses by terminal and platform. */
 	method: NotifyMethod;