@pi-unipi/unipi 0.1.17 → 2.0.0

package/README.md

@@ -9,39 +9,39 @@ pi install npm:@pi-unipi/unipi
 
 ## What You Get
 
-**Workflow** — 20 commands that take ideas to shipped code. Brainstorm, plan, execute in worktrees, review, consolidate. The agent follows skill files step by step.
+**[Workflow](./packages/workflow/README.md)** — 20 commands that take ideas to shipped code. Brainstorm, plan, execute in worktrees, review, consolidate. The agent follows skill files step by step.
 
-**Ralph** — Long-running loops that persist across sessions. Start a task, iterate through checklist items, resume after crashes. Progress tracked, state saved.
+**[Ralph](./packages/ralph/README.md)** — Long-running loops that persist across sessions. Start a task, iterate through checklist items, resume after crashes. Progress tracked, state saved.
 
-**Memory** — SQLite + vector search stores facts, preferences, and decisions. Project-scoped and global. The agent remembers what you told it last week.
+**[Memory](./packages/memory/README.md)** — SQLite + vector search stores facts, preferences, and decisions. Project-scoped and global. The agent remembers what you told it last week.
 
-**Compactor** — Zero-LLM context engine. 6-stage pipeline hits 95%+ token reduction at zero API cost. Session continuity, sandbox execution, FTS5 search.
+**[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.
 
-**Subagents** — Parallel execution with file locking. Spawn background agents to research, fix, or build while the main agent keeps going.
+**[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** — Web search, page reading, content summarization. Smart-fetch engine with browser-grade TLS fingerprinting — free, no API key. Paid providers as fallbacks.
+**[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.
 
-**MCP** — Browse 7,800+ MCP servers, add them interactively. Tools from servers register automatically as Pi tools.
+**[MCP](./packages/mcp/README.md)** — Browse 7,800+ MCP servers, add them interactively. Tools from servers register automatically as Pi tools.
 
-**Notify** — Push notifications to native OS, Gotify, Telegram, or ntfy. Per-event platform routing. Configure once, get alerts everywhere.
+**[Notify](./packages/notify/README.md)** — Push notifications to native OS, Gotify, Telegram, or ntfy. Per-event platform routing. Configure once, get alerts everywhere.
 
-**Footer** — Persistent status bar showing live stats from every package. Responsive layout, presets, per-segment toggling.
+**[Footer](./packages/footer/README.md)** — Persistent status bar showing live stats from every package. Responsive layout, presets, per-segment toggling.
 
-**BTW** — Side conversations that run in parallel. Ask questions without interrupting the main agent.
+**[BTW](./packages/btw/README.md)** — Side conversations that run in parallel. Ask questions without interrupting the main agent.
 
-**Ask User** — Structured input for decision gates. Single-select, multi-select, freeform. The agent asks instead of guessing.
+**[Ask User](./packages/ask-user/README.md)** — Structured input for decision gates. Single-select, multi-select, freeform. The agent asks instead of guessing.
 
-**Milestone** — Track project goals across workflow cycles. MILESTONES.md stays in sync with specs, plans, and completed work.
+**[Milestone](./packages/milestone/README.md)** — Track project goals across workflow cycles. MILESTONES.md stays in sync with specs, plans, and completed work.
 
-**Kanboard** — Web UI and TUI overlay for kanban boards. Parses all workflow documents into cards with progress indicators.
+**[Kanboard](./packages/kanboard/README.md)** — Web UI and TUI overlay for kanban boards. Parses all workflow documents into cards with progress indicators.
 
-**Info Screen** — Dashboard overlay showing module status, tools, and custom data groups.
+**[Info Screen](./packages/info-screen/README.md)** — Dashboard overlay showing module status, tools, and custom data groups.
 
-**Utility** — Environment info, diagnostics, cleanup, name badge, and Shiki-powered diff rendering.
+**[Utility](./packages/utility/README.md)** — Environment info, diagnostics, cleanup, name badge, and Shiki-powered diff rendering.
 
-**Updater** — Checks npm for new versions on session start. Changelog browser and readme browser in TUI overlays.
+**[Updater](./packages/updater/README.md)** — Checks npm for new versions on session start. Changelog browser and readme browser in TUI overlays.
 
-**Input Shortcuts** — Keyboard shortcuts via vim-style chord overlay. Stash/restore, undo/redo, clipboard, thinking toggle.
+**[Input Shortcuts](./packages/input-shortcuts/README.md)** — Keyboard shortcuts via vim-style chord overlay. Stash/restore, undo/redo, clipboard, thinking toggle.
 
 ## Architecture
 
@@ -77,7 +77,7 @@ 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:compact` | compact, stats, settings, preset |
+| Compactor | `/unipi:` | lossless-compact, compact-stats, compact-settings, compact-preset, session-recall, content-index, content-search |
 | Notify | `/unipi:notify-` | settings, test, set-tg, set-ntfy |
 | MCP | `/unipi:mcp-` | add, settings, sync, status |
 | Web | `/unipi:web-` | settings, cache-clear |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/unipi",
-  "version": "0.1.17",
+  "version": "2.0.0",
   "description": "All-in-one extension suite for Pi coding agent",
   "type": "module",
   "license": "MIT",
@@ -55,7 +55,8 @@
       "node_modules/@pi-unipi/command-enchantment/src/index.ts",
       "node_modules/@pi-unipi/footer/src/index.ts",
       "node_modules/@pi-unipi/updater/src/index.ts",
-      "node_modules/@pi-unipi/input-shortcuts/src/index.ts"
+      "node_modules/@pi-unipi/input-shortcuts/src/index.ts",
+      "node_modules/@pi-unipi/cocoindex/index.ts"
     ],
     "skills": [
       "node_modules/@pi-unipi/workflow/skills",
@@ -69,7 +70,8 @@
       "node_modules/@pi-unipi/notify/skills",
       "node_modules/@pi-unipi/milestone/skills",
       "node_modules/@pi-unipi/kanboard/skills",
-      "node_modules/@pi-unipi/updater/skills"
+      "node_modules/@pi-unipi/updater/skills",
+      "node_modules/@pi-unipi/cocoindex/skills"
     ]
   },
   "peerDependencies": {
@@ -97,7 +99,8 @@
     "@pi-unipi/workflow": "*",
     "@pi-unipi/footer": "*",
     "@pi-unipi/updater": "*",
-    "@pi-unipi/input-shortcuts": "*"
+    "@pi-unipi/input-shortcuts": "*",
+    "@pi-unipi/cocoindex": "*"
   },
   "devDependencies": {
     "@types/node": "^25.6.0",

package/packages/ask-user/README.md

@@ -12,6 +12,8 @@ Ask-user has no user commands. It's an agent tool package — the agent calls it
 
 All workflow skills detect ask-user and use it for decision gates. Instead of the agent deciding on its own, it presents options and waits for your input. This happens naturally during brainstorm, plan, work, and other skills when the agent faces ambiguity.
 
+For workflow handoffs, options can use `action: "new_session"` with a `prefill`. Selecting one opens a launcher where **Compact & run** queues the prefill after compaction (or a short fallback) and **Run directly** queues it immediately. If automatic queuing fails, the prefill is placed in the editor for you to submit manually.
+
 The bundled skill guides the agent to use `ask_user` for high-stakes decisions — architecture choices, database selection, naming decisions, anything with lasting impact.
 
 ## Agent Tool
@@ -43,6 +45,34 @@ ask_user({
 })
 ```
 
+### `new_session` Handoffs
+
+```typescript
+ask_user({
+  question: "Continue with implementation?",
+  options: [
+    {
+      label: "Proceed to work",
+      value: "work",
+      action: "new_session",
+      prefill: "/unipi:work specs:2026-05-06-feature-plan.md",
+    },
+    { label: "Done for now", value: "done", action: "end_turn" },
+  ],
+  allowFreeform: false,
+})
+```
+
+When the user chooses a `new_session` option:
+
+| Launcher choice | Behavior |
+|-----------------|----------|
+| 🧹 Compact & run | Starts context compaction, returns immediately, then queues/submits the prefill as a follow-up message from the compaction callback or a short fallback timer |
+| ▶ Run directly | Queues/submits the prefill immediately as a follow-up message |
+| ✕ Cancel | Cancels the handoff; no message is queued |
+
+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.
+
 ### Keyboard Controls
 
 | Mode | Keys |

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

@@ -5,7 +5,8 @@
  * Uses ctx.ui.custom() callback pattern following question.ts/questionnaire.ts.
  */
 
-import { Editor, type EditorTheme, Key, matchesKey, Text, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@mariozechner/pi-tui";
+import { Editor, type EditorTheme, Key, matchesKey, Text, truncateToWidth, type TUI, visibleWidth, wrapTextWithAnsi } from "@mariozechner/pi-tui";
+import type { Theme, AgentToolResult } from "@mariozechner/pi-coding-agent";
 import type { NormalizedOption, AskUserResponse } from "./types.js";
 
 /** Result returned by the ask UI */
@@ -31,9 +32,9 @@ export function renderAskUI(params: {
   allowFreeform: boolean;
   timeout?: number;
 }): (
-  tui: any,
-  theme: any,
-  kb: any,
+  tui: TUI,
+  theme: Theme,
+  kb: import("@mariozechner/pi-coding-agent").KeybindingsManager,
   done: (result: AskUIResult | null) => void,
 ) => {
   render: (width: number) => string[];
@@ -446,7 +447,7 @@ export function renderAskUI(params: {
     function renderOptions(
       lines: string[],
       add: (s: string) => void,
-      theme: any,
+      theme: Theme,
       width: number,
     ) {
       for (let i = 0; i < displayOptions.length; i++) {
@@ -561,8 +562,8 @@ export function renderAskUI(params: {
  * Create a renderCall function for the ask_user tool.
  */
 export function createRenderCall() {
-  return (args: any, theme: any, _context: any) => {
-    const question = args.question || "";
+  return (args: Record<string, unknown>, theme: Theme, _context: unknown) => {
+    const question = (args.question as string) || "";
     const options = Array.isArray(args.options) ? args.options : [];
     const mode = args.allowMultiple ? "multi-select" : "single-select";
     const count = options.length;
@@ -581,14 +582,15 @@ export function createRenderCall() {
  * Create a renderResult function for the ask_user tool.
  */
 export function createRenderResult() {
-  return (result: any, _options: any, theme: any, _context: any) => {
-    const details = result.details;
+  return (result: AgentToolResult<unknown>, _options: unknown, theme: Theme, _context: unknown) => {
+    const details = result.details as Record<string, unknown> | undefined;
     if (!details) {
-      const text = result.content?.[0];
-      return new Text(text?.type === "text" ? text.text : "", 0, 0);
+      const content = result.content as unknown as Array<Record<string, unknown>> | undefined;
+      const text = content?.[0];
+      return new Text(text?.type === "text" ? (text.text as string) : "", 0, 0);
     }
 
-    const response = details.response as AskUserResponse;
+    const response = (details as { response: AskUserResponse }).response;
     if (!response) {
       return new Text(theme.fg("warning", "No response"), 0, 0);
     }
@@ -638,14 +640,52 @@ export function createRenderResult() {
           0,
           0,
         );
-      case "new_session":
+      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,
+          );
+        }
+        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", "✓ ") +
             theme.fg("muted", "new session") +
-            (response.prefill ? theme.fg("accent", `: ${response.prefill}`) : ""),
+            (prefill ? theme.fg("accent", `: ${prefill}`) : ""),
           0,
           0,
         );
+      }
       default:
         return new Text(
           theme.fg("text", JSON.stringify(response)),

package/packages/ask-user/commands.ts

@@ -23,7 +23,7 @@ export function registerAskUserCommands(pi: ExtensionAPI): void {
       }
 
       ctx.ui.custom(
-        (tui: any, _theme: any, _keybindings: any, done: any) => {
+        (tui, _theme, _keybindings, done) => {
           const overlay = new AskUserSettingsOverlay();
           overlay.onClose = () => done(undefined);
           return {

package/packages/ask-user/handoff.ts

@@ -0,0 +1,163 @@
+/**
+ * @pi-unipi/ask-user — new_session handoff helpers
+ *
+ * Queues launcher prefill messages without waiting for LLM follow-up.
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { SessionLaunchReason, SessionLaunchStatus } from "./types.js";
+
+/** Compact handoff fallback timer. Keeps the launcher from stalling if callbacks wait for the tool turn to finish. */
+export const COMPACT_HANDOFF_FALLBACK_MS = 1500;
+
+export interface HandoffResult {
+  status: SessionLaunchStatus;
+  reason: SessionLaunchReason;
+  prefill?: string;
+  error?: string;
+}
+
+interface NormalizedPrefill {
+  ok: true;
+  prefill: string;
+} 
+
+interface InvalidPrefill {
+  ok: false;
+  reason: "empty-prefill";
+}
+
+function normalizePrefill(prefill: string | undefined): NormalizedPrefill | InvalidPrefill {
+  const trimmed = (prefill ?? "").trim();
+  if (!trimmed) {
+    return { ok: false, reason: "empty-prefill" };
+  }
+  return { ok: true, prefill: trimmed };
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function notify(ctx: ExtensionContext, message: string, level: "info" | "warning" | "error"): void {
+  try {
+    ctx.ui.notify(message, level);
+  } catch {
+    // Notifications are best-effort only; never let status UI break delivery.
+  }
+}
+
+function fallbackToEditor(
+  ctx: ExtensionContext,
+  prefill: string,
+  reason: SessionLaunchReason,
+  error: unknown,
+): HandoffResult {
+  try {
+    ctx.ui.setEditorText(prefill);
+    notify(ctx, "Automatic handoff failed. The command was placed in the editor; press Enter to run it.", "warning");
+    return {
+      status: "editor_prefill",
+      reason,
+      prefill,
+      error: errorMessage(error),
+    };
+  } catch (editorError) {
+    notify(ctx, `Automatic handoff failed and editor fallback failed: ${errorMessage(editorError)}`, "error");
+    return {
+      status: "failed",
+      reason,
+      prefill,
+      error: `${errorMessage(error)}; editor fallback: ${errorMessage(editorError)}`,
+    };
+  }
+}
+
+function deliverFollowUpMessage(
+  pi: ExtensionAPI,
+  ctx: ExtensionContext,
+  prefill: string,
+  reason: SessionLaunchReason,
+): HandoffResult {
+  try {
+    pi.sendUserMessage(prefill, { deliverAs: "followUp" });
+    return { status: "queued", reason, prefill };
+  } catch (error) {
+    return fallbackToEditor(ctx, prefill, reason, error);
+  }
+}
+
+export function queueDirectHandoff(
+  pi: ExtensionAPI,
+  ctx: ExtensionContext,
+  prefill: string | undefined,
+): HandoffResult {
+  const normalized = normalizePrefill(prefill);
+  if (!normalized.ok) {
+    return { status: "cancelled", reason: normalized.reason };
+  }
+
+  return deliverFollowUpMessage(pi, ctx, normalized.prefill, "direct");
+}
+
+export function queueCompactHandoff(params: {
+  pi: ExtensionAPI;
+  ctx: ExtensionContext;
+  prefill: string | undefined;
+  customInstructions: string;
+}): HandoffResult {
+  const { pi, ctx, customInstructions } = params;
+  const normalized = normalizePrefill(params.prefill);
+  if (!normalized.ok) {
+    return { status: "cancelled", reason: normalized.reason };
+  }
+
+  const { prefill } = normalized;
+  let delivered = false;
+  let fallbackTimer: ReturnType<typeof setTimeout> | undefined;
+
+  const clearFallbackTimer = () => {
+    if (fallbackTimer) {
+      clearTimeout(fallbackTimer);
+      fallbackTimer = undefined;
+    }
+  };
+
+  const deliverOnce = (reason: SessionLaunchReason): HandoffResult | undefined => {
+    if (delivered) {
+      return undefined;
+    }
+    delivered = true;
+    clearFallbackTimer();
+    if (reason === "fallback-timeout") {
+      notify(ctx, "Compaction is still running; queued the selected handoff command via fallback.", "info");
+    }
+    return deliverFollowUpMessage(pi, ctx, prefill, reason);
+  };
+
+  fallbackTimer = setTimeout(() => {
+    deliverOnce("fallback-timeout");
+  }, COMPACT_HANDOFF_FALLBACK_MS);
+
+  try {
+    ctx.compact({
+      customInstructions,
+      onComplete: () => {
+        deliverOnce("compacted");
+      },
+      onError: (error) => {
+        notify(ctx, `Compaction reported an error; continuing handoff anyway: ${errorMessage(error)}`, "warning");
+        deliverOnce("compaction-error");
+      },
+    });
+  } catch (error) {
+    notify(ctx, `Could not start compaction; running selected handoff directly: ${errorMessage(error)}`, "warning");
+    return deliverOnce("compact-start-failed") ?? {
+      status: "queued",
+      reason: "compact-start-failed",
+      prefill,
+    };
+  }
+
+  return { status: "scheduled", reason: "compact-started", prefill };
+}

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

@@ -0,0 +1,143 @@
+/**
+ * @pi-unipi/ask-user — Session Launcher TUI
+ *
+ * Secondary overlay shown when user selects a new_session option.
+ * Offers Compact & run, Run directly, or Cancel.
+ */
+
+import { Key, matchesKey, truncateToWidth, type TUI, visibleWidth } from "@mariozechner/pi-tui";
+import type { Theme, KeybindingsManager } from "@mariozechner/pi-coding-agent";
+import type { SessionLauncherResult } from "./types.js";
+
+/** Launcher option definition */
+interface LauncherOption {
+  label: string;
+  icon: string;
+  action: SessionLauncherResult["action"];
+}
+
+const OPTIONS: LauncherOption[] = [
+  { label: "Compact & run", icon: "🧹", action: "compact" },
+  { label: "Run directly", icon: "▶", action: "direct" },
+  { label: "Cancel", icon: "✕", action: "cancel" },
+];
+
+/**
+ * Render the session launcher UI.
+ *
+ * Simple single-select picker with 3 fixed options.
+ * No editor, no timeout, no multi-select.
+ */
+export function renderLauncherUI(params: {
+  prefill: string;
+}): (
+  tui: TUI,
+  theme: Theme,
+  kb: KeybindingsManager,
+  done: (result: SessionLauncherResult | null) => void,
+) => {
+  render: (width: number) => string[];
+  invalidate: () => void;
+  handleInput: (data: string) => void;
+} {
+  return (_tui, theme, _kb, done) => {
+    const { prefill } = params;
+
+    // State
+    let optionIndex = 0;
+    let cachedLines: string[] | undefined;
+
+    function refresh() {
+      cachedLines = undefined;
+      _tui.requestRender();
+    }
+
+    function handleInput(data: string) {
+      // Navigation
+      if (matchesKey(data, Key.up)) {
+        optionIndex = Math.max(0, optionIndex - 1);
+        refresh();
+        return;
+      }
+      if (matchesKey(data, Key.down)) {
+        optionIndex = Math.min(OPTIONS.length - 1, optionIndex + 1);
+        refresh();
+        return;
+      }
+
+      // Enter: select
+      if (matchesKey(data, Key.enter)) {
+        const opt = OPTIONS[optionIndex];
+        done({ action: opt.action, prefill });
+        return;
+      }
+
+      // Escape: cancel
+      if (matchesKey(data, Key.escape)) {
+        done(null);
+        return;
+      }
+    }
+
+    function render(width: number): string[] {
+      if (cachedLines) return cachedLines;
+
+      const lines: string[] = [];
+      const innerWidth = Math.max(40, width - 2);
+      const border = (s: string) => theme.fg("accent", s);
+
+      function padVisible(content: string, targetWidth: number): string {
+        const vw = visibleWidth(content);
+        const pad = Math.max(0, targetWidth - vw);
+        return content + " ".repeat(pad);
+      }
+
+      const add = (s: string) =>
+        lines.push(
+          border("│") +
+            padVisible(truncateToWidth(s, innerWidth), innerWidth) +
+            border("│"),
+        );
+      const addEmpty = () =>
+        lines.push(border("│") + " ".repeat(innerWidth) + border("│"));
+
+      // Top border
+      lines.push(border(`╭${"─".repeat(innerWidth)}╮`));
+
+      // Header: show prefill command (truncated)
+      const headerPrefix = " 🚀 ";
+      const maxPrefillWidth = innerWidth - headerPrefix.length - 1;
+      const truncatedPrefill = truncateToWidth(prefill || "(no command)", maxPrefillWidth);
+      add(theme.fg("accent", headerPrefix) + theme.fg("text", truncatedPrefill));
+      addEmpty();
+
+      // Options
+      for (let i = 0; i < OPTIONS.length; i++) {
+        const opt = OPTIONS[i];
+        const isSelected = i === optionIndex;
+        const prefix = isSelected ? theme.fg("accent", "> ") : "  ";
+        const label = `${opt.icon} ${opt.label}`;
+        const color = isSelected ? "accent" : "text";
+        add(prefix + theme.fg(color, label));
+      }
+
+      // Footer hint
+      addEmpty();
+      add(theme.fg("dim", " ↑↓ navigate • Enter select • Esc cancel"));
+
+      // Bottom border
+      lines.push(border(`╰${"─".repeat(innerWidth)}╯`));
+
+      cachedLines = lines;
+      return lines;
+    }
+
+    return {
+      render,
+      invalidate: () => {
+        cachedLines = undefined;
+      },
+      handleInput,
+    };
+  };
+}

package/packages/ask-user/skills/ask-user/SKILL.md

@@ -56,7 +56,7 @@ Use the `ask_user` tool to collect structured input from the user.
 | `"select"` | Normal selection (default). Returns immediately. |
 | `"input"` | Enters text input mode. Returns `combined` response with selection + text. |
 | `"end_turn"` | Signals end of agent turn. Returns `end_turn` response kind. |
-| `"new_session"` | Starts a new session. Returns `new_session` response kind with optional `prefill`. |
+| `"new_session"` | Starts a handoff. Returns `new_session` response kind with optional `prefill`. Shows a launcher overlay offering **Compact & run** (compact first, then queue/submit the prefill) or **Run directly** (queue/submit immediately). The current LLM follow-up is aborted after a successful queue or editor fallback. |
 
 ## Examples
 
@@ -149,4 +149,16 @@ ask_user({
 - "Looks good" returns immediately with selection
 - "I want changes" enters text input mode for the user to explain
 - "Done for now" signals the agent to end its turn
-- "Start fresh" starts a new session with the prefill message
+- "Start fresh" opens the launcher; **Compact & run** or **Run directly** queues the prefill message automatically
+
+## Session Launcher
+
+When a user selects a `new_session` option, a secondary launcher overlay appears with three choices:
+
+| Choice | Behavior |
+|--------|----------|
+| 🧹 Compact & run | Starts `ctx.compact()` without waiting in the tool spinner, then queues/submits the prefill as a follow-up message after compaction or a short fallback timer |
+| ▶ Run directly | Queues/submits the prefill immediately as a follow-up message, without compaction |
+| ✕ Cancel | Cancels the session launch; no prefill is queued |
+
+The prefill can be a slash command (for example `/unipi:work specs:...`) or any non-empty message. If automatic delivery fails, ask_user places the prefill in the editor and warns the user to press Enter. This two-step flow lets the user manage context window usage before starting a new task while avoiding unnecessary LLM follow-up in the old session.