@gavin-hu/my-pi-agent 0.11.3 → 0.12.0

package/extensions/bytefly/doctor/runtime.ts

@@ -19,11 +19,25 @@ import {
 	type ExtensionReport,
 	type ProbeSeams,
 } from "../../../lib/requirements.ts";
+import { loadNotifyConfig } from "../notify/config.ts";
 import { DEFAULT_CONFIG, type DoctorConfig } from "./config.ts";
 
 /** Seams a test may replace; everything else is built from the host. */
 export type DoctorSeamOverrides = Partial<ProbeSeams>;
 
+/**
+ * The notify capability's configured delivery, read fresh from the document.
+ *
+ * Reading at probe time rather than from the session's snapshot means a
+ * corrected method shows up on the next `r` instead of only after a reload.
+ */
+export function notifySeam(cwd: string): () => { enabled: boolean; method: string } {
+	return () => {
+		const notify = loadNotifyConfig(cwd);
+		return { enabled: notify.enabled, method: notify.method };
+	};
+}
+
 export interface DoctorRuntime {
 	/** Point the runtime at a session: its cwd and effective config. */
 	configure(options: { cwd: string; config: DoctorConfig }): void;
@@ -56,6 +70,8 @@ export function createDoctorRuntime(
 		dirs: { agentDir: getAgentDir(), cwd, configDirName: CONFIG_DIR_NAME },
 		platform: process.platform,
 		isEnabled: (extension) => isExtensionEnabled(extension) && !config.skip.includes(extension),
+		notify: notifySeam(cwd),
+		isTTY: process.stdout.isTTY === true,
 		...deps.seams,
 	});
 

package/extensions/bytefly/doctor/tools.ts

@@ -57,9 +57,7 @@ export function registerTools(pi: ExtensionAPI, runtime: DoctorRuntime): void {
 		],
 		parameters: DoctorParams,
 		outputSchema: DoctorOutput,
