pi-freeflow 1.10.0 → 1.11.1

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 1.11.1
+
+### Patch Changes
+
+- Apologies for the daemon disconnect bug introduced in v1.11.0: in multi-agent workflows or when subagents, evaluations, and background tasks completed, the extension prematurely detached from the local proxy daemon, causing the proxy to shut down while your main session remained active. The heartbeat connection now persists throughout your active terminal session.
+- Increased local health check and liveness probe timeouts from 800ms and 500ms to 2500ms and 1500ms, with an automatic probe retry to avoid false-alarm daemon restarts during heavy concurrent streaming.
+- Added unhandled error logging inside the daemon to prevent silent process exits.
+- Fresh installs now log full HTTP lifecycle debug output by default so diagnostic reports contain complete request context; turn it off anytime with `/freeflow debug off`.
+
+## 1.11.0
+
+### Minor Changes
+
+- Proxy daemon now stays up while any session uses it, even when idle. It shuts down only after the last session leaves, instead of retiring after a short quiet window.
+
 ## 1.10.0
 
 ### Minor Changes

package/README.md

@@ -250,7 +250,7 @@ cat ~/.pi/agent/pi-freeflow.log | tail -n 20
 /freeflow logs
 cat ~/.pi/agent/pi-freeflow.log | tail -n 50
 
-# debug toggle
+# debug toggle (full debug is on by default for complete error reports; `off` restores info)
 /freeflow debug on
 ```
 
@@ -290,7 +290,7 @@ to `1` before starting a session.
 Nothing visible to your other sessions. The proxy daemon is a separate background
 process shared by every OMP/Pi session on the machine. Closing one session just
 unregisters it; the daemon keeps serving the rest and retires itself automatically
-once the last client disconnects and it has been idle for a short grace period.
+once the last client disconnects and no client re-attaches within a short grace window.
 To stop it manually, run `/freeflow kill` — the next freeflow use starts it again.
 
 **Where's the normalizer?**

package/package.json

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

@@ -5,7 +5,8 @@
  * at 127.0.0.1:28180 (or spawns one if none is alive), registers a lease, and
  * renews it with a heartbeat while the session lives. When the session ends
  * the heartbeat stops; the daemon drops the lease after its TTL and retires
- * once no client holds a live lease and no request has been proxied recently.
+ * once no client holds a live lease for a grace window with nothing in flight
+ * (request-idleness alone never retires it).
  */
 
 import { randomUUID } from "node:crypto";
@@ -348,6 +349,14 @@ export async function watchdogCheck(port: number): Promise<void> {
 	} catch {
 		return;
 	}
+	if (health === null) {
+		await new Promise<void>((r) => setTimeout(r, 200));
+		try {
+			health = await getDaemonHealth(port);
+		} catch {
+			return;
+		}
+	}
 	if (health && (health.activeRequests ?? 0) > 0) {
 		trackBusyEdge(health.activeRequests ?? 0, health.lastBytesAt ?? 0);
 	} else {
@@ -565,6 +574,15 @@ export function getClientId(): string {
 	return CLIENT_ID;
 }
 
+export function hasFallbackServer(): boolean {
+	return fallbackServer !== null;
+}
+
+/** Test seam: true when client heartbeat timer is active. */
+export function isHeartbeatActive(): boolean {
+	return heartbeatTimer !== null;
+}
+
 export function _resetClientForTest(): void {
 	stopHeartbeatInternal();
 	heartbeatPort = 0;

package/src/config.ts

@@ -206,7 +206,7 @@ export const DAEMON_TTL_MS_ENV = DATA_DIR_ENV.replace("_DATA_DIR", "_DAEMON_TTL_
 export const DAEMON_HEARTBEAT_MS_ENV = DATA_DIR_ENV.replace("_DATA_DIR", "_DAEMON_HEARTBEAT_MS");
 /** Daemon GC sweep interval (ms). */
 export const DAEMON_GC_MS_ENV = DATA_DIR_ENV.replace("_DATA_DIR", "_DAEMON_GC_MS");
-/** Idle grace after the last request before a lease-less daemon exits (ms). */
+/** Zero-lease persistence window before a lease-less daemon exits (ms). */
 export const DAEMON_GRACE_MS_ENV = DATA_DIR_ENV.replace("_DATA_DIR", "_DAEMON_GRACE_MS");
 /** Max time a client waits for a freshly spawned daemon to answer /_health (ms). */
 export const DAEMON_READY_TIMEOUT_MS_ENV = DATA_DIR_ENV.replace("_DATA_DIR", "_DAEMON_READY_TIMEOUT_MS");

package/src/daemon.ts

@@ -4,7 +4,7 @@
  * Spawned as a separate OS process by src/client.ts so the local proxy survives
  * the OMP/Pi session that started it. Owns port 28180, serves the proxy plus
  * the client lease/control endpoints, and retires itself once no client holds
- * a live lease and no request has been proxied recently.
+ * a live lease (request-idleness alone never retires it).
  *
  * Run directly: `node --experimental-strip-types src/daemon.ts` (or `bun src/daemon.ts`).
  */
@@ -98,6 +98,12 @@ export async function runDaemon(): Promise<void> {
 	};
 	process.on("SIGTERM", () => retire("SIGTERM"));
 	process.on("SIGINT", () => retire("SIGINT"));
+	process.on("uncaughtException", (err) => {
+		log("error", "daemon uncaughtException", { error: String(err), stack: (err as Error)?.stack });
+	});
+	process.on("unhandledRejection", (reason) => {
+		log("error", "daemon unhandledRejection", { error: String(reason) });
+	});
 	setShutdownShouldExit(true);
 	try {
 		const r = await startProxy();
@@ -113,18 +119,21 @@ export async function runDaemon(): Promise<void> {
 		process.exit(1);
 	}
 
-	// lastActivityAt is initialized AT BIND TIME: a freshly started daemon with
-	// zero leases must never be GC'd during the parent's readiness-poll window.
+	// lastActivityAt is still seeded AT BIND TIME for the /_health snapshot, but
+	// retirement no longer reads it — only the zero-lease persistence window
+	// gates the GC, so a fresh spawn always survives its re-attach window.
 	touchActivity();
 	syncRelayStateFromDisk();
 	void seedCatalog();
 
+	// Retire only when zero leases persist past the grace window with nothing
+	// in flight — never for request-idleness.
 	startLeaseGC({
 		ttlMs: DAEMON_TTL_MS,
 		gcMs: DAEMON_GC_MS,
 		graceMs: DAEMON_GRACE_MS,
 		getActiveRequests,
-		onIdle: () => retire("no clients and idle"),
+		onIdle: () => retire("no clients"),
 	});
 
 	logInfo(`pi-freeflow daemon v${PKG_VERSION} listening on http://${HOST}:${PORT}`);

