teleportation-cli 1.3.0 → 1.4.1

package/lib/daemon/timeline-analyzer.js

@@ -16,7 +16,7 @@
 export async function fetchTimeline(session_id, config) {
   const { relayApiUrl, apiKey } = config;
 
-  const response = await fetch(`${relayApiUrl}/api/timeline/${session_id}`, {
+  const response = await fetch(`${relayApiUrl}/api/sessions/${session_id}/timeline`, {
     headers: { 'Authorization': `Bearer ${apiKey}` }
   });
 
@@ -36,7 +36,7 @@ export async function fetchTimeline(session_id, config) {
  */
 export function analyzeTaskState(events, task_id) {
   // Filter events for this specific task
-  const taskEvents = events.filter(e => e.meta?.task_id === task_id);
+  const taskEvents = events.filter(e => e.data?.task_id === task_id);
 
   if (taskEvents.length === 0) {
     return {
@@ -53,16 +53,17 @@ export function analyzeTaskState(events, task_id) {
 
   const lastEvent = taskEvents[taskEvents.length - 1];
 
-  // Count turns (each assistant_response indicates a completed turn)
+  // Count turns (each assistant_response with matching task_id indicates a completed turn)
+  // Note: relay stores source inside data object, not at event top level
   const turn_count = taskEvents.filter(e =>
-    e.type === 'assistant_response' && e.source === 'autonomous_task'
+    e.type === 'assistant_response'
   ).length;
 
   // Find the latest claude_session_id from task execution
   let claude_session_id = null;
   for (let i = taskEvents.length - 1; i >= 0; i--) {
-    if (taskEvents[i].meta?.claude_session_id) {
-      claude_session_id = taskEvents[i].meta.claude_session_id;
+    if (taskEvents[i].data?.claude_session_id) {
+      claude_session_id = taskEvents[i].data.claude_session_id;
       break;
     }
   }
@@ -72,7 +73,7 @@ export function analyzeTaskState(events, task_id) {
     e.type === 'approval_requested' &&
     !taskEvents.some(later =>
       later.type === 'approval_decided' &&
-      later.meta?.approval_id === e.meta?.approval_id
+      later.data?.approval_id === e.data?.approval_id
     )
   );
 
@@ -93,7 +94,7 @@ export function analyzeTaskState(events, task_id) {
       state: 'paused',
       turn_count,
       ready_for_execution: false,
-      reason: lastEvent.meta?.reason || 'Task paused',
+      reason: lastEvent.data?.reason || 'Task paused',
       claude_session_id,
       waiting_for_user_message: true,
     };
@@ -105,7 +106,7 @@ export function analyzeTaskState(events, task_id) {
       state: 'stopped',
       turn_count,
       ready_for_execution: false,
-      reason: lastEvent.meta?.reason || 'Task stopped',
+      reason: lastEvent.data?.reason || 'Task stopped',
       claude_session_id,
     };
   }
@@ -134,7 +135,7 @@ export function analyzeTaskState(events, task_id) {
   // If last event is assistant_response, ready for next turn
   // Use stop_reason to determine if Claude is done (works like CLI)
   if (lastEvent.type === 'assistant_response') {
-    const stopReason = lastEvent.meta?.stop_reason;
+    const stopReason = lastEvent.data?.stop_reason;
 
     // Claude uses "end_turn" when it's done with the current turn and waiting for input
     // This is the natural stopping point, just like in the CLI
@@ -183,9 +184,14 @@ export function getNextPrompt(state, task) {
     return task.task;
   }
 
-  // If paused and resumed with user message, use that message
-  if (task.pending_question) {
-    return task.pending_question;
+  // If resumed with a user answer/message, use that as the prompt
+  if (task.pending_answer) {
+    return task.pending_answer;
+  }
+
+  // If redirected with new instructions, use those
+  if (task.pending_redirect) {
+    return task.pending_redirect;
   }
 
   // Default continuation prompt

package/lib/daemon/transcript-ingestion.js

@@ -7,9 +7,12 @@
  * @module lib/daemon/transcript-ingestion
  */
 
-import { readFile, readdir } from 'fs/promises';
+import { readFile, readdir, writeFile, mkdir, appendFile } from 'fs/promises';
 import { homedir, tmpdir } from 'os';
 import { join } from 'path';
+import { createHash } from 'node:crypto';
+import { sanitizeEventData } from '../utils/log-sanitizer.js';
+import { normalizeTranscriptEvents, normalizeTranscriptEntry } from '../intelligence/schema.js';
 
 // ============================================================================
 // Configuration Constants
@@ -131,6 +134,69 @@ const RETRY_BASE_DELAY_MS = 100;
  * Set TELEPORTATION_DEBUG=true to enable verbose logging to tmpdir()
  */
 const DEBUG = process.env.TELEPORTATION_DEBUG === 'true';
+const ENABLE_REMOTE_INTELLIGENCE_INGEST = process.env.TELEPORTATION_INTELLIGENCE_REMOTE_INGEST === 'true';
+const ENABLE_LOCAL_INTELLIGENCE_SPOOL = process.env.TELEPORTATION_INTELLIGENCE_LOCAL_SPOOL !== 'false';
+const INTELLIGENCE_SPOOL_DIR = join(tmpdir(), 'teleportation-intelligence');
+const INTELLIGENCE_BATCH_PATH = '/api/intelligence/transcripts/batch';
+
+/**
+ * Generate a deterministic UUID-formatted event ID from an input string and event index.
+ * Uses the same sha256 + UUID-dash format as stop.mjs for consistency, enabling
+ * server-side deduplication via ON CONFLICT (id) DO NOTHING.
+ *
+ * Format: 8-4-4-4-12 hex characters (matches stop.mjs deterministicEventId)
+ *
+ * @param {string} input - Unique input (msg UUID or session:msg:event composite key)
+ * @param {number} eventIndex - Event index within the message
+ * @returns {string} UUID-formatted hex string (36 characters with dashes)
+ */
+function deterministicEventId(input, eventIndex) {
+  const hash = createHash('sha256').update(`${input}:${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('-');
+}
+
+/**
+ * Local cursor directory for tracking last-processed transcript index.
+ * Persists across daemon restarts so we don't reprocess the entire transcript.
+ */
+const CURSOR_DIR = join(tmpdir(), 'teleportation-cursors');
+
+/**
+ * Read the local ingestion cursor for a session.
+ * Returns the last successfully processed transcript message count.
+ * @param {string} sessionId - Session ID
+ * @returns {Promise<number>} Last processed message count (0 if no cursor)
+ */
+async function readCursor(sessionId) {
+  try {
+    const cursorPath = join(CURSOR_DIR, `${sessionId}.json`);
+    const data = JSON.parse(await readFile(cursorPath, 'utf8'));
+    return data.lastMessageCount || 0;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Write the local ingestion cursor after successful push.
+ * @param {string} sessionId - Session ID
+ * @param {number} messageCount - Total transcript messages processed
+ * @param {number} eventsPushed - Events successfully pushed this cycle
+ */
+async function writeCursor(sessionId, messageCount, eventsPushed) {
+  try {
+    await mkdir(CURSOR_DIR, { recursive: true });
+    const cursorPath = join(CURSOR_DIR, `${sessionId}.json`);
+    await writeFile(cursorPath, JSON.stringify({
+      lastMessageCount: messageCount,
+      lastEventsPushed: eventsPushed,
+      updatedAt: new Date().toISOString()
+    }));
+  } catch (e) {
+    // Non-fatal — next cycle will just reprocess some events
+    console.warn(`[transcript] Failed to write cursor for ${sessionId}: ${e.message}`);
+  }
+}
 
 /**
  * Sleep helper for retry backoff
@@ -236,6 +302,10 @@ async function pushEventsInChunks(events, relayApiUrl, apiKey, parent_session_id
           events: chunk.map(event => ({
             type: event.type,
             source: event.source,
+            // Top-level timestamp and id for relay batch endpoint
+            // (logTimelineEventsBatch accepts clientTimestamp and clientId)
+            timestamp: event.timestamp,
+            id: event.id || undefined,
             data: {
               ...event.meta,
               task_id,
@@ -275,11 +345,16 @@ async function pushEventsInChunks(events, relayApiUrl, apiKey, parent_session_id
               session_id: parent_session_id,
               type: event.type,
               source: event.source,
+              // Top-level timestamp and id kept for forward-compat; also inside data
+              // because relay's /api/timeline passes only `data` to logTimelineEvent()
+              timestamp: event.timestamp,
+              id: event.id || undefined,
               data: {
                 ...event.meta,
                 task_id,
                 claude_session_id,
                 timestamp: event.timestamp,
+                id: event.id || undefined,
               }
             })
           });
@@ -328,7 +403,31 @@ function parseTimestamp(entry) {
     return Date.now();
   }
 
-  const parsed = new Date(entry.timestamp).getTime();
+  const ts = entry.timestamp;
+
+  // Handle numeric string timestamps (epoch ms as string, e.g. "1771211826406")
+  // new Date("1771211826406") returns Invalid Date, so detect and convert first
+  if (typeof ts === 'string' && /^\d+$/.test(ts)) {
+    const numeric = Number(ts);
+    const now = Date.now();
+    if (numeric > now - TIMESTAMP_MAX_AGE_MS && numeric < now + TIMESTAMP_MAX_AGE_MS) {
+      return numeric;
+    }
+    console.warn(`[transcript] Numeric string timestamp out of range: ${ts}, using current time`);
+    return Date.now();
+  }
+
+  // Handle numeric timestamps directly
+  if (typeof ts === 'number') {
+    const now = Date.now();
+    if (ts > now - TIMESTAMP_MAX_AGE_MS && ts < now + TIMESTAMP_MAX_AGE_MS) {
+      return ts;
+    }
+    console.warn(`[transcript] Numeric timestamp out of range: ${ts}, using current time`);
+    return Date.now();
+  }
+
+  const parsed = new Date(ts).getTime();
 
   // Validate timestamp is reasonable (not NaN, not in distant past/future)
   if (isNaN(parsed)) {
@@ -353,9 +452,10 @@ function parseTimestamp(entry) {
  * Supports both old format (message at root) and new format (message nested)
  * @param {Array} transcript - Transcript messages
  * @param {number} fromIndex - Start extracting from this index (to avoid duplicates)
- * @returns {Array} Timeline events to push
+ * @param {string} sessionId - Session ID for deterministic fallback IDs (when entry has no uuid)
+ * @returns {Array} Timeline events to push (each with deterministic `id` field)
  */
-function extractTimelineEvents(transcript, fromIndex = 0) {
+function extractTimelineEvents(transcript, fromIndex = 0, sessionId = '') {
   const events = [];
 
   console.log(`[transcript] extractTimelineEvents: processing ${transcript.length - fromIndex} messages from index ${fromIndex}`);
@@ -385,6 +485,13 @@ function extractTimelineEvents(transcript, fromIndex = 0) {
     const content = message.content;
     const timestamp = parseTimestamp(entry);
 
+    // Deterministic ID generation (Bug 3):
+    // Use entry.uuid (Claude Code transcript UUID) when available,
+    // fall back to entry.message.uuid, or a composite key from sessionId:messageIndex.
+    const msgUuid = entry.uuid || message.uuid || null;
+    const msgKey = msgUuid || `${sessionId}:${i}`;
+    let msgEventIndex = 0;
+
     // Extract assistant responses
     // Schema matches stop hook batch: data.message (canonical field name)
     if (role === 'assistant' && content) {
@@ -396,8 +503,9 @@ function extractTimelineEvents(transcript, fromIndex = 0) {
       if (trimmedContent) {
         events.push({
           type: 'assistant_response',
-          source: entry.type === 'autonomous_task' ? 'autonomous_task' : 'cli_interactive',
+          source: 'cli_interactive',
           timestamp,
+          id: deterministicEventId(msgKey, msgEventIndex++),
           meta: {
             message: trimmedContent.slice(0, MAX_ASSISTANT_RESPONSE_LENGTH),
             full_length: trimmedContent.length,
@@ -418,8 +526,9 @@ function extractTimelineEvents(transcript, fromIndex = 0) {
       for (const toolUse of toolUses) {
         events.push({
           type: 'tool_use',
-          source: entry.type === 'autonomous_task' ? 'autonomous_task' : 'cli_interactive',
+          source: 'cli_interactive',
           timestamp,
+          id: deterministicEventId(msgKey, msgEventIndex++),
           meta: {
             tool_name: toolUse.name,
             tool_use_id: toolUse.id,
@@ -448,8 +557,9 @@ function extractTimelineEvents(transcript, fromIndex = 0) {
 
         events.push({
           type: isError ? 'tool_failed' : 'tool_completed',
-          source: entry.type === 'autonomous_task' ? 'autonomous_task' : 'cli_interactive',
+          source: 'cli_interactive',
           timestamp,
+          id: deterministicEventId(msgKey, msgEventIndex++),
           meta: {
             tool_use_id: toolResult.tool_use_id,
             tool_name: toolInfo?.name || null,
@@ -465,7 +575,29 @@ function extractTimelineEvents(transcript, fromIndex = 0) {
   }
 
   console.log(`[transcript] extractTimelineEvents: found ${events.length} events`);
-  return events;
+
+  // Sanitize all event meta to redact secrets (API keys, tokens, passwords, etc.)
+  return events.map(event => ({
+    ...event,
+    meta: sanitizeEventData(event.meta),
+  }));
+}
+
+/**
+ * Convert timeline events to canonical transcript intelligence events.
+ * Returns [] on normalization failures to preserve ingestion behavior.
+ *
+ * @param {Array} events - Raw timeline events from extractTimelineEvents
+ * @param {Object} context - Normalization context
+ * @returns {Array} Normalized intelligence events
+ */
+function normalizeTimelineEventsForIntelligence(events, context = {}) {
+  try {
+    return normalizeTranscriptEvents(events, context);
+  } catch (error) {
+    console.warn(`[transcript] Intelligence normalization failed: ${error.message}`);
+    return [];
+  }
 }
 
 /**
@@ -531,12 +663,13 @@ async function updateLastIngestedIndex(task_id, session_id, lastIndex, config) {
  * @param {string} options.task_id - Task ID (for event metadata)
  * @param {string} options.cwd - Working directory (to derive project slug)
  * @param {Object} options.config - Config with relayApiUrl, apiKey
+ * @param {Function} [options.onNormalizedEvents] - Optional callback for normalized intelligence events
  * @param {boolean} options.realTimeMode - If true, only process last 10 events (fast, for hooks)
  * @param {number} options.maxEvents - Maximum events to process (default: 100 for daemon, 10 for realTime)
  * @returns {Promise<Object>} Result { events_pushed: number }
  */
 export async function ingestTranscriptToTimeline(options) {
-  const { claude_session_id, parent_session_id, task_id, cwd, config, realTimeMode = false, maxEvents } = options;
+  const { claude_session_id, parent_session_id, task_id, cwd, config, onNormalizedEvents, realTimeMode = false, maxEvents } = options;
   const { relayApiUrl, apiKey } = config;
 
   // Determine max events based on mode
@@ -573,14 +706,22 @@ export async function ingestTranscriptToTimeline(options) {
   let fromIndex = 0;
 
   if (task_id) {
-    // For tasks: Use task's last ingested index
+    // For tasks: Use task's last ingested index, fall back to local cursor if fetchTask fails
     const task = await fetchTask(task_id, parent_session_id, config);
-    fromIndex = task?.last_transcript_index || 0;
-    console.log(`[transcript] Using task's last ingested index: ${fromIndex}`);
+    if (task?.last_transcript_index != null) {
+      fromIndex = task.last_transcript_index;
+      console.log(`[transcript] Using task's last ingested index: ${fromIndex}`);
+    } else {
+      // fetchTask returned null (network error) or task has no index — use local cursor
+      // Use claude_session_id as cursor key for tasks (each task has unique child session)
+      fromIndex = await readCursor(claude_session_id);
+      console.log(`[transcript] Task fetch failed or no index — using local cursor: ${fromIndex}`);
+    }
   } else {
-    // For regular sessions: Query timeline to find recent events for deduplication
-    // Queries last 50 events (not just 1) to catch concurrent hook/daemon ingestion
-    // This prevents duplicates when hook and daemon run simultaneously
+    // For regular sessions: Use local cursor as primary deduplication,
+    // with timeline query as validation
+    const cursorMessageCount = await readCursor(parent_session_id);
+    console.log(`[transcript] Local cursor: ${cursorMessageCount} messages previously processed`);
     console.log(`[transcript] Querying timeline for session ${parent_session_id} to find recent events...`);
     try {
       const timelineResponse = await fetch(
@@ -599,54 +740,93 @@ export async function ingestTranscriptToTimeline(options) {
         console.log(`[transcript] Timeline returned ${timelineEvents.length} events`);
 
         if (timelineEvents.length > 0 && timelineEvents[0].timestamp) {
-          const lastTimestamp = timelineEvents[0].timestamp;
-          console.log(`[transcript] Last timeline event timestamp: ${lastTimestamp} (${new Date(lastTimestamp).toISOString()})`);
-
-          // Sample first and last transcript timestamps
-          if (transcript.length > 0) {
-            const firstMsg = transcript[0];
-            const lastMsg = transcript[transcript.length - 1];
-            console.log(`[transcript] First transcript msg: ${firstMsg.timestamp}`);
-            console.log(`[transcript] Last transcript msg: ${lastMsg.timestamp}`);
-          }
-
-          // Find the index of the first message after this timestamp
-          fromIndex = transcript.findIndex(msg => {
-            const msgTimestamp = new Date(msg.timestamp || 0).getTime();
-            return msgTimestamp > lastTimestamp;
-          });
-
-          // If not found, start from end of transcript (all messages are older)
-          if (fromIndex === -1) {
-            log(`All messages older than last timeline event (${new Date(lastTimestamp).toISOString()}) - no new events`);
-            console.log(`[transcript] All ${transcript.length} messages are older than last timeline event - no new events to ingest`);
-            fromIndex = transcript.length;
+          // Timeline API returns timestamps as string epoch ms (e.g. "1771211826406")
+          // Must parse as number — new Date("1771211826406") returns Invalid Date
+          const rawTimestamp = timelineEvents[0].timestamp;
+          const lastTimestamp = typeof rawTimestamp === 'string' && /^\d+$/.test(rawTimestamp)
+            ? Number(rawTimestamp)
+            : typeof rawTimestamp === 'number'
+              ? rawTimestamp
+              : new Date(rawTimestamp).getTime();
+
+          if (isNaN(lastTimestamp)) {
+            console.log(`[transcript] Could not parse timeline timestamp: ${rawTimestamp} - using local cursor`);
+            fromIndex = cursorMessageCount;
           } else {
-            log(`Found ${transcript.length - fromIndex} new messages starting from index ${fromIndex}/${transcript.length}`);
-            console.log(`[transcript] Found ${transcript.length - fromIndex} new messages starting from index ${fromIndex}/${transcript.length}`);
+            console.log(`[transcript] Last timeline event timestamp: ${lastTimestamp} (${new Date(lastTimestamp).toISOString()})`);
+
+            // Find the index of the first message after this timestamp
+            fromIndex = transcript.findIndex(msg => {
+              const msgTs = msg.timestamp;
+              // Transcript timestamps are ISO strings like "2026-02-15T16:10:42.035Z"
+              // or may be missing (undefined)
+              const msgTimestamp = !msgTs ? 0
+                : typeof msgTs === 'number' ? msgTs
+                : typeof msgTs === 'string' && /^\d+$/.test(msgTs) ? Number(msgTs)
+                : new Date(msgTs).getTime() || 0;
+              return msgTimestamp > lastTimestamp;
+            });
+
+            // If not found, start from end of transcript (all messages are older)
+            if (fromIndex === -1) {
+              log(`All messages older than last timeline event (${new Date(lastTimestamp).toISOString()}) - no new events`);
+              console.log(`[transcript] All ${transcript.length} messages are older than last timeline event - no new events to ingest`);
+              fromIndex = transcript.length;
+            } else {
+              log(`Found ${transcript.length - fromIndex} new messages starting from index ${fromIndex}/${transcript.length}`);
+              console.log(`[transcript] Found ${transcript.length - fromIndex} new messages starting from index ${fromIndex}/${transcript.length}`);
+            }
           }
         } else {
-          console.log(`[transcript] No timeline events found - will process all transcript messages`);
-          fromIndex = 0;
+          // No timeline events — use local cursor to avoid reprocessing
+          fromIndex = cursorMessageCount;
+          if (cursorMessageCount > 0) {
+            console.log(`[transcript] No timeline events found - using local cursor (${cursorMessageCount})`);
+          } else {
+            console.log(`[transcript] No timeline events and no cursor - processing all transcript messages`);
+          }
         }
       } else {
-        console.log(`[transcript] Timeline query failed with status ${timelineResponse.status} - processing all messages`);
-        fromIndex = 0;
+        fromIndex = cursorMessageCount;
+        console.log(`[transcript] Timeline query failed (${timelineResponse.status}) - using local cursor (${cursorMessageCount})`);
       }
     } catch (error) {
-      console.log(`[transcript] Failed to query timeline: ${error.message}, processing all messages`);
-      fromIndex = 0;
+      fromIndex = cursorMessageCount;
+      console.log(`[transcript] Failed to query timeline: ${error.message} - using local cursor (${cursorMessageCount})`);
     }
   }
 
+  // Clamp fromIndex to transcript length to prevent stale cursors from
+  // skipping past the end of a shorter transcript (e.g., cursor=500, transcript has 100 messages)
+  if (fromIndex > transcript.length) {
+    console.warn(`[transcript] Clamping fromIndex from ${fromIndex} to transcript length ${transcript.length} — cursor may be stale or transcript truncated`);
+    fromIndex = transcript.length;
+  }
+
   // 3. Extract only NEW events from determined index
-  const allEvents = extractTimelineEvents(transcript, fromIndex);
+  const allEvents = extractTimelineEvents(transcript, fromIndex, parent_session_id);
 
   log(`Extracted ${allEvents.length} events from transcript`);
+
   if (allEvents.length === 0) {
     log(`No new events since index ${fromIndex} - returning`);
     console.log(`[transcript] No new events since index ${fromIndex} (transcript length: ${transcript.length})`);
-    return { events_pushed: 0 };
+    return { events_pushed: 0, normalized_events: 0 };
+  }
+
+  const normalizedEvents = normalizeTimelineEventsForIntelligence(allEvents, {
+    session_id: parent_session_id,
+    task_id,
+    provider: 'claude-code',
+  });
+
+  log(`Normalized ${normalizedEvents.length} intelligence events`);
+  if (typeof onNormalizedEvents === 'function') {
+    try {
+      await onNormalizedEvents(normalizedEvents);
+    } catch (error) {
+      log(`Failed to deliver normalized events: ${error.message}`);
+    }
   }
 
   // 4. Limit events to process (most recent N events)
@@ -677,12 +857,19 @@ export async function ingestTranscriptToTimeline(options) {
   log(`===== INGESTION COMPLETE: ${successCount}/${events.length} events pushed (${failCount} failed) =====`);
   console.log(`[transcript] Pushed ${successCount}/${events.length} events (${failCount} failed)`);
 
-  // 6. Update last ingested index to prevent duplicates on next call (tasks only)
-  if (task_id && successCount > 0) {
-    await updateLastIngestedIndex(task_id, parent_session_id, transcript.length, config);
+  // 6. Update cursors to prevent duplicates on next call
+  if (successCount > 0) {
+    // Local cursor — use claude_session_id for tasks (unique per child session),
+    // parent_session_id for regular sessions (maps to transcript file)
+    const cursorKey = task_id ? claude_session_id : parent_session_id;
+    await writeCursor(cursorKey, transcript.length, successCount);
+    // Remote cursor (tasks only) — persists in relay
+    if (task_id) {
+      await updateLastIngestedIndex(task_id, parent_session_id, transcript.length, config);
+    }
   }
 
-  return { events_pushed: successCount, events_failed: failCount };
+  return { events_pushed: successCount, events_failed: failCount, normalized_events: normalizedEvents.length };
 }
 
 /**
@@ -694,3 +881,75 @@ export async function getTranscriptLength(claude_session_id) {
   const transcript = await readTranscript(claude_session_id);
   return transcript.length;
 }
+
+// Export internals for unit testing
+/**
+ * Extract normalized transcript entries for the intelligence pipeline.
+ * Operates on raw transcript messages (not timeline events).
+ */
+function extractNormalizedTranscriptEntries(transcript, fromIndex = 0, sessionId = '', harness = 'claude-code') {
+  const normalized = [];
+  for (let i = fromIndex; i < transcript.length; i++) {
+    normalized.push(normalizeTranscriptEntry(transcript[i], {
+      sessionId,
+      messageIndex: i,
+      harness,
+    }));
+  }
+  return normalized;
+}
+
+function toSessionFilename(sessionId) {
+  const safe = typeof sessionId === 'string' && sessionId.trim()
+    ? sessionId.trim().replace(/[^a-zA-Z0-9._-]/g, '-')
+    : 'unknown-session';
+  return `${safe}.jsonl`;
+}
+
+/**
+ * Append normalized transcript entries to a local JSONL spool file.
+ * Enabled by default; disable with TELEPORTATION_INTELLIGENCE_LOCAL_SPOOL=false.
+ */
+async function appendLocalIntelligenceSpool(sessionId, entries, log = () => {}) {
+  if (!ENABLE_LOCAL_INTELLIGENCE_SPOOL || entries.length === 0) {
+    return { written: 0, skipped: true };
+  }
+  await mkdir(INTELLIGENCE_SPOOL_DIR, { recursive: true });
+  const filePath = join(INTELLIGENCE_SPOOL_DIR, toSessionFilename(sessionId));
+  const lines = entries.map(entry => JSON.stringify(entry)).join('\n') + '\n';
+  await appendFile(filePath, lines, 'utf8');
+  log(`Wrote ${entries.length} normalized entries to local spool: ${filePath}`);
+  return { written: entries.length, skipped: false, filePath };
+}
+
+/**
+ * Push normalized transcript entries to the relay intelligence endpoint.
+ * Off by default; enable with TELEPORTATION_INTELLIGENCE_REMOTE_INGEST=true.
+ */
+async function pushNormalizedEntriesRemote(entries, relayApiUrl, apiKey, sessionId, log = () => {}) {
+  if (!ENABLE_REMOTE_INTELLIGENCE_INGEST || entries.length === 0) {
+    return { pushed: 0, skipped: true };
+  }
+  try {
+    const response = await fetch(`${relayApiUrl}${INTELLIGENCE_BATCH_PATH}`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify({ session_id: sessionId, entries }),
+    });
+    if (!response.ok) {
+      const body = await response.text().catch(() => '');
+      console.warn(`[transcript] Intelligence remote ingest failed: ${response.status} ${body}`);
+      return { pushed: 0, skipped: false, failed: true, status: response.status };
+    }
+    log(`Pushed ${entries.length} normalized entries to remote intelligence endpoint`);
+    return { pushed: entries.length, skipped: false };
+  } catch (error) {
+    console.warn(`[transcript] Intelligence remote ingest error: ${error.message}`);
+    return { pushed: 0, skipped: false, failed: true, error: error.message };
+  }
+}
+
+export { parseTimestamp, extractTimelineEvents, extractNormalizedTranscriptEntries, readCursor, writeCursor, pushEventsInChunks, deterministicEventId, normalizeTimelineEventsForIntelligence, appendLocalIntelligenceSpool, pushNormalizedEntriesRemote };

package/lib/daemon/utils.js

@@ -33,15 +33,6 @@ export function truncateOutput(output, label) {
   return output.slice(0, MAX_OUTPUT_SIZE) + `\n\n... (output truncated, total size: ${output.length} characters) ...`;
 }
 
-/**
- * Sanitize for log (remove sensitive info)
- */
-export function sanitizeForLog(data) {
-  if (!data) return data;
-  // Simple sanitization - in a real app, use a more robust library
-  return String(data).replace(/Bearer\s+[a-zA-Z0-9._-]+/g, 'Bearer [REDACTED]');
-}
-
 /**
  * Validation helpers
  */