@blackbelt-technology/pi-agent-dashboard 0.4.6 → 0.5.1

package/packages/extension/src/bridge.ts

@@ -4,12 +4,14 @@
  * Global extension that connects to the dashboard server,
  * forwards all pi events, and relays commands back.
  */
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { Loader } from "@mariozechner/pi-tui";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Loader } from "@earendil-works/pi-tui";
 import { ConnectionManager } from "./connection.js";
 import { detectSessionSource } from "./source-detector.js";
 import { mapEventToProtocol } from "./event-forwarder.js";
 import { createCommandHandler } from "./command-handler.js";
+import { RetryTracker } from "./retry-tracker.js";
+import { UsageLimitOrderer } from "./usage-limit-orderer.js";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -27,7 +29,7 @@ import { PromptBus } from "./prompt-bus.js";
 import { DashboardDefaultAdapter } from "./dashboard-default-adapter.js";
 import { registerAskUserTool } from "./ask-user-tool.js";
 import { decodeMultiselectAnswer } from "./multiselect-decode.js";
-import { activate as activateProviderRegister, onProviderChanged, reloadProviders } from "./provider-register.js";
+import { activate as activateProviderRegister, onProviderChanged, reloadProviders, buildProviderCatalogue } from "./provider-register.js";
 import type { FlowInfo } from "@blackbelt-technology/pi-dashboard-shared/types.js";
 import { startMetricsMonitor, stopMetricsMonitor, collectMetrics } from "./process-metrics.js";
 import { scanChildProcesses } from "./process-scanner.js";
