@herbertgao/pi-extensions 2026.8.13 → 2026.8.15

package/node_modules/@tifan/pi-handoff/src/index.ts

@@ -1,6 +1,11 @@
+import { randomUUID } from "node:crypto"
 import type { AgentMessage } from "@earendil-works/pi-agent-core"
 import type { Message } from "@earendil-works/pi-ai/compat"
-import { sanitizeRenameText } from "@tifan/pi-rename/naming"
+import {
+  generateRename,
+  getUserMessageContext,
+  resolveInitialModelConfig,
+} from "@tifan/pi-rename/naming"
 import type {
   ExtensionAPI,
   ExtensionCommandContext,
@@ -10,6 +15,7 @@ import {
   BorderedLoader,
   convertToLlm,
   serializeConversation,
+  SessionManager,
   sessionEntryToContextMessages,
 } from "@earendil-works/pi-coding-agent"
 import { completeText } from "./complete-text.js"
@@ -77,6 +83,17 @@ async function nextHandoffPath(slug: string): Promise<string> {
   throw new Error("Could not allocate a unique handoff file path")
 }
 
+async function generateSessionName(
+  ctx: ExtensionCommandContext,
+  messages: readonly AgentMessage[],
+): Promise<string> {
+  const context = getUserMessageContext(messages)
+  if (!context) return "handoff-session"
+
+  const result = await generateRename(ctx, resolveInitialModelConfig(), context)
+  return result?.name ?? "handoff-session"
+}
+
 function buildNewSessionPrompt(handoffPath: string): string {
   return [
     "Continue from this handoff:",
@@ -85,6 +102,133 @@ function buildNewSessionPrompt(handoffPath: string): string {
   ].join("\n\n")
 }
 
+type HerdrTabCreateResponse = {
+  result?: {
+    root_pane?: {
+      pane_id?: unknown
+    }
+  }
+}
+
+function getHerdrWorkspaceId(): string | undefined {
+  if (process.env["HERDR_ENV"] !== "1") return undefined
+
+  const workspaceId = process.env["HERDR_WORKSPACE_ID"]?.trim()
+  if (!workspaceId) {
+    throw new Error("Herdr workspace context is unavailable")
+  }
+  return workspaceId
+}
+
+function getHerdrRootPaneId(stdout: string): string | undefined {
+  try {
+    const response = JSON.parse(stdout) as HerdrTabCreateResponse
+    const paneId = response.result?.root_pane?.pane_id
+    return typeof paneId === "string" && paneId.trim() ? paneId : undefined
+  } catch {
+    return undefined
+  }
+}
+
+function getCommandError(stdout: string, stderr: string): string {
+  return stderr.trim() || stdout.trim() || "unknown error"
+}
+
+async function startHandoffInHerdr(options: {
+  pi: ExtensionAPI
+  ctx: ExtensionCommandContext
+  handoffPath: string
+  parentSession: string | undefined
+  sessionName: string
+  workspaceId: string
+}): Promise<void> {
+  const childSessionManager = SessionManager.create(
+    options.ctx.cwd,
+    undefined,
+    options.parentSession
+      ? { parentSession: options.parentSession }
+      : undefined,
+  )
+  const childSessionPath = childSessionManager.getSessionFile()
+  const childSessionHeader = childSessionManager.getHeader()
+  if (!childSessionPath || !childSessionHeader) {
+    throw new Error("Could not create a persisted handoff session")
+  }
+  await mkdir(childSessionManager.getSessionDir(), { recursive: true })
+  await writeFile(childSessionPath, `${JSON.stringify(childSessionHeader)}\n`, {
+    flag: "wx",
+  })
+
+  const createdTab = await options.pi.exec(
+    "herdr",
+    [
+      "tab",
+      "create",
+      "--workspace",
+      options.workspaceId,
+      "--cwd",
+      options.ctx.cwd,
+      "--label",
+      options.sessionName,
+      "--focus",
+    ],
+    { timeout: 5_000 },
+  )
+  if (createdTab.code !== 0) {
+    throw new Error(
+      `Could not create Herdr tab: ${getCommandError(createdTab.stdout, createdTab.stderr)}`,
+    )
+  }
+
+  const rootPaneId = getHerdrRootPaneId(createdTab.stdout)
+  if (!rootPaneId) {
+    throw new Error("Could not find the new Herdr tab's root pane")
+  }
+
+  const agentName = `handoff-${randomUUID().slice(0, 8)}`
+  const model = options.ctx.model!
+
+  const startedAgent = await options.pi.exec(
+    "herdr",
+    [
+      "agent",
+      "start",
+      agentName,
+      "--kind",
+      "pi",
+      "--pane",
+      rootPaneId,
+      "--",
+      "--session",
+      childSessionPath,
+      "--name",
+      options.sessionName,
+      "--provider",
+      model.provider,
+      "--model",
+      model.id,
+    ],
+    { timeout: 35_000 },
+  )
+  if (startedAgent.code !== 0) {
+    throw new Error(
+      `Could not start Pi in Herdr tab: ${getCommandError(startedAgent.stdout, startedAgent.stderr)}`,
+    )
+  }
+
+  const promptedAgent = await options.pi.exec("herdr", [
+    "agent",
+    "prompt",
+    agentName,
+    buildNewSessionPrompt(options.handoffPath),
+  ])
+  if (promptedAgent.code !== 0) {
+    throw new Error(
+      `Could not send the handoff prompt: ${getCommandError(promptedAgent.stdout, promptedAgent.stderr)}`,
+    )
+  }
+}
+
 function buildDocumentWithMetadata(options: {
   generated: string
   focus: string
@@ -250,9 +394,7 @@ async function runHandoff(
     return
   }
 
-  const sessionName =
-    sanitizeRenameText(ctx.sessionManager.getSessionName() ?? focus) ||
-    "handoff-session"
+  const sessionName = await generateSessionName(ctx, messages)
   const handoffPath = await nextHandoffPath(sessionName)
   const document = buildDocumentWithMetadata({
     generated,
@@ -262,6 +404,20 @@ async function runHandoff(
   })
   await writeFile(handoffPath, document, "utf8")
 
+  const herdrWorkspaceId = getHerdrWorkspaceId()
+  if (herdrWorkspaceId) {
+    await startHandoffInHerdr({
+      pi,
+      ctx,
+      handoffPath,
+      parentSession,
+      sessionName,
+      workspaceId: herdrWorkspaceId,
+    })
+    ctx.ui.notify(`Handoff opened in a new Herdr tab: ${handoffPath}`, "info")
+    return
+  }
+
   await ctx.newSession({
     ...(parentSession ? { parentSession } : {}),
     setup: async (sessionManager) => {

package/node_modules/@tifan/pi-preferred-thinking/README.md

@@ -41,7 +41,7 @@ The extension requires `enabledModels` to exist before it can save a pin. If
 the selected model is not listed, it adds an exact entry without removing other
 models or patterns.
 
-The old `~/.config/pi/extensions/pi-preferred-thinking.json` file is no longer
+The old `$PI_CODING_AGENT_DIR/extensions/pi-preferred-thinking.json` file is no longer
 read. Existing users must move preferences to `enabledModels` or set them with
 `/preferred-thinking`.
 

package/node_modules/@tifan/pi-preferred-thinking/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tifan/pi-preferred-thinking",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Set and apply per-model thinking levels from Pi's native settings.",
   "keywords": [
     "pi",

package/node_modules/@tifan/pi-preferred-thinking/src/index.ts

@@ -138,6 +138,15 @@ function showHint(ctx: ExtensionContext, modelKey: string): void {
   }, HINT_DURATION_MS)
 }
 
+function hasExplicitSubagentThinking(): boolean {
+  return (
+    Boolean(process.env["PI_SUBAGENT_ID"]) &&
+    process.argv.some(
+      (arg) => arg === "--thinking" || arg.startsWith("--thinking="),
+    )
+  )
+}
+
 function applyPreferredThinking(
   pi: ExtensionAPI,
   ctx: ExtensionContext,
@@ -210,11 +219,15 @@ export default function (pi: ExtensionAPI): void {
 
   pi.on("session_start", async (_event, ctx) => {
     nudgedModels.clear()
-    if (ctx.model) applyPreferredThinking(pi, ctx, ctx.model)
+    if (ctx.model && !hasExplicitSubagentThinking()) {
+      applyPreferredThinking(pi, ctx, ctx.model)
+    }
   })
 
   pi.on("model_select", async (event, ctx) => {
-    applyPreferredThinking(pi, ctx, event.model)
+    if (!hasExplicitSubagentThinking()) {
+      applyPreferredThinking(pi, ctx, event.model)
+    }
   })
 
   pi.on("session_shutdown", async (_event, ctx) => {

package/node_modules/@tifan/pi-recap/README.md

@@ -44,7 +44,7 @@ Run `/recap config` to choose a different model.
 
 After you choose a model, `pi-recap` uses only that model. Choose `Use default` in `/recap config` to return to the default.
 
-You can also edit `~/.config/pi/extensions/pi-recap.json` manually:
+You can also edit `$PI_CODING_AGENT_DIR/extensions/pi-recap.json` manually:
 
 ```json
 {

package/node_modules/@tifan/pi-recap/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tifan/pi-recap",
-  "version": "0.4.5",
+  "version": "0.4.6",
   "description": "One-line session recap on demand or after you have been away.",
   "keywords": [
     "pi",
@@ -29,7 +29,7 @@
     "provenance": true
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": ">=0.84.2"
+    "@earendil-works/pi-coding-agent": ">=0.84.3"
   },
   "engines": {
     "node": ">=20"

package/node_modules/@tifan/pi-recap/src/index.ts

@@ -100,6 +100,7 @@ interface RecapState {
   visible: boolean
   stale: boolean
   lastRecapCurrent: boolean
+  skipNextAwayRecap: boolean
   abortController: AbortController | undefined
   awayTimer: ReturnType<typeof setTimeout> | undefined
 }
@@ -113,6 +114,7 @@ function createRecapState(): RecapState {
     visible: false,
     stale: false,
     lastRecapCurrent: false,
+    skipNextAwayRecap: false,
     abortController: undefined,
     awayTimer: undefined,
   }
@@ -140,6 +142,7 @@ function resetRecapSession(ctx: ExtensionContext, state: RecapState): void {
   state.visible = false
   state.stale = false
   state.lastRecapCurrent = false
+  state.skipNextAwayRecap = false
   clearAwayTimer(state)
   abortPendingGeneration(state)
   clearWidget(ctx)
@@ -551,13 +554,25 @@ export default function (pi: ExtensionAPI): void {
     state.runId++
     state.stale = false
     state.lastRecapCurrent = false
+    state.skipNextAwayRecap = false
     clearAwayTimer(state)
     abortPendingGeneration(state)
     hideRecap(ctx, state)
     clearNoModelWarning(ctx)
   })
 
+  pi.on("session_compact_failed", (event) => {
+    if (event.willRetry) return
+    state.skipNextAwayRecap = true
+    clearAwayTimer(state)
+  })
+
   pi.on("agent_settled", (_event, ctx) => {
+    if (state.skipNextAwayRecap) {
+      state.skipNextAwayRecap = false
+      return
+    }
+
     state.stale = true
     scheduleAwayRecap(pi, ctx, state)
   })

package/node_modules/@tifan/pi-rename/README.md

@@ -1,6 +1,6 @@
 # @tifan/pi-rename
 
-Generate session names for pi and Herdr.
+Generate short pi session names and rename the current Herdr pane or tab to match.
 
 ## Install
 
@@ -8,61 +8,82 @@ Generate session names for pi and Herdr.
 pi install npm:@tifan/pi-rename
 ```
 
-This package requires Pi 0.84.2 or newer.
+Requires Pi 0.84.2 or newer.
 
-## How it works
+## Usage
 
-Run `/rename` to generate a fresh hyphen-separated session name. The extension applies the name to the pi session and, when pi is running inside Herdr, to the current pane and tab when it is the tab's only pane, or to the current pane in a split tab.
+Run:
 
-When a named session starts or resumes in Herdr, the extension applies the saved pi session name when the target still has its default or temporary startup label.
+```text
+/rename
+```
 
-`/rename` builds naming context from the first user message plus up to three latest user messages. It ignores assistant replies, tool output, and attachments. Before sending context to the rename model, it redacts common secrets.
+The extension:
 
-If the rename model is unavailable, `/rename` falls back to a local name from the latest user message.
+- Builds context from the first user message and up to three latest user messages.
+- Ignores assistant replies, tool output, and attachments.
+- Redacts common secrets before sending context to the model.
+- Creates a lowercase, hyphen-separated name of up to 30 characters.
+- Falls back to the latest user message when the naming model is unavailable.
 
 ## Commands
 
 - `/rename`: Generate and apply a session name.
 - `/rename status`: Show model and rename status.
 - `/rename config`: Choose a rename model.
+- `/rename config language <auto|BCP-47>`: Set session-name language.
 - `/rename help`: List rename commands.
 
-Manual names are not supported. Use pi's built-in `/name` command when you want an exact name.
+Use pi's built-in `/name` command when you want to set an exact name.
 
 ## Configuration
 
-Out of the box, `pi-rename` uses this default model: `openai-codex/gpt-5.6-luna`.
+Default model:
+
+```text
+openai-codex/gpt-5.6-luna
+```
+
+Use `/rename config` to choose another model or reset to the default.
+
+To preserve existing behavior, names use ASCII when no language is configured. Set an output language with a BCP 47 tag, or use `auto` to follow latest user message language:
 
-Run `/rename config` to choose a different model.
+```bash
+/rename config language <BCP-47-tag>
+/rename config language auto
+```
 
-After you choose a model, `pi-rename` uses only that model. Choose `Use default` in `/rename config` to return to the default.
+`auto` and non-`en` tags preserve Unicode letters and numbers. If rename model is unavailable, fallback uses latest user message and does not translate it.
 
 You can also edit `$PI_CODING_AGENT_DIR/extensions/pi-rename.json` manually:
 
 ```json
 {
-  "model": "openai-codex/gpt-5.6-luna"
+  "model": "openai-codex/gpt-5.6-luna",
+  "language": "auto"
 }
 ```
 
-## Herdr behavior
+Use `"language": "en"` for ASCII compatibility mode. Missing or invalid language values also fall back to `en`.
 
-Herdr tab renaming requires the `herdr` CLI. If it is unavailable, the extension still renames the pi session.
-
-The extension uses `HERDR_PANE_ID` to find the current Herdr pane. With one pane in the tab, it renames both the pane and tab. With sibling panes, it renames only the current pane.
+## Herdr behavior
 
-On session startup or resume, it does not overwrite custom Herdr labels. It replaces only Herdr's default or temporary startup labels, so saved session names still apply.
+- Requires the `herdr` CLI.
+- With one pane, renames both the pane and tab.
+- In a split tab, renames only the current pane.
+- Does not replace custom labels on startup or resume.
+- Replaces default or temporary startup labels.
+- Keeps the last name when pi exits.
 
-If your launcher gives Pi a temporary Herdr label, it must set `HERDR_TEMPORARY_LABEL` before starting Pi. The value must match the label shown in Herdr. In Bash, pass it to Pi inline:
+For temporary launcher labels, set `HERDR_TEMPORARY_LABEL`:
 
 ```bash
 HERDR_TEMPORARY_LABEL="my-project (pi)" pi
 ```
 
-If you do not set this variable, `pi-rename` replaces only Herdr's default label.
-On quit, the target keeps the last session name.
+Without it, only Herdr's default label is replaced.
 
-If pi is not running inside Herdr, only the pi session name is updated.
+Outside Herdr, only the pi session is renamed.
 
 ## Release notes
 

package/node_modules/@tifan/pi-rename/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tifan/pi-rename",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "Generate pi session names and rename the current Herdr tab.",
   "keywords": [
     "herdr",

package/node_modules/@tifan/pi-rename/src/index.ts

@@ -12,14 +12,20 @@ import type {
 import { buildSessionContext } from "@earendil-works/pi-coding-agent"
 import { pickRenameModel } from "./model-picker.js"
 import {
-  deleteRenameConfig,
+  DEFAULT_RENAME_LANGUAGE,
+  parseRenameLanguage,
+  type RenameLanguage,
+} from "./language.js"
+import {
+  deleteModelPreference,
   formatAuthModelKey,
   formatModelPreference,
   formatRenameModelKey,
   getAuthenticatedTextModelPreferences,
   getRenameModelAuth,
-  resolveInitialModelConfig,
+  resolveInitialRenameConfig,
   saveModelPreference,
+  saveRenameLanguage,
   type RenameModelConfig,
 } from "./models.js"
 import { isTemporaryHerdrLabel } from "./herdr-label.js"
@@ -32,6 +38,7 @@ interface SessionContextReader {
 
 interface RenameState {
   modelConfig: RenameModelConfig
+  language: RenameLanguage
 }
 
 const RENAME_SUBCOMMANDS: AutocompleteItem[] = [
@@ -55,6 +62,7 @@ const RENAME_SUBCOMMANDS: AutocompleteItem[] = [
 function createRenameState(): RenameState {
   return {
     modelConfig: { kind: "missing" },
+    language: DEFAULT_RENAME_LANGUAGE,
   }
 }
 
@@ -241,7 +249,12 @@ async function runRenameCommand(
     })
   }
   try {
-    const result = await generateRename(ctx, state.modelConfig, context)
+    const result = await generateRename(
+      ctx,
+      state.modelConfig,
+      context,
+      state.language,
+    )
     if (!result) {
       ctx.ui.notify("Could not generate a session name.", "error")
       return
@@ -315,7 +328,7 @@ async function configureRenameModel(
 
   try {
     if (result.action === "default") {
-      deleteRenameConfig()
+      deleteModelPreference()
       state.modelConfig = { kind: "missing" }
       ctx.ui.notify("Rename model reset to default.", "info")
       return
@@ -334,6 +347,28 @@ async function configureRenameModel(
   }
 }
 
+function configureRenameLanguage(
+  ctx: ExtensionContext,
+  state: RenameState,
+  value: string | undefined,
+): void {
+  const language = parseRenameLanguage(value)
+  if (!language) {
+    ctx.ui.notify("Use /rename config language <auto|BCP-47>", "error")
+    return
+  }
+
+  try {
+    saveRenameLanguage(language)
+    state.language = language
+    ctx.ui.notify(`Rename language set to ${language}.`, "info")
+  } catch (error) {
+    const reason =
+      error instanceof SyntaxError ? "invalid JSON" : "write failed"
+    ctx.ui.notify(`Could not update rename config: ${reason}.`, "error")
+  }
+}
+
 async function notifyRenameStatus(
   ctx: ExtensionContext,
   state: RenameState,
@@ -365,6 +400,7 @@ async function notifyRenameStatus(
       "pi-rename status",
       selectedModelLine,
       activeModelLine,
+      `language: ${state.language}`,
       herdrLine,
       contextLine,
     ].join("\n"),
@@ -377,20 +413,22 @@ function registerRenameCommand(pi: ExtensionAPI, state: RenameState): void {
     description: "generate a session name",
     getArgumentCompletions: getRenameArgumentCompletions,
     handler: async (args, ctx) => {
-      const action = args.trim().split(/\s+/u)[0]?.toLowerCase() ?? ""
+      const [action = "", ...actionArgs] = args.trim().split(/\s+/u)
+      const normalizedAction = action.toLowerCase()
 
-      if (!action) {
+      if (!normalizedAction) {
         await runRenameCommand(pi, ctx, state)
         return
       }
 
-      if (action === "help") {
+      if (normalizedAction === "help") {
         ctx.ui.notify(
           [
             "pi-rename commands",
             "/rename - generate and apply a session name",
             "/rename status - show model and rename status",
             "/rename config - choose the rename model",
+            "/rename config language <auto|BCP-47> - set name language",
             "/rename help - show this help",
           ].join("\n"),
           "info",
@@ -398,13 +436,24 @@ function registerRenameCommand(pi: ExtensionAPI, state: RenameState): void {
         return
       }
 
-      if (action === "status") {
+      if (normalizedAction === "status") {
         await notifyRenameStatus(ctx, state)
         return
       }
 
-      if (action === "config") {
-        await configureRenameModel(ctx, state)
+      if (normalizedAction === "config") {
+        const [setting, value, extra] = actionArgs
+        if (!setting) {
+          await configureRenameModel(ctx, state)
+          return
+        }
+
+        if (setting.toLowerCase() === "language" && !extra) {
+          configureRenameLanguage(ctx, state, value)
+          return
+        }
+
+        ctx.ui.notify("Use /rename config language <auto|BCP-47>", "error")
         return
       }
 
@@ -419,7 +468,9 @@ export default function (pi: ExtensionAPI): void {
   registerRenameCommand(pi, state)
 
   pi.on("session_start", async () => {
-    state.modelConfig = resolveInitialModelConfig()
+    const initialConfig = resolveInitialRenameConfig()
+    state.modelConfig = initialConfig.modelConfig
+    state.language = initialConfig.language
 
     const sessionName = pi.getSessionName()?.trim()
     if (!sessionName) return

package/node_modules/@tifan/pi-rename/src/language.ts

@@ -0,0 +1,18 @@
+export const DEFAULT_RENAME_LANGUAGE = "en"
+export type RenameLanguage = string
+
+export function parseRenameLanguage(
+  value: unknown,
+): RenameLanguage | undefined {
+  if (typeof value !== "string") return undefined
+
+  const trimmed = value.trim()
+  if (trimmed.toLowerCase() === "auto") return "auto"
+  if (!trimmed) return undefined
+
+  try {
+    return Intl.getCanonicalLocales(trimmed)[0]
+  } catch {
+    return undefined
+  }
+}