pi-freeflow 1.36.3 → 1.37.1

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 1.37.1
+
+### Patch Changes
+
+- **DeepSeek V4.1 Flash (`deepseek-v4.1-flash-free`)**: Added to the OpenCode Zen lane (catalog 34 → 35 models). Configured with full **1,000,000 context window**, **384,000 max output tokens**, vision support (`input: ["text", "image"]`), and reasoning ladder (`minimal..max`).
+- **Sources of Truth & Highest-Spec Twin Policy**: Documented model reconciliation against [models.dev](https://models.dev/), [OpenRouter](https://openrouter.ai/), and OMP's built-in catalog, ensuring models are configured to the highest capability across twin models rather than artificially truncated limits.
+- **Automated OpenCode Model Health Bot**: Added dedicated GitHub Actions workflow and probe engine to continuously detect affected or degraded OpenCode free-tier models.
+
+## 1.37.0
+
+### Minor Changes
+
+- **Auto-Update Capability**: Added the `/freeflow autoupdate on|off` command (and `/freeflow update auto on|off`). When enabled, background update checks automatically download and install new versions, seamlessly restarting the proxy daemon.
+- **Automatic Daemon Recovery on Version Mismatch**: When the client detects an outdated running proxy daemon (or after an update), it automatically stops the stale daemon and restarts with the current package version, eliminating manual intervention and stale port locks.
+- **Documentation Sync**: Synchronized all documentation, specs, and routing tables to reflect the 34 verified free models across OpenCode Zen (10), KiloCode Gateway (14), Cline (2), and OVHcloud AI Endpoints (8).
+- **Self-Hosted VPS Relay Option**: Added setup guidance and documentation for self-hosting an egress relay pool on a VPS using [trefeon/warp-relay-pool](https://github.com/trefeon/warp-relay-pool).
+
 ## 1.36.3
 
 ### Patch Changes

package/README.md

@@ -1,6 +1,6 @@
 # pi-freeflow
 
-> 37 free models with up to 1M context. No API keys to manage. Add your own relays to spread requests across more IPs.
+> 35 free models with up to 1M context. No API keys to manage. Add your own relays to spread requests across more IPs.
 
 Thin by design: a model list, a relay proxy, and a log. The host (`pi-ai`) handles thinking, normalization, and provider behavior.
 
@@ -16,7 +16,7 @@ Thin by design: a model list, a relay proxy, and a log. The host (`pi-ai`) handl
 
 | Feature | What it does | Cost |
 | :--- | :--- | :--- |
-| **37 free models** | 11 from OpenCode Zen, 15 from KiloCode Gateway, 2 from Cline, 9 from OVHcloud AI Endpoints, context windows up to 1M. Full list below. | **$0** |
+| **35 free models** | 11 from OpenCode Zen, 14 from KiloCode Gateway, 2 from Cline, 8 from OVHcloud AI Endpoints, context windows up to 1M. Full list below. | **$0** |
 | **Relay pool** | Route requests through your own Cloudflare Workers, Deno Deploy, and Vercel Edge relays. Traffic spreads across the pool, or stays on one sticky relay. A relay that rate-limits, times out, or drops the connection cools down while healthy ones take its traffic. | **$0** beyond your platforms' free tiers |
 | **Automatic fallback** | When every relay is cooling down, requests go direct to upstream instead of failing. | **$0** |
 | **Short model names** | Most models have a slash-free, colon-free alias, plus an optional `:effort` suffix for thinking depth. You type `freeflow/<name>`; the two Cline models have no alias and must be typed in full. | **$0** |
@@ -108,6 +108,18 @@ For `api/relay.js`, use the canonical worker source (see below); `vercel.json` s
 { "rewrites": [{ "source": "/(.*)", "destination": "/api/relay" }] }
 ```
 
+**Option D: Self-Hosted WARP Relay on VPS (1GB VPS friendly)**
+
+If you have a Linux VPS (even a low-spec 1GB RAM instance), you can self-host a dedicated egress relay pool using [trefeon/warp-relay-pool](https://github.com/trefeon/warp-relay-pool):
+- **1GB VPS friendly**: Lightweight footprint designed to run comfortably on low-resource VPS nodes.
+- **Rotating Cloudflare WARP egress**: Automatically rotates outbound IPs so upstream rate limits don't block your sessions.
+- **Full protocol compatibility**: Implements the `x-relay-target` contract used by pi-freeflow.
+
+Once deployed on your VPS, register it in your relay pool:
+```bash
+/freeflow add https://your-vps:port vps-warp-relay
+```
+
 **Canonical worker source (all platforms)**
 
 The relay worker template is generated per deployment by `/freeflow deploy`, with one shared core adapted for Vercel, Cloudflare, and Deno. Every deploy embeds a random 32-byte secret, and the generated worker answers `401` to any request without a matching `x-relay-auth` header; the client sends that secret to each relay in the pool. Only a hand-pasted legacy worker built without a secret is open to anyone. Either way, a relay forwards only to an allowlist (`https://opencode.ai`, `https://api.kilo.ai`) with private-host and path checks.
@@ -185,12 +197,13 @@ The same command set works identically in OMP and Pi:
 
 ---
 
-### 37 models, one command
+### 35 models, one command
 
 ```bash
 /model → freeflow → pick
 ```
 
+Every model specification is reconciled against [models.dev](https://models.dev/), [OpenRouter](https://openrouter.ai/), and OMP's built-in catalog, configured with the highest verified context, output ceiling, and reasoning capabilities across twin models.
 #### OpenCode Zen (11 models), Responses and Chat API
 
 Good defaults for long coding sessions and agentic work.
@@ -207,9 +220,9 @@ Good defaults for long coding sessions and agentic work.
 | `space-bunny-free` | Stealth preview (lab undisclosed) | **1M** (1.048.576) | **512K** (524.288) | `low … max` | ✅ |
 | `longcat-2.5-preview-free` | Meituan LongCat | **1M** (1.000.000) | **131K** (131.072) | `minimal … max` | ✅ |
 | `step-5-preview-free` | StepFun | **1M** (1.000.000) | **64K** (65.536) | `low … high` | ✅ |
-| `ling-3.1-flash-free` | Inclusion AI | **262K** (262.144) | **32K** (32.768) | `minimal … max` | ❌ |
+| `deepseek-v4.1-flash-free` | DeepSeek | **1M** (1.000.000) | **384K** (384.000) | `minimal … max` | ✅ |
 
-#### KiloCode Gateway (15 models), OpenRouter compatible
+#### KiloCode Gateway (14 models), OpenRouter compatible
 
 Keyless access. Short aliases work for every row (the full ID is in parentheses).
 
@@ -229,7 +242,6 @@ Keyless access. Short aliases work for every row (the full ID is in parentheses)
 | `glyph-cluster` (`stealth/glyph-cluster`) | Stealth preview (lab undisclosed) | **256K** (256.000) | **256K** (256.000) | `minimal…xhigh`\* | ❌ |
 | `step-5-preview:kilo` (`stepfun/...:free`) | StepFun | **1M** (1.000.000) | **64K** (65.536) | `minimal…xhigh`\* | ✅ |
 | `inkling-small` (`thinkingmachines/inkling-small:free`) | Thinking Machines | **1M** (1.048.576) | **262K** (262.144) | `minimal…xhigh`\* | ✅ |
-| `ling-3.1-flash:kilo` (`inclusionai/ling-3.1-flash`) | Inclusion AI | **262K** (262.144) | **32K** (32.768) | `minimal…xhigh`\* | ❌ |
 
 \* 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.
 
@@ -245,13 +257,13 @@ Each account can only be saved once: an extra login for an account you already h
 | :--- | :--- | :--- | :--- | :--- | :--- |
 | `cline-free/muse-spark-1.3-contributor` | Meta Superintelligence Labs | **1M** (1.048.576) | **131K** (131.072) | `minimal…xhigh`\* | ✅ |
 | `z-ai/glm-5.3-flash` | Zhipu AI | **1M** (1.048.576) | **131K** (131.072) | `low/high/max` | ✅ |
-
+#### OVHcloud AI Endpoints (8 models), OpenAI compatible
 #### OVHcloud AI Endpoints (9 models), OpenAI compatible
 
 Anonymous access — no account, no key, nothing to sign in to. Direct only (never through the relay pool), because OVH has no per-IP gate for relays to route around. OVH rate-limits anonymous callers per IP, so a burst of parallel subagents can hit `429 API rate limit exceeded`; the model list itself never costs anything.
 
 Pick them with the slash-free short name (the full ID is in parentheses). Only `low` and `high` thinking levels are offered, because those are the two OVH confirmed.
-
+All eight talk the normal chat API. Hosts that prefer the responses API work too — the proxy maps that shape to chat and maps the answer back, so tool calls and streamed output behave exactly as they do on the other providers.
 All nine talk the normal chat API. Hosts that prefer the responses API work too — the proxy maps that shape to chat and maps the answer back, so tool calls and streamed output behave exactly as they do on the other providers.
 
 | Model ID | Creator / Lab | Context | Max Output | Thinking | Vision |
@@ -262,7 +274,6 @@ All nine talk the normal chat API. Hosts that prefer the responses API work too
 | `qwen3.5-9b` (`ovh-free/Qwen3.5-9B`) | Alibaba Qwen | **256K** (262.144) | **64K** (65.536) | `low/high` | ✅ |
 | `qwen3.6-27b` (`ovh-free/Qwen3.6-27B`) | Alibaba Qwen | **256K** (262.144) | **64K** (65.536) | `low/high` | ✅ |
 | `qwen3.8-27b` (`ovh-free/Qwen3.8-27B`) | Alibaba Qwen | **256K** (262.144) | **32K** (32.768) | `low/high` | ✅ |
-| `mistral-small-3.2` (`ovh-free/Mistral-Small-3.2-24B-Instruct-2506`) | Mistral AI | **128K** (131.072) | **16K** (16.384) | ❌ | ✅ |
 | `mistral-7b-v0.3` (`ovh-free/Mistral-7B-Instruct-v0.3`) | Mistral AI | **64K** (65.536) | **64K** (65.536) | ❌ | ❌ |
 | `llama-3.3-70b` (`ovh-free/Meta-Llama-3_3-70B-Instruct`) | Meta | **128K** (131.072) | **16K** (16.384) | ❌ | ❌ |
 
@@ -357,7 +368,7 @@ pnpm smoke       # verifies extensions/index.ts loads without crashing
 #### Project structure
 
 ```
-src/
+├── models.ts                # 34-model catalog definitions
 ├── index.ts                 # extension entry, lifecycle hooks
 ├── models.ts                # 37-model catalog definitions
 ├── catalog.ts               # model catalog cache (24h disk)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-freeflow",
   "type": "module",
-  "version": "1.36.3",
+  "version": "1.37.1",
   "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",

package/src/client.ts

@@ -32,7 +32,6 @@ import {
  DAEMON_WATCHDOG_MS,
  DAEMON_WATCHDOG_MS_ENV,
  HOST,
- LEGACY_PORT,
  LOG_FILE,
  NO_KILL_ENV,
  OPENCODE_VERSION_TTL_MS,
@@ -198,7 +197,8 @@ export function resolveDaemonRuntime(opts?: {
 }
 
 function daemonScriptPath(): string {
- return path.join(path.dirname(fileURLToPath(import.meta.url)), "daemon.ts");
+	const p = path.join(path.dirname(fileURLToPath(import.meta.url)), "daemon.ts");
+	return process.platform === "win32" ? p.replace(/\\/g, "/") : p;
 }
 
 function getHeartbeatMs(): number {
@@ -581,17 +581,19 @@ async function killStaleDaemon(
   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;
+	await killPortHolder(port);
+	for (let i = 0; i < 15; i++) {
+		await new Promise<void>((r) => setTimeout(r, 100));
+		if (!(await isProxyAlive(port))) {
+			lastSpawnAt = 0;
+			return true;
+		}
+	}
+	logInfo(
+		`Reusing existing pi-freeflow proxy daemon on http://${HOST}:${port} (stale kill did not free port)`,
+	);
+	return false;
 }
-
 /**
  * Open the shared log file for the detached daemon's stdout/stderr so a
  * native abort or crash leaves its reason on disk instead of vanishing into
@@ -770,28 +772,28 @@ function spawnDaemonProcess(): boolean {
 }
 
 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;
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		if (await isProxyAlive(port, 150)) return true;
+		await new Promise<void>((r) => setTimeout(r, 80));
+	}
+	return false;
 }
 
 async function probeAndMaybeReplace(
- port: number,
- label: string,
+	port: number,
+	label: string,
+	probeTimeoutMs = 150,
 ): 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;
+	if (!(await isProxyAlive(port, probeTimeoutMs))) return null;
+	const ver = await getDaemonVersion(port);
+	if (ver !== null && ver !== PKG_VERSION) {
+		logWarn(`detected proxy daemon version mismatch: running v${ver}, required v${PKG_VERSION} — auto-restarting`);
+		await killStaleDaemon(port, ver, label);
+		lastSpawnAt = 0;
+		return null;
+	}
+	return port;
 }
 
 /**
@@ -808,24 +810,9 @@ export async function ensureDaemon(): Promise<number> {
    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()) {
-   // Cross-process race guard: a sibling session may be spawning right
-   // now (singleflight is per-process). Jitter + re-probe converts most
-   // cold-start races into attach instead of N detached spawns.
-   await new Promise<void>((r) => setTimeout(r, 100 + Math.random() * 200));
-   if (await isProxyAlive(PORT)) {
-    await attachTo(PORT);
-    return PORT;
-   }
-   const spawned = spawnDaemonProcess();
+		if (isSpawnEnabled()) {
+			const spawned = spawnDaemonProcess();
    if (spawned) {
     const ready = await waitForReady(PORT, DAEMON_READY_TIMEOUT_MS);
     if (ready) {

package/src/commands.ts

@@ -36,6 +36,7 @@ import {
  saveDebugState,
 } from "./logger.ts";
 import { probeRelay } from "./probe.ts";
+import { killPortHolder } from "./proxy.ts";
 import { getUpstreamHealth, resetUpstreamGate } from "./upstream-health.ts";
 import {
  buildRelayExport,
@@ -515,7 +516,7 @@ export function createCommandSpec(
 ): Omit<RegisteredCommand, "name"> {
  return {
   description:
-   "Relay egress: auto | spread | on | off | hide | show | widget hide/show | status | add <URL> [name] | list | use <URL|name|index> [name] | label <target> <name> | remove <target> | test [target|opencode] [--chat] | export [path] [--include-secrets] | import <path> [--merge|--replace] [--dry-run] | logs [level] [n] | debug on|off | refresh | update | deploy cloudflare | deploy deno | deploy vercel | install-startup | uninstall-startup | cline login [--key] [slot] | cline accounts | cline logout [slot]",
+   "Relay egress: auto | spread | on | off | hide | show | widget hide/show | status | add <URL> [name] | list | use <URL|name|index> [name] | label <target> <name> | remove <target> | test [target|opencode] [--chat] | export [path] [--include-secrets] | import <path> [--merge|--replace] [--dry-run] | logs [level] [n] | debug on|off | refresh | update [auto on|off] | autoupdate [on|off] | deploy cloudflare | deploy deno | deploy vercel | install-startup | uninstall-startup | cline login [--key] [slot] | cline accounts | cline logout [slot]",
   getArgumentCompletions: (prefix: string) =>
    [
     "auto",
@@ -537,6 +538,12 @@ export function createCommandSpec(
     "test",
     "test opencode",
     "url",
+    "autoupdate",
+    "autoupdate on",
+    "autoupdate off",
+    "update auto",
+    "update auto on",
+    "update auto off",
     "deploy",
     "deploy cloudflare",
     "deploy deno",
@@ -1173,7 +1180,7 @@ export function createCommandSpec(
     const deadLine = deadParked.length
      ? `\nDead relays (HTTP 402 disabled deployment, parked): ${deadParked.map((r) => r.url).join(", ")} — delete the Vercel project, run /freeflow remove <url>, then deploy Cloudflare`
      : "";
-    ctx.ui.notify(`${modeLine} | ${poolLine}\n${stateFileLine}\nUpstream: ${upstreamLine}\n${clineLine}${deadLine}`, "info");
+    ctx.ui.notify(`${modeLine} | ${poolLine} | auto-update: ${relayState.autoUpdate ? "on" : "off"}\n${stateFileLine}\nUpstream: ${upstreamLine}\n${clineLine}${deadLine}`, "info");
    } else if (sub === "kill" || sub === "stop" || sub === "shutdown") {
     const port = getClientPort() || PORT;
     try {
@@ -1189,6 +1196,20 @@ export function createCommandSpec(
     } catch {
      ctx.ui.notify("Daemon not running or not reachable", "warning");
     }
+   } else if (sub === "autoupdate" || (sub === "update" && rest.trim().toLowerCase().startsWith("auto"))) {
+    const arg = sub === "autoupdate"
+     ? rest.trim().toLowerCase()
+     : rest.trim().slice(4).trim().toLowerCase();
+    if (arg === "on" || arg === "enable" || arg === "true" || arg === "1") {
+     withRelayState((s) => { s.autoUpdate = true; return s; });
+     ctx.ui.notify("Auto-update enabled (new versions will be installed automatically).", "info");
+    } else if (arg === "off" || arg === "disable" || arg === "false" || arg === "0") {
+     withRelayState((s) => { s.autoUpdate = false; return s; });
+     ctx.ui.notify("Auto-update disabled.", "info");
+    } else {
+     const current = loadRelayState().autoUpdate ? "ON" : "OFF";
+     ctx.ui.notify(`Auto-update is currently ${current}. Use '/freeflow autoupdate on|off'`, "info");
+    }
    } else if (sub === "update") {
     if (isLinkedInstall()) {
      ctx.ui.notify(
@@ -1250,7 +1271,8 @@ export function createCommandSpec(
          }
         }
         if (code === 0) {
-         ctx.ui.notify(`Updated to ${latest} — restart your host app`, "info");
+         try { await killPortHolder(PORT); } catch { }
+         ctx.ui.notify(`Updated to ${latest} and restarted proxy daemon`, "info");
         } else {
          ctx.ui.notify(
           `Update failed (exit ${code}) — try manually: ${manual}`,
@@ -1844,7 +1866,7 @@ export function createCommandSpec(
      const pf = parseDeployPlatform(rest);
      if (!pf) {
       ctx.ui.notify(
-       "Unknown platform. Use: cloudflare | deno | vercel",
+       "Unknown platform. Use: cloudflare | deno | vercel (for self-hosted VPS, see https://github.com/trefeon/warp-relay-pool)",
        "warning",
       );
      } else {

package/src/config.ts

@@ -45,7 +45,6 @@ export const OVH_CHAT_URL = `${OVH_API_BASE}/chat/completions`;
 
 // ── Network & Server defaults ───────────────────────────────────────
 export const DEFAULT_PORT = 28180;
-export const LEGACY_PORT = 18080;
 export const HOST = "127.0.0.1";
 
 export function resolvePort(): number {

package/src/index.ts

@@ -1,7 +1,7 @@
 /**
  * pi-freeflow — Modular, high-resiliency LLM extension for Pi & Oh My Pi (OMP)
  *
- * Provides access to 37 free models (11 OpenCode Zen + 15 KiloCode Gateway + 2 Cline + 9 OVH) with:
+ * Provides access to 35 free models (11 OpenCode Zen + 14 KiloCode Gateway + 2 Cline + 8 OVH) 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

package/src/models.ts

@@ -1,8 +1,8 @@
 /**
  * Static model definitions and upstream routing catalogs for pi-freeflow
  *
- * Defines the 34 verified free models (live-verified 2026-10-15):
- * - 10 OpenCode Zen models (2 Responses API + 8 Chat Completions)
+ * Defines the 35 verified free models (live-verified 2026-10-15):
+ * - 11 OpenCode Zen models (2 Responses API + 9 Chat Completions)
  * - 14 KiloCode Keyless Gateway models (OpenRouter format)
  * - 2 Cline direct-only models (per-user pool)
  * - 8 OVHcloud AI Endpoints models (keyless, direct-only)
@@ -200,6 +200,40 @@ export const OPENCODE_MODELS: ModelDef[] = [
   max: null,
  },
  },
+{
+  // Added 2026-10-15: new free model on the OpenCode Zen lane. Live-verified by
+  // probe, NOT copied from the published catalog — the entry for this exact
+  // free id claims 200,000 context, which the gateway contradicts (see below).
+  id: "deepseek-v4.1-flash-free",
+  name: "DeepSeek V4.1 Flash [OpenCode]",
+  reasoning: true,
+  // 1,048,576 measured, not assumed: a marker planted mid-prompt is still
+  // recalled through prompt_tokens=1,030,800, and the gateway turns an
+  // oversized request away with an empty-bodied 400 somewhere above ~1.05M.
+  // The published 200k belongs to the paid deepseek-v4-flash-free, a different
+  // model with a confusingly similar name. Acceptance is not capability; here
+  // the two agree, which is why this is the declared number.
+  contextWindow: 1_000_000,
+  // 384,000 output tokens per https://models.dev/models/deepseek/deepseek-v4.1-flash/
+  // and live gateway boundary probe (gateway accepts up to 393,216 = 384KiB, rejects 393,217+ with 400).
+  maxTokens: 384_000,
+  // Chat Completions only — a Responses-shaped request is refused with
+  // 400 ModelProtocolUnsupported. `api` left unset, which means chat.
+  input: ["text", "image"],
+  // Vision verified live (a 1x1 PNG reads back as "Pink"). Video is not
+  // advertised for this model upstream, so it is not offered here.
+  // Every effort level is accepted and visibly changes reasoning length, so
+  // the whole ladder stays selectable; `off` is always null.
+  thinkingLevelMap: {
+   off: null,
+   minimal: "minimal",
+   low: "low",
+   medium: "medium",
+   high: "high",
+   xhigh: "xhigh",
+   max: "max",
+  },
+},
 ];
 
 /**
@@ -589,6 +623,7 @@ export const MODEL_ALIASES: Record<string, string> = {
  "longcat-2.5-preview": "longcat-2.5-preview-free",
  "longcat": "longcat-2.5-preview-free",
  "step-5-preview": "step-5-preview-free",
+ "deepseek-v4.1-flash": "deepseek-v4.1-flash-free",
  // provider-prefixed short aliases (slash-normalized)
  "laguna-s-2.1:free": "poolside/laguna-s-2.1:free",
  "laguna-xs-2.1:free": "poolside/laguna-xs-2.1:free",

package/src/proxy.ts

@@ -687,48 +687,6 @@ async function handleKiloRequest(opts: {
  }
 }
 
-/**
- * In-flight auto-recovery for Zen 403 FreeTierError: immediately fail over
- * the current request to a healthy Kilo model instead of surfacing 403 to the caller.
- * Returns true when recovery was dispatched; false when failover is impossible.
- */
-async function tryZenGateAutoFailover(opts: {
- parsedBody: Record<string, unknown> | null;
- pathname: string;
- req: http.IncomingMessage;
- res: http.ServerResponse;
- reqId: string;
- clientRequestedStream: boolean;
- sessionKey?: string | null;
-}): Promise<boolean> {
- const { parsedBody, pathname, req, res, reqId, clientRequestedStream, sessionKey } = opts;
- if (!parsedBody || res.headersSent || res.writableEnded) return false;
- const fallbackModel = pickFailoverModel(parsedBody.model);
- if (!fallbackModel) return false;
- try {
-  const fromModel = String(parsedBody.model ?? "?");
-  parsedBody.model = fallbackModel;
-  if (pathname.endsWith("/responses")) {
-   prepareResponsesFailoverBody(parsedBody);
-  } else {
-   prepareChatFailoverBody(parsedBody);
-  }
-  log("warn", `zen 403 FreeTierError auto-fixed: failing over ${fromModel} -> ${fallbackModel}`, { model: fromModel, failover: fallbackModel }, reqId);
-  await handleKiloRequest({
-   parsedBody,
-   pathname,
-   req,
-   res,
-   reqId,
-   clientRequestedStream,
-   sessionKey,
-  });
-  return true;
- } catch (err) {
-  log("warn", `zen 403 FreeTierError auto-failover failed: ${String(err)}`, { error: String(err) }, reqId);
-  return false;
- }
-}
 
 /**
  * Relay eligibility: only free-catalog models ride relay egress. Returns true
@@ -981,31 +939,42 @@ function killViaProcNet(port: number): boolean {
 
 export async function killPortHolder(port: number): Promise<boolean> {
  if (!Number.isInteger(port) || port < 1 || port > 65535) return false;
- try {
-  if (process.platform === "win32") {
-   try {
-    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;
-     const parts = line.trim().split(/\s+/);
-     // Match the port on the Local Address column only — a raw
-     // substring match can hit longer ports (:2818 vs :28180).
-     if (!parts[1] || !parts[1].endsWith(`:${port}`)) continue;
-     const pid = parts[parts.length - 1];
-     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", windowsHide: true });
-     return true;
-    }
-   } catch { }
-   return false;
-  }
-  try {
+	try {
+		try {
+			await fetch(`http://${HOST}:${port}/_shutdown`, {
+				method: "POST",
+				signal: AbortSignal.timeout(300),
+			});
+			for (let i = 0; i < 6; i++) {
+				await new Promise<void>((r) => setTimeout(r, 50));
+				if (!(await isProxyAlive(port))) return true;
+			}
+		} catch { }
+		if (process.platform === "win32") {
+			try {
+				const out = execSync(`netstat -ano | findstr :${port}`, {
+					encoding: "utf8",
+					timeout: 3000,
+					windowsHide: true,
+				}) as string;
+				let killed = false;
+				for (const line of out.split("\n")) {
+					if (!line.includes("LISTENING")) continue;
+					const parts = line.trim().split(/\s+/);
+					if (!parts[1] || !parts[1].endsWith(`:${port}`)) continue;
+					const pid = parts[parts.length - 1];
+					if (!pid || !/^\d+$/.test(pid)) continue;
+					if (Number(pid) === process.pid) continue; // never self-kill
+					try {
+						execSync(`taskkill /F /T /PID ${pid}`, { timeout: 3000, stdio: "ignore", windowsHide: true });
+						killed = true;
+					} catch { }
+				}
+				if (killed) return true;
+			} catch { }
+			return false;
+		}
+		try {
    const out = execSync(`lsof -ti tcp:${port} 2>/dev/null || fuser -n tcp ${port} 2>/dev/null`, {
     encoding: "utf8",
     timeout: 3000,
@@ -1715,18 +1684,6 @@ export function startProxy(
           log("warn", `upstream ${response.status} for model ${String((parsedBody as Record<string, unknown> | null)?.model ?? "?")} via ${servedRelay === "direct" ? "direct upstream" : `relay ${servedRelay}`}`, { status: response.status, model: (parsedBody as Record<string, unknown> | null)?.model, path: req.url, relay: servedRelay }, reqId);
          }
          let rawText = await response.text();
-         if (response.status === 403 && isFreeTierGate(403, rawText)) {
-          const recovered = await tryZenGateAutoFailover({
-           parsedBody: parsedBody as Record<string, unknown> | null,
-           pathname: target.pathname,
-           req,
-           res,
-           reqId,
-           clientRequestedStream,
-           sessionKey,
-          });
-          if (recovered) return;
-         }
          let ct =
           response.headers.get("content-type") ||
           "application/json";
@@ -1885,22 +1842,8 @@ export function startProxy(
       // Gated upstream: a 403 free-tier gate is a final answer, not a
       // stream — buffer it and attach the recovery hint instead of
       // piping it through as a stream body.
-      // Gated upstream: a 403 free-tier gate is auto-recovered via Kilo failover.
-      // If failover is impossible, buffer it and attach the recovery hint.
-      if (upstreamRes.status === 403) {
-       const rawText403 = await upstreamRes.text();
-       if (isFreeTierGate(403, rawText403)) {
-        const recovered = await tryZenGateAutoFailover({
-         parsedBody: parsedBody as Record<string, unknown> | null,
-         pathname: target.pathname,
-         req,
-         res,
-         reqId,
-         clientRequestedStream,
-         sessionKey,
-        });
-        if (recovered) return;
-       }
+     if (upstreamRes.status === 403) {
+      const rawText403 = await upstreamRes.text();
        const data = withFreeTierHint(403, rawText403);
        const ct403 = upstreamRes.headers.get("content-type") || "application/json";
        res.writeHead(403, { "content-type": ct403 });

package/src/relay-state.ts

@@ -138,8 +138,9 @@ function parseRelayState(raw: string): RelayState | null {
       : s?.enabled !== false && relays.length > 0,
    url: typeof s?.url === "string" ? s.url.trim() : (relays[0]?.url || ""),
    relays,
-   hideWidget: s?.hideWidget === true,
-  };
+			hideWidget: s?.hideWidget === true,
+			autoUpdate: s?.autoUpdate === true,
+		};
  } catch {
   return null;
  }
@@ -204,7 +205,7 @@ export function loadRelayState(): RelayState {
    if (healed) {
     return healed;
    }
-   return { mode: "auto", enabled: true, url: "", relays: [], hideWidget: false };
+			return { mode: "auto", enabled: true, url: "", relays: [], hideWidget: false, autoUpdate: false };
   }
   const raw = fs.readFileSync(RELAY_STATE_FILE, "utf8");
   const main = parseRelayState(raw);
@@ -221,13 +222,16 @@ export function loadRelayState(): RelayState {
   });
   // parse returns null on an empty pool by design (wipe-protection above);
   // preserve an explicit hide so hide-with-zero-relays survives reload.
-  let hide = false;
-  try {
-   hide = (JSON.parse(raw) as RelayState)?.hideWidget === true;
-  } catch { }
-  return { mode: "auto", enabled: true, url: "", relays: [], hideWidget: hide };
- } catch {
-  return { mode: "auto", enabled: true, url: "", relays: [], hideWidget: false };
+		let hide = false;
+		let autoUpdate = false;
+		try {
+			const parsed = JSON.parse(raw) as RelayState;
+			hide = parsed?.hideWidget === true;
+			autoUpdate = parsed?.autoUpdate === true;
+		} catch {}
+		return { mode: "auto", enabled: true, url: "", relays: [], hideWidget: hide, autoUpdate };
+	} catch {
+		return { mode: "auto", enabled: true, url: "", relays: [], hideWidget: false, autoUpdate: false };
  }
 }
 

package/src/types.ts

@@ -48,7 +48,8 @@ export interface RelayState {
  enabled: boolean;
  url: string;
  relays: KnownRelay[];
- hideWidget?: boolean;
+	hideWidget?: boolean;
+	autoUpdate?: boolean;
 }
 export type LogLevel = "debug" | "info" | "warn" | "error" | "audit";
 

package/src/update-checker.ts

@@ -6,6 +6,7 @@ import { logInfo } from "./logger.ts";
 import { logWarn } from "./logger.ts";
 import { getActiveRelayState, getStatusUi } from "./relay-state.ts";
 import type { ExtensionUIContext } from "./types.ts";
+import { performAutoUpdate } from "./updater.ts";
 const REGISTRY_URL = "https://registry.npmjs.org/pi-freeflow/latest";
 /** Strict semver shape: major.minor.patch with optional -prerelease or +build suffix. */
 const SEMVER_PATTERN = /^\d+\.\d+\.\d+([-.][0-9A-Za-z.-]+)?$/;
@@ -142,8 +143,15 @@ export function checkForUpdateInBackground(ui?: ExtensionUIContext | null): void
 				try {
 					const local = getLocalVersion();
 					if (local && compareVersions(latest, local) > 0) {
-						logInfo(`pi-freeflow update available: ${local} -> ${latest} (run /freeflow update)`);
-						// Respect hide: log only, never re-show the widget.
+						logInfo(`pi-freeflow update available: ${local} -> ${latest}`);
+						if (getActiveRelayState().autoUpdate) {
+							void performAutoUpdate((msg) => {
+								logInfo(msg);
+								const targetUi = ui ?? getStatusUi();
+								if (targetUi?.notify) targetUi.notify(msg, "info");
+							});
+							return;
+						}
 						try {
 							if (getActiveRelayState().hideWidget) return;
 						} catch {}

package/src/updater.ts

@@ -10,6 +10,10 @@
 
 import { spawnSync } from "node:child_process";
 
+import { fetchLatestVersion, getLocalVersion, compareVersions } from "./update-checker.ts";
+import { killPortHolder } from "./proxy.ts";
+import { PORT } from "./config.ts";
+
 export interface GlobalUpdatePlan {
 	/** Binary to run. */
 	cmd: string;
@@ -90,3 +94,62 @@ export function isCommandAvailable(cmd: string): boolean {
 		return false;
 	}
 }
+
+/**
+ * Automatically perform an update to the latest published version and
+ * restart the local proxy daemon.
+ */
+export async function performAutoUpdate(
+	onProgress?: (message: string) => void,
+): Promise<{ ok: boolean; version?: string; error?: string }> {
+	const latest = await fetchLatestVersion();
+	if (!latest) return { ok: false, error: "could not fetch latest version" };
+	const local = getLocalVersion();
+	if (compareVersions(latest, local) <= 0) {
+		return { ok: true, version: local };
+	}
+	onProgress?.(`Auto-updating pi-freeflow: v${local} → v${latest}…`);
+
+	const hostSteps = selectHostUpdateSteps({
+		ompAvailable: isCommandAvailable("omp"),
+		piAvailable: isCommandAvailable("pi"),
+	});
+	let code = 1;
+	for (const step of hostSteps) {
+		try {
+			const res = spawnSync(step.cmd, step.args, {
+				stdio: "ignore",
+				timeout: 120_000,
+				windowsHide: true,
+				shell: process.platform === "win32",
+			});
+			if (res.status === 0) {
+				code = 0;
+				break;
+			}
+		} catch { }
+	}
+	if (code !== 0) {
+		const plan = selectGlobalUpdatePlan({
+			npmAvailable: isCommandAvailable("npm"),
+			bunAvailable: isCommandAvailable("bun"),
+		});
+		if (plan) {
+			try {
+				const res = spawnSync(plan.cmd, plan.args, {
+					stdio: "ignore",
+					timeout: 120_000,
+					windowsHide: true,
+					shell: process.platform === "win32",
+				});
+				if (res.status === 0) code = 0;
+			} catch { }
+		}
+	}
+	if (code === 0) {
+		onProgress?.(`pi-freeflow auto-updated to v${latest} — restarting proxy daemon…`);
+		await killPortHolder(PORT);
+		return { ok: true, version: latest };
+	}
+	return { ok: false, error: `update command failed (exit code ${code})` };
+}