one-code-extension 0.4.1 → 0.6.0

package/extensions/lib/model-unusable.ts

@@ -7,7 +7,7 @@
  * using Codex with a ChatGPT account"). The auto-mode classifier already learns
  * that on its first call and steps to the next candidate (`ClassifierState.
  * rejected`). Since subagents share the classifier's selection floor
- * (docs/decisions/model-policy.md, 2026-09-11) they land on the same first
+ * (working-docs/decisions/model-policy.md, 2026-09-11) they land on the same first
  * pick — so what one role learns must reach the other, or every session's
  * first subagent fails on a model the classifier already gave up on.
  *

package/extensions/lib/newer-model.ts

@@ -0,0 +1,100 @@
+/** Same-line upgrades at a comparable blended price. Selection only; never switches a model. */
+import type { Api, Model } from "@earendil-works/pi-ai";
+import { catalogModelFor } from "./model-catalog.ts";
+import { baseModelId, isAliasOrVariantId, isExperimentalBuild, isMovingAlias, modelSpec, stripSnapshotDate } from "./model-policy.ts";
+
+interface ModelLine {
+	line: string;
+	version: number[];
+}
+
+/** Mask the first version, not dates, size tags, or digits in a gateway's author name. */
+export function modelLine(id: string): ModelLine | undefined {
+	const base = stripSnapshotDate(baseModelId(id).toLowerCase().replace(/-20\d{2}-\d{2}-\d{2}$/, ""));
+	const slash = base.lastIndexOf("/");
+	const name = base.slice(slash + 1);
+	// Claude spells minor versions with hyphens on its direct provider, but
+	// dots on gateways. Keep size/class suffixes for every other model line.
+	const claude = name.match(/^claude-(?:opus|sonnet|haiku|fable)-(\d+(?:[-.]\d{1,2})?)/);
+	const match = claude ? /\d+(?:[-.]\d{1,2})?/.exec(claude[0]) : /\d+(?:\.\d+)*/.exec(name);
+	if (!match || match.index === undefined) return undefined;
+	// Four-digit date/version stamps (Mistral's 2407/2512, for example) do
+	// not prove a version upgrade. Leave ambiguous calendar names unpaired.
+	if (match[0].split(/[.-]/)[0].length >= 4) return undefined;
+	const end = match.index + match[0].length;
+	if (/^[bm](?:-|$)/.test(name.slice(end))) return undefined;
+	return {
+		line: `${base.slice(0, slash + 1)}${name.slice(0, match.index)}#${name.slice(end)}`,
+		version: match[0].split(/[.-]/).map(Number),
+	};
+}
+
+function compareVersion(a: number[], b: number[]): number {
+	for (let i = 0; i < Math.max(a.length, b.length); i++) {
+		const difference = (a[i] ?? 0) - (b[i] ?? 0);
+		if (difference) return difference;
+	}
+	return 0;
+}
+
+/** Catalog zeroes are unpriced sentinels, not a promise of free tokens. */
+function blendedPrice(model: Model<Api>): number | undefined {
+	const input = model.cost?.input;
+	const output = model.cost?.output;
+	if (!Number.isFinite(input) || !Number.isFinite(output) || !(input > 0) || !(output > 0)) return undefined;
+	const blend = (3 * input + output) / 4;
+	return Number.isFinite(blend) ? blend : undefined;
+}
+
+export interface NewerModelSuggestion {
+	model: Model<Api>;
+	text: string;
+	fix: string;
+}
+
+/**
+ * Available models only, on the session's provider and exact model line,
+ * dated by the model catalogs (`model-catalog.ts`); this path never fetches.
+ * Unlike secondary-model selection, tiny tiers are allowed: Qwen 27B upgrading
+ * within its own line is useful advice, not an automatic delegation decision.
+ */
+export function newerModelSuggestion(
+	available: readonly Model<Api>[],
+	current: Model<Api> | undefined,
+): NewerModelSuggestion | undefined {
+	if (!current) return undefined;
+	const currentLine = modelLine(current.id);
+	const currentDate = catalogModelFor(current)?.released;
+	const currentPrice = blendedPrice(current);
+	if (!currentLine || currentDate === undefined || currentPrice === undefined) return undefined;
+	const candidates = [];
+	for (const model of available) {
+		if (model.provider !== current.provider || isAliasOrVariantId(model.id)) continue;
+		// Experimental endpoints and moving "latest" aliases have no stable
+		// upgrade identity, even when their catalog row includes a release date.
+		if (isExperimentalBuild(model.id) || isMovingAlias(model.id)) continue;
+		const line = modelLine(model.id);
+		if (!line || line.line !== currentLine.line || compareVersion(line.version, currentLine.version) <= 0) continue;
+		const entry = catalogModelFor(model);
+		const date = entry?.released;
+		const price = blendedPrice(model);
+		if (!entry || date === undefined || date <= currentDate || price === undefined || price > currentPrice * 1.1) continue;
+		if (!entry.tools || entry.legacy || entry.deprecated) continue;
+		candidates.push({ model, version: line.version, date, price });
+	}
+	candidates.sort((a, b) => compareVersion(b.version, a.version) || b.date - a.date || a.price - b.price);
+	const pick = candidates[0];
+	if (!pick) return undefined;
+	const pricePair = (model: Model<Api>) => `$${formatPrice(model.cost.input)}/$${formatPrice(model.cost.output)}`;
+	const comparison = pick.price < currentPrice * 0.9 ? "costs less" : "costs about the same";
+	return {
+		model: pick.model,
+		text: `${pick.model.id} is newer than ${current.id} and ${comparison} (${pricePair(pick.model)} vs ${pricePair(current)} per M tokens).`,
+		fix: `Switch with /model ${modelSpec(pick.model)}.`,
+	};
+}
+
+/** At least cents, without rounding low per-token catalog prices to zero. */
+function formatPrice(price: number): string {
+	return String(price).includes("e") ? String(price) : price.toFixed(Math.max(2, (String(price).split(".")[1] ?? "").length));
+}

