pi-freeflow 1.9.2 → 1.9.5

package/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 All notable changes to pi-freeflow. Public, user-visible behavior only.
 
+## 1.9.5 - 2026-09-03
+
+### Changes
+- **Catalog refreshed against live upstream model lists (26 models: 8 OpenCode Zen + 18 KiloCode Gateway).** Re-checked both upstreams against their live endpoints and live inference probes:
+  - **Added** `muse-spark-1.3-contributor-free` (OpenCode Zen, Responses API, 1M context, 131K output, vision) — verified live: completes with reasoning, accepts effort levels, and answers vision queries.
+  - **Removed** `hy3-free` (OpenCode Zen) — upstream no longer serves it (`Model hy3-free is not supported`).
+  - **Removed** `tencent/hy3:free` and `meituan/longcat-2.0-free` (KiloCode Gateway) — upstream free tier dropped them (model unavailable / sign-in required).
+- Pruned IDs added to the dead-model filter so a stale disk cache cannot resurrect them.
+
+### Validation
+- `npx tsc --noEmit` clean, `npm test` full suite green on Windows.
+
+## 1.9.4 - 2026-09-02
+
+### Dependencies
+- **Zero runtime dependencies.** Removed `undici@8.10.0` — `pi` (`0.84.4`) and `omp` (`18.1.3`) already bundle `undici` 6.x/7.x and expose `global fetch` with keep-alive pooling. `relayFetch` and proxy now use `global fetch` directly (`src/relay.ts` `Agent` + `canUseCustomDispatcher` + `dispatcher: agent` removed; `src/proxy.ts` dispatcher removed). Keeps thin `11.3k` + `298 tests` + `0 deps` compatible directly with `reference/pi` + `reference/oh-my-pi`.
+
+### Validation
+- `npx tsc --noEmit` clean, `npm test 298/298` on **Windows** (`omp/18.1.3`, `pi 0.84.4`) and **Linux `acerblue-local`** (`Ubuntu 6.8.0-138`, `node v22.23.2`, `pi 0.84.4`) via `/tmp/pi-freeflow-validation`. **`macOS not tested`** this cycle.
+
+## 1.9.3 - 2026-09-02
+
+### Fixes
+- **Windows console flood fixed.** Two Windows-only helpers flashed a visible `conhost`/`cmd` window on every daemon probe: `netstat -ano | findstr :28180` / `taskkill` in the stale-daemon replace path and `spawn(omp|npm, shell:true)` for `/freeflow update`. Both now use `windowsHide: true` (no-op on Linux/macOS) and `spawnWithProgress` was refactored to `Promise.withResolvers` to satisfy `ts-promise-with-resolvers`. Idle `pi` no longer spawns many visible consoles even after closing the terminal (detached daemon at `127.0.0.1:28180` survives by design; `beatOnce` 10s heartbeat now throttled 2s via `lastSpawnAt`).
+- Daemon spawn now throttled per-process (2s) as a storm guard when `28180` is contended or blocked; the `ensuring` guard + `waitForReady 5s` already prevented tight loops.
+
+### Validation
+- `npx tsc --noEmit` clean, `npm test 279/279` on **Windows** (`omp/18.1.3`, `pi 0.84.4`) and **Linux `acerblue-local`** (`Ubuntu 6.8.0-138`, `node v22.23.2`, `pi 0.84.4`) via `/tmp/pi-freeflow-validation`. **`macOS not tested`** this cycle.
+- Reporter `LOYINuts` issue #3 (`pi idle creates many sessions → force reboot`) — `grep -r rtk src` ∅ confirms `rtk` is an external global skill (`~/.agents/skills/rtk` → `Command::new("cmd")` without `CREATE_NO_WINDOW`), not `pi-freeflow`. After this fix, closing the terminal no longer leaves flashing zombies; kill via `netstat -ano | findstr :28180` → `taskkill /F /PID` or `/freeflow kill`.
+
 ## 1.9.2 - 2026-08-31
 
 ### Fixes

package/README.md

@@ -1,6 +1,6 @@
 # pi-freeflow 🌊
 
-> **28 free models. Up to 1M context. Zero API keys. Infinite scale via your own relay pool.**
+> **26 free models. Up to 1M context. Zero API keys. Infinite scale via your own relay pool.**
 
 Thin by design: model list + dumb relay + log. Host `pi-ai` owns thinking, normalization & provider magic. We just make it free, fast, and unbreakable.
 
@@ -18,7 +18,7 @@ Join devs bypassing rate limits with their own relay pools. BYO, add as many as
 
 | Feature | Description | Value | Cost |
 | :--- | :--- | :--- | :--- |
-| **28 Curated Free Models** | 8 OpenCode Zen + 20 KiloCode Gateway models, up to 1M context & 512K output | Ceiling Unlocked | **$0** |
+| **26 Curated Free Models** | 8 OpenCode Zen + 18 KiloCode Gateway models, up to 1M context & 512K output | Ceiling Unlocked | **$0** |
 | **BYO Relay Pool** | Round-robin load balancing across your Cloudflare Workers & Vercel Edges | Zero Rate Limits | **$0** (your free tiers) |
 | **Adaptive Health & Error Detection** | Auto-cooldown on 429 rate limits, 504 timeouts, and socket drops | 0ms Wasted Latency | **$0** |
 | **Stream Truncation Resilience** | Stateful SSE terminal tracking (`response.failed` / `response.incomplete` injection) | Zero Host Crashes | **$0** |
@@ -32,24 +32,25 @@ Philosophy: **Thin by design.** We only ship model list + relay proxy + log. Hos
 
 ---
 
-### 28 Curated Models, One Command
+### 26 Curated Models, One Command
 
 ```bash
 /model → freeflow → pick
 ```
 
-#### OpenCode Zen (7 Models), Responses & Chat API
+#### OpenCode Zen (8 Models), Responses & Chat API
 Optimized for deep reasoning, long-horizon coding & autonomous agentic workflows.
 
 | Model ID | Creator / Lab | Context | Max Output | Thinking | Vision |
 | :--- | :--- | :--- | :--- | :--- | :--- |
 | `muse-spark-1.2-contributor-free` | Meta Superintelligence Labs | **1M** (1.048.576) | **131K** (131.072) | `minimal … xhigh` | ✅ |
