@gavin-hu/my-pi-agent 0.14.0 → 0.15.0

package/extensions/bytefly/update/cache.ts

@@ -1,34 +1,42 @@
 /**
- * The published-version answer, cached on disk with the time it was read.
+ * The package-update snapshot, cached on disk with the time it was read.
  *
- * The check already fires once per session, which leaves two gaps: a session open
- * for days never re-reads npm, and every new session pays for a request it made
- * minutes earlier. A timestamp is what fixes the second, so the cache lives in the
- * agent directory rather than in memory — one entry, one window, shared by every
- * session that starts inside it.
+ * The 24-hour window is what makes a long-lived session different from a fresh
+ * one: a session that starts inside the window reuses the last read instead of
+ * repeating Pi's npm/git checks, and `/bytefly update` re-runs them on demand.
+ * The entry is keyed by the working directory and the effective package sources,
+ * so a project switch or an install/removal invalidates it instead of showing
+ * another project's list.
  *
- * A cache can only ever be a miss. An absent, unreadable, or wrong-typed file
- * reads as `undefined` and the caller fetches; nothing here throws, because a
- * stale file must never become a session error.
+ * A cache can only ever be a miss. An absent, unreadable, old-schema, or
+ * mistyped file reads as `undefined` and the caller fetches; nothing here
+ * throws, because a stale file must never become a session error.
  */
 
+import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
+import type { PackageSource } from "@earendil-works/pi-coding-agent";
 import { writeConfigFile } from "../../../lib/config.ts";
+import type { PackageUpdate } from "./types.ts";
 import { parseVersion } from "./version.ts";
 
 /** The file name under `<agentDir>/bytefly/`. */
 export const UPDATE_CACHE_FILE = "update.json";
 
-/** How long a cached answer is reused before the next session re-reads npm. */
+/** How long a cached snapshot is reused before the next session re-reads. */
 export const UPDATE_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
 
-/** One cached answer: the newest published version and when it was read. */
+/** One cached snapshot: Pi's list, this package's version, and when it was read. */
 export interface UpdateCacheEntry {
-	/** The version npm's `latest` tag pointed at. */
-	latest: string;
-	/** Epoch milliseconds of the read that produced `latest`. */
+	/** Identity of the cwd plus the effective package sources. */
+	key: string;
+	/** Epoch milliseconds of the read that produced this snapshot. */
 	checkedAt: number;
+	/** Every package Pi reported as updateable. */
+	updates: PackageUpdate[];
+	/** This package's new version, when it is one of the updates. */
+	latest?: string;
 }
 
 /** Where the cache lives for an agent directory. */
@@ -36,15 +44,41 @@ export function updateCachePath(agentDir: string): string {
 	return join(agentDir, "bytefly", UPDATE_CACHE_FILE);
 }
 