package/src/index.ts

@@ -16,7 +16,7 @@ import {
 	refreshCatalog,
 	setAliveCatalog,
 } from "./catalog.ts";
-import { ensureDaemon as ensureClientDaemon, getClientPort, stopHeartbeat } from "./client.ts";
+import { ensureDaemon as ensureClientDaemon, getClientPort, hasFallbackServer, stopHeartbeat } from "./client.ts";
 import { createCommandSpec, stopLogsFollow, updateStatusBar } from "./commands.ts";
 import { HOST, ONBOARDED_FLAG_FILE, PORT } from "./config.ts";
 import { logInfo, logWarn } from "./logger.ts";
@@ -328,7 +328,14 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 		}
 	});
 	pi.on?.("session_shutdown", () => {
-		stopHeartbeat();
 		stopLogsFollow();
+		if (hasFallbackServer()) {
+			stopHeartbeat();
+		}
+	});
+	process.once("exit", () => {
+		try {
+			stopHeartbeat();
+		} catch {}
 	});
 }

package/src/lease.ts

@@ -1,108 +1,116 @@
-/**
- * Client lease registry for the detached pi-freeflow proxy daemon.
- *
- * Each OMP/Pi session is a client that registers a lease and renews it with a
- * heartbeat while alive. The daemon drops expired leases and, once NO client
- * holds a live lease AND no request has been proxied recently, retires itself.
- *
- * The request-touch (`lastActivityAt`) is the fallback for legacy clients that
- * never heartbeated: any proxied request counts as a live user, so the daemon
- * is never idle-killed while a session is actually using it.
- */
-
-export interface LeaseOptions {
-	/** Lease lifetime (ms); a client that misses ~3 beats is dropped. */
-	ttlMs: number;
-	/** GC sweep interval (ms). */
-	gcMs: number;
-	/** Idle grace after the last proxied request before a lease-less daemon exits (ms). */
-	graceMs: number;
-	/** Current in-flight proxied requests — daemon never exits mid-stream. */
-	getActiveRequests: () => number;
-	/** Called once when the daemon should retire (close server + exit). */
-	onIdle: () => void;
-}
-
-const leases = new Map<string, number>();
-let lastActivityAt = Date.now();
-let gcTimer: ReturnType<typeof setInterval> | null = null;
-
-/** Register or refresh a client lease. */
-export function registerClient(clientId: string): void {
-	leases.set(clientId, Date.now());
-}
-
-/** Renew an existing client lease. Returns false when the id is unknown (daemon restarted). */
-export function renewClient(clientId: string): boolean {
-	if (leases.has(clientId)) {
-		leases.set(clientId, Date.now());
-		return true;
-	}
-	return false;
-}
-
-/** Remove a client lease (graceful detach on session end). */
-export function unregisterClient(clientId: string): void {
-	leases.delete(clientId);
-}
-
-/** Number of clients holding a live lease. */
-export function getLeaseCount(): number {
-	return leases.size;
-}
-
-/** Snapshot of live client leases (id -> lastSeenAt) for health/debugging. */
-export function getLeaseSnapshot(): Record<string, number> {
-	return Object.fromEntries(leases);
-}
-
-/** Record proxy activity — any proxied request counts as a live user. */
-export function touchActivity(): void {
-	lastActivityAt = Date.now();
-}
-
-/** Timestamp of the last proxied request (0 = never; daemon inits at bind). */
-export function getLastActivityAt(): number {
-	return lastActivityAt;
-}
-
-/**
- * Start the lease GC sweep. Prunes expired leases and, when no client holds a
- * lease, nothing is in flight, and no request has been proxied within the
- * grace window, invokes `onIdle` (the daemon retires). Idempotent — a second
- * call is a no-op.
- */
-export function startLeaseGC(opts: LeaseOptions): void {
-	if (gcTimer !== null) return;
-	gcTimer = setInterval(() => {
-		const now = Date.now();
-		for (const [id, seenAt] of leases) {
-			if (now - seenAt > opts.ttlMs) {
-				leases.delete(id);
-			}
-		}
-		if (
-			leases.size === 0 &&
-			opts.getActiveRequests() === 0 &&
-			now - lastActivityAt > opts.graceMs
-		) {
-			stopLeaseGC();
-			opts.onIdle();
-		}
-	}, opts.gcMs);
-}
-
-/** Stop the GC sweep (test teardown / daemon shutdown). */
-export function stopLeaseGC(): void {
-	if (gcTimer !== null) {
-		clearInterval(gcTimer);
-		gcTimer = null;
-	}
-}
-
-/** Test-only: reset all lease state. */
-export function _resetLeaseStateForTest(): void {
-	leases.clear();
-	lastActivityAt = Date.now();
-	stopLeaseGC();
-}
+/**
+ * Client lease registry for the detached pi-freeflow proxy daemon.
+ *
+ * Each OMP/Pi session is a client that registers a lease and renews it with a
+ * heartbeat while alive. The daemon drops expired leases and retires itself
+ * once NO client holds a live lease: the empty state must persist for the
+ * grace window (a fresh spawn's clients re-attach within seconds) with
+ * nothing in flight. Request-idleness alone NEVER retires the daemon.
+ *
+ * The request-touch (`lastActivityAt`) is still recorded and surfaced in
+ * /_health for observability, but it no longer gates retirement.
+ */
+
+export interface LeaseOptions {
+	/** Lease lifetime (ms); a client that misses ~3 beats is dropped. */
+	ttlMs: number;
+	/** GC sweep interval (ms). */
+	gcMs: number;
+	/** Zero-lease persistence window (ms): how long leases must stay empty before a lease-less daemon exits. */
+	graceMs: number;
+	/** Current in-flight proxied requests — daemon never exits mid-stream. */
+	getActiveRequests: () => number;
+	/** Called once when the daemon should retire (close server + exit). */
+	onIdle: () => void;
+}
+
+const leases = new Map<string, number>();
+let lastActivityAt = 0;
+let gcTimer: ReturnType<typeof setInterval> | null = null;
+/** First sweep timestamp at which leases were observed empty; null while any lease exists. */
+let emptySince: number | null = null;
+
+/** Register or refresh a client lease. */
+export function registerClient(clientId: string): void {
+	leases.set(clientId, Date.now());
+}
+
+/** Renew an existing client lease. Returns false when the id is unknown (daemon restarted). */
+export function renewClient(clientId: string): boolean {
+	if (leases.has(clientId)) {
+		leases.set(clientId, Date.now());
+		return true;
+	}
+	return false;
+}
+
+/** Remove a client lease (graceful detach on session end). */
+export function unregisterClient(clientId: string): void {
+	leases.delete(clientId);
+}
+
+/** Number of clients holding a live lease. */
+export function getLeaseCount(): number {
+	return leases.size;
+}
+
+/** Snapshot of live client leases (id -> lastSeenAt) for health/debugging. */
+export function getLeaseSnapshot(): Record<string, number> {
+	return Object.fromEntries(leases);
+}
+
+/** Record proxy activity — any proxied request counts as a live user. */
+export function touchActivity(): void {
+	lastActivityAt = Date.now();
+}
+
+/** Timestamp of the last proxied request (0 = never; daemon inits at bind). */
+export function getLastActivityAt(): number {
+	return lastActivityAt;
+}
+
+/**
+ * Start the lease GC sweep. Prunes expired leases and, when no client holds a
+ * lease, nothing is in flight, and the lease-less state has persisted for the
+ * grace window, invokes `onIdle` (the daemon retires). Idempotent — a second
+ * call is a no-op.
+ */
+export function startLeaseGC(opts: LeaseOptions): void {
+	if (gcTimer !== null) return;
+	gcTimer = setInterval(() => {
+		const now = Date.now();
+		for (const [id, seenAt] of leases) {
+			if (now - seenAt > opts.ttlMs) {
+				leases.delete(id);
+			}
+		}
+		if (leases.size > 0) {
+			emptySince = null;
+			return;
+		}
+		if (emptySince === null) {
+			emptySince = now;
+			return;
+		}
+		if (opts.getActiveRequests() === 0 && now - emptySince >= opts.graceMs) {
+			stopLeaseGC();
+			opts.onIdle();
+		}
+	}, opts.gcMs);
+}
+
+/** Stop the GC sweep (test teardown / daemon shutdown). */
+export function stopLeaseGC(): void {
+	if (gcTimer !== null) {
+		clearInterval(gcTimer);
+		gcTimer = null;
+	}
+}
+
+/** Test-only: reset all lease state. */
+export function _resetLeaseStateForTest(): void {
+	leases.clear();
+	lastActivityAt = 0;
+	emptySince = null;
+	stopLeaseGC();
+}