-		exposure: "direct",
-		defaultActive: true,
-		annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
+		annotations: { readOnlyHint: true, openWorldHint: false },
 
 		async execute(_toolCallId, params, _signal, onUpdate, _ctx) {
 			const args = params as DoctorArgs;

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

@@ -9,13 +9,14 @@
  *
  * The built-in table is DeepSeek's published yuan pricing, with the peak
  * schedule that doubles the price during peak hours. It is the default value of
- * `rates`, so nothing here is provider-specific: another provider's currency
- * and tariff are stated in `bytefly.json`.
+ * `rates`: `currency.code` chooses which table that is, and the peak schedule
+ * applies to both. Only an unmatched model differs — `CNY` contributes no cost
+ * for it, while `USD` adds Pi's recorded dollars.
  */
 
 import { asRecord, clampInteger, clampNumber, cleanString, loadConfigSection } from "../../../../lib/config.ts";
 import { parseWindow } from "./schedule.ts";
-import type { ByteflyConfig, Currency, ModelRates, PeakSchedule, PeakWindow } from "./types.ts";
+import type { ByteflyConfig, Currency, CurrencyCode, ModelRates, PeakSchedule, PeakWindow } from "./types.ts";
 
 /** Monday to Friday, the days DeepSeek charges its peak rate. */
 const WEEKDAYS: readonly number[] = [1, 2, 3, 4, 5];
@@ -26,8 +27,8 @@ const WEEKDAYS: readonly number[] = [1, 2, 3, 4, 5];
  * Pi's catalog prices every call in dollars at one flat rate, which is wrong
  * twice over for DeepSeek: the bill is in yuan, and peak hours cost double.
  * These are the published peak figures; `DEFAULT_PEAK` supplies the tariff. A
- * `bytefly.json` entry with the same key replaces one of these, and every
- * other provider still falls back to Pi's recorded cost.
+ * `bytefly.json` entry with the same key replaces one of these. A model with no
+ * matching entry contributes no cost; USD mode uses Pi's recorded cost instead.
  *
  * Source: <https://api-docs.deepseek.com/quick_start/pricing>.
  */
@@ -36,6 +37,24 @@ export const DEFAULT_RATES: Readonly<Record<string, ModelRates>> = {
 	"deepseek/deepseek-v4-pro": { input: 9, output: 27, cacheRead: 0.3, cacheWrite: 0, offPeakMultiplier: 0.5 },
 };
 
+/**
+ * The same two models in DeepSeek's published dollars, per million tokens at the
+ * peak rate; `offPeakMultiplier` halves them off-peak. The published table has no
+ * cache-write line, so `cacheWrite` is 0 here exactly as in the yuan table.
+ *
+ * Source: <https://api-docs.deepseek.com/quick_start/pricing> (USD table).
+ */
+export const DEFAULT_RATES_USD: Readonly<Record<string, ModelRates>> = {
+	"deepseek/deepseek-flash": { input: 0.3, output: 1.2, cacheRead: 0.006, cacheWrite: 0, offPeakMultiplier: 0.5 },
+	"deepseek/deepseek-v4-pro": { input: 1.32, output: 3.96, cacheRead: 0.044, cacheWrite: 0, offPeakMultiplier: 0.5 },
+};
+
+/** The built-in table for each currency: `rates` are stated in the selected one. */
+export const DEFAULT_RATES_BY_CURRENCY: Readonly<Record<CurrencyCode, Readonly<Record<string, ModelRates>>>> = {
+	CNY: DEFAULT_RATES,
+	USD: DEFAULT_RATES_USD,
+};
+
 /**
  * DeepSeek's peak hours, in the zone the provider states them in: 01:00-04:00
  * and 06:00-10:00 UTC on weekdays, which is 09:00-12:00 and 14:00-18:00 in
@@ -51,17 +70,24 @@ export const DEFAULT_PEAK: PeakSchedule = {
 	],
 };
 
-/** Rendered-currency default: yuan, the currency `DEFAULT_RATES` is stated in. */
-export const DEFAULT_CURRENCY: Currency = { symbol: "¥", decimals: 2 };
+/** The symbol each algorithm prints. It is not configurable, so it can never disagree with the code. */
+export const CURRENCY_SYMBOLS: Readonly<Record<CurrencyCode, string>> = { CNY: "¥", USD: "$" };
+
+/** The default precision each algorithm supplies when a config sets only its code. */
+export const CURRENCY_DEFAULTS: Readonly<Record<CurrencyCode, Currency>> = {
+	CNY: { code: "CNY", decimals: 2 },
+	USD: { code: "USD", decimals: 3 },
+};
+
+/** Yuan, the currency `DEFAULT_RATES` is stated in. */
+export const DEFAULT_CURRENCY: Currency = CURRENCY_DEFAULTS.CNY;
 
 export const DEFAULT_BYTEFLY_CONFIG: ByteflyConfig = {
 	currency: DEFAULT_CURRENCY,
-	fallbackToRecordedCost: true,
 	rates: DEFAULT_RATES,
 	peak: DEFAULT_PEAK,
 };
 
-const MAX_SYMBOL_LENGTH = 4;
 const MAX_DECIMALS = 4;
 const MAX_RATE = 1_000_000;
 const MAX_RATE_KEYS = 200;
@@ -77,12 +103,22 @@ function acceptsTimeZone(timezone: string): boolean {
 	}
 }
 
+/** A supported ISO code, or the base code for a missing/mistyped value. */
+function currencyCode(raw: unknown, base: CurrencyCode): CurrencyCode {
+	const text = typeof raw === "string" ? raw.trim().toUpperCase() : "";
+	return text === "CNY" || text === "USD" ? text : base;
+}
+
 function currencyValue(raw: unknown, base: Currency): Currency {
 	const value = asRecord(raw);
 	if (!value) return base;
+	const code = currencyCode(value.code, base.code);
+	// A changed code supplies its own default precision unless this layer
+	// overrides it; an unchanged code keeps the precision customized above it.
+	const display = code !== base.code ? CURRENCY_DEFAULTS[code] : base;
 	return {
-		symbol: cleanString(value.symbol, base.symbol).slice(0, MAX_SYMBOL_LENGTH),
-		decimals: clampInteger(value.decimals, base.decimals, 0, MAX_DECIMALS),
+		code,
+		decimals: clampInteger(value.decimals, display.decimals, 0, MAX_DECIMALS),
 	};
 }
 