-/** Read the cache; a missing, corrupt, or mistyped entry is `undefined`. */
+/** Stable identity for the settings a snapshot was read under. */
+export function updateCacheKey(cwd: string, packages: readonly PackageSource[] | undefined): string {
+	return createHash("sha256")
+		.update(JSON.stringify({ cwd, packages: packages ?? [] }))
+		.digest("hex");
+}
+
+/** Whether a value has the fields Pi's package update carries. */
+function isPackageUpdate(value: unknown): value is PackageUpdate {
+	if (!value || typeof value !== "object") return false;
+	const update = value as Partial<PackageUpdate>;
+	return (
+		typeof update.source === "string" &&
+		typeof update.displayName === "string" &&
+		(update.type === "npm" || update.type === "git") &&
+		(update.scope === "user" || update.scope === "project")
+	);
+}
+
+/** Read the cache; a missing, corrupt, old-schema, or mistyped entry is `undefined`. */
 export function readUpdateCache(path: string): UpdateCacheEntry | undefined {
 	try {
 		const raw = JSON.parse(readFileSync(path, "utf-8")) as Record<string, unknown> | undefined;
 		if (!raw || typeof raw !== "object") return undefined;
-		const latest = typeof raw.latest === "string" ? raw.latest.trim() : "";
+		const key = typeof raw.key === "string" ? raw.key.trim() : "";
 		const checkedAt = typeof raw.checkedAt === "number" && Number.isFinite(raw.checkedAt) ? raw.checkedAt : 0;
-		if (!parseVersion(latest) || checkedAt <= 0) return undefined;
-		return { latest, checkedAt };
+		const updates = Array.isArray(raw.updates) ? raw.updates : undefined;
+		if (!key || checkedAt <= 0 || !updates || !updates.every(isPackageUpdate)) return undefined;
+		const latest = typeof raw.latest === "string" ? raw.latest.trim() : "";
+		return {
+			key,
+			checkedAt,
+			updates,
+			...(parseVersion(latest) ? { latest } : {}),
+		};
 	} catch {
 		return undefined;
 	}
@@ -55,7 +89,12 @@ export function readUpdateCache(path: string): UpdateCacheEntry | undefined {
  * treats a throw as a miss: a read-only agent directory must not break a session.
  */
 export function writeUpdateCache(path: string, entry: UpdateCacheEntry): void {
-	writeConfigFile(path, { latest: entry.latest, checkedAt: entry.checkedAt });
+	writeConfigFile(path, {
+		key: entry.key,
+		checkedAt: entry.checkedAt,
+		updates: entry.updates,
+		...(entry.latest ? { latest: entry.latest } : {}),
+	});
 }
 
 /**

package/extensions/bytefly/update/check.ts

@@ -10,6 +10,8 @@
  * never sees an error from a check nobody asked for.
  */
 
+import { DefaultPackageManager, getAgentDir, SettingsManager } from "@earendil-works/pi-coding-agent";
+import type { PackageUpdate, PackageUpdateCheck } from "./types.ts";
 import { parseVersion } from "./version.ts";
 
 /** The published document holding the version npm's `latest` tag points at. */
@@ -37,6 +39,39 @@ export interface UpdateCheckDeps {
 	timeoutMs?: number;
 }
 
+/** What the package-manager read needs. */
+export interface AvailableUpdatesDeps {
+	/** Session working directory. */
+	cwd: string;
+	/** Pi agent directory; defaults to `getAgentDir()`. */
+	agentDir?: string;
+	/** Whether project-local packages may be read. */
+	projectTrusted: boolean;
+	/** The real check captured before suppression; defaults to the manager method. */
+	checkForAvailableUpdates?: PackageUpdateCheck;
+}
+
+/**
+ * Every package Pi would update, or `undefined` when the check cannot run.
+ *
+ * The distinction is load-bearing: an empty list is a real answer ("everything is
+ * current") that the caller caches for a day, while a failed read must leave the
+ * previous snapshot and the header marker alone.
+ */
+export async function fetchAvailableUpdates(deps: AvailableUpdatesDeps): Promise<PackageUpdate[] | undefined> {
+	try {
+		const agentDir = deps.agentDir ?? getAgentDir();
+		const settingsManager = SettingsManager.create(deps.cwd, agentDir, {
+			projectTrusted: deps.projectTrusted,
+		});
+		const manager = new DefaultPackageManager({ cwd: deps.cwd, agentDir, settingsManager });
+		const check = deps.checkForAvailableUpdates ?? ((current) => current.checkForAvailableUpdates());
+		return await check(manager);
+	} catch {
+		return undefined;
+	}
+}
+
 /** The latest published version, or `undefined` when it cannot be read. */
 export async function fetchLatestVersion(deps: UpdateCheckDeps = {}): Promise<string | undefined> {
 	const request: FetchLike = deps.fetch ?? ((url, init) => globalThis.fetch(url, init));

package/extensions/bytefly/update/format.ts

@@ -1,25 +1,27 @@
 /**
- * Wording for the update check: the header marker, the one transcript notice, and
- * the answer an explicit re-check prints.
+ * Wording for the update surface: the header marker, the one transcript notice,
+ * and the answer an explicit re-check prints.
  *
- * All three read the same two facts — the version this session loaded and the
- * version the registry publishes — and none adds a third. The marker is the
- * shortest honest form (`↑0.12.0`); the notice names the command and the release
- * URL as text, because the notice renderer has no link support; and the re-check
- * says what it just found, including the two cases it cannot answer (offline, and
- * a registry it could not read).
+ * Pi's package manager decides which configured packages are behind. The marker
+ * is still only this package's newest version (`↑0.12.0`); the notice names every
+ * package Pi reported and, for this package, the version arrow and release URL
+ * the notice renderer can print as text.
  */
 
 import pkg from "../../../package.json";
 import { noticeMessage, type NoticeMessage } from "../../../lib/notice.ts";
 import { GLYPHS } from "../../../lib/tui/glyphs.ts";
 import type { UpdateOutcome } from "./state.ts";
+import type { PackageUpdate } from "./types.ts";
 
-/** The header marker: an up arrow and the newest version, e.g. `↑0.12.0`. */
+/** The header marker: an up arrow and this package's newest version. */
 export function updateMarker(latest: string): string {
 	return `${GLYPHS.update}${latest}`;
 }
 
+/** The command that resolves every row in the notice. */
+export const UPDATE_COMMAND = "pi update --extensions";
+
 /**
  * The release page for a version, or `undefined` when this checkout does not name
  * a GitHub repository. Derived from `package.json` so a rename cannot leave a dead
@@ -32,35 +34,72 @@ export function releaseUrl(version: string): string | undefined {
 	return `${base}/releases/tag/v${version}`;
 }
 
-/** The single notice a session posts when a newer version is published. */
-export function updateNotice(current: string, latest: string): NoticeMessage {
-	const release = releaseUrl(latest);
-	const command = "pi update --extensions";
+/** Whether a row is this package, whose version the header and notice show. */
+export function isOwnPackage(update: PackageUpdate): boolean {
+	return update.type === "npm" && update.displayName === pkg.name;
+}
+
+/** The scope word Pi's package update carries. */
+function scopeLabel(update: PackageUpdate): string {
+	return update.scope === "project" ? "project" : "global";
+}
+
+/** One package row: the version arrow for this package, the scope for the rest. */
+function packageRow(
+	update: PackageUpdate,
+	current: string,
+	ownLatest?: string,
+): {
+	label: string;
+	detail: string;
+	severity: "info";
+} {
+	const detail = isOwnPackage(update) && ownLatest ? `v${current} → v${ownLatest}` : scopeLabel(update);
+	return { label: update.displayName, detail, severity: "info" };
+}
+
+/** The headline shared by the notice and the re-check answer. */
+function headline(count: number): string {
+	return count === 1 ? "1 package update available" : `${count} package updates available`;
+}
+
+/** The headline and the package names, the sentence both answers open with. */
+function namesLine(updates: readonly PackageUpdate[]): string {
+	return `${headline(updates.length)}: ${updates.map((update) => update.displayName).join(", ")}.`;
+}
+
+/** The release URL for this package's new version, when it is known. */
+function ownRelease(ownLatest?: string): string | undefined {
+	return ownLatest ? releaseUrl(ownLatest) : undefined;
+}
+
+/** The single notice a session posts when Pi reports package updates. */
+export function updateNotice(updates: readonly PackageUpdate[], current: string, ownLatest?: string): NoticeMessage {
+	const own = updates.find(isOwnPackage);
+	const release = own ? ownRelease(ownLatest) : undefined;
+	const parts = [namesLine(updates)];
+	if (own && ownLatest) parts.push(`${pkg.name} v${current} → v${ownLatest}.`);
+	parts.push(`Run \`${UPDATE_COMMAND}\` to update.`);
+	if (release) parts.push(`Release notes: ${release}`);
 	return noticeMessage({
-		content:
-			`bytefly ${latest} is available (current ${current}). Run \`${command}\` to update.` +
-			(release ? ` Release notes: ${release}` : ""),
+		content: parts.join(" "),
 		details: {
 			source: "bytefly",
-			title: `${latest} is available`,
+			title: headline(updates.length),
 			severity: "info",
-			items: release
-				? [
-						{ label: "current", detail: `v${current}` },
-						{ label: "update", detail: command },
-						{ label: "release", detail: release },
-					]
-				: [
-						{ label: "current", detail: `v${current}` },
-						{ label: "update", detail: command },
-					],
+			items: [
+				...updates.map((update) => packageRow(update, current, ownLatest)),
+				{ label: "update", detail: UPDATE_COMMAND },
+				...(release ? [{ label: "release", detail: release }] : []),
+			],
 		},
 	});
 }
 
 /**
  * What `/bytefly update` prints. The background check is silent because nobody
- * asked; here someone did, so a skip and a failed read are answers too.
+ * asked; here someone did, so a skip, a failure, and an up-to-date answer are
+ * answers too.
  */
 export function updateOutcomeText(
 	outcome: UpdateOutcome,
@@ -71,17 +110,19 @@ export function updateOutcomeText(
 			return { text: "bytefly: the update check was skipped (PI_OFFLINE is set).", severity: "info" };
 		case "failed":
 			return {
-				text: "bytefly: could not read the published version — check the network and try again.",
+				text: "bytefly: could not check package updates — check the network and try again.",
 				severity: "warning",
 			};
 		case "current":
-			return { text: `bytefly: up to date — v${outcome.latest} is the newest published version.`, severity: "info" };
+			return { text: "bytefly: up to date — no configured package has an update.", severity: "info" };
 		case "available": {
-			const release = releaseUrl(outcome.latest);
-			return {
-				text: `bytefly: v${outcome.latest} is available (current ${current}).${release ? ` ${release}` : ""}`,
-				severity: "info",
-			};
+			const own = outcome.updates.some(isOwnPackage);
+			const release = own ? ownRelease(outcome.ownLatest) : undefined;
+			const parts = [`bytefly: ${namesLine(outcome.updates)}`];
+			if (own && outcome.ownLatest) parts.push(`This package is v${current} → v${outcome.ownLatest}.`);
+			parts.push(`Run ${UPDATE_COMMAND}.`);
+			if (release) parts.push(`Release notes: ${release}`);
+			return { text: parts.join(" "), severity: "info" };
 		}
 	}
 }

package/extensions/bytefly/update/register.ts

@@ -1,47 +1,57 @@
 /**
- * The update check's lifecycle: reuse the cached answer or read the registry once
- * per interactive session, record a newer version, and announce it once per load.
+ * The update surface's lifecycle: ask Pi's package manager which configured
+ * packages are behind, cache the snapshot, and announce it once per load.
  *
- * The request is fired without awaiting. Pi awaits `session_start` handlers, so
- * a slow registry would otherwise hold the first prompt; Pi's own version check
- * is asynchronous for the same reason. Every result that is not a strictly newer
- * version is silent, and a generation counter keeps a request that resolves
- * after shutdown from writing into the next session's state.
+ * Pi would draw its own `Package Updates Available` block from the same method
+ * after `session_start`. bytefly suppresses that block, asks the captured
+ * original check itself, and draws the single notice. The request is fired
+ * without awaiting: Pi awaits `session_start` handlers, and a slow npm/git check
+ * must not hold the first prompt.
  *
- * A cached answer with a timestamp is what makes a long-lived session different
- * from a fresh one: a session that starts inside the window reuses the last read
- * instead of repeating it, and `recheck()` ignores the window so `/bytefly update`
- * can look again without a restart. `/bytefly` and `doctor` do not report the
- * version: an available update is not a prerequisite problem.
+ * The 24-hour cache is keyed by the working directory and the effective package
+ * sources, so a project switch or an install/removal invalidates it. A cache hit
+ * costs no package-manager call; `/bytefly update` ignores the window and re-runs
+ * the check on demand.
  */
 
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import pkg from "../../../package.json";
 import { isOffline } from "../../../lib/env.ts";
-import { isFresh, readUpdateCache, updateCachePath, writeUpdateCache, type UpdateCacheEntry } from "./cache.ts";
-import { fetchLatestVersion } from "./check.ts";
-import { updateNotice } from "./format.ts";
+import {
+	isFresh,
+	readUpdateCache,
+	updateCacheKey,
+	updateCachePath,
+	writeUpdateCache,
+	type UpdateCacheEntry,
+} from "./cache.ts";
+import { fetchAvailableUpdates, fetchLatestVersion } from "./check.ts";
+import { isOwnPackage, updateNotice } from "./format.ts";
 import type { UpdateOutcome, UpdateSource } from "./state.ts";
+import { suppressPiPackageUpdates, type UpdateSuppression } from "./suppress.ts";
+import type { PackageUpdate, PackageUpdateCheck } from "./types.ts";
 import { isNewerVersion } from "./version.ts";
 
 /** The cache, as the lifecycle sees it: read on start, written after a read. */
 export interface UpdateCache {
-	/** The last recorded answer, or `undefined` for a miss. */
+	/** The last recorded snapshot, or `undefined` for a miss. */
 	read(): UpdateCacheEntry | undefined;
-	/** Record an answer; a throw is treated as a miss. */
+	/** Record a snapshot; a throw is treated as a miss. */
 	write(entry: UpdateCacheEntry): void;
 }
 
 /** What `registerUpdate` returns, so the panel can re-run the check on demand. */
 export interface UpdateHandle {
-	/** Read the registry now, ignoring the cache window. Never throws. */
+	/** Read the package list now, ignoring the cache window. Never throws. */
 	recheck(): Promise<UpdateOutcome>;
 }
 
-/** Test seams; production uses the registry read, `PI_OFFLINE`, and the agent dir. */
+/** Test seams; production uses Pi's package manager, its cache, and the agent dir. */
 export interface UpdateDeps {
-	/** Replace the registry read; a rejection counts as no answer. */
+	/** Replace the package-manager read. */
+	readUpdates?: (ctx: ExtensionContext, check: PackageUpdateCheck) => Promise<PackageUpdate[] | undefined>;
+	/** Replace the registry read that names this package's new version. */
 	fetchLatest?: () => Promise<string | undefined>;
 	/** Replace the `PI_OFFLINE` check. */
 	isOffline?: () => boolean;
@@ -49,7 +59,9 @@ export interface UpdateDeps {
 	cache?: UpdateCache;
 	/** Replace the clock the cache timestamp is read from. */
 	now?: () => number;
-	/** Called once a newer version is recorded, so a mounted surface repaints. */
+	/** Replace the host suppression; defaults to patching Pi's package manager. */
+	suppress?: () => UpdateSuppression;
+	/** Called once a snapshot is recorded, so a mounted surface repaints. */
 	onUpdate?: () => void;
 }
 
@@ -61,52 +73,112 @@ function diskCache(): UpdateCache {
 			try {
 				writeUpdateCache(updateCachePath(getAgentDir()), entry);
 			} catch {
-				// A read-only agent directory costs the next session one request, nothing more.
+				// A read-only agent directory costs the next session one check, nothing more.
 			}
 		},
 	};
 }
 
 /**
- * Register the check. `updates` is the same store the header reads, so recording
- * a version and calling `onUpdate` is what puts the marker on screen.
+ * Register the update lifecycle. `updates` is the store the header reads, so
+ * recording a snapshot is what puts this package's marker on screen.
  */
 export function registerUpdate(pi: ExtensionAPI, updates: UpdateSource, deps: UpdateDeps = {}): UpdateHandle {
+	const readUpdates =
+		deps.readUpdates ??
+		((ctx, check) =>
+			fetchAvailableUpdates({
+				cwd: ctx.cwd,
+				agentDir: getAgentDir(),
+				projectTrusted: ctx.isProjectTrusted(),
+				checkForAvailableUpdates: check,
+			}));
 	const readLatest = deps.fetchLatest ?? (() => fetchLatestVersion());
 	const offline = deps.isOffline ?? isOffline;
 	const cache = deps.cache ?? diskCache();
 	const now = deps.now ?? Date.now;
+	const suppress = deps.suppress ?? suppressPiPackageUpdates;
 	// A session is announced at most once per load, even if `session_start` fires
 	// again after a resume or a session replacement.
 	let announced = false;
 	let generation = 0;
+	let suppression: UpdateSuppression | undefined;
+	let context: ExtensionContext | undefined;
+	const fallbackCheck: PackageUpdateCheck = (manager) => manager.checkForAvailableUpdates();
+	const activeCheck = (): PackageUpdateCheck => suppression?.check ?? fallbackCheck;
 
-	/** Record a newer version and repaint the marker. */
-	const paint = (latest: string): void => {
-		if (!isNewerVersion(latest, pkg.version)) return;
+	/** Identity of the settings a snapshot is read under. */
+	const keyFor = (ctx: ExtensionContext): string => updateCacheKey(ctx.cwd, pi.getSettings?.()?.packages);
+
+	/** A cache write never turns a read into a failed check. */
+	const writeCache = (entry: UpdateCacheEntry): void => {
+		try {
+			cache.write(entry);
+		} catch {
+			// The next session performs one more check; this one already has its answer.
+		}
+	};
+
+	/** This package's new version in a snapshot, when it is actually newer. */
+	const ownLatestOf = (entry: UpdateCacheEntry): string | undefined => {
+		if (!entry.latest || !isNewerVersion(entry.latest, pkg.version)) return undefined;
+		return entry.updates.some(isOwnPackage) ? entry.latest : undefined;
+	};
+
+	/** Paint the header marker, or clear it when this package is current. */
+	const paint = (latest?: string): void => {
+		if (updates.latest() === latest) return;
 		updates.set(latest);
 		deps.onUpdate?.();
 	};
 
-	/** The once-per-load transcript notice, posted only for a strictly newer version. */
-	const announce = (latest: string): void => {
-		if (announced || !isNewerVersion(latest, pkg.version)) return;
+	/** The once-per-load transcript notice, posted only for a non-empty list. */
+	const announce = (entry: UpdateCacheEntry): void => {
+		if (announced || entry.updates.length === 0) return;
 		announced = true;
-		pi.sendMessage(updateNotice(pkg.version, latest));
+		pi.sendMessage(updateNotice(entry.updates, pkg.version, ownLatestOf(entry)));
 	};
 
-	/** One answer, from the cache or the registry: paint the marker, announce it once. */
+	/** One snapshot: paint the marker and, when it has rows, announce it once. */
 	const record = (entry: UpdateCacheEntry): void => {
-		paint(entry.latest);
-		announce(entry.latest);
+		paint(ownLatestOf(entry));
+		announce(entry);
 	};
 
-	const check = async (token: number): Promise<void> => {
+	/** Offline: the cached marker is advisory, but no notice is posted. */
+	const recordMarkerOnly = (entry: UpdateCacheEntry): void => {
+		paint(ownLatestOf(entry));
+	};
+
+	/** Resolve this package's version label, dropping an equal or older answer. */
+	const resolveOwnLatest = async (own: PackageUpdate | undefined): Promise<string | undefined> => {
+		if (!own) return undefined;
+		let latest: string | undefined;
 		try {
-			const latest = await readLatest();
-			if (latest === undefined || token !== generation) return;
-			const entry = { latest, checkedAt: now() };
-			cache.write(entry);
+			latest = await readLatest();
+		} catch {
+			return undefined;
+		}
+		return latest && isNewerVersion(latest, pkg.version) ? latest : undefined;
+	};
+
+	const check = async (ctx: ExtensionContext, token: number): Promise<void> => {
+		try {
+			const list = await readUpdates(ctx, activeCheck());
+			if (token !== generation) return;
+			// A check that could not run is not an empty answer: caching it would tell
+			// the next session "up to date" for a day and clear a marker that may still
+			// be right, so leave both alone and try again next time.
+			if (list === undefined) return;
+			const latest = await resolveOwnLatest(list.find(isOwnPackage));
+			if (token !== generation) return;
+			const entry: UpdateCacheEntry = {
+				key: keyFor(ctx),
+				checkedAt: now(),
+				updates: list,
+				...(latest ? { latest } : {}),
+			};
+			writeCache(entry);
 			record(entry);
 		} catch {
 			// A background check never surfaces an error: the session does not know it ran.
@@ -114,45 +186,62 @@ export function registerUpdate(pi: ExtensionAPI, updates: UpdateSource, deps: Up
 	};
 
 	pi.on("session_start", (_event, ctx) => {
-		// The marker lives in bytefly's header and the notice in a transcript, so a
-		// non-interactive run has nothing to draw and makes no request.
+		// `/bytefly update` can answer in any mode; only the TUI installs the host
+		// shim and posts a notice.
+		context = ctx;
 		if (ctx.mode !== "tui") return;
+		suppression ??= suppress();
+		const cached = cache.read();
+		const key = keyFor(ctx);
 		if (offline()) {
-			// No request, so the window does not matter: the cached answer is the best
-			// one available, and the marker is advisory.
-			const cached = cache.read();
-			if (cached) record(cached);
+			// No request, so the window does not matter: the cached marker is the best
+			// answer available, and no notice is posted from a stale list.
+			if (cached && cached.key === key) recordMarkerOnly(cached);
 			return;
 		}
-		const cached = cache.read();
-		if (cached && isFresh(cached, now())) {
+		if (cached && cached.key === key && isFresh(cached, now())) {
 			record(cached);
 			return;
 		}
 		if (announced) return;
-		void check(generation);
+		void check(ctx, generation);
 	});
 
 	pi.on("session_shutdown", () => {
-		// Invalidate any request still in flight and drop what this session found.
+		// Invalidate any request still in flight, drop what this session found, and
+		// give Pi's own check back to the host.
 		generation++;
 		updates.set();
+		suppression?.restore();
+		suppression = undefined;
+		context = undefined;
 	});
 
 	return {
 		async recheck() {
 			if (offline()) return { kind: "offline" };
-			let latest: string | undefined;
+			if (!context) return { kind: "failed" };
+			let list: PackageUpdate[];
 			try {
-				latest = await readLatest();
+				const found = await readUpdates(context, activeCheck());
+				if (found === undefined) return { kind: "failed" };
+				list = found;
 			} catch {
 				return { kind: "failed" };
 			}
-			if (latest === undefined) return { kind: "failed" };
-			cache.write({ latest, checkedAt: now() });
+			const latest = await resolveOwnLatest(list.find(isOwnPackage));
+			const entry: UpdateCacheEntry = {
+				key: keyFor(context),
+				checkedAt: now(),
+				updates: list,
+				...(latest ? { latest } : {}),
+			};
+			writeCache(entry);
 			// The caller prints the answer, so this path never posts a notice.
 			paint(latest);
-			return isNewerVersion(latest, pkg.version) ? { kind: "available", latest } : { kind: "current", latest };
+			return list.length > 0
+				? { kind: "available", updates: list, ...(latest ? { ownLatest: latest } : {}) }
+				: { kind: "current" };
 		},
 	};
 }

package/extensions/bytefly/update/state.ts

@@ -9,6 +9,8 @@
  * cleared on shutdown, so a reload starts from nothing.
  */
 
+import type { PackageUpdate } from "./types.ts";
+
 /** The store the header reads and the update lifecycle writes. */
 export interface UpdateSource {
 	/** The newer published version, or `undefined` when none is known. */
@@ -25,8 +27,8 @@ export interface UpdateSource {
 export type UpdateOutcome =
 	| { kind: "offline" }
 	| { kind: "failed" }
-	| { kind: "current"; latest: string }
-	| { kind: "available"; latest: string };
+	| { kind: "current" }
+	| { kind: "available"; updates: readonly PackageUpdate[]; ownLatest?: string };
 
 /** A store holding at most one version. */
 export function createUpdateState(): UpdateSource {