@pi-unipi/unipi 2.0.1 → 2.0.3

package/README.md

@@ -1,6 +1,6 @@
 # Unipi
 
-18 packages that turn Pi into a full development workstation. Structured workflows, persistent memory, parallel agents, web research, notifications, context management, and a live status bar — all wired together through a shared event system.
+20 workspace packages that turn Pi into a full development workstation. Structured workflows, persistent memory, parallel agents, web research, notifications, context management, command autocomplete, and a live status bar — all wired together through a shared event system.
 
 One command installs everything:
 ```bash
@@ -17,6 +17,8 @@ pi install npm:@pi-unipi/unipi
 
 **[Compactor](./packages/compactor/README.md)** — Zero-LLM context engine. 6-stage pipeline hits 95%+ token reduction at zero API cost. Session continuity, sandbox execution, FTS5 search.
 
+**[CocoIndex](./packages/cocoindex/README.md)** — Project indexing and semantic code search backed by CocoIndex and LanceDB. Agent tools and slash commands for status, init, update, and search.
+
 **[Subagents](./packages/subagents/README.md)** — Parallel execution with file locking. Spawn background agents to research, fix, or build while the main agent keeps going.
 
 **[Web API](./packages/web-api/README.md)** — Web search, page reading, content summarization. Smart-fetch engine with browser-grade TLS fingerprinting — free, no API key. Paid providers as fallbacks.
@@ -43,6 +45,8 @@ pi install npm:@pi-unipi/unipi
 
 **[Input Shortcuts](./packages/input-shortcuts/README.md)** — Keyboard shortcuts via vim-style chord overlay. Stash/restore, undo/redo, clipboard, thinking toggle.
 
+**[Command Enchantment](./packages/autocomplete/README.md)** — Enhanced `/unipi:*` autocomplete with package grouping, descriptions, colors, and registry audits that catch stale command docs before release.
+
 ## Architecture
 
 Packages discover each other through events, not direct imports. Core defines the event types and constants. Every package emits `MODULE_READY` on load and subscribes to events it cares about.
@@ -77,12 +81,13 @@ Coexists triggers enhance behavior when packages are installed together. Workflo
 | Workflow | `/unipi:` | brainstorm, plan, work, review-work, consolidate, quick-work, debug, fix |
 | Ralph | `/unipi:ralph` | start, stop, resume, status |
 | Memory | `/unipi:memory-` | process, search, consolidate, forget |
-| Compactor | `/unipi:` | lossless-compact, compact-stats, compact-settings, compact-preset, session-recall, content-index, content-search |
+| Compactor | `/unipi:` | lossless-compact, session-recall, compact-stats, compact-settings, compact-preset, compact-help |
+| CocoIndex | `/unipi:cocoindex-` | init, update, status, search, settings |
 | Notify | `/unipi:notify-` | settings, test, set-tg, set-ntfy |
 | MCP | `/unipi:mcp-` | add, settings, sync, status |
 | Web | `/unipi:web-` | settings, cache-clear |
-| BTW | `/btw` | question, new, tangent, inject, summarize |
-| Utility | `/unipi:` | env, doctor, status, cleanup, name-badge |
+| BTW | `/unipi:btw` | question, btw-new, btw-tangent, btw-inject, btw-summarize |
+| Utility | `/unipi:` | env, doctor, status, cleanup, badge-name |
 | Milestone | `/unipi:milestone-` | onboard, update |
 | Kanboard | `/unipi:kanboard` | toggle, doctor |
 | Footer | `/unipi:footer` | toggle, settings |
@@ -121,6 +126,7 @@ unipi/
 │   ├── ralph/          # Iterative loops
 │   ├── memory/         # SQLite + vector search
 │   ├── compactor/      # Context engine
+│   ├── cocoindex/      # Project indexing and semantic search
 │   ├── subagents/      # Parallel execution
 │   ├── web-api/        # Web research
 │   ├── mcp/            # MCP server integration
@@ -134,6 +140,7 @@ unipi/
 │   ├── utility/        # Diagnostics, diff rendering
 │   ├── updater/        # Auto-update, browsers
 │   ├── input-shortcuts/ # Keyboard shortcuts
+│   ├── autocomplete/   # Enhanced command autocomplete
 │   └── unipi/          # Umbrella package
 ├── .unipi/             # Runtime data (specs, plans, worktrees)
 └── CHANGELOG.md

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/unipi",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "All-in-one extension suite for Pi coding agent",
   "type": "module",
   "license": "MIT",

package/packages/ask-user/README.md

@@ -73,6 +73,10 @@ When the user chooses a `new_session` option:
 
 The tool result is rendered as `queued compact → ...` or `queued direct → ...`. If automatic delivery fails, ask-user falls back to editor prefill and warns you to press Enter.
 
+### History Expansion
+
+Completed `ask_user` calls stay readable in chat history. The collapsed result shows the selected answer; press Ctrl+O on the tool result to expand the original question, context, and options that were presented.
+
 ### Keyboard Controls
 
 | Mode | Keys |

package/packages/ask-user/ask-ui.ts

@@ -621,7 +621,7 @@ export function createRenderCall() {
  * Create a renderResult function for the ask_user tool.
  */
 export function createRenderResult() {
-  return (result: AgentToolResult<unknown>, _options: unknown, theme: Theme, _context: unknown) => {
+  return (result: AgentToolResult<unknown>, options: unknown, theme: Theme, _context: unknown) => {
     const details = result.details as Record<string, unknown> | undefined;
     if (!details) {
       const content = result.content as unknown as Array<Record<string, unknown>> | undefined;
@@ -634,103 +634,110 @@ export function createRenderResult() {
       return new Text(theme.fg("warning", "No response"), 0, 0);
     }
 
-    switch (response.kind) {
-      case "cancelled":
-        return new Text(theme.fg("warning", "Cancelled"), 0, 0);
-      case "timed_out":
-        return new Text(theme.fg("warning", "Timed out"), 0, 0);
-      case "freeform":
-        return new Text(
-          theme.fg("success", "✓ ") +
+    const renderOptionSummary = (): string[] => {
+      const rawOptions = (details as { options?: unknown }).options;
+      if (!Array.isArray(rawOptions) || rawOptions.length === 0) return [];
+      return rawOptions.map((opt, index) => {
+        if (typeof opt === "string") {
+          return theme.fg("dim", `  ${index + 1}. `) + theme.fg("text", opt);
+        }
+        const record = opt as Record<string, unknown>;
+        const label = String(record.label ?? record.value ?? `Option ${index + 1}`);
+        const value = typeof record.value === "string" && record.value !== label
+          ? theme.fg("dim", ` (${record.value})`)
+          : "";
+        const action = typeof record.action === "string" && record.action !== "select"
+          ? theme.fg("dim", ` [${record.action}]`)
+          : "";
+        const description = typeof record.description === "string" && record.description.trim()
+          ? `\n${theme.fg("muted", `     ${record.description}`)}`
+          : "";
+        return theme.fg("dim", `  ${index + 1}. `) + theme.fg("text", label) + value + action + description;
+      });
+    };
+
+    const answerText = (() => {
+      switch (response.kind) {
+        case "cancelled":
+          return theme.fg("warning", "Cancelled");
+        case "timed_out":
+          return theme.fg("warning", "Timed out");
+        case "freeform":
+          return theme.fg("success", "✓ ") +
             theme.fg("muted", "(wrote) ") +
-            theme.fg("accent", response.text || ""),
-          0,
-          0,
-        );
-      case "selection": {
-        const selections = response.selections || [];
-        const display =
-          selections.length === 1
+            theme.fg("accent", response.text || "");
+        case "selection": {
+          const selections = response.selections || [];
+          const display = selections.length === 1 ? selections[0] : selections.join(", ");
+          return theme.fg("success", "✓ ") + theme.fg("accent", display);
+        }
+        case "combined": {
+          const selections = response.selections || [];
+          const selDisplay = selections.length === 1
             ? selections[0]
             : selections.join(", ");
-        return new Text(
-          theme.fg("success", "✓ ") + theme.fg("accent", display),
-          0,
-          0,
-        );
-      }
-      case "combined": {
-        const selections = response.selections || [];
-        const selDisplay = selections.length === 1
-          ? selections[0]
-          : selections.join(", ");
-        return new Text(
-          theme.fg("success", "✓ ") +
+          return theme.fg("success", "✓ ") +
             theme.fg("accent", selDisplay) +
             theme.fg("muted", " and wrote ") +
-            theme.fg("accent", response.text || ""),
-          0,
-          0,
-        );
-      }
-      case "end_turn":
-        return new Text(
-          theme.fg("success", "✓ ") + theme.fg("muted", "end turn"),
-          0,
-          0,
-        );
-      case "new_session": {
-        const prefill = response.prefill || "";
-        if (response.launchStatus === "editor_prefill") {
-          const label = response.launchedWith === "compact"
-            ? "⚠ compact editor prefill → "
-            : "⚠ direct editor prefill → ";
-          return new Text(
-            theme.fg("warning", label) + theme.fg("accent", prefill),
-            0,
-            0,
-          );
-        }
-        if (response.launchStatus === "failed") {
-          const label = response.launchedWith === "compact"
-            ? "handoff failed (compact) → "
-            : "handoff failed (direct) → ";
-          return new Text(
-            theme.fg("error", label) + theme.fg("accent", prefill),
-            0,
-            0,
-          );
+            theme.fg("accent", response.text || "");
         }
-        if (response.launchedWith === "compact") {
-          return new Text(
-            theme.fg("success", "✓ queued compact → ") +
-              theme.fg("accent", prefill),
-            0,
-            0,
-          );
-        }
-        if (response.launchedWith === "direct") {
-          return new Text(
-            theme.fg("success", "✓ queued direct → ") +
-              theme.fg("accent", prefill),
-            0,
-            0,
-          );
-        }
-        return new Text(
-          theme.fg("success", "✓ ") +
+        case "end_turn":
+          return theme.fg("success", "✓ ") + theme.fg("muted", "end turn");
+        case "new_session": {
+          const prefill = response.prefill || "";
+          if (response.launchStatus === "editor_prefill") {
+            const label = response.launchedWith === "compact"
+              ? "⚠ compact editor prefill → "
+              : "⚠ direct editor prefill → ";
+            return theme.fg("warning", label) + theme.fg("accent", prefill);
+          }
+          if (response.launchStatus === "failed") {
+            const label = response.launchedWith === "compact"
+              ? "handoff failed (compact) → "
+              : "handoff failed (direct) → ";
+            return theme.fg("error", label) + theme.fg("accent", prefill);
+          }
+          if (response.launchedWith === "compact") {
+            return theme.fg("success", "✓ queued compact → ") + theme.fg("accent", prefill);
+          }
+          if (response.launchedWith === "direct") {
+            return theme.fg("success", "✓ queued direct → ") + theme.fg("accent", prefill);
+          }
+          return theme.fg("success", "✓ ") +
             theme.fg("muted", "new session") +
-            (prefill ? theme.fg("accent", `: ${prefill}`) : ""),
-          0,
-          0,
-        );
+            (prefill ? theme.fg("accent", `: ${prefill}`) : "");
+        }
+        default:
+          return theme.fg("text", JSON.stringify(response));
       }
-      default:
-        return new Text(
-          theme.fg("text", JSON.stringify(response)),
-          0,
-          0,
-        );
+    })();
+
+    const expanded = typeof options === "object" && options !== null && "expanded" in options
+      ? Boolean((options as { expanded?: boolean }).expanded)
+      : false;
+    if (!expanded) {
+      const question = typeof (details as { question?: unknown }).question === "string"
+        ? (details as { question: string }).question
+        : "";
+      const expandHint = question
+        ? theme.fg("dim", "  · Ctrl+O question/options")
+        : "";
+      return new Text(answerText + expandHint, 0, 0);
+    }
+
+    const lines = [answerText];
+    const question = (details as { question?: unknown }).question;
+    const context = (details as { context?: unknown }).context;
+    if (typeof question === "string" && question.trim()) {
+      lines.push(theme.fg("muted", "Question: ") + theme.fg("text", question));
     }
+    if (typeof context === "string" && context.trim()) {
+      lines.push(theme.fg("muted", "Context: ") + theme.fg("text", context));
+    }
+    const optionLines = renderOptionSummary();
+    if (optionLines.length > 0) {
+      lines.push(theme.fg("muted", "Options:"), ...optionLines);
+    }
+    return new Text(lines.join("\n"), 0, 0);
   };
 }

package/packages/ask-user/tools.ts

@@ -252,6 +252,13 @@ export function registerAskUserTools(pi: ExtensionAPI): void {
         action: (opt.action as NormalizedOption["action"]) ?? "select",
         prefill: opt.prefill,
       }));
+      const detailsBase = {
+        question,
+        context,
+        options: normalizedOptions,
+        allowMultiple,
+        allowFreeform,
+      };
 
       // Emit ASK_USER_PROMPT event if notifyOnAsk is enabled
       if (settings.notifyOnAsk) {
@@ -286,8 +293,7 @@ export function registerAskUserTools(pi: ExtensionAPI): void {
             },
           ],
           details: {
-            question,
-            options: normalizedOptions.map((o) => o.label),
+            ...detailsBase,
             response: {
               kind: "cancelled",
             } as AskUserResponse,
@@ -348,8 +354,7 @@ export function registerAskUserTools(pi: ExtensionAPI): void {
           return {
             content: [{ type: "text", text: "User cancelled the session launch" }],
             details: {
-              question,
-              options: normalizedOptions.map((o) => o.label),
+              ...detailsBase,
               response: {
                 kind: "cancelled",
                 comment: "Session launcher cancelled",
@@ -374,8 +379,7 @@ export function registerAskUserTools(pi: ExtensionAPI): void {
           return {
             content: [{ type: "text", text: "Session launch cancelled: no prefill message was provided." }],
             details: {
-              question,
-              options: normalizedOptions.map((o) => o.label),
+              ...detailsBase,
               response: {
                 kind: "cancelled",
                 comment: "Session launcher had no prefill to queue",
@@ -404,8 +408,7 @@ export function registerAskUserTools(pi: ExtensionAPI): void {
         return {
           content: [{ type: "text", text: contentText }],
           details: {
-            question,
-            options: normalizedOptions.map((o) => o.label),
+            ...detailsBase,
             response: {
               ...response,
               prefill: handoff.prefill ?? prefill,
@@ -421,8 +424,7 @@ export function registerAskUserTools(pi: ExtensionAPI): void {
       return {
         content: [{ type: "text", text: contentText }],
         details: {
-          question,
-          options: normalizedOptions.map((o) => o.label),
+          ...detailsBase,
           response,
         },
       };

package/packages/autocomplete/README.md

@@ -0,0 +1,36 @@
+# @pi-unipi/command-enchantment
+
+Enhanced autocomplete for Unipi commands. It wraps Pi's base autocomplete provider and makes `/unipi:*` suggestions easier to scan with package grouping, stable sorting, short descriptions, and package colors.
+
+## Commands
+
+Command Enchantment has no user commands. It improves the editor autocomplete experience automatically when the package is installed.
+
+## What It Does
+
+- Groups `/unipi:*` commands by package so workflow, memory, web, footer, and other commands are visually distinct.
+- Sorts matches in predictable tiers: exact Unipi matches first, then other Unipi matches, then system commands.
+- Preserves dynamic argument completions from command providers, including workflow document and worktree suggestions.
+- Ships an audit test that checks registered Unipi commands are represented in the autocomplete registry and have descriptions.
+
+## Development Checks
+
+Run the registry audit before releases:
+
+```bash
+npm --workspace packages/autocomplete test -- src/__tests__/command-registry.audit.test.ts
+```
+
+Run all autocomplete tests:
+
+```bash
+npm --workspace packages/autocomplete test
+```
+
+## Configuration
+
+Autocomplete enhancement is enabled by default. The package stores its toggle in the Unipi config and can be disabled by setting `autocompleteEnhanced` to `false`.
+
+## License
+
+MIT

package/packages/autocomplete/src/__tests__/command-registry.audit.test.ts

@@ -0,0 +1,120 @@
+import { describe, expect, it } from "vitest";
+import { existsSync, globSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+function findRepoRoot(start: string): string {
+  let dir = start;
+  while (dir !== dirname(dir)) {
+    if (existsSync(join(dir, "packages", "autocomplete", "src", "constants.ts"))) return dir;
+    dir = dirname(dir);
+  }
+  return start;
+}
+
+const root = findRepoRoot(process.cwd());
+
+function read(path: string): string {
+  return readFileSync(join(root, path), "utf-8");
+}
+
+function collectConstants(): Map<string, string> {
+  const constants = new Map<string, string>([["UNIPI_PREFIX", "unipi:"]]);
+
+  for (const path of globSync("packages/**/*.ts", { cwd: root })) {
+    const text = read(path);
+    for (const obj of text.matchAll(/(?:export\s+)?const\s+(\w+)\s*=\s*\{([\s\S]*?)\}\s*as\s+const/g)) {
+      const [, name, body] = obj;
+      for (const item of body.matchAll(/(\w+):\s*"([^"]+)"/g)) {
+        constants.set(`${name}.${item[1]}`, item[2]);
+      }
+    }
+  }
+
+  return constants;
+}
+
+function evaluateCommandExpression(expr: string, constants: Map<string, string>): string | null {
+  const trimmed = expr.trim();
+
+  if (trimmed.startsWith('"') || trimmed.startsWith("'")) {
+    const quote = trimmed[0];
+    const end = trimmed.indexOf(quote, 1);
+    return end > 0 ? trimmed.slice(1, end) : null;
+  }
+
+  if (trimmed.startsWith("`")) {
+    const end = trimmed.lastIndexOf("`");
+    if (end <= 0) return null;
+    return trimmed.slice(1, end).replace(/\$\{([^}]+)\}/g, (_match, key: string) => {
+      const resolved = constants.get(key.trim());
+      return resolved ?? `\${${key}}`;
+    });
+  }
+
+  return constants.get(trimmed) ?? null;
+}
+
+function registeredCommands(): { commands: Set<string>; nonUnipi: string[]; unresolved: string[] } {
+  const constants = collectConstants();
+  const commands = new Set<string>();
+  const nonUnipi: string[] = [];
+  const unresolved: string[] = [];
+
+  for (const path of globSync("packages/**/*.ts", { cwd: root }).sort()) {
+    const text = read(path);
+    if (!text.includes("registerCommand")) continue;
+
+    for (const match of text.matchAll(/\.registerCommand\(\s*([^,\n]+)/g)) {
+      const expr = match[1].trim();
+
+      // Workflow registers a loop over WORKFLOW_COMMANDS via local `fullCommand`.
+      if (path === "packages/workflow/commands.ts" && expr === "fullCommand") {
+        for (const [key, value] of constants) {
+          if (key.startsWith("WORKFLOW_COMMANDS.")) commands.add(`unipi:${value}`);
+        }
+        continue;
+      }
+
+      const command = evaluateCommandExpression(expr, constants);
+      if (!command || command.includes("${")) {
+        unresolved.push(`${path}: ${expr}`);
+        continue;
+      }
+
+      if (command.startsWith("unipi:")) {
+        commands.add(command);
+      } else {
+        nonUnipi.push(`${command} (${path})`);
+      }
+    }
+  }
+
+  return { commands, nonUnipi, unresolved };
+}
+
+function autocompleteRegistry(): { registry: Set<string>; descriptions: Set<string>; registryPackages: Set<string>; labels: Set<string> } {
+  const text = read("packages/autocomplete/src/constants.ts");
+  const registryBody = text.match(/export const COMMAND_REGISTRY[^=]*= \{([\s\S]*?)\n\};/)?.[1] ?? "";
+  const descriptionsBody = text.match(/export const COMMAND_DESCRIPTIONS[^=]*= \{([\s\S]*?)\n\};/)?.[1] ?? "";
+  const labelsBody = text.match(/export const PACKAGE_LABELS[^=]*= \{([\s\S]*?)\n\};/)?.[1] ?? "";
+
+  const registry = new Set([...registryBody.matchAll(/"(unipi:[^"]+)"\s*:/g)].map((m) => m[1]));
+  const descriptions = new Set([...descriptionsBody.matchAll(/"(unipi:[^"]+)"\s*:/g)].map((m) => m[1]));
+  const registryPackages = new Set([...registryBody.matchAll(/"unipi:[^"]+"\s*:\s*"([^"]+)"/g)].map((m) => m[1]));
+  const labels = new Set([...labelsBody.matchAll(/^\s*"?([a-z][a-z0-9-]*)"?:\s*"/gm)].map((m) => m[1]));
+
+  return { registry, descriptions, registryPackages, labels };
+}
+
+describe("autocomplete command registry audit", () => {
+  it("mirrors every registered /unipi:* command and has no non-unipi package commands", () => {
+    const registered = registeredCommands();
+    const autocomplete = autocompleteRegistry();
+
+    expect(registered.unresolved, "unresolved registerCommand expressions").toEqual([]);
+    expect(registered.nonUnipi, "package commands must use the unipi: prefix").toEqual([]);
+    expect([...registered.commands].sort()).toEqual([...autocomplete.registry].sort());
+    expect([...autocomplete.registry].sort()).toEqual([...autocomplete.descriptions].sort());
+    expect([...autocomplete.registryPackages].filter((pkg) => !autocomplete.labels.has(pkg)).sort()).toEqual([]);
+  });
+});

package/packages/autocomplete/src/constants.ts

@@ -20,6 +20,7 @@ export const PACKAGE_ORDER: string[] = [
   "workflow",
   "ralph",
   "memory",
+  "btw",
   "milestone",
   "mcp",
   "utility",
@@ -41,6 +42,7 @@ export const PACKAGE_COLORS: Record<string, string> = {
   workflow:  `${ESC}[91m`, // Bright Red
   ralph:     `${ESC}[33m`, // Yellow/Orange
   memory:    `${ESC}[93m`, // Bright Yellow
+  btw:       `${ESC}[95m`, // Bright Magenta
   milestone: `${ESC}[32m`, // Green
   mcp:       `${ESC}[32m`, // Green
   utility:   `${ESC}[36m`, // Cyan
@@ -57,7 +59,7 @@ export const PACKAGE_COLORS: Record<string, string> = {
 };
 
 // ─── Command Registry ────────────────────────────────────────────────
-/** Mapping of full command name → package name (80 verified commands) */
+/** Mapping of full command name → package name (88 verified commands) */
 export const COMMAND_REGISTRY: Record<string, string> = {
   // workflow (20 commands)
   "unipi:brainstorm":     "workflow",
@@ -95,6 +97,14 @@ export const COMMAND_REGISTRY: Record<string, string> = {
   "unipi:global-memory-list":   "memory",
   "unipi:memory-settings":   "memory",
 
+  // btw (6 commands)
+  "unipi:btw":           "btw",
+  "unipi:btw-tangent":   "btw",
+  "unipi:btw-new":       "btw",
+  "unipi:btw-clear":     "btw",
+  "unipi:btw-inject":    "btw",
+  "unipi:btw-summarize": "btw",
+
   // mcp (5 commands)
   "unipi:mcp-status":   "mcp",
   "unipi:mcp-sync":     "mcp",
@@ -126,14 +136,16 @@ export const COMMAND_REGISTRY: Record<string, string> = {
   "unipi:web-settings":    "web-api",
   "unipi:web-cache-clear": "web-api",
 
-  // compact (7 commands)
+  // compact (9 commands)
   "unipi:lossless-compact": "compact",
   "unipi:compact":         "compact",
+  "unipi:session-recall":  "compact",
   "unipi:compact-recall":  "compact",
   "unipi:compact-stats":   "compact",
   "unipi:compact-doctor":  "compact",
   "unipi:compact-settings": "compact",
   "unipi:compact-preset":  "compact",
+  "unipi:compact-help":    "compact",
 
   // cocoindex (5 commands)
   "unipi:cocoindex-update":  "cocoindex",
@@ -208,6 +220,13 @@ export const COMMAND_DESCRIPTIONS: Record<string, string> = {
   "unipi:global-memory-list":   "List all project memories",
   "unipi:memory-settings":   "Configure memory settings",
 
+  "unipi:btw":           "Run a parallel side conversation",
+  "unipi:btw-tangent":   "Start a contextless BTW tangent thread",
+  "unipi:btw-new":       "Start a fresh BTW thread with session context",
+  "unipi:btw-clear":     "Dismiss and clear the BTW thread",
+  "unipi:btw-inject":    "Inject the BTW thread into the main agent",
+  "unipi:btw-summarize": "Summarize and inject the BTW thread",
+
   "unipi:mcp-status":   "Show MCP server status",
   "unipi:mcp-sync":     "Sync MCP server connections",
   "unipi:mcp-add":      "Add a new MCP server",
@@ -238,11 +257,13 @@ export const COMMAND_DESCRIPTIONS: Record<string, string> = {
 
   "unipi:lossless-compact": "Immediate zero-LLM compaction",
   "unipi:compact":          "(DEPRECATED) Use /unipi:lossless-compact instead",
-  "unipi:compact-recall":   "Recall a compacted session",
+  "unipi:session-recall":   "Search session history, including compacted-away messages",
+  "unipi:compact-recall":   "(DEPRECATED) Use /unipi:session-recall instead",
   "unipi:compact-stats":    "Show compaction statistics",
   "unipi:compact-doctor":   "Diagnose compaction issues",
   "unipi:compact-settings": "Configure compaction settings",
   "unipi:compact-preset":   "Manage compaction presets",
+  "unipi:compact-help":     "Show compactor command help",
   "unipi:cocoindex-update":  "Run CocoIndex update to index project",
   "unipi:cocoindex-status":  "Show CocoIndex indexing status",
   "unipi:cocoindex-init":    "Initialize CocoIndex pipeline",
@@ -276,6 +297,7 @@ export const PACKAGE_LABELS: Record<string, string> = {
   workflow:  "workflow",
   ralph:     "ralph",
   memory:    "memory",
+  btw:       "btw",
   milestone: "milestone",
   mcp:       "mcp",
   utility:   "utility",
@@ -288,4 +310,5 @@ export const PACKAGE_LABELS: Record<string, string> = {
   footer:    "footer",
   updater:   "updater",
   "input-shortcuts": "input-shortcuts",
+  cocoindex: "cocoindex",
 };

package/packages/btw/README.md

@@ -1,6 +1,6 @@
 # @pi-unipi/btw
 
-Side conversations that run in parallel. Ask a question using `/btw` while the main agent keeps working — the answer streams into a modal overlay without interrupting the current task.
+Side conversations that run in parallel. Ask a question using `/unipi:btw` while the main agent keeps working — the answer streams into a modal overlay without interrupting the current task.
 
 BTW opens a real Pi sub-session with coding-tool access. Use it to clarify something, explore an idea, or think through next steps without derailing the main turn. When you're ready, inject the thread back or summarize it.
 
@@ -10,12 +10,12 @@ Based on [pi-btw](https://github.com/Neuron-Mr-White/pi-btw) by Dan Bachelder.
 
 | Command | Description |
 |---------|-------------|
-| `/btw [--save] <question>` | Ask a question in a side thread |
-| `/btw:new [question]` | Start a fresh thread with main-session context |
-| `/btw:tangent [--save] <question>` | Contextless tangent thread |
-| `/btw:clear` | Dismiss modal and clear thread |
-| `/btw:inject [instructions]` | Send full thread to main agent |
-| `/btw:summarize [instructions]` | Summarize thread and inject into main agent |
+| `/unipi:btw [--save] <question>` | Ask a question in a side thread |
+| `/unipi:btw-new [question]` | Start a fresh thread with main-session context |
+| `/unipi:btw-tangent [--save] <question>` | Contextless tangent thread |
+| `/unipi:btw-clear` | Dismiss modal and clear thread |
+| `/unipi:btw-inject [instructions]` | Send full thread to main agent |
+| `/unipi:btw-summarize [instructions]` | Summarize thread and inject into main agent |
 
 ### Keyboard Shortcuts
 
@@ -29,13 +29,13 @@ Based on [pi-btw](https://github.com/Neuron-Mr-White/pi-btw) by Dan Bachelder.
 ### Examples
 
 ```text
-/btw what file defines this route?
-/btw how would you refactor this parser?
-/btw --save summarize the last error in one sentence
-/btw:new let's start a fresh thread about auth
-/btw:tangent brainstorm from first principles without using the current chat context
-/btw:inject implement the plan we just discussed
-/btw:summarize turn that side thread into a short handoff
+/unipi:btw what file defines this route?
+/unipi:btw how would you refactor this parser?
+/unipi:btw --save summarize the last error in one sentence
+/unipi:btw-new let's start a fresh thread about auth
+/unipi:btw-tangent brainstorm from first principles without using the current chat context
+/unipi:btw-inject implement the plan we just discussed
+/unipi:btw-summarize turn that side thread into a short handoff
 ```
 
 ## Special Triggers
@@ -46,14 +46,14 @@ The BTW overlay opens top-centered so the main session remains visible underneat
 
 ## How It Works
 
-1. `/btw` creates or reuses a BTW sub-session
+1. `/unipi:btw` creates or reuses a BTW sub-session
 2. Your question runs in a real Pi session with tool access
 3. The answer streams into the BTW modal overlay
 4. The thread continues until you clear it or inject it back
 
-`/btw:inject` sends the full thread to the main agent as a user message. If Pi is busy, it queues as a follow-up. `/btw:summarize` does the same but summarizes first.
+`/unipi:btw-inject` sends the full thread to the main agent as a user message. If Pi is busy, it queues as a follow-up. `/unipi:btw-summarize` does the same but summarizes first.
 
-`/btw:tangent` starts a separate thread that doesn't inherit the main session's conversation context. Use it for unrelated exploration.
+`/unipi:btw-tangent` starts a separate thread that doesn't inherit the main session's conversation context. Use it for unrelated exploration.
 
 The `--save` flag saves that single exchange as a visible session note.
 

package/packages/btw/extensions/btw.ts

@@ -1,19 +1,19 @@
 /**
  * @pi-unipi/btw — Side Conversation Extension
  *
- * A /btw side conversation channel that opens a real pi sub-session
+ * A /unipi:btw side conversation channel that opens a real pi sub-session
  * with coding-tool access, running immediately even while the main
  * agent is still busy.
  *
  * Based on pi-btw by Dan Bachelder, adapted for the Unipi suite.
  *
  * Commands:
- *   /btw [--save] <question>   - Side conversation (contextual)
- *   /btw:tangent [--save] <q>  - Contextless tangent thread
- *   /btw:new [question]        - Fresh thread with main-session context
- *   /btw:clear                 - Dismiss and clear thread
- *   /btw:inject [instructions] - Send full thread to main agent
- *   /btw:summarize [instr]     - Summarize and inject into main agent
+ *   /unipi:btw [--save] <question>       - Side conversation (contextual)
+ *   /unipi:btw-tangent [--save] <q>      - Contextless tangent thread
+ *   /unipi:btw-new [question]            - Fresh thread with main-session context
+ *   /unipi:btw-clear                     - Dismiss and clear thread
+ *   /unipi:btw-inject [instructions]     - Send full thread to main agent
+ *   /unipi:btw-summarize [instructions]  - Summarize and inject into main agent
  */
 
 import {
@@ -44,6 +44,7 @@ import {
   type OverlayHandle,
   type TUI,
 } from "@mariozechner/pi-tui";
+import { BTW_COMMANDS, UNIPI_PREFIX } from "@pi-unipi/core";
 
 // ─── Constants ──────────────────────────────────────────────────────────────
 
@@ -1615,15 +1616,23 @@ export default function (pi: ExtensionAPI) {
 
   function parseOverlayBtwCommand(value: string): { name: string; args: string } | null {
     const trimmed = value.trim();
-    const match = trimmed.match(/^\/(btw:(?:new|tangent|clear|inject|summarize))(?:\s+(.*))?$/);
-    if (!match) {
-      return null;
+    const legacy = trimmed.match(/^\/(btw:(?:new|tangent|clear|inject|summarize))(?:\s+(.*))?$/);
+    if (legacy) {
+      return {
+        name: legacy[1],
+        args: legacy[2]?.trim() ?? "",
+      };
     }
 
-    return {
-      name: match[1],
-      args: match[2]?.trim() ?? "",
-    };
+    const unipi = trimmed.match(/^\/unipi:btw-(new|tangent|clear|inject|summarize)(?:\s+(.*))?$/);
+    if (unipi) {
+      return {
+        name: `btw:${unipi[1]}`,
+        args: unipi[2]?.trim() ?? "",
+      };
+    }
+
+    return null;
   }
 
   async function submitFromOverlay(ctx: ExtensionCommandContext | ExtensionContext, value: string): Promise<void> {
@@ -1928,42 +1937,42 @@ export default function (pi: ExtensionAPI) {
     });
   }
 
-  pi.registerCommand("btw", {
+  pi.registerCommand(`${UNIPI_PREFIX}${BTW_COMMANDS.BTW}`, {
     description: "Continue a side conversation in a focused BTW modal. Add --save to also persist a visible note.",
     handler: async (args, ctx) => {
       await dispatchBtwCommand("btw", args, ctx);
     },
   });
 
-  pi.registerCommand("btw:tangent", {
+  pi.registerCommand(`${UNIPI_PREFIX}${BTW_COMMANDS.TANGENT}`, {
     description: "Start or continue a contextless BTW tangent in the focused BTW modal.",
     handler: async (args, ctx) => {
       await dispatchBtwCommand("btw:tangent", args, ctx);
     },
   });
 
-  pi.registerCommand("btw:new", {
+  pi.registerCommand(`${UNIPI_PREFIX}${BTW_COMMANDS.NEW}`, {
     description: "Start a fresh BTW thread with main-session context. Optionally ask the first question immediately.",
     handler: async (args, ctx) => {
       await dispatchBtwCommand("btw:new", args, ctx);
     },
   });
 
-  pi.registerCommand("btw:clear", {
+  pi.registerCommand(`${UNIPI_PREFIX}${BTW_COMMANDS.CLEAR}`, {
     description: "Dismiss the BTW modal/widget and clear the current thread.",
     handler: async (args, ctx) => {
       await dispatchBtwCommand("btw:clear", args, ctx);
     },
   });
 
-  pi.registerCommand("btw:inject", {
+  pi.registerCommand(`${UNIPI_PREFIX}${BTW_COMMANDS.INJECT}`, {
     description: "Inject the full BTW thread into the main agent as a user message.",
     handler: async (args, ctx) => {
       await dispatchBtwCommand("btw:inject", args, ctx);
     },
   });
 
-  pi.registerCommand("btw:summarize", {
+  pi.registerCommand(`${UNIPI_PREFIX}${BTW_COMMANDS.SUMMARIZE}`, {
     description: "Summarize the BTW thread, then inject the summary into the main agent.",
     handler: async (args, ctx) => {
       await dispatchBtwCommand("btw:summarize", args, ctx);

package/packages/btw/skills/btw/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: btw
-description: Helps you use the /btw side-conversation workflow effectively. Use when you want to think in parallel, ask side questions without interrupting ongoing work, or inject a side thread back into the main agent.
+description: Helps you use the /unipi:btw side-conversation workflow effectively. Use when you want to think in parallel, ask side questions without interrupting ongoing work, or inject a side thread back into the main agent.
 ---
 
 # BTW
@@ -21,14 +21,14 @@ Prefer the BTW workflow when the user wants to:
 Use these commands in your guidance to the user:
 
 ```text
-/btw <question>
-/btw --save <question>
-/btw:new [question]
-/btw:tangent <question>
-/btw:tangent --save <question>
-/btw:clear
-/btw:inject [instructions]
-/btw:summarize [instructions]
+/unipi:btw <question>
+/unipi:btw --save <question>
+/unipi:btw-new [question]
+/unipi:btw-tangent <question>
+/unipi:btw-tangent --save <question>
+/unipi:btw-clear
+/unipi:btw-inject [instructions]
+/unipi:btw-summarize [instructions]
 ```
 
 ## How to guide the user
@@ -38,7 +38,7 @@ Use these commands in your guidance to the user:
 Recommend:
 
 ```text
-/btw <question>
+/unipi:btw <question>
 ```
 
 Use this when the user wants an immediate aside and does not need a visible saved note.
@@ -48,7 +48,7 @@ Use this when the user wants an immediate aside and does not need a visible save
 Recommend:
 
 ```text
-/btw --save <question>
+/unipi:btw --save <question>
 ```
 
 Use this when the user wants the exchange to appear as a visible BTW note in the session transcript.
@@ -58,13 +58,13 @@ Use this when the user wants the exchange to appear as a visible BTW note in the
 Recommend:
 
 ```text
-/btw:new
+/unipi:btw-new
 ```
 
 or
 
 ```text
-/btw:new <question>
+/unipi:btw-new <question>
 ```
 
 Use this when the previous BTW discussion is no longer relevant, but you still want the new side thread to inherit the current main-session context.
@@ -74,13 +74,13 @@ Use this when the previous BTW discussion is no longer relevant, but you still w
 Recommend:
 
 ```text
-/btw:tangent <question>
+/unipi:btw-tangent <question>
 ```
 
 or
 
 ```text
-/btw:tangent --save <question>
+/unipi:btw-tangent --save <question>
 ```
 
 Use this when the user wants a side conversation that does not include the current main-session context.
@@ -90,7 +90,7 @@ Use this when the user wants a side conversation that does not include the curre
 Recommend:
 
 ```text
-/btw:inject <instructions>
+/unipi:btw-inject <instructions>
 ```
 
 Use this when the exact discussion matters and the user wants the main agent to act on it.
@@ -100,19 +100,19 @@ Use this when the exact discussion matters and the user wants the main agent to
 Recommend:
 
 ```text
-/btw:summarize <instructions>
+/unipi:btw-summarize <instructions>
 ```
 
 Use this when the thread is long and only the distilled outcome should go back into the main agent.
 
 ## Recommendation rules
 
-- Prefer `/btw` over normal chat when the user explicitly wants a side conversation.
-- Prefer `/btw:tangent` when the user wants that side conversation to be contextless.
-- Prefer `/btw:summarize` over `/btw:inject` for long exploratory threads.
-- Prefer `/btw:inject` when precise wording, detailed tradeoffs, or a full plan matters.
-- Suggest `/btw:new` before starting a totally unrelated side topic when main-session context is still useful.
-- Suggest `/btw:clear` when the widget/thread should be dismissed.
+- Prefer `/unipi:btw` over normal chat when the user explicitly wants a side conversation.
+- Prefer `/unipi:btw-tangent` when the user wants that side conversation to be contextless.
+- Prefer `/unipi:btw-summarize` over `/unipi:btw-inject` for long exploratory threads.
+- Prefer `/unipi:btw-inject` when precise wording, detailed tradeoffs, or a full plan matters.
+- Suggest `/unipi:btw-new` before starting a totally unrelated side topic when main-session context is still useful.
+- Suggest `/unipi:btw-clear` when the widget/thread should be dismissed.
 
 ## Response style
 
@@ -127,23 +127,23 @@ When helping the user use BTW:
 ### Example: brainstorm while coding continues
 
 ```text
-/btw what are the risks of switching this to optimistic updates?
+/unipi:btw what are the risks of switching this to optimistic updates?
 ```
 
 ### Example: create a clean new thread
 
 ```text
-/btw:new sketch a safer migration plan
+/unipi:btw-new sketch a safer migration plan
 ```
 
 ### Example: start a contextless tangent
 
 ```text
-/btw:tangent think through this from first principles without using the current chat context
+/unipi:btw-tangent think through this from first principles without using the current chat context
 ```
 
 ### Example: send the result back
 
 ```text
-/btw:summarize implement the recommended migration plan
+/unipi:btw-summarize implement the recommended migration plan
 ```

package/packages/compactor/src/commands/index.ts

@@ -13,6 +13,8 @@ import { getLastCompactionStats } from "../compaction/hooks.js";
 import { vccRecall } from "../tools/vcc-recall.js";
 import { ctxStats } from "../tools/ctx-stats.js";
 import { ctxDoctor } from "../tools/ctx-doctor.js";
+import { recallBlocksFromContext } from "../session/recall-blocks.js";
+import { filterNoise } from "../compaction/filter-noise.js";
 import type { SessionDB } from "../session/db.js";
 import type { NormalizedBlock, RuntimeCounters } from "../types.js";
 
@@ -90,13 +92,19 @@ export function registerCommands(pi: ExtensionAPI, deps?: CommandDeps): void {
   });
 
   // ── /unipi:session-recall (new) ─────────────────────
-  const sessionRecallHandler = async (args: string, ctx: ExtensionCommandContext) => {
+  const sessionRecallHandler = async (args: string, ctx: ExtensionCommandContext, commandName = "/unipi:session-recall") => {
     const query = args.trim();
     if (!query) {
-      ctx.ui.notify("Usage: /unipi:session-recall <query>", "warning");
+      const suffix = commandName === "/unipi:compact-recall" ? " (deprecated; use /unipi:session-recall <query>)" : "";
+      ctx.ui.notify(`Usage: ${commandName} <query>${suffix}`, "warning");
       return;
     }
-    const blocks = deps?.getBlocks() ?? [];
+
+    // Prefer the live session branch over cached blocks. The branch includes raw
+    // pre-compaction messages that are omitted from the compacted LLM context.
+    const config = loadConfig((ctx as any).cwd ?? process.cwd());
+    const liveBlocks = filterNoise(recallBlocksFromContext(ctx), config.pipeline?.customNoisePatterns);
+    const blocks = liveBlocks.length > 0 ? liveBlocks : (deps?.getBlocks() ?? []);
     if (blocks.length === 0) {
       ctx.ui.notify("No session history available for search.", "warning");
       return;
@@ -120,7 +128,7 @@ export function registerCommands(pi: ExtensionAPI, deps?: CommandDeps): void {
     description: "(DEPRECATED) Search session history — use /unipi:session-recall instead",
     handler: async (args: string, ctx: ExtensionCommandContext) => {
       deprecationLog("/unipi:compact-recall", "/unipi:session-recall");
-      return sessionRecallHandler(args, ctx);
+      return sessionRecallHandler(args, ctx, "/unipi:compact-recall");
     },
   });
 

package/packages/compactor/src/index.ts

@@ -14,6 +14,7 @@ import { registerCommands } from "./commands/index.js";
 import { registerCompactorTools } from "./tools/register.js";
 import { normalizeMessages } from "./compaction/normalize.js";
 import { filterNoise } from "./compaction/filter-noise.js";
+import { recallBlocksFromContext } from "./session/recall-blocks.js";
 import type { NormalizedBlock, CompactorStrategyConfig, RuntimeCounters } from "./types.js";
 import type { RuntimeStats } from "./session/analytics.js";
 
@@ -242,12 +243,20 @@ export default function compactorExtension(pi: ExtensionAPI): void {
       // Non-fatal
     }
 
-    // Re-cache normalized blocks for vcc_recall
+    // Re-cache normalized blocks for session_recall/vcc_recall.
+    // Command/event contexts do not expose ctx.messages; use the append-only
+    // session branch so recall can find raw messages hidden by compaction.
     try {
-      const messages = (ctx as any).messages ?? [];
-      if (messages.length > 0) {
-        const normalized = normalizeMessages(messages);
-        cachedBlocks = filterNoise(normalized, config.pipeline?.customNoisePatterns);
+      const sessionBlocks = recallBlocksFromContext(ctx);
+      if (sessionBlocks.length > 0) {
+        cachedBlocks = filterNoise(sessionBlocks, config.pipeline?.customNoisePatterns);
+      } else {
+        // Defensive fallback for older Pi contexts that happened to expose messages.
+        const messages = (ctx as any).messages ?? [];
+        if (messages.length > 0) {
+          const normalized = normalizeMessages(messages);
+          cachedBlocks = filterNoise(normalized, config.pipeline?.customNoisePatterns);
+        }
       }
     } catch {
       // Non-fatal: recall will work on empty blocks

package/packages/compactor/src/session/recall-blocks.ts

@@ -0,0 +1,112 @@
+/**
+ * Build searchable recall blocks from Pi session entries.
+ *
+ * `ctx.messages` is not available to command handlers and compacted session
+ * context only contains summaries/kept messages. The append-only session branch
+ * still contains the raw pre-compaction messages, so recall should index that
+ * branch directly.
+ */
+
+import type { SessionEntry } from "@mariozechner/pi-coding-agent";
+import type { AgentMessage } from "@mariozechner/pi-agent-core";
+import { normalizeMessages } from "../compaction/normalize.js";
+import { sanitize } from "../compaction/sanitize.js";
+import { textOf } from "../compaction/content.js";
+import type { NormalizedBlock } from "../types.js";
+
+function block(kind: "user" | "assistant", text: string, sourceIndex?: number): NormalizedBlock[] {
+  const clean = sanitize(text);
+  return clean ? [{ kind, text: clean, sourceIndex }] : [];
+}
+
+function normalizeAgentMessage(message: AgentMessage, sourceIndex: number): NormalizedBlock[] {
+  const role = (message as { role?: string }).role;
+
+  // Standard LLM message roles are handled by the existing normalizer.
+  if (role === "user" || role === "assistant" || role === "toolResult") {
+    return normalizeMessages([message as Parameters<typeof normalizeMessages>[0][number]]).map((b) => ({
+      ...b,
+      sourceIndex,
+    }));
+  }
+
+  // Pi-specific session message roles that do not participate in pi-ai Message.
+  if (role === "bashExecution") {
+    const msg = message as AgentMessage & {
+      command?: string;
+      output?: string;
+      exitCode?: number;
+      cancelled?: boolean;
+    };
+    const text = [`$ ${msg.command ?? ""}`, msg.output ?? ""].filter(Boolean).join("\n");
+    return text
+      ? [{ kind: "tool_result", name: "bash", text: sanitize(text), isError: Boolean(msg.cancelled || (msg.exitCode ?? 0) !== 0), sourceIndex }]
+      : [];
+  }
+
+  if (role === "custom") {
+    const msg = message as AgentMessage & { customType?: string; content?: unknown };
+    return block("user", [msg.customType, textOf(msg.content)].filter(Boolean).join("\n"), sourceIndex);
+  }
+
+  if (role === "branchSummary") {
+    const msg = message as AgentMessage & { summary?: string };
+    return block("assistant", msg.summary ?? "", sourceIndex);
+  }
+
+  if (role === "compactionSummary") {
+    const msg = message as AgentMessage & { summary?: string };
+    return block("assistant", msg.summary ?? "", sourceIndex);
+  }
+
+  return [];
+}
+
+/** Convert the active append-only session branch into searchable blocks. */
+export function recallBlocksFromSessionEntries(entries: SessionEntry[]): NormalizedBlock[] {
+  return entries.flatMap((entry, i) => {
+    if (entry.type === "message") {
+      return normalizeAgentMessage(entry.message, i);
+    }
+
+    if (entry.type === "custom_message") {
+      return block("user", [entry.customType, textOf(entry.content)].filter(Boolean).join("\n"), i);
+    }
+
+    if (entry.type === "branch_summary") {
+      return block("assistant", entry.summary, i);
+    }
+
+    if (entry.type === "compaction") {
+      return block("assistant", entry.summary, i);
+    }
+
+    return [];
+  });
+}
+
+/** Best-effort read of searchable blocks from an extension context. */
+export function recallBlocksFromContext(ctx: unknown): NormalizedBlock[] {
+  const sessionManager = (ctx as { sessionManager?: { getBranch?: () => SessionEntry[]; buildSessionContext?: () => { messages?: AgentMessage[] } } })?.sessionManager;
+
+  try {
+    const entries = sessionManager?.getBranch?.();
+    if (Array.isArray(entries) && entries.length > 0) {
+      const blocks = recallBlocksFromSessionEntries(entries);
+      if (blocks.length > 0) return blocks;
+    }
+  } catch {
+    // Fall through to compacted context fallback.
+  }
+
+  try {
+    const messages = sessionManager?.buildSessionContext?.().messages ?? [];
+    if (messages.length > 0) {
+      return messages.flatMap((message, i) => normalizeAgentMessage(message, i));
+    }
+  } catch {
+    // No session context available.
+  }
+
+  return [];
+}

package/packages/compactor/src/tools/register.ts

@@ -14,7 +14,7 @@
  */
 
 import { Type } from "@sinclair/typebox";
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { compactTool } from "./compact.js";
 import { vccRecall, type RecallInput } from "./vcc-recall.js";
 import { ctxExecute, type CtxExecuteInput } from "./ctx-execute.js";
@@ -23,6 +23,9 @@ import { ctxBatchExecute, type BatchItem } from "./ctx-batch-execute.js";
 import { ctxStats, type CtxStatsResult } from "./ctx-stats.js";
 import { ctxDoctor, type DoctorResult } from "./ctx-doctor.js";
 import { contextBudgetTool } from "./context-budget.js";
+import { recallBlocksFromContext } from "../session/recall-blocks.js";
+import { filterNoise } from "../compaction/filter-noise.js";
+import { loadConfig } from "../config/manager.js";
 import type { SessionDB } from "../session/db.js";
 import type { NormalizedBlock, RuntimeCounters } from "../types.js";
 
@@ -157,10 +160,12 @@ export function registerCompactorTools(pi: ExtensionAPI, deps: CompactorToolDeps
   } as any));
 
   // 2. session_recall (new) / vcc_recall (deprecated) — search session history
-  const recallExec = async (_toolCallId: string, params: any): Promise<import("@mariozechner/pi-coding-agent").AgentToolResult<unknown>> => {
+  const recallExec = async (_toolCallId: string, params: any, _signal?: AbortSignal, _onUpdate?: unknown, ctx?: ExtensionContext): Promise<import("@mariozechner/pi-coding-agent").AgentToolResult<unknown>> => {
     const c = deps.getCounters?.();
     if (c) { c.recallQueries++; }
-    const blocks = deps.getBlocks();
+    const config = loadConfig(ctx?.cwd ?? process.cwd());
+    const liveBlocks = ctx ? filterNoise(recallBlocksFromContext(ctx), config.pipeline?.customNoisePatterns) : [];
+    const blocks = liveBlocks.length > 0 ? liveBlocks : deps.getBlocks();
     const input: RecallInput = {
       query: params.query,
       mode: params.mode,

package/packages/core/constants.ts

@@ -236,11 +236,13 @@ export const COMPACTOR_TOOLS = {
 export const COMPACTOR_COMMANDS = {
   LOSSLESS_COMPACT: "lossless-compact",
   COMPACT: "compact",
+  SESSION_RECALL: "session-recall",
   COMPACT_RECALL: "compact-recall",
   COMPACT_STATS: "compact-stats",
   COMPACT_DOCTOR: "compact-doctor",
   COMPACT_SETTINGS: "compact-settings",
   COMPACT_PRESET: "compact-preset",
+  COMPACT_HELP: "compact-help",
 } as const;
 
 /** Compactor directory paths */
@@ -287,6 +289,16 @@ export const NOTIFY_DIRS = {
   CONFIG: "~/.unipi/config/notify",
 } as const;
 
+/** BTW command names */
+export const BTW_COMMANDS = {
+  BTW: "btw",
+  TANGENT: "btw-tangent",
+  NEW: "btw-new",
+  CLEAR: "btw-clear",
+  INJECT: "btw-inject",
+  SUMMARIZE: "btw-summarize",
+} as const;
+
 /** Milestone command names */
 export const MILESTONE_COMMANDS = {
   ONBOARD: "milestone-onboard",

package/packages/workflow/README.md

@@ -97,6 +97,8 @@ For small tasks that skip the full flow:
 /unipi:worktree-merge feat/new-feature
 ```
 
+Worktree command arguments autocomplete from `.unipi/worktrees`. Suggestions are cached after the first scan in a Pi session so large worktree directories do not slow down repeated `/unipi:worktree-merge` completions.
+
 ## Special Triggers
 
 Workflow skills detect installed packages and enhance their behavior automatically. This is the coexists system — each package adds capabilities without requiring configuration.

package/packages/workflow/commands.ts

@@ -10,6 +10,8 @@ import { readFileSync, readdirSync, existsSync, statSync } from "fs";
 import { join, basename } from "path";
 import { UNIPI_PREFIX, WORKFLOW_COMMANDS, getToolsForCommand, getSandboxLevel, type SandboxLevel } from "@pi-unipi/core";
 
+type CompletionItem = { value: string; label: string; description: string };
+
 /** Options for command registration */
 export interface WorkflowCommandOptions {
   /** Check if ralph module is detected */
@@ -36,7 +38,7 @@ interface WorkflowCommand {
 /**
  * Suggest spec files from .unipi/docs/specs/ for plan command.
  */
-function suggestSpecFiles(prefix: string): { value: string; label: string; description: string }[] {
+function suggestSpecFiles(prefix: string): CompletionItem[] {
   const specsDir = join(process.cwd(), ".unipi", "docs", "specs");
   if (!existsSync(specsDir)) return [];
 
@@ -61,7 +63,7 @@ function suggestSpecFiles(prefix: string): { value: string; label: string; descr
 /**
  * Suggest plan files from .unipi/docs/plans/ for work and review-work commands.
  */
-function suggestPlanFiles(prefix: string): { value: string; label: string; description: string }[] {
+function suggestPlanFiles(prefix: string): CompletionItem[] {
   const plansDir = join(process.cwd(), ".unipi", "docs", "plans");
   if (!existsSync(plansDir)) return [];
 
@@ -86,7 +88,7 @@ function suggestPlanFiles(prefix: string): { value: string; label: string; descr
 /**
  * Suggest debug files from .unipi/docs/debug/ for fix command.
  */
-function suggestDebugFiles(prefix: string): { value: string; label: string; description: string }[] {
+function suggestDebugFiles(prefix: string): CompletionItem[] {
   const debugDir = join(process.cwd(), ".unipi", "docs", "debug");
   if (!existsSync(debugDir)) return [];
 
@@ -111,7 +113,7 @@ function suggestDebugFiles(prefix: string): { value: string; label: string; desc
 /**
  * Suggest chore files from .unipi/docs/chore/ for chore-execute command.
  */
-function suggestChoreFiles(prefix: string): { value: string; label: string; description: string }[] {
+function suggestChoreFiles(prefix: string): CompletionItem[] {
   const choreDir = join(process.cwd(), ".unipi", "docs", "chore");
   if (!existsSync(choreDir)) return [];
 
@@ -133,16 +135,29 @@ function suggestChoreFiles(prefix: string): { value: string; label: string; desc
   }
 }
 
+/** Cached per-cwd worktree suggestions. Worktree autocomplete can be invoked on every
+ * keystroke, so the recursive scan is intentionally paid only once per session/cwd.
+ */
+let worktreeSuggestionsCache: { cwd: string; items: CompletionItem[] } | null = null;
+
 /**
  * Suggest existing worktree names for merge/list commands.
  * Recursively scans for actual git worktrees (directories containing .git files).
  */
-function suggestWorktrees(): { value: string; label: string; description: string }[] {
-  const worktreesDir = join(process.cwd(), ".unipi", "worktrees");
-  if (!existsSync(worktreesDir)) return [];
+function suggestWorktrees(): CompletionItem[] {
+  const cwd = process.cwd();
+  if (worktreeSuggestionsCache?.cwd === cwd) {
+    return worktreeSuggestionsCache.items;
+  }
+
+  const worktreesDir = join(cwd, ".unipi", "worktrees");
+  if (!existsSync(worktreesDir)) {
+    worktreeSuggestionsCache = { cwd, items: [] };
+    return worktreeSuggestionsCache.items;
+  }
 
   try {
-    const results: { value: string; label: string; description: string }[] = [];
+    const results: CompletionItem[] = [];
 
     /**
      * Recursively find worktree directories (those containing a .git file).
@@ -176,9 +191,11 @@ function suggestWorktrees(): { value: string; label: string; description: string
     }
 
     findWorktrees(worktreesDir, "");
-    return results;
+    worktreeSuggestionsCache = { cwd, items: results };
+    return worktreeSuggestionsCache.items;
   } catch {
-    return [];
+    worktreeSuggestionsCache = { cwd, items: [] };
+    return worktreeSuggestionsCache.items;
   }
 }
 
@@ -334,7 +351,7 @@ export function registerWorkflowCommands(
     pi.registerCommand(fullCommand, {
       description: cmd.description,
       getArgumentCompletions: (prefix: string) => {
-        let items: { value: string; label: string; description: string }[] | null = null;
+        let items: CompletionItem[] | null = null;
 
         // Plan command: suggest spec files
         if (cmd.name === WORKFLOW_COMMANDS.PLAN) {