@phi-code-admin/phi-code 0.77.2 → 0.77.3

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [0.77.3] - 2026-06-13
+
+### Added
+
+- **`/context` command to view and set the active model's context window.**
+  `/context` shows the current window and whether it is provider-reported,
+  inferred, or a manual override. `/context 256k`, `/context 1M`, or
+  `/context 200000` set it (applied immediately to the footer and auto-compaction,
+  and saved as a per-model override that survives restarts and the background
+  refresh). `/context auto` clears the override. Useful when a provider reports no
+  window and the inferred value is wrong: the window directly drives when the
+  conversation auto-compacts (`compact when tokens > window - reserve`).
+
+### Changed
+
+- **Default fallback context window raised from 128k to 256k**, matching most
+  current high-end models. Known 128k families (DeepSeek, Llama, GPT-4o, Hy3) are
+  pinned explicitly so they are not over-reported. Note the asymmetry: a too-large
+  window risks a late compaction and a hard "context exceeded" on a genuinely
+  smaller model, so set the real value with `/context` when in doubt.
+
 ## [0.77.2] - 2026-06-13
 
 ### Changed

package/extensions/phi/models.ts

@@ -21,6 +21,7 @@ import {
 	buildOpenCodeGoProviderConfig,
 	getOpenCodeGoModels,
 } from "./providers/opencode-go.js";
+import { formatWindow, inferContextWindow, parseContextWindow } from "./providers/context-window.js";
 import { fetchLiveModels, peekCache, resetLiveModelsCache, toPersistedModel } from "./providers/live-models.js";
 
 const PROVIDER_DISPLAY: Record<string, string> = {
@@ -190,6 +191,96 @@ export default function modelsExtension(pi: ExtensionAPI) {
 		},
 	});
 
