opencode-zellij 0.0.12 → 0.0.14

package/dist/index.mjs

@@ -39,7 +39,7 @@ async function installedPackageMetadata(installRoot) {
 	try {
 		const content = await readFile(join(packageDir(installRoot), "package.json"), "utf8");
 		const pkg = JSON.parse(content);
-		if (isRecord$1(pkg)) return {
+		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
@@ -107,7 +107,7 @@ async function findInstallContext(importMetaUrl) {
 			try {
 				const content = await readFile(packageJsonPath, "utf8");
 				const pkg = JSON.parse(content);
-				if (isRecord$1(pkg) && pkg.name === "opencode-zellij" && typeof pkg.version === "string" && pkg.version.length > 0) {
+				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,
@@ -124,7 +124,7 @@ async function findInstallContext(importMetaUrl) {
 		dir = parent;
 	}
 }
-function isRecord$1(value) {
+function isRecord$2(value) {
 	return typeof value === "object" && value !== null;
 }
 function isAutoUpdatableSpec(spec) {
@@ -143,7 +143,7 @@ async function fetchLatestVersion(fetchImpl = globalThis.fetch) {
 			return;
 		}
 		const data = await response.json();
-		if (isRecord$1(data) && typeof data.latest === "string") return data.latest;
+		if (isRecord$2(data) && typeof data.latest === "string") return data.latest;
 		debug("npm registry response missing latest tag");
 		return;
 	} catch (cause) {
@@ -584,7 +584,7 @@ function numericProperty(object, keys) {
 		}
 	}
 }
-function stringProperty$1(object, keys) {
+function stringProperty$2(object, keys) {
 	for (const key of keys) {
 		const value = object[key];
 		if (typeof value === "string") return value;
@@ -643,7 +643,7 @@ function parsePaneExists(listPanesJson, paneId) {
 function tabNameProperty(object, tabId) {
 	if (tabId === void 0) return void 0;
 	if (numericProperty(object, ["tab_id", "tabId"]) !== tabId) return void 0;
-	const name = stringProperty$1(object, ["name", "title"]);
+	const name = stringProperty$2(object, ["name", "title"]);
 	return typeof name === "string" ? name : void 0;
 }
 function findTabName(value, tabId) {
@@ -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,
@@ -2338,41 +2226,21 @@ function exitAfterCleanup(signal, code) {
 //#endregion
 //#region src/zellij/tab-title-events.ts
 const execFileAsync = promisify(execFile);
-function isRecord(value) {
+function isRecord$1(value) {
 	return typeof value === "object" && value !== null;
 }
-function stringProperty(object, key) {
+function stringProperty$1(object, key) {
 	const value = object[key];
 	return typeof value === "string" ? value : void 0;
 }
-function nestedStringProperty(object, key, nestedKey) {
+function nestedStringProperty$1(object, key, nestedKey) {
 	const nested = object[key];
-	if (!isRecord(nested)) return void 0;
-	return stringProperty(nested, nestedKey);
-}
-function sessionStatusProperty(object) {
-	const status = object.status;
-	if (!isRecord(status)) return void 0;
-	if (status.type === "idle" || status.type === "busy") return { type: status.type };
-	if (status.type === "retry") return {
-		type: "retry",
-		attempt: typeof status.attempt === "number" ? status.attempt : 0,
-		message: typeof status.message === "string" ? status.message : "",
-		next: typeof status.next === "number" ? status.next : 0
-	};
-}
-function inputRequestID(object) {
-	return stringProperty(object, "id") ?? stringProperty(object, "requestID") ?? stringProperty(object, "permissionID");
-}
-function inputState(object) {
-	return (stringProperty(object, "status") ?? stringProperty(object, "state") ?? stringProperty(object, "type"))?.toLowerCase();
+	if (!isRecord$1(nested)) return void 0;
+	return stringProperty$1(nested, nestedKey);
 }
-function isResolvedInputState(state) {
-	return state === "approved" || state === "denied" || state === "rejected" || state === "resolved" || state === "replied";
-}
-function deletedSessionID(event) {
-	if (!isRecord(event.properties)) return void 0;
-	return nestedStringProperty(event.properties, "info", "id") ?? stringProperty(event.properties, "sessionID");
+function deletedSessionID$1(event) {
+	if (!isRecord$1(event.properties)) return void 0;
+	return nestedStringProperty$1(event.properties, "info", "id") ?? stringProperty$1(event.properties, "sessionID");
 }
 async function readGitBranch(worktree) {
 	return (await execFileAsync("git", [
@@ -2397,61 +2265,6 @@ async function getInitialBranch(worktree, readBranch = readGitBranch) {
 function shouldReadInitialBranch(zellij) {
 	return Boolean(zellij);
 }
-function handleTabTitleEvent(tabTitleManager, event) {
-	if (event.type === "server.instance.disposed" || event.type === "global.disposed") return tabTitleManager.destroy?.();
-	if (!isRecord(event.properties)) return;
-	const properties = event.properties;
-	switch (event.type) {
-		case "session.status": {
-			const sessionID = stringProperty(properties, "sessionID");
-			const status = sessionStatusProperty(properties);
-			if (sessionID && status && 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;
-		case "question.asked":
-		case "permission.asked": {
-			const id = inputRequestID(properties);
-			const sessionID = stringProperty(properties, "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);
-				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": {
-			const sessionID = deletedSessionID(event);
-			if (sessionID) tabTitleManager.removeSession(sessionID);
-			break;
-		}
-	}
-}
 //#endregion
 //#region src/zellij/tab-title.ts
 const defaultTabTitleEmojis = {
@@ -2470,10 +2283,237 @@ function sanitizeTitle(title, maxLength = 90) {
 	if (chars.length > maxLength) cleaned = `${chars.slice(0, maxLength - 1).join("")}…`;
 	return cleaned;
 }
-var TabTitleManager = class {
-	sessionStatuses = /* @__PURE__ */ new Map();
-	pendingInputs = /* @__PURE__ */ new Map();
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function stringProperty(object, key) {
+	const value = object[key];
+	return typeof value === "string" ? value : void 0;
+}
+function nestedStringProperty(object, key, nestedKey) {
+	const nested = object[key];
+	if (!isRecord(nested)) return void 0;
+	return stringProperty(nested, nestedKey);
+}
+function sessionStatusType(properties) {
+	const status = properties.status;
+	if (!isRecord(status)) return void 0;
+	const type = status.type;
+	if (type === "idle" || type === "busy") return type;
+	if (type === "retry") return "retry";
+}
+function inputRequestID(properties) {
+	return stringProperty(properties, "id") ?? stringProperty(properties, "requestID") ?? stringProperty(properties, "permissionID");
+}
+function inputState(properties) {
+	return (stringProperty(properties, "status") ?? stringProperty(properties, "state") ?? stringProperty(properties, "type"))?.toLowerCase();
+}
+function isResolvedInputState(state) {
+	return state === "approved" || state === "denied" || state === "rejected" || state === "resolved" || state === "replied";
+}
+function deletedSessionID(properties) {
+	return nestedStringProperty(properties, "info", "id") ?? stringProperty(properties, "sessionID");
+}
+var TabTitleIdentityModel = class {
+	ready;
+	projectName;
 	branchName;
+	worktree;
+	readBranch;
+	refreshGeneration = 0;
+	constructor(options) {
+		this.projectName = options.projectName;
+		this.worktree = options.worktree;
+		this.readBranch = options.readBranch;
+		this.ready = this.refreshBranch("initial");
+	}
+	async refreshBranch(_reason) {
+		const generation = ++this.refreshGeneration;
+		try {
+			const result = await this.readBranch(this.worktree);
+			if (generation !== this.refreshGeneration) return;
+			const trimmed = result.trim() || void 0;
+			this.branchName = trimmed;
+		} catch (error) {
+			if (generation !== this.refreshGeneration) return;
+			debug("refreshBranch failed", errorMessage(error));
+		}
+	}
+	handleEvent(event) {
+		if (event.type === "vcs.branch.updated") return this.refreshBranch("vcs.branch.updated");
+	}
+};
+var TabTitleActivityModel = class {
+	status = "idle";
+	worktreeDirectory;
+	sessions = /* @__PURE__ */ new Map();
+	scopedSessions = /* @__PURE__ */ new Set();
+	runningSessions = /* @__PURE__ */ new Set();
+	pendingInputs = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.worktreeDirectory = options.worktreeDirectory;
+	}
+	getSession(sessionID) {
+		return this.scopedSessions.has(sessionID) ? this.sessions.get(sessionID) : void 0;
+	}
+	hasPendingInput(sessionID, requestID) {
+		return this.pendingInputs.has(`${sessionID}:${requestID}`);
+	}
+	handleEvent(event) {
+		if (!isRecord(event.properties)) return;
+		const properties = event.properties;
+		switch (event.type) {
+			case "session.created":
+			case "session.updated": {
+				const info = properties.info;
+				if (isRecord(info)) {
+					const id = stringProperty(info, "id");
+					if (id) this.storeSession(id, info);
+				}
+				break;
+			}
+			case "session.status": {
+				const sessionID = stringProperty(properties, "sessionID");
+				const statusType = sessionStatusType(properties);
+				if (sessionID && statusType) {
+					if (statusType === "idle") {
+						if (this.runningSessions.has(sessionID)) {
+							this.runningSessions.delete(sessionID);
+							this.updateStatus();
+						}
+					} else if (statusType === "busy" || statusType === "retry") {
+						if (this.scopedSessions.has(sessionID)) {
+							this.runningSessions.add(sessionID);
+							this.updateStatus();
+						}
+					}
+				}
+				break;
+			}
+			case "session.idle":
+			case "session.error": {
+				const sessionID = stringProperty(properties, "sessionID");
+				if (sessionID && this.runningSessions.has(sessionID)) {
+					this.runningSessions.delete(sessionID);
+					this.updateStatus();
+				}
+				break;
+			}
+			case "question.asked":
+			case "permission.asked": {
+				const id = inputRequestID(properties);
+				const sessionID = stringProperty(properties, "sessionID");
+				if (id && sessionID && this.scopedSessions.has(sessionID)) {
+					this.pendingInputs.set(`${sessionID}:${id}`, sessionID);
+					this.runningSessions.add(sessionID);
+					this.updateStatus();
+				}
+				break;
+			}
+			case "permission.updated": {
+				const id = inputRequestID(properties);
+				const sessionID = stringProperty(properties, "sessionID");
+				const state = inputState(properties);
+				if (id && isResolvedInputState(state)) {
+					this.pendingInputs.delete(`${sessionID}:${id}`);
+					if (sessionID && this.runningSessions.has(sessionID)) this.runningSessions.add(sessionID);
+					this.updateStatus();
+				} else if (id && sessionID && this.scopedSessions.has(sessionID)) {
+					this.pendingInputs.set(`${sessionID}:${id}`, sessionID);
+					this.runningSessions.add(sessionID);
+					this.updateStatus();
+				}
+				break;
+			}
+			case "question.replied":
+			case "question.rejected":
+			case "permission.replied": {
+				const id = inputRequestID(properties);
+				const sessionID = stringProperty(properties, "sessionID");
+				if (id) this.pendingInputs.delete(`${sessionID}:${id}`);
+				if (sessionID && this.runningSessions.has(sessionID)) this.runningSessions.add(sessionID);
+				this.updateStatus();
+				break;
+			}
+			case "session.deleted": {
+				const sessionID = deletedSessionID(properties);
+				if (sessionID) {
+					this.removeSessionAndDescendants(sessionID);
+					this.updateStatus();
+				}
+				break;
+			}
+		}
+	}
+	storeSession(id, info) {
+		const directory = stringProperty(info, "directory");
+		const parentID = stringProperty(info, "parentID");
+		this.sessions.set(id, {
+			directory,
+			parentID
+		});
+		const isDirectlyScoped = directory === this.worktreeDirectory;
+		const isDescendantScoped = parentID ? this.scopedSessions.has(parentID) : false;
+		if (this.scopedSessions.has(id) || isDirectlyScoped || isDescendantScoped) this.scopedSessions.add(id);
+	}
+	removeSessionAndDescendants(rootID) {
+		const toRemove = /* @__PURE__ */ new Set();
+		toRemove.add(rootID);
+		let changed = true;
+		while (changed) {
+			changed = false;
+			for (const [id, session] of this.sessions) if (!toRemove.has(id) && session.parentID && toRemove.has(session.parentID)) {
+				toRemove.add(id);
+				changed = true;
+			}
+		}
+		for (const id of toRemove) {
+			this.sessions.delete(id);
+			this.scopedSessions.delete(id);
+			this.runningSessions.delete(id);
+		}
+		for (const [key, sessionID] of [...this.pendingInputs.entries()]) if (toRemove.has(sessionID)) this.pendingInputs.delete(key);
+	}
+	updateStatus() {
+		if (this.pendingInputs.size > 0) this.status = "needs-input";
+		else if (this.runningSessions.size > 0) this.status = "running";
+		else this.status = "idle";
+	}
+};
+var TabTitleActor = class {
+	ready;
+	identity;
+	activity;
+	emojis;
+	constructor(options) {
+		this.identity = options.identity;
+		this.activity = options.activity;
+		this.emojis = {
+			...defaultTabTitleEmojis,
+			...options.emojis
+		};
+		this.ready = this.identity.ready;
+	}
+	get context() {
+		return {
+			projectName: this.identity.projectName,
+			branchName: this.identity.branchName,
+			status: this.activity.status
+		};
+	}
+	get title() {
+		return formatTabTitle({
+			...this.context,
+			emojis: this.emojis
+		});
+	}
+	async handleEvent(event) {
+		this.activity.handleEvent(event);
+		const identityResult = this.identity.handleEvent(event);
+		if (identityResult instanceof Promise) await identityResult;
+	}
+};
+var TabTitleManager = class {
 	desiredTitle;
 	lastSyncedTitle;
 	debounceTimer;
@@ -2484,7 +2524,6 @@ var TabTitleManager = class {
 	debounceMs;
 	retryInitialMs;
 	retryMaxMs;
-	projectName;
 	cli;
 	emojis;
 	enabled;
@@ -2493,9 +2532,8 @@ var TabTitleManager = class {
 	originalTabTitleLoaded = false;
 	originalTabTitlePromise;
 	destroyPromise;
+	actor;
 	constructor(options) {
-		this.projectName = options.projectName;
-		this.branchName = options.branchName?.trim() || void 0;
 		this.cli = options.cli ?? new ZellijCli();
 		this.emojis = {
 			...defaultTabTitleEmojis,
@@ -2504,80 +2542,12 @@ var TabTitleManager = class {
 		this.debounceMs = options.debounceMs ?? 300;
 		this.retryInitialMs = options.retryInitialMs ?? 250;
 		this.retryMaxMs = options.retryMaxMs ?? 5e3;
-		this.enabled = Boolean(process.env.ZELLIJ);
-	}
-	setBranch(branch) {
-		const trimmed = branch?.trim() || void 0;
-		if (this.branchName === trimmed) return;
-		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();
-	}
-	markSessionIdle(sessionID) {
-		this.updateSessionStatus(sessionID, { type: "idle" });
-	}
-	removeSession(sessionID) {
-		const hadSessionStatus = this.sessionStatuses.delete(sessionID);
-		let hadPendingInput = false;
-		for (const [id, pendingSessionID] of this.pendingInputs) if (pendingSessionID === sessionID) {
-			this.pendingInputs.delete(id);
-			hadPendingInput = true;
-		}
-		if (!hadSessionStatus && !hadPendingInput) return;
-		this.scheduleUpdate();
-	}
-	markNeedsInput(id, sessionID) {
-		if (this.pendingInputs.get(id) === sessionID) return;
-		this.pendingInputs.set(id, sessionID);
-		this.scheduleUpdate();
-	}
-	clearNeedsInput(id) {
-		if (!this.pendingInputs.delete(id)) return;
-		this.scheduleUpdate();
-	}
-	get isBusy() {
-		for (const activity of this.sessionStatuses.values()) if (activity === "running") return true;
-		return false;
-	}
-	get needsInput() {
-		return this.pendingInputs.size > 0;
-	}
-	get status() {
-		if (this.needsInput) return "needs-input";
-		if (this.isBusy) return "running";
-		return "idle";
+		this.enabled = Boolean(process.env.ZELLIJ || process.env.ZELLIJ_SESSION_NAME);
+		this.actor = options.actor;
 	}
 	buildTitle() {
 		return sanitizeTitle(formatTabTitle({
-			projectName: this.projectName,
-			branchName: this.branchName,
-			status: this.status,
+			...this.actor.context,
 			emojis: this.emojis
 		}));
 	}
@@ -2753,10 +2723,18 @@ function createZellijPtyPlugin(dependencies = {}) {
 		registerShutdownCleanup();
 		const workspaceRoot = getWorkspaceRoot(input);
 		const projectName = getProjectName(workspaceRoot);
-		const branchName = config.tabTitle.enabled && shouldReadInitialBranch(process.env.ZELLIJ) ? await getInitialBranch(workspaceRoot) : void 0;
-		const tabTitleManager = config.tabTitle.enabled ? new TabTitleManager({
+		const identityModel = config.tabTitle.enabled ? new TabTitleIdentityModel({
 			projectName,
-			branchName,
+			worktree: workspaceRoot,
+			readBranch: async (worktree) => shouldReadInitialBranch(process.env.ZELLIJ || process.env.ZELLIJ_SESSION_NAME) ? await getInitialBranch(worktree) ?? "" : ""
+		}) : void 0;
+		const activityModel = config.tabTitle.enabled ? new TabTitleActivityModel({ worktreeDirectory: workspaceRoot }) : void 0;
+		const actor = identityModel && activityModel ? new TabTitleActor({
+			identity: identityModel,
+			activity: activityModel
+		}) : void 0;
+		const tabTitleManager = config.tabTitle.enabled && actor ? new TabTitleManager({
+			actor,
 			debounceMs: config.tabTitle.debounceMs,
 			emojis: {
 				idle: config.tabTitle.emojiIdle,
@@ -2790,22 +2768,16 @@ 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)));
+		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 (tabTitleManager) {
-					if (event.type === "server.instance.disposed" || event.type === "global.disposed") tabTitleSnapshotRefresher?.dispose();
-					await handleTabTitleEvent(tabTitleManager, event);
-					if (shouldRefreshTabTitleStatusSnapshot(event)) tabTitleSnapshotRefresher?.scheduleRefresh();
+				if (actor && tabTitleManager) {
+					await actor.handleEvent(event);
+					if (event.type === "server.instance.disposed" || event.type === "global.disposed") await tabTitleManager.destroy();
+					else tabTitleManager.scheduleUpdate();
 				}
 				if (event.type === "server.instance.disposed" || event.type === "global.disposed") {
 					completionNotifications?.clearAll();
@@ -2813,7 +2785,7 @@ function createZellijPtyPlugin(dependencies = {}) {
 					subscriberManager.setLifecycleHooks(void 0);
 				}
 				if (event.type === "session.deleted") {
-					const sessionID = deletedSessionID(event);
+					const sessionID = deletedSessionID$1(event);
 					if (!sessionID) return;
 					const sessions = sessionManager.listByOpenCodeSession(sessionID);
 					for (const session of sessions) completionNotifications?.clearSession(session.id);