pi-turns 1.5.1

package/CHANGELOG.md

@@ -0,0 +1,34 @@
+# Changelog
+
+## 1.5.0
+
+- Viewer shows up to 70% of the terminal height (was 45%, capped at 22 lines).
+- `g` / `G` jump to the top / bottom of the viewer.
+
+## 1.4.1
+
+- Leave search typing mode when opening a turn; the filter query stays.
+- Serialize star file writes so fast toggles cannot clobber each other.
+
+## 1.4.0
+
+- `/` incremental search over user/assistant text. Esc clears the query first, then closes.
+- Search stacks with the starred filter and survives opening a turn.
+
+## 1.3.0
+
+- `s` stars a turn for later review; `f` shows starred turns only.
+- Stars persist per session in `~/.pi/agent/pi-turns-stars.json` and do not move the session leaf.
+
+## 1.2.0
+
+- Truncate list previews by terminal display width (CJK counts as 2).
+- `g` / `G` jump to the first / last turn.
+- Mark the latest turn with `●`.
+
+## 1.1.0
+
+- `/turns` lists the current session branch as user/assistant turns
+- Consecutive assistant fragments between user messages are merged
+- Markdown viewer with copy; list remembers the last opened turn
+- Same-day timestamps show `HH:MM`; other days show `MM-DD HH:MM`

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 FarL1
+
+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,71 @@
+# pi-turns
+
+Browse the current [Pi](https://pi.dev) session as user and assistant turns.
+
+![Turn list](screenshots/turns.png)
+
+## Install
+
+Requires [Pi](https://pi.dev) 0.84+ and Node 22+.
+
+```sh
+pi install git:github.com/FarL1/pi-turns
+```
+
+From a local clone:
+
+```sh
+pi install .
+```
+
+Then run `/turns`. Reload with `/reload` if Pi is already open.
+
+## Keys
+
+| Key | Action |
+| --- | --- |
+| `/` | Search (type to filter; Esc clears) |
+| `↑` `↓` / `j` `k` | Move |
+| `s` | Star / unstar |
+| `f` | Show starred only |
+| `g` / `G` | First / last |
+| Enter | Open turn |
+| Esc | Back / close |
+
+**Viewer:** `c` copies the original text (not the rendered view). Enter or Esc goes back. `↑` `↓` / PageUp / PageDown scroll. `g` / `G` top/bottom.
+
+The list remembers the last opened turn. Search and the starred filter survive opening a turn.
+
+## Viewer
+
+Enter opens the selected turn as Markdown:
+
+![Markdown viewer](screenshots/viewer.png)
+
+## Star and search
+
+`s` stars a turn. `f` shows only starred turns:
+
+![Starred filter](screenshots/starred.png)
+
+`/` filters as you type:
+
+![Search](screenshots/search.png)
+
+## Behavior
+
+- Active branch only. Does not move the session leaf or write the session JSONL.
+- Consecutive assistant fragments between two user messages are one turn.
+- Tool calls, thinking, and bash results are omitted.
+- Same-day timestamps: `HH:MM`. Other days: `MM-DD HH:MM`.
+- Latest turn: `●`. Starred: `★`. Lists in the viewer: `•`.
+
+Not a session-tree browser (`/tree`) and not a search across sessions.
+
+## Data
+
+Stars are stored locally in `~/.pi/agent/pi-turns-stars.json`, keyed by session. Nothing is uploaded.
+
+## License
+
+MIT

package/extensions/core.ts

@@ -0,0 +1,197 @@
+export type Turn = {
+	role: "user" | "assistant";
+	text: string;
+	timestamp: number;
+};
+
+export function turnId(turn: Turn): string {
+	const head = turn.text.replace(/\s+/g, " ").trim().slice(0, 80);
+	return `${turn.role}:${turn.timestamp}:${head}`;
+}
+
+export function matchesQuery(text: string, query: string): boolean {
+	const needle = query.trim().toLowerCase();
+	if (!needle) return true;
+	return text.toLowerCase().includes(needle);
+}
+
+export function toggleStar(ids: Iterable<string>, id: string): string[] {
+	const next = new Set(ids);
+	if (next.has(id)) next.delete(id);
+	else next.add(id);
+	return [...next];
+}
+
+export function extractText(content: unknown): string {
+	if (typeof content === "string") return content.trim();
+	if (!Array.isArray(content)) return "";
+	const parts: string[] = [];
+	for (const block of content) {
+		if (block && typeof block === "object" && (block as { type?: string }).type === "text") {
+			const text = (block as { text?: unknown }).text;
+			if (typeof text === "string" && text.trim()) parts.push(text.trim());
+		}
+	}
+	return parts.join("\n\n");
+}
+
+function messageFromEntry(entry: unknown): { role?: string; content?: unknown; timestamp?: unknown } | undefined {
+	if (!entry || typeof entry !== "object") return undefined;
+	const record = entry as { type?: string; message?: unknown; timestamp?: unknown };
+	if (record.type && record.type !== "message") return undefined;
+	const message = record.type === "message" ? record.message : entry;
+	if (!message || typeof message !== "object") return undefined;
+	const body = message as { role?: string; content?: unknown; timestamp?: unknown };
+	return { role: body.role, content: body.content, timestamp: body.timestamp ?? record.timestamp };
+}
+
+function timestampOf(value: unknown): number {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string") {
+		const parsed = Date.parse(value);
+		if (Number.isFinite(parsed)) return parsed;
+	}
+	return 0;
+}
+
+/** One user prompt, then one combined assistant reply (all fragments until the next user). */
+export function turnsFromEntries(entries: unknown[]): Turn[] {
+	const turns: Turn[] = [];
+	let pending: Turn | undefined;
+	const flush = () => {
+		if (pending?.text) turns.push(pending);
+		pending = undefined;
+	};
+	for (const entry of entries) {
+		const message = messageFromEntry(entry);
+		if (!message) continue;
+		if (message.role === "user") {
+			flush();
+			const text = extractText(message.content);
+			if (text) turns.push({ role: "user", text, timestamp: timestampOf(message.timestamp) });
+			continue;
+		}
+		if (message.role !== "assistant") continue;
+		const text = extractText(message.content);
+		if (!pending) pending = { role: "assistant", text: "", timestamp: timestampOf(message.timestamp) };
+		if (text) pending.text = pending.text ? `${pending.text}\n\n${text}` : text;
+	}
+	flush();
+	return turns;
+}
+
+export function charWidth(ch: string): number {
+	const code = ch.codePointAt(0) ?? 0;
+	if (code <= 0x1f || (code >= 0x7f && code <= 0x9f)) return 0;
+	if (
+		code >= 0x1100 && (
+			code <= 0x115f
+			|| code === 0x2329 || code === 0x232a
+			|| (code >= 0x2e80 && code <= 0xa4cf && code !== 0x303f)
+			|| (code >= 0xac00 && code <= 0xd7a3)
+			|| (code >= 0xf900 && code <= 0xfaff)
+			|| (code >= 0xfe10 && code <= 0xfe19)
+			|| (code >= 0xfe30 && code <= 0xfe6f)
+			|| (code >= 0xff00 && code <= 0xff60)
+			|| (code >= 0xffe0 && code <= 0xffe6)
+			|| code >= 0x1f300
+		)
+	) return 2;
+	return 1;
+}
+
+export function displayWidth(text: string): number {
+	let width = 0;
+	for (const ch of text) width += charWidth(ch);
+	return width;
+}
+
+export function previewLine(text: string, max = 72): string {
+	const one = text.replace(/\s+/g, " ").trim();
+	if (displayWidth(one) <= max) return one;
+	let out = "";
+	let width = 0;
+	for (const ch of one) {
+		const next = charWidth(ch);
+		if (width + next + 1 > max) break;
+		out += ch;
+		width += next;
+	}
+	return `${out || one.slice(0, 1)}…`;
+}
+
+export function formatWhen(timestamp: number, now = Date.now()): string {
+	if (!timestamp) return "--:--";
+	const date = new Date(timestamp);
+	const current = new Date(now);
+	const clock = `${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`;
+	const sameDay = date.getFullYear() === current.getFullYear()
+		&& date.getMonth() === current.getMonth()
+		&& date.getDate() === current.getDate();
+	if (sameDay) return clock;
+	return `${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")} ${clock}`;
+}
+
+export function roleBadge(role: Turn["role"]): string {
+	return role === "user" ? "YOU" : "PI";
+}
+
+export function listLabel(turn: Turn, index: number, total: number, previewMax = 56): string {
+	return `${index + 1}/${total} ${roleBadge(turn.role)} ${formatWhen(turn.timestamp)}  ${previewLine(turn.text, previewMax)}`;
+}
+
+export function fitGap(left: string, right: string, width: number): string {
+	return " ".repeat(Math.max(1, width - left.length - right.length));
+}
+
+export function visibleLen(text: string): number {
+	return displayWidth(text.replace(/\u001b\[[0-9;]*m/g, ""));
+}
+
+export function padLine(text: string, width: number): string {
+	const extra = width - visibleLen(text);
+	return extra > 0 ? `${text}${" ".repeat(extra)}` : text;
+}
+
+export function moveSelection(current: number, total: number, delta: number): number {
+	if (total <= 0) return 0;
+	return Math.max(0, Math.min(total - 1, current + delta));
+}
+
+export function pickerWindow(selected: number, total: number, maxVisible: number): { start: number; end: number } {
+	if (total <= maxVisible) return { start: 0, end: total };
+	const half = Math.floor(maxVisible / 2);
+	let start = selected - half;
+	if (start < 0) start = 0;
+	if (start + maxVisible > total) start = total - maxVisible;
+	return { start, end: start + maxVisible };
+}
+
+export function visibleSlice(lines: string[], scroll: number, height: number): { lines: string[]; scroll: number; maxScroll: number } {
+	const view = Math.max(1, height);
+	const maxScroll = Math.max(0, lines.length - view);
+	const offset = Math.max(0, Math.min(scroll, maxScroll));
+	return { lines: lines.slice(offset, offset + view), scroll: offset, maxScroll };
+}
+
+export function roleLabel(role: Turn["role"]): string {
+	return roleBadge(role);
+}
+
+export type Theme = {
+	bold: (text: string) => string;
+	fg: (name: string, text: string) => string;
+	bg?: (name: string, text: string) => string;
+	italic?: (text: string) => string;
+	underline?: (text: string) => string;
+};
+
+export type Keybindings = {
+	matches: (data: string, id: string) => boolean;
+};
+
+export type TuiHandle = {
+	requestRender: () => void;
+	rows?: number;
+	terminal?: { rows?: number };
+};

package/extensions/index.ts

@@ -0,0 +1,331 @@
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+	fitGap,
+	formatWhen,
+	padLine,
+	listLabel,
+	moveSelection,
+	pickerWindow,
+	previewLine,
+	roleBadge,
+	matchesQuery,
+	toggleStar,
+	turnId,
+	turnsFromEntries,
+	visibleSlice,
+	type Keybindings,
+	type Theme,
+	type TuiHandle,
+	type Turn,
+} from "./core.ts";
+
+function markdownThemeFrom(theme: Theme) {
+	const fg = (color: string, value: string) => theme.fg(color, value);
+	return {
+		heading: (value: string) => theme.bold(fg("mdHeading", value)),
+		link: (value: string) => fg("mdLink", value),
+		linkUrl: (value: string) => fg("mdLinkUrl", value),
+		code: (value: string) => fg("mdCode", value),
+		codeBlock: (value: string) => fg("mdCodeBlock", value),
+		codeBlockBorder: (value: string) => fg("mdCodeBlockBorder", value),
+		quote: (value: string) => fg("mdQuote", value),
+		quoteBorder: (value: string) => fg("mdQuoteBorder", value),
+		hr: (value: string) => fg("mdHr", value),
+		listBullet: (value: string) => fg("mdListBullet", value.replace(/^[-*+]/u, "•")),
+		bold: (value: string) => theme.bold(value),
+		italic: (value: string) => theme.italic?.(value) ?? value,
+		underline: (value: string) => theme.underline?.(value) ?? value,
+		strikethrough: (value: string) => value,
+	};
+}
+
+function roleColor(theme: Theme, role: Turn["role"], text: string): string {
+	return theme.fg(role === "user" ? "userMessageText" : "accent", text);
+}
+
+function rule(theme: Theme, width: number): string {
+	return theme.fg("borderMuted", "─".repeat(Math.max(8, width)));
+}
+
+function starsFile(): string {
+	const root = process.env.PI_CODING_AGENT_DIR || join(homedir(), ".pi", "agent");
+	return join(root, "pi-turns-stars.json");
+}
+
+async function loadStars(sessionKey: string): Promise<Set<string>> {
+	try {
+		const data = JSON.parse(await readFile(starsFile(), "utf8")) as Record<string, string[]>;
+		return new Set(data[sessionKey] ?? []);
+	} catch {
+		return new Set();
+	}
+}
+
+let starWrite: Promise<void> = Promise.resolve();
+
+async function saveStars(sessionKey: string, ids: Set<string>): Promise<void> {
+	const snapshot = [...ids];
+	starWrite = starWrite.then(async () => {
+		const file = starsFile();
+		let data: Record<string, string[]> = {};
+		try {
+			data = JSON.parse(await readFile(file, "utf8")) as Record<string, string[]>;
+		} catch { /* first write */ }
+		if (snapshot.length === 0) delete data[sessionKey];
+		else data[sessionKey] = snapshot;
+		await mkdir(dirname(file), { recursive: true });
+		await writeFile(file, `${JSON.stringify(data)}\n`, "utf8");
+	}).catch(() => {});
+	return starWrite;
+}
+
+async function copyText(text: string): Promise<boolean> {
+	try {
+		const { copyToClipboard } = await import("@earendil-works/pi-coding-agent");
+		await copyToClipboard(text);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+type StarState = { ids: Set<string>; sessionKey: string };
+type ViewState = { starredOnly: boolean; query: string; searching: boolean };
+
+function pickIndex(
+	ctx: {
+		ui: {
+			custom?: (factory: (tui: TuiHandle, theme: Theme, keybindings: Keybindings, done: (value: number | undefined) => void) => unknown) => Promise<unknown>;
+			select: (title: string, options: string[]) => Promise<string | undefined>;
+		};
+	},
+	title: string,
+	turns: Turn[],
+	selectedIndex: number,
+	stars: StarState,
+	view: ViewState,
+): Promise<number | undefined> {
+	if (typeof ctx.ui.custom !== "function") {
+		const items = turns.map((turn, index) => `${stars.ids.has(turnId(turn)) ? "★ " : ""}${listLabel(turn, index, turns.length)}`);
+		return ctx.ui.select(title, items).then((chosen) => chosen === undefined ? undefined : items.indexOf(chosen));
+	}
+	return ctx.ui.custom((tui, theme, keybindings, done) => {
+		const rows = tui.rows ?? tui.terminal?.rows ?? 24;
+		const maxVisible = Math.max(6, Math.min(14, Math.floor(rows * 0.4)));
+		const visible = () => turns.filter((turn) => {
+			if (view.starredOnly && !stars.ids.has(turnId(turn))) return false;
+			return matchesQuery(turn.text, view.query);
+		});
+		const selectTurn = (turn: Turn | undefined) => {
+			if (!turn) return 0;
+			const id = turnId(turn);
+			const index = visible().findIndex((item) => turnId(item) === id);
+			return index >= 0 ? index : 0;
+		};
+		let selected = selectTurn(turns[selectedIndex]);
+		return {
+			render: (width: number) => {
+				const inner = Math.max(16, width);
+				const previewMax = Math.max(8, inner - 24);
+				const list = visible();
+				selected = moveSelection(selected, list.length, 0);
+				const latestId = turns.length ? turnId(turns[turns.length - 1]) : "";
+				const heading = `${view.starredOnly ? `${title} ★` : title}${view.searching || view.query ? ` /${view.query}` : ""}`;
+				const count = list.length ? `${selected + 1} / ${list.length}` : `0 / 0`;
+				const lines = [
+					`${theme.bold(theme.fg("accent", heading))}${fitGap(heading, count, inner)}${theme.fg("dim", count)}`,
+					rule(theme, inner),
+				];
+				if (list.length === 0) {
+					lines.push(theme.fg("dim", view.query.trim() ? "  no matches" : view.starredOnly ? "  no starred turns" : "  no turns"));
+				} else {
+					const { start, end } = pickerWindow(selected, list.length, maxVisible);
+					for (let index = start; index < end; index++) {
+						const turn = list[index];
+						const active = index === selected;
+						const mark = active ? theme.fg("accent", "▎") : " ";
+						const badge = roleColor(theme, turn.role, roleBadge(turn.role).padEnd(3));
+						const star = stars.ids.has(turnId(turn)) ? theme.fg("warning", "★") : " ";
+						const time = theme.fg("dim", formatWhen(turn.timestamp).padEnd(11));
+						const latestMark = turnId(turn) === latestId ? theme.fg("accent", "●") : " ";
+						const preview = previewLine(turn.text, previewMax);
+						lines.push(padLine(`${mark} ${active ? theme.bold(badge) : badge}  ${star} ${time} ${latestMark} ${active ? theme.fg("text", preview) : theme.fg("muted", preview)}`, inner));
+					}
+				}
+				lines.push(rule(theme, inner));
+				lines.push(padLine(theme.fg("dim", view.searching
+					? "type to filter   backspace   esc clear   enter open"
+					: "↑↓ move   / search   s star   f starred   g/G first/last   enter   esc"), inner));
+				return lines;
+			},
+			invalidate: () => {},
+			handleInput: (data: string) => {
+				const list = visible();
+				if (keybindings.matches(data, "tui.select.cancel")) {
+					if (view.query || view.searching) {
+						view.query = "";
+						view.searching = false;
+						selected = selectTurn(list[selected]);
+						tui.requestRender();
+						return;
+					}
+					done(undefined);
+					return;
+				}
+				if (keybindings.matches(data, "tui.select.confirm") || data === "\n") {
+					const turn = list[selected];
+					if (!turn) return;
+					view.searching = false;
+					done(turns.findIndex((item) => turnId(item) === turnId(turn)));
+					return;
+				}
+				if (view.searching) {
+					if (data === "\x7f" || data === "\b") {
+						const current = list[selected];
+						view.query = view.query.slice(0, -1);
+						selected = selectTurn(current);
+						tui.requestRender();
+						return;
+					}
+					if (data.length === 1 && data >= " ") {
+						const current = list[selected];
+						view.query += data;
+						selected = selectTurn(current);
+						tui.requestRender();
+						return;
+					}
+				} else if (data === "/") {
+					view.searching = true;
+					tui.requestRender();
+					return;
+				} else if (data === "s" || data === "S") {
+					const turn = list[selected];
+					if (!turn) return;
+					stars.ids = new Set(toggleStar(stars.ids, turnId(turn)));
+					void saveStars(stars.sessionKey, stars.ids);
+					tui.requestRender();
+					return;
+				} else if (data === "f" || data === "F") {
+					const current = list[selected];
+					view.starredOnly = !view.starredOnly;
+					selected = selectTurn(current);
+					tui.requestRender();
+					return;
+				}
+				if (data === "g" && !view.searching) {
+					selected = 0;
+				} else if (data === "G" && !view.searching) {
+					selected = Math.max(0, list.length - 1);
+				} else if (keybindings.matches(data, "tui.select.up") || (!view.searching && data === "k")) {
+					selected = moveSelection(selected, list.length, -1);
+				} else if (keybindings.matches(data, "tui.select.down") || (!view.searching && data === "j")) {
+					selected = moveSelection(selected, list.length, 1);
+				} else if (keybindings.matches(data, "tui.select.pageUp")) {
+					selected = moveSelection(selected, list.length, -maxVisible);
+				} else if (keybindings.matches(data, "tui.select.pageDown")) {
+					selected = moveSelection(selected, list.length, maxVisible);
+				} else {
+					return;
+				}
+				tui.requestRender();
+			},
+		};
+	}) as Promise<number | undefined>;
+
+}
+
+async function showMessage(ctx: {
+	ui: {
+		custom?: (factory: (tui: TuiHandle, theme: Theme, keybindings: Keybindings, done: (value?: undefined) => void) => unknown) => Promise<unknown>;
+		notify: (message: string, level?: string) => void;
+	};
+}, title: string, text: string, role: Turn["role"] = "assistant"): Promise<void> {
+	if (typeof ctx.ui.custom !== "function") {
+		ctx.ui.notify(text, "info");
+		return;
+	}
+	await ctx.ui.custom(async (tui, theme, keybindings, done) => {
+		const { Markdown } = await import("@earendil-works/pi-tui");
+		const { keyText, rawKeyHint } = await import("@earendil-works/pi-coding-agent");
+		const markdown = new Markdown(text, 0, 0, markdownThemeFrom(theme));
+		const rows = tui.rows ?? tui.terminal?.rows ?? 24;
+		const bodyHeight = Math.max(10, Math.min(40, Math.floor(rows * 0.7)));
+		let scroll = 0;
+		let status = "";
+		return {
+			render: (width: number) => {
+				const inner = Math.max(16, width);
+				const rendered = markdown.render(Math.max(8, inner - 2));
+				const slice = visibleSlice(rendered, scroll, bodyHeight);
+				scroll = slice.scroll;
+				const more = slice.maxScroll > 0
+					? `${slice.scroll + 1}–${slice.scroll + slice.lines.length} / ${rendered.length}`
+					: "";
+				const hint = status || `${rawKeyHint("c", "copy")}   g/G top/bottom   ${keyText("tui.select.confirm")}/${keyText("tui.select.cancel")} back`;
+				const heading = `${theme.fg("accent", "▎")} ${theme.bold(roleColor(theme, role, title))}${fitGap(`▎ ${title}`, more, inner)}${theme.fg("dim", more)}`;
+				return [heading, rule(theme, inner), ...slice.lines.map((line) => `  ${line}`), rule(theme, inner), theme.fg("dim", hint)];
+			},
+			invalidate: () => {},
+			handleInput: (data: string) => {
+				if (keybindings.matches(data, "tui.select.cancel") || keybindings.matches(data, "tui.select.confirm") || data === "\n") {
+					done();
+					return;
+				}
+				if (data === "c" || data === "C" || keybindings.matches(data, "app.message.copy")) {
+					void copyText(text).then((ok) => {
+						status = ok ? "copied" : "copy failed";
+						tui.requestRender();
+					});
+					return;
+				}
+				if (data === "g") {
+					scroll = 0;
+				} else if (data === "G") {
+					scroll = Number.MAX_SAFE_INTEGER;
+				} else if (keybindings.matches(data, "tui.select.up") || data === "k") {
+					scroll -= 1;
+				} else if (keybindings.matches(data, "tui.select.down") || data === "j") {
+					scroll += 1;
+				} else if (keybindings.matches(data, "tui.select.pageUp")) {
+					scroll -= 8;
+				} else if (keybindings.matches(data, "tui.select.pageDown")) {
+					scroll += 8;
+				} else {
+					return;
+				}
+				status = "";
+				tui.requestRender();
+			},
+		};
+	});
+}
+
+async function openTurns(_args: string, ctx: Parameters<Parameters<ExtensionAPI["registerCommand"]>[1]["handler"]>[1]): Promise<void> {
+	const turns = turnsFromEntries(ctx.sessionManager?.getBranch?.() ?? []);
+	if (turns.length === 0) {
+		ctx.ui.notify("No user/assistant messages in this session yet", "info");
+		return;
+	}
+	const sessionKey = ctx.sessionManager?.getSessionFile?.() ?? ctx.sessionManager?.getSessionId?.() ?? "ephemeral";
+	const stars = { ids: await loadStars(sessionKey), sessionKey };
+	const view = { starredOnly: false, query: "", searching: false };
+	let cursor = turns.length - 1;
+	while (true) {
+		const chosen = await pickIndex(ctx, "Turns", turns, cursor, stars, view);
+		if (chosen === undefined) return;
+		cursor = chosen;
+		const turn = turns[chosen];
+		if (!turn) return;
+		await showMessage(ctx, `${roleBadge(turn.role)}  ${formatWhen(turn.timestamp)}`, turn.text, turn.role);
+	}
+}
+
+export default function turns(pi: ExtensionAPI): void {
+	pi.registerCommand("turns", {
+		description: "Browse this session's user and assistant turns",
+		handler: openTurns,
+	});
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "pi-turns",
+  "version": "1.5.1",
+  "description": "Browse the current Pi session as user and assistant turns.",
+  "type": "module",
+  "license": "MIT",
+  "author": "FarL1",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/FarL1/pi-turns.git"
+  },
+  "homepage": "https://github.com/FarL1/pi-turns#readme",
+  "bugs": {
+    "url": "https://github.com/FarL1/pi-turns/issues"
+  },
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "pi",
+    "pi-coding-agent",
+    "turns",
+    "transcript",
+    "session"
+  ],
+  "files": [
+    "extensions",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node tests/turns.mjs"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
+  },
+  "pi": {
+    "extensions": [
+      "./extensions/index.ts"
+    ],
+    "image": "https://raw.githubusercontent.com/FarL1/pi-turns/main/screenshots/turns.png"
+  }
+}