feat: ClawTap v0.2.0

Interactive Prompts:
- Unified InteractivePrompt type across all 3 adapters (Claude/Codex/Gemini)
- InteractivePromptOverlay component with options, text input, countdown
- Gemini + Codex pane monitors detect tool confirmation, ask user, plan approval
- respondInteractivePrompt routing: permission → respondPermission, options → _selectOption
- Claude AskUserQuestion nested questions[0] structure parsing

Cross-AI Review:
- Client-generated reviewId, removed pendingReview state
- FloatingReviewPanel uses CSS display:none instead of unmount (keeps hooks alive)
- Child review sessions default to YOLO/bypass permission mode
- Send back to parent, send to existing/new review, tab switching, end review
- Collapsed review cards with read-only panel for ended reviews
- Full reconnect support: active + ended reviews restore correctly

AskUserQuestion Tool Card UI:
- Dedicated renderer replaces raw JSON display
- Options shown with selected (green) / unselected (gray) indicators
- Free text answers shown in quoted format with green border
- Collapsed summary: question → answer
- Shared parseAskQuestionInput utility (client + server)
- Historical tool results attached via _result on tool_use blocks

Adapter Fixes:
- Session→adapter mapping persisted in SQLite (survives server restart)
- SESSION_CREATED deferred for pendingRekey adapters (Codex/Gemini)
- session-rekeyed handler sends complete SESSION_CREATED with adapter + cwd
- Gemini: auto-accept folder trust, privacy notice, IDE nudge, YOLO * prompt
- Claude: auto-accept bypass permissions confirmation (v2.1.85+)
- Port fallback (EADDRINUSE → try +1), statusLine shell script wrapper

Other:
- Desktop Enter sends / Shift+Enter newline; Mobile Enter newline
- Strip CLAWTAP_REF marker from session list
- Active sessions tab shows adapter badge
- Rename CLAUDE_UI_PASSWORD → CLAWTAP_PASSWORD

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

server/adapters/gemini/gemini-tmux-adapter.ts

@@ -19,6 +19,7 @@ import type { ReconnectState } from '../../types/adapter.js';
 import type { ActiveSessionInfo } from '../interface.js';
 import { isLargeContent } from '../interface.js';
 import { PermissionManager } from '../../permission-manager.js';
+import { findActiveSession } from '../shared/find-active-session.js';
 import { readFile } from 'fs/promises';
 
 // ---------------------------------------------------------------------------
