teleportation-cli 1.1.5 → 1.2.0

package/.claude/hooks/stop.mjs

@@ -1,17 +1,115 @@
 #!/usr/bin/env bun
 /**
  * Stop Hook
- * 
+ *
  * This hook fires when Claude Code finishes responding.
- * 
+ *
  * Purpose:
  * 1. Check for pending messages from the mobile app (existing functionality)
  * 2. Extract Claude's last response from the transcript and log it to timeline
  */
 
 import { stdin, stdout, stderr, exit, env } from 'node:process';
-import { readFile } from 'node:fs/promises';
-import { appendFileSync } from 'node:fs';
+import { readFile, mkdir, writeFile } from 'node:fs/promises';
+import { appendFileSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createHash } from 'node:crypto';
+
+/**
+ * Generate a deterministic UUID-formatted event ID from message UUID and event index.
+ * This ensures the same transcript message always produces the same event IDs,
+ * enabling server-side deduplication via ON CONFLICT (id) DO NOTHING.
+ */
+const deterministicEventId = (msgUuid, eventIndex) => {
+  if (!msgUuid) return null;
+  const hash = createHash('sha256').update(`${msgUuid}:${eventIndex}`).digest('hex');
+  return [hash.slice(0,8), hash.slice(8,12), hash.slice(12,16), hash.slice(16,20), hash.slice(20,32)].join('-');
+};
+
+// Dynamic import for sanitizer (handle both installed and dev paths)
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Sanitizer is cached per hook execution. Each hook runs as a separate process
+// spawned by Claude Code, so there's no concurrency risk within a single execution.
+// The cache persists for the duration of the hook process (typically <1 second).
+let sanitizeForLog = null;
+let sanitizerWarningLogged = false;
+
+/**
+ * Basic regex-based sanitizer used as fallback when log-sanitizer.js is not available.
+ * Covers the most common sensitive patterns to prevent data leakage.
+ *
+ * @param {string} text - Text to sanitize
+ * @returns {string} - Sanitized text with sensitive data redacted
+ */
+function basicSanitizer(text) {
+  if (!text || typeof text !== 'string') return text;
+
+  return text
+    // JWT tokens (must come first as they start with 'eyJ' and could be matched by other patterns)
+    .replace(/eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g, '[JWT_REDACTED]')
+    // API keys (various formats)
+    .replace(/api[_-]?key["']?\s*[:=]\s*["']?([A-Za-z0-9_-]{20,})["']?/gi, 'api_key: [REDACTED]')
+    // Bearer tokens
+    .replace(/Bearer\s+[A-Za-z0-9_-]+/gi, 'Bearer [REDACTED]')
+    // Authorization headers
+    .replace(/Authorization["']?\s*[:=]\s*["']?([A-Za-z0-9_-]{20,})["']?/gi, 'Authorization: [REDACTED]')
+    // Passwords
+    .replace(/(password|passwd|pwd)["']?\s*[:=]\s*["']?([^\s"']+)["']?/gi, '$1: [REDACTED]')
+    // Secrets
+    .replace(/secret["']?\s*[:=]\s*["']?([^\s"']+)["']?/gi, 'secret: [REDACTED]')
+    // Generic tokens (must come after JWT to avoid partial matching)
+    .replace(/token["']?\s*[:=]\s*["']?([A-Za-z0-9_-]{20,})["']?/gi, 'token: [REDACTED]')
+    // AWS keys
+    .replace(/AKIA[A-Z0-9]{16}/g, 'AKIA[REDACTED]');
+}
+
+/**
+ * Get the sanitizer function for removing sensitive data from text.
+ * Tries multiple paths to find the log-sanitizer module.
+ * Falls back to basicSanitizer if the full module is not found.
+ *
+ * @param {Function} [log] - Optional logging function for warnings
+ * @returns {Promise<Function>} - The sanitizer function
+ */
+async function getSanitizer(log = () => {}) {
+  if (sanitizeForLog) return sanitizeForLog;
+
+  const possiblePaths = [
+    // Installed location
+    join(homedir(), '.teleportation', 'lib', 'utils', 'log-sanitizer.js'),
+    // Development mode - relative to hooks directory
+    join(__dirname, '..', '..', 'lib', 'utils', 'log-sanitizer.js'),
+  ];
+
+  for (const path of possiblePaths) {
+    if (!existsSync(path)) continue;
+    try {
+      const mod = await import(path);
+      sanitizeForLog = mod.sanitizeForLog;
+      if (sanitizeForLog) return sanitizeForLog;
+    } catch (err) {
+      // Log import failures for debugging (only in DEBUG mode to avoid noise)
+      if (env.DEBUG) {
+        log(`[Sanitizer] Failed to import from ${path}: ${err.message}`);
+      }
+      continue;
+    }
+  }
+
+  // Fallback: use basic regex sanitizer instead of identity function
+  // This ensures sensitive data is still redacted even if full sanitizer is unavailable
+  if (!sanitizerWarningLogged) {
+    sanitizerWarningLogged = true;
+    log('⚠️  Full sanitizer not found - using basic regex fallback. ' +
+        'Some sensitive patterns may not be caught.');
+  }
+  sanitizeForLog = basicSanitizer;
+  return sanitizeForLog;
+}
 
 const readStdin = () => new Promise((resolve, reject) => {
   let data = '';
@@ -47,8 +145,81 @@ const MAX_SYSTEM_MESSAGE_LENGTH = 1000;
 const MAX_TRANSCRIPT_SIZE = 500 * 1024;
 
 // Retry configuration
+// Note: With MAX_RETRIES=3 and exponential backoff, max total time per request is ~36 seconds:
+//   Attempt 1: 10s timeout + 1s delay = 11s
+//   Attempt 2: 10s timeout + 2s delay = 12s
+//   Attempt 3: 10s timeout + 3s delay = 13s
+//   Total max: ~36 seconds
 const MAX_RETRIES = 3;
 const RETRY_DELAY_MS = 1000;
+const FETCH_TIMEOUT_MS = 10000; // 10 second timeout for each fetch
+const BATCH_FETCH_TIMEOUT_MS = 60000; // 60 second timeout for batch uploads (larger payloads)
+const HEALTH_PROBE_TIMEOUT_MS = parseInt(env.TELEPORTATION_STOP_HEALTH_PROBE_TIMEOUT_MS || '2500', 10);
+const MAX_MESSAGES_ON_DEGRADED_BOOTSTRAP = parseInt(env.TELEPORTATION_STOP_DEGRADED_BOOTSTRAP_LIMIT || '250', 10);
+const STOP_FULL_INGEST_ENABLED = env.TELEPORTATION_STOP_FULL_INGEST === 'true';
+const STOP_CURSOR_DIR = join(homedir(), '.teleportation', '.stop_hook_cursor_v2');
+
+const getStopCursorPath = (sessionId) => join(STOP_CURSOR_DIR, `${sessionId}.json`);
+
+const toTimestampMs = (timestamp) => {
+  if (typeof timestamp === 'number' && Number.isFinite(timestamp)) return timestamp;
+  if (typeof timestamp === 'string' && timestamp) {
+    const parsed = new Date(timestamp).getTime();
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return 0;
+};
+
+const loadStopCursor = async (sessionId, log) => {
+  if (!sessionId) return null;
+  try {
+    const path = getStopCursorPath(sessionId);
+    const raw = await readFile(path, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object') return null;
+    return {
+      last_uuid: typeof parsed.last_uuid === 'string' ? parsed.last_uuid : null,
+      last_timestamp_ms: Number.isFinite(parsed.last_timestamp_ms) ? parsed.last_timestamp_ms : 0,
+      updated_at: Number.isFinite(parsed.updated_at) ? parsed.updated_at : 0
+    };
+  } catch {
+    return null;
+  }
+};
+
+const saveStopCursor = async (sessionId, cursor, log) => {
+  if (!sessionId || !cursor) return;
+  try {
+    await mkdir(STOP_CURSOR_DIR, { recursive: true, mode: 0o700 });
+    await writeFile(
+      getStopCursorPath(sessionId),
+      JSON.stringify({
+        last_uuid: cursor.last_uuid || null,
+        last_timestamp_ms: Number.isFinite(cursor.last_timestamp_ms) ? cursor.last_timestamp_ms : 0,
+        updated_at: Date.now()
+      }),
+      { mode: 0o600 }
+    );
+  } catch (e) {
+    log(`Failed to persist stop cursor: ${e.message}`);
+  }
+};
+
+const probeTimelineEndpoint = async (relayApiUrl, relayApiKey, sessionId, log) => {
+  try {
+    const res = await fetchWithTimeout(`${relayApiUrl}/api/sessions/${sessionId}/timeline?limit=1`, {
+      headers: { 'Authorization': `Bearer ${relayApiKey}` }
+    }, HEALTH_PROBE_TIMEOUT_MS);
+    if (!res.ok) {
+      log(`Health probe failed with HTTP ${res.status}`);
+      return false;
+    }
+    return true;
+  } catch (e) {
+    log(`Health probe failed: ${e.message}`);
+    return false;
+  }
+};
 
 /**
  * Extract text content from a message in various formats
@@ -95,20 +266,130 @@ const extractMessageContent = (msg) => {
   return '';
 };
 
+/**
+ * Sanitize event data to remove sensitive information before storing in timeline.
+ * Applies sanitization to string fields that may contain secrets.
+ *
+ * @param {Object} eventData - The event data object
+ * @param {Function} sanitizer - The sanitization function
+ * @returns {Object} - Sanitized event data
+ */
+const sanitizeEventData = (eventData, sanitizer) => {
+  if (!eventData || typeof eventData !== 'object') return eventData;
+  if (!sanitizer) return eventData;
+
+  const sanitized = { ...eventData };
+
+  // Sanitize known text fields
+  const textFields = ['message', 'summary', 'thinking', 'result', 'error'];
+  for (const field of textFields) {
+    if (typeof sanitized[field] === 'string') {
+      sanitized[field] = sanitizer(sanitized[field]);
+    }
+  }
+
+  // Sanitize tool_input if it's a string or contains sensitive data
+  if (sanitized.tool_input) {
+    if (typeof sanitized.tool_input === 'string') {
+      sanitized.tool_input = sanitizer(sanitized.tool_input);
+    } else if (typeof sanitized.tool_input === 'object') {
+      // Sanitize stringified version of object fields that might contain secrets
+      const inputStr = JSON.stringify(sanitized.tool_input);
+      const sanitizedStr = sanitizer(inputStr);
+      if (inputStr !== sanitizedStr) {
+        try {
+          sanitized.tool_input = JSON.parse(sanitizedStr);
+        } catch {
+          // If parsing fails, use sanitized string
+          sanitized.tool_input = sanitizedStr;
+        }
+      }
+    }
+  }
+
+  return sanitized;
+};
+
+/**
+ * Fetch with timeout using AbortController
+ *
+ * Wraps native fetch with a configurable timeout. If the request takes longer
+ * than timeoutMs, the request is aborted and an AbortError is thrown.
+ *
+ * @param {string} url - The URL to fetch
+ * @param {RequestInit} opts - Fetch options (method, headers, body, etc.)
+ * @param {number} [timeoutMs=FETCH_TIMEOUT_MS] - Timeout in milliseconds (default: 10s)
+ * @returns {Promise<Response>} - The fetch Response object
+ * @throws {Error} - AbortError if timeout exceeded, or network errors
+ *
+ * @example
+ * // Basic usage with default 10s timeout
+ * const res = await fetchWithTimeout('https://api.example.com/data', { method: 'GET' });
+ *
+ * @example
+ * // Custom 60s timeout for large payloads
+ * const res = await fetchWithTimeout(url, { method: 'POST', body }, 60000);
+ */
+const fetchWithTimeout = async (url, opts, timeoutMs = FETCH_TIMEOUT_MS) => {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetch(url, { ...opts, signal: controller.signal });
+    return res;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+};
+
 /**
  * Fetch JSON with retry logic
+ *
+ * Retries failed requests with exponential backoff. Does NOT retry on:
+ * - AbortError (timeout) - to prevent duplicate requests for slow endpoints
+ * - 4xx client errors - these won't succeed on retry
+ *
+ * @param {string} url - The URL to fetch
+ * @param {RequestInit} opts - Fetch options
+ * @param {Function} log - Logging function
+ * @param {number} [retries=0] - Current retry count (internal)
+ * @param {number} [timeoutMs=FETCH_TIMEOUT_MS] - Timeout per attempt
+ * @returns {Promise<Object>} - Parsed JSON response
  */
-const fetchJsonWithRetry = async (url, opts, log, retries = 0) => {
+const fetchJsonWithRetry = async (url, opts, log, retries = 0, timeoutMs = FETCH_TIMEOUT_MS) => {
+  // Extract endpoint path for logging (hide host/auth for security)
+  const urlPath = (() => {
+    try {
+      const parsed = new URL(url);
+      return parsed.pathname + parsed.search;
+    } catch {
+      return url.split('?')[0].split('/').slice(-2).join('/');
+    }
+  })();
+
   try {
-    const res = await fetch(url, opts);
+    const res = await fetchWithTimeout(url, opts, timeoutMs);
     if (!res.ok) throw new Error(`HTTP ${res.status}`);
     return res.json();
   } catch (error) {
+    // Don't retry on abort (timeout) - request may still be processing server-side
+    // This prevents duplicate entries for slow batch uploads
+    if (error.name === 'AbortError') {
+      log(`Request to ${urlPath} aborted (timeout after ${timeoutMs}ms) - not retrying to avoid duplicates`);
+      throw error;
+    }
+
+    // Don't retry on 4xx client errors - they won't succeed
+    if (error.message && error.message.startsWith('HTTP 4')) {
+      log(`Request to ${urlPath} failed: ${error.message} - not retrying (client error)`);
+      throw error;
+    }
+
     if (retries < MAX_RETRIES) {
-      log(`Retry ${retries + 1}/${MAX_RETRIES} after error: ${error.message}`);
+      log(`Retry ${retries + 1}/${MAX_RETRIES} for ${urlPath} after error: ${error.message}`);
       await new Promise(r => setTimeout(r, RETRY_DELAY_MS * (retries + 1)));
-      return fetchJsonWithRetry(url, opts, log, retries + 1);
+      return fetchJsonWithRetry(url, opts, log, retries + 1, timeoutMs);
     }
+    log(`Request to ${urlPath} failed after ${MAX_RETRIES} retries: ${error.message}`);
     throw error;
   }
 };
@@ -366,23 +647,331 @@ const extractFullTranscript = async (transcriptPath, log) => {
   }
 };
 
+/**
+ * Parse transcript into structured events for batch logging
+ * Only processes messages newer than the most recent timeline event (prevents duplicates)
+ * Extracts event types: assistant_response, thinking, tool_use, tool_result, compact_summary
+ *
+ * @param {string} transcriptPath - Path to the transcript file
+ * @param {string} sessionId - Session ID for timeline query
+ * @param {string} relayApiUrl - Relay API URL
+ * @param {string} relayApiKey - Relay API key
+ * @param {Function} log - Logging function
+ * @returns {Promise<{events: Array<{type: string, data: object}>, cursor: object|null}>}
+ */
+const parseTranscriptToEvents = async (transcriptPath, sessionId, relayApiUrl, relayApiKey, log) => {
+  try {
+    if (!transcriptPath) {
+      log('No transcript_path provided for parsing');
+      return { events: [], cursor: null };
+    }
+
+    // Get sanitizer for removing sensitive data from events
+    const sanitizer = await getSanitizer(log);
+
+    // 1. Get most recent event timestamp from timeline to find split point
+    let lastEventTimestamp = 0;
+    let lastEventIsoTimestamp = null;
+    let timelineQueryFailed = false;
+
+    try {
+      const timelineResponse = await fetchWithTimeout(`${relayApiUrl}/api/sessions/${sessionId}/timeline?limit=1`, {
+        headers: { 'Authorization': `Bearer ${relayApiKey}` }
+      });
+
+      if (timelineResponse.ok) {
+        const response = await timelineResponse.json();
+
+        // Validate response format and extract events
+        // PRD-0022: Timeline API returns { events: [...], pagination: {...} } format
+        // Also handle legacy array format for backward compatibility
+        let events;
+        if (Array.isArray(response)) {
+          events = response;
+        } else if (response && typeof response === 'object' && Array.isArray(response.events)) {
+          events = response.events;
+        } else {
+          // Unexpected format - log warning and continue with empty events
+          log(`⚠️  Unexpected timeline response format: ${typeof response}${response?.error ? ` (error: ${response.error})` : ''}`);
+          events = [];
+        }
+
+        if (events.length > 0 && events[0].timestamp) {
+          // Handle both numeric timestamps (Unix ms) and ISO string timestamps
+          const rawTimestamp = events[0].timestamp;
+          lastEventTimestamp = typeof rawTimestamp === 'number'
+            ? rawTimestamp
+            : new Date(rawTimestamp).getTime();
+
+          if (!isNaN(lastEventTimestamp) && lastEventTimestamp > 0) {
+            lastEventIsoTimestamp = new Date(lastEventTimestamp).toISOString();
+            log(`Most recent timeline event: ${lastEventIsoTimestamp} (${lastEventTimestamp}ms)`);
+          } else {
+            log(`Invalid timestamp in timeline event: ${rawTimestamp} - will process all messages`);
+            lastEventTimestamp = 0;
+          }
+        } else {
+          log('No previous events in timeline - will process all messages');
+        }
+      } else {
+        log(`Timeline query returned ${timelineResponse.status} - will process all messages`);
+      }
+    } catch (e) {
+      timelineQueryFailed = true;
+      log(`Timeline query failed: ${e.message} - will process all messages`);
+    }
+
+    // 2. Read and parse transcript (JSONL format)
+    let content;
+    try {
+      content = await readFile(transcriptPath, 'utf8');
+    } catch (e) {
+      log(`Error reading transcript: ${e.code || e.message}`);
+      return { events: [], cursor: null };
+    }
+
+    let transcript;
+    try {
+      transcript = JSON.parse(content);
+      log('Parsed transcript as JSON array');
+    } 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);
+      log(`Parsed transcript as JSONL (${transcript.length} total messages)`);
+    }
+
+    if (!Array.isArray(transcript)) {
+      log(`Transcript is not an array: ${typeof transcript}`);
+      return { events: [], cursor: null };
+    }
+
+    // 3. Filter using local cursor first, then timeline timestamp
+    const localCursor = await loadStopCursor(sessionId, log);
+    let newMessages = transcript;
+    let usedLocalCursor = false;
+
+    if (localCursor?.last_uuid) {
+      const idx = transcript.findIndex(msg => msg.uuid === localCursor.last_uuid);
+      if (idx >= 0) {
+        newMessages = transcript.slice(idx + 1);
+        usedLocalCursor = true;
+        log(`📍 Local cursor UUID matched at index ${idx}, processing ${newMessages.length} newer messages`);
+      } else {
+        log('⚠️ Local cursor UUID not found in transcript, falling back to timestamp cursor');
+      }
+    }
+
+    if (!usedLocalCursor && localCursor?.last_timestamp_ms > 0) {
+      const filtered = transcript.filter(msg => toTimestampMs(msg.timestamp) > localCursor.last_timestamp_ms);
+      if (filtered.length !== transcript.length) {
+        newMessages = filtered;
+        usedLocalCursor = true;
+        log(`📍 Local timestamp cursor applied, processing ${newMessages.length} newer messages`);
+      }
+    }
+
+    if (lastEventTimestamp > 0) {
+      newMessages = newMessages.filter(msg => toTimestampMs(msg.timestamp) > lastEventTimestamp);
+      log(`📊 Timeline cursor + local cursor reduced to ${newMessages.length} new messages`);
+    } else {
+      if (timelineQueryFailed && !usedLocalCursor && newMessages.length > MAX_MESSAGES_ON_DEGRADED_BOOTSTRAP) {
+        newMessages = newMessages.slice(-MAX_MESSAGES_ON_DEGRADED_BOOTSTRAP);
+        log(`⚠️ Timeline unavailable, limiting bootstrap parse to last ${MAX_MESSAGES_ON_DEGRADED_BOOTSTRAP} messages`);
+      } else if (!usedLocalCursor) {
+        log(`📊 Processing all ${transcript.length} messages (no previous timeline or local cursor)`);
+      }
+    }
+
+    const events = [];
+
+    // Build tool_use lookup for matching tool_result to tool_use
+    const toolUseLookup = new Map();
+    for (const msg of newMessages) {
+      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
+            });
+          }
+        }
+      }
+    }
+
+    // Parse each new message (only those newer than last timeline event)
+    for (const msg of newMessages) {
+      let msgEventIndex = 0; // Per-message counter — stable regardless of batch composition
+      const role = msg.role || msg.type || '';
+      const timestamp = msg.timestamp || Date.now();
+
+      // 1. Extract assistant responses (conversational text)
+      if (role === 'assistant' || role === 'model' || msg.isAssistant) {
+        const text = extractMessageContent(msg);
+        if (text && text.trim()) {
+          const preview = text.length > ASSISTANT_RESPONSE_MAX_LENGTH
+            ? text.slice(0, ASSISTANT_RESPONSE_MAX_LENGTH) + '...'
+            : text;
+
+          events.push({
+            type: 'assistant_response',
+            id: deterministicEventId(msg.uuid, msgEventIndex++),
+            timestamp,
+            data: {
+              message: preview,
+              model: msg.model || null,
+              full_length: text.length,
+              truncated: text.length > ASSISTANT_RESPONSE_MAX_LENGTH,
+              timestamp
+            }
+          });
+        }
+      }
+
+      // 2. 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;
+
+        events.push({
+          type: 'compact_summary',
+          id: deterministicEventId(msg.uuid, msgEventIndex++),
+          timestamp,
+          data: {
+            summary: preview,
+            full_length: content.length,
+            truncated: content.length > MAX_SYSTEM_MESSAGE_LENGTH,
+            timestamp
+          }
+        });
+      }
+
+      // 3. Extract thinking blocks and tool_use from content blocks
+      if (msg.message?.content && Array.isArray(msg.message.content)) {
+        for (const block of msg.message.content) {
+          // Thinking blocks
+          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;
+
+            events.push({
+              type: 'thinking',
+              id: deterministicEventId(msg.uuid, msgEventIndex++),
+              timestamp,
+              data: {
+                thinking: preview,
+                full_length: block.thinking.length,
+                truncated: block.thinking.length > MAX_SYSTEM_MESSAGE_LENGTH,
+                timestamp,
+                signature: block.signature ? '✓ verified' : null
+              }
+            });
+          }
+
+          // Tool use blocks
+          if (block.type === 'tool_use' && block.name) {
+            events.push({
+              type: 'tool_use',
+              id: deterministicEventId(msg.uuid, msgEventIndex++),
+              timestamp,
+              data: {
+                tool_name: block.name,
+                tool_use_id: block.id,
+                tool_input: block.input || null,
+                timestamp
+              }
+            });
+          }
+
+          // Tool result blocks
+          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
+            const toolDetails = block.tool_use_id ? toolUseLookup.get(block.tool_use_id) : null;
+
+            events.push({
+              type: 'tool_result',
+              id: deterministicEventId(msg.uuid, msgEventIndex++),
+              timestamp,
+              data: {
+                tool_use_id: block.tool_use_id,
+                tool_name: toolDetails?.name || null,
+                tool_input: toolDetails?.input || null,
+                result: preview,
+                full_length: contentStr.length,
+                truncated: contentStr.length > MAX_SYSTEM_MESSAGE_LENGTH,
+                timestamp,
+                is_error: block.is_error || false
+              }
+            });
+          }
+        }
+      }
+    }
+
+    log(`✅ Parsed ${events.length} events from transcript`);
+
+    // Sanitize all events to remove sensitive data (API keys, tokens, passwords, etc.)
+    const sanitizedEvents = events.map(event => ({
+      ...event,
+      data: sanitizeEventData(event.data, sanitizer)
+    }));
+
+    const lastMessage = newMessages.length > 0 ? newMessages[newMessages.length - 1] : null;
+    const nextCursor = lastMessage ? {
+      last_uuid: lastMessage.uuid || null,
+      last_timestamp_ms: toTimestampMs(lastMessage.timestamp) || Date.now()
+    } : localCursor;
+
+    return { events: sanitizedEvents, cursor: nextCursor };
+  } catch (e) {
+    log(`Error parsing transcript to events: ${e.message}`);
+    return { events: [], cursor: null };
+  }
+};
+
 /**
  * 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
+ * Uses UUID tracking to avoid re-processing already-logged messages
+ * @param {string} transcriptPath - Path to the transcript file
+ * @param {string} sessionId - Session ID for state tracking
+ * @param {Function} log - Logging function
+ * @returns {Promise<{messages: Array, lastUUID: string|null}>} System messages and last UUID
  */