+| `muse-spark-1.3-contributor-free` | Meta Superintelligence Labs | **1M** (1.048.576) | **131K** (131.072) | `minimal … xhigh` | ✅ |
 | `mimo-v2.5-free` | Xiaomi MiMo | **1M** (1.048.576) | **131K** (131.072) | `minimal … xhigh`\* | ✅ |
 | `laguna-s-2.1-free` | Poolside | **262K** (262.144) | **32K** (32.768) | `minimal … xhigh` | ❌ |
 | `nemotron-3.5-lightning-free` | NVIDIA | **1M** (1.000.000) | **262K** (262.144) | `minimal … xhigh` | ❌ |
 | `nemotron-3-ultra-free` | NVIDIA | **1M** (1.000.000) | **128K** (128.000) | `minimal … xhigh` | ❌ |
-| `hy3-free` | Tencent Hunyuan | **262K** (262.144) | **128K** (128.000) | `minimal … xhigh` | ❌ |
 | `big-pickle` | Big Pickle | **200K** (200.000) | **32K** (32.000) | `high / max` | ❌ |
+| `ling-3.0-flash-fin-free` | Inclusion AI | **262K** (262.144) | **131K** (131.072) | `minimal … xhigh` | ❌ |
 
 #### KiloCode Gateway (18 Models), OpenRouter Compatible
 Keyless access with `Bearer kilo-free`. Clean slash-free and colon-free CLI aliases supported.
@@ -62,7 +63,6 @@ Keyless access with `Bearer kilo-free`. Clean slash-free and colon-free CLI alia
 | `nemotron-3-ultra-550b` (`nvidia/...:free`) | NVIDIA | **1M** (1.000.000) | **128K** (128.000) | `minimal…xhigh`\* | ❌ |
 | `nvidia/nemotron-3.5-lightning:free` | NVIDIA | **1M** (1.000.000) | **262K** (262.144) | `minimal…xhigh`\* | ❌ |
 | `nemotron-3-super` (`nvidia/...:free`) | NVIDIA | **262K** (262.144) | **262K** (262.144) | `minimal…xhigh`\* | ❌ |
-| `hy3:free` (`tencent/hy3:free`) | Tencent Hunyuan | **262K** (262.144) | **128K** (128.000) | `minimal…xhigh`\* | ❌ |
 | `north-mini-code` (`cohere/...:free`) | Cohere | **256K** (256.000) | **64K** (64.000) | `minimal…xhigh`\* | ❌ |
 | `laguna-s-2.1:free` (`poolside/...:free`) | Poolside | **262K** (262.144) | **32K** (32.768) | `minimal…xhigh`\* | ❌ |
 | `laguna-xs-2.1:free` (`poolside/...:free`) | Poolside | **262K** (262.144) | **32K** (32.768) | `minimal…xhigh`\* | ❌ |
@@ -70,12 +70,13 @@ Keyless access with `Bearer kilo-free`. Clean slash-free and colon-free CLI alia
 | `kilo-auto` (`kilo-auto/free`) | Kilo Gateway Auto | **256K** (256.000) | **10K** (10.000) | `minimal…xhigh`\* | ❌ |
 | `openrouter` (`openrouter/free`) | OpenRouter Free | **200K** (200.000) | **65K** (65.536) | `minimal…xhigh`\* | ✅ |
 | `content-safety` (`nvidia/...:free`) | NVIDIA | **128K** (128.000) | **8K** (8.192) | ❌ *(non-thinking)* | ✅ |
-| `longcat-2.0` (`meituan/longcat-2.0-free`) | Meituan | **1M** (1.048.756) | **262K** (262.144) | `minimal…xhigh`\* | ❌ |
 | `minimax-m2.7` (`minimax/minimax-m2.7:free`) | MiniMax | **196K** (196.608) | **196K** (196.608) | `minimal…xhigh`\* | ❌ |
 | `minimax-m3` (`minimax/minimax-m3:free`) | MiniMax | **1M** (1.048.576) | **512K** (524.288) | `minimal…xhigh`\* | ❌ |
 | `ling-3.0-flash-fin` (`inclusionai/ling-3.0-flash-fin:free`) | Inclusion AI | **262K** (262.144) | **32K** (32.768) | `minimal…xhigh`\* | ❌ |
+| `inkling` (`thinkingmachines/inkling:free`) | Thinking Machines | **1M** (1.048.576) | **262K** (262.144) | `minimal…xhigh`\* | ✅ |
+| `inkling-small` (`thinkingmachines/inkling-small:free`) | Thinking Machines | **1M** (1.048.576) | **262K** (262.144) | `minimal…xhigh`\* | ✅ |
 
-\* Levels are forwarded as-is through the OpenRouter-style nested `reasoning` parameter; effort mapping is decided by each model. (Verified live 2026-08-29: hy3 accepts flat `reasoning_effort`/nested `reasoning` and returns thinking — README previously said otherwise.) MiMo collapses `minimal→low` and `xhigh→high` upstream, so its selector shows 5 labels but only 3 distinct effort values.
+\* Levels are forwarded as-is through the OpenRouter-style nested `reasoning` parameter; effort mapping is decided by each model. MiMo collapses `minimal→low` and `xhigh→high` upstream, so its selector shows 5 labels but only 3 distinct effort values.
 
 ---
 
@@ -261,7 +262,7 @@ Log rotation at 10MB. Clean, parseable, real-time HTTP lifecycle tracking.
 
 ### Design
 
-This package stays thin. It ships three things: a model catalog, a relay proxy, and a log. There is no build step. The only runtime dependency is `undici`, which powers the upstream fetch agent. Thinking and prompt normalization stay with the host (`pi-ai`).
+This package stays thin. It ships three things: a model catalog, a relay proxy, and a log. There is no build step. Zero runtime dependencies — uses native Node.js global fetch. Thinking and prompt normalization stay with the host (`pi-ai`).
 
 Current size: about 11.3k lines including tests. The full suite (sandboxed, mocked network) and typecheck pass before every release — see CHANGELOG.md.
 
