teleportation-cli 1.3.0 → 1.4.1

package/.claude/hooks/stop.mjs

@@ -75,6 +75,9 @@ function basicSanitizer(text) {
  * @param {Function} [log] - Optional logging function for warnings
  * @returns {Promise<Function>} - The sanitizer function
  */
+// Shared sanitizeEventData from lib/utils/log-sanitizer.js (loaded alongside sanitizeForLog)
+let sanitizeEventDataFn = null;
+
 async function getSanitizer(log = () => {}) {
   if (sanitizeForLog) return sanitizeForLog;
 
@@ -90,6 +93,7 @@ async function getSanitizer(log = () => {}) {
     try {
       const mod = await import(path);
       sanitizeForLog = mod.sanitizeForLog;
+      sanitizeEventDataFn = mod.sanitizeEventData || null;
       if (sanitizeForLog) return sanitizeForLog;
     } catch (err) {
       // Log import failures for debugging (only in DEBUG mode to avoid noise)
@@ -127,9 +131,10 @@ const isValidSessionId = (id) => {
 /**
  * Truncation length constants - intentionally different for different message types
  *
- * ASSISTANT_RESPONSE_MAX_LENGTH (2000 chars):
+ * ASSISTANT_RESPONSE_MAX_LENGTH (50000 chars / ~50KB):
  *   - Used for assistant conversational responses
- *   - Longer because these are the primary output users want to see
+ *   - Matches the relay API's MAX_EVENT_DATA_SIZE limit per field
+ *   - Responses are primary output users want to read in full
  *   - Less frequent (typically 1 per user turn)
  *
  * MAX_SYSTEM_MESSAGE_LENGTH (1000 chars):
@@ -138,7 +143,7 @@ const isValidSessionId = (id) => {
  *   - Thinking blocks can occur many times per response
  *   - Optimizes storage while maintaining useful context
  */
-const ASSISTANT_RESPONSE_MAX_LENGTH = 2000;
+const ASSISTANT_RESPONSE_MAX_LENGTH = 50000;
 const MAX_SYSTEM_MESSAGE_LENGTH = 1000;
 
 // Max size for full transcript (bytes) - 500KB
@@ -268,42 +273,49 @@ const extractMessageContent = (msg) => {
 
 /**
  * Sanitize event data to remove sensitive information before storing in timeline.
- * Applies sanitization to string fields that may contain secrets.
+ * Delegates to the shared sanitizeEventData from lib/utils/log-sanitizer.js when
+ * available, otherwise falls back to a local implementation.
  *
  * @param {Object} eventData - The event data object
  * @param {Function} sanitizer - The sanitization function
  * @returns {Object} - Sanitized event data
  */
 const sanitizeEventData = (eventData, sanitizer) => {
+  // Use shared module if loaded by getSanitizer()
+  if (sanitizeEventDataFn) {
+    return sanitizeEventDataFn(eventData, sanitizer);
+  }
+
+  // Fallback: local implementation (kept as safety net if shared module unavailable)
   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'];
+  const textFields = ['message', 'summary', 'thinking', 'result', 'error', 'stdout', 'stderr', 'content'];
   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;
+      // SYNC_WITH: lib/utils/log-sanitizer.js SENSITIVE_KEY_RE
+      const sensitiveKeyRe = /^(password|passwd|pwd|secret|token|api[_-]?key|authorization|credentials?)$/i;
+      const sanitizeValues = (obj, parentKey) => {
+        if (typeof obj === 'string') {
+          if (parentKey && sensitiveKeyRe.test(parentKey)) return '***';
+          return sanitizer(obj);
         }
-      }
+        if (typeof obj !== 'object' || obj === null) return obj;
+        if (Array.isArray(obj)) return obj.map(item => sanitizeValues(item));
+        const result = {};
+        for (const [k, v] of Object.entries(obj)) result[k] = sanitizeValues(v, k);
+        return result;
+      };
+      sanitized.tool_input = sanitizeValues(sanitized.tool_input);
     }
   }
 
@@ -479,58 +491,65 @@ const extractLastAssistantMessage = async (transcriptPath, log) => {
 };
 
 /**
- * Extract the full conversation transcript from the transcript file
- * Returns all user and assistant messages with turn_index
- * @returns {Object|null} - { messages: [{ role, content, turn_index }], total_turns: number, truncated: boolean, original_size: number } or null
+ * Read and parse transcript file once for sharing across multiple consumers.
+ * Handles JSON array and JSONL formats.
+ *
+ * @param {string} transcriptPath - Path to transcript file
+ * @param {Function} log - Logging function
+ * @returns {Promise<Array|null>} - Parsed transcript array, or null on failure
  */
-const extractFullTranscript = async (transcriptPath, log) => {
+const readAndParseTranscript = async (transcriptPath, log) => {
+  if (!transcriptPath) {
+    log('No transcript_path provided');
+    return null;
+  }
+
+  let content;
   try {
-    if (!transcriptPath) {
-      log('No transcript_path provided for full extraction');
-      return null;
+    content = await readFile(transcriptPath, 'utf8');
+  } catch (e) {
+    if (e.code === 'ENOENT') {
+      log(`Transcript file not found: ${transcriptPath}`);
+    } else if (e.code === 'EACCES' || e.code === 'EPERM') {
+      log(`Permission denied reading transcript: ${transcriptPath}`);
+    } else {
+      log(`Error reading transcript: ${e.code || e.message}`);
     }
+    return null;
+  }
 
-    // Read file directly
-    let content;
-    try {
-      content = await readFile(transcriptPath, 'utf8');
-    } catch (e) {
-      if (e.code === 'ENOENT') {
-        log(`Transcript file not found: ${transcriptPath}`);
-        return null;
-      }
-      if (e.code === 'EACCES' || e.code === 'EPERM') {
-        log(`Permission denied reading transcript: ${transcriptPath}`);
-        return null;
-      }
-      log(`Error reading transcript for full extraction: ${e.code || e.message}`);
-      return null;
-    }
+  let transcript;
+  try {
+    transcript = JSON.parse(content);
+    log('Parsed transcript as JSON array');
+  } catch (e) {
+    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} messages)`);
+  }
 
-    let transcript;
+  if (!Array.isArray(transcript)) {
+    log(`Transcript is not an array: ${typeof transcript}`);
+    return null;
+  }
 
-    // Try parsing as JSON array first
-    try {
-      transcript = JSON.parse(content);
-      log('Parsed transcript as JSON array for full extraction');
-    } catch (e) {
-      // Try parsing as JSONL (newline-delimited JSON)
-      log('JSON parse failed for full extraction, trying 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} messages) for full extraction`);
-    }
+  return transcript;
+};
 
-    if (!Array.isArray(transcript)) {
-      log(`Transcript is not an array for full extraction: ${typeof transcript}`);
-      return null;
-    }
+/**
+ * Extract the full conversation transcript from the transcript file
+ * Returns all user and assistant messages with turn_index
+ * @param {string} transcriptPath - Path to transcript file
+ * @param {Function} log - Logging function
+ * @param {Array|null} preReadTranscript - Pre-parsed transcript array (avoids re-reading file)
+ * @returns {Object|null} - { messages: [{ role, content, turn_index }], total_turns: number, truncated: boolean, original_size: number } or null
+ */
+const extractFullTranscript = async (transcriptPath, log, preReadTranscript = null) => {
+  try {
+    const transcript = preReadTranscript || await readAndParseTranscript(transcriptPath, log);
+    if (!transcript) return null;
 
     log(`Full transcript has ${transcript.length} raw messages`);
 
@@ -657,12 +676,13 @@ const extractFullTranscript = async (transcriptPath, log) => {
  * @param {string} relayApiUrl - Relay API URL
  * @param {string} relayApiKey - Relay API key
  * @param {Function} log - Logging function
+ * @param {Array|null} preReadTranscript - Pre-parsed transcript array (avoids re-reading file)
  * @returns {Promise<{events: Array<{type: string, data: object}>, cursor: object|null}>}
  */
-const parseTranscriptToEvents = async (transcriptPath, sessionId, relayApiUrl, relayApiKey, log) => {
+const parseTranscriptToEvents = async (transcriptPath, sessionId, relayApiUrl, relayApiKey, log, preReadTranscript = null) => {
   try {
-    if (!transcriptPath) {
-      log('No transcript_path provided for parsing');
+    if (!transcriptPath && !preReadTranscript) {
+      log('No transcript_path or pre-read transcript provided for parsing');
       return { events: [], cursor: null };
     }
 
@@ -721,36 +741,9 @@ const parseTranscriptToEvents = async (transcriptPath, sessionId, relayApiUrl, r
       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 };
-    }
+    // 2. Use pre-read transcript or read fresh
+    const transcript = preReadTranscript || await readAndParseTranscript(transcriptPath, log);
+    if (!transcript) return { events: [], cursor: null };
 
     // 3. Filter using local cursor first, then timeline timestamp
     const localCursor = await loadStopCursor(sessionId, log);
@@ -1150,10 +1143,22 @@ const extractSystemMessages = async (transcriptPath, sessionId, log) => {
 
   log('=== Stop Hook invoked ===');
 
-  const raw = await readStdin();
+  // PARALLEL: Read stdin + load config simultaneously (independent operations)
+  const [raw, config] = await Promise.all([
+    readStdin(),
+    (async () => {
+      try {
+        const { loadConfig } = await import('./config-loader.mjs');
+        return await loadConfig();
+      } catch (e) {
+        return { relayApiUrl: env.RELAY_API_URL || '', relayApiKey: env.RELAY_API_KEY || '' };
+      }
+    })()
+  ]);
+
   let input;
-  try { 
-    input = JSON.parse(raw || '{}'); 
+  try {
+    input = JSON.parse(raw || '{}');
   } catch (e) {
     log(`ERROR: Invalid JSON: ${e.message}`);
     return exit(0);
@@ -1162,22 +1167,7 @@ const extractSystemMessages = async (transcriptPath, sessionId, 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 {
-    const { loadConfig } = await import('./config-loader.mjs');
-    config = await loadConfig();
-  } catch (e) {
-    config = {
-      relayApiUrl: env.RELAY_API_URL || '',
-      relayApiKey: env.RELAY_API_KEY || '',
-    };
-  }
+  const source = 'cli_interactive';
 
   const RELAY_API_URL = env.RELAY_API_URL || config.relayApiUrl || '';
   const RELAY_API_KEY = env.RELAY_API_KEY || config.relayApiKey || '';
@@ -1207,150 +1197,163 @@ const extractSystemMessages = async (transcriptPath, sessionId, log) => {
     }
   }
 
-  // 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)
-  if (!stop_hook_active && !skipHeavyUpload) {
-    try {
-      const { events, cursor } = await parseTranscriptToEvents(transcript_path, session_id, RELAY_API_URL, RELAY_API_KEY, log);
-
-      if (events.length > 0) {
-        // Split into chunks of MAX_BATCH_SIZE to handle large batches
-        const MAX_BATCH_SIZE = 1000;
-        const chunks = [];
-
-        for (let i = 0; i < events.length; i += MAX_BATCH_SIZE) {
-          chunks.push(events.slice(i, i + MAX_BATCH_SIZE));
-        }
-
-        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;
+  // Read and parse transcript ONCE (shared across all consumers)
+  const transcript = (!stop_hook_active && !skipHeavyUpload && transcript_path)
+    ? await readAndParseTranscript(transcript_path, log)
+    : null;
+
+  // PARALLEL: Parse events + prepare full transcript simultaneously
+  // Both use the shared pre-read transcript to avoid duplicate file reads
+  let parsedResult = { events: [], cursor: null };
+  let transcriptData = null;
+  let cursor = null;
+
+  if (!stop_hook_active && !skipHeavyUpload && transcript) {
+    [parsedResult, transcriptData] = await Promise.all([
+      parseTranscriptToEvents(transcript_path, session_id, RELAY_API_URL, RELAY_API_KEY, log, transcript),
+      extractFullTranscript(transcript_path, log, transcript)
+    ]);
+  } else if (stop_hook_active) {
+    log('Skipping batch event log (stop_hook_active=true)');
+  } else if (!STOP_FULL_INGEST_ENABLED) {
+    log('Skipping batch event log (full ingest disabled)');
+  } else if (skipHeavyUpload) {
+    log('Skipping batch event log (timeline probe unhealthy)');
+  }
 
-            log(`✅ Batch ${i + 1}/${chunks.length}: ${success} success, ${failed} failed`);
-          } catch (e) {
-            log(`❌ Batch ${i + 1}/${chunks.length} failed: ${e.message}`);
-            totalFailed += chunk.length;
-          }
-        }
+  const events = parsedResult.events || [];
+  cursor = parsedResult.cursor || null;
 
-        log(`✅ Total: ${totalSuccess} success, ${totalFailed} failed (${chunks.length} batch(es))`);
+  // PARALLEL: Fire all HTTP calls together using Promise.allSettled
+  // This avoids sequential waiting for: batch events, transcript storage, pending messages
+  const httpTasks = [];
 
-        // 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 batch log events after ${MAX_RETRIES} retries: ${e.message}`);
-      // Don't fail the hook - continue with other functionality
+  // 1. Batch log events
+  if (events.length > 0) {
+    const MAX_BATCH_SIZE = 1000;
+    const chunks = [];
+    for (let i = 0; i < events.length; i += MAX_BATCH_SIZE) {
+      chunks.push(events.slice(i, i + MAX_BATCH_SIZE));
     }
-  } else {
-    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 && !skipHeavyUpload) {
-    try {
-      const transcriptData = await extractFullTranscript(transcript_path, log);
+    log(`📦 Sending ${events.length} events in ${chunks.length} batch(es)`);
 
-      if (transcriptData && transcriptData.messages && transcriptData.messages.length > 0) {
-        await fetchJsonWithRetry(`${RELAY_API_URL}/api/sessions/${session_id}/transcript`, {
+    for (let i = 0; i < chunks.length; i++) {
+      const chunk = chunks[i];
+      const batchIndex = i;
+      httpTasks.push(
+        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({
-            messages: transcriptData.messages,
-            total_turns: transcriptData.total_turns,
-            truncated: transcriptData.truncated,
-            original_size: transcriptData.original_size,
-            stored_at: Date.now()
+          body: JSON.stringify({ events: chunk })
+        }, log, 0, BATCH_FETCH_TIMEOUT_MS)
+          .then(response => {
+            log(`✅ Batch ${batchIndex + 1}/${chunks.length}: ${response.success || 0} success, ${response.failed || 0} failed`);
+            return { type: 'batch', success: response.success || 0, failed: response.failed || 0 };
           })
-        }, log);
-        log(`Stored full transcript (${transcriptData.messages.length} messages, ${transcriptData.total_turns} total turns, truncated: ${transcriptData.truncated})`);
-      }
-    } catch (e) {
-      // Reliability: Log but don't fail hook if transcript storage fails
-      log(`Failed to store full transcript: ${e.message}`);
+          .catch(e => {
+            log(`❌ Batch ${batchIndex + 1}/${chunks.length} failed: ${e.message}`);
+            return { type: 'batch', success: 0, failed: chunk.length };
+          })
+      );
+    }
+  } else if (!stop_hook_active && !skipHeavyUpload) {
+    log('No events to log from transcript');
+    // No events but cursor may have advanced (all filtered) — safe to save
+    if (cursor) {
+      await saveStopCursor(session_id, cursor, log);
     }
-  } else {
-    const reason = !STOP_FULL_INGEST_ENABLED ? 'full ingest disabled' : 'timeline probe unhealthy';
-    log(`Skipping transcript storage because ${reason}`);
   }
 
-  // 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 fetchWithTimeout(`${RELAY_API_URL}/api/messages/pending?session_id=${encodeURIComponent(session_id)}`, {
+  // 2. Store full transcript
+  if (transcriptData && transcriptData.messages && transcriptData.messages.length > 0) {
+    httpTasks.push(
+      fetchJsonWithRetry(`${RELAY_API_URL}/api/sessions/${session_id}/transcript`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${RELAY_API_KEY}`
+        },
+        body: JSON.stringify({
+          messages: transcriptData.messages,
+          total_turns: transcriptData.total_turns,
+          truncated: transcriptData.truncated,
+          original_size: transcriptData.original_size,
+          stored_at: Date.now()
+        })
+      }, log)
+        .then(() => {
+          log(`Stored full transcript (${transcriptData.messages.length} messages, ${transcriptData.total_turns} total turns, truncated: ${transcriptData.truncated})`);
+          return { type: 'transcript', success: true };
+        })
+        .catch(e => {
+          log(`Failed to store full transcript: ${e.message}`);
+          return { type: 'transcript', success: false };
+        })
+    );
+  }
+
+  // 3. Check for pending messages from mobile app
+  httpTasks.push(
+    fetchWithTimeout(`${RELAY_API_URL}/api/messages/pending?session_id=${encodeURIComponent(session_id)}`, {
       headers: { 'Authorization': `Bearer ${RELAY_API_KEY}` }
-    });
-    if (res.ok) {
-      const msg = await res.json();
-      if (msg && msg.id && msg.text) {
-        log(`Found pending message: ${String(msg.text).slice(0, 50)}...`);
-        try {
-          await fetchWithTimeout(`${RELAY_API_URL}/api/messages/${msg.id}/ack`, {
-            method: 'POST',
-            headers: { 'Authorization': `Bearer ${RELAY_API_KEY}` }
-          });
-        } catch {}
+    })
+      .then(async res => {
+        if (res.ok) {
+          const msg = await res.json();
+          if (msg && msg.id && msg.text) {
+            log(`Found pending message: ${String(msg.text).slice(0, 50)}...`);
+            try {
+              await fetchWithTimeout(`${RELAY_API_URL}/api/messages/${msg.id}/ack`, {
+                method: 'POST',
+                headers: { 'Authorization': `Bearer ${RELAY_API_KEY}` }
+              });
+            } catch {}
+            log(`Acknowledged pending message (mobile message injection not supported in stop hook)`);
+            return { type: 'messages', found: true };
+          }
+        }
+        return { type: 'messages', found: false };
+      })
+      .catch(e => {
+        log(`Error checking pending messages: ${e.message}`);
+        return { type: 'messages', found: false };
+      })
+  );
+
+  // Wait for all HTTP calls to complete
+  const results = await Promise.allSettled(httpTasks);
+
+  // Surface any unexpected rejections (each task has .catch(), but defense-in-depth)
+  const rejected = results.filter(r => r.status === 'rejected');
+  if (rejected.length > 0) {
+    log(`⚠️ ${rejected.length} HTTP task(s) rejected unexpectedly: ${rejected.map(r => r.reason?.message || r.reason).join(', ')}`);
+  }
 
-        // 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);
-      }
+  // Log batch totals
+  const batchResults = results
+    .filter(r => r.status === 'fulfilled' && r.value?.type === 'batch')
+    .map(r => r.value);
+  if (batchResults.length > 0) {
+    const totalSuccess = batchResults.reduce((sum, r) => sum + r.success, 0);
+    const totalFailed = batchResults.reduce((sum, r) => sum + r.failed, 0);
+    log(`✅ Total: ${totalSuccess} success, ${totalFailed} failed (${batchResults.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)`);
     }
-  } catch (e) {
-    log(`Error checking pending messages: ${e.message}`);
+  }
+
+  // Log transcript storage failure for visibility
+  const transcriptResult = results.find(r => r.status === 'fulfilled' && r.value?.type === 'transcript');
+  if (transcriptResult && !transcriptResult.value.success) {
+    log(`⚠️ Transcript storage failed - timeline events were still logged separately`);
   }
 
   log('Stop hook completed');

package/.claude/hooks/user_prompt_submit.mjs

@@ -46,9 +46,7 @@ const fetchJson = async (url, opts) => {
 
   const { session_id, prompt } = input;
 
-  // Detect message source
-  const isAutonomousTask = env.TELEPORTATION_TASK_MODE === 'true' || !!env.TELEPORTATION_PARENT_SESSION_ID;
-  const source = isAutonomousTask ? 'autonomous_task' : 'cli_interactive';
+  const source = 'cli_interactive';
 
   // Clear away mode only on actual user activity (prompt submit), not on tool attempts.
   // Also support /away and /back here in case they are handled as prompts.