package/src/logger.ts

@@ -128,7 +128,8 @@ export function getMinLogLevel(): number {
 		return LOG_LEVEL_ORDER[dbg.level];
 	}
 
-	const raw = (process.env.FREEFLOW_LOG_LEVEL || "info").toLowerCase();
+	const rawEnv = process.env.FREEFLOW_LOG_LEVEL;
+	const raw = (typeof rawEnv === "string" ? rawEnv : "").toLowerCase();
 
 	if (isEmittedLogLevel(raw)) {
 		return LOG_LEVEL_ORDER[raw as LogLevel];
@@ -142,7 +143,14 @@ export function getMinLogLevel(): number {
 		return LOG_LEVEL_ORDER.debug;
 	}
 
-	return LOG_LEVEL_ORDER.info;
+	// Fresh installs default to full debug so users can attach complete
+	// request lifecycles when reporting errors (10MB rotation bounds volume).
+	// An explicit persisted off state or env level above still wins, so
+	// /freeflow debug off keeps working on every platform.
+	if (dbg !== null) {
+		return LOG_LEVEL_ORDER.info;
+	}
+	return LOG_LEVEL_ORDER.debug;
 }
 
 export function shouldLog(level: LogLevel): boolean {

package/src/proxy.ts

@@ -147,7 +147,7 @@ export async function isProxyAlive(port: number): Promise<boolean> {
 	if (!Number.isInteger(port) || port < 1 || port > 65535) return false;
 	try {
 		const res = await fetch(`http://${HOST}:${port}/v1/models`, {
-			signal: AbortSignal.timeout(500),
+			signal: AbortSignal.timeout(1500),
 		});
 		const ct = res.headers.get("content-type") || "";
 		return res.ok && ct.includes("application/json");
@@ -182,7 +182,7 @@ export async function getDaemonHealth(
 	if (!Number.isInteger(port) || port < 1 || port > 65535) return null;
 	try {
 		const res = await fetch(`http://${HOST}:${port}/_health`, {
-			signal: AbortSignal.timeout(800),
+			signal: AbortSignal.timeout(2500),
 		});
 		if (!res.ok) return null;
 		const data: unknown = await res.json();