@alphacoder-v0/pi-loops 0.22.7 → 0.24.0

package/src/host.ts

@@ -1,10 +1,12 @@
 /**
- * The headless host — pi-loops with no pi window. Started by the last interactive pi to quit
- * (`host-control.ts`), it keeps the clock on this machine: stateful loops, dynamic trigger checks
- * for every project, MCP pushes, catch-up — with the same stores, the same in-process sub-agent
- * runner (pi's SDK) and its own MCP client instances. Chat-bound results go to the inbox. The
- * first interactive pi to open takes the clock back (its scheduler preempts a "host" leader) and
- * this process exits. Nothing restarts it after a reboot until a pi opens.
+ * The always-on host — pi-loops with no pi window, one per loops directory. A pi window starts it
+ * when there is automation to run (`ensure` in src/pi-loops.ts) and it never yields to one: it runs
+ * every loop, checks every rule and evaluates MCP pushes, with the same stores, the same in-process
+ * sub-agent runner (pi's SDK) and its own MCP client instances. A rule's result goes to the window
+ * holding the conversation that created the rule, or to the inbox marked for it. After a reboot it
+ * starts again when a pi opens, or when a service manager the person set up runs
+ * `pi-loops start --foreground`. It serves the browser page (src/page-server.ts): one pi per open
+ * conversation (src/page-children.ts), and the Background view of what it is doing.
  *
  *   node --import <pkg>/src/register-pi.mjs <pkg>/src/host-entry.mjs   (env: PI_LOOPS_DIR, PI_LOOPS_PI_PACKAGE)
  */
