pi-tty7-tab-namer 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ifyour
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,76 @@
+<p align="center">
+  <img src="./assets/readme/hero.jpg" width="100%" alt="Multiple session tabs auto-named by pi-tty7-tab-namer in the tty7 tab bar">
+</p>
+
+<h1 align="center">pi-tty7-tab-namer</h1>
+
+<p align="center">
+  <strong>pi extension</strong> · names sessions automatically with an LLM, synced to <a href="https://github.com/l0ng-ai/tty7">tty7</a> tab titles<br>
+</p>
+
+<p align="center">
+  <a href="./LICENSE"><img src="https://img.shields.io/badge/license-MIT-green" alt="MIT License"></a>
+  <img src="https://img.shields.io/badge/pi-package-5fd0a0" alt="pi package">
+  <img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fraw.githubusercontent.com%2Fifyour%2Fpi-tty7-tab-namer%2Fmain%2Fpackage.json&query=%24.version&label=version&color=blue" alt="version">
+</p>
+
+<p align="center">
+  <sub>English · <a href="README.zh-CN.md">简体中文</a></sub>
+</p>
+
+## Install
+
+Prerequisite: run pi inside the [tty7](https://github.com/l0ng-ai/tty7) terminal (this extension only activates in a tty7 environment).
+
+```bash
+pi install git:github.com/ifyour/pi-tty7-tab-namer
+```
+
+That's it — nothing else to do. Names are also written to session metadata, so they show up readable in the `/resume` session list.
+
+## Usage
+
+| Scenario | Behavior |
+|---|---|
+| First message in a new session | Tab automatically shows a short (≤10 char) title |
+| Loading an unnamed historical session | Names the **whole session** from the last 10 messages, not just the newly appended one |
+| `/name custom` | Tab updates immediately, and auto-naming stops for that session |
+| Manually renaming the tab in tty7 | Session name syncs immediately, and auto-naming stops (same as `/name`) |
+| Resuming a named session | Tab shows the name immediately |
+| Quitting pi | Tab falls back to the default tty7 title |
+
+## Features
+
+- **Auto-naming**: on the first message, calls the current session model in parallel to summarize intent into a title, without blocking the conversation
+- **Two-way sync**: manual tab rename in tty7 → writes the pi session name; naming inside pi → updates the tab
+- **Manual wins**: after `/name` or a manual tty7 rename, auto-naming never overrides
+- **Full lifecycle**: tab title follows the session name on `new` / `resume` / `fork` / `quit`
+- **Race-safe**: switching or quitting while a naming request is in flight discards the result, never writing to the wrong session; 20s timeout with automatic retry on the next turn
+- **Subagent isolation**: when the main session spawns subagents, child sessions never touch the tab title or session name (compatible with all pi sub-session mechanisms, e.g. pi-subagents and the built-in Task tool)
+
+## FAQ
+
+**Does it work in other terminals (iTerm2, etc.)?**
+
+Not currently — this extension targets tty7 only.
+
+**Does it auto-rename after multiple turns?**
+
+A session is named once (unless done manually).
+
+**Does the model call cost money?**
+
+Each naming run is one tiny request (a few hundred tokens), triggered only the first time for an unnamed session.
+
+## Development
+
+```bash
+git clone https://github.com/ifyour/pi-tty7-tab-namer
+cd pi-tty7-tab-namer
+npm test          # self-check for title sanitization logic
+pi -e .           # try locally
+```
+
+## License
+
+MIT

package/README.zh-CN.md

@@ -0,0 +1,76 @@
+<p align="center">
+  <img src="./assets/readme/hero.jpg" width="100%" alt="tty7 Tab 栏中显示多个由 pi-tty7-tab-namer 自动命名的会话标签">
+</p>
+
+<h1 align="center">pi-tty7-tab-namer</h1>
+
+<p align="center">
+  <strong>pi 扩展</strong> · 用大模型自动为会话命名，同步到 <a href="https://github.com/l0ng-ai/tty7">tty7</a> 的 Tab 标题<br>
+</p>
+
+<p align="center">
+  <a href="./LICENSE"><img src="https://img.shields.io/badge/license-MIT-green" alt="MIT License"></a>
+  <img src="https://img.shields.io/badge/pi-package-5fd0a0" alt="pi package">
+  <img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fraw.githubusercontent.com%2Fifyour%2Fpi-tty7-tab-namer%2Fmain%2Fpackage.json&query=%24.version&label=version&color=blue" alt="version">
+</p>
+
+<p align="center">
+  <sub><a href="README.md">English</a> · 简体中文</sub>
+</p>
+
+## 安装
+
+前提：在 [tty7](https://github.com/l0ng-ai/tty7) 终端内运行 pi（本扩展只在 tty7 环境下激活）。
+
+```bash
+pi install git:github.com/ifyour/pi-tty7-tab-namer
+```
+
+装好即可，无需任何操作。名字会同步写入会话元数据，`/resume` 会话列表里也直接可读。
+
+## 使用场景
+
+| 场景 | 行为 |
+|---|---|
+| 新会话发出第一条消息 | Tab 自动显示 ≤10 字中文标题 |
+| 载入未命名的历史会话 | 基于最近 10 条消息为**整个会话**命名，而不只看追加的新消息 |
+| `/name 自定义` | Tab 立即更新，且之后自动命名不再生效 |
+| 在 tty7 里手动改 Tab 名 | 会话名立即同步为该名字，之后自动命名不再生效（等同 `/name`） |
+| resume 已命名会话 | Tab 立即显示该名字 |
+| 退出 pi | Tab 回落到 tty7 默认标题 |
+
+## 特性
+
+- **自动命名**：第一条消息发出时，并行调用当前会话模型总结意图生成标题，不阻塞对话
+- **双向同步**：tty7 手动改 Tab 名 → 写入 pi 会话名；pi 内命名 → 更新 Tab
+- **手动优先**：`/name` 或 tty7 手动改名后，自动命名永不覆盖
+- **全生命周期跟随**：`new` / `resume` / `fork` / `quit` 时 Tab 标题跟随会话名字
+- **竞态安全**：命名请求在途时切换/退出会话，结果被丢弃，不会写错会话；20 秒超时，失败后下一轮自动重试
+- **子代理隔离**：主会话派发 subagent 时，子会话不会碰 Tab 标题或会话名，主会话命名不受影响（兼容所有基于 pi 子会话机制的 subagent，如 pi-subagents、内置 Task 工具）
+
+## FAQ
+
+**在其他终端（iTerm2 等）能用吗？**
+
+目前不能，本扩展仅针对 tty7。
+
+**支持多轮后自动改名吗？**
+
+目前一个会话只命名一次（手动除外）。
+
+**模型调用花钱吗？**
+
+每次命名一个极小请求（约几百 token），仅在未命名会话首次触发时发生。
+
+## 开发
+
+```bash
+git clone https://github.com/ifyour/pi-tty7-tab-namer
+cd pi-tty7-tab-namer
+npm test          # 标题清洗逻辑自检
+pi -e .           # 本地试用
+```
+
+## License
+
+MIT

package/extensions/index.ts

@@ -0,0 +1,407 @@
+/* tty7 tab-name — auto-name pi sessions and sync the name to the tty7 tab title.
+ *
+ * - Unnamed session → parallel LLM call (does not block the turn) summarizing
+ *   intent into a ≤10-char name → setSessionName + tab title. Naming looks at
+ *   the session's user messages (last 10) so a resumed old session gets named
+ *   for the whole conversation, not just the latest prompt.
+ * - Triggers: session_start (resume of an unnamed session) and the first
+ *   before_agent_start while still unnamed (covers fresh sessions and retries).
+ * - Manual `/name <x>` wins: once a name arrives from outside this extension,
+ *   auto-naming never runs again for that session.
+ * - resume/new/fork/quit: title follows the session's name; on shutdown the
+ *   title is reset so the tab falls back to tty7's default.
+ * - Reverse sync: a manual tab rename inside tty7 (tab_renamed event from
+ *   `tty7 events --json`) is treated like `/name` — manual priority, auto-
+ *   naming never overrides it afterwards. Bidirectional, no loop: our own
+ *   OSC writes never emit tab_renamed.
+ * - quit: the events listener child process is killed; if it dies mid-session
+ *   reverse sync goes silent until the next session_start.
+ *
+ * Title channel note: pi core also writes the title (`π - name - cwd`) in its
+ * own session_info_changed handler, which runs AFTER extension handlers. All
+ * our title writes are therefore deferred by one tick to land last, and we
+ * write exactly `{name}`.
+ */
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { spawn, spawnSync, type ChildProcess } from "node:child_process";
+import { appendFile, stat, truncate } from "node:fs/promises";
+
+// Lightweight always-on trace log: one JSON line per naming decision, so a
+// silent failure (timeout/model error/gen race/manual override) can be
+// diagnosed after the fact. Truncated at ~256 KB to stay bounded.
+const LOG_PATH = `${process.env["HOME"] ?? ""}/.pi/agent/tty7-tab-namer.log`;
+const LOG_MAX_BYTES = 256 * 1024;
+function log(event: string, detail: Record<string, unknown> = {}) {
+	void (async () => {
+		try {
+			const s = await stat(LOG_PATH).catch(() => null);
+			if (s && s.size > LOG_MAX_BYTES) await truncate(LOG_PATH);
+			await appendFile(LOG_PATH, JSON.stringify({ t: new Date().toISOString(), event, ...detail }) + "\n");
+		} catch {}
+	})();
+}
+
+const NAME_PROMPT =
+	"根据下面的用户消息记录，为这个会话起一个简短标题：不超过10个字，概括整个会话的主要意图，中文，不加引号、句号或任何前后缀，直接输出标题本身。\n\n<user-messages>\n";
+const MAX_TOKENS = 512;
+const NAME_TIMEOUT_MS = 20_000;
+const NAME_RETRIES = 3; // total attempts; backoff 2s → 4s between retries
+const HISTORY_MESSAGES = 10;
+const HISTORY_CHARS = 2000;
+// Subagent auto-name pattern (pi-subagents names child sessions "type#hex8",
+// e.g. "general-purpose#c897cd1c"); such names must never reach the tab.
+const SUBAGENT_NAME = /^[\w-]+#[0-9a-f]{8}$/i;
+// tty7 CLI resolves via PATH (installed at /usr/local/bin/tty7 by the app);
+// fall back to the app bundle binary for installs without the symlink.
+const TTY7_EXE = process.env["TTY7_CLI"] ?? "/usr/local/bin/tty7";
+
+/** Extract a clean title from raw model output. Exported for the self-test. */
+export function sanitizeTitle(raw: string): string {
+	const line = raw
+		.split("\n")
+		.map((l) => l.trim())
+		.find((l) => l.length > 0);
+	let t = (line ?? "").replace(/^["'「『《]|[」』》"'.,。]+$/g, "").trim();
+	if (t.length > 20) t = t.slice(0, 20);
+	return t;
+}
+
+function messageText(content: unknown): string {
+	if (typeof content === "string") return content;
+	if (Array.isArray(content)) {
+		return content
+			.filter((b): b is { type: "text"; text: string } => b?.type === "text")
+			.map((b) => b.text)
+			.join(" ");
+	}
+	return "";
+}
+
+/** Recent user messages of the current branch, oldest first. */
+function historyUserMessages(ctx: ExtensionContext): string[] {
+	const out: string[] = [];
+	try {
+		for (const entry of ctx.sessionManager.getBranch()) {
+			if (entry.type !== "message") continue;
+			const msg = entry.message as { role?: string; content?: unknown };
+			if (msg?.role !== "user") continue;
+			const text = messageText(msg.content).trim();
+			if (text) out.push(text);
+		}
+	} catch {}
+	return out.slice(-HISTORY_MESSAGES);
+}
+
+export default function (pi: ExtensionAPI) {
+	if (!process.env["TTY7"]) return; // bridge convention: only inside tty7
+
+	// Subagent sessions (pi-subagents spawns them in-process via
+	// createAgentSession; they persist a parentSession header and share the same
+	// tab) must never touch the title, or the child's name (e.g.
+	// "general-purpose#c897cd1c") clobbers the main session's name.
+	const isSubagent = (ctx: ExtensionContext): boolean => {
+		try {
+			return Boolean(ctx.sessionManager.getHeader()?.parentSession);
+		} catch {
+			return false;
+		}
+	};
+
+	let gen = 0; // bumped on every session transition; in-flight naming must match
+	let manual = false; // a name arrived that we did not set
+	let suppressInfo = false; // the next session_info_changed is our own setSessionName
+	let inFlight = false;
+	let retryTimer: ReturnType<typeof setTimeout> | null = null;
+	let lastCustom: string | null = null; // title we manage; null = leave terminal default
+
+	// --- reverse sync: tty7 tab rename → session name -----------------------
+	// tty7 emits tab_renamed ONLY for manual renames (OSC title writes land in
+	// the tab's label and fire pane_facts instead — verified). So any matching
+	// rename event is user intent and gets manual priority.
+	let eventsProc: ChildProcess | null = null;
+	let ourTabId: string | null = null;
+	let eventsBuf = "";
+	let selfRename: string | null = null; // tab rename we issued ourselves (ignore the echoed event)
+	let tabNameOurs = false; // tab's name field was last written by this extension (not the user)
+
+	function resolveTabId(): string | null {
+		const pane = Number(process.env["TTY7_PANE"]);
+		if (!Number.isFinite(pane)) return null;
+		try {
+			const out = spawnSync(TTY7_EXE, ["tab", "ls", "--json"], { encoding: "utf8", timeout: 5000 });
+			const tabs = (JSON.parse(out.stdout ?? "{}") as { tabs?: Array<{ id: string; panes: number[] }> }).tabs ?? [];
+			return tabs.find((t) => t.panes.includes(pane))?.id ?? null;
+		} catch {
+			return null;
+		}
+	}
+
+	function stopEvents() {
+		eventsProc?.kill();
+		eventsProc = null;
+		eventsBuf = "";
+	}
+
+	let lastCtx: ExtensionContext | null = null; // for ui.notify outside event handlers
+
+	function startEvents(pi: ExtensionAPI) {
+		stopEvents();
+		const newTabId = resolveTabId();
+		if (newTabId !== ourTabId) appliedTabName = null; // new tab → its name field state is unknown
+		ourTabId = newTabId;
+		try {
+			eventsProc = spawn(TTY7_EXE, ["events", "--json"], { stdio: ["ignore", "pipe", "ignore"] });
+		} catch {
+			return; // silent: reverse sync is best-effort
+		}
+		eventsProc.stdout!.on("data", (chunk: Buffer) => {
+			eventsBuf += chunk.toString();
+			let nl: number;
+			while ((nl = eventsBuf.indexOf("\n")) >= 0) {
+				const line = eventsBuf.slice(0, nl).trim();
+				eventsBuf = eventsBuf.slice(nl + 1);
+				if (!line) continue;
+				let renamed: { tab?: string; name?: string } | undefined;
+				try {
+					const evt = JSON.parse(line) as { layout?: { delta?: { tab_renamed?: { tab: string; name: string } } } };
+					renamed = evt.layout?.delta?.tab_renamed;
+				} catch {
+					continue; // partial/malformed line
+				}
+				if (!renamed || typeof renamed.name !== "string") continue;
+				// Echo of our own forward sync → not user intent.
+				if (selfRename !== null && renamed.name === selfRename) {
+					selfRename = null;
+					continue;
+				}
+				selfRename = null;
+				// Lazy re-resolve: session may have moved to another tab (resume etc.).
+				if (ourTabId !== renamed.tab) {
+					ourTabId = resolveTabId();
+					if (ourTabId !== renamed.tab) continue;
+				}
+				const name = renamed.name.trim();
+				if (!name) continue; // cleared/whitespace rename → ignore
+				if (pi.getSessionName() === name) continue; // no-op rename
+				manual = true; // user intent: auto-naming never overrides from here
+				log("reverse-sync", { name });
+				tabNameOurs = false; // the user owns the tab name now
+				appliedTabName = name;
+				suppressInfo = true;
+				pi.setSessionName(name);
+				applyName(name);
+				lastCtx?.ui.notify(`Session name set: ${name}`, "info");
+			}
+		});
+		eventsProc.on("exit", () => {
+			eventsProc = null;
+		});
+	}
+
+	// pi core rewrites the title after extension handlers on session_info_changed;
+	// a one-tick defer makes our write the final one.
+	let pendingTitle: ReturnType<typeof setTimeout> | null = null;
+	function setTitleSoon(title: string) {
+		if (pendingTitle) clearTimeout(pendingTitle);
+		pendingTitle = setTimeout(() => {
+			pendingTitle = null;
+			try {
+				process.stdout.write(`\x1B]0;${title}\x07`);
+			} catch {}
+		}, 0);
+	}
+
+	let appliedTabName: string | null = null; // name currently on the tab's name field
+
+	// Forward sync: keep the tab's `name` field equal to the session name via
+	// `tab rename`. The OSC title only updates the tab's `label`, which the GUI
+	// hides once a user rename has set `name` (verified) — so session-side
+	// renames must go through the CLI to stay visible. tab rename accepts the
+	// tab UUID directly.
+	function tabRename(name: string) {
+		if (name === appliedTabName) return;
+		if (!ourTabId) ourTabId = resolveTabId();
+		if (!ourTabId) return;
+		appliedTabName = name;
+		tabNameOurs = true;
+		selfRename = name; // ignore the tab_renamed event this will echo back
+		try {
+			spawn(TTY7_EXE, ["tab", "rename", ourTabId, name], { stdio: "ignore" }).on("error", () => {});
+		} catch {}
+	}
+
+	function applyName(name: string | null) {
+		if (name) {
+			lastCustom = name;
+			setTitleSoon(name);
+			tabRename(name);
+		} else if (lastCustom !== null) {
+			lastCustom = null;
+			setTitleSoon("");
+			// Reset the tab name too — but only if we wrote it; a user-chosen
+			// tab name survives the session ("退出 pi → Tab 回落默认" only
+			// applies to names the extension set).
+			if (tabNameOurs && ourTabId) {
+				tabNameOurs = false;
+				appliedTabName = null;
+				try {
+					spawn(TTY7_EXE, ["tab", "rename", ourTabId, ""], { stdio: "ignore" }).on("error", () => {});
+				} catch {}
+			}
+		}
+	}
+
+	function tryName(ctx: ExtensionContext, latestPrompt?: string) {
+		const skip = (why: string) => log("skip", { why, prompt: Boolean(latestPrompt), sessionId: ctx.sessionManager.getSessionId() });
+		if (manual) return skip("manual");
+		if (pi.getSessionName()) return skip("already-named");
+		if (inFlight) return skip("in-flight");
+		if (!ctx.model) return skip("no-model");
+		const messages = historyUserMessages(ctx);
+		if (latestPrompt) messages.push(latestPrompt);
+		if (messages.length === 0) return skip("no-messages");
+		let context = messages.join("\n---\n");
+		if (context.length > HISTORY_CHARS) context = context.slice(-HISTORY_CHARS);
+		const myGen = gen;
+		const model = ctx.model;
+		inFlight = true;
+		log("naming-start", { context: context.slice(-200), sessionId: ctx.sessionManager.getSessionId() });
+		// Fire-and-forget: naming must not delay the user's turn. On failure
+		// retry up to NAME_RETRIES attempts total with exponential backoff, so a
+		// flaky first call still names the session within seconds.
+		void (async () => {
+			for (let attempt = 1; attempt <= NAME_RETRIES; attempt++) {
+				let name = "";
+				try {
+					const request = ctx.modelRegistry.complete(
+						model,
+						{
+							messages: [
+								{
+									role: "user" as const,
+									content: [{ type: "text" as const, text: `${NAME_PROMPT}${context}\n</user-messages>` }],
+									timestamp: Date.now(),
+								},
+							],
+						},
+						{ maxTokens: MAX_TOKENS, cacheRetention: "none", sessionId: crypto.randomUUID() },
+					);
+					const timeout = new Promise<null>((resolve) => setTimeout(() => resolve(null), NAME_TIMEOUT_MS));
+					const response = await Promise.race([request, timeout]);
+					if (!response) {
+						log("naming-failed", { why: "timeout", attempt, ms: NAME_TIMEOUT_MS });
+					} else {
+						const text = response.content
+							.filter((c): c is { type: "text"; text: string } => c.type === "text")
+							.map((c) => c.text)
+							.join(" ");
+						name = sanitizeTitle(text);
+						if (!name) log("naming-failed", { why: "empty-after-sanitize", attempt, raw: text.slice(0, 100) });
+					}
+				} catch (err) {
+					log("naming-failed", { why: "error", attempt, error: err instanceof Error ? err.message : String(err) });
+				}
+				if (name) {
+					// On a gen change session_start already reset inFlight for the new
+					// session — leave it alone.
+					if (myGen !== gen) return log("naming-dropped", { why: "gen-changed" });
+					inFlight = false;
+					if (manual) return log("naming-dropped", { why: "manual" });
+					if (pi.getSessionName()) return log("naming-dropped", { why: "already-named" });
+					log("naming-done", { name, attempt });
+					suppressInfo = true;
+					pi.setSessionName(name);
+					applyName(name);
+					return;
+				}
+				if (attempt < NAME_RETRIES) {
+					const backoff = 2 ** attempt * 1000; // 2s, 4s
+					let aborted: "gen" | null = null;
+					const iv = setInterval(() => {
+						// Session switched away or user named it: stop retrying.
+						if (myGen !== gen || manual) aborted = "gen";
+					}, 250);
+					await new Promise((resolve) => {
+						retryTimer = setTimeout(() => {
+							clearInterval(iv);
+							resolve(null);
+						}, backoff);
+					});
+					clearInterval(iv);
+					if (aborted || manual) {
+						inFlight = false;
+						return log("naming-dropped", { why: manual ? "manual" : "gen-changed" });
+					}
+					log("naming-retry", { attempt: attempt + 1, backoffMs: backoff });
+				}
+			}
+			if (myGen === gen) inFlight = false;
+			log("naming-failed", { why: "exhausted", attempts: NAME_RETRIES });
+		})();
+	}
+
+	pi.on("session_start", (event, ctx) => {
+		if (isSubagent(ctx)) return; // child agent process: the tab belongs to the main session
+		lastCtx = ctx;
+		gen++;
+		manual = false;
+		suppressInfo = false;
+		inFlight = false;
+		if (retryTimer) {
+			clearTimeout(retryTimer); // kill any pending backoff from the old session
+			retryTimer = null;
+		}
+		// /new is a full new cycle: the tab always falls back to the default, even
+		// when the current name came from a manual tty7 rename (reverse sync).
+		if (event.reason === "new" && appliedTabName) {
+			tabRename("");
+			tabNameOurs = false;
+		} else if (tabNameOurs && ourTabId) {
+			// Switching sessions: a tab name we wrote for the previous session no
+			// longer applies; clear it before the new session's name lands.
+			tabNameOurs = false;
+			appliedTabName = null;
+			try {
+				spawn(TTY7_EXE, ["tab", "rename", ourTabId, ""], { stdio: "ignore" }).on("error", () => {});
+			} catch {}
+		}
+		const storedName = pi.getSessionName();
+		// A leaked subagent name ("type#hex8") may have been persisted into this
+		// session's file by pi-subagents; never display or trust it.
+		applyName(storedName && !SUBAGENT_NAME.test(storedName) ? storedName : null);
+		startEvents(pi);
+		// Resumed a session that was never named → name it from its history now.
+		if (event.reason === "resume" || event.reason === "fork") {
+			log("trigger", { reason: event.reason });
+			tryName(ctx);
+		}
+	});
+
+	pi.on("session_info_changed", (event, ctx) => {
+		// Subagents run in-process and setSessionName("type#hex8") on their child
+		// session; that event reaches us here and would clobber the main session's
+		// tab name (and flip manual=true, killing auto-naming). Ignore both the
+		// child-context delivery and the leaked name pattern itself.
+		if (isSubagent(ctx) || SUBAGENT_NAME.test(event.name ?? "")) return;
+		if (suppressInfo) {
+			suppressInfo = false;
+			return;
+		}
+		manual = event.name !== undefined;
+		if (event.name) applyName(event.name);
+	});
+
+	pi.on("session_shutdown", (event, ctx) => {
+		if (isSubagent(ctx)) return; // never touched the tab, nothing to reset
+		gen++;
+		stopEvents();
+		applyName(null);
+	});
+
+	pi.on("before_agent_start", (event, ctx) => {
+		if (isSubagent(ctx)) return;
+		// First prompt of an unnamed session, or a retry after a failed attempt.
+		log("trigger", { reason: "before-agent-start" });
+		tryName(ctx, event.prompt);
+	});
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+	"name": "pi-tty7-tab-namer",
+	"version": "0.1.0",
+	"description": "Auto-name pi sessions with an LLM and sync the name to the tty7 tab title. Manual /name always wins.",
+	"type": "module",
+	"files": ["extensions", "README.md"],
+	"keywords": ["pi-package", "pi", "tty7", "terminal", "tab-title", "session-name"],
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/ifyour/pi-tty7-tab-namer.git"
+	},
+	"pi": {
+		"extensions": ["extensions/*.ts"]
+	},
+	"peerDependencies": {
+		"@earendil-works/pi-agent-core": "*",
+		"@earendil-works/pi-coding-agent": "*"
+	},
+	"peerDependenciesMeta": {
+		"@earendil-works/pi-agent-core": { "optional": true },
+		"@earendil-works/pi-coding-agent": { "optional": true }
+	},
+	"scripts": {
+		"test": "node --experimental-strip-types test/sanitize.test.ts && node test/e2e.mjs"
+	}
+}