pi-zellij 0.4.0 → 0.4.6

package/CHANGELOG.md

@@ -13,6 +13,15 @@
 - Added `/zz` and `/zzh` to open a new pane from a zoxide match or direct directory path and start Pi there.
 - Added `zv-review` with `/zrv` and `/zrh`, plus bundled `code-review` skill and `/review` / `/review-diff` prompt templates for focused review workflows, including GitHub pull request review via `gh` when given a PR URL.
 - Added `zv-continue` with `/zcv` and `/zch` for split-based task handoff in the current checkout or by creating a git worktree branch with `-c <branch>`.
+- Added opt-in `paneHighlight` settings so Pi can tint the current zellij pane when an agent turn completes, with optional working-state colors.
+
+### Changed
+
+- When zellij reports created pane or tab IDs, `pi-zellij` now shows them in success notifications for split, floating, zoxide, review, continuation, and tab commands.
+- `/zt` now uses `zellij action new-tab -- <command>` when available instead of always simulating typed input, while keeping the previous typed-input path as a compatibility fallback.
+- Pane highlights now clear on the next submitted input or when the pane is focused again after being elsewhere, instead of waiting for the next agent start event. Aborted runs no longer apply the done-state tint.
+- Pane focus polling no longer writes transient zellij query timeout warnings into the Pi editor; refocus-based clearing is skipped if focus state cannot be queried reliably.
+- Done-state pane tint is now only applied while the Pi pane is unfocused, so the editor is reset immediately instead of staying green while typing in the active pane.
 
 ### Removed
 

package/README.md

@@ -1,12 +1,16 @@
 # pi-zellij
 
