@overdeck/desktop 0.49.1 → 0.49.2

package/server/agent-idle-ONBssBN_.js

@@ -0,0 +1,745 @@
+import { Li as getOverdeckHome, Ri as init_paths, Vi as packageRoot, ci as init_errors } from "./config-yaml-D9nfpEx1.js";
+import { A as listPaneValuesSync, B as sendKeys, C as init_tmux, D as killSessionSync, W as sessionExistsSync, v as getManagedTmuxSocketName } from "./tmux-DWEc4Ld9.js";
+import { c as getRuntimeBehavior, i as CLAUDE_CODE_BEHAVIOR } from "./src-CY2Wl8IX.js";
+import { A as saveAgentStateSync, K as saveAgentRuntimeState, Qr as init_pi_fifo, W as getAgentRuntimeStateSync, _n as listAgentStates, _r as init_bridge_token, ci as determineModel, f as getAgentDir, g as getAgentStateSync, gn as init_queries, gr as BRIDGE_TOKEN_HEADER, in as init_ohmypi, ni as init_context, on as spawnAgent, q as init_agents, ri as materializeAcpContextFile, rn as createOhmypiRuntimeSync } from "./agent-state-BJhGIJZe.js";
+import { t as init_behavior } from "./behavior-BiCQzqyT.js";
+import { w as init_launcher_generator } from "./auto-spawn-consent-Dc4mtM-B.js";
+import { _ as tmuxKillSession, g as tmuxCreateSession, h as init_tmux_cli, i as createCodexRuntimeSync, l as init_codex, v as tmuxSessionExists } from "./codex-KaSKE-R3.js";
+import { i as prepareHarnessLaunch, r as init_harness_binary } from "./harness-binary-tMmgJfC1.js";
+import { a as init_jsonl_parser, i as getSessionFilesSync, r as getProjectDirsSync, s as parseClaudeSessionSync } from "./jsonl-parser-DqxVCZ1k.js";
+import { i as createKimiCodeRuntimeSync, l as init_kimi_code } from "./kimi-code-BjtAHIz1.js";
+import { join } from "node:path";
+import { Effect } from "effect";
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { join as join$1 } from "path";
+import { homedir } from "os";
+import "node:os";
+import { existsSync as existsSync$1, readFileSync as readFileSync$1, rmSync as rmSync$1, statSync as statSync$1 } from "node:fs";
+import "node:crypto";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import { request } from "node:http";
+//#region ../../lib/runtimes/claude-code.ts
+init_paths();
+init_harness_binary();
+init_launcher_generator();
+init_bridge_token();
+init_queries();
+/**
+* Claude Code Runtime Implementation
+*
+* Implements AgentRuntime for Claude Code CLI.
+*
+* Session storage: ~/.claude/projects/<workspace-hash>/<session-id>.jsonl
+* Session index: ~/.claude/projects/<workspace-hash>/sessions-index.json
+*/
+init_behavior();
+init_agents();
+init_tmux();
+init_jsonl_parser();
+init_errors();
+const CLAUDE_PROJECTS_DIR = join$1(homedir(), ".claude", "projects");
+/**
+* Claude Code Runtime implementation
+*/
+var ClaudeCodeRuntimeSync = class {
+	name = "claude-code";
+	getHarnessBehavior() {
+		return CLAUDE_CODE_BEHAVIOR;
+	}
+	/**
+	* Get the project directory for a workspace
+	*
+	* Claude Code hashes the workspace path to create project directories.
+	* We need to find the project directory that contains sessions for this workspace.
+	*/
+	getProjectDirForWorkspace(workspace) {
+		if (!existsSync(CLAUDE_PROJECTS_DIR)) return null;
+		const projectDirs = getProjectDirsSync();
+		for (const projectDir of projectDirs) {
+			const indexPath = join$1(projectDir, "sessions-index.json");
+			if (existsSync(indexPath)) try {
+				if (readFileSync(indexPath, "utf-8").includes(workspace)) return projectDir;
+			} catch {}
+		}
+		return null;
+	}
+	/**
+	* Get the active session ID for an agent from the sessions index
+	*/
+	getActiveSessionId(projectDir) {
+		const indexPath = join$1(projectDir, "sessions-index.json");
+		if (!existsSync(indexPath)) return null;
+		try {
+			const indexContent = readFileSync(indexPath, "utf-8");
+			const index = JSON.parse(indexContent);
+			if (index.sessions && Array.isArray(index.sessions)) {
+				const sessions = index.sessions;
+				if (sessions.length === 0) return null;
+				return sessions.sort((a, b) => {
+					return new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime();
+				})[0].sessionId;
+			}
+		} catch {}
+		return null;
+	}
+	/**
+	* Get the most recent JSONL file for a project
+	*/
+	getMostRecentJSONL(projectDir) {
+		const files = getSessionFilesSync(projectDir);
+		return files.length > 0 ? files[0] : null;
+	}
+	/**
+	* Get the session path for an agent
+	*/
+	getSessionPath(agentId) {
+		const state = getAgentStateSync(agentId);
+		if (!state) return null;
+		const projectDir = this.getProjectDirForWorkspace(state.workspace);
+		if (!projectDir) return null;
+		const sessionId = this.getActiveSessionId(projectDir);
+		if (sessionId) {
+			const sessionPath = join$1(projectDir, `${sessionId}.jsonl`);
+			if (existsSync(sessionPath)) return sessionPath;
+		}
+		return this.getMostRecentJSONL(projectDir);
+	}
+	/**
+	* Get last activity timestamp for an agent
+	*
+	* Uses passive detection via JSONL file modification time.
+	*/
+	getLastActivity(agentId) {
+		const sessionPath = this.getSessionPath(agentId);
+		if (!sessionPath || !existsSync(sessionPath)) return null;
+		try {
+			return statSync(sessionPath).mtime;
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Read active heartbeat file if it exists
+	*/
+	getActiveHeartbeat(agentId) {
+		const heartbeatPath = join$1(homedir(), ".overdeck", "heartbeats", `${agentId}.json`);
+		if (!existsSync(heartbeatPath)) return null;
+		try {
+			const content = readFileSync(heartbeatPath, "utf-8");
+			const data = JSON.parse(content);
+			const timestamp = new Date(data.timestamp);
+			if ((/* @__PURE__ */ new Date()).getTime() - timestamp.getTime() > 300 * 1e3) return null;
+			return {
+				timestamp,
+				agentId: data.agent_id || agentId,
+				source: "active-heartbeat",
+				confidence: "high",
+				toolName: data.tool_name,
+				lastAction: data.last_action,
+				currentTask: data.current_task,
+				gitBranch: data.git_branch,
+				workspace: data.workspace,
+				pid: data.pid,
+				sessionId: data.session_id
+			};
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Get passive heartbeat from file timestamps
+	*/
+	getPassiveHeartbeat(agentId) {
+		const lastActivity = this.getLastActivity(agentId);
+		if (!lastActivity) return null;
+		return {
+			timestamp: lastActivity,
+			agentId,
+			source: "jsonl",
+			confidence: "medium"
+		};
+	}
+	/**
+	* Get heartbeat for an agent
+	*
+	* Tries active heartbeat first (if hooks configured), falls back to passive.
+	*/
+	getHeartbeat(agentId) {
+		const activeHeartbeat = this.getActiveHeartbeat(agentId);
+		if (activeHeartbeat) return activeHeartbeat;
+		return this.getPassiveHeartbeat(agentId);
+	}
+	/**
+	* Get token usage for an agent's current session
+	*/
+	getTokenUsage(agentId) {
+		const sessionPath = this.getSessionPath(agentId);
+		if (!sessionPath) return null;
+		const sessionUsage = parseClaudeSessionSync(sessionPath);
+		if (!sessionUsage) return null;
+		return sessionUsage.usage;
+	}
+	/**
+	* Get cost breakdown for an agent's current session
+	*/
+	getSessionCost(agentId) {
+		const sessionPath = this.getSessionPath(agentId);
+		if (!sessionPath) return null;
+		const sessionUsage = parseClaudeSessionSync(sessionPath);
+		if (!sessionUsage) return null;
+		const inputPrice = 3 / 1e6;
+		const outputPrice = 15 / 1e6;
+		const cacheReadPrice = .3 / 1e6;
+		const cacheWritePrice = 3.75 / 1e6;
+		const usage = sessionUsage.usage;
+		const inputCost = usage.inputTokens * inputPrice;
+		const outputCost = usage.outputTokens * outputPrice;
+		const cacheReadCost = (usage.cacheReadTokens || 0) * cacheReadPrice;
+		const cacheWriteCost = (usage.cacheWriteTokens || 0) * cacheWritePrice;
+		return {
+			inputCost,
+			outputCost,
+			cacheReadCost,
+			cacheWriteCost,
+			totalCost: inputCost + outputCost + cacheReadCost + cacheWriteCost,
+			currency: "USD"
+		};
+	}
+	/**
+	* Send a message to a running agent
+	*/
+	async sendMessage(agentId, message) {
+		if (!sessionExistsSync(agentId)) throw new Error(`Agent ${agentId} is not running`);
+		await Effect.runPromise(sendKeys(agentId, message));
+		const mailDir = join$1(getAgentDir(agentId), "mail");
+		mkdirSync(mailDir, { recursive: true });
+		writeFileSync(join$1(mailDir, `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.md`), `# Message\n\n${message}\n`);
+	}
+	/**
+	* Kill an agent
+	*/
+	killAgent(agentId) {
+		if (!sessionExistsSync(agentId)) throw new Error(`Agent ${agentId} is not running`);
+		killSessionSync(agentId);
+		saveAgentRuntimeState(agentId, {
+			state: "idle",
+			lastActivity: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		const state = getAgentStateSync(agentId);
+		if (state) {
+			state.status = "stopped";
+			saveAgentStateSync(state);
+		}
+	}
+	/**
+	* Spawn a new agent
+	*/
+	async spawnAgent(config) {
+		const state = await spawnAgent({
+			issueId: config.agentId.replace(/^agent-/, ""),
+			workspace: config.workspace,
+			harness: "claude-code",
+			model: determineModel({
+				model: config.model,
+				role: "work",
+				spawnKey: `work:${config.agentId.replace(/^agent-/, "")}`
+			}),
+			role: "work",
+			prompt: config.prompt,
+			startedBy: config.env?.["OVERDECK_AGENT_STARTED_BY"] ?? "runtime:claude-code"
+		});
+		const projectDir = this.getProjectDirForWorkspace(config.workspace);
+		const sessionId = projectDir ? this.getActiveSessionId(projectDir) : void 0;
+		return {
+			id: state.id,
+			sessionId: sessionId || "unknown",
+			runtime: "claude-code",
+			model: state.model,
+			workspace: state.workspace,
+			startedAt: new Date(state.startedAt)
+		};
+	}
+	/**
+	* List all sessions for this runtime
+	*/
+	listSessions(workspace) {
+		const sessions = [];
+		if (workspace) {
+			const projectDir = this.getProjectDirForWorkspace(workspace);
+			if (projectDir) {
+				const files = getSessionFilesSync(projectDir);
+				for (const file of files) {
+					const session = this.parseSessionFile(file, workspace);
+					if (session) sessions.push(session);
+				}
+			}
+		} else {
+			const projectDirs = getProjectDirsSync();
+			for (const projectDir of projectDirs) {
+				const files = getSessionFilesSync(projectDir);
+				for (const file of files) {
+					const session = this.parseSessionFile(file);
+					if (session) sessions.push(session);
+				}
+			}
+		}
+		return sessions;
+	}
+	/**
+	* Parse a session file into a Session object
+	*/
+	parseSessionFile(file, workspace) {
+		const sessionUsage = parseClaudeSessionSync(file);
+		if (!sessionUsage) return null;
+		const stat = statSync(file);
+		return {
+			id: sessionUsage.sessionId,
+			agentId: "unknown",
+			workspace: workspace || "unknown",
+			model: sessionUsage.model,
+			startedAt: new Date(sessionUsage.startTime),
+			lastActivity: stat.mtime,
+			tokenUsage: sessionUsage.usage
+		};
+	}
+	/**
+	* Check if an agent is running
+	*/
+	isRunning(agentId) {
+		return sessionExistsSync(agentId);
+	}
+};
+/**
+* Create a Claude Code runtime instance
+*/
+function createClaudeCodeRuntimeSync() {
+	return new ClaudeCodeRuntimeSync();
+}
+//#endregion
+//#region ../../lib/cost-parsers/pi-parser.ts
+init_errors();
+//#endregion
+//#region ../../lib/runtimes/pi.ts
+init_behavior();
+init_tmux();
+init_pi_fifo();
+init_errors();
+promisify(exec);
+//#endregion
+//#region ../../lib/runtimes/acp.ts
+init_codex();
+init_ohmypi();
+init_tmux();
+init_context();
+init_harness_binary();
+init_paths();
+init_behavior();
+init_tmux_cli();
+const execAsync = promisify(exec);
+const HOST_REQUEST_TIMEOUT_MS = 5e3;
+const SPAWN_READY_TIMEOUT_MS = 3e4;
+const POLL_INTERVAL_MS = 100;
+var AcpSpawnTimeout = class extends Error {
+	code = "ACP_SPAWN_TIMEOUT";
+	constructor(agentId) {
+		super(`ACP agent ${agentId} did not write acp-session-id within ${SPAWN_READY_TIMEOUT_MS}ms`);
+		this.name = "AcpSpawnTimeout";
+	}
+};
+var AcpRuntimeSync = class {
+	name = "acp";
+	provider;
+	overdeckHome;
+	execCommand;
+	prepareLaunch;
+	resolveAgentStates;
+	constructor(options = {}) {
+		this.provider = options.provider ?? "kimi";
+		this.overdeckHome = options.overdeckHome;
+		this.execCommand = options.execCommand ?? execAsync;
+		this.prepareLaunch = options.prepareLaunch ?? (() => prepareHarnessLaunch("acp"));
+		this.resolveAgentStates = options.listAgentStates ?? (() => listAgentStates());
+	}
+	getHarnessBehavior() {
+		return getRuntimeBehavior("acp");
+	}
+	getSessionPath(agentId) {
+		return join(this.home(), "agents", agentId, "acp-session.jsonl");
+	}
+	getLastActivity(agentId) {
+		try {
+			return statSync$1(this.getSessionPath(agentId)).mtime;
+		} catch {
+			return null;
+		}
+	}
+	getHeartbeat(agentId) {
+		const lastActivity = this.getLastActivity(agentId);
+		if (!lastActivity) return null;
+		return {
+			timestamp: lastActivity,
+			agentId,
+			source: "jsonl",
+			confidence: "medium"
+		};
+	}
+	getTokenUsage(_agentId) {
+		return null;
+	}
+	getSessionCost(_agentId) {
+		return null;
+	}
+	async sendMessage(agentId, message) {
+		const socketPath = this.socketPath(agentId);
+		if (!existsSync$1(socketPath)) throw new Error(`ACP agent ${agentId}: host socket is not available`);
+		const token = this.readToken(agentId);
+		if (!token) throw new Error(`ACP agent ${agentId}: missing acp-token`);
+		await postUnixSocketJson(socketPath, token, {
+			op: "message",
+			content: message
+		}, HOST_REQUEST_TIMEOUT_MS);
+	}
+	async killAgent(agentId) {
+		const socketPath = this.socketPath(agentId);
+		const token = this.readToken(agentId);
+		if (existsSync$1(socketPath) && token) try {
+			await postUnixSocketJson(socketPath, token, { op: "interrupt" }, HOST_REQUEST_TIMEOUT_MS);
+		} catch {}
+		if (await pollUntilSessionGone(agentId, 2e3)) return;
+		let panePid = null;
+		try {
+			const { stdout } = await this.execCommand(`tmux -L ${shellQuote(getManagedTmuxSocketName())} list-panes -t ${shellQuote(agentId)} -F '#{pane_pid}' 2>/dev/null`);
+			panePid = stdout.trim() || null;
+			if (panePid) await this.execCommand(`kill -TERM -- -${panePid} 2>/dev/null || kill -TERM ${panePid} 2>/dev/null || true`);
+		} catch {}
+		if (await pollUntilSessionGone(agentId, 5e3)) return;
+		if (panePid) try {
+			await this.execCommand(`kill -KILL -- -${panePid} 2>/dev/null || kill -KILL ${panePid} 2>/dev/null || true`);
+		} catch {}
+		if (await tmuxSessionExists(agentId)) await tmuxKillSession(agentId);
+	}
+	async spawnAgent(config) {
+		const provider = config.provider ?? this.provider;
+		const { binaryPath } = await this.prepareLaunch();
+		const contextFile = materializeAcpContextFile(join(this.home(), "agents", config.agentId), config.workspace);
+		const command = [
+			"node",
+			shellQuote(join(packageRoot, "dist", "acp-host.js")),
+			"--agent",
+			shellQuote(config.agentId),
+			"--provider",
+			shellQuote(provider),
+			"--workspace",
+			shellQuote(config.workspace),
+			"--binary-path",
+			shellQuote(binaryPath),
+			"--context-file",
+			shellQuote(contextFile)
+		];
+		if (config.sessionId) command.push("--resume", shellQuote(config.sessionId));
+		if (config.model) command.push("--model", shellQuote(config.model));
+		rmSync$1(this.agentPath(config.agentId, "acp-session-id"), { force: true });
+		rmSync$1(this.agentPath(config.agentId, "acp-launch-error"), { force: true });
+		await tmuxCreateSession(config.agentId, config.workspace, command.join(" "), {
+			...config.env,
+			OVERDECK_AGENT_ID: config.agentId
+		});
+		try {
+			const sessionId = await this.waitForSessionId(config.agentId);
+			if (!sessionId) throw new AcpSpawnTimeout(config.agentId);
+			if (config.prompt) await this.sendMessage(config.agentId, config.prompt);
+			return {
+				id: config.agentId,
+				sessionId,
+				runtime: "acp",
+				model: config.model ?? "",
+				workspace: config.workspace,
+				startedAt: /* @__PURE__ */ new Date()
+			};
+		} catch (error) {
+			if (await tmuxSessionExists(config.agentId)) await tmuxKillSession(config.agentId);
+			throw error;
+		}
+	}
+	listSessions(workspace) {
+		const sessions = [];
+		for (const state of this.resolveAgentStates()) {
+			if (state.harness !== "acp") continue;
+			if (workspace && state.workspace !== workspace) continue;
+			const sessionId = this.readSessionId(state.id);
+			if (!sessionId) continue;
+			const sessionPath = this.getSessionPath(state.id);
+			let lastActivity;
+			try {
+				lastActivity = statSync$1(sessionPath).mtime;
+			} catch {
+				try {
+					lastActivity = statSync$1(this.agentPath(state.id, "acp-session-id")).mtime;
+				} catch {
+					continue;
+				}
+			}
+			sessions.push({
+				id: sessionId,
+				agentId: state.id,
+				workspace: state.workspace,
+				model: state.model ?? "",
+				startedAt: new Date(state.startedAt),
+				lastActivity,
+				tokenUsage: {
+					inputTokens: 0,
+					outputTokens: 0
+				}
+			});
+		}
+		return sessions;
+	}
+	async isRunning(agentId) {
+		return tmuxSessionExists(agentId);
+	}
+	home() {
+		return this.overdeckHome ?? getOverdeckHome();
+	}
+	agentPath(agentId, file) {
+		return join(this.home(), "agents", agentId, file);
+	}
+	socketPath(agentId) {
+		return join(this.home(), "sockets", `acp-${agentId}.sock`);
+	}
+	readToken(agentId) {
+		try {
+			return readFileSync$1(this.agentPath(agentId, "acp-token"), "utf8").trim() || null;
+		} catch {
+			return null;
+		}
+	}
+	readLaunchError(agentId) {
+		try {
+			return readFileSync$1(this.agentPath(agentId, "acp-launch-error"), "utf8").trim() || null;
+		} catch {
+			return null;
+		}
+	}
+	readSessionId(agentId) {
+		try {
+			return readFileSync$1(this.agentPath(agentId, "acp-session-id"), "utf8").trim() || null;
+		} catch {
+			return null;
+		}
+	}
+	async waitForSessionId(agentId) {
+		const deadline = Date.now() + SPAWN_READY_TIMEOUT_MS;
+		while (Date.now() < deadline) {
+			const launchError = this.readLaunchError(agentId);
+			if (launchError) throw new Error(`ACP host ${agentId} failed to start: ${launchError}`);
+			const sessionId = this.readSessionId(agentId);
+			if (sessionId) return sessionId;
+			await delay(POLL_INTERVAL_MS);
+		}
+		return null;
+	}
+};
+async function pollUntilSessionGone(agentId, timeoutMs) {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		if (!await tmuxSessionExists(agentId)) return true;
+		await delay(POLL_INTERVAL_MS);
+	}
+	return false;
+}
+function delay(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function shellQuote(value) {
+	return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function postUnixSocketJson(socketPath, token, body, timeoutMs) {
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		let timeout;
+		const finish = (callback) => {
+			if (settled) return;
+			settled = true;
+			if (timeout) clearTimeout(timeout);
+			callback();
+		};
+		const client = request({
+			socketPath,
+			path: "/",
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+				[BRIDGE_TOKEN_HEADER]: token
+			}
+		}, (response) => {
+			const chunks = [];
+			response.on("data", (chunk) => chunks.push(chunk));
+			response.on("end", () => {
+				const responseBody = Buffer.concat(chunks).toString("utf8");
+				const status = response.statusCode ?? 0;
+				if (status < 200 || status >= 300) {
+					finish(() => reject(/* @__PURE__ */ new Error(`ACP host returned HTTP ${status}: ${responseBody}`)));
+					return;
+				}
+				finish(() => resolve({
+					status,
+					body: responseBody
+				}));
+			});
+		});
+		if (timeoutMs !== void 0) {
+			timeout = setTimeout(() => {
+				client.destroy(/* @__PURE__ */ new Error(`ACP host request timed out after ${timeoutMs}ms`));
+			}, timeoutMs);
+			timeout.unref?.();
+		}
+		client.once("error", (error) => finish(() => reject(error)));
+		client.end(JSON.stringify(body));
+	});
+}
+function createAcpRuntimeSync(options = {}) {
+	return new AcpRuntimeSync(options);
+}
+//#endregion
+//#region ../../lib/runtimes/index.ts
+init_behavior();
+init_kimi_code();
+init_agents();
+/**
+* Runtime registry implementation
+*
+* Manages multiple runtime adapters and provides lookup by agent ID.
+*/
+var RuntimeRegistry = class {
+	runtimes = /* @__PURE__ */ new Map();
+	/**
+	* Register a runtime adapter
+	*/
+	register(runtime) {
+		this.runtimes.set(runtime.name, runtime);
+	}
+	/**
+	* Get a runtime by name
+	*/
+	get(name) {
+		return this.runtimes.get(name);
+	}
+	/**
+	* Get all registered runtimes
+	*/
+	getAll() {
+		return Array.from(this.runtimes.values());
+	}
+	/**
+	* Get the runtime for a specific agent.
+	*
+	* Reads the agent's state file and dispatches by `state.harness`. When
+	* the harness field is missing or carries a legacy value (e.g. 'claude'
+	* from pre-PAN-636 wire format), we fall back to the claude-code runtime
+	* to preserve back-compat (PAN-636 ac2).
+	*/
+	getRuntimeForAgent(agentId) {
+		const state = getAgentStateSync(agentId);
+		if (!state) return null;
+		const harness = state.harness;
+		if (harness === "ohmypi" || harness === "pi") return this.get("ohmypi") ?? null;
+		if (harness === "codex") return this.get("codex") ?? null;
+		if (harness === "acp") return this.get("acp") ?? null;
+		if (harness === "kimi-code") return this.get("kimi-code") ?? null;
+		return this.get("claude-code") ?? null;
+	}
+};
+/**
+* Global runtime registry instance
+*/
+let globalRegistry = null;
+/**
+* Get the global runtime registry
+*
+* Creates a new registry if one doesn't exist.
+* Registers Claude Code runtime by default.
+*/
+function getGlobalRegistry() {
+	if (!globalRegistry) {
+		globalRegistry = new RuntimeRegistry();
+		globalRegistry.register(createClaudeCodeRuntimeSync());
+		globalRegistry.register(createOhmypiRuntimeSync());
+		globalRegistry.register(createCodexRuntimeSync());
+		globalRegistry.register(createAcpRuntimeSync());
+		globalRegistry.register(createKimiCodeRuntimeSync());
+	}
+	return globalRegistry;
+}
+/**
+* Helper to get the runtime for an agent from the global registry
+*/
+function getRuntimeForAgent(agentId) {
+	return getGlobalRegistry().getRuntimeForAgent(agentId);
+}
+//#endregion
+//#region ../../lib/cloister/agent-idle.ts
+init_agents();
+init_tmux();
+function getAgentEffectiveLastActivityMs(agentId) {
+	const candidates = [];
+	const runtimeState = getAgentRuntimeStateSync(agentId);
+	const runtimeMs = runtimeState?.lastActivity ? new Date(runtimeState.lastActivity).getTime() : NaN;
+	if (Number.isFinite(runtimeMs)) candidates.push(runtimeMs);
+	try {
+		const tmuxActivity = listPaneValuesSync(agentId, "#{window_activity}").map((value) => Number.parseInt(value.trim(), 10) * 1e3).filter(Number.isFinite);
+		candidates.push(...tmuxActivity);
+	} catch {}
+	try {
+		const heartbeat = getRuntimeForAgent(agentId)?.getHeartbeat(agentId);
+		if (heartbeat?.timestamp) {
+			const heartbeatMs = heartbeat.timestamp.getTime();
+			if (Number.isFinite(heartbeatMs)) candidates.push(heartbeatMs);
+		}
+	} catch {}
+	return candidates.length > 0 ? Math.max(...candidates) : null;
+}
+/**
+* PAN-3677: work-product activity only — the runtime mirror (hook-driven) plus
+* the transcript heartbeat, deliberately EXCLUDING tmux `window_activity`.
+* Claude Code repaints its spinner / background-task panel every second while a
+* turn is in flight, so `window_activity` stays fresh even when the provider
+* call is hung and no work is happening. A mid-turn wedge detector keyed on
+* {@link getAgentEffectiveLastActivityMs} (which takes the MAX) would never see
+* the PAN-3677 planning wedge — the hung sessions looked busy on the pane for
+* minutes while producing no tool calls, no transcript writes, and no hook
+* events. This signal goes stale exactly when real work stops.
+*/
+function getAgentWorkActivityMs(agentId) {
+	const candidates = [];
+	const runtimeState = getAgentRuntimeStateSync(agentId);
+	const runtimeMs = runtimeState?.lastActivity ? new Date(runtimeState.lastActivity).getTime() : NaN;
+	if (Number.isFinite(runtimeMs)) candidates.push(runtimeMs);
+	try {
+		const heartbeat = getRuntimeForAgent(agentId)?.getHeartbeat(agentId);
+		if (heartbeat?.timestamp) {
+			const heartbeatMs = heartbeat.timestamp.getTime();
+			if (Number.isFinite(heartbeatMs)) candidates.push(heartbeatMs);
+		}
+	} catch {}
+	return candidates.length > 0 ? Math.max(...candidates) : null;
+}
+function isAgentIdleForNudge(agentId, staleActiveThresholdMs = 300 * 1e3, now = Date.now()) {
+	const runtimeState = getAgentRuntimeStateSync(agentId);
+	const effectiveLastActivityMs = getAgentEffectiveLastActivityMs(agentId);
+	if (!runtimeState) {
+		if (effectiveLastActivityMs === null) {
+			console.log(`[deacon] ${agentId}: no runtime.json — skipping (hook not yet fired)`);
+			return false;
+		}
+		return now - effectiveLastActivityMs > staleActiveThresholdMs;
+	}
+	if (runtimeState.state === "suspended" || runtimeState.state === "stopped") return false;
+	if (runtimeState.state === "waiting-on-human") return false;
+	if (runtimeState.state === "idle") return true;
+	return now - (effectiveLastActivityMs ?? new Date(runtimeState.lastActivity).getTime()) > staleActiveThresholdMs;
+}
+//#endregion
+export { getRuntimeForAgent as i, getAgentWorkActivityMs as n, isAgentIdleForNudge as r, getAgentEffectiveLastActivityMs as t };
+
+//# sourceMappingURL=agent-idle-ONBssBN_.js.map