opencode-zellij 0.0.10 → 0.0.12

package/dist/index.mjs

@@ -250,6 +250,13 @@ const sudoPaneSchema = z.enum([
 	"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."),
@@ -261,7 +268,16 @@ const tabTitleLayerSchema = z.object({
 }).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.")
+	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.")
 }).strict();
 const autoUpdateLayerSchema = z.boolean().optional().describe("Enable automatic update checks for the opencode-zellij plugin.");
 const sidecarConfigSchema = z.object({
@@ -281,7 +297,16 @@ const defaultConfig = {
 	},
 	pty: {
 		enabled: true,
-		sudoPane: "allow"
+		cleanupExitedPaneOnRead: true,
+		sudoPane: "allow",
+		completionNotification: {
+			mode: "queue+toast",
+			prompt: {
+				requireIdle: true,
+				cooldownMs: 3e4,
+				maxAttempts: 1
+			}
+		}
 	},
 	autoUpdate: true
 };
@@ -306,7 +331,16 @@ function mergeConfig(user, project) {
 		},
 		pty: {
 			enabled: project?.pty?.enabled ?? user?.pty?.enabled ?? defaultConfig.pty.enabled,
-			sudoPane: project?.pty?.sudoPane ?? user?.pty?.sudoPane ?? defaultConfig.pty.sudoPane
+			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
 	};
@@ -390,6 +424,7 @@ function parsePaneId(output) {
 }
 //#endregion
 //#region src/pty/manager.ts
+const tombstoneTailLimit = 200;
 var SessionManager = class {
 	sessions = /* @__PURE__ */ new Map();
 	create(input) {
@@ -410,7 +445,8 @@ var SessionManager = class {
 			humanInputOnly: input.humanInputOnly,
 			exitCode: null,
 			exitedAt: null,
-			exitCodeToken: input.exitCodeToken ?? null
+			exitCodeToken: input.exitCodeToken ?? null,
+			tombstone: null
 		};
 		this.sessions.set(session.id, session);
 		return session;
@@ -434,16 +470,65 @@ var SessionManager = class {
 	}
 	updateStatus(id, status) {
 		const session = this.get(id);
+		if (session.status === "terminal" && status !== "terminal") return session;
 		session.status = status;
 		session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
 		return session;
 	}
 	markExited(id, exitCode) {
+		return this.markTerminal(id, {
+			reason: "exit_marker",
+			exitCode
+		}).session;
+	}
+	markTerminal(id, input) {
+		const session = this.get(id);
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const created = session.status !== "terminal" || !session.tombstone;
+		if (created) {
+			const tombstone = {
+				reason: input.reason,
+				terminalAt: now,
+				tail: (input.tail ?? []).slice(-tombstoneTailLimit),
+				paneClosedAt: null,
+				notificationSentAt: null
+			};
+			session.status = "terminal";
+			session.tombstone = tombstone;
+			session.updatedAt = now;
+		}
+		if (input.exitCode !== void 0 && session.exitCode === null) {
+			session.exitCode = input.exitCode;
+			session.exitedAt = now;
+			session.updatedAt = now;
+		}
+		if (session.tombstone) {
+			if (input.tail?.length && session.tombstone.tail.length === 0) session.tombstone.tail = input.tail.slice(-tombstoneTailLimit);
+			if (!session.tombstone.reason) session.tombstone.reason = input.reason;
+		}
+		return {
+			session,
+			created
+		};
+	}
+	markTerminalPaneClosed(id) {
+		const session = this.get(id);
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		if (!session.tombstone) return session;
+		if (!session.tombstone.paneClosedAt) {
+			session.tombstone.paneClosedAt = now;
+			session.updatedAt = now;
+		}
+		return session;
+	}
+	markTerminalNotificationSent(id) {
 		const session = this.get(id);
-		session.status = "exited";
-		session.exitCode = exitCode;
-		session.exitedAt = (/* @__PURE__ */ new Date()).toISOString();
-		session.updatedAt = session.exitedAt;
+		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) {
@@ -512,19 +597,19 @@ function paneMatches(object, paneId) {
 		"paneId"
 	]) === paneId && object.is_plugin !== true;
 }
-function findPaneTabId(value, paneId) {
+function findPaneRecord(value, paneId) {
 	if (Array.isArray(value)) {
 		for (const item of value) {
-			const found = findPaneTabId(item, paneId);
+			const found = findPaneRecord(item, paneId);
 			if (found !== void 0) return found;
 		}
 		return;
 	}
 	if (typeof value !== "object" || value === null) return void 0;
 	const object = value;
-	if (paneMatches(object, paneId)) return numericProperty(object, ["tab_id", "tabId"]);
+	if (paneMatches(object, paneId)) return object;
 	for (const nested of Object.values(object)) {
-		const found = findPaneTabId(nested, paneId);
+		const found = findPaneRecord(nested, paneId);
 		if (found !== void 0) return found;
 	}
 }
@@ -533,12 +618,28 @@ function parseCurrentPaneTabId(listPanesJson, paneId) {
 	const parsedPaneId = Number(paneId);
 	if (!Number.isInteger(parsedPaneId)) return void 0;
 	try {
-		return findPaneTabId(JSON.parse(listPanesJson), parsedPaneId);
+		const pane = findPaneRecord(JSON.parse(listPanesJson), parsedPaneId);
+		return pane ? numericProperty(pane, ["tab_id", "tabId"]) : void 0;
 	} catch (error) {
 		debug("parseCurrentPaneTabId failed", errorMessage(error));
 		return;
 	}
 }
+function parsePaneExists(listPanesJson, paneId) {
+	if (!paneId) return void 0;
+	let parsedPaneId;
+	try {
+		parsedPaneId = Number(normalizePaneId(paneId).slice(9));
+	} catch {
+		return;
+	}
+	try {
+		return findPaneRecord(JSON.parse(listPanesJson), parsedPaneId) !== void 0;
+	} catch (error) {
+		debug("parsePaneExists failed", errorMessage(error));
+		return;
+	}
+}
 function tabNameProperty(object, tabId) {
 	if (tabId === void 0) return void 0;
 	if (numericProperty(object, ["tab_id", "tabId"]) !== tabId) return void 0;
@@ -680,6 +781,9 @@ var ZellijCli = class {
 		if (!paneId) return void 0;
 		return parseCurrentPaneTabId((await runZellij(zellijActionArgs("list-panes", ["--json"]), { timeoutMs: 5e3 })).stdout, paneId);
 	}
+	async paneExists(paneId) {
+		return parsePaneExists((await runZellij(zellijActionArgs("list-panes", ["--json"]), { timeoutMs: 5e3 })).stdout, paneId);
+	}
 	async renameTab(title) {
 		const tabId = await this.currentPaneTabId();
 		if (tabId === void 0 && process.env.ZELLIJ) throw new Error(`Could not resolve Zellij tab id for pane ${process.env.ZELLIJ_PANE_ID ?? "<missing>"}`);
@@ -993,11 +1097,25 @@ function extractRenderedLines(event) {
 var SubscriberManager = class {
 	subscribers = /* @__PURE__ */ new Map();
 	startingSessions = /* @__PURE__ */ new Map();
-	constructor(sessions, maxBufferLines = Number(process.env.PTY_MAX_BUFFER_LINES ?? 5e4)) {
+	spawnProcess;
+	dumpScreen;
+	closePane;
+	lifecycleHooks;
+	terminalTailLines;
+	constructor(sessions, maxBufferLines = Number(process.env.PTY_MAX_BUFFER_LINES ?? 5e4), dependencies = {}) {
 		this.sessions = sessions;
 		this.maxBufferLines = maxBufferLines;
+		this.spawnProcess = dependencies.spawn ?? spawn;
+		this.dumpScreen = dependencies.dumpScreen ?? zellijCli.dumpScreen;
+		this.closePane = dependencies.closePane ?? zellijCli.closePane;
+		this.lifecycleHooks = dependencies.lifecycleHooks;
+		this.terminalTailLines = dependencies.terminalTailLines ?? 200;
+	}
+	setLifecycleHooks(hooks) {
+		this.lifecycleHooks = hooks;
 	}
 	async start(session) {
+		if ((this.sessions.find(session.id) ?? session).status === "terminal") return;
 		if (this.subscribers.get(session.id)?.child) return;
 		const inProgress = this.startingSessions.get(session.id);
 		if (inProgress) return inProgress;
@@ -1021,7 +1139,7 @@ var SubscriberManager = class {
 			lastExitedAt: null
 		};
 		if (!existing) this.subscribers.set(session.id, state);
-		const child = spawn("zellij", zellijCommandArgs([
+		const child = this.spawnProcess("zellij", zellijCommandArgs([
 			"subscribe",
 			"--pane-id",
 			session.paneId,
@@ -1048,7 +1166,7 @@ var SubscriberManager = class {
 		child.on("exit", () => this.handleSubscriberExit(session.id, child));
 		child.on("error", (error) => this.handleSubscriberError(session.id, child, error));
 		if (!existing) try {
-			const snapshot = await zellijCli.dumpScreen(session.paneId);
+			const snapshot = await this.dumpScreen(session.paneId);
 			if (this.subscribers.get(session.id) !== state || state.child !== child) return;
 			state.buffer.appendSnapshot(snapshot);
 			this.sessions.updateLineCount(session.id, state.buffer.lineCount);
@@ -1069,7 +1187,8 @@ var SubscriberManager = class {
 		return {
 			hasBuffer: Boolean(state),
 			active: Boolean(state?.child),
-			lastExitedAt: state?.lastExitedAt ?? null
+			lastExitedAt: state?.lastExitedAt ?? null,
+			terminal: this.sessions.find(sessionId)?.status === "terminal"
 		};
 	}
 	stderr(sessionId) {
@@ -1089,13 +1208,14 @@ var SubscriberManager = class {
 	stopAll() {
 		for (const sessionId of this.subscribers.keys()) this.forget(sessionId);
 	}
-	async closeSessionPane(sessionId) {
+	async closeSessionPane(sessionId, options = {}) {
 		const session = this.sessions.get(sessionId);
 		this.stop(sessionId);
 		try {
-			await zellijCli.closePane(session.paneId);
+			await this.closePane(session.paneId);
 		} catch (error) {
 			debug("closePane failed", errorMessage(error));
+			if (options.throwOnFailure) throw error;
 		}
 	}
 	handleStdout(sessionId, child, chunk) {
@@ -1133,11 +1253,8 @@ var SubscriberManager = class {
 		if (paneId && paneId !== session.paneId) return;
 		const type = eventType(event);
 		if (type === "pane_closed" || type === "PaneClosed") {
-			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");
+			this.markSessionTerminal(sessionId, "pane_closed");
 			unregisterPaneFromWatchdog(sessionId);
-			this.stop(sessionId);
 			return;
 		}
 		const lines = extractRenderedLines(event);
@@ -1152,7 +1269,7 @@ var SubscriberManager = class {
 		for (const line of lines) {
 			const marker = parseExitCodeMarker(line);
 			if (!marker || marker.token !== session.exitCodeToken) continue;
-			this.sessions.markExited(sessionId, marker.exitCode);
+			this.markSessionTerminal(sessionId, "exit_marker", { exitCode: marker.exitCode });
 			return;
 		}
 	}
@@ -1168,7 +1285,7 @@ var SubscriberManager = class {
 		if (state.child !== child) return;
 		state.child = null;
 		state.lastExitedAt = (/* @__PURE__ */ new Date()).toISOString();
-		state.stderr.push(`[zellij-pty] subscriber exited at ${state.lastExitedAt}; last buffered output is retained.`);
+		if (this.sessions.find(sessionId)?.status !== "terminal") state.stderr.push(`[zellij-pty] subscriber exited at ${state.lastExitedAt}; last buffered output is retained.`);
 		if (state.stderr.length > maxStderrLines) state.stderr = state.stderr.slice(state.stderr.length - maxStderrLines);
 	}
 	handleSubscriberError(sessionId, child, error) {
@@ -1180,6 +1297,29 @@ var SubscriberManager = class {
 			this.sessions.updateStatus(sessionId, "unknown");
 		}
 	}
+	markSessionTerminal(sessionId, reason, input = {}) {
+		const state = this.subscribers.get(sessionId);
+		if (!state) return;
+		const tail = state.buffer.read({ limit: this.terminalTailLines }).lines;
+		const result = this.sessions.markTerminal(sessionId, {
+			reason,
+			tail,
+			exitCode: input.exitCode
+		});
+		if (result.created) try {
+			const maybePromise = this.lifecycleHooks?.onSessionTerminal?.({
+				sessionId,
+				reason,
+				session: result.session
+			});
+			if (maybePromise && typeof maybePromise.then === "function") maybePromise.catch((error) => {
+				debug("onSessionTerminal hook failed", errorMessage(error));
+			});
+		} catch (error) {
+			debug("onSessionTerminal hook failed", errorMessage(error));
+		}
+		this.stop(sessionId);
+	}
 };
 const subscriberManager = new SubscriberManager(sessionManager);
 //#endregion
@@ -1192,14 +1332,21 @@ function publicSession(session) {
 		command: session.command,
 		args: session.args,
 		cwd: session.cwd,
-		status: session.status,
+		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
+		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
 	};
 }
 function nextAdvice(retryable, reason) {
@@ -1256,53 +1403,90 @@ function outputMatches(sessionId, grep, ignoreCase) {
 	}).returned > 0;
 }
 //#endregion
+//#region src/tools/pane-cleanup.ts
+async function closePaneOrVerifyGone(input) {
+	try {
+		await input.closePane();
+		return {
+			cleanupReady: true,
+			alreadyGone: false
+		};
+	} catch (error) {
+		const closeErrorMessage = error instanceof Error ? error.message : String(error);
+		if (await isPaneGone(input.paneId, input.paneExists)) return {
+			cleanupReady: true,
+			alreadyGone: true,
+			closeErrorMessage
+		};
+		return {
+			cleanupReady: false,
+			alreadyGone: false,
+			closeErrorMessage
+		};
+	}
+}
+async function isPaneGone(paneId, paneExists) {
+	if (!paneExists) return false;
+	try {
+		return await paneExists(paneId) === false;
+	} catch {
+		return false;
+	}
+}
+//#endregion
 //#region src/tools/kill.ts
 const schema$4 = tool.schema;
-function closeFailureMeansGone(message) {
-	return /not found|no such|does not exist|already closed|already gone|unknown pane/i.test(message);
+async function executeZellijPtyKill(args, dependencies = {}) {
+	const zellijCliApi = dependencies.zellijCli ?? zellijCli;
+	const session = sessionManager.get(args.id);
+	const warnings = [];
+	const output = subscriberManager.has(session.id) ? readOutputSnapshot(session.id) : void 0;
+	try {
+		await zellijCliApi.sendCtrlC(session.paneId);
+		await setTimeout$1(500);
+	} catch (error) {
+		warnings.push(`Ctrl-C failed or pane was already gone: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	const closeResult = await closePaneOrVerifyGone({
+		paneId: session.paneId,
+		closePane: () => zellijCliApi.closePane(session.paneId),
+		paneExists: zellijCliApi.paneExists
+	});
+	if (!closeResult.cleanupReady) {
+		warnings.push(`close-pane failed: ${closeResult.closeErrorMessage ?? "unknown error"}`);
+		return {
+			killed: false,
+			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
+		};
+	}
+	return finalizeKilledSession(session.id, session.paneId, output, warnings);
 }
 const zellijPtyKillTool = tool({
 	description: "Terminate a known Zellij PTY session by sending Ctrl-C, then closing its pane.",
 	args: { id: schema$4.string().describe("zellij-pty session id.") },
 	async execute(args) {
-		const session = sessionManager.get(args.id);
-		const warnings = [];
-		const output = subscriberManager.has(session.id) ? readOutputSnapshot(session.id) : void 0;
-		try {
-			await zellijCli.sendCtrlC(session.paneId);
-			await setTimeout$1(500);
-		} catch (error) {
-			warnings.push(`Ctrl-C failed or pane was already gone: ${error instanceof Error ? error.message : String(error)}`);
-		}
-		try {
-			await zellijCli.closePane(session.paneId);
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			warnings.push(`close-pane failed: ${message}`);
-			if (!closeFailureMeansGone(message)) return jsonResponse({
-				killed: false,
-				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
-			});
-		}
-		subscriberManager.stop(session.id);
-		subscriberManager.forget(session.id);
-		unregisterPaneFromWatchdog(session.id);
-		sessionManager.remove(session.id);
-		return jsonResponse({
-			killed: true,
-			cleanedUp: true,
-			id: session.id,
-			paneId: session.paneId,
-			output,
-			next: nextAdvice(false, "Session was closed and removed from the in-memory registry."),
-			warnings
-		});
+		return jsonResponse(await executeZellijPtyKill(args));
 	}
 });
+async function finalizeKilledSession(sessionId, paneId, output, warnings) {
+	subscriberManager.stop(sessionId);
+	subscriberManager.forget(sessionId);
+	unregisterPaneFromWatchdog(sessionId);
+	sessionManager.remove(sessionId);
+	return {
+		killed: true,
+		cleanedUp: true,
+		id: sessionId,
+		paneId,
+		output,
+		next: nextAdvice(false, "Session was closed and removed from the in-memory registry."),
+		warnings
+	};
+}
 //#endregion
 //#region src/tools/list.ts
 const zellijPtyListTool = tool({
@@ -1318,55 +1502,123 @@ const zellijPtyListTool = tool({
 //#endregion
 //#region src/tools/read.ts
 const schema$3 = tool.schema;
-const zellijPtyReadTool = tool({
-	description: "Read recent rendered output from a Zellij PTY session. Supports regex grep filtering.",
-	args: {
-		id: schema$3.string().describe("zellij-pty session id."),
-		maxLines: schema$3.number().int().positive().max(5e3).optional().describe("Maximum recent output lines to return. Defaults to 200."),
-		grep: schema$3.string().optional().describe("Regex used to filter returned lines."),
-		ignoreCase: schema$3.boolean().optional().describe("Use case-insensitive regex matching.")
-	},
-	async execute(args) {
-		const session = sessionManager.get(args.id);
-		const grepError = validateGrep(args.grep);
-		if (grepError) return jsonResponse({
-			session: publicSession(session),
-			output: {
-				text: "",
-				lines: [],
-				lineCount: session.lineCount,
-				returned: 0,
-				truncated: false
-			},
-			next: nextAdvice(false, `Invalid grep regex: ${grepError}`),
-			warnings: []
-		});
-		const subscriberStatus = subscriberManager.status(session.id);
-		if (!subscriberStatus.hasBuffer || !subscriberStatus.active && (session.status === "running" || session.status === "unknown")) await subscriberManager.start(session);
-		const statusAfterStart = subscriberManager.status(session.id);
-		const warnings = [];
-		if (session.humanInputOnly) warnings.push("This pane is human-input-only: agent writes are forbidden, but rendered output is visible to the agent.");
-		if (!statusAfterStart.active) {
-			warnings.push("Subscriber is inactive; returned output may be stale.");
-			if (session.status === "running") sessionManager.updateStatus(session.id, "unknown");
+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 ?? zellijCli.paneExists;
+	const session = sessionManagerApi.get(args.id);
+	const grepError = validateGrepApi(args.grep);
+	if (grepError) return {
+		session: publicSessionApi(session),
+		output: {
+			text: "",
+			lines: [],
+			lineCount: session.lineCount,
+			returned: 0,
+			truncated: false
+		},
+		next: nextAdviceApi(false, `Invalid grep regex: ${grepError}`),
+		subscriberActive: false,
+		subscriberLastExitedAt: null,
+		subscriberErrors: [],
+		warnings: [],
+		cleanup: {
+			requested: false,
+			performed: false,
+			alreadyClosed: false
 		}
-		const output = readOutputSnapshot(session.id, {
-			maxLines: args.maxLines,
-			grep: args.grep,
-			ignoreCase: args.ignoreCase
-		});
-		return jsonResponse({
-			session: publicSession(session),
-			output,
-			next: nextAdvice(session.status !== "exited" && session.status !== "killed", nextReadReason(session.status)),
-			subscriberActive: statusAfterStart.active,
-			subscriberLastExitedAt: statusAfterStart.lastExitedAt,
-			subscriberErrors: subscriberManager.stderr(session.id),
-			warnings
-		});
+	};
+	const subscriberStatus = subscriberManagerApi.status(session.id);
+	if (!subscriberStatus.hasBuffer || !subscriberStatus.active && (session.status === "running" || session.status === "unknown")) await subscriberManagerApi.start(session);
+	const statusAfterStart = subscriberManagerApi.status(session.id);
+	const warnings = [];
+	if (session.humanInputOnly) warnings.push("This pane is human-input-only: agent writes are forbidden, but rendered output is visible to the agent.");
+	if (!statusAfterStart.active && session.status === "running") {
+		warnings.push("Subscriber is inactive; returned output may be stale.");
+		sessionManagerApi.updateStatus(session.id, "unknown");
+	}
+	const output = readOutputSnapshotApi(session.id, {
+		maxLines: args.maxLines,
+		grep: args.grep,
+		ignoreCase: args.ignoreCase
+	});
+	const cleanup = await cleanupExitedPaneOnRead(session.id, session.status, args.cleanupExitedPaneOnRead ?? dependencies.defaultCleanupExitedPaneOnRead ?? true, {
+		sessionManager: sessionManagerApi,
+		subscriberManager: subscriberManagerApi,
+		paneExists: paneExistsApi
+	});
+	if (cleanup.warning) warnings.push(cleanup.warning);
+	return {
+		session: publicSessionApi(session),
+		output,
+		next: nextAdviceApi(!isCompletedSession(session.status), nextReadReason(session.status)),
+		subscriberActive: statusAfterStart.active,
+		subscriberLastExitedAt: statusAfterStart.lastExitedAt,
+		subscriberErrors: subscriberManagerApi.stderr(session.id),
+		warnings,
+		cleanup
+	};
+}
+async function cleanupExitedPaneOnRead(sessionId, status, enabled, dependencies) {
+	if (!(enabled && isCompletedSession(status))) return {
+		requested: false,
+		performed: false,
+		alreadyClosed: false
+	};
+	const session = dependencies.sessionManager.get(sessionId);
+	if (session.tombstone?.paneClosedAt) return {
+		requested: true,
+		performed: false,
+		alreadyClosed: true
+	};
+	const closeResult = await closePaneOrVerifyGone({
+		paneId: session.paneId,
+		closePane: () => dependencies.subscriberManager.closeSessionPane(sessionId, { throwOnFailure: true }),
+		paneExists: dependencies.paneExists
+	});
+	if (closeResult.cleanupReady) {
+		dependencies.sessionManager.markTerminalPaneClosed(sessionId);
+		return {
+			requested: true,
+			performed: true,
+			alreadyClosed: closeResult.alreadyGone
+		};
 	}
-});
+	return {
+		requested: true,
+		performed: false,
+		alreadyClosed: false,
+		warning: `Completed pane cleanup failed: ${closeResult.closeErrorMessage ?? "unknown error"}`
+	};
+}
+function createZellijPtyReadTool(options = {}) {
+	return tool({
+		description: "Read recent rendered output from a Zellij PTY session. Supports regex grep filtering.",
+		args: {
+			id: schema$3.string().describe("zellij-pty session id."),
+			maxLines: schema$3.number().int().positive().max(5e3).optional().describe("Maximum recent output lines to return. Defaults to 200."),
+			grep: schema$3.string().optional().describe("Regex used to filter returned lines."),
+			ignoreCase: schema$3.boolean().optional().describe("Use case-insensitive regex matching."),
+			cleanupExitedPaneOnRead: schema$3.boolean().optional().describe("Close completed panes after returning the final output. Defaults to true.")
+		},
+		async execute(args) {
+			return jsonResponse(await executeZellijPtyRead(args, {
+				...options.dependencies,
+				defaultCleanupExitedPaneOnRead: options.defaultCleanupExitedPaneOnRead
+			}));
+		}
+	});
+}
+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.";
@@ -1661,6 +1913,395 @@ const zellijPtyWriteTool = tool({
 	}
 });
 //#endregion
+//#region src/zellij/tab-title-status-snapshot.ts
+/**
+* Events that should trigger a debounced refresh of the tab title base status
+* via the `/session/status` snapshot API.
+*
+* Base state (running vs idle) is sourced from the snapshot rather than
+* individual `session.idle` events because testing showed that both parent and
+* child sessions report busy during subagent execution, and the parent remains
+* busy even after the child completes.  The snapshot gives a consistent,
+* server-authoritative view.  `needs-input` has no REST API, so it continues
+* to be managed purely through events.
+*
+* The snapshot reconciliation is intentionally *not* optimistic for idle-like
+* transitions: a lone parent/child idle event can be stale during subagent
+* handoff.  The debounce coalesces high-frequency event streams to avoid
+* hammering the API on every individual status change.
+*/
+function shouldRefreshTabTitleStatusSnapshot(event) {
+	switch (event.type) {
+		case "session.status":
+		case "session.idle":
+		case "session.error":
+		case "session.created":
+		case "session.deleted":
+		case "question.asked":
+		case "question.replied":
+		case "question.rejected":
+		case "permission.asked":
+		case "permission.replied":
+		case "permission.updated": return true;
+		default: return false;
+	}
+}
+/**
+* Best-effort fetch of session statuses for a workspace.
+*
+* Only accepts object-keyed maps: `{ [sessionID]: SessionStatus }` directly,
+* or the generated-client envelope `{ data: { [sessionID]: SessionStatus } }`.
+*
+* An empty map `{}` is a valid snapshot (all sessions ended / none tracked).
+* Arrays are never accepted — they always return undefined.
+* If any single status entry fails to parse, the entire snapshot is rejected
+* (no partial apply) to avoid incorrectly clearing session states.
+*
+* Failures are swallowed and return undefined so the caller never throws.
+*/
+async function fetchSessionStatusSnapshot(client, workspaceRoot) {
+	try {
+		if (!client.session?.status) {
+			debug("fetchSessionStatusSnapshot: 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("fetchSessionStatusSnapshot 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("fetchSessionStatusSnapshot received invalid status entry, rejecting entire snapshot");
+				return;
+			}
+			snapshot[sessionID] = parsed;
+		}
+		return snapshot;
+	} catch (err) {
+		debug("fetchSessionStatusSnapshot failed", errorMessage(err));
+		return;
+	}
+}
+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 DEFAULT_DEBOUNCE_MS = 1e3;
+/**
+* Encapsulates tab title session-status snapshot fetching with debounced refresh.
+*
+* This class replaces the nested `refreshTabTitleSnapshot` /
+* `scheduleTabTitleSnapshotRefresh` functions that previously lived inside
+* `createZellijPtyPlugin`.  It manages its own timer so the plugin factory
+* remains a simple composition root.
+*
+* Usage:
+* ```
+* const refresher = tabTitleManager
+*   ? new TabTitleStatusSnapshotRefresher({ client, workspaceRoot, manager: tabTitleManager })
+*   : undefined
+*
+* await refresher?.refreshNow()          // initial snapshot
+* refresher?.scheduleRefresh()           // on relevant events
+* refresher?.dispose()                   // on shutdown
+* ```
+*/
+var TabTitleStatusSnapshotRefresher = class {
+	client;
+	workspaceRoot;
+	manager;
+	debounceMs;
+	timer;
+	constructor(options) {
+		this.client = options.client;
+		this.workspaceRoot = options.workspaceRoot;
+		this.manager = options.manager;
+		this.debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+	}
+	/**
+	* Fetches and applies the snapshot immediately, cancelling any pending
+	* debounced refresh.
+	*/
+	async refreshNow() {
+		this.clearTimer();
+		const snapshot = await fetchSessionStatusSnapshot(this.client, this.workspaceRoot);
+		if (snapshot !== void 0) this.manager.applySessionStatusSnapshot(snapshot);
+	}
+	/**
+	* Schedules a debounced snapshot refresh.  Subsequent calls while a timer
+	* is pending coalesce into a single refresh.
+	*/
+	scheduleRefresh() {
+		if (this.timer) return;
+		this.timer = setTimeout(() => {
+			this.timer = void 0;
+			this.refreshNow().catch((err) => debug("tab title snapshot refresh failed", errorMessage(err)));
+		}, this.debounceMs);
+	}
+	/**
+	* Clears any pending debounced refresh.  Use this during shutdown so a
+	* pending timer does not fire after the manager has been destroyed.
+	*/
+	dispose() {
+		this.clearTimer();
+	}
+	clearTimer() {
+		if (this.timer) {
+			clearTimeout(this.timer);
+			this.timer = void 0;
+		}
+	}
+};
+//#endregion
+//#region src/zellij/completion-notifications.ts
+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 buildQueuedCompletionNotice(events) {
+	return [queuedNoticeHeader, ...events.map((event) => `- ${event.session.id} (${event.session.paneId}) 已完成，請使用 zellij_pty_read 讀取最終輸出並清理 pane。`)].join("\n");
+}
+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,
+		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 (input.config.mode !== "prompt") 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"
+	};
+}
+var SessionCompletionNotificationQueue = class {
+	states = /* @__PURE__ */ new Map();
+	constructor(context, hooks = {}, clock = () => Date.now()) {
+		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();
+	}
+	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,
+			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":
+				state.queued = true;
+				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) {
+			if (!state.toastSent) this.context.markSent(state.event.sessionId);
+			this.finalize(state);
+		}
+		return injectQueuedCompletionNotice(input, notice);
+	}
+	async tryPromptOrQueue(state) {
+		if (!state.event.session.openCodeSessionId) {
+			state.queued = true;
+			return;
+		}
+		const session = this.context.client.session;
+		const prompt = session?.prompt ?? session?.promptAsync;
+		const statusSnapshot = await fetchSessionStatusSnapshot(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;
+			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.context.markSent(state.event.sessionId);
+			this.finalize(state);
+		} catch (error) {
+			debug("completion notification prompt failed", errorMessage(error));
+			state.queued = true;
+		}
+	}
+	async sendToast(state) {
+		const toast = this.context.client.tui?.showToast;
+		if (!toast) {
+			debug("completion notification toast skipped: client.tui.showToast unavailable");
+			return;
+		}
+		try {
+			await toast({ body: {
+				title: completionTitle,
+				message: completionMessage,
+				variant: "success",
+				duration: 1e4
+			} });
+			state.toastSent = true;
+			this.context.markSent(state.event.sessionId);
+			if (!state.queued) this.finalize(state);
+		} catch (error) {
+			debug("completion notification toast failed", errorMessage(error));
+		}
+	}
+	finalize(state) {
+		this.states.delete(state.event.sessionId);
+	}
+};
+//#endregion
 //#region src/zellij/shutdown-cleanup.ts
 let registered = false;
 let cleanedUp = false;
@@ -1764,19 +2405,11 @@ function handleTabTitleEvent(tabTitleManager, event) {
 		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 "session.error": {
-			const sessionID = stringProperty(properties, "sessionID");
-			if (sessionID) tabTitleManager.markSessionIdle(sessionID);
+			if (sessionID && status && status.type !== "idle") tabTitleManager.updateSessionStatus(sessionID, status);
 			break;
 		}
+		case "session.idle": break;
+		case "session.error": break;
 		case "vcs.branch.updated":
 			tabTitleManager.setBranch(stringProperty(properties, "branch"));
 			break;
@@ -1784,22 +2417,32 @@ function handleTabTitleEvent(tabTitleManager, event) {
 		case "permission.asked": {
 			const id = inputRequestID(properties);
 			const sessionID = stringProperty(properties, "sessionID");
-			if (id && sessionID) tabTitleManager.markNeedsInput(id, sessionID);
+			if (id && sessionID) {
+				tabTitleManager.markNeedsInput(id, sessionID);
+				tabTitleManager.updateSessionStatus(sessionID, { type: "busy" });
+			}
 			break;
 		}
 		case "permission.updated": {
 			const id = inputRequestID(properties);
 			const sessionID = stringProperty(properties, "sessionID");
 			const state = inputState(properties);
-			if (id && isResolvedInputState(state)) tabTitleManager.clearNeedsInput(id);
-			else if (id && sessionID) tabTitleManager.markNeedsInput(id, sessionID);
+			if (id && isResolvedInputState(state)) {
+				tabTitleManager.clearNeedsInput(id);
+				if (sessionID) tabTitleManager.updateSessionStatus(sessionID, { type: "busy" });
+			} else if (id && sessionID) {
+				tabTitleManager.markNeedsInput(id, sessionID);
+				tabTitleManager.updateSessionStatus(sessionID, { type: "busy" });
+			}
 			break;
 		}
 		case "question.replied":
 		case "question.rejected":
 		case "permission.replied": {
 			const id = inputRequestID(properties);
+			const sessionID = stringProperty(properties, "sessionID");
 			if (id) tabTitleManager.clearNeedsInput(id);
+			if (sessionID) tabTitleManager.updateSessionStatus(sessionID, { type: "busy" });
 			break;
 		}
 		case "session.deleted": {
@@ -1869,6 +2512,27 @@ var TabTitleManager = class {
 		this.branchName = trimmed;
 		this.scheduleUpdate();
 	}
+	/**
+	* Applies a snapshot of session statuses from the server.
+	*
+	* This replaces the entire base status map. Sessions absent from the snapshot
+	* (e.g. because they ended) are removed so stale busy/idle entries do not
+	* persist. This is the authoritative source for the "running vs idle" base
+	* state; individual session.status events still perform optimistic updates
+	* for immediacy but the snapshot corrects drift.
+	*
+	* The `needs-input` overlay remains independent — it is managed purely by
+	* events (question/permission asked/replied/etc.) and always takes priority
+	* over the snapshot base when computing the displayed title.
+	*/
+	applySessionStatusSnapshot(statuses) {
+		for (const sessionID of this.sessionStatuses.keys()) if (!(sessionID in statuses)) this.sessionStatuses.delete(sessionID);
+		for (const [sessionID, status] of Object.entries(statuses)) {
+			const activity = status.type === "idle" ? "idle" : "running";
+			if (this.sessionStatuses.get(sessionID) !== activity) this.sessionStatuses.set(sessionID, activity);
+		}
+		this.scheduleUpdate();
+	}
 	updateSessionStatus(sessionID, status) {
 		const activity = status.type === "idle" ? "idle" : "running";
 		if (this.sessionStatuses.get(sessionID) === activity) return;
@@ -2029,13 +2693,15 @@ var TabTitleManager = class {
 };
 //#endregion
 //#region src/plugin.ts
-const ptyTools = {
-	zellij_pty_spawn: zellijPtySpawnTool,
-	zellij_pty_list: zellijPtyListTool,
-	zellij_pty_write: zellijPtyWriteTool,
-	zellij_pty_read: zellijPtyReadTool,
-	zellij_pty_kill: zellijPtyKillTool
-};
+function createPtyTools(defaultCleanupExitedPaneOnRead) {
+	return {
+		zellij_pty_spawn: zellijPtySpawnTool,
+		zellij_pty_list: zellijPtyListTool,
+		zellij_pty_write: zellijPtyWriteTool,
+		zellij_pty_read: createZellijPtyReadTool({ defaultCleanupExitedPaneOnRead }),
+		zellij_pty_kill: zellijPtyKillTool
+	};
+}
 function getProjectName(path) {
 	return path.split(/[/\\]/).filter(Boolean).pop() || "opencode";
 }
@@ -2099,22 +2765,67 @@ function createZellijPtyPlugin(dependencies = {}) {
 				branch: config.tabTitle.emojiBranch
 			}
 		}) : void 0;
-		tabTitleManager?.renderImmediate().catch((error) => debug("initial tab title render failed", errorMessage(error)));
 		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));
+				}
+			}
+		});
+		subscriberManager.setLifecycleHooks(completionNotifications ? { onSessionTerminal: (event) => void completionNotifications.handleSessionTerminal(event).catch((error) => debug("completion notification lifecycle hook failed", errorMessage(error))) } : void 0);
+		const tabTitleSnapshotRefresher = tabTitleManager ? new TabTitleStatusSnapshotRefresher({
+			client,
+			workspaceRoot,
+			manager: tabTitleManager,
+			debounceMs: 1e3
+		}) : void 0;
+		tabTitleSnapshotRefresher?.refreshNow().catch((error) => debug("initial tab title snapshot refresh failed", errorMessage(error)));
+		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 (tabTitleManager) await handleTabTitleEvent(tabTitleManager, event);
+				if (tabTitleManager) {
+					if (event.type === "server.instance.disposed" || event.type === "global.disposed") tabTitleSnapshotRefresher?.dispose();
+					await handleTabTitleEvent(tabTitleManager, event);
+					if (shouldRefreshTabTitleStatusSnapshot(event)) tabTitleSnapshotRefresher?.scheduleRefresh();
+				}
+				if (event.type === "server.instance.disposed" || event.type === "global.disposed") {
+					completionNotifications?.clearAll();
+					completionNotifications?.dispose();
+					subscriberManager.setLifecycleHooks(void 0);
+				}
 				if (event.type === "session.deleted") {
 					const sessionID = deletedSessionID(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)));
 				}
 			},
-			tool: config.pty.enabled ? {
-				...ptyTools,
+			"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 ? {
+				...createPtyTools(config.pty.cleanupExitedPaneOnRead),
 				...config.pty.sudoPane === "hide" ? {} : { zellij_pty_request_sudo: requestSudoTool }
 			} : {}
 		};