opencode-zellij 0.0.1 → 0.0.3

package/dist/index.mjs

@@ -1,10 +1,131 @@
+import process from "node:process";
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import path, { join } from "node:path";
+import { parseJSON, parseJSONC } from "confbox";
+import { z } from "zod";
 import { randomUUID } from "node:crypto";
-import { setTimeout } from "node:timers/promises";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { tool } from "@opencode-ai/plugin";
-import { execFile, spawn } from "node:child_process";
-import process from "node:process";
+import { execFile, spawn, spawnSync } from "node:child_process";
 import { promisify } from "node:util";
+import { fileURLToPath } from "node:url";
 import { Buffer } from "node:buffer";
+//#region src/config.ts
+const sudoPaneSchema = z.enum([
+	"allow",
+	"deny",
+	"hide"
+]);
+const configFilenames = ["opencode-zellij.config.jsonc", "opencode-zellij.config.json"];
+const tabTitleLayerSchema = z.object({
+	enabled: z.boolean().optional().describe("Enable dynamic Zellij tab title updates."),
+	emojiIdle: z.string().optional().describe("Prefix used when OpenCode is idle."),
+	emojiRunning: z.string().optional().describe("Prefix used while OpenCode is running work."),
+	emojiNeedsInput: z.string().optional().describe("Prefix used when OpenCode is waiting for human input."),
+	emojiBranch: z.string().optional().describe("Prefix used before the current git branch name."),
+	debounceMs: z.number().finite().min(0).optional().describe("Debounce time for tab title updates in milliseconds.")
+}).strict();
+const ptyLayerSchema = z.object({
+	enabled: z.boolean().optional().describe("Enable Zellij-backed PTY tools."),
+	sudoPane: sudoPaneSchema.optional().describe("Controls whether the sudo pane tool is available, denied, or hidden.")
+}).strict();
+const sidecarConfigSchema = z.object({
+	$schema: z.string().optional().describe("JSON Schema URI for editor completion."),
+	tabTitle: tabTitleLayerSchema.optional(),
+	pty: ptyLayerSchema.optional()
+}).strict();
+const defaultConfig = {
+	tabTitle: {
+		enabled: true,
+		emojiIdle: "🟢",
+		emojiRunning: "⚡",
+		emojiNeedsInput: "💬",
+		emojiBranch: "🌱",
+		debounceMs: 300
+	},
+	pty: {
+		enabled: true,
+		sudoPane: "allow"
+	}
+};
+function validConfigLayer(value) {
+	const result = sidecarConfigSchema.safeParse(value);
+	if (!result.success) return void 0;
+	return {
+		tabTitle: result.data.tabTitle,
+		pty: result.data.pty
+	};
+}
+function mergeConfig(user, project) {
+	return {
+		tabTitle: {
+			enabled: project?.tabTitle?.enabled ?? user?.tabTitle?.enabled ?? defaultConfig.tabTitle.enabled,
+			emojiIdle: project?.tabTitle?.emojiIdle ?? user?.tabTitle?.emojiIdle ?? defaultConfig.tabTitle.emojiIdle,
+			emojiRunning: project?.tabTitle?.emojiRunning ?? user?.tabTitle?.emojiRunning ?? defaultConfig.tabTitle.emojiRunning,
+			emojiNeedsInput: project?.tabTitle?.emojiNeedsInput ?? user?.tabTitle?.emojiNeedsInput ?? defaultConfig.tabTitle.emojiNeedsInput,
+			emojiBranch: project?.tabTitle?.emojiBranch ?? user?.tabTitle?.emojiBranch ?? defaultConfig.tabTitle.emojiBranch,
+			debounceMs: project?.tabTitle?.debounceMs ?? user?.tabTitle?.debounceMs ?? defaultConfig.tabTitle.debounceMs
+		},
+		pty: {
+			enabled: project?.pty?.enabled ?? user?.pty?.enabled ?? defaultConfig.pty.enabled,
+			sudoPane: project?.pty?.sudoPane ?? user?.pty?.sudoPane ?? defaultConfig.pty.sudoPane
+		}
+	};
+}
+async function loadConfigLayer(directory, warnings) {
+	const configFile = detectConfigFile(directory);
+	if (!configFile) return {};
+	try {
+		const text = await readFile(configFile, "utf8");
+		const layer = validConfigLayer(configFile.endsWith(".jsonc") ? parseJSONC(text) : parseJSON(text));
+		if (!layer) {
+			warnings.push(`Ignoring invalid config shape in ${configFile}.`);
+			return { source: configFile };
+		}
+		return {
+			layer,
+			source: configFile
+		};
+	} catch (cause) {
+		warnings.push(`Ignoring unreadable or invalid config file ${configFile}: ${cause instanceof Error ? cause.message : String(cause)}`);
+		return {};
+	}
+}
+function detectConfigFile(directory) {
+	return configFilenames.map((filename) => join(directory, filename)).find((path) => existsSync(path));
+}
+function userConfigDir() {
+	return process.env.XDG_CONFIG_HOME ? join(process.env.XDG_CONFIG_HOME, "opencode") : join(homedir(), ".config", "opencode");
+}
+function projectConfigDirs(input) {
+	const dirs = [];
+	if (input.worktree) dirs.push(join(input.worktree, ".opencode"));
+	if (input.directory && input.directory !== input.worktree) dirs.push(join(input.directory, ".opencode"));
+	return dirs;
+}
+async function loadConfig(input) {
+	const warnings = [];
+	const sources = {};
+	const userResult = await loadConfigLayer(userConfigDir(), warnings);
+	const userLayer = userResult.layer;
+	if (userResult.source && userLayer) sources.user = userResult.source;
+	let projectLayer;
+	for (const projectDir of projectConfigDirs(input)) {
+		const projectResult = await loadConfigLayer(projectDir, warnings);
+		if (!projectResult.source) continue;
+		projectLayer = projectResult.layer;
+		if (projectLayer) sources.project = projectResult.source;
+		break;
+	}
+	return {
+		config: mergeConfig(userLayer, projectLayer),
+		sources,
+		warnings
+	};
+}
+//#endregion
 //#region src/utils/shell-args.ts
 const directCommandExitWrapper = "token=\"$1\"; shift; set +e; \"$@\"; code=$?; printf \"\\n[zellij-pty:%s] exit-code=%s\\n\" \"$token\" \"$code\"; exit \"$code\"";
 const shellCommandExitWrapper = "token=\"$1\"; command=\"$2\"; set +e; bash -lc \"$command\"; code=$?; printf \"\\n[zellij-pty:%s] exit-code=%s\\n\" \"$token\" \"$code\"; exit \"$code\"";