@@ -37,6 +39,7 @@ import { sendStateSync as _sendStateSync, replaySessionEntries as _replaySession
 import { sendModelUpdateIfChanged as _sendModelUpdateIfChanged, sendSessionNameIfChanged as _sendSessionNameIfChanged, sendGitInfoIfChanged as _sendGitInfoIfChanged, sendJjStateIfChanged as _sendJjStateIfChanged, resetReconnectCaches as _resetReconnectCaches } from "./model-tracker.js";
 import { registerFlowEventListeners, FLOW_EVENT_MAP, SUBAGENT_EVENT_MAP } from "./flow-event-wiring.js";
 import { refreshUiModules, subscribeUiInvalidate, handleUiManagement, type UiModulesBridgeCtx } from "./ui-modules.js";
+import { inlineMessageText, type ReadFileOutcome } from "./markdown-image-inliner.js";
 
 const HEARTBEAT_INTERVAL = 15_000;
 const GIT_POLL_INTERVAL = 30_000;
@@ -190,6 +193,22 @@ function initBridge(pi: ExtensionAPI) {
   let hasRegisteredOnce = false; // see change: reattach-move-to-front
   let promptBus: PromptBus | undefined;
 
+  // Provider-retry synthesis trackers. pi's ExtensionAPI does not expose
+  // `auto_retry_*` events, so the bridge synthesizes them from observed
+  // `message_end` / `agent_end` events. See change: fix-provider-retry-infinite-loop.
+  const retryTracker = new RetryTracker();
+  const usageLimitOrderer = new UsageLimitOrderer();
+
+  /** Forward a synthesized auto_retry_* event using the standard event_forward shape. */
+  const sendSyntheticRetryEvent = (eventType: string, data: Record<string, unknown>): void => {
+    if (!isActive() || !sessionReady) return;
+    connection.send({
+      type: "event_forward",
+      sessionId,
+      event: { eventType, timestamp: Date.now(), data },
+    });
+  };
+
   // ── Per-message entry id tracking (for fix-per-message-fork) ──
   // Pi 0.69+ awaits extension handlers BEFORE sessionManager.appendMessage runs,
   // which means getLeafId() at emit time returns the previous leaf, not the
@@ -209,6 +228,96 @@ function initBridge(pi: ExtensionAPI) {
   let appendMessageWrapped = false;
   let lastWrappedSm: any = null;
 
+  // ---------------------------------------------------------------------
+  // Markdown-image inliner state (chat-markdown-local-images-and-math).
+  // Per-sessionId set of asset hashes for which an `asset_register` has
+  // already been emitted on this WebSocket. Survives across message events
+  // within the same session; reset when the session id changes (in
+  // session_start). The Map keys are sessionId strings.
+  // ---------------------------------------------------------------------
+  const emittedAssetHashesBySession = new Map<string, Set<string>>();
+  function getEmittedAssetHashes(sid: string): Set<string> {
+    let s = emittedAssetHashesBySession.get(sid);
+    if (!s) {
+      s = new Set<string>();
+      emittedAssetHashesBySession.set(sid, s);
+    }
+    return s;
+  }
+
+  /**
+   * Synchronous fs probe + read for the inliner. Wraps `fs.statSync` /
+   * `fs.readFileSync` and maps Node errno strings to the
+   * `ReadFileOutcome.kind` enum used by the pure inliner. Order: stat
+   * first so directories report EISDIR even when the path has no file
+   * extension.
+   */
+  function inlinerReadFile(absolutePath: string): ReadFileOutcome {
+    try {
+      const st = fs.statSync(absolutePath);
+      if (st.isDirectory()) return { ok: false, kind: "EISDIR" };
+      if (!st.isFile()) return { ok: false, kind: "EOTHER" };
+      const bytes = fs.readFileSync(absolutePath);
+      return { ok: true, bytes };
+    } catch (err: any) {
+      const code = err?.code;
+      if (code === "ENOENT") return { ok: false, kind: "ENOENT" };
+      if (code === "EACCES") return { ok: false, kind: "EACCES" };
+      if (code === "EISDIR") return { ok: false, kind: "EISDIR" };
+      return { ok: false, kind: "EOTHER" };
+    }
+  }
+
+  /**
+   * Apply the markdown-image inliner to an assistant message_update /
+   * message_end event. Mutates `event.message.content` in place (string
+   * → rewritten string; array<{type:"text",text}> → rewritten text in
+   * each text block). Emits `asset_register` messages BEFORE returning so
+   * the caller's subsequent `connection.send(eventForward)` lands AFTER
+   * the assets it references. User-role and thinking events are no-ops.
+   */
+  function maybeInlineAssistantImages(event: any): void {
+    const msg = event?.message;
+    if (!msg || typeof msg !== "object") return;
+    if (msg.role !== "assistant") return;
+    // Use the *current* live cwd if available; fall back to the bridge
+    // process cwd. The inliner resolves relative `./pic.png` against this.
+    const cwd = (cachedCtx?.cwd as string | undefined) ?? process.cwd();
+    const alreadyEmitted = getEmittedAssetHashes(sessionId);
+    const allAssets: { hash: string; mimeType: string; data: string }[] = [];
+
+    const rewriteOne = (text: string): string => {
+      const r = inlineMessageText(text, {
+        readFile: inlinerReadFile,
+        cwd,
+        alreadyEmitted,
+      });
+      for (const a of r.assetsToEmit) allAssets.push(a);
+      return r.rewritten;
+    };
+
+    if (typeof msg.content === "string") {
+      msg.content = rewriteOne(msg.content);
+    } else if (Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block && typeof block === "object" && block.type === "text" && typeof block.text === "string") {
+          block.text = rewriteOne(block.text);
+        }
+      }
+    }
+
+    // Send each new asset BEFORE the (rewritten) message event lands.
+    for (const a of allAssets) {
+      connection.send({
+        type: "asset_register",
+        sessionId,
+        hash: a.hash,
+        mimeType: a.mimeType,
+        data: a.data,
+      });
+    }
+  }
+
   /**
    * Wrap ctx.sessionManager.appendMessage once per session so that when pi
    * generates an entry id we capture it in the WeakMap and emit
@@ -330,6 +439,8 @@ function initBridge(pi: ExtensionAPI) {
               id: m.id,
             }));
             connection.send({ type: "models_list", sessionId, models });
+            // See change: replace-hardcoded-provider-lists.
+            connection.send({ type: "providers_list", sessionId, providers: buildProviderCatalogue() });
           } catch (err) { console.error("[dashboard] models_list push failed:", err); }
         }
         return;
@@ -555,6 +666,14 @@ function initBridge(pi: ExtensionAPI) {
       if (cachedCtx?.abort) {
         cachedCtx.abort();
       }
+      // Clear retry-synthesis trackers — the user-initiated abort path
+      // already synthesizes its own auto_retry_end via command-handler.
+      // See change: fix-provider-retry-infinite-loop.
+      retryTracker.noteAbort(sessionId);
+      usageLimitOrderer.noteRetryEnd(sessionId);
+    },
+    isIdle: () => {
+      try { return cachedCtx?.isIdle?.() ?? false; } catch { return false; }
     },
     eventSink: (msg) => connection.send(msg),
     compact: (opts) => {
@@ -709,7 +828,25 @@ function initBridge(pi: ExtensionAPI) {
       if (!sessionReady) return;
       // Track agent streaming state (survives reconnect/reload)
       if (eventType === "agent_start") getBridgeState().isAgentStreaming = true;
-      if (eventType === "agent_end") getBridgeState().isAgentStreaming = false;
+      if (eventType === "agent_end") {
+        getBridgeState().isAgentStreaming = false;
+        // Provider-retry synthesis: forward auto_retry_end BEFORE agent_end
+        // when retries were in flight, so the dashboard's retry banner
+        // clears before the error banner appears. The usage-limit orderer
+        // takes precedence (it carries the actual error string); the retry
+        // tracker handles the non-usage-limit case. See change:
+        // fix-provider-retry-infinite-loop.
+        const orderedSynth = usageLimitOrderer.maybeSynthesize(sessionId, (event as any));
+        if (orderedSynth) {
+          sendSyntheticRetryEvent(orderedSynth.eventType, orderedSynth.data);
+          retryTracker.noteAbort(sessionId); // clear tracker; orderer's event is authoritative
+        } else {
+          const trackerSynth = retryTracker.observeAgentEnd(sessionId, event as any);
+          if (trackerSynth) {
+            sendSyntheticRetryEvent(trackerSynth.eventType, trackerSynth.data);
+          }
+        }
+      }
       // For model_select, enrich the event data with thinkingLevel
       if (eventType === "model_select") {
         const enriched = { ...event, thinkingLevel: (pi as any).getThinkingLevel?.() };
@@ -765,6 +902,11 @@ function initBridge(pi: ExtensionAPI) {
         if (messageRef && typeof messageRef === "object" && !pendingNonces.has(messageRef as object)) {
           pendingNonces.set(messageRef as object, nonce);
         }
+        // Apply markdown image inliner to assistant content. Mutates
+        // event.message.content in place AND ships any new asset_register
+        // messages immediately so they precede the deferred message_end
+        // send below. See change: chat-markdown-local-images-and-math.
+        maybeInlineAssistantImages(event);
         setTimeout(() => {
           if (!isActive() || !sessionReady) return;
           const entryId =
@@ -774,10 +916,29 @@ function initBridge(pi: ExtensionAPI) {
           const enriched = { ...event, entryId, nonce };
           const protoMsg = mapEventToProtocol(sessionId, enriched);
           connection.send(protoMsg);
+          // After forwarding the original message_end, ask the retry tracker
+          // whether to synthesize an auto_retry_* event. See change:
+          // fix-provider-retry-infinite-loop.
+          const synthetic = retryTracker.observeMessageEnd(sessionId, messageRef as any);
+          if (synthetic) {
+            sendSyntheticRetryEvent(synthetic.eventType, synthetic.data);
+            if (synthetic.eventType === "auto_retry_start") {
+              usageLimitOrderer.noteRetryStart(sessionId);
+            } else {
+              usageLimitOrderer.noteRetryEnd(sessionId);
+            }
+          }
         }, 0);
         return;
       }
 
+      // Apply markdown image inliner to assistant message_update events.
+      // For other event types this is a no-op (role check inside the helper).
+      // See change: chat-markdown-local-images-and-math.
+      if (eventType === "message_update") {
+        maybeInlineAssistantImages(event);
+      }
+
       const msg = mapEventToProtocol(sessionId, event);
       connection.send(msg);
     }));
@@ -1155,6 +1316,8 @@ function initBridge(pi: ExtensionAPI) {
           id: m.id,
         }));
         connection.send({ type: "models_list", sessionId, models });
+        // See change: replace-hardcoded-provider-lists.
+        connection.send({ type: "providers_list", sessionId, providers: buildProviderCatalogue() });
       } catch { /* modelRegistry not available */ }
     }
 
