pi-hypercharm-provider 1.3.27 → 1.3.29

package/AGENTS.md

@@ -21,6 +21,9 @@ When a model needs overrides, new properties, or corrections, edit the appropria
 | `index.ts` | Provider extension code: model sync, streaming wrapper, footer-status wiring. |
 | `status.ts` | Footer-status presentation: config schema, hypercredit/rate-limit formatters, progressive-disclosure tiers, width-aware widget. Pure module — no pi imports; exercised by `tests/status.smoke.ts`. |
 | `scripts/update-models.js` | The sync script itself (edit only if changing how models are fetched/transformed). |
+| `identity.ts` | Every identifier this extension registers into a shared pi surface (provider id, custom api name, status/widget keys, command, prism entry type, auth key + env var, config/cache file names). `tests/identity.test.ts` enforces namespacing, uniqueness, and disjointness from the official `@charmland/pi-hyper-provider` — never hardcode one of these elsewhere. |
+| `notify.ts` | Deduplicated warning sink: fetch/parse failures go to the session UI once one is active, stderr before that, never thrown. |
+| `prism.ts` | Hyper routing-header validation (sanitizer + persisted-entry re-validation). Pure module — no pi imports; exercised by `tests/prism.test.ts`. |
 
 ## Data Flow
 
@@ -53,6 +56,27 @@ Provider API  ──fetch──►  models.json  ──apply──►  patch.jso
 
 ## TL;DR
 
+- **Never register into a shared pi surface with a hardcoded name** — add it to `identity.ts`; the co-installation tests enforce the namespace.
 - **Never edit `models.json`** — edit `patch.json` instead.
 - **Never edit the README model table** — run the update script instead.
 - `patch.json` and `custom-models.json` are the source files you should modify.
+
+## Tests
+
+`npm run check` runs `tsc --noEmit`, the dependency-free status smoke test, and
+the node:test suites (through `jiti/register` so the extension's extensionless
+TS imports resolve). `npm test` runs only the test suites.
+
+| File | Scope |
+|------|-------|
+| `tests/status.smoke.ts` | Footer widget layout, width math, tier building, config coercion |
+| `tests/identity.test.ts` | Co-install invariant: namespaced + unique + disjoint from the official provider's reserved names |
+| `tests/prism.test.ts` | Prism header/label sanitization and persisted-entry validation |
+| `tests/notify.test.ts` | Warning dedupe, UI routing, stale-ctx stderr fallback |
+| `tests/provider.integration.test.ts` | Real pi runtime (DefaultResourceLoader + createAgentSession + ExtensionRunner): embedded catalog, catalog hot-swap/cache/retention, deprecated grace window, warning surfacing, prism entry durability, and co-installation against `tests/fixtures/official-surface.ts` |
+
+The integration suite stubs `globalThis.fetch` and emits the session lifecycle
+events the pi CLI emits (`session_start`, `turn_start`, `after_provider_response`,
+`message_end`, `turn_end`). It must be run with jiti; `--import jiti/register`
+is already wired into `npm test`.
+

package/README.md

@@ -138,11 +138,13 @@ DeepSeek V4 models use the `deepseek` thinking format — the same native format
 
 ## Footer Status
 
