ultimate-pi 0.16.0 → 0.17.0

package/.pi/scripts/harness-generate-model-router.mjs

@@ -22,9 +22,9 @@ const UP_PKG = join(SCRIPT_DIR, "..", "..");
 const OUT_PATH = join(process.cwd(), ".pi", "model-router.json");
 
 const PROVIDER_PRIORITY = [
+	"openai",
 	"opencode-go",
 	"anthropic",
-	"openai",
 	"google",
 	"openrouter",
 	"groq",
@@ -35,6 +35,7 @@ const PROVIDER_PRIORITY = [
 /** Substring hints per tier (first match in available ids wins). */
 const TIER_HINTS = {
 	high: [
+		"gpt-5.5-pro",
 		"deepseek-v4-pro",
 		"gpt-5.4-pro",
 		"claude-opus",
@@ -43,6 +44,7 @@ const TIER_HINTS = {
 		"pro",
 	],
 	medium: [
+		"gpt-5.5",
 		"qwen3.6-plus",
 		"kimi-k2.6",
 		"gpt-5.4",
@@ -98,7 +100,10 @@ function canonicalRef(provider, modelId) {
 
 function pickTierModel(models, tier) {
 	const hints = TIER_HINTS[tier];
-	const ids = models.map((m) => m.id);
+	for (const hint of hints) {
+		const exact = models.find((m) => m.id === hint);
+		if (exact) return canonicalRef(exact.provider, exact.id);
+	}
 	for (const hint of hints) {
 		const match = models.find((m) => m.id.includes(hint));
 		if (match) return canonicalRef(match.provider, match.id);
@@ -114,6 +119,10 @@ function pickTierModel(models, tier) {
 	return canonicalRef(models[0].provider, models[0].id);
 }
 
+function modelsForProvider(available, provider) {
+	return available.filter((m) => m.provider === provider);
+}
+
 function choosePrimaryProvider(available) {
 	const byProvider = new Map();
 	for (const m of available) {
@@ -129,7 +138,7 @@ function choosePrimaryProvider(available) {
 
 function buildFallbacks(available, primaryProvider, highModel) {
 	const fallbacks = [];
-	for (const p of ["anthropic", "google", "openai"]) {
+	for (const p of ["anthropic", "google", "openai", "opencode-go"]) {
 		if (p === primaryProvider) continue;
 		const alt = available.filter((m) => m.provider === p);
 		if (alt.length === 0) continue;
@@ -139,6 +148,76 @@ function buildFallbacks(available, primaryProvider, highModel) {
 	return fallbacks.slice(0, 3);
 }
 
+/** Session-locked router: one model SKU per profile; tiers vary thinking only. */
+function buildRoutedProfile(available, provider) {
+	const models = modelsForProvider(available, provider);
+	if (models.length === 0) return null;
+	const sku =
+		pickTierModel(models, "medium") ??
+		pickTierModel(models, "high") ??
+		pickTierModel(models, "low");
+	if (!sku) return null;
+	const fallbacks = buildFallbacks(available, provider, sku);
+	const high = { model: sku, thinking: "high" };
+	if (fallbacks.length) high.fallbacks = fallbacks;
+	return {
+		high,
+		medium: { model: sku, thinking: "medium" },
+		low: { model: sku, thinking: "low" },
+	};
+}
+
+function addCheapDeepProfiles(profiles, available, provider) {
+	const models = modelsForProvider(available, provider);
+	if (models.length === 0) return;
+	const sku =
+		pickTierModel(models, "medium") ??
+		pickTierModel(models, "high") ??
+		pickTierModel(models, "low");
+	if (!sku) return;
+	const fallbacks = buildFallbacks(available, provider, sku);
+	const deepHigh = { model: sku, thinking: "xhigh" };
+	if (fallbacks.length) deepHigh.fallbacks = fallbacks;
+	profiles.cheap = {
+		high: { model: sku, thinking: "low" },
+		medium: { model: sku, thinking: "off" },
+		low: { model: sku, thinking: "off" },
+	};
+	profiles.deep = {
+		high: deepHigh,
+		medium: { model: sku, thinking: "medium" },
+		low: { model: sku, thinking: "low" },
+	};
+}
+
+function resolveClassifierModel(available) {
+	const openaiModels = modelsForProvider(available, "openai");
+	if (openaiModels.length > 0) {
+		return (
+			pickTierModel(openaiModels, "low") ??
+			canonicalRef(openaiModels[openaiModels.length - 1].provider, openaiModels[openaiModels.length - 1].id)
+		);
+	}
+	const { models } = choosePrimaryProvider(available);
+	return pickTierModel(models, "medium");
+}
+
+/** OpenAI-backed default profile name exposed as `router/auto`. */
+const OPENAI_PROFILE_NAME = "auto";
+
+function routerProfileName(provider) {
+	return provider === "openai" ? OPENAI_PROFILE_NAME : provider;
+}
+
+function resolveDefaultProfile(profiles) {
+	if (profiles[OPENAI_PROFILE_NAME]) return OPENAI_PROFILE_NAME;
+	if (profiles["opencode-go"]) return "opencode-go";
+	return (
+		Object.keys(profiles).find((name) => name !== "cheap" && name !== "deep") ??
+		OPENAI_PROFILE_NAME
+	);
+}
+
 async function main() {
 	const force = process.argv.includes("--force");
 	const dryRun = process.argv.includes("--dry-run");
@@ -171,23 +250,37 @@ async function main() {
 		process.exit(0);
 	}
 
-	const { provider: primaryProvider, models: primaryModels } =
-		choosePrimaryProvider(available);
-
-	const highModel = pickTierModel(primaryModels, "high");
-	const mediumModel = pickTierModel(primaryModels, "medium");
-	const lowModel = pickTierModel(primaryModels, "low");
+	const profiles = {};
+	for (const provider of ["openai", "opencode-go"]) {
+		const profile = buildRoutedProfile(available, provider);
+		if (profile) profiles[routerProfileName(provider)] = profile;
+	}
 
-	if (!highModel || !mediumModel || !lowModel) {
-		fail("could not assign tier models from available registry");
+	if (Object.keys(profiles).length === 0) {
+		const { provider: primaryProvider, models: primaryModels } =
+			choosePrimaryProvider(available);
+		const profile = buildRoutedProfile(available, primaryProvider);
+		if (!profile) {
+			fail("could not assign tier models from available registry");
+		}
+		profiles[primaryProvider] = profile;
 	}
 
-	const fallbacks = buildFallbacks(available, primaryProvider, highModel);
+	const cheapDeepSource = profiles["opencode-go"]
+		? "opencode-go"
+		: resolveDefaultProfile(profiles);
+	addCheapDeepProfiles(profiles, available, cheapDeepSource);
+
+	const defaultProfile = resolveDefaultProfile(profiles);
+	const classifierModel = resolveClassifierModel(available);
+	if (!classifierModel) {
+		fail("could not assign classifier model from available registry");
+	}
 
 	const config = {
-		defaultProfile: "auto",
+		defaultProfile,
 		debug: false,
-		classifierModel: mediumModel,
+		classifierModel,
 		phaseBias: 0.5,
 		maxSessionBudget: 1.0,
 		largeContextThreshold: 100000,
@@ -199,27 +292,13 @@ async function main() {
 			},
 			{ matches: "changelog", tier: "low" },
 		],
-		profiles: {
-			auto: {
-				high: { model: highModel, thinking: "high", fallbacks },
-				medium: { model: mediumModel, thinking: "medium" },
-				low: { model: lowModel, thinking: "low" },
-			},
-			cheap: {
-				high: { model: mediumModel, thinking: "low" },
-				medium: { model: lowModel, thinking: "off" },
-				low: { model: lowModel, thinking: "off" },
-			},
-			deep: {
-				high: { model: highModel, thinking: "xhigh", fallbacks },
-				medium: { model: mediumModel, thinking: "medium" },
-				low: { model: lowModel, thinking: "low" },
-			},
-		},
+		profiles,
 	};
 
 	const json = `${JSON.stringify(config, null, 2)}\n`;
 	const providerSet = [...new Set(available.map((m) => m.provider))].sort();
+	const autoProfile = profiles[OPENAI_PROFILE_NAME];
+	const opencodeProfile = profiles["opencode-go"];
 
 	if (dryRun) {
 		process.stdout.write(json);
@@ -230,13 +309,16 @@ async function main() {
 	writeFileSync(OUT_PATH, json, "utf8");
 
 	console.log("✓ Generated .pi/model-router.json from Pi authenticated providers:");
-	console.log(`  Primary provider: ${primaryProvider}`);
+	console.log(`  Default profile: ${defaultProfile}`);
+	console.log(`  Classifier: ${classifierModel}`);
 	console.log(`  Authenticated providers: ${providerSet.join(", ")}`);
 	console.log(`  Available models: ${available.length}`);
-	console.log(`  High tier: ${highModel}`);
-	console.log(`  Medium tier: ${mediumModel}`);
-	console.log(`  Low tier: ${lowModel}`);
-	if (fallbacks.length) console.log(`  Fallbacks: ${fallbacks.join(", ")}`);
+	if (autoProfile) {
+		console.log(`  auto (openai) high: ${autoProfile.high.model}`);
+	}
+	if (opencodeProfile) {
+		console.log(`  opencode-go high: ${opencodeProfile.high.model}`);
+	}
 }
 
 main().catch((err) => {

package/.pi/scripts/harness-model-router-routing.test.mjs

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+/**
+ * Unit tests for session-locked pi-model-router routing (no LLM).
+ * Run: npx tsx .pi/scripts/harness-model-router-routing.test.mjs
+ */
+
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+	decideSessionLock,
+	applyThinkingToDecision,
+	buildRoutingDecision,
+	decideRouting,
+} from "../../vendor/pi-model-router/extensions/routing.js";
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+
+const sampleProfile = {
+	high: { model: "openai/gpt-5.5", thinking: "high" },
+	medium: { model: "openai/gpt-5.5", thinking: "medium" },
+	low: { model: "openai/gpt-5.5", thinking: "low" },
+};
+
+const planningContext = {
+	systemPrompt: "You are a harness architect. Design tradeoffs and migration strategy.",
+	messages: [
+		{
+			role: "user",
+			content:
+				"Plan a multi-phase refactor across modules with architecture review.",
+			timestamp: 1,
+		},
+	],
+};
+
+const shortContext = {
+	systemPrompt: "Summarize briefly.",
+	messages: [{ role: "user", content: "changelog", timestamp: 1 }],
+};
+
+const lockHigh = decideSessionLock(
+	planningContext,
+	"auto",
+	sampleProfile,
+	undefined,
+	undefined,
+	0.5,
+	[{ matches: "changelog", tier: "low" }],
+);
+assert.equal(lockHigh.tier, "high", "planning prompt locks high tier");
+
+const lockLow = decideSessionLock(shortContext, "auto", sampleProfile);
+assert.equal(lockLow.tier, "low", "short summary locks low tier");
+
+const locked = buildRoutingDecision(
+	"auto",
+	sampleProfile,
+	lockHigh.tier,
+	"planning",
+	lockHigh.reasoning,
+);
+const thinkingTurn = decideRouting(
+	{
+		...planningContext,
+		messages: [
+			...planningContext.messages,
+			{ role: "user", content: "changelog only", timestamp: 2 },
+		],
+	},
+	"auto",
+	sampleProfile,
+	locked,
+);
+const merged = applyThinkingToDecision(locked, thinkingTurn, sampleProfile);
+assert.equal(merged.targetLabel, locked.targetLabel, "model stays locked");
+assert.equal(merged.tier, thinkingTurn.tier, "thinking tier follows turn");
+assert.equal(merged.thinking, "low", "low thinking from turn tier config");
+
+const examplePath = join(ROOT, ".pi", "model-router.example.json");
+const example = JSON.parse(readFileSync(examplePath, "utf8"));
+for (const [name, profile] of Object.entries(example.profiles ?? {})) {
+	const { high, medium, low } = profile;
+	assert.equal(
+		high.model,
+		medium.model,
+		`example profile ${name}: medium/high same model`,
+	);
+	assert.equal(
+		medium.model,
+		low.model,
+		`example profile ${name}: low/medium same model`,
+	);
+}
+
+console.log("harness-model-router-routing.test: PASS");

package/.pi/scripts/harness-sync-model-router.mjs

@@ -29,11 +29,24 @@ function saveSettings(settingsPath, data) {
 	);
 }
 
+function readDefaultRouterProfile(configPath) {
+	if (!existsSync(configPath)) return "auto";
+	try {
+		const data = JSON.parse(readFileSync(configPath, "utf8"));
+		const profile =
+			typeof data.defaultProfile === "string" ? data.defaultProfile.trim() : "";
+		return profile || "auto";
+	} catch {
+		return "auto";
+	}
+}
+
 function main() {
 	const root = process.cwd();
 	const configPath = join(root, ".pi", "model-router.json");
 	const settingsPath = join(root, ".pi", "settings.json");
 	const hasConfig = existsSync(configPath);
+	const defaultRouterProfile = readDefaultRouterProfile(configPath);
 
 	const settings = loadSettings(settingsPath);
 	if (!settings) {
@@ -67,14 +80,14 @@ function main() {
 
 	if (noProjectDefault) {
 		settings.defaultProvider = "router";
-		settings.defaultModel = "auto";
+		settings.defaultModel = defaultRouterProfile;
 		changed = true;
 	}
 
 	if (changed) {
 		saveSettings(settingsPath, settings);
 		console.log(
-			"✓ Router defaults set (`router` / `auto`) — run /reload in pi when ready",
+			`✓ Router defaults set (\`router\` / \`${defaultRouterProfile}\`) — run /reload in pi when ready`,
 		);
 	} else {
 		console.log("[harness-model-router] Defaults unchanged (user set defaultProvider)");

package/.pi/scripts/harness-verify.mjs

@@ -145,6 +145,34 @@ async function checkSentruxRules() {
 	ok(".sentrux/rules.toml present");
 }
 
+async function checkModelRouterThinkingOnly() {
+	const path = join(ROOT, ".pi", "model-router.json");
+	if (!(await fileExists(path))) {
+		ok("model-router.json absent (skip thinking-only tier check)");
+		return;
+	}
+	let raw;
+	try {
+		raw = JSON.parse(await readFile(path, "utf-8"));
+	} catch {
+		fail("invalid .pi/model-router.json");
+	}
+	const profiles = raw.profiles ?? {};
+	for (const [name, profile] of Object.entries(profiles)) {
+		const high = profile?.high?.model;
+		const medium = profile?.medium?.model;
+		const low = profile?.low?.model;
+		if (
+			!(high && medium && low && high === medium && medium === low)
+		) {
+			fail(
+				`model-router profile "${name}" must use the same model on high/medium/low (thinking-only tiers)`,
+			);
+		}
+	}
+	ok("model-router.json thinking-only (same model per profile)");
+}
+
 async function checkSentruxGate() {
 	await checkSentruxRules();
 
@@ -288,6 +316,7 @@ async function main() {
 	ok("test-diff-golden.json");
 
 	await checkSentruxGate();
+	await checkModelRouterThinkingOnly();
 
 	if (!(await fileExists(AGENTS_MANIFEST))) {
 		fail(

package/CHANGELOG.md

@@ -4,6 +4,17 @@ All notable changes to this project are documented in this file.
 
 ## [Unreleased]
 
+## [v0.17.0] — 2026-05-22
+
+### ✨ Features
+
+- **Model router:** Session-locked model SKU at start (initial prompt + system prompt); per-turn routing adjusts thinking tier only; subagents lock from agent `systemPrompt` complexity.
+- **Harness:** Thinking-only profile shape in generator/verify; plan review gate, debate eligibility, and smoke fixture updates.
+
+### ✅ Tests
+
+- Add `harness-model-router-routing` and plan-debate eligibility coverage.
+
 ## [v0.16.0] — 2026-05-19
 
 ### ✨ Features

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ultimate-pi",
-	"version": "0.16.0",
+	"version": "0.17.0",
 	"description": "Ultimate AI coding harness for pi.dev — extensible skills, Obsidian wiki knowledge layer, compressed context, deterministic output",
 	"keywords": [
 		"pi-package",

package/vendor/pi-model-router/UPSTREAM_PIN.md

@@ -3,6 +3,8 @@
 - **Repository:** https://github.com/yeliu84/pi-model-router
 - **License:** MIT (`LICENSE` in this tree)
 - **Pinned upstream commit:** `8c60095da0e753c242c4be9bb617b85f4dd3255c`
-- **Local changes:** TypeScript imports in `extensions/*.ts` use `@earendil-works/*`; relative imports end in `.js` for NodeNext; `package.json` peerDependencies list `@earendil-works/*`.
+- **Local changes:**
+  - TypeScript imports in `extensions/*.ts` use `@earendil-works/*`; relative imports end in `.js` for NodeNext; `package.json` peerDependencies list `@earendil-works/*`.
+  - **Session-locked routing (ultimate-pi harness):** one concrete model per session/profile, chosen from initial prompt + system prompt complexity; per-turn routing adjusts **thinking tier only** (`sessionLock` persisted in `router-state`). Harness generator emits the same `model` on high/medium/low tiers.
 
 **Refresh upstream:** run `npm run vendor:sync-router` from ultimate-pi root (updates this file with the latest commit SHA).

package/vendor/pi-model-router/extensions/commands.ts

@@ -58,12 +58,12 @@ export const registerCommands = (
   const SUBCOMMAND_DETAILS = [
     { name: 'status', desc: 'Show current router status' },
     { name: 'profile', desc: 'Switch to a different router profile' },
-    { name: 'pin', desc: 'Pin routing for a profile to a specific tier' },
+    { name: 'pin', desc: 'Pin thinking tier for a profile (model stays session-locked)' },
     { name: 'thinking', desc: 'Override thinking level for a tier or profile' },
     { name: 'disable', desc: 'Disable the router and restore last model' },
     {
       name: 'fix',
-      desc: 'Correct the last routing decision and pin that tier',
+      desc: 'Correct last thinking tier and pin it (model stays session-locked)',
     },
     { name: 'widget', desc: 'Toggle the router status widget' },
     { name: 'debug', desc: 'Toggle or clear router debug history' },
@@ -676,10 +676,10 @@ export const registerCommands = (
               'Router Subcommands:',
               '  status                      Show current status, profile, pin, cost, and last decision.',
               '  profile [name]              Switch to a profile (enables router if off). Lists available if no name.',
-              '  pin [profile] <tier|auto>   Force a tier (high|medium|low) for a profile or set to auto.',
+              '  pin [profile] <tier|auto>   Pin thinking tier (high|medium|low); model stays locked for the session.',
               '  thinking [prof] [tier] <lv> Override thinking level for a profile/tier (off|minimal|...|xhigh|auto).',
               '  disable                     Disable the router and restore the last used non-router model.',
-              '  fix <tier>                  Correct the last routing decision and pin that tier for the current profile.',
+              '  fix <tier>                  Correct last thinking tier and pin it for the current profile.',
               '  widget <on|off|toggle>      Control the persistent status widget visibility.',
               '  debug <on|off|show|clear>   Control routing debug logging to notifications and history.',
               '  reload                      Hot-reload the configuration JSON from .pi/model-router.json.',

package/vendor/pi-model-router/extensions/index.ts

@@ -10,6 +10,7 @@ import {
   type RouterThinkingByProfile,
   type RouterTier,
   type CustomSessionEntry,
+  type SessionLock,
 } from './types.js';
 import {
   FALLBACK_CONFIG,
@@ -47,6 +48,7 @@ const routerExtension = (pi: ExtensionAPI) => {
   let lastPersistedSnapshot: string | undefined;
   let isInitialized = false;
   let isInternalModelSwitch = false;
+  let sessionLock: SessionLock | undefined;
 
   const setModelInternally = async (
     model: NonNullable<ExtensionContext['model']>,
@@ -94,6 +96,7 @@ const routerExtension = (pi: ExtensionAPI) => {
       lastDecision,
       lastNonRouterModel,
       accumulatedCost,
+      sessionLock,
     );
     const snapshot = JSON.stringify({
       ...state,
@@ -127,6 +130,7 @@ const routerExtension = (pi: ExtensionAPI) => {
         accumulatedCost,
         widgetEnabled,
         currentConfig,
+        sessionLock,
       ),
     reloadConfig: (
       ctx?: ExtensionContext,
@@ -204,6 +208,7 @@ const routerExtension = (pi: ExtensionAPI) => {
       }
       selectedProfile = resolvedProfile;
       routerEnabled = true;
+      sessionLock = undefined;
       persistState();
       actions.updateStatus(ctx);
       return true;
@@ -253,6 +258,12 @@ const routerExtension = (pi: ExtensionAPI) => {
           set accumulatedCost(v) {
             accumulatedCost = v;
           },
+          get sessionLock() {
+            return sessionLock;
+          },
+          set sessionLock(v) {
+            sessionLock = v;
+          },
         },
         {
           persistState,
@@ -290,6 +301,7 @@ const routerExtension = (pi: ExtensionAPI) => {
         ? `${ctx.model.provider}/${ctx.model.id}`
         : lastNonRouterModel;
     lastDecision = undefined;
+    sessionLock = undefined;
 
     const entries = ctx.sessionManager.getBranch() as CustomSessionEntry[];
     const savedState = entries
@@ -322,6 +334,12 @@ const routerExtension = (pi: ExtensionAPI) => {
         : [];
       lastNonRouterModel = savedState.lastNonRouterModel ?? lastNonRouterModel;
       accumulatedCost = savedState.accumulatedCost ?? 0;
+      if (
+        savedState.sessionLock &&
+        savedState.sessionLock.profile === selectedProfile
+      ) {
+        sessionLock = { ...savedState.sessionLock };
+      }
     }
 
     await actions.ensureValidActiveRouterProfile(ctx);
@@ -432,6 +450,9 @@ const routerExtension = (pi: ExtensionAPI) => {
       }
 
       routerEnabled = true;
+      if (selectedProfile !== profileName) {
+        sessionLock = undefined;
+      }
       selectedProfile = profileName;
     } else {
       routerEnabled = false;