+	pi.registerCommand("context", {
+		description:
+			"Show or set the active model's context window (e.g. `/context 256k`, `/context 1M`, `/context auto`). Drives when the conversation auto-compacts.",
+		handler: async (args, ctx) => {
+			const model = ctx.model;
+			if (!model) {
+				ctx.ui.notify("No active model. Select one with `/model` first.", "warning");
+				return;
+			}
+			const provider = model.provider;
+			const modelId = model.id;
+			const arg = args.trim();
+
+			const readOverrideWindow = (): number | undefined => {
+				const overrides = store.getProvider(provider)?.modelOverrides as
+					| Record<string, { contextWindow?: number }>
+					| undefined;
+				return overrides?.[modelId]?.contextWindow;
+			};
+
+			const writeOverrides = (overrides: Record<string, unknown>): void => {
+				const stored = store.getProvider(provider) ?? {};
+				watcher.muteForWrite("models_json_changed");
+				store.setKey(provider, stored.apiKey ?? "local", { modelOverrides: overrides });
+			};
+
+			try {
+				if (arg === "") {
+					const source = readOverrideWindow() !== undefined ? "manual override" : "provider / inferred";
+					ctx.ui.notify(
+						`**${modelId}** (\`${provider}\`) context window: \`${formatWindow(model.contextWindow)}\` (${source}).\n` +
+							"Set the real value with `/context 256k`, `/context 1M`, or `/context 200000`. " +
+							"Reset to the detected value with `/context auto`.\n" +
+							"This is what determines when the conversation auto-compacts.",
+						"info",
+					);
+					return;
+				}
+
+				if (arg.toLowerCase() === "auto" || arg.toLowerCase() === "reset") {
+					const stored = store.getProvider(provider) ?? {};
+					const overrides = { ...((stored.modelOverrides as Record<string, unknown>) ?? {}) };
+					const entry = overrides[modelId];
+					if (entry && typeof entry === "object") {
+						const next = { ...(entry as Record<string, unknown>) };
+						delete next.contextWindow;
+						if (Object.keys(next).length === 0) delete overrides[modelId];
+						else overrides[modelId] = next;
+					}
+					writeOverrides(overrides);
+
+					// Revert the active model to the persisted/inferred window.
+					const persistedModels = (store.getProvider(provider)?.models as
+						| Array<{ id?: string; contextWindow?: number }>
+						| undefined) ?? [];
+					const persisted = persistedModels.find((m) => m?.id === modelId)?.contextWindow;
+					const reverted = persisted && persisted > 0 ? persisted : inferContextWindow(modelId, undefined, provider);
+					await pi.setModel({ ...model, contextWindow: reverted });
+					ctx.ui.notify(`Cleared context override for **${modelId}**. Reverted to \`${formatWindow(reverted)}\`.`, "info");
+					return;
+				}
+
+				const value = parseContextWindow(arg);
+				if (!value) {
+					ctx.ui.notify("Invalid value. Use e.g. `256k`, `1M`, or `200000`.", "warning");
+					return;
+				}
+
+				// Immediate effect: the footer and auto-compaction use the new window right away.
+				await pi.setModel({ ...model, contextWindow: value });
+
+				// Persist as a per-model override so it survives restarts and the background
+				// refresh (which rewrites `models` but leaves `modelOverrides` untouched).
+				const stored = store.getProvider(provider) ?? {};
+				const overrides = { ...((stored.modelOverrides as Record<string, unknown>) ?? {}) };
+				const existing = (overrides[modelId] as Record<string, unknown> | undefined) ?? {};
+				overrides[modelId] = { ...existing, contextWindow: value };
+				writeOverrides(overrides);
+
+				ctx.ui.notify(
+					`Context window for **${modelId}** set to \`${formatWindow(value)}\` (saved). ` +
+						`Auto-compaction now triggers near ${formatWindow(value)}.`,
+					"info",
+				);
+			} catch (err) {
+				ctx.ui.notify(`/context error: ${err instanceof Error ? err.message : String(err)}`, "error");
+			}
+		},
+	});
+
 	async function listCommand(target: string | undefined, ctx: { ui: { notify: (m: string, t?: "info" | "warning" | "error") => void } }): Promise<void> {
 		const providers = target ? [target] : store.listProviders();
 		if (providers.length === 0) {

package/extensions/phi/providers/context-window.ts

@@ -14,18 +14,26 @@
  * default-models.json, live-models static specs).
  */
 
-const DEFAULT_CONTEXT_WINDOW = 128_000;
+// Default when nothing is known. 256k matches the majority of current high-end
+// models. Note the asymmetry: over-reporting risks a hard "context exceeded" on a
+// genuinely smaller model (caught late by the overflow safety net), while
+// under-reporting only compacts a little early. Use `/context` to set the real
+// window for a model whose value is unknown.
+const DEFAULT_CONTEXT_WINDOW = 256_000;
 
 export function inferContextWindow(modelId: string, apiValue?: number, providerId?: string): number {
 	if (typeof apiValue === "number" && apiValue > 0) return apiValue;
 
 	const id = (modelId ?? "").toLowerCase();
+	// Large-context families that provider /models endpoints often omit.
 	if (id.includes("qwen") || id.includes("minimax")) return 1_000_000;
 	if (id.includes("gemini")) return id.includes("flash") ? 1_000_000 : 2_000_000;
+	if (id.includes("gpt-5")) return 400_000;
 	if (id.includes("kimi")) return 256_000;
 	if (id.includes("glm") || id.includes("mimo")) return 200_000;
-	if (id.includes("gpt-5")) return 400_000;
 	if (id.includes("claude")) return 200_000;
+	// Known 128k families: pin them so the larger default does not over-report them.
+	if (id.includes("deepseek") || id.includes("llama") || id.includes("gpt-4") || id.includes("hy3")) return 128_000;
 
 	// Provider-level hint when the model id is opaque.
 	const provider = (providerId ?? "").toLowerCase();
@@ -33,3 +41,23 @@ export function inferContextWindow(modelId: string, apiValue?: number, providerI
 
 	return DEFAULT_CONTEXT_WINDOW;
 }
+
+/** Parse a context-window value like "256k", "1M", "1.5m", or "200000". */
+export function parseContextWindow(input: string): number | undefined {
+	const m = input.trim().toLowerCase().match(/^(\d+(?:\.\d+)?)\s*([km])?$/);
+	if (!m) return undefined;
+	const n = Number.parseFloat(m[1]);
+	if (!Number.isFinite(n) || n <= 0) return undefined;
+	const mult = m[2] === "k" ? 1_000 : m[2] === "m" ? 1_000_000 : 1;
+	const value = Math.round(n * mult);
+	return value > 0 ? value : undefined;
+}
+
+/** Format a token count as a compact "256k" / "1M" label. */
+export function formatWindow(n: number): string {
+	if (n >= 1_000_000) {
+		const v = n / 1_000_000;
+		return `${Number.isInteger(v) ? v : v.toFixed(1)}M`;
+	}
+	return `${Math.round(n / 1_000)}k`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@phi-code-admin/phi-code",
-	"version": "0.77.2",
+	"version": "0.77.3",
 	"description": "Coding agent CLI with persistent memory, sub-agents, intelligent routing, and orchestration",
 	"type": "module",
 	"piConfig": {