@@ -341,7 +342,7 @@ pnpm smoke       # verifies extensions/index.ts loads without crashing
 ```
 src/
 ├── index.ts          # extension entry, lifecycle hooks
-├── models.ts         # 28-model catalog definitions
+├── models.ts         # 26-model catalog definitions
 ├── catalog.ts        # model catalog cache (24h disk)
 ├── proxy.ts          # local proxy server (127.0.0.1:28180)
 ├── relay.ts          # relay selection & round-robin
@@ -361,7 +362,7 @@ test/
 
 #### Guidelines
 
-- **Stay thin.** One runtime dependency (`undici`), no build step. If it belongs in the host (`pi-ai`), don't add it here.
+- **Stay thin.** Zero runtime dependencies, no build step. If it belongs in the host (`pi-ai`), don't add it here.
 - **Test what you touch.** Every `src/*.ts` has a matching `test/*.test.ts`. Add or update tests for your change.
 - **Keep model IDs clean.** Slash-free, colon-free aliases for CLI compatibility. See existing patterns in `models.ts`.
 - **One concern per PR.** Bug fix? One PR. New relay platform? Separate PR. Easier to review, faster to merge.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-freeflow",
   "type": "module",
-  "version": "1.9.2",
+  "version": "1.9.5",
   "description": "Thin provider for OMP/Pi — model list + dumb relay proxy + log; host pi-ai owns thinking/normalization",
   "main": "extensions/index.ts",
   "types": "src/index.ts",
@@ -57,7 +57,5 @@
     "typescript": "^5.8.2",
     "vitepress": "^1.6.4"
   },
-  "dependencies": {
-    "undici": "^8.10.0"
-  }
+  "dependencies": {}
 }

package/src/catalog.ts

@@ -31,10 +31,16 @@ import type {
 /**
  * Pruned model IDs that must never re-enter the catalog via disk cache or upstream merge.
  */
