@pi-unipi/unipi 3.0.0-alpha.39 → 3.0.0-alpha.40

package/CHANGELOG.md

@@ -6,6 +6,24 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [3.0.0-alpha.40] — 2026-10-12
+
+### Added
+- Typing `/` in the UniPi app suggests every command pi has, and `/command ` suggests that command's arguments, the same as in the terminal. A command's replies now show in the chat under the command. (UNI-276)
+- `/unipi:dream` suggests its subcommands (status, tray, report, run, stop, approve, reject).
+- App search: the UniPi app can search the whole session by meaning (word forms, typos, phrases) and jump to a match. (UNI-275)
+- Memory: the first session that finds 2.x memories asks once whether to convert them. (UNI-272)
+- Upgrade guide from 2.20 to 3.0: `docs/guide/upgrade-3.0.md`. (UNI-272)
+
+### Changed
+- `/unipi:visualize-progress` is calmer: one title, one bar, smaller boxes and the three newest log lines. When Goal mode is on but no goal has started yet, it says so instead of "No long-horizon mode active". (UNI-274)
+
+### Fixed
+- `/unipi:ralph <text>` + Enter no longer clears the text. (UNI-277)
+- `/unipi:goal`, `/unipi:swarm`, `/unipi:graph` and `/unipi:ralph` prompts (and `resume`) sent while the agent was working were silently dropped. They now run when the current turn ends. (UNI-276)
+- `/unipi:summarize` no longer freezes the input for the whole summary, and queues itself instead of refusing while the agent works. `/unipi:goal status` (the progress estimate), `/unipi:kanboard open|status|doctor` and `/unipi:memory-forget` run in the background, and `/unipi:session-recall` sent mid-run waits for the turn to end. (UNI-276)
+- Updater: an alpha install that is offered 3.0.0 stable now installs it, instead of reinstalling the alpha. (UNI-272)
+
 ## [3.0.0-alpha.39] — 2026-10-11
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/unipi",
-  "version": "3.0.0-alpha.39",
+  "version": "3.0.0-alpha.40",
   "description": "All-in-one extension suite for Pi coding agent",
   "type": "module",
   "license": "MIT",
@@ -80,28 +80,28 @@
     "typebox": "^1.1.38"
   },
   "dependencies": {
-    "@pi-unipi/app-bridge": "3.0.0-alpha.39",
-    "@pi-unipi/ask-user": "3.0.0-alpha.39",
-    "@pi-unipi/background-tasks": "3.0.0-alpha.39",
-    "@pi-unipi/btw": "3.0.0-alpha.39",
-    "@pi-unipi/command-enchantment": "3.0.0-alpha.39",
-    "@pi-unipi/compactor": "3.0.0-alpha.39",
-    "@pi-unipi/core": "3.0.0-alpha.39",
-    "@pi-unipi/dream": "3.0.0-alpha.39",
-    "@pi-unipi/footer": "3.0.0-alpha.39",
-    "@pi-unipi/fusion": "3.0.0-alpha.39",
-    "@pi-unipi/info-screen": "3.0.0-alpha.39",
-    "@pi-unipi/input-shortcuts": "3.0.0-alpha.39",
-    "@pi-unipi/kanboard": "3.0.0-alpha.39",
-    "@pi-unipi/mcp": "3.0.0-alpha.39",
-    "@pi-unipi/memory": "3.0.0-alpha.39",
-    "@pi-unipi/notify": "3.0.0-alpha.39",
-    "@pi-unipi/skill-registry": "3.0.0-alpha.39",
-    "@pi-unipi/subagents": "3.0.0-alpha.39",
-    "@pi-unipi/updater": "3.0.0-alpha.39",
-    "@pi-unipi/utility": "3.0.0-alpha.39",
-    "@pi-unipi/web-api": "3.0.0-alpha.39",
-    "@pi-unipi/workflow": "3.0.0-alpha.39",
+    "@pi-unipi/app-bridge": "3.0.0-alpha.40",
+    "@pi-unipi/ask-user": "3.0.0-alpha.40",
+    "@pi-unipi/background-tasks": "3.0.0-alpha.40",
+    "@pi-unipi/btw": "3.0.0-alpha.40",
+    "@pi-unipi/command-enchantment": "3.0.0-alpha.40",
+    "@pi-unipi/compactor": "3.0.0-alpha.40",
+    "@pi-unipi/core": "3.0.0-alpha.40",
+    "@pi-unipi/dream": "3.0.0-alpha.40",
+    "@pi-unipi/footer": "3.0.0-alpha.40",
+    "@pi-unipi/fusion": "3.0.0-alpha.40",
+    "@pi-unipi/info-screen": "3.0.0-alpha.40",
+    "@pi-unipi/input-shortcuts": "3.0.0-alpha.40",
+    "@pi-unipi/kanboard": "3.0.0-alpha.40",
+    "@pi-unipi/mcp": "3.0.0-alpha.40",
+    "@pi-unipi/memory": "3.0.0-alpha.40",
+    "@pi-unipi/notify": "3.0.0-alpha.40",
+    "@pi-unipi/skill-registry": "3.0.0-alpha.40",
+    "@pi-unipi/subagents": "3.0.0-alpha.40",
+    "@pi-unipi/updater": "3.0.0-alpha.40",
+    "@pi-unipi/utility": "3.0.0-alpha.40",
+    "@pi-unipi/web-api": "3.0.0-alpha.40",
+    "@pi-unipi/workflow": "3.0.0-alpha.40",
     "@resvg/resvg-wasm": "^2.6.2",
     "beautiful-mermaid": "^1.1.3"
   },