package/extensions/lib/notices.ts

@@ -0,0 +1,87 @@
+/**
+ * Lifecycle notices from several extensions, shown as one info line.
+ *
+ * pi folds back-to-back info notices into a single status line, and every
+ * status line renders the latest status text (findings §63). On session_start
+ * and model_select several extensions announce something, so each info notice
+ * overwrote the one before it. Those extensions call `queueNotice` instead of
+ * `ctx.ui.notify`; one owner per event bus collects the notices until the
+ * event's handlers have run (pi awaits each handler in turn, so one microtask
+ * is not enough: the batch closes on the next macrotask), then shows the
+ * warnings and errors first, each on its own, and ONE info notice joining the
+ * info texts with newlines.
+ *
+ * The owner is elected the way `session-model-tier.ts` elects its own: no
+ * module state is shared between extensions (each has its own jiti copy), so
+ * the first caller on a bus installs the listener and every later caller finds
+ * it there. Without a UI the notice goes straight to `ctx.ui.notify`, exactly
+ * as before (a no-op in print and json mode).
+ *
+ * Only lifecycle notices go through here. Command output and a warning or
+ * error an extension shows on its own stay direct `ctx.ui.notify` calls.
+ */
+
+import type { EventBus, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+export const NOTICE_CHANNEL = "one-code:notice";
+
+export type NoticeLevel = "info" | "warning" | "error";
+
+type NoticeCtx = Pick<ExtensionContext, "hasUI" | "ui">;
+
+interface NoticeMessage {
+	ctx: NoticeCtx;
+	level: NoticeLevel;
+	text: string;
+	/** Set by the owner when it took the notice. */
+	taken?: boolean;
+}
+
+/** Queue a lifecycle notice for the bus's owner, installing the owner if this bus has none. */
+export function queueNotice(events: Pick<EventBus, "emit" | "on">, ctx: NoticeCtx, level: NoticeLevel, text: string): void {
+	if (!ctx.hasUI) {
+		ctx.ui.notify(text, level);
+		return;
+	}
+	const message: NoticeMessage = { ctx, level, text };
+	events.emit(NOTICE_CHANNEL, message);
+	if (message.taken) return;
+	installNoticeOwner(events);
+	events.emit(NOTICE_CHANNEL, message);
+}
+
+function installNoticeOwner(events: Pick<EventBus, "on">): void {
+	let pending: NoticeMessage[] = [];
+	let timer: ReturnType<typeof setTimeout> | undefined;
+	const flush = () => {
+		timer = undefined;
+		const batch = pending;
+		pending = [];
+		showNotices(batch);
+	};
+	events.on(NOTICE_CHANNEL, (data) => {
+		const message = data as NoticeMessage;
+		if (message.taken) return;
+		message.taken = true;
+		pending.push(message);
+		timer ??= setTimeout(flush, 0);
+	});
+}
+
+/** Warnings and errors first, each on its own, then one info notice joining the rest. */
+export function showNotices(batch: readonly NoticeMessage[]): void {
+	for (const notice of batch) {
+		if (notice.level !== "info") notifySafely(notice.ctx, notice.text, notice.level);
+	}
+	const info = batch.filter((notice) => notice.level === "info");
+	if (info.length > 0) notifySafely(info[info.length - 1].ctx, info.map((notice) => notice.text).join("\n"), "info");
+}
+
+/** A session replaced before the batch closed leaves a stale ctx: the notice has nowhere to go. */
+function notifySafely(ctx: NoticeCtx, text: string, level: NoticeLevel): void {
+	try {
+		ctx.ui.notify(text, level);
+	} catch {
+		// Stale session: drop it.
+	}
+}