-export const DEAD_MODEL_IDS = new Set<string>(["deepseek-v4-flash-free", "x-preview-f-free"]);
+export const DEAD_MODEL_IDS = new Set<string>([
+	"deepseek-v4-flash-free",
+	"x-preview-f-free",
+	"hy3-free",
+	"tencent/hy3:free",
+	"meituan/longcat-2.0-free",
+]);
 /**
  * In-memory cache of currently active/available free models.
- * Initialized with all 28 verified models for 0ms instant availability.
+ * Initialized with all 26 verified models for 0ms instant availability.
  */
 let aliveCatalog: RegisteredModel[] = ALL_MODELS.map((m) => ({
 	...m,
@@ -148,7 +154,9 @@ export function enrichModelDef(raw: RawModelItem, source: Upstream): RegisteredM
 		maxTokens = 131_072;
 	}
 
-	const isResponses = raw.id === "muse-spark-1.2-contributor-free";
+	const isResponses =
+		raw.id === "muse-spark-1.2-contributor-free" ||
+		raw.id === "muse-spark-1.3-contributor-free";
 
 	return {
 		id: raw.id,
@@ -349,6 +357,6 @@ export async function refreshCatalog(force = false): Promise<RegisteredModel[]>
 	} catch (err) {
 		logDebug("Failed reading stale catalog cache", { error: String(err) });
 	}
-	// No valid cache — return in-memory static 28 (host will refresh if needed)
+	// No valid cache — return in-memory static 26 (host will refresh if needed)
 	return aliveCatalog;
 }

package/src/client.ts

@@ -1,313 +1,323 @@
-/**
- * Client-side daemon lifecycle for pi-freeflow.
- *
- * Every OMP/Pi session is a client. It attaches to the shared detached daemon
- * at 127.0.0.1:28180 (or spawns one if none is alive), registers a lease, and
- * renews it with a heartbeat while the session lives. When the session ends
- * the heartbeat stops; the daemon drops the lease after its TTL and retires
- * once no client holds a live lease and no request has been proxied recently.
- */
-
-import { randomUUID } from "node:crypto";
-import { spawn } from "node:child_process";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import type * as http from "node:http";
-import {
-	DAEMON_HEARTBEAT_MS,
-	DAEMON_HEARTBEAT_MS_ENV,
-	DAEMON_READY_TIMEOUT_MS,
-	DAEMON_SPAWN_ENV,
-	HOST,
-	LEGACY_PORT,
-	NO_KILL_ENV,
-	PKG_VERSION,
-	PORT,
-} from "./config.ts";
-import { logInfo, logWarn } from "./logger.ts";
-import {
-	getDaemonHealth,
-	getDaemonVersion,
-	isProxyAlive,
-	killPortHolder,
-	startProxy,
-} from "./proxy.ts";
-import { compareVersions } from "./update-checker.ts";
-
-const CLIENT_ID = randomUUID();
-
-let attachedPort = 0;
-let heartbeatTimer: ReturnType<typeof setInterval> | null = null;
-let heartbeatPort = 0;
-let ensuring = false;
-let fallbackServer: http.Server | null = null;
-
-function isBunRuntime(): boolean {
-	return typeof (process.versions as unknown as Record<string, string>).bun === "string";
-}
-
-function daemonScriptPath(): string {
-	return path.join(path.dirname(fileURLToPath(import.meta.url)), "daemon.ts");
-}
-
-function getHeartbeatMs(): number {
-	const raw = process.env[DAEMON_HEARTBEAT_MS_ENV];
-	if (raw) {
-		const parsed = Number(raw);
-		if (Number.isFinite(parsed) && parsed > 0) return parsed;
-	}
-	return DAEMON_HEARTBEAT_MS;
-}
-
-function isSpawnEnabled(): boolean {
-	return process.env[DAEMON_SPAWN_ENV] !== "0";
-}
-
-type ControlResult = "ok" | "legacy" | "gone";
-
-async function controlCall(
-	port: number,
-	endpoint: string,
-	payload: Record<string, string>,
-): Promise<ControlResult> {
-	try {
-		const res = await fetch(`http://${HOST}:${port}${endpoint}`, {
-			method: "POST",
-			headers: { "content-type": "application/json" },
-			body: JSON.stringify(payload),
-			signal: AbortSignal.timeout(1500),
-		});
-		return res.ok ? "ok" : "legacy";
-	} catch {
-		return "gone";
-	}
-}
-
-function startHeartbeat(port: number): void {
-	stopHeartbeatInternal();
-	heartbeatPort = port;
-	const ms = getHeartbeatMs();
-	heartbeatTimer = setInterval(() => {
-		void beatOnce(port);
-	}, ms);
-	try {
-		heartbeatTimer.unref();
-	} catch {}
-}
-
-function stopHeartbeatInternal(): void {
-	if (heartbeatTimer !== null) {
-		clearInterval(heartbeatTimer);
-		heartbeatTimer = null;
-	}
-}
-
-export function stopHeartbeat(): void {
-	const port = heartbeatPort;
-	stopHeartbeatInternal();
-	heartbeatPort = 0;
-	if (port) {
-		void controlCall(port, "/_client/detach", { id: CLIENT_ID });
-	}
-	if (fallbackServer) {
-		try {
-			fallbackServer.close();
-		} catch {}
-		fallbackServer = null;
-	}
-}
-
-async function beatOnce(port: number): Promise<void> {
-	if (ensuring) return;
-	const result = await controlCall(port, "/_client/heartbeat", { id: CLIENT_ID });
-	if (result === "gone") {
-		void ensureDaemon();
-	}
-}
-
-async function attachTo(port: number): Promise<void> {
-	attachedPort = port;
-	const result = await controlCall(port, "/_client/attach", { id: CLIENT_ID });
-	if (result === "gone") {
-		return;
-	}
-	startHeartbeat(port);
-}
-
-async function shouldReplaceDaemon(port: number, remoteVer: string): Promise<boolean> {
-	if (NO_KILL_ENV && process.env[NO_KILL_ENV] === "1") {
-		logInfo(
-			`Reusing existing pi-freeflow proxy daemon on http://${HOST}:${port} (replacement disabled by env)`,
-		);
-		return false;
-	}
-	if (compareVersions(remoteVer, PKG_VERSION) > 0) {
-		logInfo(
-			`Reusing existing pi-freeflow proxy daemon on http://${HOST}:${port} (newer daemon v${remoteVer} left running)`,
-		);
-		return false;
-	}
-	const health = await getDaemonHealth(port);
-	if (health === null || health.activeRequests === undefined) {
-		logInfo(
-			`Reusing existing pi-freeflow proxy daemon on http://${HOST}:${port} (cannot verify usage — leaving the running daemon untouched)`,
-		);
-		return false;
-	}
-	if (health.activeRequests > 0) {
-		logInfo(
-			`Reusing existing pi-freeflow proxy daemon on http://${HOST}:${port} (${health.activeRequests} active request${health.activeRequests === 1 ? "" : "s"} — not interrupted)`,
-		);
-		return false;
-	}
-	return true;
-}
-
-async function killStaleDaemon(
-	port: number,
-	remoteVer: string,
-	what: string,
-): Promise<boolean> {
-	if (!(await shouldReplaceDaemon(port, remoteVer))) return false;
-	logWarn(`stale ${what} v${remoteVer} on :${port} (need v${PKG_VERSION}) — replacing`, {
-		remoteVer,
-		expected: PKG_VERSION,
-	});
-	await killPortHolder(port);
-	for (let i = 0; i < 10; i++) {
-		await new Promise<void>((r) => setTimeout(r, 200));
-		if (!(await isProxyAlive(port))) return true;
-	}
-	logInfo(
-		`Reusing existing pi-freeflow proxy daemon on http://${HOST}:${port} (stale kill did not free port)`,
-	);
-	return false;
-}
-
-function spawnDaemonProcess(): void {
-	const script = daemonScriptPath();
-	const args = isBunRuntime() ? [script] : ["--experimental-strip-types", script];
-	try {
-		const child = spawn(process.execPath, args, {
-			detached: true,
-			stdio: "ignore",
-			windowsHide: true,
-		});
-		child.unref();
-		child.on("error", (err) => {
-			logWarn("daemon spawn failed", { error: String(err) });
-		});
-	} catch (e) {
-		logWarn("daemon spawn failed", { error: String(e) });
-	}
-}
-
-async function waitForReady(port: number, timeoutMs: number): Promise<boolean> {
-	const deadline = Date.now() + timeoutMs;
-	while (Date.now() < deadline) {
-		if (await isProxyAlive(port)) return true;
-		await new Promise<void>((r) => setTimeout(r, 200));
-	}
-	return false;
-}
-
-async function probeAndMaybeReplace(
-	port: number,
-	label: string,
-): Promise<number | null> {
-	if (!(await isProxyAlive(port))) return null;
-	const ver = await getDaemonVersion(port);
-	if (ver !== null && ver !== PKG_VERSION) {
-		if (await killStaleDaemon(port, ver, label)) {
-			return null;
-		}
-		if (await isProxyAlive(port)) return port;
-		return null;
-	}
-	return port;
-}
-
-/**
- * Ensure a proxy daemon is running and attach this client to it.
- * Returns the port the caller should use for its ProviderConfig.
- */
-export async function ensureDaemon(): Promise<number> {
-	if (ensuring) return attachedPort || PORT;
-	ensuring = true;
-	try {
-		const primary = await probeAndMaybeReplace(PORT, "proxy daemon");
-		if (primary !== null) {
-			await attachTo(primary);
-			return primary;
-		}
-
-		if (PORT !== LEGACY_PORT) {
-			const legacy = await probeAndMaybeReplace(LEGACY_PORT, "legacy proxy daemon");
-			if (legacy !== null) {
-				await attachTo(legacy);
-				return legacy;
-			}
-		}
-
-		if (isSpawnEnabled()) {
-			spawnDaemonProcess();
-			const ready = await waitForReady(PORT, DAEMON_READY_TIMEOUT_MS);
-			if (ready) {
-				const ver = await getDaemonVersion(PORT);
-				if (ver !== null && ver !== PKG_VERSION) {
-					if (await killStaleDaemon(PORT, ver, "proxy daemon")) {
-						spawnDaemonProcess();
-						const retryReady = await waitForReady(PORT, DAEMON_READY_TIMEOUT_MS);
-						if (retryReady) {
-							await attachTo(PORT);
-							return PORT;
-						}
-					} else if (await isProxyAlive(PORT)) {
-						await attachTo(PORT);
-						return PORT;
-					}
-				} else {
-					await attachTo(PORT);
-					return PORT;
-				}
-			} else {
-				logWarn("daemon spawn did not become ready — is the port blocked?");
-			}
-			return PORT;
-		}
-
-		try {
-			const r = await startProxy();
-			if (r.server) fallbackServer = r.server;
-			const port = r.port;
-			await attachTo(port);
-			return port;
-		} catch (e) {
-			logWarn("in-process fallback bind failed", { error: String(e) });
-			return PORT;
-		}
-	} finally {
-		ensuring = false;
-	}
-}
-
-export function getClientPort(): number {
-	return attachedPort || PORT;
-}
-
-export function getClientId(): string {
-	return CLIENT_ID;
-}
-
-export function _resetClientForTest(): void {
-	stopHeartbeatInternal();
-	heartbeatPort = 0;
-	attachedPort = 0;
-	ensuring = false;
-	if (fallbackServer) {
-		try {
-			fallbackServer.close();
-		} catch {}
-		fallbackServer = null;
-	}
-}
+/**
+ * Client-side daemon lifecycle for pi-freeflow.
+ *
+ * Every OMP/Pi session is a client. It attaches to the shared detached daemon
+ * at 127.0.0.1:28180 (or spawns one if none is alive), registers a lease, and
+ * renews it with a heartbeat while the session lives. When the session ends
+ * the heartbeat stops; the daemon drops the lease after its TTL and retires
+ * once no client holds a live lease and no request has been proxied recently.
+ */
+
+import { randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import type * as http from "node:http";
+import {
+	DAEMON_HEARTBEAT_MS,
+	DAEMON_HEARTBEAT_MS_ENV,
+	DAEMON_READY_TIMEOUT_MS,
+	DAEMON_SPAWN_ENV,
+	HOST,
+	LEGACY_PORT,
+	NO_KILL_ENV,
+	PKG_VERSION,
+	PORT,
+} from "./config.ts";
+import { logInfo, logWarn } from "./logger.ts";
+import {
+	getDaemonHealth,
+	getDaemonVersion,
+	isProxyAlive,
+	killPortHolder,
+	startProxy,
+} from "./proxy.ts";
+import { compareVersions } from "./update-checker.ts";
+
+const CLIENT_ID = randomUUID();
+
+let attachedPort = 0;
+let heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+let heartbeatPort = 0;
+let ensuring = false;
+let fallbackServer: http.Server | null = null;
+
+function isBunRuntime(): boolean {
+	return typeof (process.versions as unknown as Record<string, string>).bun === "string";
+}
+
+function daemonScriptPath(): string {
+	return path.join(path.dirname(fileURLToPath(import.meta.url)), "daemon.ts");
+}
+
+function getHeartbeatMs(): number {
+	const raw = process.env[DAEMON_HEARTBEAT_MS_ENV];
+	if (raw) {
+		const parsed = Number(raw);
+		if (Number.isFinite(parsed) && parsed > 0) return parsed;
+	}
+	return DAEMON_HEARTBEAT_MS;
+}
+
+function isSpawnEnabled(): boolean {
+	return process.env[DAEMON_SPAWN_ENV] !== "0";
+}
+
+type ControlResult = "ok" | "legacy" | "gone";
+
+async function controlCall(
+	port: number,
+	endpoint: string,
+	payload: Record<string, string>,
+): Promise<ControlResult> {
+	try {
+		const res = await fetch(`http://${HOST}:${port}${endpoint}`, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify(payload),
+			signal: AbortSignal.timeout(1500),
+		});
+		return res.ok ? "ok" : "legacy";
+	} catch {
+		return "gone";
+	}
+}
+
+function startHeartbeat(port: number): void {
+	stopHeartbeatInternal();
+	heartbeatPort = port;
+	const ms = getHeartbeatMs();
+	heartbeatTimer = setInterval(() => {
+		void beatOnce(port);
+	}, ms);
+	try {
+		heartbeatTimer.unref();
+	} catch {}
+}
+
+function stopHeartbeatInternal(): void {
+	if (heartbeatTimer !== null) {
+		clearInterval(heartbeatTimer);
+		heartbeatTimer = null;
+	}
+}
+
+export function stopHeartbeat(): void {
+	const port = heartbeatPort;
+	stopHeartbeatInternal();
+	heartbeatPort = 0;
+	if (port) {
+		void controlCall(port, "/_client/detach", { id: CLIENT_ID });
+	}
+	if (fallbackServer) {
+		try {
+			fallbackServer.close();
+		} catch {}
+		fallbackServer = null;
+	}
+}
+
+async function beatOnce(port: number): Promise<void> {
+	if (ensuring) return;
+	const result = await controlCall(port, "/_client/heartbeat", { id: CLIENT_ID });
+	if (result === "gone") {
+		void ensureDaemon();
+	}
+}
+
+async function attachTo(port: number): Promise<void> {
+	attachedPort = port;
+	const result = await controlCall(port, "/_client/attach", { id: CLIENT_ID });
+	if (result === "gone") {
+		return;
+	}
+	startHeartbeat(port);
+}
+
+async function shouldReplaceDaemon(port: number, remoteVer: string): Promise<boolean> {
+	if (NO_KILL_ENV && process.env[NO_KILL_ENV] === "1") {
+		logInfo(
+			`Reusing existing pi-freeflow proxy daemon on http://${HOST}:${port} (replacement disabled by env)`,
+		);
+		return false;
+	}
+	if (compareVersions(remoteVer, PKG_VERSION) > 0) {
+		logInfo(
+			`Reusing existing pi-freeflow proxy daemon on http://${HOST}:${port} (newer daemon v${remoteVer} left running)`,
+		);
+		return false;
+	}
+	const health = await getDaemonHealth(port);
+	if (health === null || health.activeRequests === undefined) {
+		logInfo(
+			`Reusing existing pi-freeflow proxy daemon on http://${HOST}:${port} (cannot verify usage — leaving the running daemon untouched)`,
+		);
+		return false;
+	}
+	if (health.activeRequests > 0) {
+		logInfo(
+			`Reusing existing pi-freeflow proxy daemon on http://${HOST}:${port} (${health.activeRequests} active request${health.activeRequests === 1 ? "" : "s"} — not interrupted)`,
+		);
+		return false;
+	}
+	return true;
+}
+
+async function killStaleDaemon(
+	port: number,
+	remoteVer: string,
+	what: string,
+): Promise<boolean> {
+	if (!(await shouldReplaceDaemon(port, remoteVer))) return false;
+	logWarn(`stale ${what} v${remoteVer} on :${port} (need v${PKG_VERSION}) — replacing`, {
+		remoteVer,
+		expected: PKG_VERSION,
+	});
+	await killPortHolder(port);
+	for (let i = 0; i < 10; i++) {
+		await new Promise<void>((r) => setTimeout(r, 200));
+		if (!(await isProxyAlive(port))) return true;
+	}
+	logInfo(
+		`Reusing existing pi-freeflow proxy daemon on http://${HOST}:${port} (stale kill did not free port)`,
+	);
+	return false;
+}
+
+let lastSpawnAt = 0;
+const SPAWN_THROTTLE_MS = 2_000;
+
+function spawnDaemonProcess(): void {
+	const now = Date.now();
+	if (now - lastSpawnAt < SPAWN_THROTTLE_MS) {
+		logWarn("daemon spawn throttled — recent spawn still pending");
+		return;
+	}
+	lastSpawnAt = now;
+	const script = daemonScriptPath();
+	const args = isBunRuntime() ? [script] : ["--experimental-strip-types", script];
+	try {
+		const child = spawn(process.execPath, args, {
+			detached: true,
+			stdio: "ignore",
+			windowsHide: true,
+		});
+		child.unref();
+		child.on("error", (err) => {
+			logWarn("daemon spawn failed", { error: String(err) });
+		});
+	} catch (e) {
+		logWarn("daemon spawn failed", { error: String(e) });
+	}
+}
+
+async function waitForReady(port: number, timeoutMs: number): Promise<boolean> {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		if (await isProxyAlive(port)) return true;
+		await new Promise<void>((r) => setTimeout(r, 200));
+	}
+	return false;
+}
+
+async function probeAndMaybeReplace(
+	port: number,
+	label: string,
+): Promise<number | null> {
+	if (!(await isProxyAlive(port))) return null;
+	const ver = await getDaemonVersion(port);
+	if (ver !== null && ver !== PKG_VERSION) {
+		if (await killStaleDaemon(port, ver, label)) {
+			return null;
+		}
+		if (await isProxyAlive(port)) return port;
+		return null;
+	}
+	return port;
+}
+
+/**
+ * Ensure a proxy daemon is running and attach this client to it.
+ * Returns the port the caller should use for its ProviderConfig.
+ */
+export async function ensureDaemon(): Promise<number> {
+	if (ensuring) return attachedPort || PORT;
+	ensuring = true;
+	try {
+		const primary = await probeAndMaybeReplace(PORT, "proxy daemon");
+		if (primary !== null) {
+			await attachTo(primary);
+			return primary;
+		}
+
+		if (PORT !== LEGACY_PORT) {
+			const legacy = await probeAndMaybeReplace(LEGACY_PORT, "legacy proxy daemon");
+			if (legacy !== null) {
+				await attachTo(legacy);
+				return legacy;
+			}
+		}
+
+		if (isSpawnEnabled()) {
+			spawnDaemonProcess();
+			const ready = await waitForReady(PORT, DAEMON_READY_TIMEOUT_MS);
+			if (ready) {
+				const ver = await getDaemonVersion(PORT);
+				if (ver !== null && ver !== PKG_VERSION) {
+					if (await killStaleDaemon(PORT, ver, "proxy daemon")) {
+						spawnDaemonProcess();
+						const retryReady = await waitForReady(PORT, DAEMON_READY_TIMEOUT_MS);
+						if (retryReady) {
+							await attachTo(PORT);
+							return PORT;
+						}
+					} else if (await isProxyAlive(PORT)) {
+						await attachTo(PORT);
+						return PORT;
+					}
+				} else {
+					await attachTo(PORT);
+					return PORT;
+				}
+			} else {
+				logWarn("daemon spawn did not become ready — is the port blocked?");
+			}
+			return PORT;
+		}
+
+		try {
+			const r = await startProxy();
+			if (r.server) fallbackServer = r.server;
+			const port = r.port;
+			await attachTo(port);
+			return port;
+		} catch (e) {
+			logWarn("in-process fallback bind failed", { error: String(e) });
+			return PORT;
+		}
+	} finally {
+		ensuring = false;
+	}
+}
+
+export function getClientPort(): number {
+	return attachedPort || PORT;
+}
+
+export function getClientId(): string {
+	return CLIENT_ID;
+}
+
+export function _resetClientForTest(): void {
+	stopHeartbeatInternal();
+	heartbeatPort = 0;
+	attachedPort = 0;
+	ensuring = false;
+	lastSpawnAt = 0;
+	if (fallbackServer) {
+		try {
+			fallbackServer.close();
+		} catch {}
+		fallbackServer = null;
+	}
+}

