opencode-zellij 0.0.12 → 0.0.13

package/dist/index.mjs

@@ -1913,62 +1913,18 @@ 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) {
+//#region src/zellij/completion-notifications.ts
+/** Fetches the prompt-mode idle guard status; unrelated to tab title state. */
+async function fetchPromptIdleStatusSnapshot(client, workspaceRoot) {
 	try {
 		if (!client.session?.status) {
-			debug("fetchSessionStatusSnapshot: client.session.status not available");
+			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("fetchSessionStatusSnapshot received non-object payload");
+			debug("fetchPromptIdleStatusSnapshot received non-object payload");
 			return;
 		}
 		const entries = Object.entries(payload);
@@ -1977,14 +1933,14 @@ async function fetchSessionStatusSnapshot(client, workspaceRoot) {
 		for (const [sessionID, status] of entries) {
 			const parsed = parseSessionStatus(status);
 			if (parsed === void 0) {
-				debug("fetchSessionStatusSnapshot received invalid status entry, rejecting entire snapshot");
+				debug("fetchPromptIdleStatusSnapshot received invalid status entry, rejecting entire snapshot");
 				return;
 			}
 			snapshot[sessionID] = parsed;
 		}
 		return snapshot;
 	} catch (err) {
-		debug("fetchSessionStatusSnapshot failed", errorMessage(err));
+		debug("fetchPromptIdleStatusSnapshot failed", errorMessage(err));
 		return;
 	}
 }
@@ -1999,74 +1955,6 @@ function parseSessionStatus(value) {
 		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";
@@ -2236,7 +2124,7 @@ var SessionCompletionNotificationQueue = class {
 		}
 		const session = this.context.client.session;
 		const prompt = session?.prompt ?? session?.promptAsync;
-		const statusSnapshot = await fetchSessionStatusSnapshot(this.context.client, this.context.workspaceRoot);
+		const statusSnapshot = await fetchPromptIdleStatusSnapshot(this.context.client, this.context.workspaceRoot);
 		const decision = evaluateCompletionPromptDecision({
 			event: state.event,
 			config: this.context.config,
@@ -2405,11 +2293,20 @@ function handleTabTitleEvent(tabTitleManager, event) {
 		case "session.status": {
 			const sessionID = stringProperty(properties, "sessionID");
 			const status = sessionStatusProperty(properties);
-			if (sessionID && status && status.type !== "idle") tabTitleManager.updateSessionStatus(sessionID, status);
+			if (sessionID && status) if (status.type === "idle") tabTitleManager.markSessionIdle(sessionID);
+			else 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);
 			break;
 		}
-		case "session.idle": break;
-		case "session.error": break;
 		case "vcs.branch.updated":
 			tabTitleManager.setBranch(stringProperty(properties, "branch"));
 			break;
@@ -2471,7 +2368,7 @@ function sanitizeTitle(title, maxLength = 90) {
 	return cleaned;
 }
 var TabTitleManager = class {
-	sessionStatuses = /* @__PURE__ */ new Map();
+	runningSessions = /* @__PURE__ */ new Set();
 	pendingInputs = /* @__PURE__ */ new Map();
 	branchName;
 	desiredTitle;
@@ -2512,44 +2409,30 @@ 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;
-		this.sessionStatuses.set(sessionID, activity);
-		this.scheduleUpdate();
+		const isRunning = status.type === "busy" || status.type === "retry";
+		const wasRunning = this.runningSessions.has(sessionID);
+		if (isRunning) {
+			if (!wasRunning) {
+				this.runningSessions.add(sessionID);
+				this.scheduleUpdate();
+			}
+		} else if (wasRunning) {
+			this.runningSessions.delete(sessionID);
+			this.scheduleUpdate();
+		}
 	}
 	markSessionIdle(sessionID) {
-		this.updateSessionStatus(sessionID, { type: "idle" });
+		if (this.runningSessions.delete(sessionID)) this.scheduleUpdate();
 	}
 	removeSession(sessionID) {
-		const hadSessionStatus = this.sessionStatuses.delete(sessionID);
+		const hadRunning = this.runningSessions.delete(sessionID);
 		let hadPendingInput = false;
 		for (const [id, pendingSessionID] of this.pendingInputs) if (pendingSessionID === sessionID) {
 			this.pendingInputs.delete(id);
 			hadPendingInput = true;
 		}
-		if (!hadSessionStatus && !hadPendingInput) return;
+		if (!hadRunning && !hadPendingInput) return;
 		this.scheduleUpdate();
 	}
 	markNeedsInput(id, sessionID) {
@@ -2562,8 +2445,7 @@ var TabTitleManager = class {
 		this.scheduleUpdate();
 	}
 	get isBusy() {
-		for (const activity of this.sessionStatuses.values()) if (activity === "running") return true;
-		return false;
+		return this.runningSessions.size > 0;
 	}
 	get needsInput() {
 		return this.pendingInputs.size > 0;
@@ -2790,23 +2672,12 @@ function createZellijPtyPlugin(dependencies = {}) {
 			}
 		});
 		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) {
-					if (event.type === "server.instance.disposed" || event.type === "global.disposed") tabTitleSnapshotRefresher?.dispose();
-					await handleTabTitleEvent(tabTitleManager, event);
-					if (shouldRefreshTabTitleStatusSnapshot(event)) tabTitleSnapshotRefresher?.scheduleRefresh();
-				}
+				if (tabTitleManager) await handleTabTitleEvent(tabTitleManager, event);
 				if (event.type === "server.instance.disposed" || event.type === "global.disposed") {
 					completionNotifications?.clearAll();
 					completionNotifications?.dispose();