package/packages/app-bridge/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/app-bridge",
-  "version": "3.0.0-alpha.39",
+  "version": "3.0.0-alpha.40",
   "description": "Live bridge between a pi TUI session and the UniPi phone app — streaming chat, prompts, steering and dialogs from the phone",
   "type": "module",
   "main": "index.ts",
@@ -31,7 +31,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "3.0.0-alpha.39"
+    "@pi-unipi/core": "3.0.0-alpha.40"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.87.1",

package/packages/app-bridge/src/bridge.ts

@@ -14,7 +14,8 @@ import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync
 import { homedir } from "node:os";
 import { join, relative, resolve as resolvePath } from "node:path";
 import { DialogHub, wrapUi } from "./dialogs.js";
-import { ENTRIES_BUDGET, HELLO_ENTRIES_BUDGET, LINE_BUDGET, fitLine, historyPage, jsonBytes, phoneSafe, snapshotEntries, clipText, wantedEntry } from "./snapshot.js";
+import { ENTRIES_BUDGET, HELLO_ENTRIES_BUDGET, LINE_BUDGET, fitLine, historyPage, jsonBytes, phoneSafe, snapshotEntries, clipText, editedAway, wantedEntry } from "./snapshot.js";
+import { searchSession } from "./search.js";
 import {
   BRIDGE_PROTOCOL,
   LineSplitter,
@@ -44,7 +45,7 @@ import { fileSuggestions } from "./files.js";
 import { statPaths } from "./paths.js";
 import { registerPath, resolveMedia } from "./media.js";
 import { listWorkItems, stopWorkItem, backgroundWorkItem, workLogPage } from "./work.js";
-import { bus, callCommandRunner, pendingWorkLabel, silenceCommandEcho, subscribePendingWork, UNIPI_EVENTS } from "@pi-unipi/core";
+import { bus, callCommandRunner, commandArgCompleters, pendingWorkLabel, silenceCommandEcho, subscribePendingWork, UNIPI_EVENTS } from "@pi-unipi/core";
 import type { BtwListPage } from "./wire.js";
 
 /** `media_chunk.data` (base64) stays well under the 900 KiB bridge line
@@ -604,6 +605,8 @@ export function createBridge(pi: ExtensionAPI, deps: BridgeDeps = defaultDeps) {
     }, 1000);
   };
 
+  /** Set once syncCustom exists (below); pushes fresh custom entries shortly after a command ran. */
+  let syncSoon: () => void = () => {};
   const commands = (): CommandInfo[] => {
     let list: CommandInfo[] = [];
     try {
@@ -1175,6 +1178,7 @@ export function createBridge(pi: ExtensionAPI, deps: BridgeDeps = defaultDeps) {
             try {
               pi.sendUserMessage(content, { expandPromptTemplates: true } as never);
               write(sock, { t: "ack", ref: msg.ref, ...(isCommand ? { as: "command" as const } : {}) });
+          if (isCommand) syncSoon();
             } catch (error) {
               fail(error instanceof Error ? error.message : String(error));
             }
@@ -1208,6 +1212,7 @@ export function createBridge(pi: ExtensionAPI, deps: BridgeDeps = defaultDeps) {
           try {
             pi.sendUserMessage(content, { expandPromptTemplates: true } as never);
             write(sock, { t: "ack", ref: msg.ref, ...(isCommand ? { as: "command" as const } : {}) });
+          if (isCommand) syncSoon();
           } catch (error) {
             fail(error instanceof Error ? error.message : String(error));
           }
@@ -1225,6 +1230,7 @@ export function createBridge(pi: ExtensionAPI, deps: BridgeDeps = defaultDeps) {
         try {
           pi.sendUserMessage(content, { deliverAs, expandPromptTemplates: true } as never);
           write(sock, { t: "ack", ref: msg.ref, ...(isCommand ? { as: "command" as const } : {}) });
+          if (isCommand) syncSoon();
         } catch (error) {
           fail(error instanceof Error ? error.message : String(error));
         }
@@ -1396,10 +1402,36 @@ export function createBridge(pi: ExtensionAPI, deps: BridgeDeps = defaultDeps) {
         write(sock, hello());
         return;
       case "history": {
-        const page = historyPage(c.sessionManager.getBranch(), msg.before, Math.min(ENTRIES_BUDGET, LINE_BUDGET - 32 * 1024));
+        const page = historyPage(c.sessionManager.getBranch(), msg.before, Math.min(ENTRIES_BUDGET, LINE_BUDGET - 32 * 1024), msg.until);
         write(sock, { t: "history", before: msg.before, entries: page.entries, more: page.more, ref: msg.ref });
         return;
       }
+      case "search": {
+        // UNI-275: the whole branch (not just what the phone has paged in).
+        const hidden = editedAway(c.sessionManager.getBranch());
+        const branch = (c.sessionManager.getBranch() as Array<{ id?: string }>).filter((e) => !hidden.has(e.id ?? "") && wantedEntry(e));
+        write(sock, { t: "search", query: msg.query, hits: searchSession(branch, msg.query, 60), ref: msg.ref });
+        return;
+      }
+      case "arg_completions": {
+        // UNI-276: the same argument completions the terminal's autocomplete shows.
+        let items: Array<{ value: string; label: string; description?: string }> = [];
+        try {
+          const cmd = (pi.getCommands() as Array<{ name: string; source: string; getArgumentCompletions?: unknown }>).find((x) => x.name === msg.command);
+          const fn = (cmd as { getArgumentCompletions?: (p: string) => unknown } | undefined)?.getArgumentCompletions ?? commandArgCompleters().get(msg.command);
+          const out = fn ? await Promise.resolve(fn(msg.prefix)) : undefined;
+          if (Array.isArray(out)) {
+            items = out
+              .filter((x): x is { value: string; label?: string; description?: string } => !!x && typeof (x as { value?: unknown }).value === "string")
+              .slice(0, 50)
+              .map((x) => ({ value: x.value, label: typeof x.label === "string" ? x.label : x.value, ...(typeof x.description === "string" ? { description: clipText(x.description, 160) } : {}) }));
+          }
+        } catch {
+          // A completer that throws just offers nothing.
+        }
+        write(sock, { t: "arg_completions", command: msg.command, prefix: msg.prefix, items, ref: msg.ref });
+        return;
+      }
       case "files": {
         const items = await fileSuggestions(c.cwd, msg.query);
         write(sock, { t: "files", query: msg.query, items, ref: msg.ref });
@@ -1749,7 +1781,10 @@ export function createBridge(pi: ExtensionAPI, deps: BridgeDeps = defaultDeps) {
     try {
       ctx = c;
       if (c.mode !== "tui" || process.env.UNIPI_SUBAGENT_CHILD === "1" || process.env.UNIPI_APP_BRIDGE === "0") return;
-      if (c.hasUI) wrapUi(c.ui, hub, (text, level) => send({ t: "notify", text: clipText(text, 4000), level }));
+      if (c.hasUI) wrapUi(c.ui, hub, (text, level) => {
+        send({ t: "notify", text: clipText(text, 4000), level });
+        syncSoon();
+      });
       computeCost();
       setRemoteDialogs(hub);
       listen();
@@ -2126,6 +2161,17 @@ export function createBridge(pi: ExtensionAPI, deps: BridgeDeps = defaultDeps) {
   };
   on("turn_end", safe(syncCustom));
   on("agent_settled", safe(syncCustom));
+  // UNI-276: a command that starts no turn (status / toggles / pickers) still
+  // leaves its echo + reply entries — push them soon after it runs.
+  syncSoon = () => {
+    for (const ms of [120, 1200, 4000]) setTimeout(() => {
+      try {
+        syncCustom();
+      } catch {
+        // never break pi
+      }
+    }, ms).unref?.();
+  };
 
   return {
     /** Test seam. */

package/packages/app-bridge/src/search.ts

@@ -0,0 +1,269 @@
+/**
+ * UNI-275: search the session for text — similarity-ranked, not just an exact
+ * substring. Pure: (branch entries, query) → hits.
+ *
+ * Score per entry = BM25 over word stems (exact words count most), plus
+ * fuzzy credit for query words that only match a vocabulary word by a typo
+ * (edit distance ≤ 1 for short words, ≤ 2 for long ones, or a shared
+ * prefix), plus a bonus when the whole query appears as a phrase. Field
+ * weights: what the user said counts most, then the model's words and
+ * commands; tool calls and their output much less (long and noisy). One hit
+ * per entry.
+ */
+
+export interface SearchHit {
+  /** Session entry id (the app jumps to it). */
+  id: string;
+  /** user | assistant | tool (a call) | output (a tool's result) | command | note */
+  role: string;
+  /** ~160 chars around the best match. */
+  snippet: string;
+  /** [start, end) of matched words inside `snippet`, for highlighting. */
+  marks: Array<[number, number]>;
+  score: number;
+  timestamp?: string;
+}
+
+interface Doc {
+  id: string;
+  role: string;
+  timestamp?: string;
+  /** Searchable text with its weight. */
+  fields: Array<{ text: string; weight: number }>;
+}
+
+const MAX_FIELD = 8 * 1024;
+const MAX_TOOL_OUTPUT = 4 * 1024;
+
+function textOf(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .map((p) => {
+      const part = p as { type?: string; text?: unknown };
+      return part?.type === "text" && typeof part.text === "string" ? part.text : "";
+    })
+    .filter(Boolean)
+    .join("\n");
+}
+
+function argsText(args: unknown): string {
+  if (!args || typeof args !== "object") return typeof args === "string" ? args : "";
+  const a = args as Record<string, unknown>;
+  const picks = ["command", "path", "file_path", "pattern", "query", "url", "task", "title"];
+  return picks.map((k) => (typeof a[k] === "string" ? (a[k] as string) : "")).filter(Boolean).join(" ");
+}
+
+/** The searchable documents of a branch (one per entry that says something). */
+export function searchDocs(branch: readonly unknown[]): Doc[] {
+  const docs: Doc[] = [];
+  for (const raw of branch) {
+    const e = raw as {
+      id?: string;
+      type?: string;
+      timestamp?: string;
+      customType?: string;
+      data?: { text?: unknown; command?: unknown };
+      content?: unknown;
+      message?: { role?: string; content?: unknown; toolName?: string };
+    };
+    if (!e?.id) continue;
+    const base = { id: e.id, ...(e.timestamp ? { timestamp: e.timestamp } : {}) };
+    if (e.type === "message" && e.message) {
+      const m = e.message;
+      if (m.role === "user") docs.push({ ...base, role: "user", fields: [{ text: textOf(m.content).slice(0, MAX_FIELD), weight: 1 }] });
+      else if (m.role === "assistant") {
+        const parts = Array.isArray(m.content) ? (m.content as Array<{ type?: string; text?: string; name?: string; arguments?: unknown }>) : [];
+        const said = parts.filter((p) => p.type === "text").map((p) => p.text ?? "").join("\n");
+        const calls = parts.filter((p) => p.type === "toolCall").map((p) => `${p.name ?? ""} ${argsText(p.arguments)}`).join("\n");
+        // What the model said and what it ran are separate hits (same entry):
+        // a command line must not surface as "the assistant said …".
+        if (said.trim()) docs.push({ ...base, role: "assistant", fields: [{ text: said.slice(0, MAX_FIELD), weight: 1 }] });
+        if (calls.trim()) docs.push({ ...base, role: "tool", fields: [{ text: calls.slice(0, MAX_FIELD), weight: 1 }] });
+      } else if (m.role === "toolResult") {
+        const out = textOf(m.content);
+        if (out.trim()) docs.push({ ...base, role: "output", fields: [{ text: out.slice(0, MAX_TOOL_OUTPUT), weight: 1 }] });
+      }
+    } else if (e.type === "custom" && e.customType === "unipi-command-echo" && typeof e.data?.text === "string") {
+      docs.push({ ...base, role: "command", fields: [{ text: e.data.text, weight: 1 }] });
+    } else if (e.type === "custom_message") {
+      const t = textOf(e.content);
+      if (t.trim()) docs.push({ ...base, role: "note", fields: [{ text: t.slice(0, MAX_FIELD), weight: 1 }] });
+    }
+  }
+  return docs;
+}
+
+// ── text ───────────────────────────────────────────────────────────────
+
+const WORD = /[\p{L}\p{N}_]+/gu;
+
+/** Light English stemmer: enough that "tests"/"testing"/"tested" meet "test". */
+export function stem(word: string): string {
+  let w = word.toLowerCase();
+  if (w.length > 4 && w.endsWith("ies")) return `${w.slice(0, -3)}y`;
+  for (const suffix of ["ing", "ed", "es", "s"]) {
+    if (w.length > suffix.length + 2 && w.endsWith(suffix)) {
+      w = w.slice(0, -suffix.length);
+      break;
+    }
+  }
+  // "running" → "runn" → "run"
+  if (w.length > 3 && w.at(-1) === w.at(-2) && !/[aeiou]/.test(w.at(-1)!)) w = w.slice(0, -1);
+  return w;
+}
+
+function words(text: string): Array<{ word: string; stem: string; start: number; end: number }> {
+  const out: Array<{ word: string; stem: string; start: number; end: number }> = [];
+  for (const m of text.matchAll(WORD)) {
+    const word = m[0].toLowerCase();
+    out.push({ word, stem: stem(word), start: m.index!, end: m.index! + m[0].length });
+  }
+  return out;
+}
+
+/** Edit distance with adjacent swaps as one edit ("depoly" → "deploy" = 1); max+1 when farther than `max`. */
+export function editDistance(a: string, b: string, max: number): number {
+  if (Math.abs(a.length - b.length) > max) return max + 1;
+  let prev2: number[] = [];
+  let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    const cur = [i];
+    let best = i;
+    for (let j = 1; j <= b.length; j++) {
+      let v = Math.min(prev[j]! + 1, cur[j - 1]! + 1, prev[j - 1]! + (a[i - 1] === b[j - 1] ? 0 : 1));
+      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) v = Math.min(v, prev2[j - 2]! + 1);
+      cur.push(v);
+      if (v < best) best = v;
+    }
+    if (best > max) return max + 1;
+    prev2 = prev;
+    prev = cur;
+  }
+  return Math.min(prev[b.length]!, max + 1);
+}
+
+/** How much a vocabulary stem stands in for a query stem (1 = same, 0 = not at all). */
+function closeness(q: string, v: string): number {
+  if (q === v) return 1;
+  if (q.length >= 3 && v.startsWith(q)) return 0.7; // "auth" → "authentication"
+  if (v.length >= 4 && q.startsWith(v)) return 0.5; // "authentication" → "auth"
+  if (q.length < 4) return 0;
+  const max = q.length >= 8 ? 2 : 1;
+  const d = editDistance(q, v, max);
+  // editDistance returns max+1 for "too far": only real distances count.
+  if (d > max || v.length < 3) return 0;
+  return d === 1 ? 0.6 : 0.4;
+}
+
+// ── search ─────────────────────────────────────────────────────────────
+
+/** What people said counts most; what was run, and its output, less (long and noisy). */
+const ROLE_WEIGHT: Record<string, number> = { user: 1.25, assistant: 1, command: 1, note: 0.7, tool: 0.45, output: 0.3 };
+
+const K1 = 1.2;
+const B = 0.75;
+
+export function searchSession(branch: readonly unknown[], query: string, limit = 50): SearchHit[] {
+  const q = query.trim();
+  if (!q) return [];
+  const qWords = [...new Set(words(q).map((w) => w.stem))];
+  if (!qWords.length) return [];
+  const docs = searchDocs(branch);
+  if (!docs.length) return [];
+
+  // Per doc: weighted term frequencies by stem, and its length.
+  const indexed = docs.map((d) => {
+    const tf = new Map<string, number>();
+    let len = 0;
+    for (const f of d.fields) {
+      for (const w of words(f.text)) {
+        tf.set(w.stem, (tf.get(w.stem) ?? 0) + f.weight);
+        len += f.weight;
+      }
+    }
+    return { d, tf, len: Math.max(1, len) };
+  });
+  const avgLen = indexed.reduce((n, x) => n + x.len, 0) / indexed.length;
+  const df = new Map<string, number>();
+  for (const x of indexed) for (const s of x.tf.keys()) df.set(s, (df.get(s) ?? 0) + 1);
+  const vocab = [...df.keys()];
+  // Each query stem → the vocabulary stems that count for it, with closeness.
+  const expansions = new Map<string, Array<{ stem: string; c: number }>>();
+  for (const qs of qWords) {
+    const list: Array<{ stem: string; c: number }> = [];
+    for (const v of vocab) {
+      const c = closeness(qs, v);
+      if (c > 0) list.push({ stem: v, c });
+    }
+    list.sort((a, b) => b.c - a.c);
+    expansions.set(qs, list.slice(0, 12));
+  }
+  const n = indexed.length;
+  const idf = (s: string) => Math.log(1 + (n - (df.get(s) ?? 0) + 0.5) / ((df.get(s) ?? 0) + 0.5));
+  const phrase = q.toLowerCase().replace(/\s+/g, " ");
+
+  const scored: Array<{ x: (typeof indexed)[number]; score: number; matched: Set<string> }> = [];
+  for (const x of indexed) {
+    let score = 0;
+    let covered = 0;
+    const matched = new Set<string>();
+    for (const qs of qWords) {
+      let best = 0;
+      for (const { stem: s, c } of expansions.get(qs) ?? []) {
+        const f = x.tf.get(s);
+        if (!f) continue;
+        const part = c * idf(s) * ((f * (K1 + 1)) / (f + K1 * (1 - B + (B * x.len) / avgLen)));
+        if (part > best) best = part;
+        matched.add(s);
+      }
+      if (best > 0) covered += 1;
+      score += best;
+    }
+    if (score <= 0) continue;
+    // Every query word present beats a few repeated ones (a hit on one word of three is weak).
+    const coverage = covered / qWords.length;
+    score *= coverage * coverage;
+    if (qWords.length > 1 && x.d.fields.some((f) => f.text.toLowerCase().replace(/\s+/g, " ").includes(phrase))) score *= 1.6;
+    score *= ROLE_WEIGHT[x.d.role] ?? 1;
+    scored.push({ x, score, matched });
+  }
+  scored.sort((a, b) => b.score - a.score);
+  const seen = new Set<string>();
+  const unique = scored.filter(({ x }) => (seen.has(x.d.id) ? false : (seen.add(x.d.id), true)));
+  return unique.slice(0, limit).map(({ x, score, matched }) => ({
+    id: x.d.id,
+    role: x.d.role,
+    ...snippet(x.d, matched, phrase),
+    score: Math.round(score * 1000) / 1000,
+    ...(x.d.timestamp ? { timestamp: x.d.timestamp } : {}),
+  }));
+}
+
+const SNIPPET = 160;
+
+function snippet(d: Doc, matched: Set<string>, phrase: string): { snippet: string; marks: Array<[number, number]> } {
+  // The best field: the first one with a match, by weight.
+  const fields = [...d.fields].sort((a, b) => b.weight - a.weight);
+  for (const f of fields) {
+    const flat = f.text.replace(/\s+/g, " ").trim();
+    const ws = words(flat).filter((w) => matched.has(w.stem));
+    if (!ws.length) continue;
+    const at = flat.toLowerCase().indexOf(phrase);
+    const anchor = at >= 0 ? at : ws[0]!.start;
+    let start = Math.max(0, anchor - 50);
+    if (start > 0) {
+      const space = flat.indexOf(" ", start);
+      if (space >= 0 && space < anchor) start = space + 1;
+    }
+    const end = Math.min(flat.length, start + SNIPPET);
+    const pre = start > 0 ? "…" : "";
+    const text = pre + flat.slice(start, end) + (end < flat.length ? "…" : "");
+    const marks: Array<[number, number]> = ws
+      .filter((w) => w.start >= start && w.end <= end)
+      .map((w) => [w.start - start + pre.length, w.end - start + pre.length]);
+    return { snippet: text, marks };
+  }
+  const flat = (fields[0]?.text ?? "").replace(/\s+/g, " ").trim();
+  return { snippet: flat.slice(0, SNIPPET) + (flat.length > SNIPPET ? "…" : ""), marks: [] };
+}

package/packages/app-bridge/src/snapshot.ts

@@ -229,21 +229,38 @@ export function fitLine(msg: object): string {
  * that fit `budget`, oldest first. `more` = older entries remain.
  * `before` not on the branch → empty page, more false.
  */
-export function historyPage(branch: readonly unknown[], before: string, budget = ENTRIES_BUDGET): { entries: Json[]; more: boolean } {
+export function historyPage(branch: readonly unknown[], before: string, budget = ENTRIES_BUDGET, until?: string): { entries: Json[]; more: boolean } {
   const end = branch.findIndex((e) => (e as { id?: string })?.id === before);
   if (end <= 0) return { entries: [], more: false };
   const hidden = editedAway(branch);
+  // UNI-275 "navigate to": page back at least to `until` (+ a little context
+  // above it); entries are clipped harder once the budget is spent so the
+  // page still fits one frame.
+  const target = until ? branch.findIndex((e) => (e as { id?: string })?.id === until) : -1;
+  const stopAt = target >= 0 && target < end ? Math.max(0, target - 6) : -1;
   const out: Json[] = [];
   let used = 0;
   let i = end - 1;
   for (; i >= 0; i--) {
     const e = branch[i];
     if (!wantedEntry(e) || hidden.has((e as { id?: string }).id ?? "")) continue;
-    const safe = phoneSafe(e);
-    const size = jsonBytes(safe) + 1;
-    if (used + size > budget && out.length > 0) break;
+    const reaching = stopAt >= 0 && i >= stopAt;
+    let safe = phoneSafe(e);
+    let size = jsonBytes(safe) + 1;
+    if (used + size > budget && out.length > 0) {
+      if (!reaching) break;
+      // Reaching for the target: keep going with small copies.
+      safe = phoneSafe(e, 1024);
+      size = jsonBytes(safe) + 1;
+      // Never past one relay frame; the app keeps paging toward the target.
+      if (used + size > Math.max(budget, LINE_BUDGET - 96 * 1024)) break;
+    }
     out.push(size > budget ? phoneSafe(e, 8 * 1024) : safe);
     used += size;
+    if (stopAt >= 0 && i <= stopAt && used >= budget / 4) {
+      i -= 1;
+      break;
+    }
   }
   // Any wanted entry left before i?
   let more = false;

package/packages/app-bridge/src/wire.ts

@@ -281,8 +281,12 @@ export type OutMsg =
   | { t: "reconnect"; reason: string }
   /** A page of older entries (oldest first) ending right before `before`. */
   | { t: "history"; before: string; entries: unknown[]; more: boolean; ref?: string }
+  /** UNI-275: similarity search over this session's branch (newest-first ties). */
+  | { t: "search"; query: string; hits: Array<{ id: string; role: string; snippet: string; marks: Array<[number, number]>; score: number; timestamp?: string }>; ref?: string }
   /** `@` file suggestions for `query` (pi's own finder: fd, .gitignore aware). */
   | { t: "files"; query: string; items: FileItem[]; ref?: string }
+  /** UNI-276: a command's argument suggestions (its getArgumentCompletions), for `/name <prefix>`. */
+  | { t: "arg_completions"; command: string; prefix: string; items: Array<{ value: string; label: string; description?: string }>; ref?: string }
   /** Reply to `paths_stat{paths}` (UNI-204): one item per requested path, same order. */
   | { t: "paths_stat"; items: Array<{ path: string; resolved: string; kind: "file" | "dir" | "missing" }>; ref?: string }
   /** Sessions matching `sessions{scope, query?}`, newest first, capped. */
@@ -387,9 +391,11 @@ export type InMsg =
   | { t: "compact"; instructions?: string; ref?: string }
   | { t: "resync"; ref?: string }
   /** Older history: entries before the entry `before` on the active branch. */
-  | { t: "history"; before: string; ref?: string }
+  | { t: "history"; before: string; until?: string; ref?: string }
+  | { t: "search"; query: string; ref?: string }
   /** `@` file suggestions; `query` is the text after `@` (may start with `"`). */
   | { t: "files"; query: string; ref?: string }
+  | { t: "arg_completions"; command: string; prefix: string; ref?: string }
   /** List sessions to resume: this project's or every project's, optionally filtered. */
   | { t: "sessions"; scope: "cwd" | "all"; query?: string; ref?: string }
   /** Start a brand-new session. `force`: abort the current run first. */
@@ -476,7 +482,9 @@ const IN_TYPES = new Set([
   "compact",
   "resync",
   "history",
+  "search",
   "files",
+  "arg_completions",
   "sessions",
   "session_new",
   "session_resume",
@@ -545,9 +553,15 @@ export function parseIn(line: string): InMsg | { bad: string; ref?: string } | u
       return { t: "set_thinking", level: m.level, ref };
     case "compact":
       return { t: "compact", instructions: typeof m.instructions === "string" ? m.instructions : undefined, ref };
+    case "search":
+      if (typeof m.query !== "string") return { bad: "search.query must be a string", ref };
+      return { t: "search", query: m.query.slice(0, 256).replace(/[\r\n]/g, " "), ref };
     case "history":
       if (typeof m.before !== "string" || !m.before) return { bad: "history.before must be an entry id", ref };
-      return { t: "history", before: m.before.slice(0, 128), ref };
+      return { t: "history", before: m.before.slice(0, 128), ...(typeof m.until === "string" && m.until ? { until: m.until.slice(0, 128) } : {}), ref };
+    case "arg_completions":
+      if (typeof m.command !== "string" || !m.command || typeof m.prefix !== "string") return { bad: "arg_completions needs command and prefix", ref };
+      return { t: "arg_completions", command: m.command.slice(0, 128), prefix: m.prefix.slice(0, 512).replace(/[\r\n]/g, " "), ref };
     case "files":
       if (typeof m.query !== "string") return { bad: "files.query must be a string", ref };
       return { t: "files", query: m.query.slice(0, 512).replace(/[\r\n]/g, ""), ref };

package/packages/ask-user/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/ask-user",
-  "version": "3.0.0-alpha.39",
+  "version": "3.0.0-alpha.40",
   "description": "Structured user input tool for Pi coding agent — single-select, multi-select, freeform",
   "type": "module",
   "main": "index.ts",
@@ -42,7 +42,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "3.0.0-alpha.39"
+    "@pi-unipi/core": "3.0.0-alpha.40"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.87.1",

package/packages/autocomplete/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/command-enchantment",
-  "version": "3.0.0-alpha.39",
+  "version": "3.0.0-alpha.40",
   "description": "Enhanced TUI autocomplete for /unipi:* commands — colored, sorted, and grouped by package",
   "type": "module",
   "main": "src/index.ts",

package/packages/background-tasks/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/background-tasks",
-  "version": "3.0.0-alpha.39",
+  "version": "3.0.0-alpha.40",
   "description": "Background tasks for UniPi — durable shell jobs and delegated background agents with a footer dock",
   "type": "module",
   "main": "src/index.ts",
@@ -10,7 +10,7 @@
   },
   "dependencies": {
     "@earendil-works/pi-ai": "^0.87.1",
-    "@pi-unipi/core": "3.0.0-alpha.39",
+    "@pi-unipi/core": "3.0.0-alpha.40",
     "turndown": "^7.2.4"
   },
   "devDependencies": {

package/packages/btw/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/btw",
-  "version": "3.0.0-alpha.39",
+  "version": "3.0.0-alpha.40",
   "description": "A pi extension for parallel side conversations with /unipi:btw — part of the Unipi suite",
   "type": "module",
   "main": "extensions/btw.ts",
@@ -37,7 +37,7 @@
     "@earendil-works/pi-tui": "^0.87.1"
   },
   "dependencies": {
-    "@pi-unipi/core": "3.0.0-alpha.39"
+    "@pi-unipi/core": "3.0.0-alpha.40"
   },
   "pi": {
     "extensions": [