pi-sessions 0.7.2 → 0.9.0

package/README.md

@@ -8,7 +8,21 @@
 
 ![session picker](images/session_picker.png)
 
-### Handoffs
+### Handoff board
+
+![handoff board showing subagents](images/handoff-board-subagents.png)
+
+![handoff board showing user sessions](images/handoff-board-user-sessions.png)
+
+### Subagent report
+
+![subagent report card in the parent session](images/handoff-subagent-report.png)
+
+### Session handoff
+
+![session handoff tool call](images/session-handoff-tool.png)
+
+### Handoff prompt review
 
 ![handoff preview](images/handoff.png)
 
@@ -20,7 +34,7 @@
 
 ## Install
 
-Requires Pi `0.80.2` or newer and Node `>=24 <26`.
+Requires Pi `0.80.10` or newer and Node `>=24 <26`.
 
 **From npm** (recommended):
 
@@ -46,20 +60,36 @@ What session did I implement the db layer?
 ```
 
 ```text
-/handoff i want to implement the frontend component now
+Open the frontend implementation task in a session to the right.
 ```
 
 ## Features
 
-| Extension          | Surface                               | What it does                                            |
-| ------------------ | ------------------------------------- | ------------------------------------------------------- |
-| Session Search     | `session_search` pi tool              | Search through old sessions                             |
-| Session Ask        | `session_ask` pi tool                 | Ask questions about old sessions                        |
-| Session Handoff    | `/handoff`, `session_handoff` pi tool | Start a focused new session; alternative to compaction  |
-| Session Messaging  | `session_send_message` pi tool        | Send messages between running Pi sessions               |
-| Session Picker     | `Alt+O`                               | Reference old sessions in your prompt                   |
-| Session Index      | `/session-index` slash command        | Shows index status and rebuilds the local session index |
-| Session Auto Title | in background, `/title` slash command | Give sessions titles                                    |
+| Extension          | Surface                                           | What it does                                            |
+| ------------------ | ------------------------------------------------- | ------------------------------------------------------- |
+| Session Search     | `session_search` pi tool                          | Search through old sessions                             |
+| Session Ask        | `session_ask` pi tool                             | Ask questions about old sessions                        |
+| Session Handoff    | `session_handoff` pi tool, `/handoff` board       | Start and manage focused child sessions                 |
+| Session Messaging  | `session_send_message`, `session_cancel` pi tools | Coordinate between live Pi sessions and own subagents   |
+| Session Picker     | `Alt+O`                                           | Reference old sessions in your prompt                   |
+| Session Index      | `/session-index` slash command                    | Shows index status and rebuilds the local session index |
+| Session Auto Title | in background, `/title` slash command             | Give sessions titles                                    |
+
+Every feature is on by default. Turn one off with `enable: false` under its own settings namespace, which unregisters its tools and hooks.
+
+```json
+{
+  "sessions": {
+    "messaging": { "enable": true },
+    "subagents": { "enable": true },
+    "handoff": { "enable": true },
+    "search": { "enable": true },
+    "ask": { "enable": true },
+    "autoTitle": { "enable": true },
+    "hooks": { "enable": true }
+  }
+}
+```
 
 ## Session Search
 
@@ -72,40 +102,25 @@ File filters distinguish read-or-write evidence from write-only evidence:
 - `files.touched`: sessions that read or changed a path
 - `files.changed`: sessions that changed a path
 
-## Session Handoff
-
-`/handoff <goal>` starts a focused new session. Give pi a goal, and it will generate a prompt for you to review before kicking it off.
-
-You can either start a new session directly in your current one, or if you have Ghostty on macOS, you can spawn a new one in a split-pane and continue in your current:
-
-- `/handoff --left <goal>`
-- `/handoff --right <goal>`
-- `/handoff --up <goal>`
-- `/handoff --down <goal>`
-
-The flag indicates the Ghostty split direction.
+Use `kind: "user"` or `kind: "subagent"` to filter by session type across the whole index. Use `relationScope: "branch"` to search subagents launched from the current conversation branch, or `relationScope: "tree"` to include subagents launched from abandoned branches as well.
 
-Flow:
-
-- run `/handoff [--<direction>] <goal>`
-- review the generated prompt preview
-- optionally edit the prompt
-- start the new session
+## Session Handoff
 
-If you do nothing, the preview autostarts after a short countdown.
+The `session_handoff` tool lets the agent create a child session with a self-contained task. Ask for a direction when you want a visible split, ask for a deferred handoff when you only want the prepared session, or let the agent delegate suitable independent work to a background subagent.
 
-When running in Ghostty on macOS, pi-sessions also exposes a `session_handoff` tool. This lets the agent start a background handoff after you choose a split direction. The current session keeps running, while the child session opens in the requested split, gathers context, and shows the same review countdown before starting.
+Directional launches use tmux when the current terminal is inside tmux, or Ghostty on macOS. Deferred launches create the child without starting it and copy its resume command to the clipboard. A background subagent runs in a detached tmux window and reports back when finished.
 
-If background handoffs ever target the wrong pane, run `/handoff --identify` from the intended source pane to refresh the in-memory Ghostty terminal binding.
+Run `/handoff` to open the **Handoffs** board. The Subagents and User sessions tabs show status, age, launch details, and the actions currently available: stop, copy an observation command, or copy a resume command.
 
 ## Session Messaging
 
-Agents can coordinate with other currently running Pi sessions:
+Agents can coordinate with live Pi sessions and their own subagents:
 
 - `session_search` with `live: true` lists live sessions
-- `session_send_message` sends a message to another live session
+- `session_send_message` sends a message to a live session or own subagent
+- `session_cancel` aborts another live session's current turn
 
-Incoming messages start the recipient agent when idle and steer it when already running. Inactive sessions cannot receive messages, but you can still use `session_search` and `session_ask` with them.
+Incoming messages start the recipient agent when idle and steer it when already running. Messaging a dormant owned subagent resumes it automatically; other inactive sessions cannot receive messages, but you can still use `session_search` and `session_ask` with them.
 
 ## Session picker
 
@@ -124,7 +139,24 @@ If you want to override the shortcut, put this in your `~/.pi/agent/settings.jso
 {
   "sessions": {
     "handoff": {
-      "pickerShortcut": "alt+p"
+      "pickerShortcut": "alt+p",
+      "deferred": {
+        "copyToClipboard": true
+      }
+    }
+  }
+}
+```
+
+`deferred.copyToClipboard` (default `true`) controls whether deferred handoffs copy the resume command to the clipboard. When off, the resume command is only shown in the tool call.
+
+Subagents require the handoff and messaging features. Limit recursive delegation depth with `sessions.subagents.maxDepth` (default `2`):
+
+```json
+{
+  "sessions": {
+    "subagents": {
+      "maxDepth": 2
     }
   }
 }
