opencode-zellij 0.0.16 → 0.0.18

package/dist/index.mjs

@@ -1,262 +1,26 @@
 import process from "node:process";
-import { execFile, spawn, spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { readFile, rename, rm } from "node:fs/promises";
-import path, { basename, dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { promisify } from "node:util";
+import { readFile } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
+import path, { dirname, join } from "node:path";
 import { parseJSON, parseJSONC } from "confbox";
 import { z } from "zod";
 import { randomUUID } from "node:crypto";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { tool } from "@opencode-ai/plugin";
+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/utils/debug.ts
-function debug(message, ...details) {
-	if (!process.env.ZELLIJ_PTY_DEBUG) return;
-	console.warn(`[opencode-zellij] ${message}`, ...details);
-}
-//#endregion
-//#region src/utils/errors.ts
-function errorMessage(error) {
-	return error instanceof Error ? error.message : String(error);
-}
-//#endregion
-//#region src/auto-update.ts
-const PACKAGE_NAME = "opencode-zellij";
-const NPM_REGISTRY_URL = "https://registry.npmjs.org/-/package/opencode-zellij/dist-tags";
-const FETCH_TIMEOUT_MS = 5e3;
-const INSTALL_TIMEOUT_MS = 6e4;
-const defaultExecFile = promisify(execFile);
-function packageDir(installRoot) {
-	return join(installRoot, "node_modules", PACKAGE_NAME);
-}
-function backupDir(installRoot) {
-	return join(installRoot, "node_modules", `${PACKAGE_NAME}.update-backup`);
-}
-async function installedPackageMetadata(installRoot) {
-	try {
-		const content = await readFile(join(packageDir(installRoot), "package.json"), "utf8");
-		const pkg = JSON.parse(content);
-		if (isRecord$2(pkg)) return {
-			name: typeof pkg.name === "string" ? pkg.name : void 0,
-			version: typeof pkg.version === "string" ? pkg.version : void 0,
-			main: typeof pkg.main === "string" ? pkg.main : void 0
-		};
-	} catch (error) {
-		debug("installedPackageMetadata failed", errorMessage(error));
-	}
-}
-function isExpectedPackage(metadata, version) {
-	return metadata?.name === "opencode-zellij" && metadata.version === version;
-}
-function hasRunnableEntry(installRoot, metadata) {
-	if (!metadata) return false;
-	const dir = packageDir(installRoot);
-	if (metadata.main && existsSync(join(dir, metadata.main))) return true;
-	return existsSync(join(dir, "dist", "index.mjs"));
-}
-async function isVerifiedInstall(installRoot, version) {
-	const metadata = await installedPackageMetadata(installRoot);
-	return isExpectedPackage(metadata, version) && hasRunnableEntry(installRoot, metadata);
-}
-async function removeInstalledPackage(installRoot) {
-	await rm(packageDir(installRoot), {
-		force: true,
-		recursive: true
-	});
-}
-async function backupInstalledPackage(installRoot) {
-	const source = packageDir(installRoot);
-	if (!existsSync(source)) return void 0;
-	const backup = backupDir(installRoot);
-	await rm(backup, {
-		force: true,
-		recursive: true
-	});
-	await rename(source, backup);
-	return backup;
-}
-async function restoreInstalledPackage(installRoot, backup) {
-	if (!backup || !existsSync(backup)) return;
-	await rm(packageDir(installRoot), {
-		force: true,
-		recursive: true
-	});
-	await rename(backup, packageDir(installRoot));
-}
-async function discardBackup(backup) {
-	if (backup) await rm(backup, {
-		force: true,
-		recursive: true
-	});
-}
-async function findInstallContext(importMetaUrl) {
-	let startPath;
-	try {
-		startPath = fileURLToPath(importMetaUrl);
-	} catch (cause) {
-		debug("invalid import.meta.url", cause instanceof Error ? cause.message : String(cause));
-		return;
-	}
-	let dir = dirname(startPath);
-	while (true) {
-		if (dir.endsWith(`/node_modules/opencode-zellij`) || dir.endsWith(`\\node_modules\\opencode-zellij`)) {
-			const packageJsonPath = join(dir, "package.json");
-			try {
-				const content = await readFile(packageJsonPath, "utf8");
-				const pkg = JSON.parse(content);
-				if (isRecord$2(pkg) && pkg.name === "opencode-zellij" && typeof pkg.version === "string" && pkg.version.length > 0) {
-					const installRoot = dirname(dirname(dir));
-					if (existsSync(join(installRoot, "package.json"))) return {
-						installRoot,
-						cacheSpec: basename(installRoot),
-						currentVersion: pkg.version
-					};
-				}
-			} catch (error) {
-				debug("findInstallContext package.json read failed", errorMessage(error));
-			}
-		}
-		const parent = dirname(dir);
-		if (parent === dir) break;
-		dir = parent;
-	}
-}
-function isRecord$2(value) {
-	return typeof value === "object" && value !== null;
-}
-function isAutoUpdatableSpec(spec) {
-	if (spec === "opencode-zellij") return true;
-	if (spec === `opencode-zellij@latest`) return true;
-	return false;
-}
-async function fetchLatestVersion(fetchImpl = globalThis.fetch) {
-	const controller = new AbortController();
-	const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
-	try {
-		const response = await fetchImpl(NPM_REGISTRY_URL, { signal: controller.signal });
-		clearTimeout(timeout);
-		if (!response.ok) {
-			debug(`npm registry returned ${response.status}`);
-			return;
-		}
-		const data = await response.json();
-		if (isRecord$2(data) && typeof data.latest === "string") return data.latest;
-		debug("npm registry response missing latest tag");
-		return;
-	} catch (cause) {
-		clearTimeout(timeout);
-		debug("failed to fetch latest version", cause instanceof Error ? cause.message : String(cause));
-		return;
-	}
-}
-async function runNpmInstall(installRoot, version, execImpl = defaultExecFile) {
-	debug(`updating ${PACKAGE_NAME} to ${version} in ${installRoot}`);
-	try {
-		const install = () => execImpl("npm", [
-			"install",
-			`${PACKAGE_NAME}@${version}`,
-			"--save-exact",
-			"--ignore-scripts",
-			"--no-audit",
-			"--no-fund",
-			"--prefer-online"
-		], {
-			cwd: installRoot,
-			timeout: INSTALL_TIMEOUT_MS
-		});
-		await install();
-		if (await isVerifiedInstall(installRoot, version)) {
-			debug(`updated ${PACKAGE_NAME} to ${version}`);
-			return true;
-		}
-		const installedPackage = await installedPackageMetadata(installRoot);
-		debug(`npm install left stale or invalid ${PACKAGE_NAME} (${installedPackage?.name ?? "<missing>"}@${installedPackage?.version ?? "<missing>"}); reinstalling ${version}`);
-		const backup = await backupInstalledPackage(installRoot);
-		try {
-			await removeInstalledPackage(installRoot);
-			await install();
-			if (await isVerifiedInstall(installRoot, version)) {
-				await discardBackup(backup);
-				debug(`updated ${PACKAGE_NAME} to ${version}`);
-				return true;
-			}
-			const reinstalledPackage = await installedPackageMetadata(installRoot);
-			debug(`npm install verification failed: expected ${PACKAGE_NAME}@${version}, found ${reinstalledPackage?.name ?? "<missing>"}@${reinstalledPackage?.version ?? "<missing>"}`);
-			await restoreInstalledPackage(installRoot, backup);
-			return false;
-		} catch (cause) {
-			await restoreInstalledPackage(installRoot, backup);
-			throw cause;
-		}
-	} catch (cause) {
-		debug("npm install failed", cause instanceof Error ? cause.message : String(cause));
-		return false;
-	}
-}
-async function checkAndUpdate(options) {
-	const context = await findInstallContext(options.importMetaUrl);
-	if (!context) {
-		debug("skipping auto-update: not installed from npm");
-		return {
-			type: "skipped",
-			reason: "not installed from npm"
-		};
-	}
-	if (!isAutoUpdatableSpec(context.cacheSpec)) {
-		debug(`skipping auto-update: cache spec is pinned or unknown (${context.cacheSpec})`);
-		return {
-			type: "skipped",
-			reason: `cache spec is pinned or unknown (${context.cacheSpec})`
-		};
-	}
-	const latest = await fetchLatestVersion(options.fetchImpl);
-	if (!latest) {
-		debug("skipping auto-update: could not determine latest version");
-		return {
-			type: "skipped",
-			reason: "could not determine latest version"
-		};
-	}
-	const installedVersion = (await installedPackageMetadata(context.installRoot))?.version ?? context.currentVersion;
-	if (latest === installedVersion) {
-		debug(`auto-update: already on latest ${latest}`);
-		return {
-			type: "up-to-date",
-			currentVersion: installedVersion
-		};
-	}
-	if (await runNpmInstall(context.installRoot, latest, options.execImpl)) {
-		debug(`updated ${PACKAGE_NAME} from ${installedVersion} to ${latest}`);
-		return {
-			type: "updated",
-			fromVersion: installedVersion,
-			toVersion: latest
-		};
-	}
-	return {
-		type: "failed",
-		currentVersion: installedVersion,
-		latestVersion: latest,
-		reason: "npm install failed"
-	};
-}
-//#endregion
+import { LogFileRotationTransport } from "@loglayer/transport-log-file-rotation";
+import { LogLayer } from "loglayer";
+import { serializeError } from "serialize-error";
 //#region src/config.ts
 const sudoPaneSchema = z.enum([
 	"allow",
 	"deny",
 	"hide"
 ]);
-const completionNotificationModeSchema = z.enum([
-	"off",
-	"queue",
-	"toast",
-	"queue+toast",
-	"prompt"
-]);
 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."),
@@ -269,22 +33,12 @@ const tabTitleLayerSchema = z.object({
 const ptyLayerSchema = z.object({
 	enabled: z.boolean().optional().describe("Enable Zellij-backed PTY tools."),
 	cleanupExitedPaneOnRead: z.boolean().optional().describe("Remove exited PTY panes after they are read."),
-	sudoPane: sudoPaneSchema.optional().describe("Controls whether the sudo pane tool is available, denied, or hidden."),
-	completionNotification: z.object({
-		mode: completionNotificationModeSchema.optional().describe("Controls how completion notifications are delivered."),
-		prompt: z.object({
-			requireIdle: z.boolean().optional().describe("Require the plugin to be idle before prompting."),
-			cooldownMs: z.number().finite().min(0).optional().describe("Cooldown time before prompting again in milliseconds."),
-			maxAttempts: z.number().finite().int().min(0).optional().describe("Maximum prompt attempts before backing off.")
-		}).strict().optional().describe("Prompt-specific completion notification settings.")
-	}).strict().optional().describe("Completion notification delivery settings.")
+	sudoPane: sudoPaneSchema.optional().describe("Controls whether the sudo pane tool is available, denied, or hidden.")
 }).strict();
-const autoUpdateLayerSchema = z.boolean().optional().describe("Enable automatic update checks for the opencode-zellij plugin.");
 const sidecarConfigSchema = z.object({
 	$schema: z.string().optional().describe("JSON Schema URI for editor completion."),
 	tabTitle: tabTitleLayerSchema.optional(),
-	pty: ptyLayerSchema.optional(),
-	autoUpdate: autoUpdateLayerSchema.optional()
+	pty: ptyLayerSchema.optional()
 }).strict();
 const defaultConfig = {
 	tabTitle: {
@@ -298,25 +52,15 @@ const defaultConfig = {
 	pty: {
 		enabled: true,
 		cleanupExitedPaneOnRead: true,
-		sudoPane: "allow",
-		completionNotification: {
-			mode: "queue+toast",
-			prompt: {
-				requireIdle: true,
-				cooldownMs: 3e4,
-				maxAttempts: 1
-			}
-		}
-	},
-	autoUpdate: 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,
-		autoUpdate: result.data.autoUpdate
+		pty: result.data.pty
 	};
 }
 function mergeConfig(user, project) {
@@ -332,17 +76,8 @@ function mergeConfig(user, project) {
 		pty: {
 			enabled: project?.pty?.enabled ?? user?.pty?.enabled ?? defaultConfig.pty.enabled,
 			cleanupExitedPaneOnRead: project?.pty?.cleanupExitedPaneOnRead ?? user?.pty?.cleanupExitedPaneOnRead ?? defaultConfig.pty.cleanupExitedPaneOnRead,
-			sudoPane: project?.pty?.sudoPane ?? user?.pty?.sudoPane ?? defaultConfig.pty.sudoPane,
-			completionNotification: {
-				mode: project?.pty?.completionNotification?.mode ?? user?.pty?.completionNotification?.mode ?? defaultConfig.pty.completionNotification.mode,
-				prompt: {
-					requireIdle: project?.pty?.completionNotification?.prompt?.requireIdle ?? user?.pty?.completionNotification?.prompt?.requireIdle ?? defaultConfig.pty.completionNotification.prompt.requireIdle,
-					cooldownMs: project?.pty?.completionNotification?.prompt?.cooldownMs ?? user?.pty?.completionNotification?.prompt?.cooldownMs ?? defaultConfig.pty.completionNotification.prompt.cooldownMs,
-					maxAttempts: project?.pty?.completionNotification?.prompt?.maxAttempts ?? user?.pty?.completionNotification?.prompt?.maxAttempts ?? defaultConfig.pty.completionNotification.prompt.maxAttempts
-				}
-			}
-		},
-		autoUpdate: project?.autoUpdate ?? user?.autoUpdate ?? defaultConfig.autoUpdate
+			sudoPane: project?.pty?.sudoPane ?? user?.pty?.sudoPane ?? defaultConfig.pty.sudoPane
+		}
 	};
 }
 async function loadConfigLayer(directory, warnings) {
@@ -490,8 +225,7 @@ var SessionManager = class {
 				reason: input.reason,
 				terminalAt: now,
 				tail: (input.tail ?? []).slice(-tombstoneTailLimit),
-				paneClosedAt: null,
-				notificationSentAt: null
+				paneClosedAt: null
 			};
 			session.status = "terminal";
 			session.tombstone = tombstone;
@@ -521,16 +255,6 @@ var SessionManager = class {
 		}
 		return session;
 	}
-	markTerminalNotificationSent(id) {
-		const session = this.get(id);
-		const now = (/* @__PURE__ */ new Date()).toISOString();
-		if (!session.tombstone) return session;
-		if (!session.tombstone.notificationSentAt) {
-			session.tombstone.notificationSentAt = now;
-			session.updatedAt = now;
-		}
-		return session;
-	}
 	listByOpenCodeSession(openCodeSessionId) {
 		return this.list().filter((session) => session.openCodeSessionId === openCodeSessionId);
 	}
@@ -573,6 +297,17 @@ function buildCommandArgv(input, options = {}) {
 	];
 }
 //#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/utils/errors.ts
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
 //#region src/zellij/parse.ts
 function numericProperty(object, keys) {
 	for (const key of keys) {
@@ -1393,48 +1128,51 @@ var SubscriberManager = class {
 const subscriberManager = new SubscriberManager(sessionManager);
 //#endregion
 //#region src/tools/format.ts
-function publicSession(session) {
-	return {
+function publicSession(session, options = {}) {
+	const status = session.status === "terminal" ? "exited" : session.status;
+	const summary = {
 		id: session.id,
 		paneId: session.paneId,
 		title: session.title,
 		command: session.command,
-		args: session.args,
-		cwd: session.cwd,
-		status: session.status === "terminal" ? "exited" : session.status,
-		lineCount: session.lineCount,
-		createdAt: session.createdAt,
-		updatedAt: session.updatedAt,
-		agentWritable: session.allowAgentInput,
-		humanInputOnly: session.humanInputOnly,
-		exitCode: session.exitCode,
-		exitedAt: session.exitedAt,
-		tombstone: session.tombstone ? {
-			reason: session.tombstone.reason,
-			terminalAt: session.tombstone.terminalAt,
-			tailLines: session.tombstone.tail.length,
-			paneClosedAt: session.tombstone.paneClosedAt,
-			notificationSentAt: session.tombstone.notificationSentAt
-		} : null
+		status
 	};
+	if (options.agentWritable === false) summary.humanInputOnly = true;
+	if (options.includeTombstone) summary.tombstone = session.tombstone ? {
+		reason: session.tombstone.reason,
+		terminalAt: session.tombstone.terminalAt,
+		tailLines: session.tombstone.tail.length,
+		paneClosedAt: session.tombstone.paneClosedAt
+	} : null;
+	return summary;
 }
-function nextAdvice(retryable, reason) {
+function jsonResponse(value) {
+	return JSON.stringify(value, null, 2);
+}
+function publicCompletedPane(session) {
+	const status = session.status === "terminal" ? "exited" : session.status;
+	const safeStatus = status === "exited" || status === "killed" || status === "unknown" ? status : "unknown";
 	return {
-		retryable,
-		reason
+		id: session.id,
+		paneId: session.paneId,
+		status: safeStatus,
+		exitCode: session.exitCode,
+		reason: session.tombstone?.reason ?? null
 	};
 }
-function jsonResponse(value) {
-	return JSON.stringify(value, null, 2);
+function completedPanesFromSessions(sessions) {
+	const completedPanes = sessions.filter((session) => session.status === "terminal").map(publicCompletedPane);
+	return {
+		completedPaneIds: completedPanes.map((pane) => pane.id),
+		completedPanes
+	};
 }
 //#endregion
 //#region src/tools/output.ts
 function emptyOutputSnapshot(lineCount = 0) {
 	return {
 		text: "",
-		lines: [],
 		lineCount,
-		returned: 0,
 		truncated: false
 	};
 }
@@ -1456,20 +1194,20 @@ function readOutputSnapshot(sessionId, options = {}) {
 		ignoreCase: options.ignoreCase
 	});
 	sessionManager.updateLineCount(sessionId, buffered.lineCount);
-	return {
+	const snapshot = {
 		text: buffered.lines.join("\n"),
-		lines: buffered.lines,
 		lineCount: buffered.lineCount,
-		returned: buffered.returned,
 		truncated: buffered.offset > 0
 	};
+	if (options.grep !== void 0) snapshot.matched = buffered.returned;
+	return snapshot;
 }
 function outputMatches(sessionId, grep, ignoreCase) {
-	return readOutputSnapshot(sessionId, {
+	return (readOutputSnapshot(sessionId, {
 		maxLines: 5e3,
 		grep,
 		ignoreCase
-	}).returned > 0;
+	}).matched ?? 0) > 0;
 }
 //#endregion
 //#region src/tools/pane-cleanup.ts
@@ -1528,7 +1266,6 @@ async function executeZellijPtyKill(args, dependencies = {}) {
 			cleanedUp: false,
 			session: publicSession(sessionManager.updateStatus(session.id, "unknown")),
 			output,
-			next: nextAdvice(true, "close-pane failed and the pane may still be running; the session was kept so kill can be retried."),
 			warnings
 		};
 	}
@@ -1552,7 +1289,6 @@ async function finalizeKilledSession(sessionId, paneId, output, warnings) {
 		id: sessionId,
 		paneId,
 		output,
-		next: nextAdvice(false, "Session was closed and removed from the in-memory registry."),
 		warnings
 	};
 }
@@ -1562,10 +1298,14 @@ const zellijPtyListTool = tool({
 	description: "List known Zellij pane-backed PTY sessions created by this plugin process for the current OpenCode session.",
 	args: {},
 	async execute(_args, context) {
-		return jsonResponse({ sessions: sessionManager.listByOpenCodeSession(context.sessionID).map((session) => ({
-			...publicSession(session),
-			subscriber: subscriberManager.status(session.id)
-		})) });
+		const sessionList = sessionManager.listByOpenCodeSession(context.sessionID);
+		return jsonResponse({
+			sessions: sessionList.map((session) => ({
+				...publicSession(session, { includeTombstone: true }),
+				subscriber: subscriberManager.status(session.id)
+			})),
+			...completedPanesFromSessions(sessionList)
+		});
 	}
 });
 //#endregion
@@ -1575,26 +1315,22 @@ async function executeZellijPtyRead(args, dependencies = {}) {
 	const sessionManagerApi = dependencies.sessionManager ?? sessionManager;
 	const subscriberManagerApi = dependencies.subscriberManager ?? subscriberManager;
 	const publicSessionApi = dependencies.publicSession ?? publicSession;
-	const nextAdviceApi = dependencies.nextAdvice ?? nextAdvice;
 	const readOutputSnapshotApi = dependencies.readOutputSnapshot ?? readOutputSnapshot;
 	const validateGrepApi = dependencies.validateGrep ?? validateGrep;
 	const paneExistsApi = dependencies.paneExists ?? ((paneId) => zellijCli.paneExists(paneId));
 	const session = sessionManagerApi.get(args.id);
 	const grepError = validateGrepApi(args.grep);
 	if (grepError) return {
-		session: publicSessionApi(session),
+		session: publicSessionApi(session, { includeTombstone: true }),
 		output: {
 			text: "",
-			lines: [],
 			lineCount: session.lineCount,
-			returned: 0,
 			truncated: false
 		},
-		next: nextAdviceApi(false, `Invalid grep regex: ${grepError}`),
 		subscriberActive: false,
 		subscriberLastExitedAt: null,
 		subscriberErrors: [],
-		warnings: [],
+		warnings: [`Invalid grep regex: ${grepError}`],
 		cleanup: {
 			requested: false,
 			performed: false,
@@ -1622,9 +1358,8 @@ async function executeZellijPtyRead(args, dependencies = {}) {
 	});
 	if (cleanup.warning) warnings.push(cleanup.warning);
 	return {
-		session: publicSessionApi(session),
+		session: publicSessionApi(session, { includeTombstone: true }),
 		output,
-		next: nextAdviceApi(!isCompletedSession(session.status), nextReadReason(session.status)),
 		subscriberActive: statusAfterStart.active,
 		subscriberLastExitedAt: statusAfterStart.lastExitedAt,
 		subscriberErrors: subscriberManagerApi.stderr(session.id),
@@ -1686,12 +1421,6 @@ createZellijPtyReadTool();
 function isCompletedSession(status) {
 	return status === "terminal" || status === "exited" || status === "killed";
 }
-function nextReadReason(status) {
-	if (status === "terminal") return "Session has finished; the final output is retained until the completed pane is read and cleaned up.";
-	if (status === "running") return "Session is still running; read again later if more output is expected.";
-	if (status === "unknown") return "Session state is unknown because the subscriber is inactive; output may be stale, but retrying read may restart observation.";
-	return "Session is no longer running.";
-}
 //#endregion
 //#region src/utils/pane-title.ts
 const generatedInstanceId = randomUUID().replaceAll("-", "").slice(0, 8);
@@ -1768,10 +1497,8 @@ const requestSudoTool = tool({
 		registerPaneForWatchdog(session);
 		await subscriberManager.start(session);
 		return jsonResponse({
-			session: publicSession(session),
-			output: readOutputSnapshot(session.id),
-			next: nextAdvice(false, "The user must review the summary and commands in Zellij, then type YES and any required credentials directly in the pane."),
-			warnings: []
+			session: publicSession(session, { agentWritable: false }),
+			output: readOutputSnapshot(session.id)
 		});
 	}
 });
@@ -1781,7 +1508,6 @@ const defaultSleepSeconds = 1;
 const defaultProbeTimeoutSeconds = 20;
 const pollIntervalMs = 250;
 async function runProbe(probe, outputReader) {
-	const startedAt = Date.now();
 	const effectiveProbe = probe ?? {
 		type: "sleep",
 		seconds: defaultSleepSeconds
@@ -1789,16 +1515,16 @@ async function runProbe(probe, outputReader) {
 	if (effectiveProbe.type === "sleep") {
 		const seconds = effectiveProbe.seconds ?? defaultSleepSeconds;
 		await setTimeout$1(seconds * 1e3);
-		return result(effectiveProbe.type, true, `Slept for ${seconds}s.`, startedAt);
+		return result(effectiveProbe.type, true, `Slept for ${seconds}s.`);
 	}
 	if (effectiveProbe.type === "output") {
 		const timeoutSeconds = effectiveProbe.timeoutSeconds ?? defaultProbeTimeoutSeconds;
 		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);
+			if (outputReader(effectiveProbe.grep, effectiveProbe.ignoreCase)) return result(effectiveProbe.type, true, `Observed output matching /${effectiveProbe.grep}/.`);
 			await setTimeout$1(pollIntervalMs);
 		}
-		return result(effectiveProbe.type, false, `Timed out after ${timeoutSeconds}s waiting for output matching /${effectiveProbe.grep}/.`, startedAt);
+		return result(effectiveProbe.type, false, `Timed out after ${timeoutSeconds}s waiting for output matching /${effectiveProbe.grep}/.`);
 	}
 	const timeoutSeconds = effectiveProbe.timeoutSeconds ?? defaultProbeTimeoutSeconds;
 	const deadline = Date.now() + timeoutSeconds * 1e3;
@@ -1810,7 +1536,7 @@ async function runProbe(probe, outputReader) {
 			const response = await fetch(effectiveProbe.url, { signal: AbortSignal.timeout(Math.min(remainingMs, 3e3)) });
 			if (expectStatus === void 0 ? response.status >= 200 && response.status < 400 : response.status === expectStatus) {
 				const expected = expectStatus === void 0 ? "2xx/3xx" : String(expectStatus);
-				return result(effectiveProbe.type, true, `HTTP probe ${effectiveProbe.url} returned expected status ${expected}.`, startedAt);
+				return result(effectiveProbe.type, true, `HTTP probe ${effectiveProbe.url} returned expected status ${expected}.`);
 			}
 			lastError = `HTTP ${response.status}`;
 		} catch (error) {
@@ -1818,14 +1544,13 @@ async function runProbe(probe, outputReader) {
 		}
 		await setTimeout$1(pollIntervalMs);
 	}
-	return result(effectiveProbe.type, false, `Timed out after ${timeoutSeconds}s probing ${effectiveProbe.url}: ${lastError}.`, startedAt);
+	return result(effectiveProbe.type, false, `Timed out after ${timeoutSeconds}s probing ${effectiveProbe.url}: ${lastError}.`);
 }
-function result(type, ok, message, startedAt) {
+function result(type, ok, message) {
 	return {
 		type,
 		ok,
-		message,
-		elapsedMs: Date.now() - startedAt
+		message
 	};
 }
 //#endregion
@@ -1888,12 +1613,12 @@ const zellijPtySpawnTool = tool({
 		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 });
+		const completedPanes = completedPanesFromSessions(sessionManager.listByOpenCodeSession(context.sessionID));
 		return jsonResponse({
 			session: publicSession(session),
 			output,
 			probe,
-			next: nextAdvice(probe.ok, probe.ok ? "Probe completed; continue with this session or read later for long-running output." : probe.message),
-			warnings: ["Registry remains in-memory; restarting OpenCode loses plugin session records."]
+			...completedPanes
 		});
 	}
 });
@@ -1942,8 +1667,7 @@ const zellijPtyWriteTool = tool({
 		const session = sessionManager.get(args.id);
 		if (session.humanInputOnly || !session.allowAgentInput) return jsonResponse({
 			session: publicSession(session),
-			output: subscriberManager.has(session.id) ? readOutputSnapshot(session.id, { maxLines: args.maxLines }) : emptyOutputSnapshot(session.lineCount),
-			next: nextAdvice(false, "This session is human-input-only; the user must type directly in the Zellij pane."),
+			output: subscriberManager.has(session.id) ? readOutputSnapshot(session.id, { maxLines: args.maxLines }) : emptyOutputSnapshot(),
 			warnings: ["Agent writes to human-input-only sessions are forbidden."]
 		});
 		if (args.data === "" || args.data === "") await zellijCli.sendCtrlC(session.paneId);
@@ -1969,296 +1693,155 @@ const zellijPtyWriteTool = tool({
 		return jsonResponse({
 			session: publicSession(session),
 			output,
-			next: nextAdvice(true, args.interruptAfterSeconds ? "Input was sent; Ctrl-C was sent after the requested interrupt timeout if the session was still running." : "Input was sent and recent output was observed."),
 			warnings
 		});
 	}
 });
 //#endregion
-//#region src/zellij/completion-notifications.ts
-/** Fetches the prompt-mode idle guard status; unrelated to tab title state. */
-async function fetchPromptIdleStatusSnapshot(client, workspaceRoot) {
+//#region src/utils/runtime.ts
+/**
+* Detect whether the plugin process is running inside an OpenCode TUI
+* session, as opposed to a headless `opencode run` invocation.
+*
+* OpenCode spawns the TUI's renderer as a worker child process and
+* explicitly sets `OPENCODE_PROCESS_ROLE=worker`
+* (see `packages/opencode/src/cli/cmd/tui/thread.ts` in opencode). The
+* headless `opencode run` command keeps the default `main` role set by
+* the CLI entry point, so this is the most reliable signal to tell TUI
+* from headless.
+*
+* Outside the TUI there is no surface for toasts, prompts, or Zellij
+* panes, and the plugin's lifecycle hooks (watchdogs, tab title actor,
+* completion notifications) misbehave. The plugin short-circuits to a
+* no-op in headless mode to avoid leaking side effects.
+*/
+function isOpencodeTuiMode() {
+	return process.env.OPENCODE_PROCESS_ROLE === "worker";
+}
+//#endregion
+//#region src/utils/logger.ts
+const defaultDebugLogPath = `${process.env.XDG_CACHE_HOME?.trim() || `${homedir()}/.cache`}/opencode-zellij/debug.log`;
+function buildRootLogger() {
+	const filename = process.env.OPENCODE_ZELLIJ_DEBUG_LOG?.trim() || defaultDebugLogPath;
+	if (!filename) return null;
 	try {
-		if (!client.session?.status) {
-			debug("fetchPromptIdleStatusSnapshot: client.session.status not available");
-			return;
-		}
-		const result = await client.session.status({ query: { directory: workspaceRoot } });
-		const payload = result && typeof result === "object" && "data" in result ? result.data : result;
-		if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
-			debug("fetchPromptIdleStatusSnapshot received non-object payload");
-			return;
-		}
-		const entries = Object.entries(payload);
-		if (entries.length === 0) return {};
-		const snapshot = {};
-		for (const [sessionID, status] of entries) {
-			const parsed = parseSessionStatus(status);
-			if (parsed === void 0) {
-				debug("fetchPromptIdleStatusSnapshot received invalid status entry, rejecting entire snapshot");
-				return;
-			}
-			snapshot[sessionID] = parsed;
-		}
-		return snapshot;
-	} catch (err) {
-		debug("fetchPromptIdleStatusSnapshot failed", errorMessage(err));
-		return;
+		mkdirSync(dirname(filename), { recursive: true });
+	} catch {
+		return null;
+	}
+	try {
+		return new LogLayer({
+			errorSerializer: serializeError,
+			transport: new LogFileRotationTransport({
+				filename: filename.includes("%DATE%") ? filename : `${filename}-%DATE%`,
+				dateFormat: "YMD",
+				size: "1M",
+				maxLogs: "7d",
+				frequency: "daily",
+				compressOnRotate: true,
+				auditFile: join(dirname(filename), "audit.json")
+			})
+		});
+	} catch {
+		return null;
 	}
 }
-function parseSessionStatus(value) {
-	if (!value || typeof value !== "object" || !("type" in value)) return void 0;
-	const status = value;
-	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
-	};
+const rootLogger = buildRootLogger();
+/**
+* Returns a child logger that prefixes every message with `[name]`, or
+* null if the root logger failed to initialize.
+*/
+function getChildLogger(name) {
+	return rootLogger?.withPrefix(`[${name}]`) ?? null;
 }
-const completionTitle = "Zellij PTY session completed";
-const completionMessage = "A Zellij PTY session completed. Review the finished pane if needed.";
-const queuedNoticeHeader = "[OpenCode] Zellij PTY completion notice";
-function supportsActivePrompt(mode) {
-	return mode === "prompt" || mode === "queue+toast";
+//#endregion
+//#region src/zellij/completion-notifications.ts
+const logger = getChildLogger("completion-notifications");
+async function postPromptAsync(serverUrl, sessionID, body) {
+	const url = new URL(`/session/${encodeURIComponent(sessionID)}/prompt_async`, serverUrl);
+	const headers = { "Content-Type": "application/json" };
+	const directory = process.env.OPENCODE_DIRECTORY?.trim();
+	if (directory) headers["x-opencode-directory"] = encodeURIComponent(directory);
+	return fetch(url, {
+		method: "POST",
+		headers,
+		body: JSON.stringify(body)
+	});
+}
+function formatExitCode(exitCode) {
+	return exitCode === null ? "?" : String(exitCode);
 }
-function buildQueuedCompletionNotice(events) {
-	return [queuedNoticeHeader, ...events.map((event) => `- ${event.session.id} (${event.session.paneId}) 已完成，請使用 zellij_pty_read 讀取最終輸出並清理 pane。`)].join("\n");
+function buildCompletionPromptText(event) {
+	const { paneId, exitCode } = event.session;
+	return `[zellij_pty] pane ${paneId} exit=${formatExitCode(exitCode)} — call zellij_pty_read to read, then zellij_pty_kill to close.`;
 }
 function buildCompletionPromptRequest(event) {
 	return {
-		path: { id: event.session.openCodeSessionId },
-		body: { parts: [{
-			type: "text",
-			text: completionMessage
-		}] }
-	};
-}
-function injectQueuedCompletionNotice(input, notice) {
-	if (typeof input === "string") return `${notice}\n\n${input}`;
-	if (!input || typeof input !== "object") return input;
-	const record = input;
-	if (Array.isArray(record.parts)) return {
-		...record,
+		sessionID: event.session.openCodeSessionId,
 		parts: [{
 			type: "text",
-			text: notice
-		}, ...record.parts]
-	};
-	if (typeof record.message === "string") return {
-		...record,
-		message: `${notice}\n\n${record.message}`
-	};
-	if (typeof record.content === "string") return {
-		...record,
-		content: `${notice}\n\n${record.content}`
-	};
-	if (typeof record.text === "string") return {
-		...record,
-		text: `${notice}\n\n${record.text}`
-	};
-	return {
-		...record,
-		message: notice
-	};
-}
-function evaluateCompletionPromptDecision(input) {
-	if (!supportsActivePrompt(input.config.mode)) return {
-		shouldPrompt: false,
-		shouldQueue: false,
-		reason: "prompt mode disabled"
-	};
-	if (input.event.session.humanInputOnly || !input.event.session.allowAgentInput) return {
-		shouldPrompt: false,
-		shouldQueue: true,
-		reason: "human-input-only session"
-	};
-	if (!input.promptClientAvailable) return {
-		shouldPrompt: false,
-		shouldQueue: true,
-		reason: "prompt client unavailable"
-	};
-	if (!input.event.session.openCodeSessionId) return {
-		shouldPrompt: false,
-		shouldQueue: true,
-		reason: "session id unavailable"
-	};
-	if (!input.snapshotAvailable) return {
-		shouldPrompt: false,
-		shouldQueue: true,
-		reason: "session status snapshot unavailable"
-	};
-	if (input.config.prompt.maxAttempts <= 0 || input.promptAttemptCount >= input.config.prompt.maxAttempts) return {
-		shouldPrompt: false,
-		shouldQueue: true,
-		reason: "prompt max attempts reached"
-	};
-	if (input.config.prompt.cooldownMs > 0 && input.lastPromptAttemptAt !== null && input.now - input.lastPromptAttemptAt < input.config.prompt.cooldownMs) return {
-		shouldPrompt: false,
-		shouldQueue: true,
-		reason: "prompt cooldown active"
-	};
-	if (input.config.prompt.requireIdle) {
-		const sessionId = input.event.session.openCodeSessionId;
-		if (!sessionId) return {
-			shouldPrompt: false,
-			shouldQueue: true,
-			reason: "session status unavailable"
-		};
-		const status = sessionId ? input.snapshot?.[sessionId] : void 0;
-		if (!status) return {
-			shouldPrompt: false,
-			shouldQueue: true,
-			reason: "session status unavailable"
-		};
-		if (status && status.type !== "idle") return {
-			shouldPrompt: false,
-			shouldQueue: true,
-			reason: "session not idle"
-		};
-	}
-	return {
-		shouldPrompt: true,
-		shouldQueue: false,
-		reason: "prompt allowed"
+			text: buildCompletionPromptText(event)
+		}]
 	};
 }
-var SessionCompletionNotificationQueue = class {
-	states = /* @__PURE__ */ new Map();
-	constructor(context, hooks = {}, clock = () => Date.now()) {
+var SessionCompletionNotificationManager = class {
+	seen = /* @__PURE__ */ new Set();
+	constructor(context) {
 		this.context = context;
-		this.hooks = hooks;
-		this.clock = clock;
-	}
-	hasPending(sessionId) {
-		return this.states.get(sessionId)?.queued ?? false;
-	}
-	clearSession(sessionId) {
-		this.states.delete(sessionId);
-	}
-	clearAll() {
-		this.states.clear();
 	}
 	dispose() {
-		this.clearAll();
+		this.seen.clear();
 	}
 	async handleSessionTerminal(event) {
-		if (this.context.config.mode === "off") return;
-		if (this.states.has(event.sessionId) || event.session.tombstone?.notificationSentAt) return;
-		const state = {
-			event,
-			queued: false,
-			sent: false,
-			toastSent: false,
-			promptAttempts: 0,
-			promptAttemptedAt: null
-		};
-		this.states.set(event.sessionId, state);
-		switch (this.context.config.mode) {
-			case "queue":
-				state.queued = true;
-				return;
-			case "toast":
-				await this.sendToast(state);
-				this.finalize(state);
-				return;
-			case "queue+toast":
-				await this.tryPromptOrQueue(state);
-				await this.sendToast(state);
-				return;
-			case "prompt":
-				await this.tryPromptOrQueue(state);
-				break;
-			default:
-		}
-	}
-	injectQueuedChatMessage(input) {
-		const pending = [...this.states.values()].filter((state) => state.queued);
-		if (pending.length === 0) return input;
-		const notice = buildQueuedCompletionNotice(pending.map((state) => state.event));
-		for (const state of pending) {
-			this.markStateSent(state);
-			this.finalize(state);
-		}
-		return injectQueuedCompletionNotice(input, notice);
-	}
-	async tryPromptOrQueue(state) {
-		if (!state.event.session.openCodeSessionId) {
-			state.queued = true;
+		logger?.withMetadata({
+			session: event.sessionId,
+			reason: event.reason,
+			paneId: event.session.paneId,
+			openCodeSessionId: event.session.openCodeSessionId ?? "null"
+		}).info("handleSessionTerminal");
+		if (this.seen.has(event.sessionId)) return;
+		this.seen.add(event.sessionId);
+		if (!event.session.openCodeSessionId) {
+			logger?.withMetadata({ session: event.sessionId }).info("skipped: no openCodeSessionId");
 			return;
 		}
 		const session = this.context.client.session;
-		const prompt = session?.prompt ?? session?.promptAsync;
-		const statusSnapshot = await fetchPromptIdleStatusSnapshot(this.context.client, this.context.workspaceRoot);
-		const decision = evaluateCompletionPromptDecision({
-			event: state.event,
-			config: this.context.config,
-			snapshot: statusSnapshot,
-			snapshotAvailable: statusSnapshot !== void 0,
-			now: this.clock(),
-			lastPromptAttemptAt: state.promptAttemptedAt,
-			promptAttemptCount: state.promptAttempts,
-			promptClientAvailable: Boolean(prompt)
-		});
-		if (!decision.shouldPrompt) {
-			state.queued = decision.shouldQueue;
-			return;
-		}
-		if (this.hooks.prompt) try {
-			const maybePromise = this.hooks.prompt(state.event);
-			if (maybePromise && typeof maybePromise.then === "function") await maybePromise;
-		} catch (error) {
-			debug("completion notification prompt hook failed", errorMessage(error));
-		}
-		if (!session || !prompt) {
-			state.queued = true;
+		const sdkPrompt = session?.promptAsync ?? session?.prompt;
+		const request = buildCompletionPromptRequest(event);
+		const sessionID = request.sessionID;
+		if (sdkPrompt) try {
+			logger?.withMetadata({ sessionID }).info("SDK prompt attempt");
+			await sdkPrompt(request);
+			logger?.withMetadata({ sessionID }).info("SDK prompt ok");
 			return;
-		}
-		state.promptAttempts += 1;
-		state.promptAttemptedAt = this.clock();
-		try {
-			if (session.prompt) await session.prompt(buildCompletionPromptRequest(state.event));
-			else if (session.promptAsync) await session.promptAsync(buildCompletionPromptRequest(state.event));
-			else {
-				state.queued = true;
-				return;
-			}
-			this.markStateSent(state);
-			this.finalize(state);
 		} catch (error) {
-			debug("completion notification prompt failed", errorMessage(error));
-			state.queued = true;
+			logger?.withMetadata({
+				sessionID,
+				error: errorMessage(error)
+			}).warn("SDK prompt failed, falling back to HTTP");
 		}
-	}
-	async sendToast(state) {
-		const toast = this.context.client.tui?.showToast;
-		if (!toast) {
-			debug("completion notification toast skipped: client.tui.showToast unavailable");
+		else logger?.withMetadata({
+			sessionID,
+			sessionKeys: session ? Object.keys(session).join(",") : "null"
+		}).info("no SDK prompt on client, using HTTP fallback");
+		if (!this.context.serverUrl) {
+			logger?.withMetadata({ sessionID }).error("no serverUrl for HTTP fallback");
 			return;
 		}
 		try {
-			await toast({ body: {
-				title: completionTitle,
-				message: completionMessage,
-				variant: "success",
-				duration: 1e4
-			} });
-			state.toastSent = true;
-			this.markStateSent(state);
-			if (!state.queued) this.finalize(state);
+			const response = await postPromptAsync(this.context.serverUrl, sessionID, { parts: request.parts });
+			logger?.withMetadata({
+				sessionID,
+				status: response.status,
+				ok: response.ok
+			}).info("HTTP fallback response");
 		} catch (error) {
-			debug("completion notification toast failed", errorMessage(error));
+			logger?.withMetadata({
+				sessionID,
+				error: errorMessage(error)
+			}).error("HTTP fallback threw");
 		}
 	}
-	markStateSent(state) {
-		if (state.sent) return;
-		this.context.markSent(state.event.sessionId);
-		state.sent = true;
-	}
-	finalize(state) {
-		this.states.delete(state.event.sessionId);
-	}
 };
 //#endregion
 //#region src/zellij/shutdown-cleanup.ts
@@ -2600,9 +2183,6 @@ var TabTitleManager = class {
 	emojis;
 	enabled;
 	destroyed = false;
-	originalTabTitle;
-	originalTabTitleLoaded = false;
-	originalTabTitlePromise;
 	destroyPromise;
 	actor;
 	constructor(options) {
@@ -2628,8 +2208,6 @@ var TabTitleManager = class {
 	}
 	async renderImmediate() {
 		if (!this.enabled || this.destroyed) return;
-		await this.ensureOriginalTabTitle();
-		if (this.destroyed) return;
 		this.desiredTitle = this.buildTitle();
 		this.clearDebounceTimer();
 		await this.syncDesiredTitle();
@@ -2651,7 +2229,6 @@ var TabTitleManager = class {
 	async syncDesiredTitle() {
 		if (!this.enabled || this.destroyed) return;
 		const generation = this.syncGeneration;
-		await this.ensureOriginalTabTitle();
 		if (this.destroyed || generation !== this.syncGeneration) return;
 		if (this.syncInFlight) return this.syncPromise;
 		this.syncInFlight = true;
@@ -2701,23 +2278,6 @@ var TabTitleManager = class {
 		if (this.debounceTimer) clearTimeout(this.debounceTimer);
 		this.debounceTimer = void 0;
 	}
-	async ensureOriginalTabTitle() {
-		if (!this.enabled || this.originalTabTitleLoaded) return;
-		if (this.originalTabTitlePromise) return this.originalTabTitlePromise;
-		this.originalTabTitlePromise = this.saveOriginalTabTitle();
-		return this.originalTabTitlePromise;
-	}
-	async saveOriginalTabTitle() {
-		try {
-			const title = await this.cli.currentTabTitle();
-			if (title !== void 0) this.originalTabTitle = title;
-		} catch (error) {
-			debug("TabTitleManager failed to save original tab title", errorMessage(error));
-		} finally {
-			this.originalTabTitleLoaded = true;
-			this.originalTabTitlePromise = void 0;
-		}
-	}
 	destroy() {
 		if (this.destroyed) return this.destroyPromise ?? Promise.resolve();
 		this.destroyed = true;
@@ -2725,21 +2285,12 @@ var TabTitleManager = class {
 		this.desiredTitle = void 0;
 		this.clearDebounceTimer();
 		this.clearRetryTimer();
-		if (!this.enabled) return Promise.resolve();
-		this.destroyPromise = this.restoreOriginalTabTitle().catch((error) => debug("TabTitleManager failed to restore original tab title", errorMessage(error)));
-		return this.destroyPromise;
-	}
-	async restoreOriginalTabTitle() {
-		await this.originalTabTitlePromise;
-		await this.syncPromise;
-		const originalTitle = this.originalTabTitle;
-		this.originalTabTitle = void 0;
-		if (originalTitle === void 0) return;
-		await this.cli.renameTab(originalTitle);
+		return Promise.resolve();
 	}
 };
 //#endregion
 //#region src/plugin.ts
+const PLUGIN_ID = "opencode-zellij";
 function createPtyTools(defaultCleanupExitedPaneOnRead) {
 	return {
 		zellij_pty_spawn: zellijPtySpawnTool,
@@ -2755,29 +2306,6 @@ function getProjectName(path) {
 function getWorkspaceRoot(input) {
 	return input.worktree || input.directory || process.cwd();
 }
-function showUpdateToast(client, result) {
-	if (result.type === "updated") client.tui.showToast({ body: {
-		title: "opencode-zellij updated",
-		message: `Updated to ${result.toVersion}. Restart OpenCode to apply the changes.`,
-		variant: "success",
-		duration: 1e4
-	} }).catch((error) => debug("show update toast for successful update failed", errorMessage(error)));
-	else if (result.type === "failed") client.tui.showToast({ body: {
-		title: "opencode-zellij update failed",
-		message: `Failed to update to ${result.latestVersion}.`,
-		variant: "error",
-		duration: 8e3
-	} }).catch((error) => debug("show update toast for failed update failed", errorMessage(error)));
-}
-function startAutoUpdateCheck(client, importMetaUrl, check = checkAndUpdate) {
-	(async () => {
-		try {
-			showUpdateToast(client, await check({ importMetaUrl }));
-		} catch (cause) {
-			debug("auto-update check failed", errorMessage(cause));
-		}
-	})();
-}
 async function cleanupStep(stepName, sessionId, step) {
 	try {
 		await step();
@@ -2793,6 +2321,10 @@ async function cleanupDeletedSession(sessionId) {
 }
 function createZellijPtyPlugin(dependencies = {}) {
 	return async (input) => {
+		if (!isOpencodeTuiMode()) {
+			debug("opencode-zellij disabled: not running inside an OpenCode TUI session");
+			return {};
+		}
 		const { config, warnings } = await loadConfig(input);
 		for (const warning of warnings) debug(warning);
 		configureSudoPane(config.pty.sudoPane === "allow");
@@ -2820,60 +2352,35 @@ function createZellijPtyPlugin(dependencies = {}) {
 				branch: config.tabTitle.emojiBranch
 			}
 		}) : void 0;
-		const client = input.client;
-		const completionNotifications = config.pty.completionNotification.mode === "off" ? void 0 : dependencies.createCompletionNotifications?.({
-			client,
-			workspaceRoot,
-			config: config.pty.completionNotification,
-			markSent(sessionId) {
-				try {
-					sessionManager.markTerminalNotificationSent(sessionId);
-				} catch (error) {
-					debug("mark terminal notification sent failed", errorMessage(error));
-				}
-			}
-		}) ?? new SessionCompletionNotificationQueue({
-			client,
-			workspaceRoot,
-			config: config.pty.completionNotification,
-			markSent(sessionId) {
-				try {
-					sessionManager.markTerminalNotificationSent(sessionId);
-				} catch (error) {
-					debug("mark terminal notification sent failed", errorMessage(error));
-				}
-			}
+		const completionNotifications = dependencies.createCompletionNotifications?.({
+			client: { session: input.client?.session },
+			serverUrl: input.serverUrl
+		}) ?? new SessionCompletionNotificationManager({
+			client: { session: input.client?.session },
+			serverUrl: input.serverUrl
 		});
-		subscriberManager.setLifecycleHooks(completionNotifications ? { onSessionTerminal: (event) => void completionNotifications.handleSessionTerminal(event).catch((error) => debug("completion notification lifecycle hook failed", errorMessage(error))) } : void 0);
+		subscriberManager.setLifecycleHooks({ onSessionTerminal: (event) => void completionNotifications.handleSessionTerminal(event).catch((error) => debug("completion notification lifecycle hook failed", errorMessage(error))) });
 		if (actor) await actor.ready;
 		tabTitleManager?.renderImmediate().catch((error) => debug("initial tab title render failed", errorMessage(error)));
-		if (config.autoUpdate) (dependencies.startAutoUpdateCheck ?? startAutoUpdateCheck)(client, dependencies.importMetaUrl ?? import.meta.url);
 		return {
 			async event(input) {
 				const event = input.event;
 				if (actor && tabTitleManager) {
 					await actor.handleEvent(event);
-					if (event.type === "server.instance.disposed" || event.type === "global.disposed") await tabTitleManager.destroy();
-					else tabTitleManager.scheduleUpdate();
+					tabTitleManager.scheduleUpdate();
 				}
 				if (event.type === "server.instance.disposed" || event.type === "global.disposed") {
-					completionNotifications?.clearAll();
-					completionNotifications?.dispose();
+					completionNotifications.dispose();
 					subscriberManager.setLifecycleHooks(void 0);
 				}
 				if (event.type === "session.deleted") {
 					const sessionID = deletedSessionID$1(event);
 					if (!sessionID) return;
 					const sessions = sessionManager.listByOpenCodeSession(sessionID);
-					for (const session of sessions) completionNotifications?.clearSession(session.id);
 					await Promise.all(sessions.map((session) => cleanupDeletedSession(session.id)));
 				}
 			},
-			"chat.message": async (_input, output) => {
-				const injected = completionNotifications?.injectQueuedChatMessage(output) ?? output;
-				if (injected !== output && injected && typeof injected === "object" && Array.isArray(injected.parts)) output.parts = injected.parts;
-			},
-			"tool": config.pty.enabled ? {
+			tool: config.pty.enabled ? {
 				...createPtyTools(config.pty.cleanupExitedPaneOnRead),
 				...config.pty.sudoPane === "hide" ? {} : { zellij_pty_request_sudo: requestSudoTool }
 			} : {}
@@ -2881,7 +2388,11 @@ function createZellijPtyPlugin(dependencies = {}) {
 	};
 }
 const ZellijPtyPlugin = createZellijPtyPlugin();
+var plugin_default = {
+	id: PLUGIN_ID,
+	server: ZellijPtyPlugin
+};
 //#endregion
-export { ZellijPtyPlugin, ZellijPtyPlugin as default, createZellijPtyPlugin, showUpdateToast, startAutoUpdateCheck };
+export { ZellijPtyPlugin, createZellijPtyPlugin, plugin_default as default };
 
 //# sourceMappingURL=index.mjs.map