@@ -12,38 +14,54 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-import { ModelRuntime, ProjectTrustStore, SettingsManager, getAgentDir, readStoredCredential, type ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { ModelRuntime, ProjectTrustStore, SettingsManager, VERSION as PI_VERSION, getAgentDir, readStoredCredential, type ToolDefinition } from "@earendil-works/pi-coding-agent";
 import type { Model } from "@earendil-works/pi-ai";
-import { loadConfig } from "./config.ts";
+import { loadConfig, pageBindPort } from "./config.ts";
 import { computeNext, stamp } from "./schedule.ts";
-import { hostSocketPath, serveHostChannel } from "./host-control-channel.ts";
-import { HOST_LOG, clearHostRecord, hostProcessMatches, readHost, writeHostRecord } from "./host-control.ts";
+import { hostSocketPath, recentRun, requestQueues, serveHostChannel, stopRunFrom } from "./host-control-channel.ts";
+import { HOST_LOG, claimHostService, crashPaused, crashPauseText, hostServiceNames, leavesWithWindows, openWindows, stopWaitsForPage, waitForPageTurns, readSpawnLog, recordCrash, removeHostService, updateHostService, type HostServiceRecord } from "./host-control.ts";
+import { ChildPool, piCommand } from "./page-children.ts";
+import { type HostStatus, lanAddresses, openForLaunch, type PageServer, ring as ringChild, sessionRows, startPageServer, unsentPersonRows, webToken } from "./page-server.ts";
+import { piPackage } from "./pi-resolver.mjs";
+import { RequestStore } from "./requests.ts";
+import { awayFor, pruneSeen, readSeen, sinceCounts } from "./seen.ts";
+import { LeaseStore, holderAlive, openWindowPids, procStart } from "./lease.ts";
+import { sessionTitle, shortSessionId } from "./session-head.ts";
+import { writeFileAtomic } from "./lock.ts";
 import { THINKING_LEVELS, thinkingLevelOrUndefined } from "./thinking.ts";
-import { withFileLock } from "./lock.ts";
 import { rotateInPlace } from "./log.ts";
 import { createHostRuntime } from "./host-runtime.ts";
 import { McpPool } from "./mcp-pool.ts";
-import { McpSource, droppedNotificationMessage, loadMcpConfigFiles, mapNotification, mcpToolDefinitions, mcpTokenFromEnv } from "./mcp.ts";
+import { McpSource, droppedNotificationMessage, loadMcpConfigFiles, mapNotification, mcpToolDefinitions, mcpTokenFromEnv, type McpNotification, type McpServerConfig } from "./mcp.ts";
+import { failingJobs } from "./job-health.ts";
+import { loopLabel } from "./job-lines.ts";
 import { previewRedacted, redact } from "./redact.ts";
-import { parentRuntimeFlags } from "./runner.ts";
+import { parentRuntimeFlags, type RunnerResult, type SubagentRunner } from "./runner.ts";
 import type { SessionSnapshot } from "./scheduler.ts";
-import { createInProcessRunner } from "./sdk-runner.ts";
-import { defaultLoopsDir } from "./store.ts";
-import { isExactlyTrusted } from "./trust.ts";
+import type { HostSnapshot, PageOpened, PageOpenRequest } from "./host-control-channel.ts";
+import { createInProcessRunner, releaseHeldResources } from "./sdk-runner.ts";
+import { defaultLoopsDir, homeLoopsDir, sessionExists } from "./store.ts";
+import { sameProject } from "./paths.ts";
+import { isExactlyTrusted, isTrustedByPi } from "./trust.ts";
 import { PI_LOOPS_VERSION } from "./version.ts";
+import { readUiPrefs, writeUiPref } from "./ui-prefs.ts";
 
 const agentDir = getAgentDir();
 const dir = process.env.PI_LOOPS_DIR || defaultLoopsDir(agentDir);
 const PACKAGE_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 fs.mkdirSync(dir, { recursive: true });
 const logFile = path.join(dir, HOST_LOG);
+// Run with `pi-loops start --foreground`, a line also goes to the terminal, or the service manager's journal.
+const logToStdout = process.env.PI_LOOPS_HOST_MANAGED === "foreground";
 const log = (msg: string) => {
 	const line = `${stamp()} ${redact(msg)}\n`;
+	if (logToStdout) process.stdout.write(line);
 	try {
 		fs.appendFileSync(logFile, line);
-		// The host's stdout and stderr are this file too (host-control.ts), so a chatty MCP server
-		// writes here as well. It is the one file a user is told to read; keep it readable — by the
-		// same rule as every other log in this project, which lives in src/log.ts.
+		// The process's own stdout and stderr are this file too (host-control.ts): what an extension
+		// prints there arrives as written, not through this function's redaction. MCP servers' stderr
+		// does not (src/mcp.ts pipes it). It is the one file a user is told to read; keep it readable,
+		// by the same rule as every other log in this project, which lives in src/log.ts.
 		rotateInPlace(logFile);
 	} catch {
 		process.stderr.write(line);
@@ -67,8 +85,8 @@ function logConfigErrors(): void {
 }
 logConfigErrors();
 
-// The session the host "is": no chat, no project; for unpinned work, the model and thinking level
-// of the pi that handed off (env), else the settings' defaults. Never "some available model".
+// The session the host "is": no chat, no project; for unpinned work, `PI_LOOPS_HOST_MODEL` and
+// `PI_LOOPS_HOST_THINKING` when set, else the settings' defaults. Never "some available model".
 const settings = SettingsManager.create(os.homedir(), agentDir, { projectTrusted: false });
 const settingsModel = settings.getDefaultProvider() && settings.getDefaultModel() ? `${settings.getDefaultProvider()}/${settings.getDefaultModel()}` : undefined;
 // The environment is a boundary: `PI_LOOPS_HOST_THINKING` is whatever the process that spawned this
@@ -88,8 +106,17 @@ let parentModel: Model<any> | undefined;
 
 /* ---------------------------------------------------------------- MCP */
 
-const mcpLoaded = loadMcpConfigFiles({ dir, projectTrusted: false });
+let mcpLoaded = loadMcpConfigFiles({ dir, projectTrusted: false });
 for (const d of mcpLoaded.diagnostics) log(`mcp: ${d}`);
+/** mcp.toml's modification time when it was last read; "" when there is none. */
+const mcpConfigStamp = (): string => {
+	try {
+		return String(fs.statSync(path.join(dir, "mcp.toml")).mtimeMs);
+	} catch {
+		return ""; // no mcp.toml: no servers of the user's own
+	}
+};
+let mcpReadAt = mcpConfigStamp();
 const mcpSources: McpSource[] = [];
 const mcpToolDefs = new Map<string, ToolDefinition<any, any>[]>();
 const mcpToolNames = new Map<string, string[]>();
@@ -108,7 +135,30 @@ const resolveMcpToken = (ref: string): string | undefined => {
 
 /* ------------------------------------------------------------ runtime */
 
-const runner = createInProcessRunner({
+const leases = new LeaseStore(dir);
+const requests = new RequestStore(dir);
+/**
+ * An injecting push is the holder's to put in its chat; the host files it only when no window has
+ * that server. A project's server is that project's: a window elsewhere with a server of the same name
+ * does not count.
+ */
+const someWindowInjects = (server: string, cwd?: string): boolean => leases.list().some((l) => !!l.holder && l.holder.pushServers.includes(server) && holderAlive(l.holder) && (!cwd || (!!l.cwd && sameProject(l.cwd, cwd))));
+
+/**
+ * A host started by a service manager has its environment, not a shell's: a provider key that is
+ * only exported in `.bashrc` is not there. When a run fails on authentication, the error says so, so
+ * the failure in `/cron` points at its cause instead of at the job.
+ */
+const AUTH_FAILURE = /\b(401|403|unauthori[sz]ed|authentication|api[ _-]?key|invalid[ _-]?key|no credentials|not logged in)\b/i;
+function explainAuthFailure(result: RunnerResult): RunnerResult {
+	if (result.ok || !AUTH_FAILURE.test(result.errorMessage ?? "")) return result;
+	// Started by a window, it has that window's environment, for days: a key exported in another shell
+	// since, or in the window's shell after it started, never reached it.
+	const whose = managed === "foreground" ? "pi-loops was started with --foreground by a service manager, so keys exported only in your shell do not reach it" : `pi-loops in the background has the environment of ${process.env.PI_LOOPS_STARTED_BY || "the window that started it"}; pi-loops restart from a shell gives it that shell's`;
+	return { ...result, errorMessage: `${result.errorMessage} (${whose}; keys saved with pi's /login always reach it)` };
+}
+
+const inProcessRunner = createInProcessRunner({
 	agentDir,
 	parentFlags: parentRuntimeFlags([]),
 	getParentModel: () => parentModel,
@@ -123,57 +173,128 @@ const runner = createInProcessRunner({
 	// host owns the scheduler and is built with this runner, so it can only be asked at run time.
 	budget: () => host.scheduler.budgetState(),
 	log: (msg) => log(`sub-agent: ${msg}`),
+	notice: (text, cwd) => host.notice(text, cwd),
+});
+const runner: SubagentRunner = async (req) => explainAuthFailure(await inProcessRunner(req));
+/**
+ * The browser page's pis, one per open conversation. Built before the claim: what it does at once is
+ * stop the children of a pi-loops that is gone, which a second process losing the claim may do too.
+ */
+const pool = new ChildPool({
+	dir,
+	command: () => piCommand(process.env, piPackage),
+	env: process.env,
+	version: PI_LOOPS_VERSION,
+	log,
+	ring: (child) => ringChild(child),
+	unsent: (child) => unsentPersonRows(requests, child),
+	onExit: (child, code, signal) => log(`page: conversation ${(child.sessionId ? shortSessionId(child.sessionId) : undefined) ?? `not yet named (pid ${child.pid})`} pi exited (${signal ?? code})`),
 });
 /** Project-level MCP servers, connected on demand: the host itself has no project. */
-const mcpPool = new McpPool({ isTrusted: (cwd) => isExactlyTrusted(agentDir, cwd), resolveToken: resolveMcpToken, log: (msg) => log(`mcp pool: ${msg}`) });
+const mcpPool = new McpPool({ isTrusted: (cwd) => isExactlyTrusted(agentDir, cwd), resolveToken: resolveMcpToken, log: (msg) => log(`mcp pool: ${msg}`), onNotification: (cwd, cfg, n, source) => onPush(cfg, n, source, cwd) });
 const host = createHostRuntime({
 	dir,
 	config: () => config,
 	session: () => session,
 	runner,
 	mcpTools: () => [...mcpToolDefs.values()].flat(),
-	projectMcpTools: (cwd, taken) => mcpPool.toolsFor(cwd, taken),
+	projectMcpTools: (cwd, taken, trusted) => mcpPool.toolsFor(cwd, taken, trusted),
 	// Project-local hooks.toml: the same exact-trust rule as a project's MCP servers and tools.
 	isProjectTrusted: (cwd) => isExactlyTrusted(agentDir, cwd),
+	ownerTrusts: (cwd) => isTrustedByPi(agentDir, cwd),
 	log,
-	exit: (code) => shutdown(code),
+	// A conversation a window holds is alive whatever the disk says (--session-dir, another root).
+	// Its file where a window last saw it counts too: `--session-dir` keeps conversations elsewhere.
+	sessionExists: (id) => {
+		const lease = leases.read(id);
+		if (lease?.holder && holderAlive(lease.holder)) return true;
+		if (lease?.sessionFile && fs.existsSync(lease.sessionFile)) return true;
+		return sessionExists(path.join(agentDir, "sessions"), id);
+	},
+	onTick: (now) => everyTick(now),
+	// Open in the page, its pi writes the file: a plain job's turn there would be a second writer.
+	pageHolds: (id) => pool.has(id),
 });
 
+/**
+ * One push, from a user-level server or a project's (then `cwd` is that project, and only its rules
+ * are evaluated). An injecting push is the holder's to put in its chat; the host files it only when no
+ * window has that server.
+ */
+function onPush(cfg: McpServerConfig, n: McpNotification, source: McpSource, cwd?: string): void {
+	const trigger = mapNotification(cfg.name, n);
+	if (!trigger) {
+		source.status.droppedCount++;
+		source.status.lastError = droppedNotificationMessage(n.method);
+		return;
+	}
+	if (cwd) trigger.cwd = cwd;
+	const delivery = cfg.injectAndRun ? "inject_and_run" : cfg.injectSummary ? "inject_summary" : "sub_agent";
+	if (delivery !== "sub_agent" && someWindowInjects(cfg.name, cwd)) return;
+	void host.triggers.handle(trigger, delivery).catch((err) => log(`trigger: ${err?.message ?? err}`));
+}
+
+/** Every minute: the trusted projects with enabled rules keep their push servers connected. */
+function watchProjectPushServers(): void {
+	const cwds = [...new Set(host.triggers.store.load().filter((r) => r.enabled).map((r) => r.cwd))];
+	mcpPool.watch(cwds);
+}
+
 function startMcpSources(): void {
-	for (const cfg of mcpLoaded.servers) {
-		const source = new McpSource(cfg, {
-			onConnected: async (src) => {
-				let tools;
-				try {
-					tools = await src.listTools();
-				} catch (err: any) {
-					src.status.lastError = `tools/list failed: ${err?.message ?? err}`;
-					return;
-				}
-				const already = mcpToolNames.get(cfg.name) ?? [];
-				const defs = mcpToolDefs.get(cfg.name) ?? [];
-				const taken = new Set([...mcpToolDefs.values()].flat().map((d) => d.name));
-				for (const { def } of mcpToolDefinitions(src, tools, taken, already)) defs.push(def);
-				mcpToolNames.set(cfg.name, already);
-				mcpToolDefs.set(cfg.name, defs);
-				log(`mcp ${cfg.name}: connected, ${already.length} tool(s)`);
-			},
-			onNotification: (n) => {
-				const trigger = mapNotification(cfg.name, n);
-				if (!trigger) {
-					source.status.droppedCount++;
-					source.status.lastError = droppedNotificationMessage(n.method);
-					return;
-				}
-				const delivery = cfg.injectAndRun ? "inject_and_run" : cfg.injectSummary ? "inject_summary" : "sub_agent";
-				void host.triggers.handle(trigger, delivery).catch((err) => log(`trigger: ${err?.message ?? err}`));
-			},
-			resolveToken: resolveMcpToken,
-			log: (msg) => log(`mcp ${cfg.name}: ${previewRedacted(msg, 200)}`),
-		});
-		mcpSources.push(source);
-		source.start();
+	for (const cfg of mcpLoaded.servers) startMcpSource(cfg);
+}
+
+/**
+ * This process lives for days, and mcp.toml is edited meanwhile: a window reads it at every start,
+ * and so must this, or a server added there never reaches a loop until a restart. Only the servers
+ * that changed are stopped or started.
+ */
+function reloadMcpIfChanged(): void {
+	const at = mcpConfigStamp();
+	if (at === mcpReadAt) return;
+	mcpReadAt = at;
+	const next = loadMcpConfigFiles({ dir, projectTrusted: false });
+	for (const d of next.diagnostics) log(`mcp: ${d}`);
+	const same = (a: McpServerConfig, b: McpServerConfig) => JSON.stringify(a) === JSON.stringify(b);
+	let stopped = 0;
+	for (const source of [...mcpSources]) {
+		if (next.servers.some((cfg) => same(cfg, source.config))) continue;
+		mcpSources.splice(mcpSources.indexOf(source), 1);
+		mcpToolDefs.delete(source.config.name);
+		mcpToolNames.delete(source.config.name);
+		source.stop().catch((err: any) => log(`mcp ${source.config.name}: stop failed: ${err?.message ?? err}`));
+		stopped++;
 	}
+	const fresh = next.servers.filter((cfg) => !mcpSources.some((source) => same(cfg, source.config)));
+	mcpLoaded = next;
+	for (const cfg of fresh) startMcpSource(cfg);
+	log(`mcp.toml changed: ${fresh.length} server(s) started, ${stopped} stopped`);
+}
+
+function startMcpSource(cfg: McpServerConfig): void {
+	const source = new McpSource(cfg, {
+		onConnected: async (src) => {
+			let tools;
+			try {
+				tools = await src.listTools();
+			} catch (err: any) {
+				src.status.lastError = `tools/list failed: ${err?.message ?? err}`;
+				return;
+			}
+			const already = mcpToolNames.get(cfg.name) ?? [];
+			const defs = mcpToolDefs.get(cfg.name) ?? [];
+			const taken = new Set([...mcpToolDefs.values()].flat().map((d) => d.name));
+			for (const { def } of mcpToolDefinitions(src, tools, taken, already)) defs.push(def);
+			mcpToolNames.set(cfg.name, already);
+			mcpToolDefs.set(cfg.name, defs);
+			log(`mcp ${cfg.name}: connected, ${already.length} tool(s)`);
+		},
+		onNotification: (n) => onPush(cfg, n, source),
+		resolveToken: resolveMcpToken,
+		log: (msg) => log(`mcp ${cfg.name}: ${previewRedacted(msg, 200)}`),
+	});
+	mcpSources.push(source);
+	source.start();
 }
 
 /* ------------------------------------------------------------ lifecycle */
@@ -183,23 +304,47 @@ async function shutdown(code: number): Promise<void> {
 	if (stopping) return;
 	stopping = true;
 	// Whatever hangs (a lock, an MCP server that will not die), the process leaves.
-	setTimeout(() => process.exit(code), 10_000).unref();
+	setTimeout(() => {
+		// A clean stop that ran out of time is still a clean stop: its record goes, so the next window
+		// does not count it as a crash.
+		if (code === 0) {
+			try {
+				removeHostService(dir, process.pid);
+			} catch (err: any) {
+				log(`could not remove the pi-loops record: ${err?.message ?? err}`);
+			}
+		}
+		process.exit(code);
+	}, 10_000).unref();
 	try {
+		// The page's pis first: each is a conversation someone has open, and it quits as /quit does.
+		await pool.stopAll();
 		await host.stop();
+		// Held turns' extensions get their session_shutdown before the process goes.
+		await Promise.race([releaseHeldResources({ idleMs: 0, keep: 0 }), new Promise((r) => setTimeout(r, 3000).unref())]);
 		await mcpPool.stopAll();
 		await Promise.all(mcpSources.map((s) => s.stop()));
 	} catch (err: any) {
 		log(`shutdown: ${err?.message ?? err}`);
 	}
 	try {
+		page?.close();
 		channel?.close();
 		fs.rmSync(hostSocketPath(dir), { force: true });
 	} catch {
 		/* going away anyway */
 	}
-	// A clean exit removes the record; a crash leaves it so the next pi can say the host died.
-	if (code === 0) clearHostRecord(dir, process.pid);
-	log(`host stopped (exit ${code})`);
+	// A clean exit removes the record; a crash leaves it so the next pi can say the host died. Only a
+	// record that still names this process: a host that lost its claim must not remove the winner's.
+	if (code === 0) {
+		try {
+			removeHostService(dir, process.pid);
+			removeLegacyFence();
+		} catch (err: any) {
+			log(`could not remove the pi-loops record: ${err?.message ?? err}`);
+		}
+	}
+	log(`pi-loops stopped (exit ${code})`);
 	process.exit(code);
 }
 // `shutdown` stops stores, MCP servers and the scheduler; any of them can reject, and the process
@@ -210,28 +355,165 @@ const leave = (code: number) => void shutdown(code).catch((err: any) => {
 });
 process.on("SIGTERM", () => leave(0));
 process.on("SIGINT", () => leave(0));
+// The terminal `pi-loops start --foreground` runs in was closed: a stop like any other, not a crash.
+process.on("SIGHUP", () => leave(0));
+// No catch-and-continue inside the process: its state after an uncaught error cannot be trusted.
+// The log lands first (the error, its stack and what was in flight), then the crash is counted
+// (three within five minutes pause the host instead of a restart loop) and the record cleared, and
+// the process exits for whatever started it to judge.
 process.on("uncaughtException", (err) => {
-	log(`uncaught: ${redact(String(err?.stack ?? err))}`);
+	// Already leaving: an error thrown on the way out is logged, not counted as another crash.
+	if (stopping) {
+		log(`uncaught while stopping: ${redact(String(err?.stack ?? err))}`);
+		return;
+	}
+	const inFlight = [...host.scheduler.runningRuns().map((r) => `${r.label} (${r.runId.slice(0, 12)})`), ...host.triggers.runningList().map((c) => `check ${c.traceId.slice(0, 8)}`)];
+	log(`uncaught: ${redact(String(err?.stack ?? err))}${inFlight.length ? `\n  in flight: ${inFlight.join(", ")}` : ""}`);
+	try {
+		recordCrash(dir, `pi-loops crashed: ${previewRedacted(String(err?.message ?? err), 160)}; see ${HOST_LOG}`);
+		removeHostService(dir, process.pid);
+	} catch (e: any) {
+		log(`could not record the crash: ${e?.message ?? e}`);
+	}
 	leave(1);
 });
 process.on("unhandledRejection", (err: any) => log(`unhandled rejection: ${redact(String(err?.stack ?? err))}`));
 
-// One host per machine: two pis quitting together may both spawn one; the second to get here
-// leaves without touching the first's record (host.json names the survivor, so /cron host and
-// crash detection keep working).
-const claimed = await withFileLock(path.join(dir, "host.lock"), () => {
-	const other = readHost(dir);
-	if (other && other.pid !== process.pid && other.host === os.hostname() && hostProcessMatches(other)) return false;
-	writeHostRecord(dir, { pid: process.pid, host: os.hostname(), startedAt: stamp(), node: process.execPath, entry: process.argv[1] });
-	return true;
+// Run by `pi-loops start --foreground` (a service manager the person set up), or spawned by a pi window.
+const managed: HostServiceRecord["managed"] = process.env.PI_LOOPS_HOST_MANAGED === "foreground" ? "foreground" : "spawned";
+// After the crash budget paused it, a service manager would restart it at once after each failure:
+// it waits the pause out instead, as a window does, and goes on early when /pi-loops start ends it.
+// A stop while it waits is a clean stop (the signal handlers above).
+if (managed === "foreground" && crashPaused(readSpawnLog(dir), Date.now())) {
+	log(`paused: ${crashPauseText(readSpawnLog(dir))}`);
+	await new Promise<void>((resolve) => {
+		const wait = setInterval(() => {
+			if (crashPaused(readSpawnLog(dir), Date.now())) return;
+			clearInterval(wait);
+			resolve();
+		}, 15_000);
+	});
+}
+
+// One host per loops directory: two windows opening together may both spawn one, and the second
+// to get here leaves before it opens the socket or any MCP connection. The claim, not the socket,
+// is the single-instance argument (src/host-control.ts).
+const startedAt = stamp();
+const claimToken = webToken(dir, (message) => {
+	log(message);
+	process.exit(1);
 });
-if (!claimed) {
-	log(`another host is already running (pid ${readHost(dir)?.pid}); exiting`);
+const claim = claimHostService(dir, {
+	v: 1,
+	pid: process.pid,
+	procStart: procStart(process.pid),
+	startedAt,
+	version: PI_LOOPS_VERSION,
+	piVersion: PI_VERSION,
+	entry: process.argv[1] ?? "",
+	node: process.execPath,
+	dir,
+	socket: hostSocketPath(dir),
+	token: claimToken,
+	managed,
+});
+if (!claim.claimed) {
+	log(`pi-loops is already running (pid ${claim.other.pid}); exiting`);
 	process.exit(0);
 }
-log(`pi-loops ${PI_LOOPS_VERSION} headless host started (pid ${process.pid}, dir ${dir})`);
-// A window into a process with no chat: `/cron host` and `pi-loops host status` read this.
-const startedAt = stamp();
+// A `pi-loops stop` that landed while a window was starting this process: every start by a person
+// clears the mark first, so a mark here is the stop, said after the window looked.
+if (readUiPrefs(dir).host === "stopped") {
+	log("pi-loops was stopped by hand while it started; leaving");
+	removeHostService(dir, process.pid);
+	process.exit(0);
+}
+log(`pi-loops ${PI_LOOPS_VERSION} started (pid ${process.pid}, dir ${dir})`);
+// The status page's token, from before the page moved here: `web-token` is the one token now.
+try {
+	fs.unlinkSync(path.join(dir, "host-page-token"));
+	log("removed host-page-token: the page uses web-token now");
+} catch (err: any) {
+	if (err?.code !== "ENOENT") log(`host-page-token: ${err?.message ?? err}`);
+}
+
+/**
+ * The fence that keeps a pi-loops 0.22 window from running loops beside this host during an
+ * upgrade. Such a window elects a leader through `scheduler.json`, preempts only a record of kind
+ * "host", and stands by while a fresh record with a live pid names someone else; so this writes one
+ * every tick. Removed once 0.22 windows are gone (release 6 of the design).
+ */
+const LEGACY_FENCE = path.join(dir, "scheduler.json");
+function writeLegacyFence(now: number): void {
+	writeFileAtomic(LEGACY_FENCE, `${JSON.stringify({ pid: process.pid, host: os.hostname(), instance: "service", kind: "service", startedAt, heartbeatAt: stamp(now) }, null, 2)}\n`);
+}
+function removeLegacyFence(): void {
+	try {
+		const rec = JSON.parse(fs.readFileSync(LEGACY_FENCE, "utf8"));
+		if (rec?.pid === process.pid) fs.rmSync(LEGACY_FENCE, { force: true });
+	} catch {
+		/* no fence, or not ours to remove */
+	}
+}
+
+/** Every tick: am I still the host the record names (a stale lock break can let two claim), and the fence. */
+/**
+ * Every ten minutes: forget conversations nothing refers to any more. A lease is written for every
+ * conversation a window opens; one that nobody holds and that has no plain job, rule or queued request
+ * is deleted (a window opening it again writes it again), and so is its since-you-looked cursor.
+ */
+let sweptAt = 0;
+function sweepConversations(now: number): void {
+	if (now - sweptAt < 10 * 60_000) return;
+	sweptAt = now;
+	// A loop's runs count for the conversation that created it (since-you-looked), so that one stays too.
+	const working = new Set<string>([...host.scheduler.store.load().flatMap((j) => [j.sessionId, j.createdBy?.sessionId].filter((id): id is string => !!id)), ...host.triggers.store.load().flatMap((r) => (r.createdBy?.sessionId ? [r.createdBy.sessionId] : [])), ...requests.sessions()]);
+	// The page's last conversation keeps its lease, which names its project: `GET /` opens a new
+	// conversation there when that one was never saved (src/page-server.ts rootPage).
+	const lastPage = readUiPrefs(dir).lastPage;
+	if (lastPage) working.add(lastPage);
+	let removed = 0;
+	for (const lease of leases.list()) if (!working.has(lease.sessionId) && leases.removeIfFree(lease.sessionId)) removed++;
+	const pruned = pruneSeen(dir, (id) => working.has(id) || !!leases.read(id));
+	if (removed || pruned) log(`swept ${removed} idle conversation lease(s) and ${pruned} since-you-looked cursor(s)`);
+}
+
+function everyTick(now: number): void {
+	if (!hostServiceNames(dir, process.pid, startedAt)) {
+		log("host-service.json no longer names this process; leaving");
+		leave(0);
+		return;
+	}
+	// `[host] auto = false`: this process lives while a pi window does, as 0.22.8 ran loops only in
+	// an open window (src/host-control.ts leavesWithWindows). The next window starts it again. The
+	// page's pis count with their tabs: one still starting, or one a terminal took the conversation
+	// from, holds no lease.
+	if (leavesWithWindows({ auto: config.hostAuto, managed, windows: openWindows({ terminalPids: openWindowPids(leases), pageChildPids: pool.list().map((c) => c.pid), tabs: page?.clients() ?? 0 }), upForMs: now - Date.parse(startedAt), asked: process.env.PI_LOOPS_HOST_ASKED === "1" || readUiPrefs(dir).host === "started" })) {
+		log("[host] auto = false and no pi window is open; leaving (the next window starts pi-loops again)");
+		leave(0);
+		return;
+	}
+	try {
+		writeLegacyFence(now);
+	} catch (err: any) {
+		log(`legacy fence: ${err?.message ?? err}`);
+	}
+	try {
+		sweepConversations(now);
+	} catch (err: any) {
+		log(`conversation sweep: ${err?.message ?? err}`);
+	}
+	pool.sweep(now).catch((err: any) => log(`page: idle sweep: ${err?.message ?? err}`));
+	if (!page && pageWaiting?.reason === "older-page" && !pageBinding) bindPageAndSay().catch((err: any) => log(`page: ${err?.message ?? err}`));
+	// The heartbeat windows read before they evict: a socket that does not answer while this is fresh
+	// is a broken control channel, not a wedged host (src/host-control.ts decideEviction).
+	try {
+		updateHostService(dir, process.pid, { tickAt: stamp(now) });
+	} catch (err: any) {
+		log(`heartbeat: ${err?.message ?? err}`);
+	}
+}
+
 /**
  * A control channel that cannot be opened is a degraded host, not a dead one: `pi-loops host
  * status` falls back to the recorded pid, and the loops keep running. This is the top level of the
@@ -246,61 +528,299 @@ function serveHostChannelSafely(...args: Parameters<typeof serveHostChannel>): R
 	}
 }
 
+/** The rules, or none when triggers.json cannot be read: a status must not fail with the file it reports on. */
+function rulesOrNone(): ReturnType<typeof host.triggers.store.load> {
+	try {
+		return host.triggers.store.load();
+	} catch (err: any) {
+		log(`rules: ${err?.message ?? err}`);
+		return [];
+	}
+}
+
+function snapshot(): HostSnapshot {
+	// One read of each store for the whole snapshot. jobs.json was read four times and
+	// triggers.json twice, so a tick landing in between could have `enabled` counted against
+	// one version of the file and `total` against another — a status line contradicting itself.
+	const jobs = host.scheduler.store.load();
+	const rules = rulesOrNone();
+	return {
+		pid: process.pid,
+		host: os.hostname(),
+		startedAt,
+		startedBy: process.env.PI_LOOPS_STARTED_BY || undefined,
+		model: session.model,
+		version: PI_LOOPS_VERSION,
+		sessions: leases.list().flatMap((l) => {
+			if (!l.holder || !holderAlive(l.holder)) return [];
+			const pid = l.holder.pid;
+			const child = pool.list().find((c) => c.pid === pid);
+			const title = l.sessionFile ? sessionTitle(l.sessionFile) : undefined;
+			return [{ sessionId: l.sessionId, pid, mode: l.holder.mode, ...(child ? { page: { tabs: child.clients.size, idleMs: Date.now() - child.lastClientAt } } : {}), ...(title ? { title } : {}) }];
+		}),
+		runs: host.scheduler.runningRuns(),
+		checks: host.triggers.runningList().map((r) => ({ traceId: r.traceId, sourceLabel: r.sourceLabel, eventLabel: r.eventLabel, startedAt: r.startedAt, cwd: r.cwd })),
+		jobs: { enabled: jobs.filter((j) => j.enabled).length, total: jobs.length },
+		rules: { enabled: rules.filter((r) => r.enabled).length, total: rules.length },
+		inboxNew: host.scheduler.inbox.newCount(),
+		// Without these a host that has failed every run for six hours reads exactly like one
+		// that succeeded an hour ago: "nothing running right now".
+		recent: host.scheduler.store
+			.listRuns(undefined, 5)
+			.reverse()
+			.map(recentRun),
+		// The three-in-a-row rule `/cron` and the badge use: one missed run is not a failing loop.
+		failing: failingJobs(jobs).map((j) => ({ job: loopLabel(j), error: previewRedacted(j.lastError ?? "", 120) })),
+		nextDue: (() => {
+			const next = jobs
+				.filter((j) => j.enabled && j.stateful)
+				.map((j) => computeNext({ schedule: j.schedule, createdAt: Date.parse(j.createdAt), lastFiredAt: j.lastFiredAt ? Date.parse(j.lastFiredAt) : undefined }, Date.now()))
+				.filter((n): n is number => n !== undefined)
+				.sort((a, b) => a - b)[0];
+			return next ? stamp(next) : undefined;
+		})(),
+		budget: (() => {
+			const b = host.scheduler.budgetState();
+			return b.cap > 0 ? { spent: b.spent, cap: b.cap } : undefined;
+		})(),
+		mcp: mcpSources.map((s) => ({ name: s.config.name, state: s.status.state, lastError: s.status.lastError ? previewRedacted(s.status.lastError, 120) : undefined })),
+		page: pageUrl,
+		pageOpen: pool.list().length,
+		pageWaiting: pageWaiting && pageWaitingLine(pageWaiting.reason),
+		lastPolls: [...host.triggers.lastPolls.values()],
+		notices: host.notices(),
+		requests: requestQueues(requests, leases),
+	};
+}
+
+
+/**
+ * What the Background view shows: the snapshot, and every conversation that has a lease, a plain job, a
+ * rule or a queued request, with who holds it. Built per request; the page refreshes every 15 s.
+ */
+function hostStatus(): HostStatus {
+	const allJobs = host.scheduler.store.load();
+	const jobs = allJobs.filter((j) => j.enabled && !j.stateful && j.sessionId);
+	const rules = rulesOrNone().filter((r) => r.enabled && r.createdBy?.sessionId);
+	// Only conversations someone holds or that have work: one lease per conversation ever opened
+	// would otherwise make the page a list of every closed chat, each reading "nobody".
+	const working = new Set([...jobs.map((j) => j.sessionId!), ...rules.map((r) => r.createdBy!.sessionId!), ...requests.sessions()]);
+	const leaseList = leases.list().filter((l) => working.has(l.sessionId) || (l.holder && holderAlive(l.holder)));
+	const legacy = host.scheduler.presenceList().flatMap((e) => (e.sessionId && !e.leases && e.kind !== "host" ? [{ sessionId: e.sessionId, pid: e.pid }] : []));
+	const ids = new Set([...leaseList.map((l) => l.sessionId), ...jobs.map((j) => j.sessionId!), ...rules.map((r) => r.createdBy!.sessionId!), ...legacy.map((l) => l.sessionId)]);
+	const queued = new Map<string, number>();
+	for (const id of ids) {
+		const n = requests.list(id).length;
+		if (n) queued.set(id, n);
+	}
+	const seen = readSeen(dir);
+	const runs = host.scheduler.store.allRuns();
+	const findings = host.scheduler.inbox.list();
+	const cwdOf = new Map(leaseList.flatMap((l) => (l.cwd ? [[l.sessionId, l.cwd] as const] : [])));
+	const now = Date.now();
+	// Each conversation's project, counted as its away card and session-start line count it.
+	const zero = { runs: 0, failed: 0, findings: 0, mine: 0 };
+	return {
+		snapshot: snapshot(),
+		managed,
+		sessions: sessionRows({
+			leases: leaseList,
+			plainJobSessions: jobs.map((j) => j.sessionId!),
+			ruleSessions: rules.map((r) => r.createdBy!.sessionId!),
+			mailbox: queued,
+			legacy,
+			alive: (h) => holderAlive(h),
+			since: (id) => {
+				const cwd = cwdOf.get(id);
+				return cwd ? sinceCounts(awayFor({ seen, runs, findings, cwd, sessionId: id, now, inProject: sameProject })) : zero;
+			},
+			title: sessionTitle,
+			jobName: (id) => allJobs.find((j) => j.id === id)?.name,
+		}),
+	};
+}
+
+/** The control channel's `abort`, and Stop it on the page's waiting page. The status lines show shortened ids, so that is what a watcher types back. */
+function abortRun(runId: string): boolean {
+	const match = host.scheduler.runningRuns().find((r) => r.runId === runId || r.runId.startsWith(runId));
+	return match ? host.scheduler.abortRun(match.runId) : false;
+}
+
+/** What src/host-control-channel.ts stopRunFrom needs of this process. */
+const stopHost = {
+	scheduler: { runningRuns: () => host.scheduler.runningRuns(), abortRun: (id: string, from: "page" | "cli") => host.scheduler.abortRun(id, from), noteStopFrom: (id: string, from: "page" | "cli") => host.scheduler.noteStopFrom(id, from) },
+	heldTurn: (sessionId: string) => host.heldTurn(sessionId),
+	ring: (sessionId: string) => host.ring(sessionId),
+	leases: () => leases.list(),
+	append: (row: Parameters<typeof requests.append>[0]) => void requests.append(row),
+	createdBy: () => ({ pid: process.pid, instance: "host", procStart: procStart(process.pid), version: PI_LOOPS_VERSION }),
+};
+
+/* ------------------------------------------------------------ the page */
+
+/** The browser page, on the port `pageBindPort` picks. A taken port costs the page, never the loops. */
+const pageBind = {
+	host: config.pageHost,
+	port: pageBindPort(config, { defaultDir: path.resolve(dir) === path.resolve(homeLoopsDir(agentDir)), env: process.env.PI_LOOPS_PAGE_PORT }),
+};
+const pageWhere = `${pageBind.host}:${pageBind.port}`;
+const pageOnLoopback = ["127.0.0.1", "::1", "localhost"].includes(pageBind.host);
+let page: PageServer | undefined;
+let pageUrl: string | undefined;
+/** Why the page is not served yet. An older page's port is tried again every tick; another program's only after a restart. */
+let pageWaiting: { reason: "older-page" | "other-program"; since: string } | undefined;
+/** The bind under way, if one is: the first at start, then one per tick while an older page holds the port. */
+let pageBinding: Promise<void> | undefined;
+
+function pageWaitingLine(reason: "older-page" | "other-program"): string {
+	return reason === "older-page" ? `waiting for ${pageWhere} (an older pi-loops page holds it)` : `not served: ${pageWhere} is used by another program (set [page] port in config.toml, then pi-loops restart)`;
+}
+
+/** Bind the page once: the server, or why not. `startPageServer` settles only on a bind, so a failed one is answered here. */
+function bindPage(): Promise<PageServer | NodeJS.ErrnoException> {
+	return new Promise((resolve) => {
+		let bound = false;
+		startPageServer({
+			dir,
+			bind: pageBind,
+			allowHosts: config.pageAllowHosts,
+			token: claimToken,
+			version: PI_LOOPS_VERSION,
+			pool,
+			sessions: { known: (id) => leases.read(id) ?? undefined },
+			sessionsRoot: path.join(agentDir, "sessions"),
+			heldTurn: (id) => host.heldTurn(id),
+			abortRun,
+			stopRun: stopRunFrom("person", false, stopHost),
+			ruleLook: (id) => host.triggers.ruleLook(id),
+			lastPage: () => readUiPrefs(dir).lastPage,
+			rememberPage: (id) => writeUiPref(dir, "lastPage", id),
+			background: hostStatus,
+			budget: () => host.scheduler.budgetState(),
+			log,
+			onListenError: (err) => {
+				if (bound) log(`page: ${err?.message ?? err}`);
+				else resolve(err);
+			},
+		}).then(
+			(server) => {
+				bound = true;
+				resolve(server);
+			},
+			(err: any) => resolve(err instanceof Error ? err : new Error(String(err))),
+		);
+	});
+}
+
+/**
+ * Whatever holds the port answers a plain GET. An older pi-loops page says `x-pi-loops-web: 1` and
+ * leaves when its terminal closes, so this waits for it; anything else is another program's port.
+ * No credential is sent to find out.
+ */
+async function whoHoldsThePort(): Promise<"older-page" | "other-program"> {
+	const probe = pageBind.host === "0.0.0.0" || pageBind.host === "::" ? "127.0.0.1" : pageBind.host;
+	try {
+		const answer = await fetch(`http://${probe.includes(":") ? `[${probe}]` : probe}:${pageBind.port}/`, { signal: AbortSignal.timeout(2000), redirect: "manual" });
+		return answer.headers.get("x-pi-loops-web") === "1" ? "older-page" : "other-program";
+	} catch {
+		return "other-program"; // it took the port and answers no HTTP: not a page of ours
+	}
+}
+
+async function bindPageOnce(): Promise<void> {
+	const got = await bindPage();
+	if (!(got instanceof Error)) {
+		page = got;
+		pageUrl = got.url();
+		pageWaiting = undefined;
+		try {
+			updateHostService(dir, process.pid, { url: pageUrl, pageWaiting: undefined });
+		} catch (err: any) {
+			log(`could not record the page: ${err?.message ?? err}`);
+		}
+		log(`page: ${pageUrl}`);
+		if (!pageOnLoopback) log(`page on the local network, unencrypted: ${lanAddresses(got.port())[0]?.url ?? `http://${pageBind.host}:${got.port()}/`}`);
+		return;
+	}
+	if (got.code !== "EADDRINUSE") {
+		log(`page unavailable: ${got.message}`);
+		return;
+	}
+	const reason = await whoHoldsThePort();
+	if (pageWaiting?.reason === reason) return;
+	pageWaiting = { reason, since: stamp() };
+	log(reason === "older-page" ? `page: ${pageWhere} is held by a pi-loops page from before 0.24; it is served here once that page exits` : `page unavailable: ${pageWhere} is used by another program; set [page] port in config.toml, then pi-loops restart`);
+	try {
+		updateHostService(dir, process.pid, { pageWaiting });
+	} catch (err: any) {
+		log(`could not record the page: ${err?.message ?? err}`);
+	}
+}
+
+/** One bind at a time: the first at start, then one per tick while an older page holds the port. */
+function bindPageAndSay(): Promise<void> {
+	pageBinding = bindPageOnce()
+		.catch((err: any) => log(`page: ${err?.message ?? err}`))
+		.finally(() => {
+			pageBinding = undefined;
+		});
+	return pageBinding;
+}
+
+/**
+ * `page-open` over the socket (`openForLaunch`). One that arrives during the first bind starts its
+ * pi at once and answers when the bind settles; one that arrives while the port is held is refused.
+ */
+async function pageOpen(req: Omit<PageOpenRequest, "op">): Promise<PageOpened> {
+	const notServed = () => (pageWaiting ? `the page is ${pageWaitingLine(pageWaiting.reason)}` : "the page is not served");
+	const server = page ? Promise.resolve(page) : !pageWaiting && pageBinding ? pageBinding.then(() => page) : undefined;
+	if (!server) return { error: notServed() };
+	return openForLaunch(req, {
+		pool,
+		server,
+		notServed,
+		heldTurn: (id) => host.heldTurn(id),
+		lease: (id) => leases.read(id) ?? undefined,
+	});
+}
+
+// The page binds while the socket already takes `page-open`: a launch's pi starts beside the bind.
+const firstBind = bindPageAndSay();
 const channel = serveHostChannelSafely(
 	dir,
 	{
-		status: () => {
-			// One read of each store for the whole snapshot. jobs.json was read four times and
-			// triggers.json twice, so a tick landing in between could have `enabled` counted against
-			// one version of the file and `total` against another — a status line contradicting itself.
-			const jobs = host.scheduler.store.load();
-			const rules = host.triggers.store.load();
-			return {
-				pid: process.pid,
-				host: os.hostname(),
-				startedAt,
-				model: session.model,
-				leader: host.scheduler.isLeader,
-				runs: host.scheduler.runningRuns(),
-				checks: host.triggers.runningList().map((r) => ({ traceId: r.traceId, sourceLabel: r.sourceLabel, eventLabel: r.eventLabel, startedAt: r.startedAt, cwd: r.cwd })),
-				jobs: { enabled: jobs.filter((j) => j.enabled).length, total: jobs.length },
-				rules: { enabled: rules.filter((r) => r.enabled).length, total: rules.length },
-				inboxNew: host.scheduler.inbox.newCount(),
-				// Without these a host that has failed every run for six hours reads exactly like one
-				// that succeeded an hour ago: "nothing running right now".
-				recent: host.scheduler.store
-					.listRuns(undefined, 5)
-					.reverse()
-					.map((r) => ({ job: r.jobName ?? r.jobId, at: r.finishedAt, ok: r.ok, error: r.error ? previewRedacted(r.error, 100) : undefined, cost: r.usage?.cost })),
-				failing: jobs.filter((j) => j.enabled && j.lastError).map((j) => ({ job: j.name ?? j.id, error: previewRedacted(j.lastError ?? "", 120) })),
-				nextDue: (() => {
-					const next = jobs
-						.filter((j) => j.enabled && j.stateful)
-						.map((j) => computeNext({ schedule: j.schedule, createdAt: Date.parse(j.createdAt), lastFiredAt: j.lastFiredAt ? Date.parse(j.lastFiredAt) : undefined }, Date.now()))
-						.filter((n): n is number => n !== undefined)
-						.sort((a, b) => a - b)[0];
-					return next ? stamp(next) : undefined;
-				})(),
-				budget: (() => {
-					const b = host.scheduler.budgetState();
-					return b.cap > 0 ? { spent: b.spent, cap: b.cap } : undefined;
-				})(),
-				mcp: mcpSources.map((s) => ({ name: s.config.name, state: s.status.state, lastError: s.status.lastError ? previewRedacted(s.status.lastError, 120) : undefined })),
-			};
-		},
-		// The status lines show shortened ids, so that is what a watcher types back.
-		abortRun: (runId) => {
-			const match = host.scheduler.runningRuns().find((r) => r.runId === runId || r.runId.startsWith(runId));
-			return match ? host.scheduler.abortRun(match.runId) : false;
-		},
+		status: () => snapshot(),
+		abortRun,
+		stopRun: stopRunFrom("cli", true, stopHost),
 		abortCheck: (traceId) => {
 			const match = host.triggers.runningList().find((r) => r.traceId === traceId || r.traceId.startsWith(traceId));
 			return match ? host.triggers.abort(match.traceId) : false;
 		},
-		stop: () => leave(0),
+		// Called once, or twice when a plain stop cuts a restart's or an upgrade's wait short: that
+		// `stop` leaves at once, and the wait's own leave later finds the shutdown under way. A restart
+		// or an upgrade first lets a turn in the page finish, up to PAGE_TURN_WAIT_MS; a signal still
+		// leaves at once.
+		stop: (reason) => {
+			log(reason === "upgrade" ? "a newer pi-loops asked this process to make way; leaving" : reason === "restart" ? "asked to restart; leaving" : "asked to stop; leaving");
+			if (!stopWaitsForPage(reason)) return leave(0);
+			waitForPageTurns({ busy: () => pool.views().filter((c) => c.busy).length, log })
+				.catch((err: any) => log(`waiting for the page: ${err?.message ?? err}`))
+				.finally(() => leave(0))
+				.catch((err: any) => log(`leaving: ${err?.message ?? err}`));
+		},
+		run: (jobId, requestedBy) => host.scheduler.runNow(jobId, requestedBy),
+		ring: (sessionId) => host.ring(sessionId),
+		pageOpen,
+		pageKey: (sessionId) => {
+			if (!page) return { error: "the page is not served" };
+			if (!pool.has(sessionId) && !leases.read(sessionId)) return { error: `pi-loops knows no conversation ${shortSessionId(sessionId)}` };
+			return { openKey: page.openKeyFor(sessionId) };
+		},
+		pair: () => (page ? { code: page.newPairCode(), addresses: pageOnLoopback ? [] : lanAddresses(page.port()).map((a) => a.url) } : { error: "the page is not served" }),
 	},
 	log,
 );
+await firstBind;
 parentModel = await defaultModel().catch((err) => {
 	log(`default model: ${err?.message ?? err}`);
 	return undefined;
@@ -308,15 +828,31 @@ parentModel = await defaultModel().catch((err) => {
 log(`default model: ${parentModel ? `${parentModel.provider}/${parentModel.id}` : "none (jobs must pin one)"}`);
 startMcpSources();
 host.start();
+// As in the minute timer below: a rules file that cannot be read must cost its rules, not every loop.
+try {
+	watchProjectPushServers();
+} catch (err: any) {
+	log(`project push servers: ${err?.message ?? err}`);
+}
 // The scheduler's timer is unref'd (an extension must never keep pi alive); the host wants to live,
 // and re-reads config.toml so edits take effect without a restart.
 setInterval(() => {
+	try {
+		watchProjectPushServers();
+	} catch (err: any) {
+		log(`project push servers: ${err?.message ?? err}`);
+	}
 	config = loadConfig(dir);
 	logConfigErrors();
+	try {
+		reloadMcpIfChanged();
+	} catch (err: any) {
+		log(`mcp.toml: ${err?.message ?? err}`);
+	}
 	host.triggers.pollIntervalSecs = config.triggerPollIntervalSecs;
 	host.triggers.runTimeoutMs = config.triggerRunTimeoutMs;
 	// And the model, on the same minute. This process can live for days: a credential added with
-	// `/login` in a pi that opened after the hand-off, or a provider that started resolving, would
+	// `/login` in a pi that opened after this host started, or a provider that started resolving, would
 	// otherwise never reach it — `parentModel` was resolved once, at startup. Only an improvement is
 	// taken: a model that stops resolving leaves the one the host already has in place.
 	void defaultModel()