@@ -190,7 +222,9 @@ To change auto-titling settings, edit `~/.pi/agent/settings.json`:
   "sessions": {
     "autoTitle": {
       "refreshTurns": 4,
+      "timeoutSecs": 15,
       "model": "anthropic/claude-haiku-4-5",
+      "thinkingLevel": "off",
       "prompt": "Custom prompt that overrides the default."
     }
   }

package/extensions/pi-sessions.ts

@@ -0,0 +1,125 @@
+import {
+  type ExtensionAPI,
+  type ModelRuntime,
+  SessionManager,
+} from "@earendil-works/pi-coding-agent";
+import { installAsk } from "./session-ask/install.ts";
+import { installAutoTitle } from "./session-auto-title/install.ts";
+import { installHandoff } from "./session-handoff/install.ts";
+import { installHooks } from "./session-hooks/install.ts";
+import { installIndex } from "./session-index/install.ts";
+import { installMessaging } from "./session-messaging/install.ts";
+import {
+  createSessionCancelTool,
+  createSessionSendMessageTool,
+} from "./session-messaging/pi/tools.ts";
+import { installSearch } from "./session-search/install.ts";
+import type { SessionLifecycle } from "./shared/composition.ts";
+import { createSessionModelRuntime, type ModelRuntimeProvider } from "./shared/model-runtime.ts";
+import { loadSettings } from "./shared/settings.ts";
+import { installSubagents } from "./subagents/install.ts";
+
+/**
+ * The single advertised entrypoint. It loads settings once, constructs each feature in
+ * dependency order, and wires them by constructor parameters.
+ * It also owns the single `session_start`/`session_shutdown` subscription so lifecycle order
+ * is deterministic: broker registration (messaging) resolves before any other feature hook.
+ */
+export default function piSessions(pi: ExtensionAPI): void {
+  const settings = loadSettings();
+  let sessionEpoch = 0;
+
+  // The mirrored ModelRuntime is expensive to build and only changes across session
+  // boundaries, so cache it per epoch (the root's own invalidation signal) instead of
+  // rebuilding it on every auto-title, /title, session_ask, and handoff draft.
+  let cachedModelRuntime: { epoch: number; runtime: Promise<ModelRuntime> } | undefined;
+  const getModelRuntime: ModelRuntimeProvider = (modelRegistry) => {
+    if (cachedModelRuntime?.epoch !== sessionEpoch) {
+      cachedModelRuntime = {
+        epoch: sessionEpoch,
+        runtime: createSessionModelRuntime(modelRegistry),
+      };
+    }
+    return cachedModelRuntime.runtime;
+  };
+
+  const index = installIndex(pi, { settings });
+  const messaging = settings.features.messaging
+    ? installMessaging(pi, { settings, index })
+    : undefined;
+
+  const lifecycles: SessionLifecycle[] = [];
+  if (messaging) {
+    lifecycles.push(messaging);
+  }
+  const subagents =
+    settings.features.subagents && messaging
+      ? installSubagents(pi, { settings, messaging })
+      : undefined;
+  if (subagents) {
+    lifecycles.push(subagents);
+  }
+  if (messaging) {
+    pi.registerTool(
+      createSessionSendMessageTool(subagents ?? messaging, {
+        wakeCapable: Boolean(subagents),
+        getCachedRelationTo: messaging.getCachedRelationTo,
+      }),
+    );
+    pi.registerTool(createSessionCancelTool(subagents ?? messaging));
+  }
+  if (settings.features.handoff) {
+    const board = {
+      roster: subagents?.roster,
+      cancelSubagent: subagents
+        ? (sessionId: string) => subagents.cancelSession(sessionId)
+        : undefined,
+      listLiveSessions: messaging ? () => messaging.listSessions() : undefined,
+      readSessionEntries: (sessionFile: string) => SessionManager.open(sessionFile).getEntries(),
+    };
+    lifecycles.push(
+      installHandoff(pi, {
+        settings,
+        index,
+        getModelRuntime,
+        ...(subagents ? { getLaunchTargets: () => subagents.getLaunchTargets() } : {}),
+        board,
+      }),
+    );
+  }
+  if (settings.features.search) {
+    installSearch(pi, { settings, index, messaging, roster: subagents?.roster });
+  }
+  if (settings.features.ask) {
+    installAsk(pi, { settings, index, getModelRuntime });
+  }
+  if (settings.features.autoTitle) {
+    lifecycles.push(
+      installAutoTitle(pi, {
+        settings,
+        getModelRuntime,
+        getSessionEpoch: () => sessionEpoch,
+      }),
+    );
+  }
+  if (settings.features.hooks) {
+    lifecycles.push(installHooks(pi, { settings, index }));
+  }
+  // Messaging leads every session_start so the broker connection is registered before any
+  // other feature hook runs. A side effect is that messaging's first relation snapshot can
+  // predate hooks' index sync for this session; getCachedRelationTo self-heals on miss, so
+  // this ordering is intentional — do not reorder to "fix" it.
+  pi.on("session_start", async (event, ctx) => {
+    sessionEpoch += 1;
+    for (const lifecycle of lifecycles) {
+      await lifecycle.onSessionStart?.(event, ctx);
+    }
+  });
+
+  pi.on("session_shutdown", async (event, ctx) => {
+    sessionEpoch += 1;
+    for (let index = lifecycles.length - 1; index >= 0; index -= 1) {
+      await lifecycles[index]?.onSessionShutdown?.(event, ctx);
+    }
+  });
+}

