pi-freeflow 1.2.0 → 1.3.0

package/extensions/index.ts

@@ -1,2141 +1,8 @@
 /**
- * bansos — pi extension (with KiloCode free support)
+ * pi-freeflow — Pi & Oh My Pi (OMP) Extension Entrypoint
  *
- * OpenCode models + KiloCode gateway free models
+ * Lightweight bridge re-exporting the modular codebase rooted in src/
  */
-import { randomUUID } from "node:crypto";
-import fs from "node:fs";
-import http from "node:http";
-import https from "node:https";
-import { homedir } from "node:os";
-import path from "node:path";
-import { Readable } from "node:stream";
-import type { ReadableStream as WebReadableStream } from "node:stream/web";
-import { fileURLToPath } from "node:url";
-import type { ExtensionAPI, ExtensionUIContext } from "@earendil-works/pi-coding-agent";
 
-
-// Ensure subagents and OMP resolver recognize active credentials for freeflow
-if (!process.env.FREEFLOW_API_KEY) {
-	process.env.FREEFLOW_API_KEY = "freeflow";
-}
-if (!process.env.BANSOS_API_KEY) {
-	process.env.BANSOS_API_KEY = "freeflow";
-}
-// ── Configuration ──────────────────────────────────────────────────
-const UPSTREAM_OPENCODE = "https://opencode.ai/zen";
-// KiloCode gateway — OpenAI-compatible; free models are keyless (200 req/hr per IP)
-const KILO_CHAT_URL = "https://api.kilo.ai/api/gateway/chat/completions";
-const PORT = Number(process.env.FREEFLOW_PORT || process.env.BANSOS_PORT) || 18080;
-const HOST = "127.0.0.1";
-const API = `${UPSTREAM_OPENCODE}/v1`;
-const OPENCODE_USER_AGENT = "opencode/latest/1.14.50/cli";
-const OPENCODE_CLIENT = "cli";
-const OPENCODE_PROJECT = "default";
-const OPENCODE_SESSION = randomUUID();
-
-function opencodeHeaders(): Record<string, string> {
-	return {
-		"User-Agent": OPENCODE_USER_AGENT,
-		"x-opencode-client": OPENCODE_CLIENT,
-		"x-opencode-project": OPENCODE_PROJECT,
-		"x-opencode-session": OPENCODE_SESSION,
-		"x-opencode-request": randomUUID(),
-	};
-}
-
-// ── Relay egress (vercel/cloudflare worker, x-relay-target pattern) ──────────
-// Same logic as 9router ProxyFetch: when enabled, redirect upstream calls to a
-// relay URL and inject x-relay-target / x-relay-path headers. Body untouched →
-// SSE streaming passes through unchanged. Toggle live via /bansos command.
-// No built-in default relay — a published package must not bake in any one
-// user's personal relay URL. Bring your own via /bansos deploy or /bansos url.
-const DEFAULT_RELAY_URL = "";
-// State lives OUTSIDE the package dir so npm updates don't wipe it.
-// Uses ~/.pi/agent/pi-bansos-relay-state.json (stable), falls back to
-// package-root .relay-state.json for dev/local installs.
-function resolveRelayStatePath(): string {
-	try {
-		const primary = path.join(homedir(), ".pi", "agent", "pi-freeflow-relay-state.json");
-		const legacy = path.join(homedir(), ".pi", "agent", "pi-bansos-relay-state.json");
-		if (!fs.existsSync(primary) && fs.existsSync(legacy)) {
-			try { fs.copyFileSync(legacy, primary); } catch {}
-		}
-		return primary;
-	} catch {
-		return path.join(
-			path.dirname(fileURLToPath(import.meta.url)),
-			"..",
-			".relay-state.json",
-		);
-	}
-}
-function resolveLogFilePath(): string {
-	try {
-		return path.join(homedir(), ".pi", "agent", "pi-freeflow.log");
-	} catch {
-		return path.join(
-			path.dirname(fileURLToPath(import.meta.url)),
-			"..",
-			"pi-freeflow.log",
-		);
-	}
-}
-const LOG_FILE = resolveLogFilePath();
-const RELAY_STATE_FILE = resolveRelayStatePath();
-type KnownRelay = { url: string; label?: string; addedAt?: string };
-type RelayState = { enabled: boolean; url: string; relays: KnownRelay[] };
-function loadRelayState(): RelayState {
-	try {
-		const s = JSON.parse(fs.readFileSync(RELAY_STATE_FILE, "utf8"));
-		const relays: KnownRelay[] = Array.isArray(s?.relays) ? s.relays : [];
-		// Auto-on by default if saved relays exist, unless explicitly set to false
-		const enabled = s?.enabled !== undefined ? Boolean(s.enabled) : relays.length > 0;
-		return {
-			enabled,
-			url: typeof s?.url === "string" ? s.url.trim() : (relays[0]?.url || ""),
-			relays,
-		};
-	} catch {
-		return { enabled: true, url: "", relays: [] };
-	}
-}
-function saveRelayState(s: RelayState): void {
-	try {
-		const dir = path.dirname(RELAY_STATE_FILE);
-		if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-		const tmpPath = `${RELAY_STATE_FILE}.${randomUUID()}.tmp`;
-		fs.writeFileSync(tmpPath, JSON.stringify(s, null, 2), "utf8");
-		fs.renameSync(tmpPath, RELAY_STATE_FILE);
-	} catch (e) {
-		log("warn", "could not persist relay state", { error: String(e) });
-	}
-}
-// dedupe-add a relay to the known list
-function ensureRelay(s: RelayState, url: string, label?: string): void {
-	if (!url || s.relays.some((r) => r.url === url)) return;
-	s.relays.push({ url, label, addedAt: new Date().toISOString() });
-}
-function removeRelay(s: RelayState, url: string): void {
-	s.relays = s.relays.filter((r) => r.url !== url);
-}
-function resolveRelayState(): RelayState {
-	const s = loadRelayState();
-	// migrate legacy {enabled,url}: seed the known list with default + active url
-	if (!s.relays.length) {
-		ensureRelay(s, DEFAULT_RELAY_URL, "9Router default");
-		if (s.url && s.url !== DEFAULT_RELAY_URL) ensureRelay(s, s.url, "previous");
-	}
-	if (!s.url) s.url = DEFAULT_RELAY_URL;
-	return s;
-}
-let relayState: RelayState = resolveRelayState();
-let statusUi: ExtensionUIContext | null = null;
-function shortRelayLabel(url: string): string {
-	const hit = relayState.relays.find((r) => r.url === url);
-	if (hit?.label) return hit.label;
-	try { return new URL(url).host.split(".")[0]; } catch { return url.slice(0, 18); }
-}
-function getOrderedRelayUrls(): string[] {
-	relayState = loadRelayState();
-	if (relayState.relays && relayState.relays.length > 0) {
-		const active = (relayState.url || "").trim();
-		let activeIdx = relayState.relays.findIndex((r) => r.url === active);
-		if (activeIdx < 0) activeIdx = 0;
-		const ordered: string[] = [];
-		for (let i = 0; i < relayState.relays.length; i++) {
-			const r = relayState.relays[(activeIdx + i) % relayState.relays.length];
-			if (r?.url?.trim()) ordered.push(r.url.trim());
-		}
-		return ordered.length > 0 ? ordered : [DEFAULT_RELAY_URL];
-	}
-	if (relayState.url?.trim()) return [relayState.url.trim()];
-	return [DEFAULT_RELAY_URL];
-}
-function isRetriableStatus(status: number): boolean {
-	return (
-		status === 429 ||
-		status === 502 ||
-		status === 503 ||
-		status === 504 ||
-		status === 408 ||
-		status === 402 ||
-		status === 403 ||
-		status === 500 ||
-		status === 400
-	);
-}
-
-// Catalog served at GET /v1/models — ONLY the alive free models we register.
-// Set after health checks. Prevents paid/other upstream models from leaking
-// through the proxy's /v1/models (opencode returns 60 models incl. 54 paid).
-type RegisteredModel = ModelDef & { source: Upstream };
-let aliveCatalog: RegisteredModel[] = [];
-
-async function relayFetch(
-	url: string,
-	opts: RequestInit = {},
-	reqId?: string,
-): Promise<Response> {
-	const rid = reqId || randomUUID().slice(0, 8);
-	if (!relayState.enabled) {
-		log("debug", `relayFetch: direct (relay disabled) -> ${url}`, undefined, rid);
-		return fetch(url, opts);
-	}
-
-	const candidates = getOrderedRelayUrls();
-	let lastResponse: Response | null = null;
-	let lastError: unknown = null;
-	const u = new URL(url);
-	const relayTarget = `${u.protocol}//${u.host}`;
-	const relayPath = `${u.pathname}${u.search}`;
-
-	const bodySizeKB =
-		typeof opts.body === "string"
-			? (opts.body.length / 1024).toFixed(1)
-			: Buffer.isBuffer(opts.body)
-				? (opts.body.length / 1024).toFixed(1)
-				: "0";
-
-	log("info", `request starting (${bodySizeKB}KB payload) -> ${url}`, undefined, rid);
-	if (isDebugEnabled()) {
-		try {
-			const bodyPreview = typeof opts.body === "string" ? opts.body.slice(0, 1200) : "";
-			const modelMatch = bodyPreview.match(/"model"\s*:\s*"([^"]+)"/);
-			const streamMatch = bodyPreview.match(/"stream"\s*:\s*(true|false)/);
-			log("debug", `request detail`, {
-				model: modelMatch?.[1],
-				stream: streamMatch?.[1],
-				sizeKB: bodySizeKB,
-				relayTarget,
-				relayPath,
-				candidates: candidates.length,
-			}, rid);
-		} catch {}
-	}
-
-	for (let i = 0; i < candidates.length; i++) {
-		const targetUrl = candidates[i];
-		const attemptStart = Date.now();
-		try {
-			let targetHost = "opencode.ai";
-			try {
-				if (targetUrl) targetHost = new URL(targetUrl).host;
-			} catch {}
-			const headers = new Headers(opts.headers);
-			headers.set("x-relay-target", relayTarget);
-			headers.set("x-relay-path", relayPath);
-			headers.set("host", targetHost);
-			headers.set("x-request-id", rid);
-			const signal = opts.signal || AbortSignal.timeout(300_000);
-			const res = await fetch(targetUrl, { ...opts, headers, signal });
-			const elapsed = ((Date.now() - attemptStart) / 1000).toFixed(1);
-
-			// Vercel 504 Gateway Timeout on heavy prompts (>50KB or >25s):
-			// Don't cycle through 5 more identical Vercel 25s timeouts. Fast fallback to direct!
-			if (res.status === 504) {
-				log(
-					"warn",
-					`relay ${targetUrl} hit HTTP 504 Gateway Timeout in ${elapsed}s (prompt evaluation exceeded Vercel 25s limit) — fast fallback to direct upstream`,
-					{ upstream: url, sizeKB: bodySizeKB },
-					rid,
-				);
-				break;
-			}
-
-			if (isRetriableStatus(res.status)) {
-				lastResponse = res;
-				log(
-					"warn",
-					`relay ${targetUrl} returned HTTP ${res.status} in ${elapsed}s — rolling to next relay`,
-					{ upstream: url, status: res.status },
-					rid,
-				);
-				continue;
-			}
-
-			// SUCCESS or non-retriable client error (e.g. 200, 400 Bad Request, 404):
-			// If we switched to a different relay because previous failed, update sticky active relay!
-			if (relayState.url !== targetUrl) {
-				log("info", `active relay auto-switched to ${targetUrl}`, {
-					previous: relayState.url,
-				}, rid);
-				relayState.url = targetUrl;
-				saveRelayState(relayState);
-			}
-
-			log("info", `relay ${targetUrl} succeeded (HTTP ${res.status} in ${elapsed}s)`, undefined, rid);
-			if (isDebugEnabled()) {
-				log("debug", `relay headers`, {
-					status: res.status,
-					contentType: res.headers.get("content-type"),
-					via: res.headers.get("via") || res.headers.get("x-vercel-id") || "direct",
-				}, rid);
-			}
-
-			// Update TUI status
-			const label = shortRelayLabel(targetUrl);
-			const total = relayState.relays.length || 1;
-			const pos = Math.max(
-				1,
-				relayState.relays.findIndex((r) => r.url === targetUrl) + 1,
-			);
-			statusUi?.setStatus?.("freeflow", `relay: ON | ${label} ${pos}/${total}`);
-
-			return res;
-		} catch (err) {
-			const elapsed = ((Date.now() - attemptStart) / 1000).toFixed(1);
-			lastError = err;
-			log(
-				"warn",
-				`relay ${targetUrl} fetch error in ${elapsed}s — rolling to next relay`,
-				{ upstream: url, error: String(err) },
-				rid,
-			);
-			continue;
-		}
-	}
-
-	// Full fallback: attempt direct fetch to upstream
-	const directStart = Date.now();
-	try {
-		log("warn", "relays bypassed/exhausted — attempting direct fetch to upstream", {
-			upstream: url,
-			sizeKB: bodySizeKB,
-		}, rid);
-		const directHeaders = new Headers(opts.headers);
-		directHeaders.delete("x-relay-target");
-		directHeaders.delete("x-relay-path");
-		directHeaders.set("host", u.host);
-		directHeaders.set("x-request-id", rid);
-		const directRes = await fetch(url, { ...opts, headers: directHeaders });
-		const directElapsed = ((Date.now() - directStart) / 1000).toFixed(1);
-		log("info", `direct fetch returned HTTP ${directRes.status} in ${directElapsed}s`, undefined, rid);
-		return directRes;
-	} catch (directErr) {
-		const directElapsed = ((Date.now() - directStart) / 1000).toFixed(1);
-		log("error", `direct fallback also failed in ${directElapsed}s`, {
-			upstream: url,
-			error: String(directErr),
-		}, rid);
-		if (lastResponse) return lastResponse;
-		throw directErr || lastError;
-	}
-}
-
-// ── Deploy a fresh Vercel relay (same flow as 9Router) ───────────────────────
-// Token is used in-memory only and NEVER persisted. Resulting URL is saved to
-// the relay state and activated. Worker uses the x-relay-target/x-relay-path
-// pattern, identical to the cloudflare/vercel relays 9Router deploys.
-const VERCEL_API = "https://api.vercel.com";
-const VERCEL_RELAY_WORKER = `// Only the 2 upstreams pi-bansos talks to. Anything else = open proxy abuse.
-const ALLOWED_TARGETS = ["https://opencode.ai", "https://api.kilo.ai"];
-export const config = { runtime: "edge" };
-export default async function handler(req) {
-  const target = req.headers.get("x-relay-target");
-  const relayPath = req.headers.get("x-relay-path") || "/";
-  if (!target) return new Response(JSON.stringify({ error: "Missing x-relay-target header" }), { status: 400, headers: { "content-type": "application/json" } });
-  const cleanTarget = target.replace(/\\/$/, "");
-  if (!ALLOWED_TARGETS.includes(cleanTarget)) return new Response(JSON.stringify({ error: "Forbidden target" }), { status: 403, headers: { "content-type": "application/json" } });
-  if (!relayPath.startsWith("/")) return new Response(JSON.stringify({ error: "Bad path" }), { status: 400, headers: { "content-type": "application/json" } });
-  const targetUrl = cleanTarget + relayPath;
-  const headers = new Headers(req.headers);
-  headers.delete("x-relay-target"); headers.delete("x-relay-path"); headers.delete("host");
-  const response = await fetch(targetUrl, { method: req.method, headers, body: req.method !== "GET" && req.method !== "HEAD" ? req.body : undefined, duplex: "half" });
-  return new Response(response.body, { status: response.status, headers: response.headers });
-}`;
-
-async function deployVercelRelay(
-	token: string,
-	name: string,
-	onProgress?: (msg: string) => void,
-): Promise<string> {
-	const auth = {
-		Authorization: `Bearer ${token}`,
-		"Content-Type": "application/json",
-	};
-	// 1. create deployment (3 inline files, no git repo)
-	onProgress?.("Uploading relay to Vercel…");
-	const dep = await fetch(`${VERCEL_API}/v13/deployments`, {
-		method: "POST",
-		headers: auth,
-		body: JSON.stringify({
-			name,
-			files: [
-				{ file: "api/relay.js", data: VERCEL_RELAY_WORKER },
-				{
-					file: "package.json",
-					data: JSON.stringify({ name, version: "1.0.0" }),
-				},
-				{
-					file: "vercel.json",
-					data: JSON.stringify({
-						rewrites: [{ source: "/(.*)", destination: "/api/relay" }],
-					}),
-				},
-			],
-			projectSettings: { framework: null },
-			target: "production",
-		}),
-	});
-	if (!dep.ok) {
-		const e = await dep
-			.json()
-			.catch(() => ({}) as { error?: { message?: string } });
-		throw new Error(
-			e?.error?.message || `Vercel deploy failed (HTTP ${dep.status})`,
-		);
-	}
-	const depJson = await dep.json();
-	const depId = depJson.id || depJson.uid;
-	const projectId = depJson.projectId || name;
-	// 2. make the deployment public (disable SSO protection)
-	await fetch(`${VERCEL_API}/v9/projects/${projectId}`, {
-		method: "PATCH",
-		headers: auth,
-		body: JSON.stringify({ ssoProtection: null }),
-	});
-	// 3. poll until READY (3s interval, 120s timeout — same as 9Router)
-	onProgress?.("Waiting for deployment to go live…");
-	const deadline = Date.now() + 120_000;
-	while (Date.now() < deadline) {
-		const s = await fetch(`${VERCEL_API}/v13/deployments/${depId}`, {
-			headers: { Authorization: `Bearer ${token}` },
-		});
-		const j = await s.json();
-		if (j.readyState === "READY") return `https://${j.url}`;
-		if (j.readyState === "ERROR" || j.readyState === "CANCELED")
-			throw new Error(`Deployment failed: ${j.readyState}`);
-		await new Promise((r) => setTimeout(r, 3000));
-	}
-	throw new Error("Deployment timed out (120s)");
-}
-
-// ── Model Definitions ──────────────────────────────────────────────
-type ProviderApi = "openai-completions" | "openai-responses";
-type Upstream = "opencode" | "kilo";
-
-interface ModelDef {
-	id: string;
-	name: string;
-	reasoning: boolean;
-	contextWindow: number;
-	maxTokens: number;
-	api?: ProviderApi;
-	input?: ("text" | "image")[];
-	thinkingFormat?: "openrouter";
-	thinkingLevelMap?: Partial<
-		Record<
-			"off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max",
-			string | null
-		>
-	>;
-}
-
-// OpenCode Zen free models verified against the live catalog and inference APIs.
-const KNOWN_MODELS: ModelDef[] = [
-	{
-		id: "x-preview-f-free",
-		name: "Ox Alpha (1M)",
-		reasoning: true,
-		contextWindow: 1_048_576,
-		maxTokens: 131_072,
-		input: ["text", "image"],
-		thinkingLevelMap: {
-			off: "low",
-			minimal: "low",
-			low: "low",
-			medium: "high",
-			high: "high",
-			xhigh: "max",
-			max: "max",
-		},
-	},
-	{
-		id: "muse-spark-1.2-contributor-free",
-		name: "Muse Spark 1.2 (1M)",
-		reasoning: true,
-		contextWindow: 1_048_576,
-		maxTokens: 131_072,
-		api: "openai-responses",
-		input: ["text", "image"],
-		thinkingLevelMap: {
-			off: null,
-			minimal: "minimal",
-			low: "low",
-			medium: "medium",
-			high: "high",
-			xhigh: "xhigh",
-			max: "max",
-		},
-	},
-	{
-		id: "mimo-v2.5-free",
-		name: "MiMo V2.5 (1M)",
-		reasoning: true,
-		contextWindow: 1_048_576,
-		maxTokens: 131_072,
-		input: ["text", "image"],
-		thinkingLevelMap: {
-			off: "low",
-			minimal: "low",
-			low: "low",
-			medium: "medium",
-			high: "high",
-			xhigh: "high",
-			max: "high",
-		},
-	},
-	{
-		id: "hy3-free",
-		name: "Hy3 (262K)",
-		reasoning: true,
-		contextWindow: 262_144,
-		maxTokens: 128_000,
-		thinkingLevelMap: {
-			off: "low",
-			minimal: "low",
-			low: "low",
-			medium: "high",
-			high: "high",
-			xhigh: "max",
-			max: "max",
-		},
-	},
-	{
-		id: "nemotron-3-ultra-free",
-		name: "Nemotron 3 Ultra (1M)",
-		reasoning: true,
-		contextWindow: 1_000_000,
-		maxTokens: 128_000,
-		thinkingLevelMap: {
-			off: "low",
-			minimal: "low",
-			low: "low",
-			medium: "high",
-			high: "high",
-			xhigh: "max",
-			max: "max",
-		},
-	},
-	{
-		id: "nemotron-3.5-lightning-free",
-		name: "Nemotron 3.5 Lightning (1M)",
-		reasoning: true,
-		contextWindow: 1_000_000,
-		maxTokens: 262_144,
-		thinkingLevelMap: {
-			off: "low",
-			minimal: "low",
-			low: "low",
-			medium: "high",
-			high: "high",
-			xhigh: "max",
-			max: "max",
-		},
-	},
-	{
-		id: "big-pickle",
-		name: "Big Pickle",
-		reasoning: true,
-		contextWindow: 200_000,
-		maxTokens: 32_000,
-		thinkingLevelMap: {
-			off: "high",
-			minimal: "high",
-			low: "high",
-			medium: "high",
-			high: "high",
-			xhigh: "max",
-			max: "max",
-		},
-	},
-	{
-		id: "laguna-s-2.1-free",
-		name: "Laguna S 2.1 (1M)",
-		reasoning: true,
-		contextWindow: 1_048_576,
-		maxTokens: 131_072,
-		thinkingLevelMap: {
-			off: "low",
-			minimal: "low",
-			low: "low",
-			medium: "high",
-			high: "high",
-			xhigh: "max",
-			max: "max",
-		},
-	},
-];
-
-// KiloCode gateway free models (keyless — https://kilo.ai/docs/gateway).
-const KILO_MODELS: ModelDef[] = [
-	{
-		id: "kilo-auto/free",
-		name: "Kilo Auto",
-		reasoning: false,
-		contextWindow: 256_000,
-		maxTokens: 10_000,
-		input: ["text"],
-	},
-	{
-		id: "stepfun/step-3.7-flash:free",
-		name: "Step 3.7 Flash",
-		reasoning: true,
-		contextWindow: 262_144,
-		maxTokens: 262_144,
-		input: ["text", "image"],
-		thinkingFormat: "openrouter",
-	},
-	{
-		id: "nvidia/nemotron-3-ultra-550b-a55b:free",
-		name: "Nemotron 3 Ultra 550B (1M)",
-		reasoning: true,
-		contextWindow: 1_000_000,
-		maxTokens: 65_536,
-		input: ["text"],
-		thinkingFormat: "openrouter",
-	},
-	{
-		id: "nvidia/nemotron-3-super-120b-a12b:free",
-		name: "Nemotron 3 Super 120B",
-		reasoning: true,
-		contextWindow: 262_144,
-		maxTokens: 262_144,
-		input: ["text"],
-		thinkingFormat: "openrouter",
-	},
-	{
-		id: "dots-studio/dots-3-note-preview:free",
-		name: "Dots3-Note Preview (512K)",
-		reasoning: true,
-		contextWindow: 512_000,
-		maxTokens: 512_000,
-		input: ["text", "image"],
-		thinkingFormat: "openrouter",
-	},
-	{
-		id: "cohere/north-mini-code:free",
-		name: "North Mini Code",
-		reasoning: true,
-		contextWindow: 256_000,
-		maxTokens: 64_000,
-		input: ["text"],
-		thinkingFormat: "openrouter",
-	},
-	{
-		id: "poolside/laguna-xs-2.1:free",
-		name: "Laguna XS 2.1",
-		reasoning: true,
-		contextWindow: 262_144,
-		maxTokens: 32_768,
-		input: ["text"],
-		thinkingFormat: "openrouter",
-	},
-	{
-		id: "nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free",
-		name: "Nemotron 3 Nano Omni",
-		reasoning: true,
-		contextWindow: 256_000,
-		maxTokens: 65_536,
-		input: ["text", "image"],
-		thinkingFormat: "openrouter",
-	},
-	{
-		id: "openrouter/free",
-		name: "OpenRouter Auto",
-		reasoning: false,
-		contextWindow: 200_000,
-		maxTokens: 65_536,
-		input: ["text"],
-	},
-	{
-		id: "nvidia/nemotron-3.5-lightning:free",
-		name: "Nemotron 3.5 Lightning (Kilo)",
-		reasoning: true,
-		contextWindow: 1_000_000,
-		maxTokens: 65_536,
-		input: ["text"],
-		thinkingFormat: "openrouter",
-	},
-	{
-		id: "nvidia/nemotron-3.5-content-safety:free",
-		name: "Nemotron Content Safety",
-		reasoning: false,
-		contextWindow: 128_000,
-		maxTokens: 8_192,
-		input: ["text"],
-	},
-	{
-		id: "tencent/hy3:free",
-		name: "Tencent Hy3 (Kilo)",
-		reasoning: true,
-		contextWindow: 262_144,
-		maxTokens: 128_000,
-		input: ["text"],
-		thinkingFormat: "openrouter",
-	},
-	{
-		id: "liquid/lfm-2.5-2.6b:free",
-		name: "Liquid LFM 2.5",
-		reasoning: true,
-		contextWindow: 65_536,
-		maxTokens: 8_192,
-		input: ["text"],
-		thinkingFormat: "openrouter",
-	},
-	{
-		id: "poolside/laguna-s-2.1:free",
-		name: "Laguna S 2.1 (Kilo)",
-		reasoning: true,
-		contextWindow: 262_144,
-		maxTokens: 32_768,
-		input: ["text"],
-		thinkingFormat: "openrouter",
-	},
-];
-const KILO_MODEL_IDS = new Set(KILO_MODELS.map((m) => m.id));
-const ALL_MODELS = [...KNOWN_MODELS, ...KILO_MODELS];
-const MODEL_MAP = new Map(ALL_MODELS.map((m) => [m.id, m]));
-// ── Whitelists ─────────────────────────────────────────────────────
-const ALLOWED_PATH_PATTERN = /^\/v1\/[a-zA-Z0-9/_.,\-?&=]*$/;
-const PATH_TRAVERSAL_PATTERN = /\.\./;
-const ALLOWED_METHODS = new Set(["GET", "POST", "OPTIONS", "HEAD"]);
-const STRIP_HEADERS = new Set([
-	"authorization",
-	"host",
-	"content-length",
-	"x-forwarded-for",
-	"x-forwarded-host",
-	"x-forwarded-proto",
-	"x-real-ip",
-	"x-client-ip",
-	"x-originate-ip",
-	"cookie",
-	"set-cookie",
-	"proxy-connection",
-	"proxy-authorization",
-]);
-
-// ── Logger (structured, leveled, rotating, request-aware) ─────────
-// Reference: pi-ai SDK diagnostics (provider streaming + thinking deltas)
-//   - api/openai-completions.js: thinkingFormat branches + reasoning_effort mapping
-//   - api/openai-responses-shared.js: reasoning block handling for Responses API
-//   - api/anthropic-messages.js: thinking/thinking_delta + signature handling
-// This logger mirrors that trace plane for offline audit without TUI noise.
-type LogLevel = "debug" | "info" | "warn" | "error" | "audit";
-const LOG_LEVEL_ORDER: Record<LogLevel, number> = {
-	debug: 0,
-	info: 1,
-	warn: 2,
-	error: 3,
-	audit: 4,
-};
-const LOG_MAX_BYTES = 5 * 1024 * 1024;
-const LOG_MAX_FILES = 3;
-const DEBUG_STATE_FILE = path.join(homedir(), ".pi", "agent", "pi-freeflow-debug.json");
-interface DebugState { debug: boolean; level?: LogLevel }
-let cachedDebugState: DebugState | null | undefined = undefined;
-let cachedDebugMtime = 0;
-let cachedDebugAt = 0;
-function loadDebugState(): DebugState | null {
-	const now = Date.now();
-	// cache for 1s to avoid per-chunk FS hit in hot pipe path
-	if (cachedDebugState !== undefined && now - cachedDebugAt < 1000) {
-		return cachedDebugState;
-	}
-	try {
-		if (!fs.existsSync(DEBUG_STATE_FILE)) {
-			cachedDebugState = null;
-			cachedDebugAt = now;
-			return null;
-		}
-		const stat = fs.statSync(DEBUG_STATE_FILE);
-		if (stat.mtimeMs === cachedDebugMtime && cachedDebugState !== undefined) {
-			cachedDebugAt = now;
-			return cachedDebugState;
-		}
-		const raw = fs.readFileSync(DEBUG_STATE_FILE, "utf8");
-		const d = JSON.parse(raw) as DebugState;
-		if (typeof d.debug === "boolean") {
-			cachedDebugState = d;
-			cachedDebugMtime = stat.mtimeMs;
-			cachedDebugAt = now;
-			return d;
-		}
-	} catch {}
-	cachedDebugState = null;
-	cachedDebugAt = now;
-	return null;
-}
-function saveDebugState(s: DebugState): void {
-	try {
-		const dir = path.dirname(DEBUG_STATE_FILE);
-		if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-		const tmp = `${DEBUG_STATE_FILE}.${randomUUID()}.tmp`;
-		fs.writeFileSync(tmp, JSON.stringify(s, null, 2), "utf8");
-		fs.renameSync(tmp, DEBUG_STATE_FILE);
-		// update cache
-		try {
-			const stat = fs.statSync(DEBUG_STATE_FILE);
-			cachedDebugState = s;
-			cachedDebugMtime = stat.mtimeMs;
-			cachedDebugAt = Date.now();
-		} catch {
-			cachedDebugState = s;
-			cachedDebugAt = Date.now();
-		}
-	} catch {}
-}
-function getMinLogLevel(): number {
-	const dbg = loadDebugState();
-	if (dbg?.debug) return LOG_LEVEL_ORDER.debug;
-	if (dbg?.level && dbg.level in LOG_LEVEL_ORDER) return LOG_LEVEL_ORDER[dbg.level];
-	const raw = (
-		process.env.FREEFLOW_LOG_LEVEL ||
-		process.env.BANSOS_LOG_LEVEL ||
-		"info"
-	).toLowerCase();
-	if (raw in LOG_LEVEL_ORDER) return LOG_LEVEL_ORDER[raw as LogLevel];
-	if (process.env.FREEFLOW_DEBUG === "1" || process.env.FREEFLOW_DEBUG === "true") {
-		return LOG_LEVEL_ORDER.debug;
-	}
-	return LOG_LEVEL_ORDER.info;
-}
-function shouldLog(level: LogLevel): boolean {
-	return LOG_LEVEL_ORDER[level] >= getMinLogLevel();
-}
-function isDebugEnabled(): boolean {
-	return LOG_LEVEL_ORDER.debug >= getMinLogLevel();
-}
-function rotateLogsIfNeeded(): void {
-	try {
-		if (!fs.existsSync(LOG_FILE)) return;
-		if (fs.statSync(LOG_FILE).size <= LOG_MAX_BYTES) return;
-		for (let i = LOG_MAX_FILES - 1; i >= 1; i--) {
-			const src = i === 1 ? LOG_FILE : `${LOG_FILE}.${i - 1}`;
-			const dst = `${LOG_FILE}.${i}`;
-			try {
-				if (fs.existsSync(src)) {
-					if (fs.existsSync(dst)) fs.unlinkSync(dst);
-					fs.renameSync(src, dst);
-				}
-			} catch {}
-		}
-	} catch {}
-}
-function formatLogMeta(
-	meta?: Record<string, unknown>,
-	reqId?: string,
-): string {
-	const parts: string[] = [];
-	if (reqId) parts.push(`req=${reqId}`);
-	if (meta && Object.keys(meta).length > 0) {
-		const safe: Record<string, unknown> = {};
-		for (const [k, v] of Object.entries(meta)) {
-			if (typeof v === "string" && v.length > 800) {
-				safe[k] = `${v.slice(0, 800)}…(${v.length})`;
-			} else {
-				safe[k] = v;
-			}
-		}
-		parts.push(JSON.stringify(safe));
-	}
-	return parts.length ? ` ${parts.join(" ")}` : "";
-}
-function log(
-	level: LogLevel,
-	message: string,
-	meta?: Record<string, unknown>,
-	reqId?: string,
-): void {
-	if (!shouldLog(level)) return;
-	try {
-		const ts = new Date().toISOString();
-		const line = `[${ts}] [${level.toUpperCase()}]${reqId ? ` [${reqId}]` : ""} ${message}${formatLogMeta(meta, undefined)}\n`;
-		rotateLogsIfNeeded();
-		fs.appendFileSync(LOG_FILE, line, "utf8");
-	} catch {}
-}
-function logDebug(
-	message: string,
-	meta?: Record<string, unknown>,
-	reqId?: string,
-): void {
-	log("debug", message, meta, reqId);
-}
-
-// ── Rate Limiter ───────────────────────────────────────────────────
-// Kilo documents 200 free requests/hour/IP. OpenCode owns its own daily quota;
-// local limits only stop one Pi process from flooding either upstream.
-const rateLimitMap = new Map<string, { count: number; resetAt: number }>();
-const RATE_LIMIT_MAX: Record<Upstream, number> = {
-	opencode: 200, // public free quota: requests per UTC day/IP
-	kilo: 200, // documented gateway quota: requests per one-hour window/IP
-};
-
-function rateLimitResetAt(upstream: Upstream, now: number): number {
-	if (upstream === "kilo") return now + 60 * 60_000;
-	const nextUtcDay = new Date(now);
-	nextUtcDay.setUTCHours(24, 0, 0, 0);
-	return nextUtcDay.getTime();
-}
-
-function rateLimitKey(upstream: Upstream, ip: string, now: number): string {
-	if (upstream === "kilo") return `${upstream}:${ip}`;
-	return `${upstream}:${new Date(now).toISOString().slice(0, 10)}:${ip}`;
-}
-
-// ponytail: Vercel relay rejects requests that ask for very large max_tokens
-// (response body / duration limits). Clamp at relay layer so direct mode stays
-// unconstrained and model config stays accurate.
-const RELAY_MAX_TOKENS = 131_072;
-
-function checkRateLimit(ip: string, upstream: Upstream): boolean {
-	const now = Date.now();
-	const key = rateLimitKey(upstream, ip, now);
-	const entry = rateLimitMap.get(key);
-	if (!entry || entry.resetAt <= now) {
-		rateLimitMap.set(key, {
-			count: 1,
-			resetAt: rateLimitResetAt(upstream, now),
-		});
-		return true;
-	}
-	if (entry.count >= RATE_LIMIT_MAX[upstream]) return false;
-	entry.count++;
-	return true;
-}
-
-// ── Health Check & Dynamic Catalog Auto-Update ────────────────────
-const CATALOG_CACHE_FILE = path.join(
-	homedir(),
-	".pi",
-	"agent",
-	"pi-freeflow-catalog-cache.json",
-);
-const CATALOG_CACHE_TTL_MS = 3600_000; // 1 hour
-
-function formatCleanDisplayName(id: string, customName?: string): string {
-	if (customName && customName.trim()) return customName.trim();
-	const known = MODEL_MAP.get(id);
-	if (known && known.name) return known.name;
-
-	// Strip provider prefix ("nvidia/", "stepfun/", "dots-studio/", etc.)
-	let clean = id.replace(/^[a-zA-Z0-9_.-]+\//, "");
-	// Strip variant suffixes
-	clean = clean.replace(/:(free|preview|exacto|default|batch)$/i, "");
-	clean = clean.replace(/-(free|contributor|preview)$/i, "");
-
-	// Capitalize words nicely
-	const parts = clean.split(/[-_]/).map((w) => {
-		const lower = w.toLowerCase();
-		if (lower === "gpt") return "GPT";
-		if (lower === "ai") return "AI";
-		if (lower === "lfm") return "LFM";
-		if (lower === "hy3") return "Hy3";
-		if (lower === "mimo") return "MiMo";
-		if (lower === "ocr") return "OCR";
-		return w.charAt(0).toUpperCase() + w.slice(1);
-	});
-
-	return parts.join(" ");
-}
-
-interface RawModelItem {
-	id: string;
-	context_length?: number;
-	max_output_tokens?: number;
-	[key: string]: unknown;
-}
-
-function enrichModelDef(raw: RawModelItem, source: Upstream): RegisteredModel {
-	const known = MODEL_MAP.get(raw.id);
-	if (known) return { ...known, source };
-
-	const idLower = raw.id.toLowerCase();
-	const hasVision =
-		idLower.includes("vision") ||
-		idLower.includes("vl") ||
-		idLower.includes("omni") ||
-		idLower.includes("note") ||
-		idLower.includes("image");
-	const hasReasoning =
-		idLower.includes("reasoning") ||
-		idLower.includes("r1") ||
-		idLower.includes("o1") ||
-		idLower.includes("think") ||
-		idLower.includes("alpha") ||
-		idLower.includes("spark");
-
-	let contextWindow =
-		typeof raw.context_length === "number" ? raw.context_length : 262_144;
-	if (
-		idLower.includes("1m") ||
-		idLower.includes("ultra") ||
-		idLower.includes("lightning") ||
-		idLower.includes("mimo-v2.5") ||
-		idLower.includes("muse-spark")
-	) {
-		contextWindow = 1_048_576;
-	}
-
-	let maxTokens =
-		typeof raw.max_output_tokens === "number"
-			? raw.max_output_tokens
-			: 65_536;
-	if (idLower.includes("ultra") || idLower.includes("lightning")) {
-		maxTokens = 131_072;
-	}
-
-	const isResponses = raw.id === "muse-spark-1.2-contributor-free";
-
-	return {
-		id: raw.id,
-		name: formatCleanDisplayName(raw.id),
-		source,
-		reasoning: hasReasoning,
-		contextWindow,
-		maxTokens,
-		api: isResponses ? "openai-responses" : undefined,
-		input: hasVision ? ["text", "image"] : ["text"],
-		thinkingFormat: source === "kilo" && hasReasoning ? "openrouter" : undefined,
-	};
-}
-
-interface CatalogCacheData {
-	timestamp: number;
-	opencode: string[];
-	kilo: string[];
-	models?: RegisteredModel[];
-}
-
-function readCatalogCache(): CatalogCacheData | null {
-	try {
-		if (!fs.existsSync(CATALOG_CACHE_FILE)) return null;
-		const raw = fs.readFileSync(CATALOG_CACHE_FILE, "utf8");
-		const data = JSON.parse(raw) as CatalogCacheData;
-		if (Date.now() - data.timestamp < CATALOG_CACHE_TTL_MS) {
-			return data;
-		}
-	} catch {}
-	return null;
-}
-
-async function refreshCatalog(force = false): Promise<RegisteredModel[]> {
-	if (!force) {
-		const disk = readCatalogCache();
-		if (disk && Array.isArray(disk.models) && disk.models.length > 0) {
-			aliveCatalog = disk.models;
-			return aliveCatalog;
-		}
-	}
-
-	// 1. Fetch OpenCode Zen models
-	let opencodeList: RegisteredModel[] = [];
-	try {
-		const r = await fetch(`${API}/models`, {
-			headers: opencodeHeaders(),
-			signal: AbortSignal.timeout(10_000),
-		});
-		if (r.ok) {
-			const d = await r.json();
-			const items: RawModelItem[] = Array.isArray(d?.data) ? d.data : [];
-			const aliveIds = new Set(items.map((m) => m.id));
-			opencodeList = KNOWN_MODELS.filter((m) => aliveIds.has(m.id)).map((m) => ({
-				...m,
-				source: "opencode" as const,
-			}));
-		}
-	} catch {}
-	if (!opencodeList.length) {
-		opencodeList = KNOWN_MODELS.map((m) => ({ ...m, source: "opencode" as const }));
-	}
-
-	// 2. Fetch KiloCode Gateway models
-	let kiloList: RegisteredModel[] = [];
-	try {
-		const r = await fetch(
-			KILO_CHAT_URL.replace("/chat/completions", "/models"),
-			{
-				headers: { Authorization: "Bearer kilo-free" },
-				signal: AbortSignal.timeout(10_000),
-			},
-		);
-		if (r.ok) {
-			const d = await r.json();
-			const items: RawModelItem[] = Array.isArray(d?.data) ? d.data : [];
-			const aliveIds = new Set(items.map((m) => m.id));
-			kiloList = KILO_MODELS.filter((m) => aliveIds.has(m.id)).map((m) => ({
-				...m,
-				source: "kilo" as const,
-			}));
-		}
-	} catch {}
-	if (!kiloList.length) {
-		kiloList = KILO_MODELS.map((m) => ({ ...m, source: "kilo" as const }));
-	}
-
-	const all = [...opencodeList, ...kiloList];
-	aliveCatalog = all;
-
-	// Write rich models to cache atomically
-	try {
-		const dir = path.dirname(CATALOG_CACHE_FILE);
-		if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-		const data: CatalogCacheData = {
-			timestamp: Date.now(),
-			opencode: opencodeList.map((m) => m.id),
-			kilo: kiloList.map((m) => m.id),
-			models: all,
-		};
-		const tmpPath = `${CATALOG_CACHE_FILE}.${randomUUID()}.tmp`;
-		fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2), "utf8");
-		fs.renameSync(tmpPath, CATALOG_CACHE_FILE);
-	} catch {}
-
-	return all;
-}
-
-
-// ── Helpers ────────────────────────────────────────────────────────
-function getClientIP(req: http.IncomingMessage): string {
-	const addr = req.socket.remoteAddress;
-	if (!addr) return "unknown";
-	return addr.startsWith("::ffff:") ? addr.slice(7) : addr;
-}
-
-function validatePath(rawUrl: string): URL | null {
-	const cleaned = rawUrl.replace(/^\/+/, "");
-	if (!ALLOWED_PATH_PATTERN.test(`/${cleaned}`)) return null;
-	if (PATH_TRAVERSAL_PATTERN.test(cleaned)) return null;
-	try {
-		const decoded = decodeURIComponent(cleaned);
-		if (decoded !== cleaned && !ALLOWED_PATH_PATTERN.test(`/${decoded}`))
-			return null;
-	} catch {
-		return null;
-	}
-	try {
-		return new URL(cleaned, `${UPSTREAM_OPENCODE}/`);
-	} catch {
-		return null;
-	}
-}
-
-function sanitizeHeaders(
-	incoming: http.IncomingHttpHeaders,
-	targetHost: string,
-): Record<string, string> {
-	const sanitized: Record<string, string> = {};
-	for (const [key, value] of Object.entries(incoming)) {
-		const lower = key.toLowerCase();
-		if (STRIP_HEADERS.has(lower) || lower.startsWith(":")) continue;
-		if (typeof value === "string") sanitized[lower] = value;
-		else if (Array.isArray(value)) sanitized[lower] = value.join(", ");
-	}
-	sanitized.host = targetHost;
-	Object.assign(sanitized, opencodeHeaders());
-	sanitized["accept-encoding"] = "identity";
-	sanitized.connection = "keep-alive";
-	return sanitized;
-}
-
-function normalizeRequestBody(
-	body: Record<string, unknown>,
-	isRelay = false,
-	isKilo = false,
-	reqId?: string,
-): Record<string, unknown> {
-	const DBG = isDebugEnabled();
-	const modelId = typeof body.model === "string" ? body.model : "";
-	const modelDef = MODEL_MAP.get(modelId);
-	const isResponsesApi = modelId === "muse-spark-1.2-contributor-free";
-
-	if (DBG) {
-		log("debug", `normalize: incoming model=${modelId} kilo=${isKilo} relay=${isRelay}`, {
-			reasoning_effort: body.reasoning_effort,
-			reasoning: body.reasoning,
-			thinking: (body as Record<string, unknown>).thinking,
-			tool_choice: body.tool_choice,
-			toolsLen: Array.isArray(body.tools) ? body.tools.length : undefined,
-		}, reqId);
-	}
-
-	// 1. Tool choice & empty tools normalization (pi-ai compat: opencode only supports auto)
-	if (Array.isArray(body.tools) && body.tools.length === 0) {
-		delete body.tools;
-		delete body.tool_choice;
-	}
-	if (body.tool_choice === "none") {
-		delete body.tool_choice;
-		delete body.tools;
-	} else if (!isKilo && body.tool_choice && body.tool_choice !== "auto") {
-		body.tool_choice = "auto";
-	}
-
-	// 1b. Anthropic thinking -> OpenAI reasoning_effort auto-translate
-	// Pi sends anthropic `thinking: {type:"enabled",budget_tokens}` when provider is anthropic.
-	// Our proxy is always openai-completions/responses upstream, so translate.
-	// Ref: pi-ai api/anthropic-messages.js (thinking.type adaptive/enabled/disabled) -> api/openai-completions.js (reasoning_effort)
-	const thinkingRaw = (body as Record<string, unknown>).thinking;
-	if (thinkingRaw && typeof thinkingRaw === "object") {
-		const th = thinkingRaw as Record<string, unknown>;
-		if (th.type === "disabled") {
-			delete (body as Record<string, unknown>).thinking;
-			// Mark as off so downstream reasoning mapping can clear effort
-			if (!body.reasoning_effort && !body.reasoning) {
-				body.reasoning_effort = "off";
-			}
-		} else if (th.type === "enabled" || th.type === "adaptive") {
-			delete (body as Record<string, unknown>).thinking;
-			// Preserve budget as hint if no explicit effort set
-			if (!body.reasoning_effort && typeof th.budget_tokens === "number") {
-				const budget = th.budget_tokens as number;
-				if (budget >= 8000) body.reasoning_effort = "xhigh";
-				else if (budget >= 4000) body.reasoning_effort = "high";
-				else if (budget >= 2000) body.reasoning_effort = "medium";
-				else body.reasoning_effort = "low";
-			}
-		}
-	}
-
-	// 2. Reasoning normalization — per-model thinkingLevelMap aware
-	// Ref: pi-ai api/openai-completions.js (compat.thinkingFormat branches) + api/openai-responses-shared.js
-	const mapEffort = (rawEffort: string): string | null | undefined => {
-		const key = rawEffort.toLowerCase() as keyof NonNullable<ModelDef["thinkingLevelMap"]>;
-		if (modelDef?.thinkingLevelMap && key in modelDef.thinkingLevelMap) {
-			return modelDef.thinkingLevelMap[key] as string | null;
-		}
-		if (rawEffort === "xhigh" || rawEffort === "max") {
-			return isResponsesApi ? "xhigh" : (modelId === "x-preview-f-free" ? "max" : "xhigh");
-		}
-		if (rawEffort === "high" || rawEffort === "medium") return "high";
-		if (rawEffort === "minimal") return "minimal";
-		if (rawEffort === "none" || rawEffort === "off") return null;
-		return "low";
-	};
-
-	if (typeof body.reasoning_effort === "string") {
-		const mapped = mapEffort(body.reasoning_effort);
-		if (mapped === null || mapped === undefined) {
-			delete body.reasoning_effort;
-		} else {
-			body.reasoning_effort = mapped;
-		}
-	}
-	if (body.reasoning && typeof body.reasoning === "object") {
-		const r = body.reasoning as Record<string, unknown>;
-		if (r.effort === "none" || r.effort === "off") {
-			delete r.effort;
-		} else if (typeof r.effort === "string") {
-			const mapped = mapEffort(r.effort);
-			if (mapped === null || mapped === undefined) {
-				delete r.effort;
-			} else {
-				r.effort = mapped;
-			}
-		}
-		if (isResponsesApi && r.effort === "max") r.effort = "xhigh";
-	}
-
-	// 3. Max & Min tokens clamping (model-specific clamp + Vercel relay clamp)
-	const modelMax = modelDef?.maxTokens ?? RELAY_MAX_TOKENS;
-	const clampTokens = (val: number): number => {
-		let clamped = val;
-		if (!isKilo && clamped < 16) clamped = 16;
-		if (clamped > modelMax) clamped = modelMax;
-		if (isRelay && clamped > RELAY_MAX_TOKENS) clamped = RELAY_MAX_TOKENS;
-		return clamped;
-	};
-
-	if (typeof body.max_tokens === "number") {
-		body.max_tokens = clampTokens(body.max_tokens);
-	}
-	if (typeof body.maxTokens === "number") {
-		body.maxTokens = clampTokens(body.maxTokens);
-	}
-	if (typeof body.max_output_tokens === "number") {
-		body.max_output_tokens = clampTokens(body.max_output_tokens);
-	}
-
-	if (DBG) {
-		log("debug", `normalize: outgoing model=${modelId}`, {
-			reasoning_effort: body.reasoning_effort,
-			reasoning: body.reasoning,
-			max_tokens: body.max_tokens,
-			max_output_tokens: body.max_output_tokens,
-		}, reqId);
-	}
-
-	return body;
-}
-
-// ponytail: shared stream pipe — upstream abort/timeout must end response,
-// not become an uncaught exception that crashes pi.
-// Adds lightweight thinking-tag sniffing for debug audit (no payload mutation).
-// Ref: pi-ai api/openai-completions.js (thinkingDelta) + api/openai-responses-shared.js (reasoning)
-function pipeUpstreamStream(
-	nodeStream: Readable,
-	res: http.ServerResponse,
-	req: http.IncomingMessage,
-	reqId?: string,
-): void {
-	const rid = reqId || randomUUID().slice(0, 8);
-	let totalChunks = 0;
-	let totalBytes = 0;
-	let thinkingChunks = 0;
-	let thinkingBytes = 0;
-	let firstChunkAt: number | null = null;
-	const startAt = Date.now();
-	const sniffThinking = (chunk: Buffer | string): boolean => {
-		const s = typeof chunk === "string" ? chunk : chunk.toString("utf8", 0, Math.min(chunk.length, 4000));
-		return (
-			s.includes("reasoning") ||
-			s.includes("thinking") ||
-			s.includes("<think>") ||
-			s.includes("reasoning_content") ||
-			s.includes("\"type\":\"thinking\"") ||
-			s.includes("thinking_delta")
-		);
-	};
-
-	try {
-		if (typeof res.flushHeaders === "function") {
-			res.flushHeaders();
-		}
-	} catch {}
-
-	nodeStream.on("data", (chunk: Buffer | string) => {
-		try {
-			if (firstChunkAt === null) {
-				firstChunkAt = Date.now();
-				const ttfb = firstChunkAt - startAt;
-				log("debug", `stream first chunk in ${ttfb}ms`, undefined, rid);
-			}
-			totalChunks++;
-			totalBytes += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
-			if (sniffThinking(chunk)) {
-				thinkingChunks++;
-				thinkingBytes += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
-				if (isDebugEnabled() && thinkingChunks <= 3) {
-					const preview = typeof chunk === "string" ? chunk.slice(0, 600) : chunk.toString("utf8", 0, 600);
-					log("debug", `thinking chunk #${thinkingChunks}`, { preview: preview.slice(0, 400) }, rid);
-				}
-			}
-			res.write(chunk);
-			const maybeFlush = res as unknown as { flush?: () => void };
-			if (typeof maybeFlush.flush === "function") maybeFlush.flush();
-		} catch {}
-	});
-
-	nodeStream.on("error", (e: unknown) => {
-		log("error", "upstream stream error", { error: String(e), totalChunks, thinkingChunks }, rid);
-		try {
-			if (!res.headersSent) {
-				res.writeHead(502, { "content-type": "application/json" });
-			}
-			if (!res.writableEnded) {
-				res.end();
-			}
-		} catch {}
-	});
-	nodeStream.on("end", () => {
-		const elapsed = ((Date.now() - startAt) / 1000).toFixed(1);
-		if (thinkingChunks > 0) {
-			log("info", `stream ended in ${elapsed}s — ${totalChunks} chunks (${(totalBytes/1024).toFixed(1)}KB), thinking: ${thinkingChunks} chunks (${(thinkingBytes/1024).toFixed(1)}KB)`, undefined, rid);
-		} else if (isDebugEnabled()) {
-			log("debug", `stream ended in ${elapsed}s — ${totalChunks} chunks (${(totalBytes/1024).toFixed(1)}KB), no thinking detected`, undefined, rid);
-		}
-		try {
-			if (!res.writableEnded) res.end();
-		} catch {}
-	});
-	nodeStream.on("close", () => {
-		try {
-			if (!res.writableEnded) res.end();
-		} catch {}
-	});
-	req.on("aborted", () => {
-		log("warn", "client aborted — destroying upstream", { totalChunks }, rid);
-		if (!nodeStream.destroyed) nodeStream.destroy();
-	});
-	req.on("close", () => {
-		if (!nodeStream.destroyed) nodeStream.destroy();
-	});
-	res.on("close", () => {
-		if (!nodeStream.destroyed) nodeStream.destroy();
-	});
-	res.on("error", () => {
-		if (!nodeStream.destroyed) nodeStream.destroy();
-	});
-}
-
-// ── Start local proxy ──────────────────────────────────────────────
-function startProxy(
-	overridePort?: number,
-): Promise<{ server: http.Server | null; port: number }> {
-	const basePort = overridePort ?? PORT;
-
-	const server = http.createServer((req, res) => {
-		const clientIP = getClientIP(req);
-		const reqId = randomUUID().slice(0, 8);
-		if (isDebugEnabled()) {
-			log("debug", `incoming ${req.method} ${req.url} from ${clientIP}`, { ip: clientIP, method: req.method, url: req.url }, reqId);
-		}
-		if (!ALLOWED_METHODS.has(req.method ?? "")) {
-			res.writeHead(405, { "content-type": "application/json" });
-			res.end(JSON.stringify({ error: "method not allowed" }));
-			return;
-		}
-
-		if (req.method === "OPTIONS") {
-			res.writeHead(204, {
-				"access-control-allow-origin": "*",
-				"access-control-allow-methods": "GET, POST, OPTIONS",
-				"access-control-max-age": "86400",
-			});
-			res.end();
-			return;
-		}
-
-		// Serve ONLY our registered free models. Never forward /v1/models to
-		// upstream (that would leak ~54 paid models into the picker).
-		if (
-			req.method === "GET" &&
-			(req.url === "/v1/models" || req.url === "/v1/models/")
-		) {
-			const body = JSON.stringify({
-				object: "list",
-				data: aliveCatalog.map((m) => ({
-					id: m.id,
-					object: "model",
-					created: 0,
-					owned_by: m.source === "kilo" ? "kilocode" : "opencode",
-				})),
-			});
-			res.writeHead(200, {
-				"content-type": "application/json",
-				"content-length": Buffer.byteLength(body),
-			});
-			res.end(body);
-			return;
-		}
-
-		const target = validatePath(req.url ?? "/");
-		if (!target) {
-			res.writeHead(403, { "content-type": "application/json" });
-			res.end(JSON.stringify({ error: "forbidden" }));
-			return;
-		}
-
-		// Read body to detect model for routing
-		const bodyChunks: Buffer[] = [];
-		req.on("error", (err) => {
-			log("warn", "client request error during body buffering", { error: String(err) }, reqId);
-			if (!res.headersSent) res.writeHead(400, { "content-type": "application/json" });
-			res.end(JSON.stringify({ error: "bad request" }));
-		});
-		req.on("data", (chunk: Buffer) => bodyChunks.push(chunk));
-		req.on("end", async () => {
-			const bodyStr = Buffer.concat(bodyChunks).toString();
-			let isKilo = false;
-			let parsedBody: Record<string, unknown> | null = null;
-
-			try {
-				parsedBody = JSON.parse(bodyStr);
-				if (
-					typeof parsedBody?.model === "string" &&
-					KILO_MODEL_IDS.has(parsedBody.model)
-				) {
-					isKilo = true;
-				}
-			} catch {}
-
-			const upstream: Upstream = isKilo ? "kilo" : "opencode";
-			const isStream = parsedBody?.stream === true;
-			if (!checkRateLimit(clientIP, upstream)) {
-				res.writeHead(429, { "content-type": "application/json" });
-				res.end(JSON.stringify({ error: "rate limit exceeded" }));
-				return;
-			}
-
-			try {
-				if (isKilo && parsedBody) {
-					const kiloBodyObj = structuredClone(parsedBody);
-					normalizeRequestBody(kiloBodyObj, true, isKilo, reqId);
-					const response = await relayFetch(KILO_CHAT_URL, {
-						method: "POST",
-						headers: {
-							"Content-Type": "application/json",
-							Authorization: "Bearer kilo-free",
-						},
-						body: JSON.stringify(kiloBodyObj),
-						signal: AbortSignal.timeout(300_000),
-					}, reqId);
-					if (isStream && response.ok && response.body) {
-						const ct =
-							response.headers.get("content-type") || "text/event-stream";
-						res.writeHead(response.status, {
-							"content-type": ct,
-							"cache-control": "no-cache, no-transform",
-							"connection": "keep-alive",
-							"x-accel-buffering": "no",
-						});
-						pipeUpstreamStream(
-							Readable.fromWeb(
-								response.body as unknown as WebReadableStream,
-							),
-							res,
-							req,
-							reqId,
-						);
-					} else {
-						const data = await response.text();
-						const ct =
-							response.headers.get("content-type") || "application/json";
-						res.writeHead(response.status, { "content-type": ct });
-						res.end(data);
-					}
-				} else {
-					// OpenCode routing — relay (fetch-based) when enabled, else direct (existing, untouched)
-					// round-robin: any saved relay qualifies, not just single url
-					if (relayState.enabled && (relayState.url || relayState.relays.length > 0)) {
-						const fullUrl = `${UPSTREAM_OPENCODE}${req.url ?? "/"}`;
-						const activeHost = relayState.url ? new URL(relayState.url).host : "opencode.ai";
-						const relayHeaders = sanitizeHeaders(
-							req.headers,
-							activeHost,
-						);
-						try {
-							if (parsedBody) {
-								const relayBodyObj = structuredClone(parsedBody);
-								normalizeRequestBody(relayBodyObj, true, isKilo, reqId);
-								const relayBody = Buffer.from(JSON.stringify(relayBodyObj));
-								const response = await relayFetch(fullUrl, {
-									method: req.method || "POST",
-									headers: relayHeaders,
-									body: relayBody,
-									signal: AbortSignal.timeout(300_000),
-								}, reqId);
-								if (isStream && response.ok && response.body) {
-									const ct =
-										response.headers.get("content-type") || "text/event-stream";
-									res.writeHead(response.status, {
-										"content-type": ct,
-										"cache-control": "no-cache, no-transform",
-										"connection": "keep-alive",
-										"x-accel-buffering": "no",
-									});
-									pipeUpstreamStream(
-										Readable.fromWeb(
-											response.body as unknown as WebReadableStream,
-										),
-										res,
-										req,
-										reqId,
-									);
-								} else {
-									const data = await response.text();
-									const ct =
-										response.headers.get("content-type") || "application/json";
-									res.writeHead(response.status, { "content-type": ct });
-									res.end(data);
-								}
-								return; // relay handled the response
-							}
-						} catch (e) {
-							log("warn", "opencode relay failed, falling back to direct", {
-								error: String(e),
-							}, reqId);
-							if (res.headersSent) return; // can't recover mid-stream
-						}
- 					}
-					// direct path — with debug trace and thinking-aware normalize
-					let directBody = Buffer.concat(bodyChunks);
-					if (parsedBody) {
-						const directBodyObj = structuredClone(parsedBody);
-						normalizeRequestBody(directBodyObj, false, isKilo, reqId);
-						directBody = Buffer.from(JSON.stringify(directBodyObj));
-					}
-					if (isDebugEnabled()) {
-						log("debug", `direct upstream ${target.hostname}${target.pathname} (${directBody.length}B)`, { model: parsedBody?.model, isKilo }, reqId);
-					}
-					const fwd = sanitizeHeaders(req.headers, target.hostname);
- 					if (directBody.length > 0) {
- 						fwd["content-length"] = String(directBody.byteLength);
- 					}
- 					const proxy = https.request(
- 						{
- 							method: req.method,
- 							hostname: target.hostname,
- 							port: 443,
- 							path: target.pathname + target.search,
- 							headers: fwd,
- 						},
- 						(upstream) => {
- 							const outHeaders: Record<string, string> = {};
- 							for (const h of [
- 								"content-type",
- 								"cache-control",
- 								"x-request-id",
- 							]) {
- 								const val = upstream.headers[h];
- 								if (typeof val === "string") outHeaders[h] = val;
- 							}
- 							outHeaders["x-content-type-options"] = "nosniff";
- 							res.writeHead(upstream.statusCode ?? 502, outHeaders);
- 							upstream.on("error", (streamErr) => {
- 								log("error", "upstream stream error in direct proxy", { error: String(streamErr) }, reqId);
- 								if (!res.writableEnded) res.end();
- 							});
- 							upstream.pipe(res);
- 						},
- 					);
- 					proxy.on("error", (proxyErr) => {
- 						log("error", "proxy socket error", { error: String(proxyErr) }, reqId);
- 						if (!res.headersSent) {
- 							res.writeHead(502, { "content-type": "application/json" });
- 							res.end(JSON.stringify({ error: "upstream error" }));
- 						} else if (!res.writableEnded) {
- 							res.end();
- 						}
- 					});
- 					proxy.setTimeout(300_000, () => {
- 						proxy.destroy(new Error("timeout"));
- 					});
- 					req.on("aborted", () => {
- 						if (!proxy.destroyed) proxy.destroy();
- 					});
- 					req.on("close", () => {
- 						if (!proxy.destroyed) proxy.destroy();
- 					});
- 					res.on("close", () => {
- 						if (!proxy.destroyed) proxy.destroy();
- 					});
- 					// ponytail: body already buffered in bodyChunks above for model routing;
- 					// req is drained so pipe() would send an empty body → upstream hang → 502.
- 					proxy.end(directBody);
- 				}
- 			} catch (err) {
- 				log("error", "proxy error", { error: String(err) }, reqId);
- 				if (!res.headersSent)
- 					res.writeHead(502, { "content-type": "application/json" });
- 				res.end(JSON.stringify({ error: "internal error" }));
- 			}
- 		});
- 	});
-
- 	return new Promise((resolve, reject) => {
- 		let attempt = 0;
- 		let settled = false;
- 		const tryListen = async (port: number) => {
- 			server.once("error", async (err: NodeJS.ErrnoException) => {
- 				if (settled) return;
- 				if (err.code === "EADDRINUSE") {
- 					// Re-check if the base port is alive (attached master race)
- 					if (await isProxyAlive(basePort)) {
- 						settled = true;
- 						log("info", `attached to running proxy on http://${HOST}:${basePort}`);
- 						resolve({ server: null, port: basePort });
- 						return;
- 					}
- 					if (attempt < 20) {
- 						attempt++;
- 						log("warn", `port ${port} taken — trying ${port + 1}`);
- 						tryListen(port + 1);
- 						return;
- 					}
- 				}
- 				settled = true;
- 				log("error", "server error", { code: err.code, message: err.message });
- 				reject(err);
- 			});
- 			server.listen(port, HOST, () => {
- 				if (settled) return;
- 				settled = true;
- 				const addr = server.address();
- 				const realPort = addr && typeof addr === "object" ? addr.port : port;
- 				log("info", `proxy listening on http://${HOST}:${realPort}`);
- 				resolve({ server, port: realPort });
- 			});
- 		};
- 		tryListen(basePort);
- 	});
- }
-
- // Probe whether an existing freeflow proxy is already running on a port
- async function isProxyAlive(port: number): Promise<boolean> {
- 	try {
- 		const res = await fetch(`http://${HOST}:${port}/v1/models`, {
- 			signal: AbortSignal.timeout(500),
- 		});
- 		const ct = res.headers.get("content-type") || "";
- 		return res.ok && ct.includes("application/json");
- 	} catch {
- 		return false;
- 	}
- }
-// ── Main extension ─────────────────────────────────────────────────
-export default async function (pi: ExtensionAPI) {
-	log("info", "extension loading...");
-	let server: http.Server | null = null;
-	let actualPort = PORT;
-
-	// Single-Port Shared Pattern: If proxy is already running on PORT (e.g. parent session),
-	// subagents reuse http://127.0.0.1:18080 directly without spawning redundant servers!
-	const alreadyRunning = await isProxyAlive(PORT);
-	if (alreadyRunning) {
-		log("info", `reusing existing freeflow proxy on http://${HOST}:${PORT}`);
-		actualPort = PORT;
-	} else {
-		try {
-			const r = await startProxy();
-			server = r.server;
-			actualPort = r.port;
-		} catch {
-			log(
-				"error",
-				"extension inactive — could not bind proxy port. resolve the port conflict and restart pi.",
-			);
-			return;
-		}
-	}
-	const aliveModels = await refreshCatalog();
-	aliveCatalog = aliveModels;
-	if (aliveModels.length === 0) {
-		// Don't bail: still register /bansos below so the user can recover
-		// (e.g. switch the relay off) instead of being stranded with no command.
-		log(
-			"warn",
-			"no alive models found — provider inactive; /bansos still available to switch relay off / go direct",
-		);
-	} else {
-		log(
-			"info",
-			`${aliveModels.length} model(s) registered: ${aliveModels.map((m) => m.id).join(", ")}`,
-		);
-
-		const providerConfig = {
-			baseUrl: `http://${HOST}:${actualPort}/v1`,
-			apiKey: "placeholder",
-			api: "openai-completions" as const,
-			compat: { supportsDeveloperRole: false },
-			models: aliveModels.map((m) => ({
-				id: m.id,
-				name: m.name,
-				api: m.api,
-				reasoning: m.reasoning,
-				thinkingLevelMap: m.thinkingLevelMap,
-				input: m.input ?? ["text"],
-				contextWindow: m.contextWindow,
-				maxTokens: m.maxTokens,
-				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-				compat: m.thinkingFormat
-					? { supportsDeveloperRole: false, thinkingFormat: m.thinkingFormat }
-					: m.api === "openai-responses"
-						? { sessionAffinityFormat: "openai-nosession" }
-						: m.source === "kilo"
-							? { supportsDeveloperRole: false, supportsReasoningEffort: false }
-							: { supportsDeveloperRole: false, supportsReasoningEffort: true },
-			})),
-		};
-
-		pi.registerProvider("freeflow", providerConfig);
-	}
-	// ── /bansos command: relay + debug + logs ───
-	const commandSpec = {
-		description:
-			"Relay egress: on | off | status | logs [level] [n] | debug on|off|status | url [URL] | deploy | list | use <URL> | remove <URL> | refresh",
-		getArgumentCompletions: (prefix: string) =>
-			["on", "off", "status", "url", "deploy", "list", "use", "remove", "refresh", "models", "logs", "debug", "trace"]
-				.filter((s) => s.startsWith(prefix))
-				.map((s) => ({ value: s, label: s })),
-		handler: async (args: string, ctx) => {
-			const parts = String(args || "")
-				.trim()
-				.split(/\s+/);
-			const sub = parts[0] || "";
-			const rest = parts.slice(1).join(" ");
-
-			const flash = () => {
-				const activeLabel = shortRelayLabel(relayState.url);
-				const activeIdx = Math.max(1, relayState.relays.findIndex((r) => r.url === relayState.url) + 1);
-				const total = relayState.relays.length || 1;
-				ctx.ui.notify(
-					`Relay ${relayState.enabled ? "ON" : "OFF"}${relayState.enabled ? ` → ${activeLabel} (${activeIdx}/${total})` : " (direct)"} | saved=${relayState.relays.length} (auto-fallback rolling)`,
-					"info",
-				);
-			};
-			const persist = () => {
-				saveRelayState(relayState);
-				statusUi = ctx.ui;
-				ctx.ui.setStatus("freeflow", undefined);
-				ctx.ui.setStatus("bansos", undefined);
-			};
-			// mutate in place so the saved-relays list is preserved across switches
-			const setRelay = (enabled: boolean, url: string, addLabel?: string) => {
-				relayState.enabled = enabled;
-				relayState.url = (url || "").trim() || DEFAULT_RELAY_URL;
-				if (relayState.url) ensureRelay(relayState, relayState.url, addLabel);
-			};
-			const doDeploy = async () => {
-				// Token prompted (not stored). pi's input has no secret mode — shows while typing.
-				const defaultName = `relay-${Date.now().toString(36)}`;
-				const token = (
-					await ctx.ui.input("Vercel API token (vercel-…):", "")
-				)?.trim();
-				if (!token) {
-					ctx.ui.notify("Deploy cancelled — no token", "warning");
-					return;
-				}
-				const name =
-					(
-						await ctx.ui.input("Project name (empty = auto):", defaultName)
-					)?.trim() || defaultName;
-				ctx.ui.setStatus("bansos", "deploying relay…");
-				try {
-					const url = await deployVercelRelay(token, name, (m) =>
-						ctx.ui.notify(m, "info"),
-					);
-					setRelay(true, url, `deployed ${name}`);
-					persist();
-					ctx.ui.notify(`✓ Deployed & active: ${url}`, "info");
-				} catch (e) {
-					ctx.ui.setStatus(
-						"freeflow",
-						`relay: ${relayState.enabled ? "ON" : "OFF"}`,
-					);
-					ctx.ui.notify(`Deploy failed: ${(e as Error).message}`, "error");
-				}
-			};
-			const switchRelay = async () => {
-				if (!relayState.relays.length) {
-					ctx.ui.notify("No saved relays yet", "warning");
-					return;
-				}
-				const fmt = (r: KnownRelay) =>
-					`${r.url === relayState.url ? "★ " : "  "}${r.url}${r.label ? `  (${r.label})` : ""}`;
-				const opts = relayState.relays.map(fmt);
-				const choice = await ctx.ui.select("Switch relay", opts);
-				if (!choice) return;
-				const match = relayState.relays.find((r) => fmt(r) === choice);
-				if (!match) return;
-				setRelay(true, match.url);
-				persist();
-				flash();
-			};
-			const showList = () => {
-				if (!relayState.relays.length) {
-					ctx.ui.notify("No saved relays", "info");
-					return;
-				}
-				const lines = relayState.relays.map(
-					(r) =>
-						`${r.url === relayState.url ? "★" : " "} ${r.url}${r.label ? `  [${r.label}]` : ""}`,
-				);
-				ctx.ui.notify(
-					`Saved relays (${relayState.relays.length}):\n${lines.join("\n")}`,
-					"info",
-				);
-			};
-			const removeRelayMenu = async () => {
-				const removable = relayState.relays.filter(
-					(r) => r.url !== relayState.url,
-				);
-				if (!removable.length) {
-					ctx.ui.notify(
-						"Nothing to remove — the active relay can't be removed (switch first)",
-						"warning",
-					);
-					return;
-				}
-				const fmt = (r: KnownRelay) =>
-					`${r.url}${r.label ? `  (${r.label})` : ""}`;
-				const choice = await ctx.ui.select("Remove relay", removable.map(fmt));
-				if (!choice) return;
-				const match = removable.find((r) => fmt(r) === choice);
-				if (!match) return;
-				removeRelay(relayState, match.url);
-				persist();
-				ctx.ui.notify(`Removed: ${match.url}`, "info");
-			};
-
-			if (sub === "on") {
-				setRelay(true, relayState.url || DEFAULT_RELAY_URL);
-				persist();
-				flash();
-			} else if (sub === "off") {
-				relayState.enabled = false;
-				persist();
-				flash();
-			} else if (sub === "status") {
-				flash();
-			} else if (sub === "list") {
-				showList();
-			} else if (sub === "use") {
-				const url = (
-					rest ||
-					(await ctx.ui.input("Relay URL to activate:", "")) ||
-					""
-				).trim();
-				if (!url) {
-					ctx.ui.notify("No URL given", "warning");
-					return;
-				}
-				setRelay(true, url, "manual");
-				persist();
-				flash();
-			} else if (sub === "debug") {
-				const arg = rest.trim().toLowerCase();
-				if (arg === "on" || arg === "enable" || arg === "true") {
-					saveDebugState({ debug: true });
-					ctx.ui.notify("🔍 Debug ON — verbose trace enabled (level=debug). Logs now include request IDs, thinking sniffing, and payload normalize details.", "info");
-				} else if (arg === "off" || arg === "disable" || arg === "false") {
-					saveDebugState({ debug: false });
-					ctx.ui.notify("🔇 Debug OFF — level restored to info. File: " + DEBUG_STATE_FILE, "info");
-				} else if (arg.startsWith("level")) {
-					const lvl = arg.split(/\s+/)[1] as LogLevel | undefined;
-					if (lvl && lvl in LOG_LEVEL_ORDER) {
-						saveDebugState({ debug: false, level: lvl });
-						ctx.ui.notify(`Log level set to ${lvl} (persisted to ${DEBUG_STATE_FILE})`, "info");
-					} else {
-						ctx.ui.notify(`Unknown level: ${lvl} (use debug/info/warn/error)`, "warn");
-					}
-				} else {
-					const st = loadDebugState();
-					const cur = st?.debug ? "debug (ON)" : (st?.level || process.env.FREEFLOW_LOG_LEVEL || "info");
-					ctx.ui.notify(`Debug status: ${cur}\nFile: ${DEBUG_STATE_FILE}\nMinLevel: ${getMinLogLevel()} | isDebug=${isDebugEnabled()}\nUsage: /freeflow debug on|off | /freeflow debug level debug`, "info");
-				}
-			} else if (sub === "logs" || sub === "log" || sub === "trace") {
-				try {
-					const rawRest = rest.trim();
-					let filterLevel: LogLevel | null = null;
-					let filterReqId: string | null = null;
-					let count = 25;
-					// trace mode: sub === trace or rest starts with trace/req
-					if (sub === "trace" && rawRest) {
-						filterReqId = rawRest.split(/\s+/)[0];
-					} else if (rawRest) {
-						const tokens = rawRest.split(/\s+/);
-						for (const t of tokens) {
-							const lower = t.toLowerCase();
-							if (lower in LOG_LEVEL_ORDER) filterLevel = lower as LogLevel;
-							else if (/^\d+$/.test(t)) count = Math.min(200, Math.max(5, parseInt(t, 10)));
-							else if (/^[a-f0-9]{6,8}$/i.test(t) || t.startsWith("req=")) filterReqId = t.replace(/^req=/, "");
-							else if (lower === "trace" || lower === "req") continue;
-							else filterReqId = t;
-						}
-					}
-					const files: string[] = [LOG_FILE, `${LOG_FILE}.1`, `${LOG_FILE}.2`].filter((f) => fs.existsSync(f));
-					if (files.length === 0) {
-						ctx.ui.notify("Log file is empty (no logs yet)", "info");
-						return;
-					}
-					let allLines: string[] = [];
-					for (const f of files) {
-						try {
-							const c = fs.readFileSync(f, "utf8");
-							const ls = c.trim().split("\n").filter(Boolean);
-							allLines = ls.concat(allLines);
-						} catch {}
-					}
-					let filtered = allLines;
-					if (filterLevel) {
-						const want = `[${filterLevel.toUpperCase()}]`;
-						filtered = filtered.filter((l) => l.includes(want));
-					}
-					if (filterReqId) {
-						// match [reqId] bracket or req= prefix
-						filtered = filtered.filter((l) => l.includes(filterReqId as string) || l.includes(`[${filterReqId}]`));
-					}
-					const lines = filtered.slice(-count);
-					if (lines.length === 0) {
-						ctx.ui.notify(`No logs matched (level=${filterLevel || "any"} reqId=${filterReqId || "any"} count=${count})`, "warning");
-						return;
-					}
-					const header = `pi-freeflow logs (last ${lines.length}/${filtered.length} matched, total ${allLines.length} lines, file: ${LOG_FILE}${filterLevel ? ` level=${filterLevel}` : ""}${filterReqId ? ` req=${filterReqId}` : ""}):`;
-					ctx.ui.notify(`${header}\n\n${lines.join("\n")}`, "info");
-				} catch (e) {
-					ctx.ui.notify(`Could not read log file: ${(e as Error).message}`, "error");
-				}
-			} else if (sub === "refresh" || sub === "reload" || sub === "models") {
-				ctx.ui.notify("Refreshing model catalog from live upstreams…", "info");
-				const updated = await refreshCatalog(true);
-				persist();
-				ctx.ui.notify(
-					`✓ Refreshed ${updated.length} models with full-spec metadata!`,
-					"info",
-				);
-			} else if (sub === "remove") {
-				const url = (
-					rest ||
-					(await ctx.ui.input("Relay URL to remove:", "")) ||
-					""
-				).trim();
-				if (!url) {
-					ctx.ui.notify("No URL given", "warning");
-					return;
-				}
-				if (url === relayState.url) {
-					ctx.ui.notify(
-						"Can't remove the active relay — switch first",
-						"warning",
-					);
-					return;
-				}
-				if (!relayState.relays.some((r) => r.url === url)) {
-					ctx.ui.notify("Not in saved list", "warning");
-					return;
-				}
-				removeRelay(relayState, url);
-				persist();
-				ctx.ui.notify(`Removed: ${url}`, "info");
-			} else if (sub === "url") {
-				const input =
-					rest ||
-					(await ctx.ui.input(
-						"Relay URL (empty = default):",
-						relayState.url || DEFAULT_RELAY_URL,
-					));
-				setRelay(
-					relayState.enabled,
-					(input || "").trim() || DEFAULT_RELAY_URL,
-					"manual",
-				);
-				persist();
-				flash();
-			} else if (sub === "deploy") {
-				await doDeploy();
-			} else {
-				const choice = await ctx.ui.select("bansos relay", [
-					`Relay: ${relayState.enabled ? "ON" : "OFF"} → ${relayState.url || "direct"}`,
-					"Turn ON",
-					"Turn OFF",
-					"Switch relay…",
-					"Remove relay…",
-					"Set URL",
-					"Deploy Vercel relay…",
-					"List saved relays",
-				]);
-				if (choice === "Turn ON") {
-					setRelay(true, relayState.url || DEFAULT_RELAY_URL);
-					persist();
-					flash();
-				} else if (choice === "Turn OFF") {
-					relayState.enabled = false;
-					persist();
-					flash();
-				} else if (choice === "Switch relay…") {
-					await switchRelay();
-				} else if (choice === "Remove relay…") {
-					await removeRelayMenu();
-				} else if (choice === "Set URL") {
-					const input = await ctx.ui.input(
-						"Relay URL (empty = default):",
-						relayState.url || DEFAULT_RELAY_URL,
-					);
-					setRelay(
-						relayState.enabled,
-						(input || "").trim() || DEFAULT_RELAY_URL,
-						"manual",
-					);
-					persist();
-					flash();
-				} else if (choice === "Deploy Vercel relay…") {
-					await doDeploy();
-				} else if (choice === "List saved relays") {
-					showList();
-				}
-			}
-		},
-	};
-	pi.registerCommand("freeflow", commandSpec);
-	pi.registerCommand("bansos", commandSpec);
-
-	function updateStatusBar(ui?: ExtensionContext["ui"], providerName?: string) {
-		if (!ui) return;
-		if (relayState.enabled && relayState.relays.length > 0) {
-			const label = shortRelayLabel(relayState.url);
-			const idx = Math.max(
-				1,
-				relayState.relays.findIndex((r) => r.url === relayState.url) + 1,
-			);
-			const total = relayState.relays.length;
-			ui.setStatus?.("freeflow", `relay: ON | ${label} ${idx}/${total}`);
-		} else {
-			ui.setStatus?.("freeflow", undefined);
-		}
-		ui.setStatus?.("bansos", undefined);
-	}
-
-	// Reload persisted state on session start/resume and show status ONLY if active model is FreeFlow
-	pi.on?.("session_start", async (_event, ctx) => {
-		relayState = resolveRelayState();
-		statusUi = ctx.ui;
-
-		const activeModel =
-			ctx && typeof ctx === "object" && "model" in ctx
-				? (ctx as { model?: { provider?: string; id?: string } }).model
-				: null;
-		const provider = activeModel?.provider;
-		const modelId = activeModel?.id;
-		const isFreeFlow =
-			provider === "freeflow" ||
-			Boolean(modelId && aliveCatalog.some((m) => m.id === modelId));
-
-		if (isFreeFlow) {
-			updateStatusBar(ctx.ui);
-		} else {
-			// Relay status OFF / cleared when non-freeflow model is active in session
-			ctx.ui?.setStatus?.("freeflow", undefined);
-		}
-	});
-
-	// Update status bar immediately when user switches models
-	pi.on?.("model_select", async (event, ctx) => {
-		statusUi = ctx.ui;
-		const model =
-			event && typeof event === "object" && "model" in event
-				? (event as { model?: { provider?: string; id?: string } }).model
-				: null;
-		const provider = model?.provider;
-		const modelId = model?.id;
-		const isFreeFlow =
-			provider === "freeflow" ||
-			Boolean(modelId && aliveCatalog.some((m) => m.id === modelId));
-
-		if (isFreeFlow) {
-			updateStatusBar(ctx.ui);
-		} else {
-			// Matikan status relay seketika jika model yang dipilih bukan model FreeFlow
-			ctx.ui?.setStatus?.("freeflow", undefined);
-		}
-	});
-
-	// Pi normally pauses after threshold compaction. Queue a follow-up while the
-	// original run is still active so the core agent continues automatically.
-	pi.on?.("session_compact", (event, ctx) => {
-		if (
-			event.reason !== "threshold" ||
-			event.willRetry ||
-			ctx.isIdle() ||
-			ctx.hasPendingMessages()
-		) {
-			return;
-		}
-		pi.sendUserMessage?.(
-			"Continue the current task from the compacted context. Do not wait for another user message; proceed with the next required step.",
-			{ deliverAs: "followUp" },
-		);
-	});
-
-	pi.on?.("session_shutdown", () => {
-		if (server) {
-			log("info", "shutting down proxy...");
-			server.close();
-			rateLimitMap.clear();
-			log("info", "shutdown complete");
-		}
-	});
-}
+export { default } from "../src/index.ts";
+export * from "../src/index.ts";