package/src/commands.ts

@@ -69,30 +69,31 @@ function spawnWithProgress(
 	args: string[],
 	ctx: ExtensionContext,
 ): Promise<number> {
-	return new Promise((resolve) => {
-		try {
-			const child = spawn(cmd, args, {
-				shell: process.platform === "win32",
-				stdio: "pipe",
-			});
-			child.stdout?.on("data", (d: Buffer) => {
-				const s = String(d).trim();
-				if (s) ctx.ui.notify(s, "info");
-			});
-			child.stderr?.on("data", (d: Buffer) => {
-				const s = String(d).trim();
-				if (s) ctx.ui.notify(s, "info");
-			});
-			child.on("error", (err: Error) => {
-				ctx.ui.notify(`spawn ${cmd} failed: ${err.message}`, "warning");
-				resolve(1);
-			});
-			child.on("close", (code: number | null) => resolve(code ?? 0));
-		} catch (e) {
-			ctx.ui.notify(`spawn ${cmd} failed: ${(e as Error).message}`, "warning");
+	const { promise, resolve } = Promise.withResolvers<number>();
+	try {
+		const child = spawn(cmd, args, {
+			shell: process.platform === "win32",
+			stdio: "pipe",
+			windowsHide: true,
+		});
+		child.stdout?.on("data", (d: Buffer) => {
+			const s = String(d).trim();
+			if (s) ctx.ui.notify(s, "info");
+		});
+		child.stderr?.on("data", (d: Buffer) => {
+			const s = String(d).trim();
+			if (s) ctx.ui.notify(s, "info");
+		});
+		child.on("error", (err: Error) => {
+			ctx.ui.notify(`spawn ${cmd} failed: ${err.message}`, "warning");
 			resolve(1);
-		}
-	});
+		});
+		child.on("close", (code: number | null) => resolve(code ?? 0));
+	} catch (e) {
+		ctx.ui.notify(`spawn ${cmd} failed: ${(e as Error).message}`, "warning");
+		resolve(1);
+	}
+	return promise;
 }
 
 /**

package/src/index.ts

@@ -1,7 +1,7 @@
 /**
  * pi-freeflow — Modular, high-resiliency LLM extension for Pi & Oh My Pi (OMP)
  *
- * Provides access to 28 free models (8 OpenCode Zen + 20 KiloCode Gateway) with:
+ * Provides access to 26 free models (8 OpenCode Zen + 18 KiloCode Gateway) with:
  * - Single-port daemon reuse on 28180 across concurrent subagents
  * - Multi-cloud rolling egress relays (Vercel Edge, Cloudflare, Deno)
  * - 0ms instant startup with verified static catalog and background live health checks
@@ -258,7 +258,7 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 						? `Relay pool ready: ${freshRelayState.relays.length} relay(s). Run /freeflow for pool management.`
 						: "Relay pool empty — direct mode. Run /freeflow deploy to add your own egress.";
 				ctx.ui?.notify?.(
-					`freeflow ready: 28 free models via local proxy 127.0.0.1:28180. ${hint}`,
+					`freeflow ready: ${ALL_MODELS.length} free models via local proxy 127.0.0.1:28180. ${hint}`,
 					"info",
 				);
 			}

package/src/models.ts

@@ -1,9 +1,9 @@
 /**
  * Static model definitions and upstream routing catalogs for pi-freeflow
  *
- * Defines the 28 verified free models:
- * - 8 OpenCode Zen models (1 Responses API + 7 Chat Completions)
- * - 20 KiloCode Keyless Gateway models (19 OpenRouter format + 1 Standard format)
+ * Defines the 26 verified free models:
+ * - 8 OpenCode Zen models (2 Responses API + 6 Chat Completions)
+ * - 18 KiloCode Keyless Gateway models (17 OpenRouter format + 1 Standard format)
  */
 
 import type { ModelDef, ThinkingLevelMap, Upstream } from "./types.ts";