package/extensions/session-ask/agent.ts

@@ -1,5 +1,5 @@
 import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionContext, ModelRuntime } from "@earendil-works/pi-coding-agent";
 import {
   createAgentSession,
   DefaultResourceLoader,
@@ -8,7 +8,8 @@ import {
   SessionManager,
 } from "@earendil-works/pi-coding-agent";
 import { type Static, Type } from "typebox";
-import { resolveConfiguredModel } from "../shared/model.ts";
+import { resolveAuthenticatedModel } from "../shared/model-resolution.ts";
+import { freshenModel } from "../shared/model-runtime.ts";
 import {
   type SessionLineageRow,
   searchSessionChunks,
@@ -122,6 +123,7 @@ export interface SessionAskAgentResult {
 
 export async function runSessionAskAgent(params: {
   ctx: ExtensionContext;
+  modelRuntime: ModelRuntime;
   target: SessionLineageRow;
   question: string;
   indexPath: string;
@@ -129,13 +131,22 @@ export async function runSessionAskAgent(params: {
   thinkingLevel: ThinkingLevel | undefined;
   signal?: AbortSignal | undefined;
 }): Promise<SessionAskAgentResult | undefined> {
+  params.signal?.throwIfAborted();
   const navigationData = loadSessionNavigationData(params.target.sessionPath);
-  const model =
-    resolveConfiguredModel(params.ctx.modelRegistry.getAvailable(), params.askSettings?.model) ??
-    params.ctx.model;
+  const configured = params.askSettings?.model
+    ? resolveAuthenticatedModel({
+        modelRuntime: params.modelRuntime,
+        modelPattern: params.askSettings.model,
+      })
+    : undefined;
+  const currentModel = params.ctx.model
+    ? freshenModel(params.modelRuntime, params.ctx.model)
+    : undefined;
+  const model = (configured?.ok ? configured.model : undefined) ?? currentModel;
   if (!model) {
     throw new Error("No active model is available for session_ask.");
   }
+  const configuredThinkingLevel = configured?.ok ? configured.thinkingLevel : undefined;
 
   let capturedArguments: ProvideResultsArgs | undefined;
   const searchSessionTool = defineTool({
@@ -234,7 +245,7 @@ export async function runSessionAskAgent(params: {
     description: "Return the final answer for session_ask.",
     promptSnippet: "Provide session ask result",
     promptGuidelines: [
-      "Call provide_results exactly once when you are ready to answer. It is the final tool call and ends the session_ask sub-agent turn.",
+      "Call provide_results exactly once when you are ready to answer. It is the final tool call and ends the session_ask subagent turn.",
     ],
     parameters: PROVIDE_RESULTS_PARAMETERS,
     execute: async (_toolCallId, toolParams: ProvideResultsArgs) => {
@@ -261,9 +272,12 @@ export async function runSessionAskAgent(params: {
     noSkills: true,
     appendSystemPromptOverride: (base) => [...base, SESSION_ASK_NAVIGATION_SYSTEM_PROMPT],
   });
+  params.signal?.throwIfAborted();
   await resourceLoader.reload();
+  params.signal?.throwIfAborted();
 
-  const thinkingLevel = params.askSettings?.thinkingLevel ?? params.thinkingLevel;
+  const thinkingLevel =
+    params.askSettings?.thinkingLevel ?? configuredThinkingLevel ?? params.thinkingLevel;
   const sessionManager = params.askSettings?.persistRuns
     ? SessionManager.create(cwd, getDefaultSessionAskRunsDir())
     : SessionManager.inMemory(cwd);
@@ -273,7 +287,7 @@ export async function runSessionAskAgent(params: {
   const { session } = await createAgentSession({
     cwd,
     model,
-    modelRegistry: params.ctx.modelRegistry,
+    modelRuntime: params.modelRuntime,
     ...(thinkingLevel ? { thinkingLevel } : {}),
     tools: SESSION_ASK_AGENT_TOOLS,
     customTools: [searchSessionTool, sessionReadTool, provideResultsTool],
@@ -281,29 +295,35 @@ export async function runSessionAskAgent(params: {
     sessionManager,
   });
 
-  const abortHandler = (): void => {
-    void session.abort();
+  // Exactly one session.abort() runs no matter how many abort paths fire.
+  let nestedAbort: Promise<void> | undefined;
+  const startNestedAbort = (): void => {
+    nestedAbort ??= Promise.resolve(session.abort()).catch(() => {});
   };
 
   try {
-    params.signal?.addEventListener("abort", abortHandler, { once: true });
+    params.signal?.addEventListener("abort", startNestedAbort, { once: true });
     if (params.signal?.aborted) {
-      await session.abort();
-      return undefined;
+      startNestedAbort();
     }
 
     for (let attempt = 1; attempt <= MAX_SESSION_ASK_ATTEMPTS; attempt += 1) {
+      params.signal?.throwIfAborted();
       const prompt =
         attempt === 1
           ? buildNavigationPrompt(navigationData, params.question)
           : `You did not call ${PROVIDE_RESULTS_TOOL_NAME}. Continue from your prior work and call ${PROVIDE_RESULTS_TOOL_NAME} exactly once with the final markdown answer.`;
       await session.prompt(prompt);
+      params.signal?.throwIfAborted();
       if (capturedArguments) {
         break;
       }
     }
   } finally {
-    params.signal?.removeEventListener("abort", abortHandler);
+    params.signal?.removeEventListener("abort", startNestedAbort);
+    if (nestedAbort) {
+      await nestedAbort;
+    }
     session.dispose();
   }
 

package/extensions/{session-ask.ts → session-ask/install.ts}

@@ -1,39 +1,38 @@
-import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
-import { getKeybindings, type Keybinding, Text } from "@earendil-works/pi-tui";
+import { type ExtensionAPI, SessionManager } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { runSessionAskAgent } from "./session-ask/agent.ts";
+import { isSessionStarting } from "../session-handoff/metadata.ts";
+import type { IndexHandle } from "../shared/composition.ts";
+import type { ModelRuntimeProvider } from "../shared/model-runtime.ts";
 import {
   getSessionById,
   type SessionLineageRow,
   withSessionIndex,
-} from "./shared/session-index/index.ts";
-import { formatSessionTitleOrShortId, isExactSessionId } from "./shared/session-ui.ts";
-import { loadSettings } from "./shared/settings.ts";
-
-const COLLAPSED_ANSWER_PREVIEW_ROWS = 6;
+} from "../shared/session-index/index.ts";
+import { isExactSessionId } from "../shared/session-ui.ts";
+import type { SessionSettings } from "../shared/settings.ts";
+import { runSessionAskAgent } from "./agent.ts";
+import { renderSessionAskResult } from "./renderer.ts";
+import type {
+  SessionAskProgressDetails,
+  SessionAskRelevantFile,
+  SessionAskResultDetails,
+} from "./tool-contract.ts";
 
 interface SessionAskToolParams {
   session: string;
   question: string;
 }
 
-interface SessionAskRelevantFile {
-  path: string;
-  reason: string;
-}
-
-interface SessionAskToolDetails {
-  answer?: string | undefined;
-  debugSessionPath?: string | undefined;
-  question?: string | undefined;
-  relevantFiles?: SessionAskRelevantFile[] | undefined;
-  sessionId?: string | undefined;
-  sessionName?: string | undefined;
-  sessionPath?: string | undefined;
-}
-
-export default function sessionAskExtension(pi: ExtensionAPI): void {
-  const settings = loadSettings();
+export function installAsk(
+  pi: ExtensionAPI,
+  deps: {
+    settings: SessionSettings;
+    index: IndexHandle;
+    getModelRuntime: ModelRuntimeProvider;
+  },
+): void {
+  const { settings } = deps;
+  const indexPath = deps.index.path;
 
   pi.registerTool({
     name: "session_ask",
@@ -60,12 +59,40 @@ export default function sessionAskExtension(pi: ExtensionAPI): void {
         throw new Error("session_ask requires a question.");
       }
 
-      const resolvedTarget = resolveSessionAskTarget(sessionId, settings.index.path);
+      const resolvedTarget = resolveSessionAskTarget(sessionId, indexPath);
       if (!resolvedTarget.resolved) {
         throw new Error(resolvedTarget.error ?? "Unable to resolve session id.");
       }
 
-      const progressDetails: SessionAskToolDetails = {
+      const startingAnswer = getStartingSessionAnswer(resolvedTarget.resolved.sessionPath);
+      if (startingAnswer) {
+        const details: SessionAskResultDetails = {
+          answer: startingAnswer,
+          relevantFiles: [],
+          sessionId: resolvedTarget.resolved.sessionId,
+          sessionName: resolvedTarget.resolved.sessionName,
+          sessionPath: resolvedTarget.resolved.sessionPath,
+          question,
+        };
+        return {
+          content: [
+            {
+              type: "text",
+              text: [
+                formatSessionAskHeader(
+                  resolvedTarget.resolved.sessionId,
+                  resolvedTarget.resolved.sessionName,
+                  question,
+                ),
+                startingAnswer,
+              ].join("\n\n"),
+            },
+          ],
+          details,
+        };
+      }
+
+      const progressDetails: SessionAskProgressDetails = {
         question,
         sessionId: resolvedTarget.resolved.sessionId,
         sessionName: resolvedTarget.resolved.sessionName,
@@ -90,26 +117,26 @@ export default function sessionAskExtension(pi: ExtensionAPI): void {
         details: progressDetails,
       });
 
+      const modelRuntime = await deps.getModelRuntime(ctx.modelRegistry);
       const agentResult = await runSessionAskAgent({
         ctx,
+        modelRuntime,
         target: resolvedTarget.resolved,
         question,
-        indexPath: settings.index.path,
+        indexPath,
         askSettings: settings.ask,
         thinkingLevel: pi.getThinkingLevel(),
         signal,
       });
 
-      if (signal?.aborted) {
-        throw new Error("Session ask was cancelled.");
-      }
-
       const answer = agentResult?.answer || "Could not determine an answer from the session.";
       const relevantFiles = agentResult?.relevantFiles ?? [];
 
-      const details: SessionAskToolDetails = {
+      const details: SessionAskResultDetails = {
         answer,
-        debugSessionPath: agentResult?.debugSessionPath,
+        ...(agentResult?.debugSessionPath
+          ? { debugSessionPath: agentResult.debugSessionPath }
+          : {}),
         relevantFiles,
         sessionId: resolvedTarget.resolved.sessionId,
         sessionName: resolvedTarget.resolved.sessionName,
@@ -133,42 +160,21 @@ export default function sessionAskExtension(pi: ExtensionAPI): void {
         details,
       };
     },
-    renderResult(result, { expanded, isPartial }, theme, context) {
-      const details = result.details as SessionAskToolDetails | undefined;
-      const content = result.content[0];
-      if (content?.type !== "text") {
-        return new Text(theme.fg("error", "No session output"), 0, 0);
-      }
-
-      if (context.isError) {
-        return new Text(theme.fg("error", content.text), 0, 0);
-      }
-
-      if (isPartial) {
-        const lines = [theme.bold(theme.fg("warning", "Reading session..."))];
-        if (details?.sessionId || details?.sessionName) {
-          const identity = formatSessionTitleOrShortId(details.sessionName, details.sessionId);
-          lines.push(`title: ${theme.fg("accent", identity)}`);
-        }
-        if (details?.question) {
-          lines.push(theme.fg("muted", `prompt: ${details.question}`));
-        }
-        return new Text(lines.join("\n"), 0, 0);
-      }
-
-      const answer = (details?.answer ?? "").trim() || "No answer generated.";
-      const identity = formatSessionTitleOrShortId(details?.sessionName, details?.sessionId);
-      const lines = [`title: ${theme.bold(identity)}`];
-      if (details?.question) {
-        lines.push(theme.fg("muted", `prompt: ${details.question}`));
-        lines.push("");
-      }
-      lines.push(...formatSessionAskAnswerPreview(answer, expanded, theme));
-      return new Text(lines.join("\n"), 0, 0);
-    },
+    renderResult: renderSessionAskResult,
   });
 }
 
+function getStartingSessionAnswer(sessionPath: string): string | undefined {
+  try {
+    if (isSessionStarting(SessionManager.open(sessionPath).getBranch())) {
+      return "This session is still starting: a handoff is in progress and it has not received its kickoff. Retry once the session is no longer starting.";
+    }
+  } catch {
+    // The navigation agent preserves the existing failure behavior for unreadable sessions.
+  }
+  return undefined;
+}
+
 function resolveSessionAskTarget(
   sessionId: string,
   indexPath: string,
@@ -220,26 +226,3 @@ function formatSessionAskAnswer(
   }
   return lines.join("\n");
 }
-
-function formatSessionAskAnswerPreview(answer: string, expanded: boolean, theme: Theme): string[] {
-  const lines = answer.split(/\r?\n/);
-  if (expanded || lines.length <= COLLAPSED_ANSWER_PREVIEW_ROWS) {
-    return lines;
-  }
-
-  return [
-    ...lines.slice(0, COLLAPSED_ANSWER_PREVIEW_ROWS),
-    formatOverflowHint(lines.length - COLLAPSED_ANSWER_PREVIEW_ROWS, lines.length, theme),
-  ];
-}
-
-function formatOverflowHint(remaining: number, total: number, theme: Theme): string {
-  return `${theme.fg("muted", `... (${remaining} more lines, ${total} total,`)} ${theme.fg(
-    "dim",
-    formatKeyHint("app.tools.expand"),
-  )}${theme.fg("muted", " to expand)")}`;
-}
-
-function formatKeyHint(keybinding: Keybinding): string {
-  return getKeybindings().getKeys(keybinding).join("/");
-}

package/extensions/session-ask/navigate.ts

@@ -7,6 +7,7 @@ import {
   SessionManager,
   type SessionMessageEntry,
 } from "@earendil-works/pi-coding-agent";
+import { HANDOFF_KICKOFF_CUSTOM_TYPE } from "../session-handoff/kickoff.ts";
 import { contentToText, isRecord, truncateBlock, truncateInline } from "../shared/text.ts";
 
 const MAX_TOOL_RESULT_PREVIEW_CHARS = 300;
@@ -726,7 +727,8 @@ function renderEntryContent(entry: SessionEntry, body: SessionReadBodyMode = "fu
     return renderMessageEntry(entry, body);
   }
   if (entry.type === "custom_message") {
-    return `[Custom]: ${String(entry.content ?? "")}`;
+    const label = entry.customType === HANDOFF_KICKOFF_CUSTOM_TYPE ? "Handoff kickoff" : "Custom";
+    return `[${label}]: ${String(entry.content ?? "")}`;
   }
   if (entry.type === "compaction" || entry.type === "branch_summary") {
     return String(entry.summary ?? "");