@@ -116,12 +117,13 @@ export class GeminiTmuxAdapter extends EventEmitter {
 
   // === Session Lifecycle ===
 
-  async startSession(cwd: string, options: QueryOptions = {}): Promise<{ sessionId: string }> {
+  async startSession(cwd: string, options: QueryOptions = {}): Promise<{ sessionId: string; pendingRekey?: boolean }> {
     const mode = options.permissionMode || 'default';
     const parts = ['gemini', '--approval-mode', this._toCliApprovalMode(mode)];
     if (options.model) parts.push('-m', options.model);
 
     const tempName = `gemini-${Date.now()}`;
+    console.log(`[gemini-tmux] startSession: tempName=${tempName} cwd=${cwd} mode=${mode}`);
     const windowId = await tmuxManager.createWindow(tempName, cwd, parts.join(' '));
 
     // Register session BEFORE _waitForReady — SessionStart hook fires during
@@ -137,14 +139,16 @@ export class GeminiTmuxAdapter extends EventEmitter {
       const rekeyed = [...this.sessions.entries()].find(([, s]) => s.windowId === windowId)?.[0];
       if (rekeyed) {
         finalId = rekeyed;
+        console.log(`[gemini-tmux] startSession: rekeyed ${tempName} → ${rekeyed}`);
       } else {
         console.warn(`[gemini-tmux] Session ${tempName} vanished during startup (windowId=${windowId})`);
       }
     }
 
+    console.log(`[gemini-tmux] startSession: finalId=${finalId} pendingRekey=${finalId === tempName}`);
     this._startMonitor(finalId, windowId);
 
-    return { sessionId: finalId };
+    return { sessionId: finalId, pendingRekey: finalId === tempName };
   }
 
   async resumeSession(sessionId: string, cwd: string, options: QueryOptions = {}): Promise<{ sessionId: string }> {
@@ -581,6 +585,27 @@ export class GeminiTmuxAdapter extends EventEmitter {
     await tmuxManager.sendKeys(session.windowId, answer, true);
   }
 
+  respondInteractivePrompt(requestId: string, selectedOption?: string, textValue?: string): void {
+    const pending = this._permissions.resolvePermission(requestId)
+      || this._permissions.resolveQuestion(requestId);
+    // For pane-monitor-detected prompts, there may be no pending entry — find session from active sessions
+    const sessionId = pending?.sessionId || findActiveSession(this.sessions);
+    if (!sessionId) return;
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+
+    if (selectedOption != null) {
+      const index = parseInt(selectedOption);
+      if (!isNaN(index)) {
+        // Gemini numbered options: navigate Down × index, then Enter
+        this._selectNumberedOption(session.windowId, index).catch(() => {});
+      }
+    }
+    if (textValue != null) {
+      tmuxManager.sendKeys(session.windowId, textValue, true).catch(() => {});
+    }
+  }
+
   /** Release all pending requests for a session */
   releaseAllPending(sessionId: string): void {
     this._permissions.dismissAll(sessionId);
@@ -598,6 +623,14 @@ export class GeminiTmuxAdapter extends EventEmitter {
     }
   }
 
+  private async _selectNumberedOption(windowId: string, targetIndex: number): Promise<void> {
+    for (let i = 0; i < targetIndex; i++) {
+      await tmuxManager.sendControl(windowId, 'Down');
+      await new Promise<void>(r => setTimeout(r, 50));
+    }
+    await tmuxManager.sendControl(windowId, 'Enter');
+  }
+
   // === Cleanup ===
 
   async destroy(): Promise<void> {
@@ -662,7 +695,7 @@ export class GeminiTmuxAdapter extends EventEmitter {
    * Wait for Gemini CLI to be ready.
    * Polls tmux pane content until a prompt indicator appears.
    */
-  private async _waitForReady(windowId: string, timeoutMs: number = 30000): Promise<void> {
+  private async _waitForReady(windowId: string, timeoutMs: number = 60000): Promise<void> {
     const start = Date.now();
     let attempt = 0;
     while (Date.now() - start < timeoutMs) {
@@ -670,17 +703,69 @@ export class GeminiTmuxAdapter extends EventEmitter {
       try {
         const content = await tmuxManager.capturePane(windowId);
         const lines = content.split('\n');
-        // Gemini shows > or similar prompt indicator
-        const hasPrompt = lines.some(l => /^\s*[>❯]/.test(l));
-        const lineCount = lines.filter(l => l.trim()).length;
-        if (attempt <= 3 || attempt % 5 === 0) {
-          console.log(`[gemini-tmux] waitForReady #${attempt}: window=${windowId} prompt=${hasPrompt} lines=${lineCount}`);
-        }
-        if (hasPrompt && lineCount >= 2) {
+        // Gemini shows > (default), * (yolo), or ❯ as prompt indicator
+        const hasPrompt = lines.some(l => /^\s*[>*❯]/.test(l));
+
+        if (hasPrompt) {
           console.log(`[gemini-tmux] CLI ready for ${windowId} in ${Date.now() - start}ms`);
           await new Promise<void>(r => setTimeout(r, 300));
           return;
         }
+
+        // Privacy Notice or Terms of Service popup — dismiss with Esc
+        if (!hasPrompt && (content.includes('Privacy Notice') ||
+            (content.includes('Terms of Service') && !content.includes('trust the files')))) {
+          console.log('[gemini-tmux] Privacy/ToS notice detected, dismissing');
+          await tmuxManager.sendControl(windowId, 'Escape');
+          await new Promise<void>(r => setTimeout(r, 500));
+          continue;
+        }
+
+        // Multi-folder trust dialog ("trust the following folders")
+        if (!hasPrompt && content.includes('trust the following folders')) {
+          console.log('[gemini-tmux] Multi-folder trust detected, accepting');
+          await tmuxManager.sendControl(windowId, 'Enter');
+          await new Promise<void>(r => setTimeout(r, 1000));
+          continue;
+        }
+
+        // IDE integration nudge — decline
+        if (!hasPrompt && content.includes('Do you want to connect') && content.includes('Gemini CLI')) {
+          console.log('[gemini-tmux] IDE nudge detected, declining');
+          await tmuxManager.sendControl(windowId, 'Down');
+          await new Promise<void>(r => setTimeout(r, 50));
+          await tmuxManager.sendControl(windowId, 'Enter');
+          await new Promise<void>(r => setTimeout(r, 500));
+          continue;
+        }
+
+        // Auto-accept folder trust prompt (Gemini asks on first use in a directory).
+        // Only runs when prompt is NOT yet visible.
+        if (content.includes('trust the files') && content.includes('Trust folder')) {
+          const parentMatch = content.match(/(\d+)\.\s+Trust parent folder/);
+          if (parentMatch) {
+            const targetOption = parseInt(parentMatch[1]);
+            console.log(`[gemini-tmux] Folder trust prompt detected, selecting option ${targetOption} (Trust parent folder)`);
+            for (let i = 1; i < targetOption; i++) {
+              await tmuxManager.sendControl(windowId, 'Down');
+              await new Promise<void>(r => setTimeout(r, 50));
+            }
+          } else {
+            console.log(`[gemini-tmux] Folder trust prompt detected, accepting default (Trust folder)`);
+          }
+          await tmuxManager.sendControl(windowId, 'Enter');
+          await new Promise<void>(r => setTimeout(r, 1000));
+          continue;
+        }
+
+        if (attempt <= 3 || attempt % 5 === 0) {
+          const lineCount = lines.filter(l => l.trim()).length;
+          console.log(`[gemini-tmux] waitForReady #${attempt}: window=${windowId} prompt=${hasPrompt} lines=${lineCount}`);
+          if (lineCount > 0) {
+            const nonEmpty = lines.filter(l => l.trim());
+            console.log(`[gemini-tmux] waitForReady content: first="${nonEmpty[0]?.substring(0, 60)}" last="${nonEmpty[nonEmpty.length - 1]?.substring(0, 60)}"`);
+          }
+        }
       } catch (err) {
         console.log(`[gemini-tmux] waitForReady #${attempt}: ERROR ${(err as Error).message}`);
       }

server/adapters/gemini/index.ts

@@ -73,10 +73,10 @@ export class GeminiAdapter extends IAdapter {
   }
 
   setup(app: Express): void {
-    this.installHooks();
     this._registerHookRoutes(app);
   }
 
+  setHookPort(port: number | string): void { this._hookConfig.port = port; }
   installHooks(): void { this._hookConfig.install(); }
   uninstallHooks(): void { this._hookConfig.uninstall(); }
 
@@ -167,6 +167,7 @@ export class GeminiAdapter extends IAdapter {
   async switchPermissionMode(sid: string, mode: string): Promise<boolean> { return this._tmux.switchPermissionMode(sid, mode); }
   respondPermission(reqId: string, behavior: PermissionBehavior): void { this._tmux.respondPermission(reqId, behavior); }
   async respondQuestion(reqId: string, answer: string): Promise<void> { return this._tmux.respondQuestion(reqId, answer); }
+  respondInteractivePrompt(reqId: string, opt?: string, text?: string): void { this._tmux.respondInteractivePrompt(reqId, opt, text); }
   releaseAllPending(sid: string): void { this._tmux.releaseAllPending(sid); }
   resolveAllPendingAs(sid: string, behavior: PermissionBehavior): void { this._tmux.resolveAllPendingAs(sid, behavior); }
 

server/adapters/gemini/json-store.ts

@@ -2,6 +2,7 @@ import { readdirSync, readFileSync, statSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 import { extractUserText } from './message-utils.js';
+import { stripMarker } from '../shared/content-utils.js';
 import type { DirectoryEntry } from '../interface.js';
 import type { SessionInfo } from '../../types/adapter.js';
 
@@ -123,7 +124,7 @@ export function getSessions(dir?: string, limit?: number): SessionInfo[] {
             if (m.type === 'user' && m.content != null) {
               const text = extractUserText(m.content);
               if (text.trim()) {
-                firstPrompt = text.slice(0, 200);
+                firstPrompt = stripMarker(text).slice(0, 200);
                 break;
               }
             }
@@ -223,7 +224,6 @@ export function getSessionMessages(
     const projectName = getProjectName(dir);
     if (projectName) {
       const chatsDir = join(GEMINI_TMP_DIR, projectName, 'chats');
-      // Try exact match first, then scan
       try {
         const files = readdirSync(chatsDir);
         for (const file of files) {
@@ -245,6 +245,8 @@ export function getSessionMessages(
         // chats dir not readable
       }
     }
+    // Fallback: project name mapping failed — scan all projects
+    if (!filePath) filePath = findSessionFile(sessionId);
   } else {
     filePath = findSessionFile(sessionId);
   }

server/adapters/gemini/pane-monitor.ts

@@ -16,6 +16,16 @@
 // that will be refined through empirical testing with the actual Gemini CLI.
 
 import { EventEmitter } from 'events';
+import { InteractivePrompt } from '../../types/messages.js';
+
+function simpleHash(str: string): string {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    hash = ((hash << 5) - hash) + str.charCodeAt(i);
+    hash |= 0;
+  }
+  return Math.abs(hash).toString(36);
+}
 
 /** Minimal interface for the tmux manager dependency */
 interface TmuxCapture {
@@ -44,6 +54,7 @@ export class GeminiPaneMonitor {
   private interval: ReturnType<typeof setInterval> | null = null;
   private _lastContent: string = '';
   private _lastResponseText: string = '';
+  private lastPromptId: string | null = null;
 
   constructor(
     sessionId: string,
@@ -86,6 +97,20 @@ export class GeminiPaneMonitor {
       if (content === this._lastContent) return;
       this._lastContent = content;
 
+      const lines = content.split('\n');
+
+      // 0. Check for interactive prompt (highest priority)
+      const prompt = this._detectPrompt(content, lines);
+      if (prompt) {
+        if (prompt.requestId !== this.lastPromptId) {
+          this.lastPromptId = prompt.requestId;
+          this.emitter.emit('interactive-prompt', this.sessionId, prompt);
+        }
+        return; // Don't process streaming while prompt is showing
+      } else if (this.lastPromptId) {
+        this.lastPromptId = null;
+      }
+
       // 1. Check for thinking indicator
       const thinking = detectThinking(content);
       if (thinking) {
@@ -103,6 +128,103 @@ export class GeminiPaneMonitor {
       // Silently ignore — tmux window may have been killed
     }
   }
+
+  /**
+   * Detect an interactive prompt in the Gemini CLI pane content.
+   * Returns an InteractivePrompt if one is detected, null otherwise.
+   */
+  private _detectPrompt(content: string, _lines: string[]): InteractivePrompt | null {
+    // Tool Confirmation: "Action Required" with numbered options
+    if (content.includes('Action Required') && /●\s+\d+\./.test(content)) {
+      const description = this._extractBetween(content, 'Action Required', '●');
+      const options = this._parseNumberedOptions(content);
+      return {
+        requestId: `gemini-perm-${simpleHash(description)}`,
+        promptType: 'permission',
+        title: 'Action Required',
+        description: description.trim(),
+        options,
+      };
+    }
+
+    // Plan Approval: "Approval" with "Yes" and "feedback"
+    if (content.includes('Approval') && /Yes/.test(content) && /feedback/i.test(content)) {
+      const description = this._extractBetween(content, 'Approval', '●');
+      const options = this._parseNumberedOptions(content);
+      return {
+        requestId: `gemini-plan-${simpleHash(description)}`,
+        promptType: 'plan',
+        title: 'Plan Approval',
+        description: description.trim(),
+        options,
+        textInput: { placeholder: 'Provide feedback...' },
+      };
+    }
+
+    // AskUser: "Answer Questions"
+    if (content.includes('Answer Questions')) {
+      const description = this._extractBetween(content, 'Answer Questions', '●');
+      const options = this._parseNumberedOptions(content);
+      if (options.length > 0) {
+        return {
+          requestId: `gemini-ask-${simpleHash(description)}`,
+          promptType: 'question',
+          title: 'Answer Questions',
+          description: description.trim(),
+          options,
+        };
+      }
+      return {
+        requestId: `gemini-ask-${simpleHash(description)}`,
+        promptType: 'question',
+        title: 'Answer Questions',
+        description: description.trim(),
+        textInput: { placeholder: 'Type your answer...' },
+      };
+    }
+
+    // Loop Detection: "potential loop was detected"
+    if (content.includes('potential loop was detected')) {
+      const options = this._parseNumberedOptions(content);
+      return {
+        requestId: `gemini-loop-${simpleHash('loop-detected')}`,
+        promptType: 'loop-detected',
+        title: 'Loop Detected',
+        description: 'A potential loop was detected.',
+        options,
+      };
+    }
+
+    return null;
+  }
+
+  /**
+   * Parse numbered options from Gemini CLI content.
+   * Matches patterns like "● 1. Allow this action" or "1. Allow this action".
+   * Returns 0-based index values.
+   */
+  private _parseNumberedOptions(content: string): { value: string; label: string }[] {
+    const results: { value: string; label: string }[] = [];
+    const regex = /(?:●\s+)?(\d+)\.\s+(.+?)(?:\n|$)/g;
+    let match: RegExpExecArray | null;
+    while ((match = regex.exec(content)) !== null) {
+      const index = parseInt(match[1]!, 10);
+      results.push({ value: String(index - 1), label: match[2]!.trim() });
+    }
+    return results;
+  }
+
+  /**
+   * Extract text between two markers in the content.
+   */
+  private _extractBetween(content: string, start: string, end: string): string {
+    const startIdx = content.indexOf(start);
+    if (startIdx === -1) return '';
+    const afterStart = startIdx + start.length;
+    const endIdx = content.indexOf(end, afterStart);
+    if (endIdx === -1) return content.slice(afterStart).trim();
+    return content.slice(afterStart, endIdx).trim();
+  }
 }
 
 // =============================================================================
@@ -178,7 +300,7 @@ export function extractResponseText(content: string): string {
     // Gemini user prompt patterns (conservative):
     // - ">" or "❯" at start of line followed by user text
     // - "user:" prefix
-    if (/^\s*[>❯]\s+\S/.test(line) || /^\s*user:\s/i.test(line)) {
+    if (/^\s*[>*❯]\s+\S/.test(line) || /^\s*user:\s/i.test(line)) {
       lastUserPrompt = i;
       break;
     }
@@ -204,7 +326,7 @@ export function extractResponseText(content: string): string {
       // Horizontal rules
       /^[─━═\-]{5,}/.test(line.trim()) ||
       // New user prompt
-      /^\s*[>❯]\s+\S/.test(line) ||
+      /^\s*[>*❯]\s+\S/.test(line) ||
       // Spinner/thinking indicators (braille set)
       /^\s*[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]\s*/.test(line)
     ) {