teleportation-cli 1.2.2 → 1.4.0

package/.claude/hooks/session-register.mjs

@@ -34,9 +34,10 @@ async function loadVersionInfo() {
  * @param {string} session_id - Session ID (also Claude session ID)
  * @param {string} cwd - Current working directory
  * @param {object} config - Config object with relayApiUrl and relayApiKey
+ * @param {object} [preExtractedMetadata] - Pre-extracted metadata to avoid duplicate extraction
  * @returns {Promise<boolean|object>} - True if registered successfully, or error object if orphan
  */
-export async function ensureSessionRegistered(session_id, cwd, config) {
+export async function ensureSessionRegistered(session_id, cwd, config, preExtractedMetadata = null) {
   const RELAY_API_URL = config.relayApiUrl || '';
   const RELAY_API_KEY = config.relayApiKey || '';
 
@@ -65,36 +66,43 @@ export async function ensureSessionRegistered(session_id, cwd, config) {
     console.error(`[SessionRegister] Registering session ${session_id}`);
   }
 
-  // Extract enhanced session metadata
-  let metadata = { cwd, claude_session_id: session_id };
-  try {
-    // Try to load metadata extraction module
-    const possiblePaths = [
-      join(__dirname, '..', '..', 'lib', 'session', 'metadata.js'),
-      join(process.env.HOME || process.env.USERPROFILE || '', '.teleportation', 'lib', 'session', 'metadata.js'),
-      './lib/session/metadata.js'
-    ];
+  // Use pre-extracted metadata if provided (avoids duplicate git subprocess calls)
+  let metadata;
+  if (preExtractedMetadata && Object.keys(preExtractedMetadata).length > 0) {
+    metadata = { ...preExtractedMetadata, session_id, claude_session_id: session_id };
+    if (env.DEBUG) {
+      console.error('[SessionRegister] Using pre-extracted metadata (skipping re-extraction)');
+    }
+  } else {
+    // Fallback: extract metadata (for callers that don't provide it)
+    metadata = { cwd, claude_session_id: session_id };
+    try {
+      const possiblePaths = [
+        join(__dirname, '..', '..', 'lib', 'session', 'metadata.js'),
+        join(process.env.HOME || process.env.USERPROFILE || '', '.teleportation', 'lib', 'session', 'metadata.js'),
+        './lib/session/metadata.js'
+      ];
 
-    let metadataModule = null;
-    for (const path of possiblePaths) {
-      try {
-        metadataModule = await import('file://' + path);
-        break;
-      } catch (e) {
-        // Try next path
+      let metadataModule = null;
+      for (const path of possiblePaths) {
+        try {
+          metadataModule = await import('file://' + path);
+          break;
+        } catch (e) {
+          // Try next path
+        }
       }
-    }
 
-    if (metadataModule && metadataModule.extractSessionMetadata && cwd) {
-      const extracted = await metadataModule.extractSessionMetadata(cwd);
-      extracted.session_id = session_id;
-      extracted.claude_session_id = session_id; // Include Claude session ID for autonomous task resumption
-      metadata = extracted;
-    }
-  } catch (e) {
-    // If metadata extraction fails, fall back to basic metadata
-    if (env.DEBUG) {
-      console.error('[SessionRegister] Failed to extract metadata:', e.message);
+      if (metadataModule && metadataModule.extractSessionMetadata && cwd) {
+        const extracted = await metadataModule.extractSessionMetadata(cwd);
+        extracted.session_id = session_id;
+        extracted.claude_session_id = session_id;
+        metadata = extracted;
+      }
+    } catch (e) {
+      if (env.DEBUG) {
+        console.error('[SessionRegister] Failed to extract metadata:', e.message);
+      }
     }
   }
 

package/.claude/hooks/session_end.mjs

@@ -40,9 +40,7 @@ const readStdin = () => new Promise((resolve, reject) => {
   const DAEMON_PORT = config.daemonPort || env.TELEPORTATION_DAEMON_PORT || '3050';
   const DAEMON_ENABLED = config.daemonEnabled !== false && env.TELEPORTATION_DAEMON_ENABLED !== 'false';
 
-  // 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';
 
   const updateSessionDaemonState = async (updates) => {
     if (!session_id || !RELAY_API_URL || !RELAY_API_KEY) return;

package/.claude/hooks/session_start.mjs

@@ -196,7 +196,7 @@ function updateSessionMarker(sessionId) {
         ].filter(Boolean);
 
         // Import fs/promises once outside the loop
-        const { access } = await import('fs/promises');
+        const { access, readFile } = await import('fs/promises');
         let daemonScript = null;
         for (const location of possibleLocations) {
           try {
@@ -217,6 +217,20 @@ function updateSessionMarker(sessionId) {
           return exit(0);
         }
 
+        // Staleness check: detect outdated daemon that imports removed heartbeat-manager module
+        try {
+          const daemonSource = await readFile(daemonScript, 'utf-8');
+          if (/require\s*\(\s*['"]\.\/heartbeat-manager(?:\.js)?['"]\s*\)|from\s+['"]\.\/heartbeat-manager(?:\.js)?['"]/.test(daemonSource)) {
+            console.error('[SessionStart] ⚠️  Installed daemon is stale (imports removed heartbeat-manager module).');
+            console.error('[SessionStart] Run: teleportation install-hooks');
+            // Continue without daemon rather than crash
+            try { process.stdout.write(JSON.stringify({ suppressOutput: true })); } catch {}
+            return exit(0);
+          }
+        } catch {
+          // If we can't read the file, let agentStart handle the error
+        }
+
         // Start daemon using agent-runtime
         // This handles retries, health checks, and platform-native service installation
         try {

package/.claude/hooks/stop.mjs

@@ -479,58 +479,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 +664,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 +729,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 +1131,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 +1155,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 +1185,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.