shariq-pi-extensions 0.4.0 → 0.5.0

package/docs/EXTENSIONS.md

@@ -36,7 +36,7 @@ Managed PTYs for servers, watchers, long builds, and interactive programs: up to
 
 ### [Web fetch](../extensions/web-fetch/README.md)
 
-`web_fetch` retrieves one known HTTP or HTTPS URL as Markdown, text, or HTML, with time and size limits and no Firecrawl credits.
+`web_fetch` retrieves one known HTTP or HTTPS URL as Markdown, text, or HTML, with time and size limits and no Firecrawl credits. Local and private network addresses are blocked unless `PI_WEB_FETCH_ALLOW_PRIVATE=1` is set.
 
 ## Interface
 

package/extensions/ask-user/index.ts

@@ -77,8 +77,10 @@ function cleanMultiline(text: string): string {
   return sanitizeTerminalText(text).trim();
 }
 
+// Compare labels the way they are displayed (whitespace collapsed), so two
+// labels that look identical on screen are rejected as duplicates.
 function normalizedChoiceKey(label: string): string {
-  return label.normalize("NFKC").toLocaleLowerCase("en-US");
+  return oneLine(label).normalize("NFKC").toLocaleLowerCase("en-US");
 }
 
 function normalizeQuestionInput(
@@ -124,6 +126,7 @@ function createEditorTheme(theme: Theme): EditorTheme {
 export class AskUserView implements Focusable {
   private selected = 0;
   private editing = false;
+  private questionOffset = 0;
   private cachedWidth?: number;
   private cachedLines?: string[];
   private _focused = false;
@@ -133,6 +136,7 @@ export class AskUserView implements Focusable {
   private readonly requestRender: () => void;
   private readonly finish: (selection: Selection | null) => void;
   private readonly editor: Editor;
+  private readonly maxRows: () => number;
 
   constructor(
     question: string,
@@ -141,6 +145,7 @@ export class AskUserView implements Focusable {
     requestRender: () => void,
     finish: (selection: Selection | null) => void,
     editor: Editor,
+    maxRows: () => number = () => Number.POSITIVE_INFINITY,
   ) {
     this.question = question;
     this.options = options;
@@ -148,6 +153,7 @@ export class AskUserView implements Focusable {
     this.requestRender = requestRender;
     this.finish = finish;
     this.editor = editor;
+    this.maxRows = maxRows;
     this.editor.onSubmit = (value) => {
       const answer = cleanMultiline(value).slice(0, MAX_ANSWER_LENGTH);
       if (!answer) {
@@ -189,6 +195,15 @@ export class AskUserView implements Focusable {
   }
 
   handleInput(data: string): void {
+    if (matchesKey(data, Key.ctrl("c"))) {
+      this.finish(null);
+      return;
+    }
+    if (matchesKey(data, Key.pageUp) || matchesKey(data, Key.pageDown)) {
+      this.questionOffset = Math.max(0, this.questionOffset + (matchesKey(data, Key.pageUp) ? -5 : 5));
+      this.refresh();
+      return;
+    }
     if (this.editing) {
       if (matchesKey(data, Key.escape)) {
         this.editing = false;
@@ -220,7 +235,7 @@ export class AskUserView implements Focusable {
       this.choose(this.selected);
       return;
     }
-    if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c"))) {
+    if (matchesKey(data, Key.escape)) {
       this.finish(null);
     }
   }
@@ -229,54 +244,61 @@ export class AskUserView implements Focusable {
     if (this.cachedWidth === width && this.cachedLines) return this.cachedLines;
     const safeWidth = Math.max(1, width);
     const inner = Math.max(1, safeWidth - 4);
-    const lines: string[] = [frameTop(this.theme, safeWidth, "Decision needed")];
-
-    for (const line of wrapTextWithAnsi(this.theme.bold(cleanMultiline(this.question)), inner)) {
-      lines.push(padLine(`  ${this.theme.fg("text", line)}`, safeWidth));
-    }
-    lines.push(padLine("", safeWidth));
+    const questionLines = wrapTextWithAnsi(this.theme.bold(cleanMultiline(this.question)), inner)
+      .map((line) => padLine(`  ${this.theme.fg("text", line)}`, safeWidth));
 
+    const rest: string[] = [padLine("", safeWidth)];
     this.options.forEach((option, index) => {
       const active = index === this.selected;
       const marker = option.custom ? "✎" : `${index + 1}.`;
       const prefix = active ? this.theme.fg("accent", "❯") : " ";
-      const label = `${prefix} ${marker} ${oneLine(option.label)}`;
-      lines.push(
-        padLine(
+      // Wrap long labels so options that differ only near the end stay distinguishable.
+      const labelLines = wrapTextWithAnsi(oneLine(option.label), Math.max(8, inner - 4));
+      labelLines.forEach((text, lineIndex) => {
+        const label = lineIndex === 0 ? `${prefix} ${marker} ${text}` : `${" ".repeat(marker.length + 3)}${text}`;
+        rest.push(padLine(
           active
             ? this.theme.bg("selectedBg", this.theme.fg("accent", label))
             : this.theme.fg(option.custom ? "muted" : "text", label),
           safeWidth,
-        ),
-      );
+        ));
+      });
       if (option.description) {
         for (const description of wrapTextWithAnsi(oneLine(option.description), Math.max(8, inner - 4))) {
-          lines.push(padLine(`      ${this.theme.fg("muted", description)}`, safeWidth));
+          rest.push(padLine(`      ${this.theme.fg("muted", description)}`, safeWidth));
         }
       }
     });
-
     if (this.editing) {
-      lines.push(padLine("", safeWidth));
-      lines.push(padLine(`  ${this.theme.fg("muted", "Your answer")}`, safeWidth));
+      rest.push(padLine("", safeWidth));
+      rest.push(padLine(`  ${this.theme.fg("muted", "Your answer")}`, safeWidth));
       for (const line of this.editor.render(Math.max(10, safeWidth - 4))) {
-        lines.push(padLine(`  ${line}`, safeWidth));
+        rest.push(padLine(`  ${line}`, safeWidth));
       }
     }
+    rest.push(padLine("", safeWidth));
+
+    // Keep the choices, editor, and controls on screen; a long question scrolls.
+    const questionRoom = this.maxRows() - rest.length - 3;
+    let visibleQuestion = questionLines;
+    let scrollHint = "";
+    if (questionLines.length > questionRoom) {
+      const room = Math.max(1, questionRoom);
+      this.questionOffset = Math.min(this.questionOffset, Math.max(0, questionLines.length - room));
+      visibleQuestion = questionLines.slice(this.questionOffset, this.questionOffset + room);
+      scrollHint = `pgup/pgdn question ${this.questionOffset + 1}-${this.questionOffset + visibleQuestion.length}/${questionLines.length} · `;
+    }
 
-    lines.push(padLine("", safeWidth));
-    lines.push(
-      padLine(
-        `  ${this.theme.fg(
-          "dim",
-          this.editing
-            ? "enter submit · escape choices"
-            : `up/down or 1-${this.options.length} choose · enter confirm · escape dismiss`,
-        )}`,
-        safeWidth,
-      ),
-    );
-    lines.push(frameBottom(this.theme, safeWidth));
+    const controls = this.editing
+      ? "enter submit · escape choices · ctrl+c dismiss"
+      : `up/down or 1-${this.options.length} choose · enter confirm · escape dismiss`;
+    const lines = [
+      frameTop(this.theme, safeWidth, "Decision needed"),
+      ...visibleQuestion,
+      ...rest,
+      padLine(`  ${this.theme.fg("dim", `${scrollHint}${controls}`)}`, safeWidth),
+      frameBottom(this.theme, safeWidth),
+    ];
     this.cachedWidth = width;
     this.cachedLines = lines.map((line) => truncateToWidth(line, safeWidth, ""));
     return this.cachedLines;
@@ -315,6 +337,8 @@ async function openQuestion(
         () => tui.requestRender(),
         complete,
         new Editor(tui, createEditorTheme(theme)),
+        // Matches the overlay's maxHeight (86%) minus its margin.
+        () => Math.max(8, Math.floor((tui.terminal.rows || 24) * 0.86) - 2),
       );
       return {
         get focused() {
@@ -407,9 +431,12 @@ export default function askUserExtension(pi: ExtensionAPI) {
         invalidate() {},
       };
     },
-    renderResult(result, _options, theme) {
+    renderResult(result, _options, theme, context) {
       const details = result.details as AskUserDetails | undefined;
-      const text = !details || details.cancelled
+      const errorText = result.content.find((item) => item.type === "text")?.text ?? "invalid question";
+      const text = context.isError
+        ? `${theme.fg("error", "● not asked")} ${theme.fg("muted", oneLine(errorText))}`
+        : !details || details.cancelled
         ? theme.fg("warning", "● dismissed")
         : `${theme.fg("success", "● answered")} ${theme.fg("accent", oneLine(details.answer ?? ""))}`;
       return { render: (width: number) => [truncateToWidth(text, width)], invalidate() {} };

package/extensions/background-terminals/README.md

@@ -21,19 +21,19 @@ When a model-started terminal exits, its status and a bounded output tail are de
 - live counts and status;
 - terminal list with a selected-session inspector;
 - live output, elapsed time, dimensions, command, cwd, and full-log size;
-- real PTY input;
+- real PTY input: every printable key goes to the process;
 - Ctrl+C delivery to the PTY;
-- scrolling and top/bottom navigation;
-- two-press process-stop guard.
+- PgUp/PgDn scrolling;
+- a two-press Ctrl+X process-stop guard in the detail view.
 
 ## Lifecycle and safety
 
 - Maximum eight concurrent terminals and 32 tracked entries.
 - Newest 2 MiB retained in memory per terminal.
 - Raw output spills to a mode-`0600` file under a mode-`0700` temporary session directory, capped at 64 MiB per terminal.
-- Spill backpressure pauses and resumes the PTY; reaching the cap stops log growth while retaining the newest live-output tail.
+- Under Node, spill backpressure pauses and resumes the PTY. Bun's terminal API has no pause, so the 64 MiB cap is the only bound there. Reaching the cap stops log growth while retaining the newest live-output tail.
 - Pruning an old settled terminal deletes its spill file immediately; session shutdown removes the complete temporary directory.
 - Output is sanitized before TUI or model rendering.
 - Processes run in their own PTY process group and are stopped on session shutdown, replacement, or reload.
-- Shutdown and stop operations are bounded and escalate from SIGTERM to SIGKILL.
+- Shutdown and stop operations are bounded and escalate from SIGTERM to SIGKILL. A stop finishes only when the whole process group is gone, including descendants that outlive the shell and ignore hangup.
 - Completion delivery is keyed by terminal id, so each terminal produces at most one result message.

package/extensions/background-terminals/index.ts

@@ -432,7 +432,7 @@ export default function backgroundTerminals(pi: ExtensionAPI) {
         return;
       }
       if (trimmed.startsWith("stop ")) {
-        const ids = [...new Set(trimmed.slice("stop ".length).split(/[\\s,]+/).filter(Boolean))];
+        const ids = [...new Set(trimmed.slice("stop ".length).split(/[\s,]+/).filter(Boolean))];
         if (ids.length === 0) {
           ctx.ui.notify("Usage: /term stop <id> [id…]", "error");
           return;

package/extensions/background-terminals/src/manager.ts

@@ -365,6 +365,7 @@ export class TerminalManager {
         // node-pty still knows how to terminate its direct child.
       }
     }
+    if (entry.snapshot.status !== "running") return;
     try {
       entry.pty.kill(signal);
     } catch {
@@ -372,6 +373,26 @@ export class TerminalManager {
     }
   }
 
+  /** The PTY's process group can outlive its leader when descendants ignore hangup. */
+  private groupAlive(entry: Entry): boolean {
+    if (process.platform === "win32") return false;
+    try {
+      process.kill(-entry.snapshot.pid, 0);
+      return true;
+    } catch (error) {
+      return (error as NodeJS.ErrnoException).code === "EPERM";
+    }
+  }
+
+  private async waitForStop(entry: Entry, timeoutMs: number): Promise<void> {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      if (entry.snapshot.status !== "running" && !this.groupAlive(entry)) return;
+      await Promise.race([entry.settled, wait(25)]);
+      if (entry.snapshot.status !== "running") await wait(25);
+    }
+  }
+
   async kill(ids: ReadonlyArray<string>): Promise<ReadonlyArray<TerminalSnapshot>> {
     const unique = [...new Set(ids)];
     const entries = unique.map((id) => {
@@ -380,13 +401,15 @@ export class TerminalManager {
       return entry;
     });
     await Promise.all(entries.map(async (entry) => {
-      if (entry.snapshot.status !== "running") return;
-      entry.killRequested = true;
+      // Stop is complete only when the whole group is gone, not just the leader.
+      const running = entry.snapshot.status === "running";
+      if (!running && !this.groupAlive(entry)) return;
+      if (running) entry.killRequested = true;
       this.signal(entry, "SIGTERM");
-      await Promise.race([entry.settled, wait(TERM_GRACE_MS)]);
-      if (entry.snapshot.status !== "running") return;
+      await this.waitForStop(entry, TERM_GRACE_MS);
+      if (entry.snapshot.status !== "running" && !this.groupAlive(entry)) return;
       this.signal(entry, "SIGKILL");
-      await Promise.race([entry.settled, wait(KILL_GRACE_MS)]);
+      await this.waitForStop(entry, KILL_GRACE_MS);
       if (entry.snapshot.status === "running") {
         entry.snapshot.errorText ??= "Process exit was not observed after SIGKILL; output may be incomplete.";
         await this.finalize(entry, 137, 9);
@@ -471,8 +494,10 @@ export class TerminalManager {
     if (this.disposed) return;
     this.disposed = true;
     this.settledListener = undefined;
-    const running = this.list().filter((snapshot) => snapshot.status === "running").map((snapshot) => snapshot.id);
-    if (running.length > 0) await this.kill(running);
+    const live = [...this.entries.values()]
+      .filter((entry) => entry.snapshot.status === "running" || this.groupAlive(entry))
+      .map((entry) => entry.snapshot.id);
+    if (live.length > 0) await this.kill(live);
     this.listeners.clear();
     this.idListeners.clear();
     this.entries.clear();

package/extensions/background-terminals/src/pty.ts

@@ -30,6 +30,9 @@ class BunPtyAdapter implements UniversalPty {
   private readonly dataListeners = new Set<(chunk: string) => void>();
   private readonly exitListeners = new Set<(event: { exitCode: number; signal?: number }) => void>();
   private exited = false;
+  // Chunks can split a multibyte character; a streaming decoder carries the
+  // partial bytes into the next chunk instead of emitting replacement characters.
+  private readonly decoder = new TextDecoder("utf-8");
 
   constructor(options: SpawnUniversalPtyOptions) {
     const cmd = [options.file, ...options.args];
@@ -40,14 +43,7 @@ class BunPtyAdapter implements UniversalPty {
         cols: options.cols,
         rows: options.rows,
         data: (_term: unknown, chunk: Uint8Array | string) => {
-          const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
-          for (const listener of this.dataListeners) {
-            try {
-              listener(text);
-            } catch {
-              // Ignore listener errors
-            }
-          }
+          this.emitData(typeof chunk === "string" ? chunk : this.decoder.decode(chunk, { stream: true }));
         },
       },
     });
@@ -57,6 +53,7 @@ class BunPtyAdapter implements UniversalPty {
     void this.proc.exited.then((exitCode: number) => {
       if (this.exited) return;
       this.exited = true;
+      this.emitData(this.decoder.decode());
       const signal = this.proc.signalCode
         ? typeof this.proc.signalCode === "number"
           ? this.proc.signalCode
@@ -72,6 +69,17 @@ class BunPtyAdapter implements UniversalPty {
     });
   }
 
+  private emitData(text: string) {
+    if (!text) return;
+    for (const listener of this.dataListeners) {
+      try {
+        listener(text);
+      } catch {
+        // Ignore listener errors
+      }
+    }
+  }
+
   onData(listener: (chunk: string) => void) {
     this.dataListeners.add(listener);
     return {
@@ -140,6 +148,15 @@ class NodePtyAdapter implements UniversalPty {
     this.pty.resize(cols, rows);
   }
 
+  // Flow control for spill backpressure: stop reading the PTY until the log drains.
+  pause(): void {
+    this.pty.pause();
+  }
+
+  resume(): void {
+    this.pty.resume();
+  }
+
   kill(signal?: string): void {
     this.pty.kill(signal);
   }

package/extensions/background-terminals/src/ui.ts

@@ -393,7 +393,8 @@ export class TerminalDetail implements Component, Focusable {
       this.close();
       return;
     }
-    if (data === "x") {
+    // Printable keys belong to the input field, so detail controls use modifiers.
+    if (matchesKey(data, Key.ctrl("x"))) {
       if (terminal?.status !== "running") return;
       if (this.killArmed) {
         this.killArmed = false;
@@ -404,26 +405,16 @@ export class TerminalDetail implements Component, Focusable {
       this.tui.requestRender();
       return;
     }
-    if (this.keybindings.matches(data, "tui.editor.pageUp") || data === "k") {
+    if (this.keybindings.matches(data, "tui.editor.pageUp")) {
       this.scrollOffset += Math.max(4, this.viewportHeight() - 2);
       this.tui.requestRender();
       return;
     }
-    if (this.keybindings.matches(data, "tui.editor.pageDown") || data === "j") {
+    if (this.keybindings.matches(data, "tui.editor.pageDown")) {
       this.scrollOffset = Math.max(0, this.scrollOffset - Math.max(4, this.viewportHeight() - 2));
       this.tui.requestRender();
       return;
     }
-    if (data === "g") {
-      this.scrollOffset = Number.MAX_SAFE_INTEGER;
-      this.tui.requestRender();
-      return;
-    }
-    if (data === "G") {
-      this.scrollOffset = 0;
-      this.tui.requestRender();
-      return;
-    }
     this.killArmed = false;
     this.input.handleInput(data);
     this.tui.requestRender();
@@ -462,10 +453,10 @@ export class TerminalDetail implements Component, Focusable {
     lines.push(frameBottom(theme, width));
     if (terminal.status === "running") lines.push(...this.input.render(width));
     else lines.push(truncateToWidth(`  ${theme.fg("muted", "Process settled; input is closed.")}`, width));
-    const stop = this.killArmed ? theme.fg("warning", "x again to stop") : "x stop (confirm)";
+    const stop = this.killArmed ? theme.fg("warning", "ctrl+x again to stop") : "ctrl+x stop (confirm)";
     lines.push(
       truncateToWidth(
-        theme.fg("dim", `  enter send · ctrl+c interrupt PTY · ${stop} · pgup/pgdn or j/k scroll · g/G top/bottom · ${configuredKeys(this.keybindings, "tui.select.cancel")} back`),
+        theme.fg("dim", `  enter send · ctrl+c interrupt PTY · ${stop} · pgup/pgdn scroll · ${configuredKeys(this.keybindings, "tui.select.cancel")} back`),
         width,
       ),
     );

package/extensions/context-usage/index.ts

@@ -2,6 +2,7 @@ import type { Component } from "@earendil-works/pi-tui";
 import type { ContextUsage, ExtensionAPI, ExtensionContext, SessionEntry, Theme, ToolInfo } from "@earendil-works/pi-coding-agent";
 import { buildSessionContext, convertToLlm, getAgentDir, keyText } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { createHash } from "node:crypto";
 import { homedir } from "node:os";
 import { delimiter, join } from "node:path";
 import { stripAnsi } from "./lib/ansi.ts";
@@ -528,8 +529,10 @@ function splitConfigPaths(value: string | undefined, separator = delimiter): str
   return (value ?? "").split(separator).map((entry) => expandHomePath(entry.trim())).filter(Boolean);
 }
 
-function loadContextUsageConfig(cwd: string): ContextUsageConfig {
-  const paths = [...configPaths("pi-context-usage", cwd), ...splitConfigPaths(process.env.PI_CONTEXT_USAGE_CONFIG)];
+function loadContextUsageConfig(cwd: string, projectTrusted: boolean): ContextUsageConfig {
+  // The project file applies only to trusted projects; global and explicit env paths always apply.
+  const [globalPath, projectPath] = configPaths("pi-context-usage", cwd);
+  const paths = [globalPath!, ...(projectTrusted ? [projectPath!] : []), ...splitConfigPaths(process.env.PI_CONTEXT_USAGE_CONFIG)];
   return paths.reduce<ContextUsageConfig>(
     (config, filePath) => mergeContextUsageConfig(config, readJsonConfig(filePath, parseContextUsageConfig)),
     {},
@@ -1184,13 +1187,18 @@ function buildSnapshot(
   const session = buildSessionBreakdown(sessionManager);
   const contextUsage = getContextUsage?.();
 
+  // Hash the full rendered inputs: same-length prompt or schema edits must
+  // still invalidate cached counts.
+  const contentHash = createHash("sha1")
+    .update(systemPrompt)
+    .update(JSON.stringify(pi.getAllTools().map((tool) => [tool.name, tool.description, tool.parameters])))
+    .digest("hex");
   const signature = [
-    systemPrompt.length,
+    contentHash,
     model ? `${model.provider}:${model.id}:${model.api}` : "no-model",
     `${heuristic.label}:${heuristic.textDenominator}:${heuristic.sessionDenominator}:${heuristic.toolDenominator}:${heuristic.toolNumerator}`,
     JSON.stringify(config),
     pi.getActiveTools().join(","),
-    pi.getAllTools().map((tool) => `${tool.name}:${tool.description.length}`).join(","),
     session ? `${session.thinkingChars}:${session.toolOutputChars}:${session.messageChars}:${session.messageCount}` : "no-session",
     contextUsage ? `${contextUsage.tokens}:${contextUsage.contextWindow}:${contextUsage.percent}` : "no-usage",
   ].join("|");
@@ -1481,9 +1489,10 @@ function renderSessionRows(snapshot: PrefixSnapshot, theme: Theme, width: number
     rows.push(renderMetricRow({
       label: "Total request",
       tokens: usage.tokens,
-      exact: true,
+      // Pi reports this as an estimate (last usage plus trailing messages).
+      exact: false,
       emphasis: true,
-      detail: percent && window ? `(${percent} / ${window} ctx)` : "(Pi usage)",
+      detail: percent && window ? `(${percent} / ${window} ctx)` : "(Pi estimate)",
     }, theme, layout));
     rows.push(...renderContextBar(snapshot, estimate, theme, width));
   }
@@ -1536,7 +1545,7 @@ function renderSummary(snapshot: PrefixSnapshot, theme: Theme, width = 80): stri
   const percent = formatPercent(usage?.percent ?? null);
   const budgetParts = [
     `Harness ~${compactCount(harness)}`,
-    typeof request === "number" ? `Request ${compactCount(request)}` : undefined,
+    typeof request === "number" ? `Request ~${compactCount(request)}` : undefined,
     window && window > 0 ? `/ ${contextWindowLabel(window)}` : undefined,
     percent ? `· ${percent}` : undefined,
   ].filter(Boolean).join(" ");
@@ -1656,8 +1665,9 @@ function renderExpanded(snapshot: PrefixSnapshot, theme: Theme, width: number):
   return lines;
 }
 
+// Wrap to the exact width Pi supplies; a minimum here would overflow narrow terminals.
 function wrapLines(lines: string[], width: number): string[] {
-  const maxWidth = Math.max(24, width);
+  const maxWidth = Math.max(1, width);
   const out: string[] = [];
   for (const rawLine of lines) {
     if (rawLine.length === 0) {
@@ -1737,7 +1747,7 @@ class StartupContextComponent implements Component {
       this.cachedSignature = snapshot.signature;
       this.cachedMode = this.mode;
       this.cachedWidth = width;
-      this.cachedLines = wrapLines(body, Math.max(20, width));
+      this.cachedLines = wrapLines(body, width);
       return this.cachedLines;
     } catch {
       this.cachedSignature = "context-usage-unavailable";
@@ -1746,7 +1756,7 @@ class StartupContextComponent implements Component {
       this.cachedLines = wrapLines([
         "",
         `${accent(undefined, "[Context Usage]")} unavailable while Pi finishes resuming this session`,
-      ], Math.max(20, width));
+      ], width);
       return this.cachedLines;
     }
   }
@@ -1807,9 +1817,24 @@ function isContextBlockInstalled(block: StartupContextComponent): boolean {
   return Array.isArray(chat?.children) && chat.children.includes(block);
 }
 
-function installContextBlock(block: StartupContextComponent): boolean {
+/**
+ * With quietStartup Pi renders no resource rows to anchor on. Pi's document
+ * container holds exactly [header, loaded resources, chat]; mount into the
+ * (empty) loaded-resources slot so the card sits in the same place.
+ */
+function findQuietStartupContainer(tui: unknown): ContainerLike | undefined {
+  const isContainer = (value: unknown) => !!value && typeof value === "object" && Array.isArray((value as { children?: unknown }).children);
+  const document = findContainerBy(tui, (children) => children.length === 3 && children.every(isContainer));
+  const resources = document?.children[1] as ContainerLike | undefined;
+  return resources && Array.isArray(resources.children) && resources.children.every((child) => isPrefixBlock(child) || isBlankComponent(child as Component))
+    ? resources
+    : undefined;
+}
+
+function installContextBlock(block: StartupContextComponent, allowQuietFallback = false): boolean {
   const tui = g.__piContextUsageTui;
-  const chat = findResourceChatContainer(tui) ?? g.__piContextUsageChat;
+  const chat = findResourceChatContainer(tui) ?? g.__piContextUsageChat ??
+    (allowQuietFallback ? findQuietStartupContainer(tui) : undefined);
   if (!chat || !Array.isArray(chat.children)) return false;
 
   g.__piContextUsageChat = chat;
@@ -1828,7 +1853,8 @@ function scheduleInstall(block: StartupContextComponent): void {
   let attempts = 0;
   const attempt = () => {
     attempts++;
-    if (safely(() => installContextBlock(block), false)) return;
+    // Prefer the resource-list anchor; fall back only after it has had time to render.
+    if (safely(() => installContextBlock(block, attempts > 10), false)) return;
     if (attempts < 30) {
       g.__piContextUsageInstallTimer = setTimeout(attempt, 50);
     }
@@ -1918,11 +1944,8 @@ export default function piContextUsage(pi: ExtensionAPI) {
   pi.on("session_start", async (_event, ctx) => {
     if (!ctx.hasUI) return;
 
-    // Restore Pi's normal header; this extension now renders below Pi's loaded-resource list.
-    ctx.ui.setHeader(undefined);
-
     const currentMode = g.__piContextUsageMode ?? DEFAULT_MODE;
-    const config = loadContextUsageConfig(ctx.cwd);
+    const config = loadContextUsageConfig(ctx.cwd, ctx.isProjectTrusted());
     g.__piContextUsageModel = toModelSummary(ctx.model);
     markDirty();
     const block = new StartupContextComponent(

package/extensions/firecrawl-web/auth.ts

@@ -64,7 +64,7 @@ function readCliCredentials(home: string, platform: NodeJS.Platform): { apiKey?:
 function normalizeApiUrl(value: string | undefined): string {
   const input = value?.trim() || DEFAULT_API_URL;
   const url = new URL(input);
-  const localHttp = url.protocol === "http:" && ["localhost", "127.0.0.1", "::1"].includes(url.hostname);
+  const localHttp = url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
   if (url.protocol !== "https:" && !localHttp) throw new Error("Firecrawl API URL must use HTTPS (or localhost HTTP).");
   url.pathname = url.pathname.replace(/\/+$/, "");
   return url.toString().replace(/\/$/, "");

package/extensions/firecrawl-web/client.ts

@@ -191,11 +191,16 @@ function retryAfterMs(value: string | null): number | undefined {
 function delay(ms: number, signal?: AbortSignal): Promise<void> {
   return new Promise((resolve, reject) => {
     if (signal?.aborted) return reject(signal.reason ?? new Error("Request aborted"));
-    const timer = setTimeout(resolve, ms);
-    signal?.addEventListener("abort", () => {
+    // Remove the listener on both paths so retries sharing a signal do not pile up.
+    const onAbort = () => {
       clearTimeout(timer);
-      reject(signal.reason ?? new Error("Request aborted"));
-    }, { once: true });
+      reject(signal?.reason ?? new Error("Request aborted"));
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
   });
 }
 
@@ -260,7 +265,12 @@ export async function firecrawlRequest(
       });
 
       const contentLength = Number(response.headers.get("content-length") || 0);
-      if (contentLength > MAX_RESPONSE_BYTES) throw new Error("Firecrawl response exceeded 25 MiB.");
+      if (contentLength > MAX_RESPONSE_BYTES) {
+        // Stop the transfer instead of leaving the body streaming in the background.
+        await response.body?.cancel("Firecrawl response exceeded 25 MiB.").catch(() => undefined);
+        timeout.abort(new Error("Firecrawl response exceeded 25 MiB."));
+        throw new Error("Firecrawl response exceeded 25 MiB.");
+      }
       const bytes = await readResponseBounded(response);
       const text = new TextDecoder().decode(bytes);
       let payload: unknown;

package/extensions/firecrawl-web/output.ts

@@ -26,8 +26,11 @@ async function writeArtifact(operation: string, value: unknown): Promise<string>
   return path;
 }
 
+// Room for the artifact footer, so the returned text stays within Pi's limits.
+const FOOTER_RESERVE_BYTES = 512;
+
 async function boundOutput(text: string, operation: string, raw: unknown, forceArtifact = false): Promise<string> {
-  const bounded = truncateHead(text, { maxBytes: DEFAULT_MAX_BYTES, maxLines: DEFAULT_MAX_LINES });
+  const bounded = truncateHead(text, { maxBytes: DEFAULT_MAX_BYTES - FOOTER_RESERVE_BYTES, maxLines: DEFAULT_MAX_LINES - 2 });
   if (!bounded.truncated && !forceArtifact) return text;
   const path = await writeArtifact(operation, raw);
   if (!bounded.truncated) return `${text}\n\n[Complete Firecrawl response saved to: ${path}]`;