@cad0p/pi-tree-navigator 0.1.3 → 0.2.0

package/extensions/navigate-tree/index.ts

@@ -38,8 +38,10 @@
 
 import { randomUUID } from "node:crypto";
 import {
+  type AgentTool,
   estimateContextTokens,
   type StreamFn,
+  type ThinkingLevel,
 } from "@earendil-works/pi-agent-core";
 import {
   AgentSession,
@@ -47,12 +49,23 @@ import {
   collectEntriesForBranchSummary,
   type ExtensionAPI,
   generateBranchSummary,
+  keyHint,
   type ModelRegistry,
   type SessionEntry,
   type SessionManager,
   sessionEntryToContextMessages,
 } from "@earendil-works/pi-coding-agent";
+import { Container, Spacer, Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
+import {
+  buildLiveSummaryMessages,
+  type CacheRequest,
+  createCachePreservingStreamFn,
+  detectBranchSummaryCacheMiss,
+  formatBranchSummaryCacheMissNotice,
+  measureSummaryCache,
+  resolveSummaryCacheRetention,
+} from "./cache-summary.ts";
 import {
   extractTextContent,
   formatContextDelta,
@@ -170,7 +183,21 @@ interface PiInternals {
   agent: {
     state: {
       messages: unknown[];
+      /** Live system prompt (cache-preserving request mirror; #33). */
+      systemPrompt: string;
+      /** Live tool instances (cache-preserving request mirror; #33). */
+      tools: unknown[];
     };
+    /** Live thinking token budgets (plain field on pi-agent-core's Agent). */
+    thinkingBudgets?: unknown;
+  };
+  /**
+   * Plain field on `AgentSession`; the extension ctx does not expose
+   * settings. Used only to gate the TUI cache notice on pi's own
+   * `showCacheMissNotices` setting (default off).
+   */
+  settingsManager?: {
+    getShowCacheMissNotices?: () => boolean;
   };
   sessionManager: SessionManager;
 }
@@ -285,19 +312,25 @@ function stripNullHeaders(
  * native `/tree` summary fails deterministically).
  *
  * The tool-execute ctx exposes neither `settingsManager` (telemetry attribution)
- * nor the live routing `sessionId`, so this replicates only the session half of
- * pi's merge (`getSessionHeaders` in `provider-attribution.ts`): for
+ * nor the live routing `sessionId` on 0.81.x, so this replicates only the session
+ * half of pi's merge (`getSessionHeaders` in `provider-attribution.ts`): for
  * opencode-family providers, inject `x-opencode-session` + `x-opencode-client`.
- * The value is a fresh UUID per rewind — upstream does the same for routing
- * (`completeSummarization` falls back to `uuidv7()` when the caller passes no
- * session id), and one-off summaries have no continuation to route. Proven by
- * the branch-summary eval harness, whose identical injection succeeds on
- * opencode-go where the bare call 400s. Never overrides a header the auth layer
- * already set.
+ *
+ * `sessionId` is the LIVE session id when the caller can supply one
+ * (`sm.getSessionId()`), so the summarization request routes to the same
+ * replica/affinity bucket as the turns it summarizes. A fresh UUID is only the
+ * fallback for callers that cannot supply one (upstream's `completeSummarization`
+ * does the same via `uuidv7()`). The header is routing-only — on
+ * openai-responses the *cache key* is `prompt_cache_key`, derived from the
+ * forwarded `sessionId` option, not from this header (pi-ai sets the header from
+ * `sessionId` only when the provider opts into session affinity).
+ *
+ * Never overrides a header the auth layer already set.
  */
 function withSessionHeaders(
   model: { provider?: string; baseUrl?: string } | undefined,
   headers: Record<string, string> | undefined,
+  sessionId?: string,
 ): Record<string, string> | undefined {
   const provider = model?.provider ?? "";
   let host = "";
@@ -313,7 +346,7 @@ function withSessionHeaders(
   if (!needsSession) return headers;
   const merged = { ...(headers ?? {}) };
   if (!merged["x-opencode-session"]) {
-    merged["x-opencode-session"] = randomUUID();
+    merged["x-opencode-session"] = sessionId || randomUUID();
   }
   if (!merged["x-opencode-client"]) {
     merged["x-opencode-client"] = "pi";
@@ -386,6 +419,108 @@ function findLabeledEntry(
   return null;
 }
 
+/** Shape of a `toolCall` content block on an assistant message. */
+interface ToolCallBlock {
+  id: string;
+  name?: unknown;
+}
+
+/**
+ * Find the assistant message that declared the in-flight tool call and
+ * return its full tool-call batch as emitted (emission order), or `null`
+ * when neither the active branch nor the captured session's live messages
+ * carry it.
+ *
+ * `rewind` is only structurally safe as a solo call (#37): it forks the
+ * tree and re-declares ONLY its own tool call in a synthetic assistant, so
+ * a sibling call's result — appended by pi's sequential loop after the
+ * fork — would land on the new branch with no declaring assistant and
+ * brick every subsequent request. This helper is the detection seam for
+ * the pre-mutation refusal guard.
+ *
+ * Primary source is `sm.getBranch()`: pi persists the assistant
+ * SessionEntry on `message_end` before `tool_execution_start`, so the
+ * in-flight assistant is already on the active branch when `execute` runs
+ * (asserted by `scripts/pi-upstream-probe.mjs`). The walk matches by
+ * tool-call id, not by tail position, because preceding sibling results
+ * may already trail the assistant. `getBranch()` reads internal session
+ * state and can throw, and tree-write lag can leave it stale; both cases
+ * fall back to the same scan over the captured session's
+ * `agent.state.messages`. A miss returns `null` so callers fall through to
+ * the pre-guard behavior — never hard-fail on undetectable state.
+ *
+ * Detection fails open on shape, not count: every `toolCall` block with a
+ * string `id` counts toward the returned batch, even if its `name` is
+ * missing or malformed (`name` falls back to `"unknown"`), so a sibling
+ * call can't be silently dropped from the count by an unexpected shape.
+ */
+function findInFlightAssistantToolCalls(
+  sm: SessionManager,
+  toolCallId: string,
+): Array<{ id: string; name: string }> | null {
+  const scan = (
+    items: ReadonlyArray<unknown>,
+  ): Array<{ id: string; name: string }> | null => {
+    for (let i = items.length - 1; i >= 0; i--) {
+      const item = items[i] as
+        | { type?: unknown; message?: unknown }
+        | null
+        | undefined;
+      if (!item || typeof item !== "object") continue;
+      // SessionEntry: `{ type: "message", message: {...} }`. Raw
+      // `agent.state.messages` entries are the message itself.
+      const candidate = (item.type === "message" ? item.message : item) as
+        | { role?: unknown; content?: unknown }
+        | null
+        | undefined;
+      if (
+        !candidate ||
+        typeof candidate !== "object" ||
+        candidate.role !== "assistant" ||
+        !Array.isArray(candidate.content)
+      ) {
+        continue;
+      }
+      const toolCalls = candidate.content.filter(
+        (block): block is ToolCallBlock =>
+          !!block &&
+          typeof block === "object" &&
+          (block as { type?: unknown }).type === "toolCall" &&
+          typeof (block as { id?: unknown }).id === "string",
+      );
+      if (toolCalls.some((block) => block.id === toolCallId)) {
+        return toolCalls.map((block) => ({
+          id: block.id,
+          name: typeof block.name === "string" ? block.name : "unknown",
+        }));
+      }
+    }
+    return null;
+  };
+
+  let branch: SessionEntry[] | undefined;
+  try {
+    branch = sm.getBranch();
+  } catch {
+    // getBranch() reads internal session state; fall through to the
+    // captured-session scan instead of aborting the rewind.
+  }
+  if (branch) {
+    const onBranch = scan(branch);
+    if (onBranch) return onBranch;
+  }
+  const session = findOwningSession(sm);
+  const liveMessages = session
+    ? asInternals(session).agent?.state?.messages
+    : undefined;
+  if (!Array.isArray(liveMessages)) return null;
+  try {
+    return scan(liveMessages);
+  } catch {
+    return null;
+  }
+}
+
 function estimateActiveBranchTokens(sm: SessionManager): number {
   return estimateContextTokens(sm.buildSessionContext().messages).tokens;
 }
@@ -541,7 +676,13 @@ function toolError(
 ): ToolResult {
   return {
     content: [{ type: "text", text }],
-    details,
+    // `isError` is a statement of intent only: pi-agent-core ignores the flag
+    // on a *returned* result (only a thrown `execute()` is finalized as
+    // failed), so without the `refusal` marker below the host records this
+    // as a successful call and the TUI paints the row with `toolSuccessBg`.
+    // The `tool_result` handler in the factory promotes the marker into the
+    // host's real error channel.
+    details: { ...details, refusal: true },
     isError: true,
   };
 }
@@ -579,6 +720,20 @@ export default function (
     return { systemPrompt: `${event.systemPrompt}\n\n${ANCHOR_MANDATE}` };
   });
 
+  // Refusals must render (and be recorded) as failed tool calls. A returned
+  // `isError: true` never reaches the host's error channel — pi-agent-core
+  // only finalizes a call as failed when `execute()` throws, overwriting the
+  // flag with its own boolean — so `toolError` tags its details with
+  // `refusal: true` and this handler flips the host's `isError`, which drives
+  // the TUI's `toolErrorBg` shell, the transcript entry, and any other
+  // extension's `tool_result` view. Content is left untouched, so the model
+  // still reads the refusal copy.
+  pi.on("tool_result", (event) => {
+    if (event.toolName !== TOOL_NAME) return undefined;
+    const details = event.details as { refusal?: boolean } | undefined;
+    return details?.refusal === true ? { isError: true } : undefined;
+  });
+
   pi.registerTool({
     name: TOOL_NAME,
     label: "Navigate Tree",
@@ -761,6 +916,27 @@ Operations (set \`action\`):
         );
       }
 
+      // Solo-batch guard (#37): a rewind must be the only tool call in its
+      // assistant batch. Pi runs a batch containing this sequential-mode tool
+      // sequentially; `branchWithSummary` then puts the declaring assistant
+      // on the abandoned branch, and the synthetic assistant re-declares
+      // ONLY this call — so any sibling result pi appends afterwards would
+      // land on the new branch with no declaring `tool_calls`, 400-ing every
+      // subsequent request. Refuse before any mutation or LLM call. A missed
+      // detection returns null and falls through to today's behavior. The
+      // validations above ran first so the copy can interpolate a valid
+      // labelStart.
+      const inFlightBatch = findInFlightAssistantToolCalls(sm, toolCallId);
+      if (inFlightBatch && inFlightBatch.length > 1) {
+        return toolError(
+          `rewind must be the only tool call in its batch — after it, the next context is everything up to '${p.labelStart}' plus the new summary, so any other call's result would be orphaned — never read by anyone. Those other calls already ran; re-issue only the rewind, alone.`,
+          {
+            rejected: "batched-rewind",
+            batchedToolCalls: inFlightBatch.map((call) => call.name),
+          },
+        );
+      }
+
       const target = findLabeledEntry(sm, LABEL_PREFIX + p.labelStart);
       if (!target) {
         return toolError(
@@ -879,16 +1055,174 @@ Operations (set \`action\`):
         return toolError(`Auth resolution failed: ${auth.error}`);
       }
 
+      // -----------------------------------------------------------------
+      // Cache-preserving summary request (#33)
+      //
+      // `generateBranchSummary` builds a cold, standalone request (generic
+      // summarization prompt, serialized blob, no tools, cacheRetention
+      // "none", fresh session id). The live turns being collapsed were just
+      // cache-served, so the summary re-bills the whole input. We cannot
+      // patch upstream (the extension loader aliases @earendil-works/* to the
+      // host process), but the `streamFn` seam we already inject is the exact
+      // point where upstream's cold context/options exist — wrap it and
+      // rewrite them to the live shape. Every live input is read
+      // defensively: on any miss we leave `summaryCacheRequest` null and the
+      // wrapper delegates today's cold request (with a user-visible warning).
+      //
+      // Two evidence guards also refuse the cache path and fall back to the
+      // cold request, because raw branch evidence must beat a cache hit when
+      // the two disagree:
+      //
+      //   - "branch-crosses-compaction": `buildContextEntries()` applies the
+      //     compaction cut — entries before the latest compaction's
+      //     `firstKeptEntryId` are dropped from the live projection. When a
+      //     rewind segment reaches older than that cut, the cache payload
+      //     would summarize the lossy compacted projection while the legacy
+      //     path summarizes the raw segment. The compaction entry itself is
+      //     retained, so `branchStartRetained` cannot catch this; the
+      //     id-difference check below does (every other entry type — labels,
+      //     model changes, thinking-level changes — stays in the projection,
+      //     so only compaction-dropped entries are missing).
+      //   - "branch-start-not-retained": no message from the collapsed
+      //     segment survived into the payload (labels-only segment) or the
+      //     newest message alone exceeded the token budget. The legacy path
+      //     then either summarizes the raw evidence or returns "No content to
+      //     summarize" before any wire call.
+      // -----------------------------------------------------------------
+      const providerStream = resolveProviderStreamFn(
+        ctx.modelRegistry,
+        ctx.model.provider,
+      );
+      let summaryCacheRequest: CacheRequest | null = null;
+      let summaryCacheFallbackReason: string | undefined;
+      let branchStartRetained = true;
+
+      if (process.env.PI_NAVIGATE_TREE_SUMMARY_CACHE === "0") {
+        // Kill switch: an env-var escape hatch to force the pre-#33 cold
+        // request without unloading the extension.
+        summaryCacheFallbackReason = "disabled";
+      } else if (!providerStream) {
+        summaryCacheFallbackReason = "no-provider-stream";
+      } else {
+        const owning = findOwningSession(sm);
+        const internals = owning ? asInternals(owning) : undefined;
+        const liveTools = internals?.agent?.state?.tools;
+        if (!internals) {
+          summaryCacheFallbackReason = "reflection-missing";
+        } else if (!Array.isArray(liveTools)) {
+          summaryCacheFallbackReason = "no-live-tools";
+        } else {
+          // Public accessor first (0.81+), reflected field as backstop. Both
+          // are read here AND in refreshAgentMessages; the reflection probe
+          // covers the plain-field shape.
+          let systemPrompt: string | undefined;
+          if (typeof ctx.getSystemPrompt === "function") {
+            try {
+              systemPrompt = ctx.getSystemPrompt();
+            } catch {
+              systemPrompt = undefined;
+            }
+          }
+          if (typeof systemPrompt !== "string" || systemPrompt.length === 0) {
+            const reflected = internals.agent?.state?.systemPrompt;
+            systemPrompt =
+              typeof reflected === "string" ? reflected : undefined;
+          }
+          if (typeof systemPrompt !== "string" || systemPrompt.length === 0) {
+            summaryCacheFallbackReason = "no-system-prompt";
+          } else {
+            const contextEntries = sm.buildContextEntries();
+            const contextIds = new Set(contextEntries.map((e) => e.id));
+            // Evidence-loss guard: any segment entry missing from the live
+            // projection means the compaction cut dropped raw evidence, so
+            // the cache payload would diverge from the legacy raw segment.
+            // Use the id-difference predicate — NOT a "segment contains a
+            // compaction" check: a segment that contains the compaction
+            // entry but whose target sits at/after `firstKeptEntryId` loses
+            // no evidence and must still take the cache path.
+            if (entries.some((e) => !contextIds.has(e.id))) {
+              summaryCacheFallbackReason = "branch-crosses-compaction";
+            } else {
+              const branchEntryIds = new Set(entries.map((e) => e.id));
+              // Upstream's default `reserveTokens`; the fallback path will
+              // recompute the same budget inside generateBranchSummary.
+              const tokenBudget = (ctx.model.contextWindow || 128000) - 16384;
+              const built = buildLiveSummaryMessages({
+                contextEntries,
+                branchEntryIds,
+                inFlightToolCallId: toolCallId,
+                tokenBudget,
+                focus: p.summaryFocus,
+              });
+              branchStartRetained = built.branchStartRetained;
+              if (!built.branchStartRetained) {
+                summaryCacheFallbackReason = "branch-start-not-retained";
+              } else {
+                const sessionId = sm.getSessionId();
+                // Public since 0.81.0; `ctx.thinkingLevel` only exists >=
+                // 0.84.2, so never read it directly. "off" is omitted,
+                // mirroring the live loop's request shape.
+                const reasoning =
+                  typeof pi.getThinkingLevel === "function"
+                    ? pi.getThinkingLevel()
+                    : undefined;
+                summaryCacheRequest = {
+                  context: {
+                    systemPrompt,
+                    messages: built.messages,
+                    tools: liveTools as AgentTool[],
+                  },
+                  // Provider-scoped `PI_CACHE_RETENTION` (auth.env) must win
+                  // over `process.env`, mirroring pi-ai's
+                  // `getProviderEnvValue`: the live turns resolve retention
+                  // from the provider env, so a provider-scoped "long" with
+                  // a process-level "short" would make live=long /
+                  // summary=short and silently miss.
+                  cacheRetention: resolveSummaryCacheRetention(auth.env),
+                  ...(sessionId ? { sessionId } : {}),
+                  ...(typeof reasoning === "string" && reasoning !== "off"
+                    ? { reasoning: reasoning as ThinkingLevel }
+                    : {}),
+                  ...(internals.agent?.thinkingBudgets
+                    ? { thinkingBudgets: internals.agent.thinkingBudgets }
+                    : {}),
+                };
+              }
+            }
+          }
+        }
+      }
+
+      // Always wrap when a provider stream exists: with a request it rewrites
+      // the live shape, without one it delegates today's cold request
+      // byte-for-byte (the `used` flag records which happened).
+      const cacheWrapped = providerStream
+        ? createCachePreservingStreamFn({
+            realStreamFn: providerStream.streamFn,
+            request: summaryCacheRequest,
+          })
+        : undefined;
+
+      // `auth.baseUrl` (OAuth/credential-derived endpoint, e.g.
+      // githubCopilotOAuth) must be applied to the model, mirroring pi's
+      // own `_getSummarizationRequestAuth` (`result.auth.baseUrl ?
+      // { ...model, baseUrl: result.auth.baseUrl } : model`). Use this one
+      // resolved model for BOTH the summarization call and the session
+      // headers: the routing header is derived from the endpoint actually
+      // contacted, so reading the un-overridden `ctx.model` there would
+      // diverge.
+      const requestModel = auth.baseUrl
+        ? { ...ctx.model, baseUrl: auth.baseUrl }
+        : ctx.model;
+
       const result = await summarize(entries, {
-        // `auth.baseUrl` (OAuth/credential-derived endpoint, e.g.
-        // githubCopilotOAuth) must be applied to the model, mirroring pi's
-        // own `_getSummarizationRequestAuth` (`result.auth.baseUrl ?
-        // { ...model, baseUrl: result.auth.baseUrl } : model`).
-        model: auth.baseUrl
-          ? { ...ctx.model, baseUrl: auth.baseUrl }
-          : ctx.model,
+        model: requestModel,
         apiKey: auth.apiKey ?? "",
-        headers: withSessionHeaders(ctx.model, stripNullHeaders(auth.headers)),
+        headers: withSessionHeaders(
+          requestModel,
+          stripNullHeaders(auth.headers),
+          sm.getSessionId(),
+        ),
         ...(auth.env ? { env: auth.env } : {}),
         signal: signal ?? new AbortController().signal,
         customInstructions: p.summaryFocus,
@@ -899,9 +1233,9 @@ Operations (set \`action\`):
         // compat registry (which only knows builtin apis) — without this,
         // rewind fails with "No API provider registered for api:
         // <custom-id>" for any custom-api provider (e.g. commandcode 0.5.x
-        // with api "commandcode-custom").
-        ...(resolveProviderStreamFn(ctx.modelRegistry, ctx.model.provider) ??
-          {}),
+        // with api "commandcode-custom"). The wrapper delegates to it in
+        // both the live-prefix and fallback cases.
+        ...(cacheWrapped ? { streamFn: cacheWrapped.streamFn } : {}),
       });
       if (result.aborted) {
         return toolError("Summarization aborted.");
@@ -912,6 +1246,68 @@ Operations (set \`action\`):
         );
       }
 
+      // Cache outcome measured from provider usage. Mode reflects whether a
+      // cache-preserving request was BUILT; `used` reflects whether the
+      // wrapper actually delegated it (false when the summarizer is stubbed,
+      // aborted before the wire call, or the fallback path ran).
+      const summaryCacheMode = summaryCacheRequest ? "live-prefix" : "fallback";
+      const summaryCacheStats = measureSummaryCache(
+        result.usage ?? { input: 0, cacheRead: 0, cacheWrite: 0 },
+      );
+
+      // Fork-faithful miss accounting (cad0p/pi@eval/branch-summary-prompt):
+      // scan the entries as they stand (the branch_summary is not appended
+      // yet) and compare the summary's measured usage against the previous
+      // request's baseline — the baseline survives branch_summary entries
+      // (the summary request reuses the live prefix), while a summary miss
+      // after a model switch is suppressed as expected re-billing. HITS ARE
+      // SILENT — the footer/session totals already cover them; only an
+      // actionable miss is worth a transcript line. The fallback path (cache
+      // request not built) is NOT special-cased: the legacy cold request
+      // measures as a miss exactly when the numbers say so, and
+      // `fallbackReason` lives in `details.summaryCache` only. Upstream pi
+      // renders cache notices as transcript lines gated by
+      // `showCacheMissNotices`; the extension does the same by storing the
+      // notice string and rendering it from the tool's `renderResult`. The
+      // model-visible tool-result content stays cache-free (the model was
+      // proven to echo the line verbatim). The setting is read reflectively
+      // off the captured session — the extension ctx does not expose
+      // `settingsManager`. `Date.now()` is the summary timestamp, as the
+      // fork's `navigateTree` call site uses. Headless runs and setting-off
+      // runs surface the same numbers via `details.summaryCache`.
+      const summaryCacheMiss = result.usage
+        ? detectBranchSummaryCacheMiss(
+            allEntries,
+            result.usage,
+            requestModel.provider,
+            requestModel.id,
+            Date.now(),
+            {
+              getModel: (provider, model) =>
+                ctx.modelRegistry.find(provider, model),
+            },
+          )
+        : undefined;
+      let summaryCacheNotice: string | null = null;
+      if (summaryCacheMiss) {
+        const notice = formatBranchSummaryCacheMissNotice(summaryCacheMiss);
+        if (notice !== null) {
+          let showCacheNotices = false;
+          try {
+            const owning = findOwningSession(sm);
+            showCacheNotices =
+              (owning
+                ? asInternals(owning).settingsManager
+                : undefined
+              )?.getShowCacheMissNotices?.() ?? false;
+          } catch {
+            // Unreadable settings -> stay silent (mirror pi's default off).
+            showCacheNotices = false;
+          }
+          if (showCacheNotices) summaryCacheNotice = notice;
+        }
+      }
+
       // Move the tree.
       const summaryId = sm.branchWithSummary(target, result.summary, {
         readFiles: result.readFiles ?? [],
@@ -1064,11 +1460,61 @@ Operations (set \`action\`):
           contextAfter: afterTokens,
           contextWindow,
           agentMessagesRefreshed: refreshed,
+          summaryCache: {
+            mode: summaryCacheMode,
+            fallbackReason: summaryCacheFallbackReason ?? null,
+            branchStartRetained,
+            used: cacheWrapped?.used.value ?? false,
+            cacheRead: summaryCacheStats.cacheRead,
+            input: summaryCacheStats.fresh,
+            cacheWrite: summaryCacheStats.cacheWrite,
+            hit: summaryCacheStats.hit,
+            missedTokens: summaryCacheMiss?.missedTokens ?? 0,
+            missedCost: summaryCacheMiss?.missedCost ?? 0,
+            idleMs: summaryCacheMiss?.idleMs ?? 0,
+            modelChanged: summaryCacheMiss?.modelChanged ?? false,
+            notice: summaryCacheNotice,
+          },
           readFiles: result.readFiles ?? [],
           modifiedFiles: result.modifiedFiles ?? [],
         },
       };
     },
+    // Upstream pi renders cache notices as transcript lines (its
+    // `maybeShowCacheMissNotice` + `createResultFallback`), not toasts.
+    // Reproduce the default tool-result rendering and append the notice that
+    // `execute` stored. `showCacheMissNotices` gating already happened in
+    // `execute`; this renderer only runs in the TUI.
+    renderResult(result, { expanded }, theme) {
+      const output = result.content
+        .filter((block) => block.type === "text")
+        .map((block) => (block.type === "text" ? block.text : ""))
+        .join("\n");
+      const lines = output.split("\n");
+      const displayLines = expanded ? lines : lines.slice(0, 10);
+      const remaining = lines.length - displayLines.length;
+      let text = displayLines
+        .map((line) => theme.fg("toolOutput", line))
+        .join("\n");
+      if (remaining > 0) {
+        text += `${theme.fg("muted", `\n... (${remaining} more lines,`)} ${keyHint(
+          "app.tools.expand",
+          "to expand",
+        )}${theme.fg("muted", ")")}`;
+      }
+      const container = new Container();
+      container.addChild(new Text(text, 0, 0));
+      const notice = (
+        result.details as
+          | { summaryCache?: { notice?: string | null } }
+          | undefined
+      )?.summaryCache?.notice;
+      if (typeof notice === "string" && notice.length > 0) {
+        container.addChild(new Spacer(1));
+        container.addChild(new Text(theme.fg("warning", notice), 1, 0));
+      }
+      return container;
+    },
   });
 }
 
@@ -1112,6 +1558,7 @@ export const __testHooks = {
   buildSyntheticAssistant,
   findLabelHint,
   findLabeledEntry,
+  findInFlightAssistantToolCalls,
   buildContextMessages,
   refreshAgentMessages,
   captureSession,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cad0p/pi-tree-navigator",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "agent-callable session tree navigation for pi: anchor named milestones, rewind work into a branch summary, free up context for long autonomous sessions",
   "publishConfig": {
     "access": "public",
@@ -49,6 +49,7 @@
   "peerDependencies": {
     "@earendil-works/pi-agent-core": ">=0.81.0",
     "@earendil-works/pi-coding-agent": ">=0.81.0",
+    "@earendil-works/pi-tui": ">=0.81.0",
     "typebox": "^1.0.0"
   },
   "license": "MIT"