-const extractSystemMessages = async (transcriptPath, log) => {
+const extractSystemMessages = async (transcriptPath, sessionId, log) => {
   try {
     if (!transcriptPath) {
       log('No transcript_path provided for system messages');
-      return [];
+      return { messages: [], lastUUID: null };
     }
 
+    // 1. Read and parse transcript
     let content;
     try {
       content = await readFile(transcriptPath, 'utf8');
     } catch (e) {
       log(`Error reading transcript for system messages: ${e.code || e.message}`);
-      return [];
+      return { messages: [], lastUUID: null };
     }
 
     let transcript;
@@ -402,15 +991,49 @@ const extractSystemMessages = async (transcriptPath, log) => {
 
     if (!Array.isArray(transcript)) {
       log(`Transcript is not an array for system messages`);
-      return [];
+      return { messages: [], lastUUID: null };
+    }
+
+    log(`📊 Transcript contains ${transcript.length} total messages`);
+
+    // 2. Load last processed state
+    const stateDir = join(homedir(), '.teleportation', '.stop_hook_state');
+    const stateFile = join(stateDir, `${sessionId}.json`);
+
+    let lastProcessedUUID = null;
+    try {
+      const state = JSON.parse(await readFile(stateFile, 'utf8'));
+      lastProcessedUUID = state.lastUUID;
+      log(`📍 Last processed UUID: ${lastProcessedUUID?.substring(0, 8)}...`);
+    } catch (e) {
+      log('📄 No previous state - will process all messages');
+    }
+
+    // 3. Find last processed index and slice to get only new messages
+    let startIndex = 0;
+    if (lastProcessedUUID) {
+      const lastIndex = transcript.findIndex(msg => msg.uuid === lastProcessedUUID);
+      if (lastIndex >= 0) {
+        startIndex = lastIndex + 1;
+        log(`✂️ Skipping ${startIndex} already-processed messages`);
+      } else {
+        log(`⚠️ Last UUID not found in transcript, processing all messages`);
+      }
+    }
+
+    const newMessages = transcript.slice(startIndex);
+    log(`🆕 Processing ${newMessages.length} new messages`);
+
+    if (newMessages.length === 0) {
+      log('✓ No new messages to process');
+      return { messages: [], lastUUID: lastProcessedUUID };
     }
 
     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: {...} }
+
+    // 4. Build lookup ONLY for new messages (more efficient)
     const toolUseLookup = new Map();
-    for (const msg of transcript) {
+    for (const msg of newMessages) {
       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) {
@@ -422,9 +1045,10 @@ const extractSystemMessages = async (transcriptPath, log) => {
         }
       }
     }
-    log(`Built tool_use lookup with ${toolUseLookup.size} entries`);
+    log(`🔧 Built tool_use lookup with ${toolUseLookup.size} entries`);
 
-    for (const msg of transcript) {
+    // 5. Process only new messages
+    for (const msg of newMessages) {
       // Extract compact summaries
       if (msg.isCompactSummary && msg.message?.content) {
         const content = typeof msg.message.content === 'string'
@@ -503,11 +1127,14 @@ const extractSystemMessages = async (transcriptPath, log) => {
       }
     }
 
-    log(`Extracted ${systemMessages.length} system messages (summaries, thinking, tool results)`);
-    return systemMessages;
+    // 6. Determine last UUID from new messages
+    const lastUUID = newMessages[newMessages.length - 1]?.uuid || lastProcessedUUID;
+
+    log(`📝 Extracted ${systemMessages.length} system messages from ${newMessages.length} new messages`);
+    return { messages: systemMessages, lastUUID };
   } catch (e) {
     log(`Error extracting system messages: ${e.message}`);
-    return [];
+    return { messages: [], lastUUID: null };
   }
 };
 
@@ -535,6 +1162,11 @@ const extractSystemMessages = async (transcriptPath, log) => {
   const { session_id, transcript_path, stop_hook_active } = input || {};
   log(`Session: ${session_id}, Transcript: ${transcript_path}, stop_hook_active: ${stop_hook_active}`);
 
+  // Detect message source
+  const isAutonomousTask = env.TELEPORTATION_TASK_MODE === 'true' || !!env.TELEPORTATION_PARENT_SESSION_ID;
+  const source = isAutonomousTask ? 'autonomous_task' : 'cli_interactive';
+  log(`Message source: ${source}`);
+
   // Load config
   let config;
   try {
@@ -561,51 +1193,100 @@ const extractSystemMessages = async (transcriptPath, log) => {
     return exit(0);
   }
 
-  // 1. Extract and log Claude's last response to timeline
+  if (!STOP_FULL_INGEST_ENABLED) {
+    log('Stop full ingest disabled (TELEPORTATION_STOP_FULL_INGEST!=true) - running lightweight stop path');
+  }
+
+  let timelineHealthy = false;
+  let skipHeavyUpload = true;
+  if (STOP_FULL_INGEST_ENABLED) {
+    timelineHealthy = await probeTimelineEndpoint(RELAY_API_URL, RELAY_API_KEY, session_id, log);
+    skipHeavyUpload = !timelineHealthy;
+    if (skipHeavyUpload) {
+      log('⚠️ Relay timeline probe failed - skipping batch event and transcript uploads for this stop cycle');
+    }
+  }
+
+  // 1. Parse transcript and batch log all events (NEW APPROACH)
   // Skip if this is a continuation from a previous stop hook (stop_hook_active=true)
-  // to avoid logging duplicate responses
-  if (!stop_hook_active) {
+  if (!stop_hook_active && !skipHeavyUpload) {
     try {
-      const result = await extractLastAssistantMessage(transcript_path, log);
+      const { events, cursor } = await parseTranscriptToEvents(transcript_path, session_id, RELAY_API_URL, RELAY_API_KEY, log);
 
-      if (result && result.text) {
-        const { text, model } = result;
+      if (events.length > 0) {
+        // Split into chunks of MAX_BATCH_SIZE to handle large batches
+        const MAX_BATCH_SIZE = 1000;
+        const chunks = [];
 
-        // Truncate for timeline storage
-        const preview = text.length > ASSISTANT_RESPONSE_MAX_LENGTH
-          ? text.slice(0, ASSISTANT_RESPONSE_MAX_LENGTH) + '...'
-          : text;
+        for (let i = 0; i < events.length; i += MAX_BATCH_SIZE) {
+          chunks.push(events.slice(i, i + MAX_BATCH_SIZE));
+        }
 
-        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: 'assistant_response',
-            data: {
-              message: preview,
-              model: model, // Include the model field
-              full_length: text.length,
-              truncated: text.length > ASSISTANT_RESPONSE_MAX_LENGTH
-            }
-          })
-        }, log);
-        log(`Logged assistant response to timeline (${preview.length} chars, model: ${model || 'not specified'})`);
+        log(`📦 Sending ${events.length} events in ${chunks.length} batch(es)`);
+
+        let totalSuccess = 0;
+        let totalFailed = 0;
+
+        for (let i = 0; i < chunks.length; i++) {
+          const chunk = chunks[i];
+
+          try {
+            // Use longer timeout for batch uploads (60s) to handle large payloads
+            // Don't retry on timeout to prevent duplicate events (see fetchJsonWithRetry)
+            const response = await fetchJsonWithRetry(`${RELAY_API_URL}/api/sessions/${session_id}/events/batch`, {
+              method: 'POST',
+              headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${RELAY_API_KEY}`
+              },
+              body: JSON.stringify({ events: chunk })
+            }, log, 0, BATCH_FETCH_TIMEOUT_MS);
+
+            const success = response.success || 0;
+            const failed = response.failed || 0;
+
+            totalSuccess += success;
+            totalFailed += failed;
+
+            log(`✅ Batch ${i + 1}/${chunks.length}: ${success} success, ${failed} failed`);
+          } catch (e) {
+            log(`❌ Batch ${i + 1}/${chunks.length} failed: ${e.message}`);
+            totalFailed += chunk.length;
+          }
+        }
+
+        log(`✅ Total: ${totalSuccess} success, ${totalFailed} failed (${chunks.length} batch(es))`);
+
+        // Save cursor AFTER successful upload — prevents reprocessing on next stop
+        // Only save if all events succeeded (partial failures should retry next time)
+        if (cursor && totalFailed === 0) {
+          await saveStopCursor(session_id, cursor, log);
+        } else if (cursor && totalFailed > 0) {
+          log(`⚠️ Skipping cursor save due to ${totalFailed} failed events (will retry next stop)`);
+        }
+      } else {
+        log('No events to log from transcript');
+        // No events but cursor advanced (all filtered) — safe to save
+        if (cursor) {
+          await saveStopCursor(session_id, cursor, log);
+        }
       }
     } catch (e) {
-      log(`Failed to log assistant response after ${MAX_RETRIES} retries: ${e.message}`);
+      log(`Failed to batch log events after ${MAX_RETRIES} retries: ${e.message}`);
       // Don't fail the hook - continue with other functionality
     }
   } else {
-    log('Skipping assistant response log (stop_hook_active=true)');
+    const reason = stop_hook_active
+      ? 'stop_hook_active=true'
+      : !STOP_FULL_INGEST_ENABLED
+        ? 'full ingest disabled'
+        : 'timeline probe unhealthy';
+    log(`Skipping batch event log (${reason})`);
   }
 
   // 2. Store full transcript for session (new feature: PRD-0011 Phase 2)
   // Only store if not in a recursive stop hook call
-  if (!stop_hook_active) {
+  if (!stop_hook_active && !skipHeavyUpload) {
     try {
       const transcriptData = await extractFullTranscript(transcript_path, log);
 
@@ -630,49 +1311,24 @@ const extractSystemMessages = async (transcriptPath, log) => {
       // Reliability: Log but don't fail hook if transcript storage fails
       log(`Failed to store full transcript: ${e.message}`);
     }
+  } else {
+    const reason = !STOP_FULL_INGEST_ENABLED ? 'full ingest disabled' : 'timeline probe unhealthy';
+    log(`Skipping transcript storage because ${reason}`);
   }
 
-  // 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}`);
-    }
-  }
+  // 3. Individual system message logging REMOVED
+  // Now handled by batch event ingestion in step 1 above
+  // Previously logged thinking blocks, tool results, etc. individually which caused:
+  // - 27K+ tool_result events
+  // - 21K+ thinking events
+  // - 99.75% data loss due to mech-storage issues
+  //
+  // New approach: Single batch request with all events parsed from transcript
+  // See: parseTranscriptToEvents() function above
 
   // 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)}`, {
+    const res = await fetchWithTimeout(`${RELAY_API_URL}/api/messages/pending?session_id=${encodeURIComponent(session_id)}`, {
       headers: { 'Authorization': `Bearer ${RELAY_API_KEY}` }
     });
     if (res.ok) {
@@ -680,19 +1336,16 @@ const extractSystemMessages = async (transcriptPath, log) => {
       if (msg && msg.id && msg.text) {
         log(`Found pending message: ${String(msg.text).slice(0, 50)}...`);
         try {
-          await fetch(`${RELAY_API_URL}/api/messages/${msg.id}/ack`, {
+          await fetchWithTimeout(`${RELAY_API_URL}/api/messages/${msg.id}/ack`, {
             method: 'POST',
             headers: { 'Authorization': `Bearer ${RELAY_API_KEY}` }
           });
         } catch {}
 
-        const out = {
-          decision: 'block',
-          reason: msg.text,
-          hookSpecificOutput: { hookEventName: 'Stop' },
-          suppressOutput: true
-        };
-        stdout.write(JSON.stringify(out));
+        // Stop hook cannot inject messages via decision/reason - that's not supported
+        // Mobile messages should be handled by a polling mechanism or different hook
+        log(`Acknowledged pending message (mobile message injection not supported in stop hook)`);
+        // Just exit cleanly without JSON output
         return exit(0);
       }
     }