-A Neuralwatt-style status line sits below the editor. It appears after the
-session's first HyperCharm turn completes (never before — no half-empty line
-on fresh sessions or other providers), refreshes its balance when the agent
-run fully settles, and makes no status-related API calls in sessions that
-never use HyperCharm:
+A Neuralwatt-style status line sits below the editor. It appears as soon as a
+HyperCharm model is selected — the account side (team, balance, rate limits)
+renders when the session-start or model-select credits fetch lands, and the
+session side joins it after the first HyperCharm turn completes. Selecting
+another provider hides it (`hideOnOtherProvider` defaults to `true`), the
+balance refreshes when the agent run fully settles, and sessions that never
+use HyperCharm make no status-related API calls:
 
 ```
 ⚡ 1.24 hc · 7 req                       Xu's Team ◆ 249 hc · 996/1k/h · 29d

package/identity.ts

@@ -0,0 +1,49 @@
+/**
+ * Single source of truth for every identifier this extension registers into
+ * shared Pi surfaces.
+ *
+ * Co-installation with the official `@charmland/pi-hyper-provider` is a hard
+ * requirement, so no identifier we register may be a bare shared name. Every
+ * key derives from PROVIDER_ID: provider id, custom api name, status and widget
+ * keys, command name, prism entry type, auth key and env var, and the on-disk
+ * config/cache file names. tests/identity.test.ts and
+ * tests/provider.integration.test.ts enforce the invariant (namespacing,
+ * uniqueness, and disjointness from the official provider's reserved names).
+ */
+export const PROVIDER_ID = "hypercharm";
+export const PROVIDER_DISPLAY_NAME = "HyperCharm";
+
+/** Custom api name: keeps our streamSimple handler distinct from pi's built-in openai-completions pipeline. */
+export const API_NAME = PROVIDER_ID;
+
+export const API_KEY_ENV = "HYPERCHARM_API_KEY";
+export const API_KEY_PLACEHOLDER = `$${API_KEY_ENV}`;
+
+export const STATUS_COMMAND = `${PROVIDER_ID}-status`;
+export const STATUS_KEY_SESSION = `${PROVIDER_ID}-session`;
+export const STATUS_KEY_ACCOUNT = `${PROVIDER_ID}-account`;
+export const WIDGET_KEY = PROVIDER_ID;
+export const PRISM_ENTRY_TYPE = `${PROVIDER_ID}-prism-route`;
+
+export const CONFIG_FILE_NAME = `${PROVIDER_ID}.json`;
+export const CACHE_FILE_NAME = `${PROVIDER_ID}-models.json`;
+
+/**
+ * Every distinct namespaced identifier this extension registers or writes.
+ * API_NAME and WIDGET_KEY alias PROVIDER_ID by design — pi keys the custom api
+ * handler and the below-editor widget by provider id — so the set is deduped;
+ * what matters is that no *value* is shared with another extension.
+ */
+export const IDENTIFIERS: readonly string[] = Object.freeze([
+	...new Set([
+		PROVIDER_ID,
+		API_KEY_ENV,
+		API_KEY_PLACEHOLDER,
+		STATUS_COMMAND,
+		STATUS_KEY_SESSION,
+		STATUS_KEY_ACCOUNT,
+		PRISM_ENTRY_TYPE,
+		CONFIG_FILE_NAME,
+		CACHE_FILE_NAME,
+	]),
+]);

package/index.ts

@@ -33,12 +33,15 @@
  *   The right side compresses across progressive tiers as the terminal
  *   narrows. The balance flips to a ⚠ warning at/below lowBalanceHc.
  *
- *   Lifecycle (mirrors pi-neuralwatt-provider): nothing renders before this
- *   session's first HyperCharm turn completes, so fresh sessions and other
- *   providers' sessions see no half-empty line. Credits/team are prefetched
- *   on session start or model select when a HyperCharm model is active, so
- *   the first turn ends with data already cached. The balance is polled
- *   again on pi's agent_settled event (fires only once no automatic retry,
+ *   Lifecycle (mirrors pi-neuralwatt-provider): selecting a HyperCharm model
+ *   shows the line — the account side renders as soon as the credits/team
+ *   prefetch lands, and the session side (spend/requests) joins it on the
+ *   first completed turn. hideOnOtherProvider (default true) clears
+ *   everything the moment the active model belongs to another provider.
+ *   Credits/team are prefetched on session start or model select when a
+ *   HyperCharm model is active, so the first turn ends with data already
+ *   cached. The balance is polled again on pi's agent_settled event (fires
+ *   only once no automatic retry,
  *   compaction, or queued continuation can follow) — and nowhere else, so
  *   sessions without HyperCharm turns make zero status-related API calls.
  *   Between polls the balance moves optimistically: each turn's
@@ -103,7 +106,23 @@
 
 import { clampThinkingLevel, streamOpenAICompletions } from "@earendil-works/pi-ai/compat";
 import type { AssistantMessageEventStream, SimpleStreamOptions } from "@earendil-works/pi-ai/compat";
+import { Text } from "@earendil-works/pi-tui";
 import { USER_AGENT, loginHypercharm, refreshHypercharmToken } from "./oauth";
+import {
+	API_KEY_PLACEHOLDER,
+	API_NAME,
+	CACHE_FILE_NAME,
+	CONFIG_FILE_NAME,
+	PRISM_ENTRY_TYPE,
+	PROVIDER_DISPLAY_NAME,
+	PROVIDER_ID,
+	STATUS_COMMAND,
+	STATUS_KEY_ACCOUNT,
+	STATUS_KEY_SESSION,
+	WIDGET_KEY,
+} from "./identity";
+import { createNotifier } from "./notify";
+import { prismRouteFromHeaders, prismRouteLabel, readPrismRoute, type PrismRoute } from "./prism";
 import { getAgentDir, type ExtensionAPI, type ExtensionContext, type ModelRegistry } from "@earendil-works/pi-coding-agent";
 import modelsData from "./models.json" with { type: "json" };
 import customModelsData from "./custom-models.json" with { type: "json" };
@@ -132,6 +151,18 @@ import path from "path";
 
 // ─── Types ────────────────────────────────────────────────────────────────────
 
+// Warning sink for fetch/parse failures: deduplicated, routed to the session UI
+// once one is active, stderr before that. Warnings must never throw.
+const notifier = createNotifier();
+
+function describeError(err: unknown): string {
+	return err instanceof Error ? err.message : String(err);
+}
+
+function warnAccountFetch(label: string, reason: string): void {
+	notifier.warn(`Unable to refresh HyperCharm ${label}: ${reason}.`);
+}
+
 interface JsonModel {
 	id: string;
 	name: string;
@@ -248,11 +279,10 @@ function buildModels(base: JsonModel[], custom: JsonModel[], patch: PatchData):
 
 // ─── Stale-While-Revalidate Model Sync ────────────────────────────────────────
 
-const PROVIDER_ID = "hypercharm";
 const BASE_URL = "https://hyper.charm.land/v1";
 const MODELS_URL = `${BASE_URL}/provider`;
 const CACHE_DIR = path.join(getAgentDir(), "cache");
-const CACHE_PATH = path.join(CACHE_DIR, `${PROVIDER_ID}-models.json`);
+const CACHE_PATH = path.join(CACHE_DIR, CACHE_FILE_NAME);
 const LIVE_FETCH_TIMEOUT_MS = 8000;
 
 const PI_THINKING_LEVELS = ["minimal", "low", "medium", "high", "xhigh", "max"] as const;
@@ -322,12 +352,22 @@ async function fetchLiveModels(apiKey: string, signal?: AbortSignal): Promise<Js
 			headers: { Authorization: `Bearer ${apiKey}`, "User-Agent": USER_AGENT },
 			signal: signal ? AbortSignal.any([AbortSignal.timeout(LIVE_FETCH_TIMEOUT_MS), signal]) : AbortSignal.timeout(LIVE_FETCH_TIMEOUT_MS),
 		});
-		if (!response.ok) return null;
+		if (!response.ok) {
+			notifier.warn(`HyperCharm model catalog refresh failed: HTTP ${response.status} — serving cached/embedded models.`);
+			return null;
+		}
 		const data = await response.json();
 		const apiModels = Array.isArray(data) ? data : (data.models || data.data || []);
-		if (!Array.isArray(apiModels) || apiModels.length === 0) return null;
+		if (!Array.isArray(apiModels) || apiModels.length === 0) {
+			notifier.warn("HyperCharm model catalog refresh returned no usable models — serving cached/embedded models.");
+			return null;
+		}
 		return apiModels.map(transformApiModel).filter((m): m is JsonModel => m !== null);
-	} catch {
+	} catch (err) {
+		// An aborted signal means the session was replaced, not that Hyper failed.
+		if (!signal?.aborted) {
+			notifier.warn(`HyperCharm model catalog refresh failed: ${describeError(err)} — serving cached/embedded models.`);
+		}
 		return null;
 	}
 }
@@ -336,7 +376,10 @@ function loadCachedModels(): JsonModel[] | null {
 	try {
 		const data = JSON.parse(fs.readFileSync(CACHE_PATH, "utf8"));
 		return Array.isArray(data) ? data : null;
-	} catch {
+	} catch (err) {
+		if ((err as NodeJS.ErrnoException)?.code !== "ENOENT") {
+			notifier.warn(`Ignoring unreadable HyperCharm model cache at ${CACHE_PATH}: ${describeError(err)}.`);
+		}
 		return null;
 	}
 }
@@ -345,8 +388,9 @@ function cacheModels(models: JsonModel[]): void {
 	try {
 		fs.mkdirSync(CACHE_DIR, { recursive: true });
 		fs.writeFileSync(CACHE_PATH, JSON.stringify(models, null, 2) + "\n");
-	} catch {
-		// Cache write failure is non-fatal
+	} catch (err) {
+		// Non-fatal: the freshly fetched catalog still serves this session.
+		notifier.warn(`Could not write the HyperCharm model cache to ${CACHE_PATH}: ${describeError(err)}.`);
 	}
 }
 
@@ -451,8 +495,11 @@ function loadStatusConfig(): StatusConfig {
 	try {
 		const raw = JSON.parse(fs.readFileSync(CONFIG_PATH, "utf8"));
 		statusConfig = coerceStatusConfig(raw);
-	} catch {
-		// Missing or unreadable file → defaults
+	} catch (err) {
+		// A missing file is normal; anything else is worth surfacing once.
+		if ((err as NodeJS.ErrnoException)?.code !== "ENOENT") {
+			notifier.warn(`Ignoring unreadable HyperCharm status config at ${CONFIG_PATH}: ${describeError(err)} — using defaults.`);
+		}
 	}
 	return statusConfig;
 }
@@ -473,8 +520,9 @@ function writeStatusConfig(): void {
 		raw.glyphs = statusConfig.glyphs;
 		fs.mkdirSync(path.dirname(CONFIG_PATH), { recursive: true });
 		fs.writeFileSync(CONFIG_PATH, JSON.stringify(raw, null, 2) + "\n");
-	} catch {
-		// Config write failure is non-fatal — the in-memory config still applies
+	} catch (err) {
+		// Non-fatal: the in-memory config still applies to this session.
+		notifier.warn(`Could not save the HyperCharm status config to ${CONFIG_PATH}: ${describeError(err)}.`);
 	}
 }
 
@@ -650,7 +698,7 @@ let lastCreditsFetchAt = 0;
 let creditsInFlight: Promise<void> | null = null;
 let metaFetched = false;
 
-async function fetchJsonGet(url: string, apiKey: string, signal?: AbortSignal): Promise<any | null> {
+async function fetchJsonGet(url: string, apiKey: string, signal: AbortSignal | undefined, label: string): Promise<any | null> {
 	try {
 		const response = await fetch(url, {
 			headers: { Authorization: `Bearer ${apiKey}`, "User-Agent": USER_AGENT },
@@ -658,9 +706,14 @@ async function fetchJsonGet(url: string, apiKey: string, signal?: AbortSignal):
 				? AbortSignal.any([AbortSignal.timeout(ACCOUNT_FETCH_TIMEOUT_MS), signal])
 				: AbortSignal.timeout(ACCOUNT_FETCH_TIMEOUT_MS),
 		});
-		if (!response.ok) return null;
+		if (!response.ok) {
+			warnAccountFetch(label, `HTTP ${response.status}`);
+			return null;
+		}
 		return await response.json();
-	} catch {
+	} catch (err) {
+		// An abort means the session was replaced or shut down, not a failure.
+		if (!signal?.aborted) warnAccountFetch(label, describeError(err));
 		return null;
 	}
 }
@@ -673,7 +726,7 @@ function refreshCredits(apiKey: string | undefined, signal: AbortSignal | undefi
 	if (creditsInFlight) return creditsInFlight;
 	creditsInFlight = (async () => {
 		try {
-			const data = await fetchJsonGet(`${BASE_URL}/credits`, apiKey, signal);
+			const data = await fetchJsonGet(`${BASE_URL}/credits`, apiKey, signal, "Hypercredit balance");
 			if (data === null) return;
 			// /credits can report hypercredits ("balance") or USD ("balance_usd",
 			// USD-billed accounts). Handle both at the observed 20 hc = $1 rate so a
@@ -693,8 +746,8 @@ function refreshCredits(apiKey: string | undefined, signal: AbortSignal | undefi
 async function refreshAccountMeta(apiKey: string | undefined, signal?: AbortSignal): Promise<void> {
 	if (!apiKey || metaFetched) return;
 	const [teams, devices] = await Promise.all([
-		fetchJsonGet(`${BASE_URL}/teams`, apiKey, signal),
-		fetchJsonGet(`${BASE_URL}/devices`, apiKey, signal),
+		fetchJsonGet(`${BASE_URL}/teams`, apiKey, signal, "team metadata"),
+		fetchJsonGet(`${BASE_URL}/devices`, apiKey, signal, "device sessions"),
 	]);
 	if (signal?.aborted) return;
 
@@ -719,10 +772,6 @@ async function refreshAccountMeta(apiKey: string | undefined, signal?: AbortSign
 
 // ─── Status Rendering ─────────────────────────────────────────────────────────
 
-const WIDGET_KEY = "hypercharm";
-const STATUS_KEY_SESSION = "hypercharm-session";
-const STATUS_KEY_ACCOUNT = "hypercharm-account";
-
 function currentProviderId(ctx: ExtensionContext): string | undefined {
 	// ctx.model is a getter that can throw on stale contexts
 	try {
@@ -781,10 +830,13 @@ function renderStatus(ctx: ExtensionContext): void {
 		widgetGlyphClampNotified = true;
 		ctx.ui.notify("HyperCharm: widget glyphs stay ASCII on this terminal — unicode glyphs overflow legacy mintty/Cygwin cell widths. Statusbar is unaffected.", "info");
 	}
-	// Show only after HyperCharm activity this session (like pi-neuralwatt):
-	// no empty-gap line on fresh sessions, no stale account glare on other
-	// providers' sessions.
-	const accountVisible = statusConfig.account !== "off" && accountHasData(account) && hasActivity;
+	// Show while HyperCharm is the selected provider — the account side renders
+	// as soon as the session_start/model_select credits fetch lands, with no
+	// need to wait for a turn — and once this session recorded HyperCharm
+	// activity, which is what keeps the line alive after a switch when
+	// hideOnOtherProvider is false. The default true clears it on the switch.
+	const visible = hasActivity || provider === PROVIDER_ID;
+	const accountVisible = statusConfig.account !== "off" && accountHasData(account) && visible;
 	const lowBalance =
 		statusConfig.lowBalanceHc !== null && account.balance !== null && account.balance <= statusConfig.lowBalanceHc;
 	const sessionLine = statusConfig.session !== "off" ? buildSessionLine(sessionStats, glyphs) : undefined;
@@ -1055,15 +1107,15 @@ let currentModels: JsonModel[] = [];
 function makeProviderConfig(models: JsonModel[] = currentModels) {
 	return {
 		baseUrl: BASE_URL,
-		apiKey: "$HYPERCHARM_API_KEY",
+		apiKey: API_KEY_PLACEHOLDER,
 		// Custom API name so our streamSimple registers as its own handler and
 		// never shadows pi's built-in openai-completions pipeline for other
 		// providers. streamHypercharm delegates to pi-ai's OpenAI-compat streamer.
-		api: "hypercharm",
+		api: API_NAME,
 		models,
 		streamSimple: streamHypercharm,
 		oauth: {
-			name: "HyperCharm",
+			name: PROVIDER_DISPLAY_NAME,
 			login: (callbacks) => loginHypercharm(callbacks),
 			refreshToken: (credentials, signal) => refreshHypercharmToken(credentials, signal),
 			getApiKey: (credentials) => String(credentials.access ?? ""),
@@ -1076,13 +1128,17 @@ export default function (pi: ExtensionAPI) {
 	const customModels = customModelsData as JsonModel[];
 	const patches = patchData as PatchData;
 
+	// Prism routing state: collected per assistant request, committed at turn_end.
+	let collectingPrismRoute = false;
+	let prismRoute: PrismRoute | undefined;
+
 	const staleBase = loadStaleModels(embeddedModels);
 	const staleModels = buildModels(staleBase, customModels, patches);
 	currentModels = staleModels;
 
 	pi.registerProvider(PROVIDER_ID, makeProviderConfig(staleModels));
 
-	pi.registerCommand("hypercharm-status", {
+	pi.registerCommand(STATUS_COMMAND, {
 		description: "Configure the HyperCharm footer status (session spend, balance, rate limits)",
 		handler: async (args, ctx) => {
 			await handleStatusCommand(args, ctx);
@@ -1090,6 +1146,7 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	pi.on("session_start", async (_event, ctx) => {
+		notifier.activate(ctx);
 		const epoch = ++statusEpoch;
 		revalidateAbort?.abort();
 		revalidateAbort = new AbortController();
@@ -1100,12 +1157,19 @@ export default function (pi: ExtensionAPI) {
 
 		loadStatusConfig();
 		resetStatusState();
-		updateStatus(ctx); // clears any carryover; activity-gated, renders nothing yet
+		updateStatus(ctx); // clears any carryover; the account side lands with the credits fetch
 		// Re-register so our identity (custom api + streamSimple) always wins
 		// over anything that touched provider registration during load.
 		pi.registerProvider(PROVIDER_ID, makeProviderConfig());
 
-		resolveApiKey(ctx.modelRegistry).then(() => {
+		// A failure here used to vanish: no key resolved meant no refresh and no
+		// diagnostics. Surface it, then continue — without a key we serve the
+		// embedded/cached catalog.
+		resolveApiKey(ctx.modelRegistry)
+			.catch((err) => {
+				notifier.warn(`Unable to resolve HyperCharm credentials: ${describeError(err)} — serving cached/embedded models.`);
+			})
+			.then(() => {
 			// A session replacement while the key resolved invalidated the
 			// captured ctx (fast-resume, /new, /fork); nothing below may touch it.
 			if (epoch !== statusEpoch) return;
@@ -1129,8 +1193,11 @@ export default function (pi: ExtensionAPI) {
 		updateStatus(ctx);
 		const model: any = (event as any).model;
 		if (model?.provider === PROVIDER_ID && cachedApiKey) {
+			// Both refreshes repaint when they land: selection alone must fill in
+			// the account side (balance now, team/auth atoms a moment later)
+			// instead of leaving a bare gem until the next turn.
 			updateStatusAfter(refreshCredits(cachedApiKey, statusAbort?.signal ?? undefined, false), ctx);
-			void refreshAccountMeta(cachedApiKey, statusAbort?.signal ?? undefined);
+			updateStatusAfter(refreshAccountMeta(cachedApiKey, statusAbort?.signal ?? undefined), ctx);
 		}
 	});
 
@@ -1165,4 +1232,42 @@ export default function (pi: ExtensionAPI) {
 		ctx.ui.setStatus(STATUS_KEY_ACCOUNT, undefined);
 		ctx.ui.setWidget(WIDGET_KEY, undefined);
 	});
+
+	// Prism routing: Hyper's edge reports which upstream model actually served the
+	// assistant request via response headers. Collection is scoped to that request
+	// so auxiliary calls between turns cannot leak a route into the transcript,
+	// and the route lands at turn_end as a durable session entry — never a
+	// notification — so it survives reopening the session.
+	pi.registerEntryRenderer(PRISM_ENTRY_TYPE, (entry, _options, theme) => {
+		const route = readPrismRoute(entry.data);
+		const label = route ? prismRouteLabel(route) : undefined;
+		if (label === undefined) return undefined;
+		return new Text(`${theme.fg("muted", "Prism")} ${theme.fg("dim", "→")} ${theme.fg("muted", label)}`, 0, 0);
+	});
+
+	pi.on("turn_start", () => {
+		collectingPrismRoute = true;
+		prismRoute = undefined;
+	});
+
+	pi.on("after_provider_response", (event) => {
+		if (!collectingPrismRoute) return;
+		prismRoute = prismRouteFromHeaders(event.headers);
+	});
+
+	pi.on("message_end", (event) => {
+		if (event.message.role === "assistant") collectingPrismRoute = false;
+	});
+
+	pi.on("turn_end", (event) => {
+		const route = prismRoute;
+		prismRoute = undefined;
+		collectingPrismRoute = false;
+		if (route === undefined) return;
+		if (event.message.role !== "assistant") return;
+		if (event.message.provider !== PROVIDER_ID) return;
+		if (event.message.stopReason === "error" || event.message.stopReason === "aborted") return;
+		pi.appendEntry(PRISM_ENTRY_TYPE, route);
+	});
+
 }

package/notify.ts

@@ -0,0 +1,50 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+export type WarningSink = (message: string) => void;
+
+export interface Notifier {
+	/** Emit a deduplicated warning through the currently available output. */
+	warn: WarningSink;
+	/** Route future warnings through this session's UI (no-op without a UI). */
+	activate(ctx: ExtensionContext): void;
+}
+
+/**
+ * Fetch and parse failures must never be silent, and must never spam: warnings
+ * are deduplicated by message for the life of the process. Until a UI session
+ * activates the notifier they go to stderr (visible in print/json modes); after
+ * activation they go through ctx.ui.notify. A stale ctx — a refresh landing
+ * after its session was replaced — falls back to stderr instead of throwing.
+ */
+export function createNotifier(): Notifier {
+	const seenWarnings = new Set<string>();
+	const toStderr: WarningSink = (message) => {
+		process.stderr.write(`HyperCharm warning: ${message}\n`);
+	};
+	let emit: WarningSink = toStderr;
+
+	return {
+		warn(message) {
+			if (seenWarnings.has(message)) return;
+			seenWarnings.add(message);
+			emit(message);
+		},
+
+		activate(ctx) {
+			let hasUI = false;
+			try {
+				hasUI = ctx.hasUI;
+			} catch {
+				return;
+			}
+			if (!hasUI) return;
+			emit = (message) => {
+				try {
+					ctx.ui.notify(message, "warning");
+				} catch {
+					toStderr(message);
+				}
+			};
+		},
+	};
+}

package/package.json

@@ -1,9 +1,17 @@
 {
   "name": "pi-hypercharm-provider",
-  "version": "1.3.27",
+  "version": "1.3.29",
   "description": "HyperCharm provider extension for pi - Access DeepSeek, GLM, Kimi, Qwen, MiniMax, Gemma, and GPT-OSS models through the Charm Hyper API",
   "type": "module",
   "main": "index.ts",
+  "scripts": {
+    "clean": "echo 'nothing to clean'",
+    "build": "echo 'nothing to build'",
+    "check": "tsc --noEmit && npm run smoke && npm test",
+    "smoke": "node tests/status.smoke.ts",
+    "test": "node --import jiti/register --test tests/identity.test.ts tests/prism.test.ts tests/notify.test.ts tests/provider.integration.test.ts",
+    "update-models": "node scripts/update-models.js"
+  },
   "keywords": [
     "pi",
     "extension",
@@ -21,10 +29,15 @@
     "gemma",
     "gpt-oss"
   ],
+  "peerDependencies": {
+    "@earendil-works/pi-tui": "*"
+  },
   "devDependencies": {
     "@earendil-works/pi-ai": "0.85.1",
     "@earendil-works/pi-coding-agent": "0.85.1",
+    "@earendil-works/pi-tui": "0.85.1",
     "@types/node": "^24.10.1",
+    "jiti": "2.7.0",
     "typescript": "6.0.3"
   },
   "author": "",
@@ -33,12 +46,5 @@
     "extensions": [
       "./index.ts"
     ]
-  },
-  "scripts": {
-    "clean": "echo 'nothing to clean'",
-    "build": "echo 'nothing to build'",
-    "check": "tsc --noEmit && node tests/status.smoke.ts",
-    "smoke": "node tests/status.smoke.ts",
-    "update-models": "node scripts/update-models.js"
   }
-}
+}

package/prism.ts

@@ -0,0 +1,43 @@
+import { PRISM_ENTRY_TYPE } from "./identity";
+
+export { PRISM_ENTRY_TYPE };
+
+/** Longest routing label we accept (mirrors the official provider's limit). */
+const MAX_LABEL_LENGTH = 200;
+/** Control, format, line-separator, and paragraph-separator characters. */
+const UNSAFE_LABEL = /[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/u;
+
+export interface PrismRoute {
+	modelName?: string;
+	modelId?: string;
+}
+
+/** Trimmed, length- and character-checked routing label; undefined when unusable. */
+export function prismLabel(value: unknown): string | undefined {
+	if (typeof value !== "string") return undefined;
+	const label = value.trim();
+	if (label === "" || label.length > MAX_LABEL_LENGTH || UNSAFE_LABEL.test(label)) return undefined;
+	return label;
+}
+
+/** Route captured from a provider response; undefined when neither header is usable. */
+export function prismRouteFromHeaders(headers: Record<string, string> | undefined): PrismRoute | undefined {
+	if (!headers) return undefined;
+	const modelName = prismLabel(headers["x-prism-model-name"]);
+	const modelId = prismLabel(headers["x-prism-model-id"]);
+	return modelName !== undefined || modelId !== undefined ? { modelName, modelId } : undefined;
+}
+
+/** Re-validate persisted entry data: session files are user-editable input. */
+export function readPrismRoute(data: unknown): PrismRoute | undefined {
+	if (typeof data !== "object" || data === null) return undefined;
+	const record = data as Record<string, unknown>;
+	const modelName = prismLabel(record.modelName);
+	const modelId = prismLabel(record.modelId);
+	return modelName !== undefined || modelId !== undefined ? { modelName, modelId } : undefined;
+}
+
+/** What to show for a route: the human name when present, else the model id. */
+export function prismRouteLabel(route: PrismRoute): string | undefined {
+	return route.modelName ?? route.modelId;
+}

package/tests/fixtures/official-surface.ts

@@ -0,0 +1,42 @@
+/**
+ * Stand-in for the official @charmland/pi-hyper-provider@0.4.0 registration
+ * surface, used by tests/provider.integration.test.ts to prove both extensions
+ * can be installed at once.
+ *
+ * It deliberately registers under the OFFICIAL identifiers — provider id
+ * "hyper", status key "hyper", /hyper-status command, hyper-prism-route entry
+ * renderer, HYPER_API_KEY — and publishes a model with an id we also serve
+ * ("glm-5.3"), so the test asserts provider-scoped model resolution instead of
+ * accidental global-key behaviour.
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+export default function officialSurfaceFixture(pi: ExtensionAPI) {
+	pi.registerProvider("hyper", {
+		baseUrl: "https://hyper.charm.land/v1",
+		apiKey: "$HYPER_API_KEY",
+		api: "openai-completions",
+		models: [
+			{
+				id: "glm-5.3",
+				name: "Official fixture GLM 5.3",
+				reasoning: false,
+				input: ["text"],
+				cost: { input: 1, output: 2, cacheRead: 0, cacheWrite: 0 },
+				contextWindow: 4096,
+				maxTokens: 512,
+			},
+		],
+	});
+
+	pi.registerEntryRenderer("hyper-prism-route", () => undefined);
+
+	pi.registerCommand("hyper-status", {
+		description: "Configure the Charm Hyper footer status",
+		handler: async () => {},
+	});
+
+	pi.on("turn_end", (_event, ctx) => {
+		ctx.ui.setStatus("hyper", "Hyper fixture status");
+	});
+}