-Pi package with zellij-powered terminal integrations for [Pi](https://pi.dev).
+Pi package with [zellij](https://zellij.dev)-powered terminal integrations for [Pi](https://pi.dev). Make your workflow agent driven.
+
+## Workflow
+
+![pi-zellij workflow](assets/workflow.gif)
 
 ## Why
 
 [Pi](https://pi.dev) works well in the terminal, but pane orchestration is better handled by a terminal multiplexer. `pi-zellij` adds zellij-native split workflows for Pi.
 
-It includes split and tab commands, generic tool launchers, settings-driven floating app shortcuts, zoxide jumps, review workflows, and split-based task handoff.
+It includes split and tab commands, generic tool launchers, settings-driven floating app shortcuts, opt-in pane highlighting for completed agent turns, zoxide jumps, review workflows, and split-based task handoff.
 
 ## Usage
 
@@ -34,6 +38,13 @@ If pi is already running, use:
 - pane, tab, and floating commands must be run from inside an active zellij session
 - `zoxide` is required for the zoxide commands
 
+### Recommended zellij version
+
+| zellij version | status | notes |
+| --- | --- | --- |
+| `0.44.0+` | recommended | `pi-zellij` can show created pane/tab IDs in success notifications, and `/zt` can launch its initial command directly via `zellij action new-tab -- <command>` |
+| older versions | supported with fallback | commands still work, but zellij may not expose created IDs and `/zt` may fall back to the older typed-input startup path |
+
 ## Feature overview
 
 ### Pane and tab workflows
@@ -49,6 +60,8 @@ If pi is already running, use:
 
 - `pi-zellij.commands` in `settings.json`
   - registers floating app shortcuts such as `/zh` for `hx` or `/zg` for `lazygit`
+- `pi-zellij.paneHighlight` in `settings.json`
+  - optionally tints the current zellij pane when Pi finishes a turn and is waiting for input
 
 ### Review and handoff workflows
 
@@ -66,6 +79,7 @@ If pi is already running, use:
 Extensions:
 - `zv-split`
 - `zv-open`
+- `zv-highlight`
 - `zv-zoxide`
 - `zv-review`
 - `zv-continue`
@@ -184,6 +198,53 @@ Configured command names cannot reuse built-in Pi commands such as `/settings`,
 
 If the same command exists in both global and project settings, the project setting wins. After changing settings, run `/reload` in Pi.
 
+### Pane highlight on completion
+
+You can optionally tint the current zellij pane when Pi finishes a turn and is waiting for input.
+
+Supported locations:
+- `~/.pi/agent/settings.json` for global settings
+- `.pi/settings.json` for project-local settings
+
+During the rename from `pi-zv` to `pi-zellij`, legacy `pi-zv.paneHighlight` is still accepted for compatibility. If both keys exist, `pi-zellij.paneHighlight` wins.
+
+Minimal form:
+
+```json
+{
+  "pi-zellij": {
+    "paneHighlight": true
+  }
+}
+```
+
+That enables a default done-state background tint. The feature is zellij-only and does nothing outside an active zellij session.
+
+Object form:
+
+```json
+{
+  "pi-zellij": {
+    "paneHighlight": {
+      "enabled": true,
+      "doneBg": "#17352a",
+      "doneFg": "#e7fff0",
+      "workingBg": "#2f2415"
+    }
+  }
+}
+```
+
+Supported keys:
+- `enabled`
+  - set to `false` to disable the feature
+- `doneBg`, `doneFg`
+  - pane colors to apply after `agent_end` when the pane is not currently focused
+- `workingBg`, `workingFg`
+  - optional pane colors to apply while Pi is working; if omitted, `pi-zellij` resets the pane to its default colors when the next input is submitted or when the pane is focused again after being elsewhere
+
+When enabled, `pi-zellij` resets the pane color on session start, session switch, the next submitted input, pane refocus when zellij focus state is available, and session shutdown so completed-turn highlights do not linger across sessions. If the pane is already focused when a turn completes, the done-state tint is skipped so the Pi editor does not stay tinted while you type. Aborted runs do not apply the done-state tint. After changing these settings, run `/reload` in Pi.
+
 ### Zoxide jump commands
 
 - `/zz <query>`

package/extensions/git-core.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { basename, dirname, join } from "node:path";
 import { existsSync, mkdirSync } from "node:fs";
 

package/extensions/index.ts

@@ -1,9 +1,10 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import zvSplitExtension from "./zv-split.ts";
 import zvZoxideExtension from "./zv-zoxide.ts";
 import zvReviewExtension from "./zv-review.ts";
 import zvContinueExtension from "./zv-continue.ts";
 import zvOpenExtension from "./zv-open.ts";
+import zvHighlightExtension from "./zv-highlight.ts";
 
 export default function piZellijExtensionBundle(pi: ExtensionAPI) {
 	zvSplitExtension(pi);
@@ -11,4 +12,5 @@ export default function piZellijExtensionBundle(pi: ExtensionAPI) {
 	zvReviewExtension(pi);
 	zvContinueExtension(pi);
 	zvOpenExtension(pi);
+	zvHighlightExtension(pi);
 }

package/extensions/zv-continue.ts

@@ -1,10 +1,12 @@
 import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { SessionManager, type ExtensionAPI, type ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import { SessionManager, type ExtensionAPI, type ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import {
 	buildPiCommand,
+	formatPaneSuccessMessage,
 	openCommandInNewSplit,
+	type PaneOpenResult,
 	type SplitDirection,
 } from "./zv-core.ts";
 import {
@@ -388,7 +390,7 @@ async function openContinueSplit(
 	ctx: ExtensionCommandContext,
 	direction: SplitDirection,
 	request: ContinueRequest,
-): Promise<{ ok: true } | { ok: false; error: string }> {
+): Promise<PaneOpenResult> {
 	const handoffTarget = await resolveHandoffTarget(pi, ctx, request);
 	if (!handoffTarget.ok) {
 		return handoffTarget;
@@ -422,7 +424,7 @@ function registerContinueCommand(
 
 			const result = await openContinueSplit(pi, ctx, direction, parsed.request);
 			if (result.ok) {
-				ctx.ui.notify(successMessage, "info");
+				ctx.ui.notify(formatPaneSuccessMessage(successMessage, result.paneId), "info");
 			} else {
 				ctx.ui.notify(`continuation split failed: ${result.error}`, "error");
 			}

package/extensions/zv-core.ts

@@ -1,8 +1,10 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 const ZELLIJ_TIMEOUT_MS = 5000;
 
 export type SplitDirection = "right" | "down";
+export type PaneOpenResult = { ok: true; paneId?: string } | { ok: false; error: string };
+export type TabOpenResult = { ok: true; tabId?: string } | { ok: false; error: string };
 
 interface ZellijExecResult {
 	ok: boolean;
@@ -11,10 +13,49 @@ interface ZellijExecResult {
 	error?: string;
 }
 
-function isInsideZellijSession(): boolean {
+export function isInsideZellijSession(): boolean {
 	return Boolean(process.env.ZELLIJ || process.env.ZELLIJ_SESSION_NAME || process.env.ZELLIJ_PANE_ID);
 }
 
+function getLastNonEmptyLine(value: string): string | undefined {
+	const lines = value
+		.split(/\r?\n/)
+		.map((line) => line.trim())
+		.filter((line) => line.length > 0);
+	return lines.length > 0 ? lines[lines.length - 1] : undefined;
+}
+
+function normalizePaneId(value: string): string | undefined {
+	const trimmed = value.trim();
+	if (!trimmed) {
+		return undefined;
+	}
+	if (/^(?:terminal|plugin)_\d+$/.test(trimmed)) {
+		return trimmed;
+	}
+	if (/^\d+$/.test(trimmed)) {
+		return `terminal_${trimmed}`;
+	}
+	return undefined;
+}
+
+function getCreatedPaneId(stdout: string): string | undefined {
+	return normalizePaneId(getLastNonEmptyLine(stdout) ?? "");
+}
+
+function getCreatedTabId(stdout: string): string | undefined {
+	const candidate = getLastNonEmptyLine(stdout);
+	return candidate && /^\d+$/.test(candidate) ? candidate : undefined;
+}
+
+export function formatPaneSuccessMessage(message: string, paneId?: string): string {
+	return paneId ? `${message} (${paneId})` : message;
+}
+
+export function formatTabSuccessMessage(message: string, tabId?: string): string {
+	return tabId ? `${message} (tab ${tabId})` : message;
+}
+
 export function shellEscape(value: string): string {
 	return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -60,11 +101,88 @@ async function execZellij(pi: ExtensionAPI, args: string[]): Promise<ZellijExecR
 	};
 }
 
+function getCurrentPaneTargetArgs(): string[] {
+	return process.env.ZELLIJ_PANE_ID ? ["-p", process.env.ZELLIJ_PANE_ID] : [];
+}
+
+export async function resetCurrentPaneColor(pi: ExtensionAPI): Promise<{ ok: true } | { ok: false; error: string }> {
+	if (!isInsideZellijSession()) {
+		return { ok: false, error: "This command must be run from inside an active zellij session" };
+	}
+
+	const result = await execZellij(pi, ["action", "set-pane-color", ...getCurrentPaneTargetArgs(), "--reset"]);
+	if (!result.ok) {
+		return { ok: false, error: result.error || "Failed to reset zellij pane color" };
+	}
+
+	return { ok: true };
+}
+
+export async function setCurrentPaneColor(
+	pi: ExtensionAPI,
+	options: { bg?: string; fg?: string },
+): Promise<{ ok: true } | { ok: false; error: string }> {
+	if (!isInsideZellijSession()) {
+		return { ok: false, error: "This command must be run from inside an active zellij session" };
+	}
+
+	const paneTargetArgs = getCurrentPaneTargetArgs();
+	const args = ["action", "set-pane-color", ...paneTargetArgs];
+	if (options.bg) {
+		args.push("--bg", options.bg);
+	}
+	if (options.fg) {
+		args.push("--fg", options.fg);
+	}
+	if (args.length === 2 + paneTargetArgs.length) {
+		return resetCurrentPaneColor(pi);
+	}
+
+	const result = await execZellij(pi, args);
+	if (!result.ok) {
+		return { ok: false, error: result.error || "Failed to set zellij pane color" };
+	}
+
+	return { ok: true };
+}
+
+function buildNewTabArgs(cwd: string, options?: { name?: string }): string[] {
+	const args = ["action", "new-tab", "--cwd", cwd];
+	if (options?.name) {
+		args.push("--name", options.name);
+	}
+	return args;
+}
+
+async function openCommandInNewTabLegacy(
+	pi: ExtensionAPI,
+	cwd: string,
+	command: string,
+	options?: { name?: string },
+): Promise<TabOpenResult> {
+	const newTabResult = await execZellij(pi, buildNewTabArgs(cwd, options));
+	if (!newTabResult.ok) {
+		return { ok: false, error: newTabResult.error || "Failed to open a new zellij tab" };
+	}
+
+	const writeCommandResult = await execZellij(pi, ["action", "write-chars", command]);
+	if (!writeCommandResult.ok) {
+		return { ok: false, error: writeCommandResult.error || "Failed to write command to new zellij tab" };
+	}
+
+	const submitCommandResult = await execZellij(pi, ["action", "write", "10"]);
+	if (!submitCommandResult.ok) {
+		return { ok: false, error: submitCommandResult.error || "Failed to start command in new zellij tab" };
+	}
+
+	return { ok: true, tabId: getCreatedTabId(newTabResult.stdout) };
+}
+
 export async function openCommandInNewSplit(
 	pi: ExtensionAPI,
 	direction: SplitDirection,
 	command: string,
-): Promise<{ ok: true } | { ok: false; error: string }> {
+): Promise<PaneOpenResult> {
 	if (!isInsideZellijSession()) {
 		return { ok: false, error: "This command must be run from inside an active zellij session" };
 	}
@@ -74,14 +192,14 @@ export async function openCommandInNewSplit(
 		return { ok: false, error: result.error || "Failed to open a new zellij pane" };
 	}
 
-	return { ok: true };
+	return { ok: true, paneId: getCreatedPaneId(result.stdout) };
 }
 
 export async function openCommandInFloatingPane(
 	pi: ExtensionAPI,
 	command: string,
 	options?: { name?: string; width?: string; height?: string; x?: string; y?: string },
-): Promise<{ ok: true } | { ok: false; error: string }> {
+): Promise<PaneOpenResult> {
 	if (!isInsideZellijSession()) {
 		return { ok: false, error: "This command must be run from inside an active zellij session" };
 	}
@@ -99,7 +217,7 @@ export async function openCommandInFloatingPane(
 		return { ok: false, error: result.error || "Failed to open a new floating zellij pane" };
 	}
 
-	return { ok: true };
+	return { ok: true, paneId: getCreatedPaneId(result.stdout) };
 }
 
 export async function openCommandInNewTab(
@@ -107,30 +225,15 @@ export async function openCommandInNewTab(
 	cwd: string,
 	command: string,
 	options?: { name?: string },
-): Promise<{ ok: true } | { ok: false; error: string }> {
+): Promise<TabOpenResult> {
 	if (!isInsideZellijSession()) {
 		return { ok: false, error: "This command must be run from inside an active zellij session" };
 	}
 
-	const newTabArgs = ["action", "new-tab", "--cwd", cwd];
-	if (options?.name) {
-		newTabArgs.push("--name", options.name);
-	}
-
-	const newTabResult = await execZellij(pi, newTabArgs);
-	if (!newTabResult.ok) {
-		return { ok: false, error: newTabResult.error || "Failed to open a new zellij tab" };
-	}
-
-	const writeCommandResult = await execZellij(pi, ["action", "write-chars", command]);
-	if (!writeCommandResult.ok) {
-		return { ok: false, error: writeCommandResult.error || "Failed to write command to new zellij tab" };
+	const newTabResult = await execZellij(pi, [...buildNewTabArgs(cwd, options), "--", "sh", "-lc", command]);
+	if (newTabResult.ok) {
+		return { ok: true, tabId: getCreatedTabId(newTabResult.stdout) };
 	}
 
-	const submitCommandResult = await execZellij(pi, ["action", "write", "10"]);
-	if (!submitCommandResult.ok) {
-		return { ok: false, error: submitCommandResult.error || "Failed to start command in new zellij tab" };
-	}
-
-	return { ok: true };
+	return openCommandInNewTabLegacy(pi, cwd, command, options);
 }

package/extensions/zv-highlight.ts

@@ -0,0 +1,523 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { isInsideZellijSession, resetCurrentPaneColor, setCurrentPaneColor } from "./zv-core.ts";
+
+const DEFAULT_DONE_BG = "#17352a";
+const GLOBAL_SETTINGS_PATH = join(homedir(), ".pi", "agent", "settings.json");
+const SETTINGS_SECTION_NAMES = ["pi-zellij", "pi-zv"] as const;
+const FOCUS_POLL_INTERVAL_MS = 1000;
+const FOCUS_QUERY_TIMEOUT_MS = 2000;
+const MAX_FOCUS_QUERY_FAILURES = 3;
+
+interface PaneHighlightConfigInput {
+	enabled?: boolean;
+	doneBg?: string;
+	doneFg?: string;
+	workingBg?: string;
+	workingFg?: string;
+}
+
+interface PaneHighlightConfig {
+	enabled: boolean;
+	doneBg: string;
+	doneFg?: string;
+	workingBg?: string;
+	workingFg?: string;
+}
+
+interface MessageLike {
+	role?: unknown;
+	stopReason?: unknown;
+	content?: unknown;
+}
+
+type JsonRecord = Record<string, unknown>;
+
+function readJsonFile(path: string): Record<string, unknown> | undefined {
+	if (!existsSync(path)) {
+		return undefined;
+	}
+
+	try {
+		const parsed = JSON.parse(readFileSync(path, "utf8")) as unknown;
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+			console.warn(`[pi-zellij] Ignoring non-object settings file: ${path}`);
+			return undefined;
+		}
+		return parsed as Record<string, unknown>;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		console.warn(`[pi-zellij] Failed to read settings from ${path}: ${message}`);
+		return undefined;
+	}
+}
+
+function readPaneHighlightSetting(settingsPath: string): unknown {
+	const settings = readJsonFile(settingsPath);
+	for (const sectionName of SETTINGS_SECTION_NAMES) {
+		const section = settings?.[sectionName];
+		if (!section) {
+			continue;
+		}
+		if (typeof section !== "object" || Array.isArray(section)) {
+			console.warn(`[pi-zellij] Ignoring invalid \"${sectionName}\" settings in ${settingsPath}`);
+			continue;
+		}
+		const paneHighlight = (section as { paneHighlight?: unknown }).paneHighlight;
+		if (paneHighlight === undefined) {
+			continue;
+		}
+		return paneHighlight;
+	}
+	return undefined;
+}
+
+function normalizeOptionalString(value: unknown): string | undefined {
+	if (typeof value !== "string") {
+		return undefined;
+	}
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function normalizePaneHighlightConfig(value: unknown, settingsPath: string): Partial<PaneHighlightConfig> | undefined {
+	if (value === undefined) {
+		return undefined;
+	}
+	if (typeof value === "boolean") {
+		return { enabled: value };
+	}
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		console.warn(`[pi-zellij] Ignoring invalid paneHighlight settings in ${settingsPath}`);
+		return undefined;
+	}
+
+	const config = value as PaneHighlightConfigInput;
+	return {
+		enabled: config.enabled !== false,
+		doneBg: normalizeOptionalString(config.doneBg),
+		doneFg: normalizeOptionalString(config.doneFg),
+		workingBg: normalizeOptionalString(config.workingBg),
+		workingFg: normalizeOptionalString(config.workingFg),
+	};
+}
+
+function loadPaneHighlightConfig(cwd: string): PaneHighlightConfig {
+	let merged: Partial<PaneHighlightConfig> = { enabled: false };
+
+	for (const settingsPath of [GLOBAL_SETTINGS_PATH, join(cwd, ".pi", "settings.json")]) {
+		const normalized = normalizePaneHighlightConfig(readPaneHighlightSetting(settingsPath), settingsPath);
+		if (!normalized) {
+			continue;
+		}
+		merged = { ...merged, ...normalized };
+	}
+
+	return {
+		enabled: merged.enabled === true,
+		doneBg: merged.doneBg ?? DEFAULT_DONE_BG,
+		doneFg: merged.doneFg,
+		workingBg: merged.workingBg,
+		workingFg: merged.workingFg,
+	};
+}
+
+function hasWorkingColors(config: PaneHighlightConfig): boolean {
+	return Boolean(config.workingBg || config.workingFg);
+}
+
+function isRecord(value: unknown): value is JsonRecord {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function normalizePaneId(value: unknown): string | undefined {
+	if (typeof value === "number" && Number.isInteger(value) && value >= 0) {
+		return `terminal_${value}`;
+	}
+	if (typeof value !== "string") {
+		return undefined;
+	}
+
+	const trimmed = value.trim();
+	if (!trimmed) {
+		return undefined;
+	}
+	if (/^(?:terminal|plugin)_\d+$/.test(trimmed)) {
+		return trimmed;
+	}
+	if (/^\d+$/.test(trimmed)) {
+		return `terminal_${trimmed}`;
+	}
+	return undefined;
+}
+
+function readBoolean(value: unknown): boolean | undefined {
+	if (typeof value === "boolean") {
+		return value;
+	}
+	if (typeof value === "string") {
+		if (value === "true") return true;
+		if (value === "false") return false;
+	}
+	return undefined;
+}
+
+function normalizeTabId(value: unknown): number | undefined {
+	if (typeof value === "number" && Number.isInteger(value) && value >= 0) {
+		return value;
+	}
+	if (typeof value === "string" && /^\d+$/.test(value.trim())) {
+		return Number(value.trim());
+	}
+	return undefined;
+}
+
+function getPaneEntries(parsed: unknown): JsonRecord[] {
+	if (Array.isArray(parsed)) {
+		return parsed.filter(isRecord);
+	}
+	if (!isRecord(parsed)) {
+		return [];
+	}
+
+	for (const key of ["panes", "items", "data", "results"]) {
+		const candidate = parsed[key];
+		if (Array.isArray(candidate)) {
+			return candidate.filter(isRecord);
+		}
+	}
+
+	return [parsed];
+}
+
+function getPaneIdFromEntry(entry: JsonRecord): string | undefined {
+	for (const key of ["pane_id", "paneId", "id", "terminal_id", "terminalId"]) {
+		const normalized = normalizePaneId(entry[key]);
+		if (normalized) {
+			return normalized;
+		}
+	}
+
+	const nestedPane = entry.pane;
+	if (isRecord(nestedPane)) {
+		return getPaneIdFromEntry(nestedPane);
+	}
+
+	return undefined;
+}
+
+function getTabIdFromEntry(entry: JsonRecord): number | undefined {
+	for (const key of ["tab_id", "tabId"]) {
+		const normalized = normalizeTabId(entry[key]);
+		if (normalized !== undefined) {
+			return normalized;
+		}
+	}
+
+	const nestedTab = entry.tab;
+	if (isRecord(nestedTab)) {
+		return getTabIdFromEntry(nestedTab);
+	}
+
+	const nestedPane = entry.pane;
+	if (isRecord(nestedPane)) {
+		return getTabIdFromEntry(nestedPane);
+	}
+
+	return undefined;
+}
+
+function getFocusedStateFromEntry(entry: JsonRecord): boolean | undefined {
+	for (const key of ["is_focused", "focused", "isFocused", "active", "is_active", "isActive"]) {
+		const normalized = readBoolean(entry[key]);
+		if (normalized !== undefined) {
+			return normalized;
+		}
+	}
+
+	const nestedState = entry.state;
+	if (isRecord(nestedState)) {
+		return getFocusedStateFromEntry(nestedState);
+	}
+
+	const nestedPane = entry.pane;
+	if (isRecord(nestedPane)) {
+		return getFocusedStateFromEntry(nestedPane);
+	}
+
+	return undefined;
+}
+
+function hasVisibleAssistantContent(message: MessageLike): boolean {
+	if (typeof message.content === "string") {
+		return message.content.trim().length > 0;
+	}
+	if (!Array.isArray(message.content)) {
+		return false;
+	}
+	return message.content.length > 0;
+}
+
+function shouldHighlightAfterAgentEnd(messages: readonly unknown[]): boolean {
+	const assistantMessages = messages.filter((message): message is MessageLike => {
+		return isRecord(message) && message.role === "assistant";
+	});
+	if (assistantMessages.length === 0) {
+		return false;
+	}
+
+	const lastAssistantMessage = assistantMessages[assistantMessages.length - 1]!;
+	if (lastAssistantMessage.stopReason === "aborted") {
+		return false;
+	}
+	return hasVisibleAssistantContent(lastAssistantMessage);
+}
+
+export default function zvHighlightExtension(pi: ExtensionAPI) {
+	let config = loadPaneHighlightConfig(process.cwd());
+	let lastActionError: string | undefined;
+	let focusPollTimer: ReturnType<typeof setInterval> | undefined;
+	let focusPollInFlight = false;
+	let shouldClearOnRefocus = false;
+	let sawPaneBlurSinceDone = false;
+	let consecutiveFocusQueryFailures = 0;
+
+	function warnActionError(message: string): void {
+		if (lastActionError === message) {
+			return;
+		}
+		lastActionError = message;
+		console.warn(`[pi-zellij] ${message}`);
+	}
+
+	function clearActionError(): void {
+		lastActionError = undefined;
+	}
+
+	function stopFocusPolling(): void {
+		if (focusPollTimer) {
+			clearInterval(focusPollTimer);
+			focusPollTimer = undefined;
+		}
+		focusPollInFlight = false;
+		shouldClearOnRefocus = false;
+		sawPaneBlurSinceDone = false;
+		consecutiveFocusQueryFailures = 0;
+	}
+
+	async function getActiveTabId(): Promise<number | undefined> {
+		const result = await pi.exec("zellij", ["action", "current-tab-info"], {
+			timeout: FOCUS_QUERY_TIMEOUT_MS,
+		});
+		if (result.killed || result.code !== 0) {
+			return undefined;
+		}
+
+		const match = /^\s*id:\s*(\d+)\s*$/m.exec(result.stdout);
+		return match ? Number(match[1]) : undefined;
+	}
+
+	async function getCurrentPaneFocusedState(): Promise<boolean | undefined> {
+		if (!isInsideZellijSession()) {
+			return undefined;
+		}
+
+		const currentPaneId = normalizePaneId(process.env.ZELLIJ_PANE_ID);
+		if (!currentPaneId) {
+			return undefined;
+		}
+
+		const result = await pi.exec("zellij", ["action", "list-panes", "--json", "--state"], {
+			timeout: FOCUS_QUERY_TIMEOUT_MS,
+		});
+		if (result.killed || result.code !== 0) {
+			return undefined;
+		}
+
+		try {
+			const parsed = JSON.parse(result.stdout) as unknown;
+			for (const entry of getPaneEntries(parsed)) {
+				if (getPaneIdFromEntry(entry) !== currentPaneId) {
+					continue;
+				}
+				const focused = getFocusedStateFromEntry(entry);
+				if (focused === undefined) {
+					return undefined;
+				}
+				if (!focused) {
+					clearActionError();
+					return false;
+				}
+
+				const paneTabId = getTabIdFromEntry(entry);
+				const activeTabId = await getActiveTabId();
+				clearActionError();
+				if (paneTabId === undefined || activeTabId === undefined) {
+					return true;
+				}
+				return paneTabId === activeTabId;
+			}
+			return undefined;
+		} catch {
+			return undefined;
+		}
+	}
+
+	async function refreshConfig(cwd: string): Promise<void> {
+		const wasEnabled = config.enabled;
+		config = loadPaneHighlightConfig(cwd);
+		if ((!wasEnabled && !config.enabled) || !isInsideZellijSession()) {
+			stopFocusPolling();
+			return;
+		}
+
+		stopFocusPolling();
+		const result = await resetCurrentPaneColor(pi);
+		if (!result.ok) {
+			warnActionError(`pane highlight reset failed: ${result.error}`);
+			return;
+		}
+		clearActionError();
+	}
+
+	async function resetPaneIfEnabled(): Promise<void> {
+		stopFocusPolling();
+		if (!config.enabled || !isInsideZellijSession()) {
+			return;
+		}
+
+		const result = await resetCurrentPaneColor(pi);
+		if (!result.ok) {
+			warnActionError(`pane highlight reset failed: ${result.error}`);
+			return;
+		}
+		clearActionError();
+	}
+
+	async function applyWorkingState(): Promise<void> {
+		stopFocusPolling();
+		if (!config.enabled || !isInsideZellijSession()) {
+			return;
+		}
+		if (!hasWorkingColors(config)) {
+			await resetPaneIfEnabled();
+			return;
+		}
+
+		const result = await setCurrentPaneColor(pi, {
+			bg: config.workingBg,
+			fg: config.workingFg,
+		});
+		if (!result.ok) {
+			warnActionError(`pane highlight update failed: ${result.error}`);
+			return;
+		}
+		clearActionError();
+	}
+
+	async function pollFocusForReset(): Promise<void> {
+		if (!shouldClearOnRefocus || focusPollInFlight) {
+			return;
+		}
+
+		focusPollInFlight = true;
+		try {
+			const focused = await getCurrentPaneFocusedState();
+			if (focused === undefined) {
+				consecutiveFocusQueryFailures += 1;
+				if (consecutiveFocusQueryFailures >= MAX_FOCUS_QUERY_FAILURES) {
+					stopFocusPolling();
+				}
+				return;
+			}
+			consecutiveFocusQueryFailures = 0;
+			if (!sawPaneBlurSinceDone) {
+				if (!focused) {
+					sawPaneBlurSinceDone = true;
+				}
+				return;
+			}
+			if (!focused) {
+				return;
+			}
+			await resetPaneIfEnabled();
+		} finally {
+			focusPollInFlight = false;
+		}
+	}
+
+	function armFocusBasedReset(): void {
+		stopFocusPolling();
+		if (!config.enabled || !isInsideZellijSession() || !process.env.ZELLIJ_PANE_ID) {
+			return;
+		}
+
+		shouldClearOnRefocus = true;
+		sawPaneBlurSinceDone = true;
+		focusPollTimer = setInterval(() => {
+			void pollFocusForReset();
+		}, FOCUS_POLL_INTERVAL_MS);
+	}
+
+	async function applyDoneState(messages: readonly unknown[]): Promise<void> {
+		if (!config.enabled || !isInsideZellijSession()) {
+			return;
+		}
+		if (!shouldHighlightAfterAgentEnd(messages)) {
+			await resetPaneIfEnabled();
+			return;
+		}
+
+		const focused = await getCurrentPaneFocusedState();
+		if (focused !== false) {
+			await resetPaneIfEnabled();
+			return;
+		}
+
+		const result = await setCurrentPaneColor(pi, {
+			bg: config.doneBg,
+			fg: config.doneFg,
+		});
+		if (!result.ok) {
+			warnActionError(`pane highlight update failed: ${result.error}`);
+			return;
+		}
+		clearActionError();
+		armFocusBasedReset();
+	}
+
+	pi.on("session_start", async (_event, ctx) => {
+		await refreshConfig(ctx.cwd);
+	});
+
+	pi.on("session_switch", async (_event, ctx) => {
+		await refreshConfig(ctx.cwd);
+	});
+
+	pi.on("session_fork", async (_event, ctx) => {
+		await refreshConfig(ctx.cwd);
+	});
+
+	pi.on("session_tree", async (_event, ctx) => {
+		await refreshConfig(ctx.cwd);
+	});
+
+	pi.on("input", async () => {
+		await resetPaneIfEnabled();
+		return { action: "continue" };
+	});
+
+	pi.on("agent_start", async () => {
+		await applyWorkingState();
+	});
+
+	pi.on("agent_end", async (event) => {
+		await applyDoneState(event.messages);
+	});
+
+	pi.on("session_shutdown", async () => {
+		await resetPaneIfEnabled();
+	});
+}

package/extensions/zv-open.ts

@@ -1,11 +1,13 @@
-import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import {
 	buildShellCommand,
+	formatPaneSuccessMessage,
 	openCommandInFloatingPane as openCommandInFloatingZellijPane,
 	openCommandInNewSplit,
+	type PaneOpenResult,
 	type SplitDirection,
 } from "./zv-core.ts";
 
@@ -73,7 +75,7 @@ async function openToolInSplit(
 	ctx: ExtensionCommandContext,
 	direction: SplitDirection,
 	args: string,
-): Promise<{ ok: true } | { ok: false; error: string }> {
+): Promise<PaneOpenResult> {
 	return openCommandInNewSplit(pi, direction, buildShellCommand(ctx.cwd, args.trim()));
 }
 
@@ -82,7 +84,7 @@ async function openToolInFloatingPane(
 	ctx: ExtensionCommandContext,
 	command: string,
 	name?: string,
-): Promise<{ ok: true } | { ok: false; error: string }> {
+): Promise<PaneOpenResult> {
 	return openCommandInFloatingZellijPane(pi, buildShellCommand(ctx.cwd, command.trim()), {
 		name,
 		...DEFAULT_FLOATING_PANE_OPTIONS,
@@ -107,7 +109,7 @@ function registerOpenCommand(
 
 			const result = await openToolInSplit(pi, ctx, direction, command);
 			if (result.ok) {
-				ctx.ui.notify(successMessage, "info");
+				ctx.ui.notify(formatPaneSuccessMessage(successMessage, result.paneId), "info");
 			} else {
 				ctx.ui.notify(`tool split failed: ${result.error}`, "error");
 			}
@@ -257,7 +259,7 @@ function registerConfiguredFloatingCommand(
 			const command = trimmedArgs.length > 0 ? `${config.run} ${trimmedArgs}` : config.run;
 			const result = await openToolInFloatingPane(pi, ctx, command, commandName);
 			if (result.ok) {
-				ctx.ui.notify(`Opened /${commandName} in a floating pane`, "info");
+				ctx.ui.notify(formatPaneSuccessMessage(`Opened /${commandName} in a floating pane`, result.paneId), "info");
 			} else {
 				ctx.ui.notify(`floating pane failed: ${result.error}`, "error");
 			}

package/extensions/zv-review.ts

@@ -1,5 +1,11 @@
-import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
-import { buildPiCommand, openCommandInNewSplit, type SplitDirection } from "./zv-core.ts";
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import {
+	buildPiCommand,
+	formatPaneSuccessMessage,
+	openCommandInNewSplit,
+	type PaneOpenResult,
+	type SplitDirection,
+} from "./zv-core.ts";
 
 type ReviewMode = "general" | "bugs" | "refactor" | "tests" | "diff";
 
@@ -89,7 +95,7 @@ async function openReviewSplit(
 	ctx: ExtensionCommandContext,
 	direction: SplitDirection,
 	request: ReviewRequest,
-): Promise<{ ok: true } | { ok: false; error: string }> {
+): Promise<PaneOpenResult> {
 	return openCommandInNewSplit(pi, direction, buildPiCommand(ctx.cwd, { prompt: buildReviewPrompt(request) }));
 }
 
@@ -111,7 +117,7 @@ function registerReviewCommand(
 
 			const result = await openReviewSplit(pi, ctx, direction, parsed.request);
 			if (result.ok) {
-				ctx.ui.notify(successMessage, "info");
+				ctx.ui.notify(formatPaneSuccessMessage(successMessage, result.paneId), "info");
 			} else {
 				ctx.ui.notify(`review pane failed: ${result.error}`, "error");
 			}

package/extensions/zv-split.ts

@@ -1,12 +1,21 @@
-import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
-import { buildPiCommand, openCommandInNewSplit, openCommandInNewTab, type SplitDirection } from "./zv-core.ts";
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import {
+	buildPiCommand,
+	formatPaneSuccessMessage,
+	formatTabSuccessMessage,
+	openCommandInNewSplit,
+	openCommandInNewTab,
+	type PaneOpenResult,
+	type SplitDirection,
+	type TabOpenResult,
+} from "./zv-core.ts";
 
 async function openPiInSplit(
 	pi: ExtensionAPI,
 	ctx: ExtensionCommandContext,
 	direction: SplitDirection,
 	args: string,
-): Promise<{ ok: true } | { ok: false; error: string }> {
+): Promise<PaneOpenResult> {
 	return openCommandInNewSplit(
 		pi,
 		direction,
@@ -18,7 +27,7 @@ async function openPiInTab(
 	pi: ExtensionAPI,
 	ctx: ExtensionCommandContext,
 	args: string,
-): Promise<{ ok: true } | { ok: false; error: string }> {
+): Promise<TabOpenResult> {
 	return openCommandInNewTab(pi, ctx.cwd, buildPiCommand(ctx.cwd, { prompt: args.trim().length > 0 ? args : undefined }));
 }
 
@@ -34,7 +43,7 @@ function registerSplitCommand(
 		handler: async (args, ctx) => {
 			const result = await openPiInSplit(pi, ctx, direction, args);
 			if (result.ok) {
-				ctx.ui.notify(successMessage, "info");
+				ctx.ui.notify(formatPaneSuccessMessage(successMessage, result.paneId), "info");
 			} else {
 				ctx.ui.notify(`zellij split failed: ${result.error}`, "error");
 			}
@@ -53,7 +62,7 @@ function registerTabCommand(
 		handler: async (args, ctx) => {
 			const result = await openPiInTab(pi, ctx, args);
 			if (result.ok) {
-				ctx.ui.notify(successMessage, "info");
+				ctx.ui.notify(formatTabSuccessMessage(successMessage, result.tabId), "info");
 			} else {
 				ctx.ui.notify(`zellij tab failed: ${result.error}`, "error");
 			}

package/extensions/zv-zoxide.ts

@@ -1,9 +1,15 @@
-import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { execFileSync } from "node:child_process";
 import { existsSync, statSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { buildPiCommand, openCommandInNewSplit, type SplitDirection } from "./zv-core.ts";
+import {
+	buildPiCommand,
+	formatPaneSuccessMessage,
+	openCommandInNewSplit,
+	type PaneOpenResult,
+	type SplitDirection,
+} from "./zv-core.ts";
 
 const ZOXIDE_TIMEOUT_MS = 5000;
 const MAX_COMPLETIONS = 10;
@@ -90,7 +96,7 @@ async function openPiInZoxideSplit(
 	query: string,
 	direction: SplitDirection,
 	commandName: string,
-): Promise<{ ok: true } | { ok: false; error: string }> {
+): Promise<PaneOpenResult> {
 	const targetResult = await resolveZoxideTarget(pi, query, ctx.cwd, commandName);
 	if (!targetResult.ok) {
 		return targetResult;
@@ -121,7 +127,7 @@ function registerZoxideCommand(
 
 			const result = await openPiInZoxideSplit(pi, ctx, query, direction, name);
 			if (result.ok) {
-				ctx.ui.notify(successMessage, "info");
+				ctx.ui.notify(formatPaneSuccessMessage(successMessage, result.paneId), "info");
 			} else {
 				ctx.ui.notify(`zoxide failed: ${result.error}`, "error");
 			}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-zellij",
-  "version": "0.4.0",
+  "version": "0.4.6",
   "description": "Pi package with zellij-powered terminal integrations",
   "author": "Javi Molina",
   "license": "MIT",
@@ -46,9 +46,9 @@
     ]
   },
   "peerDependencies": {
-    "@mariozechner/pi-coding-agent": "*"
+    "@earendil-works/pi-coding-agent": "*"
   },
   "devDependencies": {
-    "@mariozechner/pi-coding-agent": "*"
+    "@earendil-works/pi-coding-agent": "*"
   }
 }