@pi-unipi/unipi 2.0.0 → 2.0.2

package/README.md

@@ -77,12 +77,12 @@ 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 |
 | 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 |

package/package.json

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

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

@@ -450,6 +450,20 @@ export function renderAskUI(params: {
       theme: Theme,
       width: number,
     ) {
+      const addWrappedOptionLine = (prefix: string, content: string) => {
+        const prefixWidth = visibleWidth(prefix);
+        const contentWidth = Math.max(1, width - prefixWidth);
+        const continuationPrefix = " ".repeat(prefixWidth);
+        const wrapped = wrapTextWithAnsi(content, contentWidth);
+        for (let lineIndex = 0; lineIndex < wrapped.length; lineIndex++) {
+          add((lineIndex === 0 ? prefix : continuationPrefix) + wrapped[lineIndex]);
+        }
+      };
+
+      const addWrappedDescription = (description: string) => {
+        addWrappedOptionLine("     ", theme.fg("muted", description));
+      };
+
       for (let i = 0; i < displayOptions.length; i++) {
         const opt = displayOptions[i];
         const isSelected = i === optionIndex;
@@ -467,11 +481,9 @@ export function renderAskUI(params: {
             label = `${opt.label}: "${customText}"`;
           }
           
-          add(
-            prefix +
-              theme.fg(color, `[${box}]`) +
-              " " +
-              theme.fg(isSelected ? "accent" : "text", label),
+          addWrappedOptionLine(
+            prefix + theme.fg(color, `[${box}]`) + " ",
+            theme.fg(isSelected ? "accent" : "text", label),
           );
           
           // Show edit indicator if in edit mode for this option
@@ -493,11 +505,9 @@ export function renderAskUI(params: {
             label = `${opt.label}: "${optCustom}"`;
           }
           
-          add(
-            prefix +
-              theme.fg(color, `[${box}]`) +
-              " " +
-              theme.fg(isSelected ? "accent" : "text", label),
+          addWrappedOptionLine(
+            prefix + theme.fg(color, `[${box}]`) + " ",
+            theme.fg(isSelected ? "accent" : "text", label),
           );
           
           // Show edit indicator if in edit mode for this option
@@ -525,11 +535,11 @@ export function renderAskUI(params: {
             label += theme.fg("dim", " ↗");
           }
           
-          add(
-            prefix +
-              (isSelected
-                ? theme.fg("accent", label)
-                : theme.fg("text", label)),
+          addWrappedOptionLine(
+            prefix,
+            isSelected
+              ? theme.fg("accent", label)
+              : theme.fg("text", label),
           );
           
           // Show edit indicator if in edit mode for this option
@@ -543,7 +553,7 @@ export function renderAskUI(params: {
 
         // Description
         if (opt.description) {
-          add(`     ${theme.fg("muted", opt.description)}`);
+          addWrappedDescription(opt.description);
         }
       }
     }
@@ -564,17 +574,46 @@ export function renderAskUI(params: {
 export function createRenderCall() {
   return (args: Record<string, unknown>, theme: Theme, _context: unknown) => {
     const question = (args.question as string) || "";
-    const options = Array.isArray(args.options) ? args.options : [];
+    const context = (args.context as string | undefined) || "";
+    const options = Array.isArray(args.options)
+      ? (args.options as Array<Record<string, unknown>>)
+      : [];
     const mode = args.allowMultiple ? "multi-select" : "single-select";
+    const allowFreeform = args.allowFreeform !== false;
     const count = options.length;
 
-    let text =
-      theme.fg("toolTitle", theme.bold("ask_user ")) +
-      theme.fg("muted", question);
+    const lines: string[] = [];
+    lines.push(
+      theme.fg("toolTitle", theme.bold("ask_user")) +
+        theme.fg("dim", ` (${count} option${count !== 1 ? "s" : ""}, ${mode}${allowFreeform ? ", freeform" : ""})`),
+    );
+    if (context) {
+      lines.push(theme.fg("muted", "Context: ") + theme.fg("text", context));
+    }
+    lines.push(theme.fg("muted", "Question: ") + theme.fg("text", question));
+
     if (count > 0) {
-      text += theme.fg("dim", ` (${count} option${count !== 1 ? "s" : ""}, ${mode})`);
+      lines.push(theme.fg("muted", "Options:"));
+      options.forEach((option, index) => {
+        const label = String(option.label ?? option.value ?? `Option ${index + 1}`);
+        const action = typeof option.action === "string" && option.action !== "select"
+          ? theme.fg("dim", ` [${option.action}]`)
+          : "";
+        lines.push(
+          theme.fg("dim", `  ${index + 1}. `) +
+            theme.fg("text", label) +
+            action,
+        );
+        if (typeof option.description === "string" && option.description.trim()) {
+          lines.push(theme.fg("muted", `     ${option.description}`));
+        }
+        if (typeof option.prefill === "string" && option.prefill.trim()) {
+          lines.push(theme.fg("dim", `     prefill: ${option.prefill}`));
+        }
+      });
     }
-    return new Text(text, 0, 0);
+
+    return new Text(lines.join("\n"), 0, 0);
   };
 }
 

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/cocoindex/bridge.ts

@@ -64,6 +64,7 @@ export interface CocoindexDeps {
 const COCOINDEX_STATE_DIR = ".cocoindex";
 const DEFAULT_PIPELINE_DIR = ".unipi/cocoindex";
 const DEFAULT_LANCEDB_PATH = ".unipi/cocoindex/.lancedb";
+const DEFAULT_UPDATE_TIMEOUT_MS = 15 * 60 * 1000;
 const DEFAULT_LEXICAL_SCAN_LIMIT = 50_000;
 
 // ─────────────────────────────────────────────────────────
@@ -268,11 +269,22 @@ export async function indexProject(projectDir: string): Promise<IndexResult> {
     const proc = spawn(cocoindexBin, ["update", "main.py"], {
       cwd: pipelineDir,
       stdio: ["pipe", "pipe", "pipe"],
-      timeout: 300000, // 5 min timeout
     });
 
     let stdout = "";
     let stderr = "";
+    let timedOut = false;
+    let settled = false;
+    const timeoutMs = getUpdateTimeoutMs();
+
+    const timer = setTimeout(() => {
+      timedOut = true;
+      proc.kill("SIGTERM");
+      setTimeout(() => {
+        if (!settled) proc.kill("SIGKILL");
+      }, 5000).unref();
+    }, timeoutMs);
+    timer.unref();
 
     proc.stdout.on("data", (data: Buffer) => {
       stdout += data.toString();
@@ -282,7 +294,9 @@ export async function indexProject(projectDir: string): Promise<IndexResult> {
       stderr += data.toString();
     });
 
-    proc.on("close", (code: number | null) => {
+    proc.on("close", (code: number | null, signal: NodeJS.Signals | null) => {
+      settled = true;
+      clearTimeout(timer);
       const durationMs = Date.now() - start;
       const chunksProcessed = parseChunksProcessed(stdout);
 
@@ -293,12 +307,14 @@ export async function indexProject(projectDir: string): Promise<IndexResult> {
           success: false,
           chunksProcessed,
           durationMs,
-          error: stderr.trim() || `Process exited with code ${code}`,
+          error: formatIndexFailure({ code, signal, timedOut, timeoutMs, stdout, stderr }),
         });
       }
     });
 
     proc.on("error", (err: Error) => {
+      settled = true;
+      clearTimeout(timer);
       resolve({
         success: false,
         chunksProcessed: 0,
@@ -310,6 +326,46 @@ export async function indexProject(projectDir: string): Promise<IndexResult> {
 }
 
 /** Parse the number of files processed from cocoindex v1.0+ output. */
+function getUpdateTimeoutMs(): number {
+  const raw = process.env.COCOINDEX_UPDATE_TIMEOUT_MS;
+  if (!raw) return DEFAULT_UPDATE_TIMEOUT_MS;
+
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed <= 0) return DEFAULT_UPDATE_TIMEOUT_MS;
+  return parsed;
+}
+
+function formatIndexFailure(args: {
+  code: number | null;
+  signal: NodeJS.Signals | null;
+  timedOut: boolean;
+  timeoutMs: number;
+  stdout: string;
+  stderr: string;
+}): string {
+  const parts: string[] = [];
+
+  if (args.timedOut) {
+    parts.push(`Timed out after ${(args.timeoutMs / 1000).toFixed(0)}s`);
+  } else if (args.signal) {
+    parts.push(`Process terminated by ${args.signal}`);
+  } else {
+    parts.push(`Process exited with code ${args.code ?? "unknown"}`);
+  }
+
+  const stderr = tailText(args.stderr.trim(), 4000);
+  const stdout = tailText(args.stdout.trim(), 2000);
+  if (stderr) parts.push(`stderr:\n${stderr}`);
+  if (stdout) parts.push(`stdout:\n${stdout}`);
+
+  return parts.join("\n\n");
+}
+
+function tailText(text: string, maxChars: number): string {
+  if (text.length <= maxChars) return text;
+  return `…${text.slice(-maxChars)}`;
+}
+
 function parseChunksProcessed(output: string): number {
   // v1.0+ format: "✅ process_file: 604 total | 604 added"
   // Capture the last "added" or "reprocessed" count for process_file
@@ -321,9 +377,14 @@ function parseChunksProcessed(output: string): number {
     }
   }
   if (lastProcessLine) {
-    // Match the number before "added" or "reprocessed"
-    const match = lastProcessLine.match(/(\d+)\s+(?:added|reprocessed)/);
-    if (match) return parseInt(match[1], 10);
+    // Prefer completed work counts. Lines can contain multiple counters, e.g.
+    // "process_file: 615 total | 8 added, 606 reprocessed".
+    const matches = [...lastProcessLine.matchAll(/(\d+)\s+(?:added|reprocessed|skipped|deleted)/g)];
+    const completed = matches.reduce((sum, match) => sum + parseInt(match[1], 10), 0);
+    if (completed > 0) return completed;
+
+    const total = lastProcessLine.match(/process_file:\s*(\d+)\s+total/);
+    if (total) return parseInt(total[1], 10);
   }
 
   // Fallback: old format "Processed 42 chunks"
@@ -634,6 +695,8 @@ import os
 
 # ── Configuration ────────────────────────────────────
 PROJECT_ROOT = os.environ.get("PROJECT_ROOT", "${projectDir}")
+# Safety limit for huge generated/lock files. Set COCO_MAX_FILE_CHARS=0 to disable.
+MAX_FILE_CHARS = int(os.environ.get("COCO_MAX_FILE_CHARS", "200000"))
 
 # ── LanceDB context key ──────────────────────────────
 db_key = coco.ContextKey("lancedb/${projectBasename}")
@@ -703,6 +766,8 @@ async def process_file(
 
     if not content.strip():
         return
+    if MAX_FILE_CHARS > 0 and len(content) > MAX_FILE_CHARS:
+        return
 
     relative = file.file_path.path.as_posix()
     chunks = await chunk_text(content)
@@ -750,7 +815,10 @@ async def app_main() -> None:
             excluded_patterns=[
                 "**/node_modules/**", "**/.git/**", "**/dist/**",
                 "**/build/**", "**/.next/**", "**/__pycache__/**",
-                "**/.unipi/cocoindex/**",
+                "**/coverage/**", "**/.turbo/**", "**/.cache/**",
+                "**/.unipi/**",
+                "**/*.min.js", "**/bundled.js", "**/bundle.js", "**/*bundle*.js",
+                "**/package-lock.json", "**/pnpm-lock.yaml", "**/yarn.lock",
             ],
         ),
     )

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",