@@ -63,6 +184,9 @@ function wildcardMatches(pattern, commandLine) {
 	return new RegExp(`^${pattern.split("*").map(escapeRegex).join(".*")}$`).test(commandLine);
 }
 function configurePolicy(config) {
+	configuredDenyCommands = [];
+	configuredAllowCommands = [];
+	allowSudoPane = true;
 	if (!config || typeof config !== "object") return;
 	const object = config;
 	if (isStringArray(object.denyCommands)) configuredDenyCommands = object.denyCommands;
@@ -74,8 +198,8 @@ function assertCommandAllowed(input) {
 	for (const pattern of denyPatterns) if (pattern.test(commandLine)) throw new Error(`Command denied by zellij-pty policy: ${commandLine}`);
 	for (const pattern of configuredDenyCommands) if (wildcardMatches(pattern, commandLine)) throw new Error(`Command denied by zellij-pty configured deny rule: ${commandLine}`);
 	if (configuredAllowCommands.length > 0 && !configuredAllowCommands.some((pattern) => wildcardMatches(pattern, commandLine))) throw new Error(`Command denied by zellij-pty allow list: ${commandLine}`);
-	if (!input.humanInputOnly && sudoPattern.test(commandLine)) throw new Error("sudo commands must use request_sudo so credentials stay human-input-only and never pass through agent tool input.");
-	if (input.humanInputOnly && sudoPattern.test(commandLine) && !allowSudoPane) throw new Error("sudo pane is disabled by zellij-pty policy.");
+	if (!input.humanInputOnly && sudoPattern.test(commandLine)) throw new Error("sudo commands must use zellij_pty_request_sudo so credentials stay human-input-only and never pass through agent tool input.");
+	if (input.humanInputOnly && !allowSudoPane) throw new Error("sudo pane is disabled by zellij-pty policy.");
 }
 //#endregion
 //#region src/utils/ids.ts
@@ -159,7 +283,7 @@ var SessionManager = class {
 const sessionManager = new SessionManager();
 //#endregion
 //#region src/zellij/cli.ts
-const execFileAsync = promisify(execFile);
+const execFileAsync$1 = promisify(execFile);
 function zellijCommandArgs(actionArgs) {
 	const sessionName = process.env.ZELLIJ_SESSION_NAME?.trim();
 	if (sessionName) return [
@@ -185,6 +309,13 @@ function buildNewPaneActionArgs(options) {
 	args.push("--", ...buildCommandArgv(options, { exitCodeToken: options.exitCodeToken }));
 	return args;
 }
+function buildRenameTabActionArgs(title) {
+	return [
+		"action",
+		"rename-tab",
+		title
+	];
+}
 function ensureZellijTarget() {
 	if (process.env.ZELLIJ || process.env.ZELLIJ_SESSION_NAME) return;
 	throw new Error("Zellij context not found. Run OpenCode inside Zellij or set ZELLIJ_SESSION_NAME to an existing session.");
@@ -192,7 +323,7 @@ function ensureZellijTarget() {
 async function runZellij(actionArgs, options = {}) {
 	ensureZellijTarget();
 	try {
-		const result = await execFileAsync("zellij", zellijCommandArgs(actionArgs), {
+		const result = await execFileAsync$1("zellij", zellijCommandArgs(actionArgs), {
 			encoding: "utf8",
 			timeout: options.timeoutMs ?? 1e4,
 			maxBuffer: 20 * 1024 * 1024
@@ -230,6 +361,14 @@ var ZellijCli = class {
 	async closePane(paneId) {
 		await runZellij(zellijActionArgs("close-pane", ["--pane-id", paneId]));
 	}
+	closePaneSync(paneId) {
+		ensureZellijTarget();
+		spawnSync("zellij", zellijCommandArgs(zellijActionArgs("close-pane", ["--pane-id", paneId])), {
+			encoding: "utf8",
+			stdio: "ignore",
+			timeout: 2e3
+		});
+	}
 	async focusPane(paneId) {
 		await runZellij(zellijActionArgs("focus-pane-id", [paneId]));
 	}
@@ -240,9 +379,149 @@ var ZellijCli = class {
 			"--full"
 		]), { timeoutMs: 1e4 })).stdout;
 	}
+	async renameTab(title) {
+		await runZellij(buildRenameTabActionArgs(title));
+	}
 };
 const zellijCli = new ZellijCli();
 //#endregion
+//#region src/zellij/pane-watchdog.ts
+const instanceId = randomUUID();
+let watchdogStarted = false;
+function registryDirectory() {
+	const base = process.env.XDG_RUNTIME_DIR || tmpdir();
+	return path.join(base, `opencode-zellij-${process.getuid?.() ?? "user"}`);
+}
+function watchdogRegistryPath() {
+	return path.join(registryDirectory(), `panes-${process.pid}-${instanceId}.json`);
+}
+function parseLinuxProcessStartTime(stat) {
+	return stat.slice(stat.lastIndexOf(")") + 2).trim().split(/\s+/)[19] ?? null;
+}
+function linuxProcessStartTime(pid) {
+	try {
+		return parseLinuxProcessStartTime(readFileSync(`/proc/${pid}/stat`, "utf8"));
+	} catch {
+		return null;
+	}
+}
+function emptyRegistry() {
+	return {
+		version: 1,
+		instanceId,
+		ownerPid: process.pid,
+		ownerStartTime: linuxProcessStartTime(process.pid),
+		zellijSessionName: process.env.ZELLIJ_SESSION_NAME?.trim() || null,
+		panes: []
+	};
+}
+function readRegistry() {
+	const file = watchdogRegistryPath();
+	if (!existsSync(file)) return emptyRegistry();
+	try {
+		const parsed = JSON.parse(readFileSync(file, "utf8"));
+		if (parsed.version !== 1 || parsed.instanceId !== instanceId || parsed.ownerPid !== process.pid || !Array.isArray(parsed.panes)) return emptyRegistry();
+		return parsed;
+	} catch {
+		return emptyRegistry();
+	}
+}
+function writeRegistry(registry) {
+	mkdirSync(registryDirectory(), {
+		recursive: true,
+		mode: 448
+	});
+	const file = watchdogRegistryPath();
+	const tempFile = `${file}.tmp-${process.pid}`;
+	writeFileSync(tempFile, JSON.stringify(registry, null, 2), { mode: 384 });
+	renameSync(tempFile, file);
+}
+function ensureWatchdog() {
+	if (watchdogStarted) return;
+	watchdogStarted = true;
+	spawn("node", [watchdogRunnerPath(), watchdogRegistryPath()], {
+		detached: true,
+		stdio: "ignore",
+		env: process.env
+	}).unref();
+}
+function watchdogRunnerPath() {
+	return fileURLToPath(new URL("./pane-watchdog-runner.mjs", import.meta.url));
+}
+function cleanupStaleWatchdogRegistries() {
+	const directory = registryDirectory();
+	if (!existsSync(directory)) return;
+	for (const fileName of readdirSync(directory)) {
+		if (!fileName.startsWith("panes-") || !fileName.endsWith(".json")) continue;
+		const file = path.join(directory, fileName);
+		try {
+			const registry = JSON.parse(readFileSync(file, "utf8"));
+			if (registry.version !== 1 || ownerStillMatches(registry)) continue;
+			closeRegistryPanes(registry);
+			rmSync(file, { force: true });
+		} catch {
+			rmSync(file, { force: true });
+		}
+	}
+}
+function ownerStillMatches(registry) {
+	try {
+		process.kill(registry.ownerPid, 0);
+	} catch {
+		return false;
+	}
+	return !registry.ownerStartTime || linuxProcessStartTime(registry.ownerPid) === registry.ownerStartTime;
+}
+function closeRegistryPanes(registry) {
+	for (const pane of registry.panes) {
+		const args = [];
+		if (registry.zellijSessionName) args.push("--session", registry.zellijSessionName);
+		args.push("action", "close-pane", "--pane-id", pane.paneId);
+		spawn("zellij", args, {
+			detached: true,
+			stdio: "ignore",
+			env: process.env
+		}).unref();
+	}
+}
+function upsertWatchdogPane(registry, session) {
+	return {
+		...registry,
+		panes: [...registry.panes.filter((pane) => pane.sessionId !== session.id && pane.paneId !== session.paneId), {
+			sessionId: session.id,
+			paneId: session.paneId,
+			title: session.title,
+			openCodeSessionId: session.openCodeSessionId,
+			createdAt: session.createdAt
+		}]
+	};
+}
+function removeWatchdogPane(registry, sessionId) {
+	return {
+		...registry,
+		panes: registry.panes.filter((pane) => pane.sessionId !== sessionId)
+	};
+}
+function registerPaneForWatchdog(session) {
+	writeRegistry(upsertWatchdogPane(readRegistry(), session));
+	ensureWatchdog();
+}
+function unregisterPaneFromWatchdog(sessionId) {
+	const registry = readRegistry();
+	const updated = removeWatchdogPane(registry, sessionId);
+	if (updated.panes.length === registry.panes.length) return;
+	if (updated.panes.length === 0) {
+		removeWatchdogRegistry();
+		return;
+	}
+	writeRegistry(updated);
+}
+function removeWatchdogRegistry() {
+	try {
+		rmSync(watchdogRegistryPath(), { force: true });
+	} catch {}
+}
+//#endregion
 //#region src/pty/ring-buffer.ts
 const ansiPattern$1 = new RegExp(`${String.fromCharCode(27)}\\[[0-9;?]*[a-z]`, "gi");
 function normalizeLines(input) {
@@ -501,6 +780,7 @@ var SubscriberManager = class {
 			state.buffer.append(`[zellij-pty] Pane ${session.paneId} closed at ${(/* @__PURE__ */ new Date()).toISOString()}`);
 			this.sessions.updateLineCount(sessionId, state.buffer.lineCount);
 			this.sessions.updateStatus(sessionId, session.status === "killed" ? "killed" : "exited");
+			unregisterPaneFromWatchdog(sessionId);
 			this.stop(sessionId);
 			return;
 		}
@@ -629,7 +909,7 @@ const zellijPtyKillTool = tool({
 		const output = subscriberManager.has(session.id) ? readOutputSnapshot(session.id) : void 0;
 		try {
 			await zellijCli.sendCtrlC(session.paneId);
-			await setTimeout(500);
+			await setTimeout$1(500);
 		} catch (error) {
 			warnings.push(`Ctrl-C failed or pane was already gone: ${error instanceof Error ? error.message : String(error)}`);
 		}
@@ -649,6 +929,7 @@ const zellijPtyKillTool = tool({
 		}
 		subscriberManager.stop(session.id);
 		subscriberManager.forget(session.id);
+		unregisterPaneFromWatchdog(session.id);
 		sessionManager.remove(session.id);
 		return jsonResponse({
 			killed: true,
@@ -784,7 +1065,7 @@ const requestSudoTool = tool({
 			humanInputOnly: true
 		});
 		const command = buildReviewScript(args.summary, args.scripts);
-		const title = createOpenCodePaneTitle("request_sudo");
+		const title = createOpenCodePaneTitle("zellij_pty_request_sudo");
 		const paneId = await zellijCli.newPane({
 			command: "bash",
 			args: ["-lc", command],
@@ -804,13 +1085,14 @@ const requestSudoTool = tool({
 			openCodeSessionId: context.sessionID,
 			paneId,
 			title,
-			command: "request_sudo",
+			command: "zellij_pty_request_sudo",
 			args: [],
 			cwd,
 			allowAgentInput: false,
 			humanInputOnly: true,
 			exitCodeToken
 		});
+		registerPaneForWatchdog(session);
 		await subscriberManager.start(session);
 		return jsonResponse({
 			session: publicSession(session),
@@ -833,7 +1115,7 @@ async function runProbe(probe, outputReader) {
 	};
 	if (effectiveProbe.type === "sleep") {
 		const seconds = effectiveProbe.seconds ?? defaultSleepSeconds;
-		await setTimeout(seconds * 1e3);
+		await setTimeout$1(seconds * 1e3);
 		return result(effectiveProbe.type, true, `Slept for ${seconds}s.`, startedAt);
 	}
 	if (effectiveProbe.type === "output") {
@@ -841,7 +1123,7 @@ async function runProbe(probe, outputReader) {
 		const deadline = Date.now() + timeoutSeconds * 1e3;
 		while (Date.now() <= deadline) {
 			if (outputReader(effectiveProbe.grep, effectiveProbe.ignoreCase)) return result(effectiveProbe.type, true, `Observed output matching /${effectiveProbe.grep}/.`, startedAt);
-			await setTimeout(pollIntervalMs);
+			await setTimeout$1(pollIntervalMs);
 		}
 		return result(effectiveProbe.type, false, `Timed out after ${timeoutSeconds}s waiting for output matching /${effectiveProbe.grep}/.`, startedAt);
 	}
@@ -861,7 +1143,7 @@ async function runProbe(probe, outputReader) {
 		} catch (error) {
 			lastError = error instanceof Error ? error.message : String(error);
 		}
-		await setTimeout(pollIntervalMs);
+		await setTimeout$1(pollIntervalMs);
 	}
 	return result(effectiveProbe.type, false, `Timed out after ${timeoutSeconds}s probing ${effectiveProbe.url}: ${lastError}.`, startedAt);
 }
@@ -934,6 +1216,7 @@ const zellijPtySpawnTool = tool({
 			humanInputOnly: false,
 			exitCodeToken
 		});
+		registerPaneForWatchdog(session);
 		await subscriberManager.start(session);
 		const probe = await runProbe(args.probe, (grep, ignoreCase) => outputMatches(session.id, grep, ignoreCase));
 		const output = readOutputSnapshot(session.id, { maxLines: args.maxLines });
@@ -982,7 +1265,7 @@ const schema = tool.schema;
 const zellijPtyWriteTool = tool({
 	description: "Write stdin to a Zellij PTY session. Refuses human-input-only sessions.",
 	args: {
-		id: schema.string().describe("zellij-pty session id returned by zellij_pty_spawn or request_sudo."),
+		id: schema.string().describe("zellij-pty session id returned by zellij_pty_spawn or zellij_pty_request_sudo."),
 		data: schema.string().describe("Text to write. Use  to send Ctrl-C."),
 		maxLines: schema.number().int().positive().max(5e3).optional().describe("Maximum recent output lines to return. Defaults to 200."),
 		interruptAfterSeconds: schema.number().positive().max(300).optional().describe("Blindly send Ctrl-C after this many seconds if the pane is still running; keeps the pane alive.")
@@ -1002,12 +1285,12 @@ const zellijPtyWriteTool = tool({
 		}
 		session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
 		if (args.interruptAfterSeconds) {
-			await setTimeout(args.interruptAfterSeconds * 1e3);
+			await setTimeout$1(args.interruptAfterSeconds * 1e3);
 			if (sessionManager.get(session.id).status === "running") {
 				await zellijCli.sendCtrlC(session.paneId);
-				await setTimeout(500);
+				await setTimeout$1(500);
 			}
-		} else await setTimeout(1e3);
+		} else await setTimeout$1(1e3);
 		return jsonResponse({
 			session: publicSession(session),
 			output: readOutputSnapshot(session.id, { maxLines: args.maxLines }),
@@ -1017,28 +1300,336 @@ const zellijPtyWriteTool = tool({
 	}
 });
 //#endregion
+//#region src/utils/debug.ts
+function debug(message, ...details) {
+	if (!process.env.ZELLIJ_PTY_DEBUG) return;
+	console.warn(`[opencode-zellij] ${message}`, ...details);
+}
+//#endregion
+//#region src/zellij/shutdown-cleanup.ts
+let registered = false;
+let cleanedUp = false;
+function cleanupPanesOnShutdown(sessions = sessionManager, subscribers = subscriberManager) {
+	if (cleanedUp) return;
+	cleanedUp = true;
+	for (const session of sessions.list()) {
+		try {
+			zellijCli.closePaneSync(session.paneId);
+		} catch {}
+		subscribers.forget(session.id);
+		try {
+			sessions.remove(session.id);
+		} catch {}
+	}
+}
+function registerShutdownCleanup() {
+	if (registered) return;
+	registered = true;
+	process.once("exit", () => cleanupPanesOnShutdown());
+	process.once("SIGINT", () => exitAfterCleanup("SIGINT", 130));
+	process.once("SIGTERM", () => exitAfterCleanup("SIGTERM", 143));
+	process.once("SIGHUP", () => exitAfterCleanup("SIGHUP", 129));
+}
+function exitAfterCleanup(signal, code) {
+	cleanupPanesOnShutdown();
+	process.removeAllListeners(signal);
+	process.exit(code);
+}
+//#endregion
+//#region src/zellij/tab-title-events.ts
+const execFileAsync = promisify(execFile);
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function stringProperty(object, key) {
+	const value = object[key];
+	return typeof value === "string" ? value : void 0;
+}
+function nestedStringProperty(object, key, nestedKey) {
+	const nested = object[key];
+	if (!isRecord(nested)) return void 0;
+	return stringProperty(nested, nestedKey);
+}
+function sessionStatusProperty(object) {
+	const status = object.status;
+	if (!isRecord(status)) return void 0;
+	if (status.type === "idle" || status.type === "busy") return { type: status.type };
+	if (status.type === "retry") return {
+		type: "retry",
+		attempt: typeof status.attempt === "number" ? status.attempt : 0,
+		message: typeof status.message === "string" ? status.message : "",
+		next: typeof status.next === "number" ? status.next : 0
+	};
+}
+function inputRequestID(object) {
+	return stringProperty(object, "id") ?? stringProperty(object, "requestID") ?? stringProperty(object, "permissionID");
+}
+function deletedSessionID(event) {
+	if (!isRecord(event.properties)) return void 0;
+	return nestedStringProperty(event.properties, "info", "id") ?? stringProperty(event.properties, "sessionID");
+}
+async function readGitBranch(worktree) {
+	return (await execFileAsync("git", [
+		"-C",
+		worktree,
+		"branch",
+		"--show-current"
+	], {
+		encoding: "utf8",
+		timeout: 1e3,
+		maxBuffer: 1024 * 1024
+	})).stdout;
+}
+async function getInitialBranch(worktree, readBranch = readGitBranch) {
+	try {
+		return (await readBranch(worktree)).trim() || void 0;
+	} catch {
+		return;
+	}
+}
+function shouldReadInitialBranch(zellij) {
+	return Boolean(zellij);
+}
+function handleTabTitleEvent(tabTitleManager, event) {
+	if (!isRecord(event.properties)) return;
+	const properties = event.properties;
+	switch (event.type) {
+		case "session.status": {
+			const sessionID = stringProperty(properties, "sessionID");
+			const status = sessionStatusProperty(properties);
+			if (sessionID && status) tabTitleManager.updateSessionStatus(sessionID, status);
+			break;
+		}
+		case "session.idle": {
+			const sessionID = stringProperty(properties, "sessionID");
+			if (sessionID) tabTitleManager.markSessionIdle(sessionID);
+			break;
+		}
+		case "vcs.branch.updated":
+			tabTitleManager.setBranch(stringProperty(properties, "branch"));
+			break;
+		case "question.asked":
+		case "permission.asked":
+		case "permission.updated": {
+			const id = inputRequestID(properties);
+			const sessionID = stringProperty(properties, "sessionID");
+			if (id && sessionID) tabTitleManager.markNeedsInput(id, sessionID);
+			break;
+		}
+		case "question.replied":
+		case "question.rejected":
+		case "permission.replied": {
+			const id = inputRequestID(properties);
+			if (id) tabTitleManager.clearNeedsInput(id);
+			break;
+		}
+		case "session.deleted": {
+			const sessionID = deletedSessionID(event);
+			if (sessionID) tabTitleManager.removeSession(sessionID);
+			break;
+		}
+	}
+}
+//#endregion
+//#region src/zellij/tab-title.ts
+const defaultTabTitleEmojis = {
+	idle: "🟢",
+	running: "⚡",
+	needsInput: "💬",
+	branch: "🌱"
+};
+function formatTabTitle(context) {
+	const branch = context.branchName ? ` ${context.emojis.branch} ${context.branchName}` : "";
+	return `${context.emojis[context.status === "needs-input" ? "needsInput" : context.status]} ${context.projectName}${branch}`;
+}
+function sanitizeTitle(title, maxLength = 90) {
+	let cleaned = title.replace(/[\p{Cc}\p{Cf}\p{Co}\p{Cn}]/gu, " ").replace(/\s+/g, " ").trim();
+	const chars = Array.from(cleaned);
+	if (chars.length > maxLength) cleaned = `${chars.slice(0, maxLength - 1).join("")}…`;
+	return cleaned;
+}
+var TabTitleManager = class {
+	sessionStatuses = /* @__PURE__ */ new Map();
+	pendingInputs = /* @__PURE__ */ new Map();
+	branchName;
+	desiredTitle;
+	lastSyncedTitle;
+	debounceTimer;
+	syncInFlight = false;
+	debounceMs;
+	projectName;
+	cli;
+	emojis;
+	enabled;
+	constructor(options) {
+		this.projectName = options.projectName;
+		this.branchName = options.branchName?.trim() || void 0;
+		this.cli = options.cli ?? new ZellijCli();
+		this.emojis = {
+			...defaultTabTitleEmojis,
+			...options.emojis
+		};
+		this.debounceMs = options.debounceMs ?? 300;
+		this.enabled = Boolean(process.env.ZELLIJ);
+	}
+	setBranch(branch) {
+		const trimmed = branch?.trim() || void 0;
+		if (this.branchName === trimmed) return;
+		this.branchName = trimmed;
+		this.scheduleUpdate();
+	}
+	updateSessionStatus(sessionID, status) {
+		const activity = status.type === "idle" ? "idle" : "running";
+		if (this.sessionStatuses.get(sessionID) === activity) return;
+		this.sessionStatuses.set(sessionID, activity);
+		this.scheduleUpdate();
+	}
+	markSessionIdle(sessionID) {
+		this.updateSessionStatus(sessionID, { type: "idle" });
+	}
+	removeSession(sessionID) {
+		const hadSessionStatus = this.sessionStatuses.delete(sessionID);
+		let hadPendingInput = false;
+		for (const [id, pendingSessionID] of this.pendingInputs) if (pendingSessionID === sessionID) {
+			this.pendingInputs.delete(id);
+			hadPendingInput = true;
+		}
+		if (!hadSessionStatus && !hadPendingInput) return;
+		this.scheduleUpdate();
+	}
+	markNeedsInput(id, sessionID) {
+		if (this.pendingInputs.get(id) === sessionID) return;
+		this.pendingInputs.set(id, sessionID);
+		this.scheduleUpdate();
+	}
+	clearNeedsInput(id) {
+		if (!this.pendingInputs.delete(id)) return;
+		this.scheduleUpdate();
+	}
+	get isBusy() {
+		for (const activity of this.sessionStatuses.values()) if (activity === "running") return true;
+		return false;
+	}
+	get needsInput() {
+		return this.pendingInputs.size > 0;
+	}
+	get status() {
+		if (this.needsInput) return "needs-input";
+		if (this.isBusy) return "running";
+		return "idle";
+	}
+	buildTitle() {
+		return sanitizeTitle(formatTabTitle({
+			projectName: this.projectName,
+			branchName: this.branchName,
+			status: this.status,
+			emojis: this.emojis
+		}));
+	}
+	getCurrentTitle() {
+		return this.buildTitle();
+	}
+	async renderImmediate() {
+		if (!this.enabled) return;
+		this.desiredTitle = this.buildTitle();
+		this.clearDebounceTimer();
+		await this.syncDesiredTitle();
+	}
+	scheduleUpdate() {
+		if (!this.enabled) return;
+		const title = this.buildTitle();
+		if (title === this.desiredTitle && title === this.lastSyncedTitle) return;
+		this.desiredTitle = title;
+		if (this.syncInFlight) return;
+		this.clearDebounceTimer();
+		this.debounceTimer = setTimeout(() => {
+			this.debounceTimer = void 0;
+			this.syncDesiredTitle().catch(() => {});
+		}, this.debounceMs);
+	}
+	async syncDesiredTitle() {
+		if (!this.enabled) return;
+		if (this.syncInFlight) return;
+		this.syncInFlight = true;
+		try {
+			while (this.desiredTitle && this.desiredTitle !== this.lastSyncedTitle) {
+				const title = this.desiredTitle;
+				try {
+					await this.cli.renameTab(title);
+					this.lastSyncedTitle = title;
+				} catch (cause) {
+					debug("Failed to rename Zellij tab.", cause);
+					break;
+				}
+			}
+		} finally {
+			this.syncInFlight = false;
+		}
+	}
+	clearDebounceTimer() {
+		if (this.debounceTimer) clearTimeout(this.debounceTimer);
+		this.debounceTimer = void 0;
+	}
+	destroy() {
+		this.clearDebounceTimer();
+	}
+};
+//#endregion
 //#region src/plugin.ts
-const ZellijPtyPlugin = async (_input, options) => {
-	configurePolicy(options?.zellijPty ?? options);
+const ptyTools = {
+	zellij_pty_spawn: zellijPtySpawnTool,
+	zellij_pty_list: zellijPtyListTool,
+	zellij_pty_write: zellijPtyWriteTool,
+	zellij_pty_read: zellijPtyReadTool,
+	zellij_pty_kill: zellijPtyKillTool
+};
+function getProjectName(path) {
+	return path.split(/[/\\]/).filter(Boolean).pop() || "opencode";
+}
+function getWorkspaceRoot(input) {
+	return input.worktree || input.directory || process.cwd();
+}
+const ZellijPtyPlugin = async (input) => {
+	const { config, warnings } = await loadConfig(input);
+	for (const warning of warnings) debug(warning);
+	configurePolicy({ allowSudoPane: config.pty.sudoPane === "allow" });
+	cleanupStaleWatchdogRegistries();
+	registerShutdownCleanup();
+	const workspaceRoot = getWorkspaceRoot(input);
+	const projectName = getProjectName(workspaceRoot);
+	const branchName = config.tabTitle.enabled && shouldReadInitialBranch(process.env.ZELLIJ) ? await getInitialBranch(workspaceRoot) : void 0;
+	const tabTitleManager = config.tabTitle.enabled ? new TabTitleManager({
+		projectName,
+		branchName,
+		debounceMs: config.tabTitle.debounceMs,
+		emojis: {
+			idle: config.tabTitle.emojiIdle,
+			running: config.tabTitle.emojiRunning,
+			needsInput: config.tabTitle.emojiNeedsInput,
+			branch: config.tabTitle.emojiBranch
+		}
+	}) : void 0;
+	tabTitleManager?.renderImmediate().catch(() => {});
 	return {
 		async event(input) {
-			if (input.event.type === "session.deleted") {
-				const sessions = sessionManager.listByOpenCodeSession(input.event.properties.info.id);
+			const event = input.event;
+			if (tabTitleManager) handleTabTitleEvent(tabTitleManager, event);
+			if (event.type === "session.deleted") {
+				const sessionID = deletedSessionID(event);
+				if (!sessionID) return;
+				const sessions = sessionManager.listByOpenCodeSession(sessionID);
 				await Promise.all(sessions.map(async (session) => {
 					await subscriberManager.closeSessionPane(session.id);
 					subscriberManager.forget(session.id);
+					unregisterPaneFromWatchdog(session.id);
 					sessionManager.remove(session.id);
 				}));
 			}
 		},
-		tool: {
-			zellij_pty_spawn: zellijPtySpawnTool,
-			zellij_pty_list: zellijPtyListTool,
-			zellij_pty_write: zellijPtyWriteTool,
-			zellij_pty_read: zellijPtyReadTool,
-			zellij_pty_kill: zellijPtyKillTool,
-			request_sudo: requestSudoTool
-		}
+		tool: config.pty.enabled ? {
+			...ptyTools,
+			...config.pty.sudoPane === "hide" ? {} : { zellij_pty_request_sudo: requestSudoTool }
+		} : {}
 	};
 };
 //#endregion