@@ -31,35 +31,36 @@ export const OPENCODE_MODELS: ModelDef[] = [
 			max: null,},
 	},
 	{
-		id: "mimo-v2.5-free",
-		name: "MiMo V2.5 (1M)",
+		id: "muse-spark-1.3-contributor-free",
+		name: "Muse Spark 1.3 (1M)",
 		reasoning: true,
 		contextWindow: 1_048_576,
 		maxTokens: 131_072,
+		api: "openai-responses",
 		input: ["text", "image"],
 		thinkingLevelMap: {
 			off: null,
-			minimal: "low",
+			minimal: "minimal",
 			low: "low",
 			medium: "medium",
 			high: "high",
-			xhigh: "high",
+			xhigh: "xhigh",
 			max: null,},
 	},
 	{
-		id: "hy3-free",
-		name: "Hy3 (262K)",
+		id: "mimo-v2.5-free",
+		name: "MiMo V2.5 (1M)",
 		reasoning: true,
-		contextWindow: 262_144,
-		maxTokens: 128_000,
-		input: ["text"],
+		contextWindow: 1_048_576,
+		maxTokens: 131_072,
+		input: ["text", "image"],
 		thinkingLevelMap: {
 			off: null,
-			minimal: "minimal",
+			minimal: "low",
 			low: "low",
 			medium: "medium",
 			high: "high",
-			xhigh: "xhigh",
+			xhigh: "high",
 			max: null,},
 	},
 	{
@@ -226,16 +227,6 @@ export const KILO_MODELS: ModelDef[] = [
 		thinkingFormat: "openrouter",
 		thinkingLevelMap: KILO_REASONING_MAP,
 	},
-	{
-		id: "tencent/hy3:free",
-		name: "Tencent Hy3 (Kilo)",
-		reasoning: true,
-		contextWindow: 262_144,
-		maxTokens: 128_000,
-		input: ["text"],
-		thinkingFormat: "openrouter",
-		thinkingLevelMap: KILO_REASONING_MAP,
-	},
 	{
 		id: "cohere/north-mini-code:free",
 		name: "North Mini Code",
@@ -304,16 +295,6 @@ export const KILO_MODELS: ModelDef[] = [
 		maxTokens: 8_192,
 		input: ["text", "image"],
 	},
-{
-	id: "meituan/longcat-2.0-free",
-	name: "LongCat 2.0 (1M)",
-	reasoning: true,
-	contextWindow: 1_048_756,
-	maxTokens: 262_144,
-	input: ["text"],
-	thinkingFormat: "openrouter",
-	thinkingLevelMap: KILO_REASONING_MAP,
-},
 {
 	id: "minimax/minimax-m2.7:free",
 	name: "MiniMax M2.7 (free)",
@@ -384,14 +365,12 @@ export const MODEL_ALIASES: Record<string, string> = {
 	"north-mini-code": "cohere/north-mini-code:free",
 	"lfm-2.5": "liquid/lfm-2.5-2.6b:free",
 	"content-safety": "nvidia/nemotron-3.5-content-safety:free",
-	"longcat-2.0": "meituan/longcat-2.0-free",
 	"minimax-m2.7": "minimax/minimax-m2.7:free",
 	"minimax-m3": "minimax/minimax-m3:free",
 	"ling-3.0-flash-fin": "inclusionai/ling-3.0-flash-fin:free",
 	"inkling": "thinkingmachines/inkling:free",
 	"inkling-small": "thinkingmachines/inkling-small:free",
 	// provider-prefixed short aliases (slash-normalized)
-	"hy3:free": "tencent/hy3:free",
 	"laguna-s-2.1:free": "poolside/laguna-s-2.1:free",
 	"laguna-xs-2.1:free": "poolside/laguna-xs-2.1:free",
 	"kilo-auto": "kilo-auto/free",
@@ -417,7 +396,7 @@ export const KILO_MODEL_IDS = new Set<string>([
 ]);
 
 /**
- * Combined list of all 28 static free models (canonical)
+ * Combined list of all 26 static free models (canonical)
  */
 export const ALL_MODELS: ModelDef[] = [...OPENCODE_MODELS, ...KILO_MODELS];
 

package/src/proxy.ts

@@ -32,7 +32,7 @@ import { isDebugEnabled, log } from "./logger.ts";
 import { KILO_MODEL_IDS, resolveCanonicalModelId } from "./models.ts";
 // normalize removed — host pi-ai already normalizes thinking/reasoning before proxy
 import { checkRateLimit } from "./rate-limiter.ts";
-import { agent, canUseCustomDispatcher, relayFetch } from "./relay.ts";
+import { relayFetch } from "./relay.ts";
 import { getActiveRelayState } from "./relay-state.ts";
 import { pipeUpstreamStream } from "./stream-pipe.ts";
 import type { Upstream } from "./types.ts";
@@ -182,7 +182,11 @@ export async function killPortHolder(port: number): Promise<boolean> {
 	try {
 		if (process.platform === "win32") {
 			try {
-				const out = execSync(`netstat -ano | findstr :${port}`, { encoding: "utf8", timeout: 3000 }) as string;
+				const out = execSync(`netstat -ano | findstr :${port}`, {
+					encoding: "utf8",
+					timeout: 3000,
+					windowsHide: true,
+				}) as string;
 				for (const line of out.split("\n")) {
 					if (!line.includes("LISTENING")) continue;
 					if (!line.includes(`:${port}`)) continue;
@@ -191,7 +195,7 @@ export async function killPortHolder(port: number): Promise<boolean> {
 					if (!pid || !/^\d+$/.test(pid)) continue;
 					// Windows netstat report: 127.0.0.1:38180 ... LISTENING/PID
 					if (Number(pid) === process.pid) continue; // never self-kill
-					execSync(`taskkill /F /PID ${pid}`, { timeout: 3000, stdio: "ignore" });
+					execSync(`taskkill /F /PID ${pid}`, { timeout: 3000, stdio: "ignore", windowsHide: true });
 					return true;
 				}
 			} catch {}
@@ -641,7 +645,6 @@ export function startProxy(
 							headers: fwd,
 							body: directBody.length > 0 ? directBody : undefined,
 							signal: controller.signal,
-							...(canUseCustomDispatcher ? { dispatcher: agent } : {}),
 						} as unknown as RequestInit);
 						clearTimeout(timeoutId);
 						res.off("close", onClientClose);

package/src/relay.ts

@@ -4,20 +4,7 @@
 
 import { randomUUID } from "node:crypto";
 import { Buffer } from "node:buffer";
-import { Agent } from "undici";
 import { isDebugEnabled, log } from "./logger.ts";
-
-export const agent = new Agent({ keepAliveTimeout: 30_000 });
-/**
- * Node's global fetch runs on the node-process-bundled undici. Node 22/23
- * bundle undici 6.x/7.x whose dispatcher interface rejects an npm-undici 8.x
- * Agent passed as `dispatcher` (`invalid onRequestStart method`). Only attach
- * the custom dispatcher when the bundled undici major matches (Node 25+);
- * otherwise fall back to the built-in global dispatcher, which still pools
- * keep-alive connections, so the relay proxy works on Node 22/23 too.
- */
-const bundledUndiciMajor = Number((process.versions.undici ?? "0").split(".")[0]);
-export const canUseCustomDispatcher = bundledUndiciMajor >= 8;
 import {
 	getActiveRelayState,
 	getOrderedRelayUrls,
@@ -68,7 +55,7 @@ export async function relayFetch(
 
 	if (!relayState.enabled) {
 		log("debug", `relayFetch: direct (relay disabled) -> ${url}`, undefined, rid);
-		return fetch(url, { ...opts, ...(canUseCustomDispatcher ? { dispatcher: agent } : {}) } as unknown as RequestInit);
+		return fetch(url, opts as unknown as RequestInit);
 	}
 	const candidates = getOrderedRelayUrls();
 
@@ -76,7 +63,7 @@ export async function relayFetch(
 		// Empty pool: skip straight to upstream instead of logging a misleading
 		// "relays bypassed/exhausted" WARN on every request.
 		log("debug", `relayFetch: direct (empty relay pool) -> ${url}`, undefined, rid);
-		return fetch(url, { ...opts, ...(canUseCustomDispatcher ? { dispatcher: agent } : {}) } as unknown as RequestInit);
+		return fetch(url, opts as unknown as RequestInit);
 	}
 
 	let lastResponse: Response | null = null;
@@ -145,7 +132,7 @@ export async function relayFetch(
 			}
 
 			const signal = opts.signal || AbortSignal.timeout(300_000);
-			const res = await fetch(targetUrl, { ...opts, headers, signal, ...(canUseCustomDispatcher ? { dispatcher: agent } : {}) } as unknown as RequestInit);
+			const res = await fetch(targetUrl, { ...opts, headers, signal } as unknown as RequestInit);
 			const elapsed = ((Date.now() - attemptStart) / 1000).toFixed(1);
 			// Vercel 504 Gateway Timeout on heavy prompts (>50KB or >25s):
 			// Fast fallback directly to upstream instead of cycling through multiple 25s timeouts.
@@ -251,7 +238,7 @@ export async function relayFetch(
 		directHeaders.set("host", u.host);
 		directHeaders.set("x-request-id", rid);
 
-		const directRes = await fetch(url, { ...opts, headers: directHeaders, ...(canUseCustomDispatcher ? { dispatcher: agent } : {}) } as unknown as RequestInit);
+		const directRes = await fetch(url, { ...opts, headers: directHeaders } as unknown as RequestInit);
 		// lastResponse holds an unread body that would otherwise leak its socket
 		// until GC; the salvage path below still needs it, so only cancel here.
 		lastResponse?.body?.cancel().catch(() => {});