@@ -1374,6 +1537,8 @@ function initBridge(pi: ExtensionAPI) {
           id: m.id,
         }));
         connection.send({ type: "models_list", sessionId, models });
+        // See change: replace-hardcoded-provider-lists.
+        connection.send({ type: "providers_list", sessionId, providers: buildProviderCatalogue() });
       } catch { /* ignore */ }
 
       // Retry pending default model — custom provider may now have its models

package/packages/extension/src/command-handler.ts

@@ -3,7 +3,7 @@
  */
 import { readdirSync } from "node:fs";
 import { join, relative } from "node:path";
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type {
   ServerToExtensionMessage,
   ExtensionToServerMessage,
@@ -12,6 +12,7 @@ import { killProcessByPgid } from "./process-scanner.js";
 import type { FileEntry, PiSessionInfo } from "@blackbelt-technology/pi-dashboard-shared/types.js";
 import { filterHiddenCommands } from "./bridge-context.js";
 import { expandPromptTemplateFromDisk } from "./prompt-expander.js";
+import { buildProviderCatalogue } from "./provider-register.js";
 
 const IGNORE_DIRS = new Set([".git", "node_modules", ".next", "dist", "build", ".cache", "__pycache__", ".venv"]);
 const MAX_RESULTS = 20;
@@ -144,6 +145,11 @@ export function createCommandHandler(
     getThinkingLevel?: () => string | undefined;
     shutdown?: () => void;
     abort?: () => void;
+    /**
+     * Probe agent idleness for the persistent-abort scheduler.
+     * See change: fix-provider-retry-infinite-loop.
+     */
+    isIdle?: () => boolean;
     getCwd?: () => string;
     /** Callback to send events (e.g., bash_output, command_feedback) back to server */
     eventSink?: (msg: ExtensionToServerMessage) => void;
@@ -160,6 +166,33 @@ export function createCommandHandler(
   },
 ): CommandHandler {
   const getSessionId = typeof sessionIdOrGetter === "function" ? sessionIdOrGetter : () => sessionIdOrGetter;
+
+  /**
+   * Persistent-abort scheduler. Re-invokes `options.abort()` at 200ms
+   * intervals for up to 2 seconds, breaking early when `options.isIdle()`
+   * returns true. Closes the retry race window in pi-coding-agent.
+   * See change: fix-provider-retry-infinite-loop.
+   */
+  const PERSISTENT_ABORT_INTERVAL_MS = 200;
+  const PERSISTENT_ABORT_MAX_MS = 2000;
+  function schedulePersistentAbort(opts: NonNullable<typeof options>): void {
+    if (!opts.abort) return;
+    const startedAt = Date.now();
+    const interval = setInterval(() => {
+      if (Date.now() - startedAt >= PERSISTENT_ABORT_MAX_MS) {
+        clearInterval(interval);
+        return;
+      }
+      try {
+        if (opts.isIdle?.()) {
+          clearInterval(interval);
+          return;
+        }
+      } catch { /* probe failure — keep trying */ }
+      try { opts.abort?.(); } catch { /* idempotent */ }
+    }, PERSISTENT_ABORT_INTERVAL_MS);
+  }
+
   return {
     async handle(msg: ServerToExtensionMessage): Promise<ExtensionToServerMessage | undefined> {
       const sessionId = getSessionId();
@@ -291,6 +324,31 @@ export function createCommandHandler(
           if (options?.abort) {
             options.abort();
           }
+          // Synthesize an immediate auto_retry_end so the dashboard clears
+          // any in-flight retry banner without waiting for pi's natural
+          // auto_retry_end (which is delayed by the abortable-sleep cancel
+          // window AND, on extension API, never reaches us at all — see
+          // https://github.com/badlogic/pi-mono/discussions/2073). The
+          // reducer no-ops auto_retry_end when retryState is undefined,
+          // so this is idempotent against later events.
+          if (options?.eventSink) {
+            options.eventSink({
+              type: "event_forward",
+              sessionId,
+              event: {
+                eventType: "auto_retry_end",
+                timestamp: Date.now(),
+                data: { success: false, attempt: -1, finalError: "Aborted by user" },
+              },
+            });
+          }
+          // Persistent-abort scheduler: pi-coding-agent's _retryAbortController
+          // is briefly `undefined` between sleep-end and the next
+          // agent.continue() call. An abort that arrives in that window is
+          // a no-op against the retry. Re-invoke abort every 200ms for up
+          // to 2s, breaking early when the agent is idle.
+          // See change: fix-provider-retry-infinite-loop.
+          if (options) schedulePersistentAbort(options);
           return undefined;
 
         case "request_commands": {
@@ -344,6 +402,11 @@ export function createCommandHandler(
           return { type: "models_list", sessionId, models: [] };
         }
 
+        case "request_providers": {
+          // See change: replace-hardcoded-provider-lists.
+          return { type: "providers_list", sessionId, providers: buildProviderCatalogue() };
+        }
+
         case "set_thinking_level":
           if (options?.setThinkingLevel) {
             options.setThinkingLevel(msg.level);
@@ -388,7 +451,7 @@ export function createCommandHandler(
         case "list_sessions": {
           try {
             // Dynamic import to avoid hard dependency at module load
-            const { SessionManager } = await import("@mariozechner/pi-coding-agent") as any;
+            const { SessionManager } = await import("@earendil-works/pi-coding-agent") as any;
             const cwd = msg.cwd || options?.getCwd?.() || process.cwd();
             const sessionInfos = await SessionManager.list(cwd);
             const sessions: PiSessionInfo[] = (sessionInfos || []).map((s: any) => ({

package/packages/extension/src/flow-event-wiring.ts

@@ -2,7 +2,7 @@
  * Flow event wiring: registers listeners for pi-flows events
  * and forwards them as protocol messages to the dashboard server.
  */
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { BridgeContext } from "./bridge-context.js";
 import { filterHiddenCommands } from "./bridge-context.js";
 import type { FlowInfo } from "@blackbelt-technology/pi-dashboard-shared/types.js";

package/packages/extension/src/markdown-image-inliner.ts

@@ -0,0 +1,268 @@
+/**
+ * Markdown image inliner for the bridge.
+ *
+ * Scans assistant message text for fully-closed `![alt](src)` markdown image
+ * tokens, reads any local-path file references, hashes the bytes, and
+ * rewrites the token to `![alt](pi-asset:<hash>)`. Bytes ride out of band
+ * via `asset_register` events (one per unique hash per session). The text
+ * itself only ever carries the short `pi-asset:<hash>` token, keeping
+ * streaming `message_update` events bandwidth-bounded.
+ *
+ * The core helper `inlineMessageText` is **pure** — all I/O is delegated to
+ * the injected `readFile` callback so tests can drive every branch with
+ * memory fixtures. The bridge wires `readFile = node:fs.readFileSync` plus
+ * a per-session `alreadyEmitted: Set<string>` of hashes already shipped.
+ *
+ * See change: chat-markdown-local-images-and-math.
+ */
+import { createHash } from "node:crypto";
+import path from "node:path";
+
+/** Per-image hard cap (decision D8). */
+export const MAX_PER_IMAGE_BYTES = 5 * 1024 * 1024;
+/** Per-message cumulative cap on **newly-inlined** asset bytes (decision D8). */
+export const MAX_PER_MESSAGE_BYTES = 20 * 1024 * 1024;
+
+/** MIME allowlist keyed by lowercased extension. Decision D8. */
+const MIME_BY_EXT: Record<string, string> = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".avif": "image/avif",
+  ".bmp": "image/bmp",
+};
+
+/** Matches a fully-closed `![alt](src)` markdown image token. */
+const IMAGE_TOKEN_RE = /!\[([^\]\n]*)\]\(([^)\n\s]+)\)/g;
+
+export interface ParsedImageToken {
+  /** The full original `![alt](src)` substring. */
+  token: string;
+  alt: string;
+  src: string;
+  /** Start offset within the input text. */
+  index: number;
+  length: number;
+}
+
+/**
+ * Find every fully-closed `![alt](src)` token in `text`. Partial tokens
+ * (e.g. `![alt](/path/x` without closing `)`) are NOT returned — the
+ * regex requires the closing paren. Tokens spanning newlines are NOT
+ * returned (markdown doesn't allow newlines inside the URL portion).
+ */
+export function parseImageTokens(text: string): ParsedImageToken[] {
+  const out: ParsedImageToken[] = [];
+  let match: RegExpExecArray | null;
+  IMAGE_TOKEN_RE.lastIndex = 0;
+  while ((match = IMAGE_TOKEN_RE.exec(text)) !== null) {
+    out.push({
+      token: match[0],
+      alt: match[1] ?? "",
+      src: match[2] ?? "",
+      index: match.index,
+      length: match[0].length,
+    });
+  }
+  return out;
+}
+
+/**
+ * Returns true iff `src` looks like a local filesystem path (i.e. NOT an
+ * already-resolved web URL, data URL, blob URL, fragment, or pre-rewritten
+ * `pi-asset:<hash>` token). Idempotency hinges on `pi-asset:` returning
+ * `false` here.
+ */
+export function isLocalSrc(src: string): boolean {
+  if (!src) return false;
+  if (src.startsWith("data:")) return false;
+  if (src.startsWith("blob:")) return false;
+  if (src.startsWith("http://")) return false;
+  if (src.startsWith("https://")) return false;
+  if (src.startsWith("pi-asset:")) return false;
+  if (src.startsWith("#")) return false;
+  // `file://` prefix — treat the rest as a local path.
+  return true;
+}
+
+/**
+ * Resolve `src` to an absolute path against `cwd`. `file://` prefix is
+ * stripped. Absolute paths pass through. Relative paths resolve against
+ * `cwd`.
+ */
+export function resolveLocalPath(src: string, cwd: string): string {
+  let raw = src;
+  if (raw.startsWith("file://")) raw = raw.slice("file://".length);
+  if (path.isAbsolute(raw)) return raw;
+  return path.resolve(cwd, raw);
+}
+
+/**
+ * Detect MIME from the file extension (case-insensitive). Returns null
+ * if the extension is not in the image allowlist.
+ */
+export function mimeFromExtension(filePath: string): string | null {
+  const ext = path.extname(filePath).toLowerCase();
+  return MIME_BY_EXT[ext] ?? null;
+}
+
+/**
+ * Hash file bytes to a 16-hex-char identifier (sha256 truncated). Decision D4.
+ */
+export function hashBytes(buf: Buffer): string {
+  return createHash("sha256").update(buf).digest("hex").slice(0, 16);
+}
+
+/** Format a byte count to a one-decimal MB string for placeholder text. */
+function formatMB(bytes: number): string {
+  return (bytes / (1024 * 1024)).toFixed(1);
+}
+
+/** Bridge-side per-file read result; thin enough to mock in tests. */
+export interface ReadFileResult {
+  ok: true;
+  bytes: Buffer;
+}
+export interface ReadFileError {
+  ok: false;
+  /** Use ENOENT/EACCES/EISDIR/EOTHER. EACCES is folded into ENOENT in placeholder text. */
+  kind: "ENOENT" | "EACCES" | "EISDIR" | "EOTHER";
+}
+export type ReadFileOutcome = ReadFileResult | ReadFileError;
+
+export interface InlineOptions {
+  /** Synchronous file-read callback. Bridge wires this to `node:fs.readFileSync` + `fs.statSync`. */
+  readFile: (absolutePath: string) => ReadFileOutcome;
+  /** Working directory used to resolve relative srcs. */
+  cwd: string;
+  /**
+   * Per-session set of hashes for which an `asset_register` has already been
+   * emitted. The inliner checks-then-adds so dedup is automatic across
+   * multiple message events within the same session.
+   */
+  alreadyEmitted: Set<string>;
+  /** Override the per-image cap. Default `MAX_PER_IMAGE_BYTES`. */
+  maxPerImageBytes?: number;
+  /** Override the per-message cap. Default `MAX_PER_MESSAGE_BYTES`. */
+  maxPerMessageBytes?: number;
+}
+
+export interface AssetToEmit {
+  hash: string;
+  mimeType: string;
+  /** Base64-encoded bytes ready for the `asset_register` message. */
+  data: string;
+}
+
+export interface InlineResult {
+  /** The rewritten text with every applicable token replaced. */
+  rewritten: string;
+  /** Newly-discovered assets to emit BEFORE the message_update / message_end. */
+  assetsToEmit: AssetToEmit[];
+}
+
+/**
+ * Pure inliner. Scans `text` for image tokens; rewrites local-path tokens
+ * either to `![alt](pi-asset:<hash>)` (success) or to a visible placeholder
+ * text (file too large / unsupported MIME / read error / message budget
+ * exhausted). Tokens with web/data/blob/pi-asset/# srcs pass through
+ * unchanged. Idempotent — re-running on already-rewritten text yields the
+ * same output (because `pi-asset:` returns `false` from `isLocalSrc`).
+ */
+export function inlineMessageText(text: string, opts: InlineOptions): InlineResult {
+  const tokens = parseImageTokens(text);
+  if (tokens.length === 0) {
+    return { rewritten: text, assetsToEmit: [] };
+  }
+
+  const maxPerImage = opts.maxPerImageBytes ?? MAX_PER_IMAGE_BYTES;
+  const maxPerMessage = opts.maxPerMessageBytes ?? MAX_PER_MESSAGE_BYTES;
+
+  const assetsToEmit: AssetToEmit[] = [];
+  let bytesInThisMessage = 0;
+
+  // Build the rewritten string by stitching segments separated by token
+  // replacements. Walk tokens left-to-right; tokens that pass through
+  // unchanged keep their original substring.
+  const out: string[] = [];
+  let cursor = 0;
+
+  for (const tok of tokens) {
+    // Append the segment before this token verbatim.
+    out.push(text.slice(cursor, tok.index));
+    cursor = tok.index + tok.length;
+
+    if (!isLocalSrc(tok.src)) {
+      // External / data: / pi-asset: / fragment — pass through unchanged.
+      out.push(tok.token);
+      continue;
+    }
+
+    const absPath = resolveLocalPath(tok.src, opts.cwd);
+
+    // Order matters here:
+    //   1. readFile FIRST so EISDIR / ENOENT / EACCES are reported with
+    //      their proper placeholders even when the path has no extension
+    //      (e.g. `/home/me` resolving to a directory).
+    //   2. mimeFromExtension after a successful read so an existing file
+    //      with a non-image extension reports "unsupported image type"
+    //      rather than a generic read failure.
+    //   3. hashBytes so we can consult `alreadyEmitted` BEFORE the
+    //      per-image and per-message caps. Already-registered assets bypass
+    //      caps because their bytes were paid for on the previous emission.
+    //   4. Per-image cap and per-message budget gate ONLY new emissions.
+    const outcome = opts.readFile(absPath);
+    if (!outcome.ok) {
+      // EACCES is folded into ENOENT placeholder to avoid leaking permission
+      // existence. EISDIR / EOTHER use the generic "read failed" wording.
+      if (outcome.kind === "ENOENT" || outcome.kind === "EACCES") {
+        out.push(`[image not found: ${tok.src}]`);
+      } else {
+        out.push(`[image read failed: ${tok.src}]`);
+      }
+      continue;
+    }
+
+    const mime = mimeFromExtension(absPath);
+    if (!mime) {
+      out.push(`[unsupported image type: ${tok.src}]`);
+      continue;
+    }
+
+    const hash = hashBytes(outcome.bytes);
+
+    if (opts.alreadyEmitted.has(hash)) {
+      // Bytes already shipped earlier in the session — only the token rewrites.
+      // Caps are bypassed: dedup means no new bytes go on the wire.
+      out.push(`![${tok.alt}](pi-asset:${hash})`);
+      continue;
+    }
+
+    const size = outcome.bytes.length;
+    if (size > maxPerImage) {
+      out.push(`[image too large: ${tok.src} (${formatMB(size)} MB)]`);
+      continue;
+    }
+
+    // New asset. Check the per-message budget before committing.
+    if (bytesInThisMessage + size > maxPerMessage) {
+      out.push(`[message asset budget exhausted: ${tok.src}]`);
+      continue;
+    }
+
+    bytesInThisMessage += size;
+    opts.alreadyEmitted.add(hash);
+    assetsToEmit.push({
+      hash,
+      mimeType: mime,
+      data: outcome.bytes.toString("base64"),
+    });
+    out.push(`![${tok.alt}](pi-asset:${hash})`);
+  }
+
+  out.push(text.slice(cursor));
+  return { rewritten: out.join(""), assetsToEmit };
+}

package/packages/extension/src/multiselect-list.ts

@@ -23,7 +23,7 @@ interface Item {
 
 /**
  * Minimal shape of pi-tui's `Component` interface — we avoid importing from
- * `@mariozechner/pi-tui` directly so this module stays compile-friendly when
+ * `@earendil-works/pi-tui` directly so this module stays compile-friendly when
  * that peer dep isn't present (e.g. in unit tests running via vitest without
  * the full pi runtime).
  */