teleportation-cli 1.0.2 → 1.1.1

package/.claude/hooks/permission_request.mjs

@@ -101,15 +101,15 @@ const fetchJson = async (url, opts) => {
 
   const raw = await readStdin();
   let input;
-  try { 
-    input = JSON.parse(raw || '{}'); 
+  try {
+    input = JSON.parse(raw || '{}');
   } catch (e) {
     log(`ERROR: Invalid JSON: ${e.message}`);
     return exit(0);
   }
 
-  const { session_id, tool_name, tool_input, cwd } = input || {};
-  log(`Session: ${session_id}, Tool: ${tool_name}, CWD: ${cwd}`);
+  const { session_id, tool_name, tool_input, cwd, tool_use_id, transcript_path } = input || {};
+  log(`Session: ${session_id}, Tool: ${tool_name}, CWD: ${cwd}, tool_use_id: ${tool_use_id || 'none'}`);
 
   // Validate session_id
   if (!isValidSessionId(session_id)) {
@@ -157,15 +157,10 @@ const fetchJson = async (url, opts) => {
     log(`Could not check away status: ${e.message} - using fail-safe: ${failSafe}`);
   }
 
-  // If user is NOT away, don't create an approval - let Claude Code handle it locally
-  // This prevents stale approvals from appearing in the mobile UI
-  if (!isAway) {
-    log('User is present - letting Claude Code show permission dialog (no remote approval created)');
-    return exit(0);
-  }
-
-  // User is AWAY - create remote approval and poll for decision
-  log(`Creating remote approval for ${tool_name}...`);
+  // ALWAYS create remote approval so it's visible in mobile UI
+  // If user is present, we'll also let Claude Code show its native prompt
+  // The PostToolUse hook will invalidate the approval if user approves locally
+  log(`Creating remote approval for ${tool_name} (away=${isAway})...`);
 
   // Extract session metadata (project name, hostname, branch, etc.)
   let meta = {};
@@ -207,7 +202,48 @@ const fetchJson = async (url, opts) => {
     log(`Warning: Failed to invalidate old approvals: ${e.message}`);
   }
 
-  // Create approval request with metadata
+  // Build conversation context (PRD-0013 Phase 1)
+  let conversation_context = null;
+  if (transcript_path) {
+    try {
+      const transcriptData = await readFile(transcript_path, 'utf-8');
+      const transcript = JSON.parse(transcriptData);
+
+      // Find last user message
+      let lastUserMessage = null;
+      for (let i = transcript.length - 1; i >= 0; i--) {
+        if (transcript[i]?.role === 'user' && transcript[i]?.content) {
+          // Extract text from content array
+          const textContent = Array.isArray(transcript[i].content)
+            ? transcript[i].content.find(c => c?.type === 'text')?.text
+            : transcript[i].content;
+          if (textContent) {
+            lastUserMessage = textContent;
+            break;
+          }
+        }
+      }
+
+      if (lastUserMessage) {
+        conversation_context = {
+          user_last_message: lastUserMessage.slice(0, 500), // Truncate to 500 chars
+          claude_reasoning: null, // Phase 2: extract Claude's reasoning
+          timestamp: Date.now()
+        };
+        log(`Extracted conversation context: user_message="${lastUserMessage.slice(0, 50)}..."`);
+      }
+    } catch (e) {
+      log(`Warning: Failed to extract conversation context: ${e.message}`);
+    }
+  }
+
+  // Fallback: Generate tool_use_id if not provided (defensive programming)
+  const effective_tool_use_id = tool_use_id || `tool_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+  if (!tool_use_id) {
+    log(`Warning: tool_use_id not provided, generated fallback: ${effective_tool_use_id}`);
+  }
+
+  // Create approval request with metadata and context (PRD-0013)
   let approvalId;
   try {
     const created = await fetchJson(`${RELAY_API_URL}/api/approvals`, {
@@ -216,17 +252,35 @@ const fetchJson = async (url, opts) => {
         'Content-Type': 'application/json',
         'Authorization': `Bearer ${RELAY_API_KEY}`
       },
-      body: JSON.stringify({ session_id, tool_name, tool_input, meta })
+      body: JSON.stringify({
+        session_id,
+        tool_name,
+        tool_input,
+        meta,
+        tool_use_id: effective_tool_use_id,
+        conversation_context,
+        task_description: null, // Phase 2: infer multi-step tasks
+        transcript_excerpt: null // Phase 2: include recent messages
+      })
     });
     approvalId = created.id;
-    log(`Approval created: ${approvalId}`);
+    log(`Approval created: ${approvalId} (tool_use_id: ${effective_tool_use_id})`);
   } catch (e) {
     log(`ERROR creating approval: ${e.message}`);
     return exit(0); // Let Claude Code handle it
   }
 
-  // Poll for remote approval decision
-  log('Polling for remote approval decision...');
+  // If user is PRESENT: return immediately and let Claude Code show its native prompt
+  // The approval is now visible in mobile UI. If user approves locally:
+  // - PostToolUse will invalidate the approval
+  // - Mobile UI will filter it out (any timeline event after approval = stale)
+  if (!isAway) {
+    log(`User is present - approval ${approvalId} created for mobile visibility, letting Claude Code handle locally`);
+    return exit(0);
+  }
+
+  // User is AWAY - poll for remote approval decision
+  log(`User is away - polling for remote approval decision (timeout=${FAST_APPROVAL_TIMEOUT_MS}ms)...`);
   let consecutiveFailures = 0;
   const MAX_CONSECUTIVE_FAILURES = 5;
 
@@ -241,7 +295,6 @@ const fetchJson = async (url, opts) => {
       if (status.status === 'allowed') {
         log('Remote approval: ALLOWED');
         // Acknowledge on the fast-path to prevent duplicate daemon execution.
-        // CRITICAL: If ACK fails, we must NOT proceed with local execution to avoid duplicates.
         try {
           const ackRes = await fetch(`${RELAY_API_URL}/api/approvals/${approvalId}/ack`, {
             method: 'POST',
@@ -252,7 +305,6 @@ const fetchJson = async (url, opts) => {
           }
         } catch (e) {
           log(`ERROR: Failed to ack approval ${approvalId}: ${e.message} - aborting to prevent duplicate execution`);
-          // Return early without allowing - let daemon handle it instead
           const out = {
             hookSpecificOutput: {
               hookEventName: 'PermissionRequest',
@@ -306,8 +358,7 @@ const fetchJson = async (url, opts) => {
     await sleep(POLLING_INTERVAL_MS);
   }
 
-  // Fast-path timeout: do NOT fall back to local permission prompts while user is away.
-  // Instead, hand off to daemon (background) and inform Claude.
+  // Timeout while user is away - hand off to daemon
   log('Fast-path approval timeout - handing off to daemon');
 
   try {
@@ -327,7 +378,7 @@ const fetchJson = async (url, opts) => {
     hookSpecificOutput: {
       hookEventName: 'PermissionRequest',
       permissionDecision: 'deny',
-      permissionDecisionReason: '⏳ Teleportation: waiting for mobile approval timed out. This request was handed off to the daemon and will run in the background once approved. You will see a Daemon Work Update here when it completes.'
+      permissionDecisionReason: '⏳ Teleportation: waiting for mobile approval timed out. This request was handed off to the daemon and will run in the background once approved.'
     },
     suppressOutput: true
   };

package/.claude/hooks/post_tool_use.mjs

@@ -81,7 +81,9 @@ const fetchJson = async (url, opts) => {
   }
 
   // Clear any pending approvals for this session since the tool executed successfully
-  // This handles the case where Claude Code auto-approved the tool
+  // This handles the case where Claude Code auto-approved the tool locally
+  // We set handled_location: 'local' to explicitly mark these as locally-handled
+  // (not approved via mobile UI) - this prevents race conditions in the frontend
   try {
     await fetchJson(`${RELAY_API_URL}/api/approvals/invalidate`, {
       method: 'POST',
@@ -91,7 +93,8 @@ const fetchJson = async (url, opts) => {
       },
       body: JSON.stringify({
         session_id,
-        reason: `Tool ${tool_name} executed (auto-approved by Claude Code)`
+        reason: `Tool ${tool_name} executed (auto-approved by Claude Code)`,
+        handled_location: 'local'
       })
     });
     log(`Cleared pending approvals after tool execution: ${tool_name}`);

package/.claude/hooks/pre_tool_use.mjs

@@ -144,6 +144,7 @@ const fetchJson = async (url, opts) => {
   // can approve/deny from their mobile device. This enables true remote control.
 
   // Helper: Format daemon work results into a human-readable message
+  // Enhanced for PRD-0013 Phase 1: Context Preservation
   const formatDaemonUpdate = (results) => {
     if (!results || results.length === 0) return '';
 
@@ -151,12 +152,53 @@ const fetchJson = async (url, opts) => {
     const hasBrowserTasks = results.some(r => {
       const toolName = (r.tool_name || '').toLowerCase();
       const command = (r.command || '').toLowerCase();
-      return toolName.includes('browser') || toolName.includes('mcp') || 
+      return toolName.includes('browser') || toolName.includes('mcp') ||
              command.includes('browser') || command.includes('mcp');
     });
-    
+
     const taskType = hasBrowserTasks ? 'browser/interactive task' : 'task';
-    const header = `🤖 **Daemon Work Update** (${results.length} ${taskType}${results.length > 1 ? 's' : ''} completed while you were away)\n\n`;
+    let header = `🤖 **Daemon Work Update** (${results.length} ${taskType}${results.length > 1 ? 's' : ''} completed while you were away)\n\n`;
+
+    // PRD-0013 Phase 1: Show original context if available
+    // This helps Claude remember what the user originally requested
+    const firstResult = results[0];
+    if (firstResult?.original_context?.user_last_message) {
+      const context = firstResult.original_context;
+      const timeElapsed = context.timestamp
+        ? Date.now() - context.timestamp
+        : null;
+
+      // Format time elapsed
+      let timeAgo = '';
+      if (timeElapsed) {
+        const seconds = Math.floor(timeElapsed / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+
+        if (hours > 0) {
+          timeAgo = `${hours} hour${hours > 1 ? 's' : ''} ago`;
+        } else if (minutes > 0) {
+          timeAgo = `${minutes} minute${minutes > 1 ? 's' : ''} ago`;
+        } else {
+          timeAgo = `${seconds} second${seconds > 1 ? 's' : ''} ago`;
+        }
+      }
+
+      header += `**Original Request**${timeAgo ? ` (${timeAgo})` : ''}:\n`;
+      header += `> ${context.user_last_message}\n\n`;
+
+      // Show original tool_use_id if available (helps with debugging/tracing)
+      if (firstResult.original_tool_use_id) {
+        header += `_Results for tool ID: ${firstResult.original_tool_use_id}_\n\n`;
+      }
+
+      // PRD-0013 Phase 2: Show task description and next step suggestion if available
+      // For Phase 1, task_description will be null, so this won't appear yet
+      if (context.task_description) {
+        header += `**Next Step:**\n`;
+        header += `${context.task_description}\n\n`;
+      }
+    }
     
     const formatOutput = (output, toolName) => {
       if (!output || output.trim() === '') return '(No output)';

package/.claude/hooks/stop.mjs

@@ -26,8 +26,22 @@ const isValidSessionId = (id) => {
   return id && typeof id === 'string' && /^[a-zA-Z0-9-]+$/.test(id) && id.length >= 8;
 };
 
-// Max length for assistant response preview (characters)
+/**
+ * Truncation length constants - intentionally different for different message types
+ *
+ * ASSISTANT_RESPONSE_MAX_LENGTH (2000 chars):
+ *   - Used for assistant conversational responses
+ *   - Longer because these are the primary output users want to see
+ *   - Less frequent (typically 1 per user turn)
+ *
+ * MAX_SYSTEM_MESSAGE_LENGTH (1000 chars):
+ *   - Used for system messages (compact summaries, thinking blocks, tool results)
+ *   - Shorter because these are more frequent and supplementary
+ *   - Thinking blocks can occur many times per response
+ *   - Optimizes storage while maintaining useful context
+ */
 const ASSISTANT_RESPONSE_MAX_LENGTH = 2000;
+const MAX_SYSTEM_MESSAGE_LENGTH = 1000;
 
 // Max size for full transcript (bytes) - 500KB
 const MAX_TRANSCRIPT_SIZE = 500 * 1024;
@@ -36,6 +50,51 @@ const MAX_TRANSCRIPT_SIZE = 500 * 1024;
 const MAX_RETRIES = 3;
 const RETRY_DELAY_MS = 1000;
 
+/**
+ * Extract text content from a message in various formats
+ * Handles multiple message formats from Claude Code transcripts:
+ * - Direct string content
+ * - Content blocks array [{ type: 'text', text: '...' }]
+ * - Nested message.content (Claude Code format)
+ * - Legacy text/message fields
+ *
+ * @param {Object} msg - Message object from transcript
+ * @returns {string} Extracted text content, or empty string if none found
+ */
+const extractMessageContent = (msg) => {
+  // Handle direct string content
+  if (typeof msg.content === 'string') {
+    return msg.content;
+  }
+
+  // Handle content blocks array format
+  if (Array.isArray(msg.content)) {
+    return msg.content
+      .filter(block => block.type === 'text' && block.text)
+      .map(block => block.text)
+      .join('\n\n');
+  }
+
+  // Handle nested message.content (Claude Code transcript format)
+  if (msg.message && typeof msg.message === 'object' && msg.message.content) {
+    if (typeof msg.message.content === 'string') {
+      return msg.message.content;
+    }
+    if (Array.isArray(msg.message.content)) {
+      return msg.message.content
+        .filter(block => block.type === 'text' && block.text)
+        .map(block => block.text)
+        .join('\n\n');
+    }
+  }
+
+  // Handle legacy formats
+  if (msg.text) return msg.text;
+  if (msg.message && typeof msg.message === 'string') return msg.message;
+
+  return '';
+};
+
 /**
  * Fetch JSON with retry logic
  */
@@ -118,23 +177,8 @@ const extractLastAssistantMessage = async (transcriptPath, log) => {
       // Check for assistant role (various possible formats)
       const role = msg.role || msg.type || '';
       if (role === 'assistant' || role === 'model' || msg.isAssistant) {
-        // Extract content (could be string or array of content blocks)
-        let text = '';
-
-        if (typeof msg.content === 'string') {
-          text = msg.content;
-        } else if (Array.isArray(msg.content)) {
-          // Content blocks format: [{ type: 'text', text: '...' }, ...]
-          text = msg.content
-            .filter(block => block.type === 'text' && block.text)
-            .map(block => block.text)
-            .join('\n\n'); // Use double newline for paragraph separation
-        } else if (msg.text) {
-          text = msg.text;
-        } else if (msg.message) {
-          // Don't stringify objects - only use if it's a string
-          text = typeof msg.message === 'string' ? msg.message : '';
-        }
+        // Extract content using shared helper
+        const text = extractMessageContent(msg);
 
         if (text && text.trim()) {
           // Extract model if available
@@ -214,27 +258,24 @@ const extractFullTranscript = async (transcriptPath, log) => {
     let turnIndex = 0;
 
     for (const msg of transcript) {
+      // Skip system-generated messages (compact summaries, transcript-only messages)
+      if (msg.isCompactSummary || msg.isVisibleInTranscriptOnly) {
+        continue;
+      }
+
+      // Skip tool result messages (they appear as "user" but are system messages)
+      if (msg.message?.content?.[0]?.type === 'tool_result') {
+        continue;
+      }
+
       const role = msg.role || msg.type || '';
       const isAssistant = role === 'assistant' || role === 'model' || msg.isAssistant;
       const isUser = role === 'user' || role === 'human' || msg.isUser;
 
       if (!isAssistant && !isUser) continue;
 
-      // Extract content
-      let text = '';
-      if (typeof msg.content === 'string') {
-        text = msg.content;
-      } else if (Array.isArray(msg.content)) {
-        // Content blocks format: [{ type: 'text', text: '...' }, ...]
-        text = msg.content
-          .filter(block => block.type === 'text' && block.text)
-          .map(block => block.text)
-          .join('\n\n');
-      } else if (msg.text) {
-        text = msg.text;
-      } else if (msg.message && typeof msg.message === 'string') {
-        text = msg.message;
-      }
+      // Extract content using shared helper
+      const text = extractMessageContent(msg);
 
       if (text && text.trim()) {
         messages.push({
@@ -325,6 +366,151 @@ const extractFullTranscript = async (transcriptPath, log) => {
   }
 };
 
+/**
+ * Extract system messages (compact summaries, thinking blocks, tool results) from transcript
+ * @returns {Array<{type: string, data: object}>} Array of system messages to log to timeline
+ */
+const extractSystemMessages = async (transcriptPath, log) => {
+  try {
+    if (!transcriptPath) {
+      log('No transcript_path provided for system messages');
+      return [];
+    }
+
+    let content;
+    try {
+      content = await readFile(transcriptPath, 'utf8');
+    } catch (e) {
+      log(`Error reading transcript for system messages: ${e.code || e.message}`);
+      return [];
+    }
+
+    let transcript;
+    try {
+      transcript = JSON.parse(content);
+    } catch (e) {
+      // Try JSONL format
+      const lines = content.trim().split('\n').filter(l => l.trim());
+      transcript = lines.map(line => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
+        }
+      }).filter(Boolean);
+    }
+
+    if (!Array.isArray(transcript)) {
+      log(`Transcript is not an array for system messages`);
+      return [];
+    }
+
+    const systemMessages = [];
+    
+    // Build a lookup map from tool_use_id to tool details (name + input)
+    // tool_use blocks have: { type: 'tool_use', id: 'toolu_...', name: 'Bash', input: {...} }
+    const toolUseLookup = new Map();
+    for (const msg of transcript) {
+      if (msg.message?.content && Array.isArray(msg.message.content)) {
+        for (const block of msg.message.content) {
+          if (block.type === 'tool_use' && block.id && block.name) {
+            toolUseLookup.set(block.id, {
+              name: block.name,
+              input: block.input || null
+            });
+          }
+        }
+      }
+    }
+    log(`Built tool_use lookup with ${toolUseLookup.size} entries`);
+
+    for (const msg of transcript) {
+      // Extract compact summaries
+      if (msg.isCompactSummary && msg.message?.content) {
+        const content = typeof msg.message.content === 'string'
+          ? msg.message.content
+          : JSON.stringify(msg.message.content);
+
+        const preview = content.length > MAX_SYSTEM_MESSAGE_LENGTH
+          ? content.slice(0, MAX_SYSTEM_MESSAGE_LENGTH) + '...'
+          : content;
+
+        systemMessages.push({
+          type: 'compact_summary',
+          data: {
+            summary: preview,
+            full_length: content.length,
+            truncated: content.length > MAX_SYSTEM_MESSAGE_LENGTH,
+            timestamp: msg.timestamp
+          }
+        });
+      }
+
+      // Extract thinking blocks
+      if (msg.message?.content && Array.isArray(msg.message.content)) {
+        for (const block of msg.message.content) {
+          if (block.type === 'thinking' && block.thinking) {
+            const preview = block.thinking.length > MAX_SYSTEM_MESSAGE_LENGTH
+              ? block.thinking.slice(0, MAX_SYSTEM_MESSAGE_LENGTH) + '...'
+              : block.thinking;
+
+            systemMessages.push({
+              type: 'thinking',
+              data: {
+                thinking: preview,
+                full_length: block.thinking.length,
+                truncated: block.thinking.length > MAX_SYSTEM_MESSAGE_LENGTH,
+                timestamp: msg.timestamp,
+                signature: block.signature ? '✓ verified' : null
+              }
+            });
+          }
+        }
+      }
+
+      // Extract tool results
+      if (msg.message?.content && Array.isArray(msg.message.content)) {
+        for (const block of msg.message.content) {
+          if (block.type === 'tool_result' && block.content) {
+            const contentStr = Array.isArray(block.content)
+              ? block.content.map(c => c.text || '').join('\n')
+              : String(block.content);
+
+            const preview = contentStr.length > MAX_SYSTEM_MESSAGE_LENGTH
+              ? contentStr.slice(0, MAX_SYSTEM_MESSAGE_LENGTH) + '...'
+              : contentStr;
+
+            // Look up the tool details from the corresponding tool_use block
+            const toolDetails = block.tool_use_id ? toolUseLookup.get(block.tool_use_id) : null;
+            const toolName = toolDetails?.name || null;
+            const toolInput = toolDetails?.input || null;
+
+            systemMessages.push({
+              type: 'tool_result',
+              data: {
+                tool_use_id: block.tool_use_id,
+                tool_name: toolName,  // Include resolved tool name
+                tool_input: toolInput, // Include tool input (file_path, command, etc.)
+                result: preview,
+                full_length: contentStr.length,
+                truncated: contentStr.length > MAX_SYSTEM_MESSAGE_LENGTH,
+                timestamp: msg.timestamp,
+                is_error: block.is_error || false
+              }
+            });
+          }
+        }
+      }
+    }
+
+    log(`Extracted ${systemMessages.length} system messages (summaries, thinking, tool results)`);
+    return systemMessages;
+  } catch (e) {
+    log(`Error extracting system messages: ${e.message}`);
+    return [];
+  }
+};
+
 (async () => {
   const hookLogFile = env.TELEPORTATION_HOOK_LOG || '/tmp/teleportation-hook.log';
   const log = (msg) => {
@@ -446,7 +632,45 @@ const extractFullTranscript = async (transcriptPath, log) => {
     }
   }
 
-  // 3. Check for pending messages from mobile app (existing functionality)
+  // 3. Extract and log system messages to timeline (compact summaries, thinking blocks, tool results)
+  if (!stop_hook_active) {
+    try {
+      const systemMessages = await extractSystemMessages(transcript_path, log);
+      const failedLogs = [];
+
+      for (const msg of systemMessages) {
+        try {
+          await fetchJsonWithRetry(`${RELAY_API_URL}/api/timeline`, {
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json',
+              'Authorization': `Bearer ${RELAY_API_KEY}`
+            },
+            body: JSON.stringify({
+              session_id,
+              type: msg.type,
+              data: msg.data
+            })
+          }, log);
+          log(`Logged ${msg.type} to timeline`);
+        } catch (e) {
+          failedLogs.push({ type: msg.type, error: e.message });
+          log(`Failed to log ${msg.type}: ${e.message}`);
+        }
+      }
+
+      // Report aggregate failures for visibility
+      if (failedLogs.length > 0) {
+        log(`⚠️ Failed to log ${failedLogs.length}/${systemMessages.length} system messages to timeline`);
+      } else if (systemMessages.length > 0) {
+        log(`✓ Successfully logged all ${systemMessages.length} system messages to timeline`);
+      }
+    } catch (e) {
+      log(`Failed to extract system messages: ${e.message}`);
+    }
+  }
+
+  // 4. Check for pending messages from mobile app (existing functionality)
   try {
     const res = await fetch(`${RELAY_API_URL}/api/messages/pending?session_id=${encodeURIComponent(session_id)}`, {
       headers: { 'Authorization': `Bearer ${RELAY_API_KEY}` }