tau-coding-agent 0.1.4 → 0.1.5

package/extensions/{interlude.ts → stash.ts}

@@ -1,16 +1,19 @@
 import fs from "node:fs";
-import os from "node:os";
 import path from "node:path";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import {
+  getAgentDir,
+  type ExtensionAPI,
+  type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
 
 const DEFAULT_SHORTCUTS = ["alt+x"] as const;
-const STATUS_KEY = "interlude";
-const KEYBINDINGS_PATH = path.join(os.homedir(), ".pi", "agent", "keybindings.json");
+const STATUS_KEY = "stash";
+const KEYBINDINGS_PATH = path.join(getAgentDir(), "keybindings.json");
 
 type ShortcutConfig = string | string[] | undefined;
 
 type KeybindingsConfig = {
-  interlude?: ShortcutConfig;
+  stash?: ShortcutConfig;
   [key: string]: unknown;
 };
 
@@ -37,9 +40,9 @@ function normalizeShortcuts(value: ShortcutConfig): string[] {
   return normalized.length > 0 ? [...new Set(normalized)] : [...DEFAULT_SHORTCUTS];
 }
 
-export default function interludeExtension(pi: ExtensionAPI): void {
+export default function stashExtension(pi: ExtensionAPI): void {
   const keybindings = readKeybindings(KEYBINDINGS_PATH);
-  const shortcuts = normalizeShortcuts(keybindings.interlude);
+  const shortcuts = normalizeShortcuts(keybindings.stash);
 
   let stashedDraft: string | null = null;
   let armed = false;
@@ -52,7 +55,7 @@ export default function interludeExtension(pi: ExtensionAPI): void {
     if (!ctx.hasUI) return;
 
     if (armed && stashedDraft !== null) {
-      ctx.ui.setStatus(STATUS_KEY, `interlude (${shortcutLabel()})`);
+      ctx.ui.setStatus(STATUS_KEY, `stash (${shortcutLabel()})`);
       return;
     }
 
@@ -80,7 +83,7 @@ export default function interludeExtension(pi: ExtensionAPI): void {
 
     if (armed && stashedDraft !== null) {
       restoreDraft(ctx);
-      ctx.ui.notify("Interlude draft restored", "info");
+      ctx.ui.notify("Stashed draft restored", "info");
       return;
     }
 
@@ -101,8 +104,7 @@ export default function interludeExtension(pi: ExtensionAPI): void {
 
   for (const shortcut of shortcuts) {
     pi.registerShortcut(shortcut as never, {
-      description:
-        "Stash the current message draft, send one interlude message, then restore the draft",
+      description: "Stash the current message draft, send one message, then restore it",
       handler: async (ctx) => {
         stashOrRestore(ctx);
       },

package/extensions/tool-display-mode.ts

@@ -1,7 +1,7 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
-import os from "node:os";
 import path from "node:path";
 import {
+  getAgentDir,
   type AppKeybinding,
   CustomEditor,
   createBashToolDefinition,
@@ -77,8 +77,7 @@ function emptyConfig(): ToolDisplayModeConfig {
 }
 
 function getConfigPath(): string {
-  const agentDir = process.env.PI_CODING_AGENT_DIR ?? path.join(os.homedir(), ".pi", "agent");
-  return path.join(agentDir, CONFIG_FILE);
+  return path.join(getAgentDir(), CONFIG_FILE);
 }
 
 function isObject(value: unknown): value is JsonObject {

package/extensions/usage/index.ts

@@ -1,5 +1,9 @@
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { BorderedLoader } from "@earendil-works/pi-coding-agent";
+import {
+  BorderedLoader,
+  getAgentDir,
+  type ExtensionAPI,
+  type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
 import {
   Key,
   matchesKey,
@@ -31,7 +35,7 @@ import type {
 } from "./types.js";
 
 const ALL_TAB_ID = "all";
-const SESSION_ROOT = path.join(os.homedir(), ".pi", "agent", "sessions");
+const SESSION_ROOT = path.join(getAgentDir(), "sessions");
 const RANGE_DAYS = [7, 30, 90] as const;
 const FILE_PARSE_CONCURRENCY = 16;
 
@@ -2205,7 +2209,7 @@ export default function usageBreakdownExtension(pi: ExtensionAPI) {
     handler: async (_args, ctx: ExtensionContext) => {
       const liveUsageAvailability = await getLiveUsageAvailabilityMap(ctx);
 
-      if (!ctx.hasUI) {
+      if (ctx.mode !== "tui") {
         const [data, liveUsage] = await Promise.all([
           computeBreakdown(liveUsageAvailability, undefined),
           fetchLiveUsage(SUPPORTED_PROVIDERS, liveUsageAvailability, ctx, undefined),

package/extensions/websearch/README.md

@@ -16,7 +16,7 @@ Current routes:
 
 Optional config file:
 
-- `~/.pi/websearch.json`
+- `~/.pi/agent/websearch.json`
 
 Example:
 

package/extensions/websearch/browser/chromium.ts

@@ -1,11 +1,13 @@
-import { execFileSync } from "node:child_process";
-import { createDecipheriv, createHash, pbkdf2Sync } from "node:crypto";
-import { existsSync, readdirSync } from "node:fs";
+import { execFile } from "node:child_process";
+import { createDecipheriv, createHash, pbkdf2 } from "node:crypto";
+import { readdir } from "node:fs/promises";
 import { DatabaseSync } from "node:sqlite";
 import os from "node:os";
 import path from "node:path";
+import { promisify } from "node:util";
 
 import type { BrowserCookie, BrowserProfile } from "../types.js";
+import { pathExists } from "./fs.js";
 import { withSqliteSnapshot } from "./sqlite.js";
 
 const MACOS_BROWSER_CONFIGS: ChromiumBrowserConfig[] = [
@@ -72,6 +74,8 @@ interface ChromiumBrowserConfig {
   secretToolApp?: string;
 }
 
+const execFileAsync = promisify(execFile);
+const pbkdf2Async = promisify(pbkdf2);
 const passwordCache = new Map<string, string | null>();
 
 function browserConfigs(): ChromiumBrowserConfig[] {
@@ -80,13 +84,15 @@ function browserConfigs(): ChromiumBrowserConfig[] {
   return [];
 }
 
-export function discoverChromiumProfiles(preferredProfileName?: string): BrowserProfile[] {
+export async function discoverChromiumProfiles(
+  preferredProfileName?: string,
+): Promise<BrowserProfile[]> {
   const profiles: BrowserProfile[] = [];
 
   for (const config of browserConfigs()) {
-    if (!existsSync(config.baseDir)) continue;
+    if (!(await pathExists(config.baseDir))) continue;
 
-    const candidates = ["Default", ...discoverProfileDirectories(config.baseDir)];
+    const candidates = ["Default", ...(await discoverProfileDirectories(config.baseDir))];
     const seen = new Set<string>();
     for (const directoryName of candidates) {
       if (!directoryName || seen.has(directoryName)) continue;
@@ -94,7 +100,7 @@ export function discoverChromiumProfiles(preferredProfileName?: string): Browser
 
       const profilePath = path.join(config.baseDir, directoryName);
       const cookiesPath = path.join(profilePath, "Cookies");
-      if (!existsSync(cookiesPath)) continue;
+      if (!(await pathExists(cookiesPath))) continue;
 
       profiles.push({
         family: "chromium",
@@ -136,9 +142,9 @@ function isPreferredChromiumProfile(
   return profile.profileName === preferredProfileName;
 }
 
-function discoverProfileDirectories(baseDir: string): string[] {
+async function discoverProfileDirectories(baseDir: string): Promise<string[]> {
   try {
-    return readdirSync(baseDir, { withFileTypes: true })
+    return (await readdir(baseDir, { withFileTypes: true }))
       .filter((entry) => entry.isDirectory())
       .map((entry) => entry.name)
       .filter((name) => name === "Default" || /^Profile\s+\d+$/.test(name));
@@ -147,27 +153,28 @@ function discoverProfileDirectories(baseDir: string): string[] {
   }
 }
 
-export function loadChromiumCookies(profile: BrowserProfile): BrowserCookie[] {
+export async function loadChromiumCookies(profile: BrowserProfile): Promise<BrowserCookie[]> {
   const browserConfig = browserConfigs().find((config) =>
     profile.profilePath.startsWith(config.baseDir),
   );
   if (!browserConfig) return [];
 
-  const password = readBrowserPassword(browserConfig);
+  const cookiesPath = path.join(profile.profilePath, "Cookies");
+  if (!(await pathExists(cookiesPath))) return [];
+
+  const password = await readBrowserPassword(browserConfig);
   if (!password) return [];
 
-  const keyMaterial = pbkdf2Sync(
+  const keyMaterial = await pbkdf2Async(
     password,
     "saltysalt",
     process.platform === "darwin" ? 1003 : 1,
     16,
     "sha1",
   );
-  const cookiesPath = path.join(profile.profilePath, "Cookies");
-  if (!existsSync(cookiesPath)) return [];
 
   try {
-    return withSqliteSnapshot(cookiesPath, "websearch-chromium", (tempDbPath) => {
+    return await withSqliteSnapshot(cookiesPath, "websearch-chromium", (tempDbPath) => {
       const db = new DatabaseSync(tempDbPath, { readOnly: true });
       try {
         const rows = db
@@ -277,7 +284,7 @@ function stripHostKeyDigest(buffer: Buffer, hostKey: string | null): Buffer {
   return buffer.subarray(0, 32).equals(digest) ? buffer.subarray(32) : buffer;
 }
 
-function readBrowserPassword(config: ChromiumBrowserConfig): string | null {
+async function readBrowserPassword(config: ChromiumBrowserConfig): Promise<string | null> {
   const cacheKey = `${config.name}:${config.baseDir}`;
   if (passwordCache.has(cacheKey)) {
     return passwordCache.get(cacheKey) ?? null;
@@ -286,9 +293,13 @@ function readBrowserPassword(config: ChromiumBrowserConfig): string | null {
   let password: string | null = null;
   if (process.platform === "darwin") {
     if (!config.keychainAccount || !config.keychainService) return null;
-    password = readMacKeychainPassword(config.name, config.keychainAccount, config.keychainService);
+    password = await readMacKeychainPassword(
+      config.name,
+      config.keychainAccount,
+      config.keychainService,
+    );
   } else if (process.platform === "linux") {
-    password = readLinuxPassword(config.secretToolApp);
+    password = await readLinuxPassword(config.secretToolApp);
   }
 
   if (password) {
@@ -297,33 +308,33 @@ function readBrowserPassword(config: ChromiumBrowserConfig): string | null {
   return password;
 }
 
-function readMacKeychainPassword(
+async function readMacKeychainPassword(
   browserName: string,
   account: string,
   service: string,
-): string | null {
+): Promise<string | null> {
   try {
-    return (
-      execFileSync("security", ["find-generic-password", "-w", "-a", account, "-s", service], {
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"],
-      }).trim() || null
+    const { stdout } = await execFileAsync(
+      "security",
+      ["find-generic-password", "-w", "-a", account, "-s", service],
+      { encoding: "utf8" },
     );
+    return stdout.trim() || null;
   } catch {
     throw new Error(`Could not read ${browserName} cookie decryption password from Keychain.`);
   }
 }
 
-function readLinuxPassword(secretToolApp?: string): string | null {
+async function readLinuxPassword(secretToolApp?: string): Promise<string | null> {
   if (!secretToolApp) return "peanuts";
 
   try {
-    return (
-      execFileSync("secret-tool", ["lookup", "application", secretToolApp], {
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"],
-      }).trim() || "peanuts"
+    const { stdout } = await execFileAsync(
+      "secret-tool",
+      ["lookup", "application", secretToolApp],
+      { encoding: "utf8" },
     );
+    return stdout.trim() || "peanuts";
   } catch {
     return "peanuts";
   }

package/extensions/websearch/browser/discovery.ts

@@ -11,32 +11,34 @@ import type {
 const COOKIE_CACHE_TTL_MS = 30_000;
 const cookieCache = new Map<string, { cookies: BrowserCookie[]; expiresAt: number }>();
 
-export function discoverProfiles(
+export async function discoverProfiles(
   browserFamilies: WebsearchBrowserFamily[],
   preferredProfiles: WebsearchConfig["profiles"],
-): BrowserProfile[] {
+): Promise<BrowserProfile[]> {
   const profiles: BrowserProfile[] = [];
 
   for (const family of browserFamilies) {
     if (family === "firefox") {
-      profiles.push(...discoverFirefoxProfiles(preferredProfiles.firefox));
+      profiles.push(...(await discoverFirefoxProfiles(preferredProfiles.firefox)));
       continue;
     }
 
-    profiles.push(...discoverChromiumProfiles(preferredProfiles.chromium));
+    profiles.push(...(await discoverChromiumProfiles(preferredProfiles.chromium)));
   }
 
   return profiles;
 }
 
-export function loadCookies(profile: BrowserProfile): BrowserCookie[] {
+export async function loadCookies(profile: BrowserProfile): Promise<BrowserCookie[]> {
   const cacheKey = `${profile.family}:${profile.profilePath}`;
   const cached = cookieCache.get(cacheKey);
   if (cached && cached.expiresAt > Date.now()) return cached.cookies;
   if (cached) cookieCache.delete(cacheKey);
 
   const cookies =
-    profile.family === "firefox" ? loadFirefoxCookies(profile) : loadChromiumCookies(profile);
+    profile.family === "firefox"
+      ? await loadFirefoxCookies(profile)
+      : await loadChromiumCookies(profile);
 
   if (cookies.length > 0) {
     cookieCache.set(cacheKey, {
@@ -48,11 +50,11 @@ export function loadCookies(profile: BrowserProfile): BrowserCookie[] {
   return cookies;
 }
 
-export function createBrowserSession(
+export async function createBrowserSession(
   profile: BrowserProfile,
   domains: string[],
-): BrowserSession | null {
-  const cookies = loadCookies(profile).filter((cookie) => {
+): Promise<BrowserSession | null> {
+  const cookies = (await loadCookies(profile)).filter((cookie) => {
     return domains.some((domain) => matchesBrowserDomain(domain, cookie.domain));
   });
   if (cookies.length === 0) return null;

package/extensions/websearch/browser/firefox.ts

@@ -1,9 +1,10 @@
-import { existsSync, readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { DatabaseSync } from "node:sqlite";
 import os from "node:os";
 import path from "node:path";
 
 import type { BrowserCookie, BrowserProfile } from "../types.js";
+import { pathExists } from "./fs.js";
 import { withSqliteSnapshot } from "./sqlite.js";
 
 function firefoxBaseDir(): string | null {
@@ -45,7 +46,9 @@ function parseIni(text: string): Array<Record<string, string>> {
   return sections;
 }
 
-export function discoverFirefoxProfiles(preferredProfileName?: string): BrowserProfile[] {
+export async function discoverFirefoxProfiles(
+  preferredProfileName?: string,
+): Promise<BrowserProfile[]> {
   const baseDir = firefoxBaseDir();
   if (!baseDir) return [];
 
@@ -53,7 +56,7 @@ export function discoverFirefoxProfiles(preferredProfileName?: string): BrowserP
 
   let sections: Array<Record<string, string>> = [];
   try {
-    sections = parseIni(readFileSync(profilesIniPath, "utf8"));
+    sections = parseIni(await readFile(profilesIniPath, "utf8"));
   } catch {
     return [];
   }
@@ -67,7 +70,7 @@ export function discoverFirefoxProfiles(preferredProfileName?: string): BrowserP
     const profilePath =
       section.IsRelative === "1" ? path.join(baseDir, profilePathValue) : profilePathValue;
     const cookiesPath = path.join(profilePath, "cookies.sqlite");
-    if (!existsSync(cookiesPath)) continue;
+    if (!(await pathExists(cookiesPath))) continue;
 
     profiles.push({
       family: "firefox",
@@ -100,12 +103,12 @@ function isPreferredFirefoxProfile(
   );
 }
 
-export function loadFirefoxCookies(profile: BrowserProfile): BrowserCookie[] {
+export async function loadFirefoxCookies(profile: BrowserProfile): Promise<BrowserCookie[]> {
   const cookiesPath = path.join(profile.profilePath, "cookies.sqlite");
-  if (!existsSync(cookiesPath)) return [];
+  if (!(await pathExists(cookiesPath))) return [];
 
   try {
-    return withSqliteSnapshot(cookiesPath, "websearch-firefox", (tempDbPath) => {
+    return await withSqliteSnapshot(cookiesPath, "websearch-firefox", (tempDbPath) => {
       const db = new DatabaseSync(tempDbPath, { readOnly: true });
       try {
         const rows = db

package/extensions/websearch/browser/fs.ts

@@ -0,0 +1,10 @@
+import { access } from "node:fs/promises";
+
+export async function pathExists(filePath: string): Promise<boolean> {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/extensions/websearch/browser/sqlite.ts

@@ -1,33 +1,40 @@
-import { copyFileSync, existsSync, mkdirSync, rmSync } from "node:fs";
+import { copyFile, mkdtemp, rm } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 
-export function withSqliteSnapshot<T>(
+import { pathExists } from "./fs.js";
+
+export async function withSqliteSnapshot<T>(
   sourceDbPath: string,
   tempPrefix: string,
-  operation: (snapshotPath: string) => T,
-): T {
-  const tempDir = path.join(os.tmpdir(), `${tempPrefix}-${process.pid}-${Date.now()}`);
+  operation: (snapshotPath: string) => T | Promise<T>,
+): Promise<T> {
+  const tempDir = await mkdtemp(path.join(os.tmpdir(), `${tempPrefix}-${process.pid}-`));
   const snapshotPath = path.join(tempDir, path.basename(sourceDbPath));
 
   try {
-    mkdirSync(tempDir, { recursive: true });
-    copyFileSync(sourceDbPath, snapshotPath);
-    copySidecar(sourceDbPath, snapshotPath, "-wal");
-    copySidecar(sourceDbPath, snapshotPath, "-shm");
-    copySidecar(sourceDbPath, snapshotPath, "-journal");
-    return operation(snapshotPath);
+    await copyFile(sourceDbPath, snapshotPath);
+    await Promise.all([
+      copySidecar(sourceDbPath, snapshotPath, "-wal"),
+      copySidecar(sourceDbPath, snapshotPath, "-shm"),
+      copySidecar(sourceDbPath, snapshotPath, "-journal"),
+    ]);
+    return await operation(snapshotPath);
   } finally {
-    rmSync(tempDir, { recursive: true, force: true });
+    await rm(tempDir, { recursive: true, force: true });
   }
 }
 
-export function copySidecar(sourceDbPath: string, targetDbPath: string, suffix: string): void {
+export async function copySidecar(
+  sourceDbPath: string,
+  targetDbPath: string,
+  suffix: string,
+): Promise<void> {
   const source = `${sourceDbPath}${suffix}`;
-  if (!existsSync(source)) return;
+  if (!(await pathExists(source))) return;
 
   try {
-    copyFileSync(source, `${targetDbPath}${suffix}`);
+    await copyFile(source, `${targetDbPath}${suffix}`);
   } catch (error) {
     const code =
       error && typeof error === "object" && "code" in error

package/extensions/websearch/config.ts

@@ -1,10 +1,10 @@
 import { readFileSync } from "node:fs";
-import { homedir } from "node:os";
 import path from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
 
 import type { WebsearchConfig, WebsearchRouteId } from "./types.js";
 
-const WEBSEARCH_CONFIG_PATH = path.join(homedir(), ".pi", "websearch.json");
+const WEBSEARCH_CONFIG_PATH = path.join(getAgentDir(), "websearch.json");
 
 const DEFAULT_ROUTES: WebsearchRouteId[] = [
   "pi:openai-codex",

package/extensions/websearch/index.ts

@@ -128,15 +128,15 @@ function throwIfAborted(signal?: AbortSignal): void {
   throw signal.reason ?? new Error("The operation was aborted.");
 }
 
-function getBrowserProfiles(
+async function getBrowserProfiles(
   cache: Partial<Record<WebsearchBrowserFamily, BrowserProfile[]>>,
   family: WebsearchBrowserFamily,
   config: WebsearchConfig,
-): BrowserProfile[] {
+): Promise<BrowserProfile[]> {
   const cached = cache[family];
   if (cached) return cached;
 
-  const profiles = discoverProfiles([family], config.profiles);
+  const profiles = await discoverProfiles([family], config.profiles);
   cache[family] = profiles;
   return profiles;
 }
@@ -153,7 +153,7 @@ async function searchBrowserRoute(
     : "chromium";
   const browserProvider = route.endsWith(":gemini") ? browserGemini : browserOpenAICodex;
   const configuredProfileName = config.profiles[profileFamily];
-  const profiles = getBrowserProfiles(profileCache, profileFamily, config);
+  const profiles = await getBrowserProfiles(profileCache, profileFamily, config);
   let lastError: string | null = null;
 
   if (configuredProfileName && profiles.length === 0) {
@@ -164,7 +164,7 @@ async function searchBrowserRoute(
     throwIfAborted(signal);
 
     try {
-      const session = createBrowserSession(profile, browserProvider.domains);
+      const session = await createBrowserSession(profile, browserProvider.domains);
       if (!session) {
         if (configuredProfileName) {
           throw new Error(
@@ -265,7 +265,7 @@ export default function (pi: ExtensionAPI) {
       promptSnippet:
         "Search the web for current or external information unavailable in local files",
       promptGuidelines: [
-        "Use this for recent facts, live service behavior, or external documentation that is not already present in the repo.",
+        "Use websearch for recent facts, live service behavior, or external documentation that is not already present in the repo.",
         "Do not use websearch when repository files or supplied context already answer the question.",
       ],
       parameters: Type.Object({

package/extensions/worktree.ts

@@ -40,9 +40,9 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 
 const STATUS_KEY = "0-worktree";
-const MANUAL_OPEN_MESSAGE_TYPE = "worktree-open-command";
-const RESTORE_STASH_MESSAGE_TYPE = "worktree-restore-command";
-const SCRIPT_RERUN_MESSAGE_TYPE = "worktree-script-rerun-command";
+const MANUAL_OPEN_ENTRY_TYPE = "worktree-open-command";
+const RESTORE_STASH_ENTRY_TYPE = "worktree-restore-command";
+const SCRIPT_RERUN_ENTRY_TYPE = "worktree-script-rerun-command";
 const MANUAL_OPEN_INTRO =
   "Worktree ready. Open it in a separate terminal or tmux pane with this command";
 
@@ -224,15 +224,10 @@ function showCommandMessage(
     return;
   }
 
-  pi.sendMessage({
-    customType,
-    content: intro,
-    display: true,
-    details: {
-      intro,
-      command,
-      copiedToClipboard,
-    } satisfies CommandMessageDetails,
+  pi.appendEntry<CommandMessageDetails>(customType, {
+    intro,
+    command,
+    copiedToClipboard,
   });
 }
 
@@ -241,7 +236,7 @@ function showManualOpenCommand(
   ctx: ExtensionCommandContext,
   command: string,
 ): void {
-  showCommandMessage(pi, ctx, MANUAL_OPEN_MESSAGE_TYPE, MANUAL_OPEN_INTRO, command);
+  showCommandMessage(pi, ctx, MANUAL_OPEN_ENTRY_TYPE, MANUAL_OPEN_INTRO, command);
 }
 
 function showRestoreStashCommand(
@@ -253,7 +248,7 @@ function showRestoreStashCommand(
   showCommandMessage(
     pi,
     ctx,
-    RESTORE_STASH_MESSAGE_TYPE,
+    RESTORE_STASH_ENTRY_TYPE,
     `Main-worktree changes were stashed as ${stashSpec}. Restore them in the new worktree with this command`,
     `cd ${shellQuoteCompact(targetPath)} && git stash apply ${shellQuote(stashSpec)}`,
   );
@@ -270,7 +265,7 @@ function showScriptRerunCommand(
   showCommandMessage(
     pi,
     ctx,
-    SCRIPT_RERUN_MESSAGE_TYPE,
+    SCRIPT_RERUN_ENTRY_TYPE,
     `${label} failed (exit ${exitCode}). Re-run it manually with this command`,
     `cd ${shellQuoteCompact(worktreeRoot)} && ${command}`,
   );
@@ -2008,18 +2003,23 @@ async function handleList(pi: ExtensionAPI, ctx: ExtensionCommandContext): Promi
     return { repo, items };
   });
 
-  if (!ctx.hasUI) {
-    for (const item of items) {
-      const dirty = item.status === "dirty" ? " *" : "";
-      const meta: string[] = [];
-      if (item.tracked) meta.push("↑");
-      if (item.isMain) meta.push("[primary]");
-      if (item.pathState !== "ok") meta.push(item.pathState);
-      if (item.wt.locked)
-        meta.push(item.wt.lockedReason ? `locked:${item.wt.lockedReason}` : "locked");
-      const suffix = meta.length > 0 ? `  ${meta.join("  ")}` : "";
-      console.log(`  ${item.branch}${dirty}${suffix}  ${collapsePath(item.wt.path)}`);
-    }
+  if (ctx.mode !== "tui") {
+    const output = items
+      .map((item) => {
+        const dirty = item.status === "dirty" ? " *" : "";
+        const meta: string[] = [];
+        if (item.tracked) meta.push("↑");
+        if (item.isMain) meta.push("[primary]");
+        if (item.pathState !== "ok") meta.push(item.pathState);
+        if (item.wt.locked)
+          meta.push(item.wt.lockedReason ? `locked:${item.wt.lockedReason}` : "locked");
+        const suffix = meta.length > 0 ? `  ${meta.join("  ")}` : "";
+        return `  ${item.branch}${dirty}${suffix}  ${collapsePath(item.wt.path)}`;
+      })
+      .join("\n");
+
+    if (ctx.mode === "print") console.log(output);
+    else ctx.ui.notify(output, "info");
     return;
   }
 
@@ -2114,14 +2114,14 @@ function parseSubcommand(args: string): { subcommand: Subcommand | null; rest: s
 
 export default function worktreeExtension(pi: ExtensionAPI) {
   for (const customType of [
-    MANUAL_OPEN_MESSAGE_TYPE,
-    RESTORE_STASH_MESSAGE_TYPE,
-    SCRIPT_RERUN_MESSAGE_TYPE,
+    MANUAL_OPEN_ENTRY_TYPE,
+    RESTORE_STASH_ENTRY_TYPE,
+    SCRIPT_RERUN_ENTRY_TYPE,
   ]) {
-    pi.registerMessageRenderer(customType, (message, _options, theme) => {
-      const details = message.details as CommandMessageDetails | undefined;
+    pi.registerEntryRenderer<CommandMessageDetails>(customType, (entry, _options, theme) => {
+      const details = entry.data;
       if (!details || typeof details.intro !== "string" || typeof details.command !== "string") {
-        return new Text(typeof message.content === "string" ? message.content : "", 0, 0);
+        return undefined;
       }
 
       const box = new Box(1, 1, (text) => theme.bg("customMessageBg", text));