@pi-unipi/unipi 2.0.1 → 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.1",
+  "version": "2.0.2",
   "description": "All-in-one extension suite for Pi coding agent",
   "type": "module",
   "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",