@@ -137,11 +173,14 @@ function peakValue(raw: unknown, base: PeakSchedule): PeakSchedule {
 /** Validate a raw config object over `base`. Total: never throws, never guesses. */
 export function normalizeByteflyConfig(raw: Record<string, unknown> | undefined, base: ByteflyConfig): ByteflyConfig {
 	if (!raw) return base;
+	const currency = currencyValue(raw.currency, base.currency);
+	// `rates` are stated in the selected currency, so a layer that switches the
+	// code starts from that currency's table instead of reinterpreting the old
+	// numbers in the new unit. A layer that sets both merges onto the new table.
+	const rateBase = currency.code === base.currency.code ? base.rates : DEFAULT_RATES_BY_CURRENCY[currency.code];
 	return {
-		currency: currencyValue(raw.currency, base.currency),
-		fallbackToRecordedCost:
-			typeof raw.fallbackToRecordedCost === "boolean" ? raw.fallbackToRecordedCost : base.fallbackToRecordedCost,
-		rates: ratesValue(raw.rates, base.rates),
+		currency,
+		rates: ratesValue(raw.rates, rateBase),
 		peak: peakValue(raw.peak, base.peak),
 	};
 }

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

@@ -2,8 +2,10 @@
  * 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. A record with no matching rate
- * keeps Pi's recorded cost (in USD) unless the config turns that fallback off.
+ * 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.
  */
 
 import { emptyUsage } from "../collect/entries.ts";
@@ -32,6 +34,9 @@ function tokenCost(record: UsageRecord, rates: ModelRates): number {
  * its price always describe the same set of records.
  */
 export function createPricer(config: ByteflyConfig): (records: readonly UsageRecord[]) => UsageTotals {
+	// 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";
 	// Building a formatter is the expensive part, and only a schedule needs one.
 	const format = config.peak.windows.length > 0 ? peakFormatter(config.peak.timezone) : null;
 
@@ -42,16 +47,24 @@ export function createPricer(config: ByteflyConfig): (records: readonly UsageRec
 			totals.output += record.output;
 			totals.cacheRead += record.cacheRead;
 			totals.cacheWrite += record.cacheWrite;
-			totals.cost += recordCost(config, format, record);
+			const rates = findRates(config.rates, record.provider, record.model);
+			if (rates !== undefined) {
+				totals.cost += ratedCost(config, format, record, rates);
+				continue;
+			}
+			if (dollars) totals.cost += record.recordedCost;
 		}
 		return totals;
 	};
 }
 
-/** One record's cost: the configured rate, or Pi's recorded value. */
-function recordCost(config: ByteflyConfig, format: Intl.DateTimeFormat | null, record: UsageRecord): number {
-	const rates = findRates(config.rates, record.provider, record.model);
-	if (rates === undefined) return config.fallbackToRecordedCost ? record.recordedCost : 0;
+/** One record's cost at its matched rates, after the peak schedule. */
+function ratedCost(
+	config: ByteflyConfig,
+	format: Intl.DateTimeFormat | null,
+	record: UsageRecord,
+	rates: ModelRates,
+): number {
 	const cost = tokenCost(record, rates);
 	// An undated record is never discounted: we cannot tell which tariff applied.
 	if (format === null || record.at === null) return cost;

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

@@ -6,15 +6,23 @@
  * `../types.ts`.
  */
 
-/** How a cost is rendered. */
+/** The two pricing algorithms, named by the currency they total. */
+export type CurrencyCode = "CNY" | "USD";
+
+/** How a cost is calculated and rendered. */
 export interface Currency {
-	/** Printed before the number, e.g. `$` or `¥`. */
-	symbol: string;
-	/** Digits after the decimal point. */
+	/**
+	 * Which table `rates` starts from, and what an unmatched model contributes:
+	 * both currencies price a matched record from `rates` and the peak schedule,
+	 * while `CNY` gives an unmatched model no cost and `USD` adds Pi's recorded
+	 * dollars for it.
+	 */
+	code: CurrencyCode;
+	/** Digits after the decimal point. The symbol follows from `code`. */
 	decimals: number;
 }
 
-/** Per-million-token rates for one model, expressed in the configured currency. */
+/** Per-million-token rates for one model, in yuan; used by the CNY algorithm. */
 export interface ModelRates {
 	input: number;
 	output: number;
@@ -45,8 +53,6 @@ export interface PeakSchedule {
 /** Everything the price calculation is configured with. */
 export interface ByteflyConfig {
 	currency: Currency;
-	/** Fall back to Pi's recorded cost for a record that no rate matches. */
-	fallbackToRecordedCost: boolean;
 	/** Rates keyed by `provider/model`, matched through wildcards. */
 	rates: Readonly<Record<string, ModelRates>>;
 	peak: PeakSchedule;

package/extensions/bytefly/footer/render/format.ts

@@ -11,7 +11,7 @@ import { shortenPath } from "../../../../lib/format.ts";
 import { gaugeRole } from "../../../../lib/tui/gauge.ts";
 import type { TuiRole } from "../../../../lib/tui/tokens.ts";
 import { CONFIG } from "../config.ts";
-import { DEFAULT_CURRENCY } from "../price/config.ts";
+import { CURRENCY_SYMBOLS, DEFAULT_CURRENCY } from "../price/config.ts";
 import type { Currency } from "../price/types.ts";
 
 /** Theme tokens for the reasoning-effort indicator. */
@@ -31,7 +31,8 @@ export type ThinkingColor =
  * `¥<0.01` — so a small cost is never reported as free.
  */
 export function formatCost(cost: number, currency: Currency = DEFAULT_CURRENCY): string {
-	const { symbol, decimals } = currency;
+	const { decimals } = currency;
+	const symbol = CURRENCY_SYMBOLS[currency.code];
 	if (!Number.isFinite(cost) || cost <= 0) return `${symbol}${(0).toFixed(decimals)}`;
 	const minimum = 10 ** -decimals;
 	if (cost < minimum) return `${symbol}<${minimum.toFixed(decimals)}`;

package/extensions/bytefly/footer/render/segments.ts

@@ -171,13 +171,14 @@ export function windowSegment(snapshot: StatusSnapshot, theme: Theme): Segment |
 }
 
 export function costSegment(snapshot: StatusSnapshot, theme: Theme): Segment | null {
-	if (snapshot.usage.cost === 0) return null;
+	const { cost } = snapshot.usage;
+	if (cost === 0) return null;
 	return {
 		id: "cost",
 		weight: 2,
 		droppable: true,
 		separator: faint(theme, CONFIG.separators.item),
-		forms: [paint(theme, "meta", formatCost(snapshot.usage.cost, snapshot.currency))],
+		forms: [paint(theme, "meta", formatCost(cost, snapshot.currency))],
 	};
 }
 

package/extensions/bytefly/footer/types.ts

@@ -32,6 +32,7 @@ export interface UsageTotals {
 	output: number;
 	cacheRead: number;
 	cacheWrite: number;
+	/** Cost in the configured currency: rated in CNY mode, Pi's recorded amount in USD mode. */
 	cost: number;
 }
 

package/extensions/bytefly/header/component.ts

@@ -17,6 +17,7 @@ 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 HelpEntry } from "./config.ts";
 
 /** The header's shape, resolved once per apply so `render` stays cheap. */
@@ -27,6 +28,8 @@ export interface HeaderView {
 	halfBlocks: boolean;
 	/** Columns of left margin: Pi's output pad, so the nameplate sits on the transcript margin. */
 	pad: number;
+	/** A newer published version of this package, when one is known. */
+	latest?: string;
 }
 
 /** The mark block is four columns on both rows, so the identity column aligns. */
@@ -78,7 +81,7 @@ export class ByteflyHeader implements Component {
 		const w = Math.max(1, width);
 		const theme = this.getTheme();
 		const view = this.view();
-		const viewKey = `${view.showVersion}:${view.halfBlocks}:${view.pad}`;
+		const viewKey = `${view.showVersion}:${view.halfBlocks}:${view.pad}:${view.latest ?? ""}`;
 		const keys = this.keySignature();
 		if (
 			this.cachedWidth === w &&
@@ -106,7 +109,8 @@ export class ByteflyHeader implements Component {
 	}
 
 	private build(w: number, theme: Theme, view: HeaderView): string[] {
-		const { nameRole, chromeRole, detailRole, chromeTagline, chromeName, chromeVersion, help } = HEADER_CONFIG;
+		const { nameRole, chromeRole, detailRole, updateRole, chromeTagline, chromeName, chromeVersion, help } =
+			HEADER_CONFIG;
 		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);
@@ -120,11 +124,18 @@ export class ByteflyHeader implements Component {
 				: theme.bold(paint(theme, nameRole, HEADER_CONFIG.appName))
 			: version;
 		const chrome = `${paint(theme, detailRole, chromeTagline)} ${paint(theme, chromeRole, chromeName)}`;
-		const chromeVersioned = chromeVersion ? `${chrome} ${paint(theme, detailRole, `v${chromeVersion}`)}` : chrome;
-
-		// The identity rows shed as one block: chrome version, chrome line, agent.
+		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, chromeVersioned],
+			[agent, chromeWithMarker],
+			[agent, chromeWithVersion],
 			[agent, chrome],
 			[agent, ""],
 			["", ""],
@@ -132,7 +143,11 @@ export class ByteflyHeader implements Component {
 		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) ?? ["", ""];
 
+		// 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
+		// screen adds none, and `setHeader` swaps only the header child.
 		return [
+			"",
 			this.identityLine(pad, markTop, agentCell, w),
 			this.identityLine(pad, markBottom, chromeCell, w),
 			this.rule(theme, w, pad),

package/extensions/bytefly/header/config.ts

@@ -35,6 +35,8 @@ export interface HeaderConfig {
 	readonly chromeRole: TuiRole;
 	/** Role for the versions, the tagline, and the help descriptions. */
 	readonly detailRole: TuiRole;
+	/** Role for the update marker: an action, so the accent rather than a warning colour. */
+	readonly updateRole: TuiRole;
 	/** Role for the rule's accent lead under the mark. */
 	readonly ruleAccentRole: TuiRole;
 	/** Role for the rest of the rule. */
@@ -57,6 +59,7 @@ export const HEADER_CONFIG: HeaderConfig = {
 	nameRole: "label",
 	chromeRole: "meta",
 	detailRole: "faint",
+	updateRole: "accent",
 	ruleAccentRole: "accent",
 	ruleRole: "rule",
 	chromeTagline: "enhanced by",

package/extensions/bytefly/header/register.ts

@@ -9,21 +9,40 @@
  * `pi config` remains the way to turn all of bytefly's chrome off. The header
  * is installed only in interactive (`tui`) sessions; every other mode leaves
  * Pi's built-in header in place, which does not exist there.
+ *
+ * The update check resolves after this install, so the header reads the newest
+ * known version through `UpdateSource` and `refresh()` re-applies the last
+ * context's header once one arrives. That is the only reason the header is ever
+ * installed twice.
  */
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { isAppleTerminalSession } from "@earendil-works/pi-tui";
 import { DEFAULT_HOST_PAD } from "../pad.ts";
+import { createUpdateState, type UpdateSource } from "../update/state.ts";
 import { createHeader, type HeaderView } from "./component.ts";
 import { HEADER_CONFIG } from "./config.ts";
 
-/** Register the install/restore lifecycle for the custom header. */
-export function registerHeader(pi: ExtensionAPI): void {
+/** The installed header, and the way to re-install it after a change. */
+export interface HeaderHandle {
+	/** Re-apply the last session's header, picking up the current update marker. */
+	refresh(): void;
+}
+
+/**
+ * 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.
+ */
+export function registerHeader(pi: ExtensionAPI, updates: UpdateSource = createUpdateState()): 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();
+	let last: ExtensionContext | undefined;
 
 	const apply = (ctx: ExtensionContext): void => {
+		last = ctx;
 		if (ctx.mode !== "tui") return;
 		// Bytefly's startup TUI is on only when Pi's `quietStartup` is true, which
 		// hides Pi's built-in startup header. Every other value (`false`,
@@ -36,14 +55,26 @@ export function registerHeader(pi: ExtensionAPI): void {
 		// value the tool frame and the notice inset by. An older host without
 		// `getSettings` keeps the default margin.
 		const pad = pi.getSettings?.().outputPad ?? DEFAULT_HOST_PAD;
-		const view = (): HeaderView => ({ showVersion: HEADER_CONFIG.showVersion, halfBlocks, pad });
+		const view = (): HeaderView => ({
+			showVersion: HEADER_CONFIG.showVersion,
+			halfBlocks,
+			pad,
+			latest: updates.latest(),
+		});
 		ctx.ui.setHeader(createHeader(() => ctx.ui.theme, view));
 	};
 
 	pi.on("session_start", (_event, ctx) => apply(ctx));
 	pi.on("session_tree", (_event, ctx) => apply(ctx));
 	pi.on("session_shutdown", (_event, ctx) => {
+		last = undefined;
 		if (ctx.mode !== "tui") return;
 		ctx.ui.setHeader(undefined);
 	});
+
+	return {
+		refresh() {
+			if (last) apply(last);
+		},
+	};
 }

package/extensions/bytefly/index.ts

@@ -1,5 +1,5 @@
 /**
- * bytefly — the package's terminal chrome and diagnostics, composed from ten
+ * bytefly — the package's terminal chrome and diagnostics, composed from eleven
  * feature folders: `header/` (the themed startup mark and version), `footer/`
  * (the two-line, width-adaptive status bar with its price calculation),
  * `message/` (the user-message nameplate), `notice/` (the shared transcript
@@ -7,7 +7,8 @@
  * transcript turn rule), `working/` (the live elapsed counter on Pi's working
  * row), `panel/` (the unified `/bytefly` screen and its
  * `doctor` report), `doctor/` (the `run_doctor` tool and its session-scoped
- * probe runtime), and `notify/` (OS notifications for unattended runs).
+ * probe runtime), `notify/` (OS notifications for unattended runs), and
+ * `update/` (the published-version check behind the header's update marker).
  *
  * The header, footer, turn rule, and working timer are installed only in
  * interactive (`tui`) sessions, and are always on; the user-message marker,
@@ -34,6 +35,8 @@ 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 { registerUpdate, type UpdateDeps } from "./update/register.ts";
+import { createUpdateState } from "./update/state.ts";
 import { registerWorkingTimer } from "./working/register.ts";
 
 /** Host seams, injected by tests. */
@@ -44,13 +47,18 @@ export interface ByteflyDeps {
 	doctor?: DoctorDeps;
 	/** Seams for the notify capability. */
 	notify?: NotifyDeps;
+	/** Seams for the published-version check. */
+	update?: UpdateDeps;
 }
 
 /** Register every bytefly surface; the factory only registers. */
 export default function bytefly(pi: ExtensionAPI, deps: ByteflyDeps = {}): void {
 	if (!isExtensionEnabled("bytefly")) return;
 
-	registerHeader(pi);
+	// One store per load: the update check writes the newest published version and
+	// the header reads it, so the marker and every re-install agree.
+	const updates = createUpdateState();
+	const header = registerHeader(pi, updates);
 	registerFooter(pi);
 	registerUserMessage(pi);
 	// One store per load: the tool frame and the notice record Pi's output pad and
@@ -66,4 +74,6 @@ export default function bytefly(pi: ExtensionAPI, deps: ByteflyDeps = {}): void
 	const doctor = registerDoctor(pi, deps.doctor);
 	registerPanel(pi, { doctor, discover: deps.extensions?.discover });
 	registerNotify(pi, deps.notify);
+	// Last, so a version that arrives after startup can re-install the header.
+	registerUpdate(pi, updates, { ...deps.update, onUpdate: () => header.refresh() });
 }