@hailer/mcp 1.1.14 → 1.1.16

package/dist/agents/shared/services/session-logger.js

@@ -0,0 +1,724 @@
+"use strict";
+/**
+ * Session Logger Service
+ *
+ * Manages per-activity session tracking and logging to Hailer workflows:
+ * - Tracks metrics (tokens, tool calls, messages)
+ * - Logs completed sessions to SESSION_LOG workflow
+ * - Manages idle session detection and flushing
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionLoggerService = void 0;
+const types_1 = require("../../shared/types");
+class SessionLoggerService {
+    agentDirectoryId;
+    logger;
+    callMcpTool;
+    getDefaultTeamId;
+    activitySessions = new Map();
+    lastGlobalLogId = null;
+    idleCheckTimer = null;
+    anthropicClient = null;
+    schemaCache = null;
+    _currentWorkspaceId = null;
+    constructor(agentDirectoryId, logger, callMcpTool, getDefaultTeamId) {
+        this.agentDirectoryId = agentDirectoryId;
+        this.logger = logger;
+        this.callMcpTool = callMcpTool;
+        this.getDefaultTeamId = getDefaultTeamId;
+    }
+    /**
+     * Set the workspace schema cache for dynamic ID lookup
+     */
+    setSchemaCache(cache, workspaceId) {
+        this.schemaCache = cache;
+        this._currentWorkspaceId = workspaceId;
+    }
+    /**
+     * Get Session Log schema from cache for a specific workspace
+     */
+    getSessionLogSchema(workspaceId) {
+        if (!this.schemaCache || !workspaceId) {
+            return null;
+        }
+        return this.schemaCache.getSessionLogSchema(workspaceId) || null;
+    }
+    /**
+     * Set Anthropic client for generating summaries
+     */
+    setAnthropicClient(client) {
+        this.anthropicClient = client;
+    }
+    /**
+     * Get or create an activity session for tracking
+     * Multi-tenant: workspaceId is required for proper schema lookup
+     */
+    getOrCreateActivitySession(message) {
+        // Use linked activity ID as key, fallback to discussion ID
+        const sessionKey = message.linkedActivityId || message.discussionId;
+        let session = this.activitySessions.get(sessionKey);
+        if (!session) {
+            session = {
+                activityId: message.linkedActivityId || "",
+                activityName: message.linkedActivityName || `Discussion ${message.discussionId.substring(0, 8)}`,
+                discussionId: message.discussionId,
+                workspaceId: message.workspaceId, // Multi-tenant: store workspace for this session
+                startTime: Date.now(),
+                lastActivityTime: Date.now(),
+                metrics: {
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    cacheCreationTokens: 0,
+                    cacheReadTokens: 0,
+                    toolCalls: 0,
+                    writeOperations: 0,
+                    messagesProcessed: 0,
+                    responsesPosted: 0,
+                    apiCalls: 0,
+                },
+                actions: [],
+                previousLogId: this.lastGlobalLogId,
+                conversation: [],
+                writeDetails: [],
+                triggerRequest: null,
+                requestedBy: null,
+                requestedById: null,
+            };
+            this.activitySessions.set(sessionKey, session);
+            this.logger.debug("Created new activity session", {
+                sessionKey,
+                workspaceId: message.workspaceId,
+                activityName: session.activityName,
+            });
+        }
+        return session;
+    }
+    /**
+     * Get session by key
+     */
+    getSession(key) {
+        return this.activitySessions.get(key);
+    }
+    /**
+     * Get all active sessions
+     */
+    getActiveSessions() {
+        return new Map(this.activitySessions);
+    }
+    /**
+     * Check for idle sessions and flush them
+     * Called periodically by timer
+     */
+    async checkAndFlushIdleSessions() {
+        const now = Date.now();
+        const sessionsToFlush = [];
+        for (const [key, session] of this.activitySessions) {
+            const idleTime = now - session.lastActivityTime;
+            if (idleTime >= types_1.SESSION_IDLE_TIMEOUT) {
+                sessionsToFlush.push(key);
+            }
+        }
+        for (const key of sessionsToFlush) {
+            const session = this.activitySessions.get(key);
+            if (session) {
+                await this.flushActivitySession(key, session);
+                this.activitySessions.delete(key);
+            }
+        }
+        if (sessionsToFlush.length > 0) {
+            this.logger.debug("Flushed idle sessions", { count: sessionsToFlush.length });
+        }
+    }
+    /**
+     * Flush a single activity session to the session log
+     * Set DISABLE_SESSION_LOG=true to skip persistence (saves 20+ tokens per session)
+     */
+    async flushActivitySession(_key, session) {
+        // Check if session logging is disabled via env var
+        if (process.env.DISABLE_SESSION_LOG === 'true') {
+            this.logger.debug("Skipping session log - disabled via DISABLE_SESSION_LOG", {
+                activity: session.activityName,
+                metrics: session.metrics,
+            });
+            return;
+        }
+        // Only log if API calls were made (skip sessions with no activity)
+        if (session.metrics.apiCalls === 0) {
+            this.logger.debug("Skipping session log - no API calls", {
+                activity: session.activityName,
+            });
+            return;
+        }
+        // Get dynamic schema for this session's workspace
+        const schema = this.getSessionLogSchema(session.workspaceId);
+        if (!schema) {
+            this.logger.debug("Skipping session log - no Session Log workflow in workspace", {
+                workspaceId: session.workspaceId,
+            });
+            return;
+        }
+        if (!this.agentDirectoryId) {
+            this.logger.debug("Skipping session log - no agent directory ID");
+            return;
+        }
+        try {
+            // Build descriptive session name from first write operation
+            let sessionName;
+            if (session.writeDetails.length > 0) {
+                sessionName = session.writeDetails[0].what;
+            }
+            else {
+                sessionName = session.activityName || `Session ${new Date().toISOString()}`;
+            }
+            // Generate session metadata (headline, topics, entities, outcome, summary)
+            const metadata = await this.generateSessionMetadata(session);
+            const summary = await this.buildActivitySessionSummary(session, metadata);
+            // Calculate total tokens and cost
+            const { inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens } = session.metrics;
+            const totalTokens = inputTokens + outputTokens + cacheCreationTokens + cacheReadTokens;
+            const cost = this.calculateCost(inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens);
+            // Get field IDs from schema (use our standard keys that were mapped)
+            const contextSummaryFieldId = schema.fields["contextSummary"] || schema.fields["Context summary"];
+            const madeByFieldId = schema.fields["madeBy"] || schema.fields["Log entry made by"];
+            const costFieldId = schema.fields["cost"] || schema.fields["Tokens Used"];
+            const previousLogFieldId = schema.fields["previousLog"] || schema.fields["Previus log entry"];
+            const linkedWorkFieldId = schema.fields["linkedWork"] || schema.fields["Most relevant link to work"];
+            // New billing field IDs (looked up by key from schema)
+            const uncachedTokensFieldId = schema.fields["uncachedTokens"];
+            const cachedTokensFieldId = schema.fields["cachedTokens"];
+            const outputTokensFieldId = schema.fields["outputTokens"];
+            const cacheHitRateFieldId = schema.fields["cacheHitRate"];
+            const costUsdFieldId = schema.fields["costUsd"];
+            const apiCallsFieldId = schema.fields["apiCalls"];
+            const durationSecFieldId = schema.fields["durationSec"];
+            const writeOperationsFieldId = schema.fields["writeOperations"];
+            // Memory metadata field IDs (for smart retrieval)
+            const headlineFieldId = schema.fields["headline"];
+            const topicsFieldId = schema.fields["topics"];
+            const entitiesFieldId = schema.fields["entities"];
+            const outcomeFieldId = schema.fields["outcome"];
+            const discussionIdFieldId = schema.fields["discussionId"];
+            // Calculate metrics
+            const sessionDuration = Math.round((Date.now() - session.startTime) / 1000);
+            const cacheHitPct = totalTokens > 0
+                ? Math.round((cacheReadTokens / (inputTokens + cacheCreationTokens + cacheReadTokens)) * 100)
+                : 0;
+            // Build fields
+            const fields = {};
+            // Context summary (just the conversation summary, not stats)
+            if (contextSummaryFieldId) {
+                fields[contextSummaryFieldId] = summary;
+            }
+            if (madeByFieldId && this.agentDirectoryId) {
+                fields[madeByFieldId] = this.agentDirectoryId;
+            }
+            if (costFieldId) {
+                fields[costFieldId] = totalTokens;
+            }
+            // Billing fields (separate columns for reporting) - only if fields exist in schema
+            if (uncachedTokensFieldId) {
+                fields[uncachedTokensFieldId] = inputTokens + cacheCreationTokens; // tokens charged at full/125% rate
+            }
+            if (cachedTokensFieldId) {
+                fields[cachedTokensFieldId] = cacheReadTokens;
+            }
+            if (outputTokensFieldId) {
+                fields[outputTokensFieldId] = outputTokens;
+            }
+            if (cacheHitRateFieldId) {
+                fields[cacheHitRateFieldId] = cacheHitPct;
+            }
+            if (costUsdFieldId) {
+                fields[costUsdFieldId] = parseFloat(cost.toFixed(6)); // Store as number for aggregation
+            }
+            if (apiCallsFieldId) {
+                fields[apiCallsFieldId] = session.metrics.apiCalls;
+            }
+            if (durationSecFieldId) {
+                fields[durationSecFieldId] = sessionDuration;
+            }
+            if (writeOperationsFieldId) {
+                fields[writeOperationsFieldId] = session.metrics.writeOperations;
+            }
+            // Chain to previous log
+            if (session.previousLogId && previousLogFieldId) {
+                fields[previousLogFieldId] = session.previousLogId;
+            }
+            // Link to activity being worked on
+            if (session.activityId && linkedWorkFieldId) {
+                fields[linkedWorkFieldId] = session.activityId;
+            }
+            // Memory metadata fields (for smart retrieval)
+            if (metadata) {
+                if (headlineFieldId && metadata.headline) {
+                    fields[headlineFieldId] = metadata.headline;
+                }
+                if (topicsFieldId && metadata.topics) {
+                    fields[topicsFieldId] = metadata.topics;
+                }
+                if (entitiesFieldId && metadata.entities) {
+                    fields[entitiesFieldId] = metadata.entities;
+                }
+                if (outcomeFieldId && metadata.outcome) {
+                    fields[outcomeFieldId] = metadata.outcome;
+                }
+            }
+            // Store discussionId for filtering/retrieval
+            if (discussionIdFieldId && session.discussionId) {
+                fields[discussionIdFieldId] = session.discussionId;
+            }
+            // Get phase ID (try "active" first, then first available)
+            const phaseId = schema.phases["active"] || Object.values(schema.phases)[0];
+            const createParams = {
+                workflowId: schema.workflowId,
+                name: sessionName,
+                phaseId,
+                fields,
+            };
+            const wsTeamId = this.getDefaultTeamId();
+            if (wsTeamId) {
+                createParams.teamId = wsTeamId;
+            }
+            const result = await this.callMcpTool("create_activity", createParams);
+            // Extract created ID for chaining
+            const resultText = result?.content?.[0]?.text;
+            if (resultText) {
+                const idMatch = resultText.match(/"_id":\s*"([a-f0-9]{24})"/i) ||
+                    resultText.match(/`([a-f0-9]{24})`/);
+                if (idMatch) {
+                    this.lastGlobalLogId = idMatch[1];
+                }
+            }
+            const durationSec = Math.round((Date.now() - session.startTime) / 1000);
+            const cacheHitRate = totalTokens > 0
+                ? Math.round((cacheReadTokens / (inputTokens + cacheCreationTokens + cacheReadTokens)) * 100)
+                : 0;
+            this.logger.info("Activity session logged", {
+                activity: session.activityName,
+                durationSec,
+                messages: session.metrics.messagesProcessed,
+                toolCalls: session.metrics.toolCalls,
+                tokens: totalTokens,
+                cacheHitRate: `${cacheHitRate}%`,
+                costUsd: `$${cost.toFixed(4)}`,
+            });
+        }
+        catch (error) {
+            this.logger.warn("Failed to flush activity session", {
+                activity: session.activityName,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    /**
+     * Flush all active sessions (called on shutdown)
+     */
+    async flushAllSessions() {
+        for (const [key, session] of this.activitySessions) {
+            await this.flushActivitySession(key, session);
+        }
+        this.activitySessions.clear();
+    }
+    /**
+     * Build summary for an activity session
+     * Uses pre-generated metadata if available
+     */
+    async buildActivitySessionSummary(session, metadata) {
+        const lines = [];
+        // Who requested this
+        if (session.requestedBy) {
+            lines.push(`**Requested by:** ${session.requestedBy}`);
+        }
+        // What they asked for
+        if (session.triggerRequest) {
+            lines.push(`**Request:** "${session.triggerRequest}"`);
+        }
+        // What was changed (write operations only)
+        if (session.writeDetails.length > 0) {
+            lines.push("");
+            lines.push(`**Changes made:**`);
+            for (const detail of session.writeDetails) {
+                lines.push(`- ${detail.what}`);
+            }
+        }
+        // Use metadata summary if available, otherwise generate one
+        const conversationSummary = metadata?.summary || await this.generateConversationSummary(session);
+        if (conversationSummary) {
+            lines.push("");
+            lines.push(`**Conversation:** ${conversationSummary}`);
+        }
+        // Stats are now in separate fields, so just return the context summary
+        return lines.join("\n");
+    }
+    /**
+     * Calculate cost in USD based on Haiku 4.5 pricing
+     * - Input (uncached): $0.80 / 1M tokens
+     * - Output: $4.00 / 1M tokens
+     * - Cache creation: $1.00 / 1M tokens (125% of input)
+     * - Cache read: $0.08 / 1M tokens (10% of input)
+     */
+    calculateCost(inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens) {
+        const inputCost = (inputTokens / 1_000_000) * 0.80;
+        const outputCost = (outputTokens / 1_000_000) * 4.00;
+        const cacheCreationCost = (cacheCreationTokens / 1_000_000) * 1.00;
+        const cacheReadCost = (cacheReadTokens / 1_000_000) * 0.08;
+        return inputCost + outputCost + cacheCreationCost + cacheReadCost;
+    }
+    /**
+     * Start periodic idle session checking
+     */
+    startIdleCheckTimer(intervalMs = 30_000) {
+        if (this.idleCheckTimer) {
+            clearInterval(this.idleCheckTimer);
+        }
+        this.idleCheckTimer = setInterval(() => {
+            this.checkAndFlushIdleSessions().catch(err => {
+                this.logger.warn("Error checking idle sessions", { error: err });
+            });
+        }, intervalMs);
+    }
+    /**
+     * Stop idle check timer
+     */
+    stopIdleCheckTimer() {
+        if (this.idleCheckTimer) {
+            clearInterval(this.idleCheckTimer);
+            this.idleCheckTimer = null;
+        }
+    }
+    // ===== MEMORY SYSTEM =====
+    /**
+     * Sanitize string to remove invalid Unicode surrogate pairs
+     * These can cause JSON parsing errors in the Anthropic API
+     */
+    sanitizeString(str) {
+        // Remove unpaired surrogates (invalid Unicode)
+        // eslint-disable-next-line no-control-regex
+        return str.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, '');
+    }
+    /**
+     * Generate conversation summary AND metadata for memory retrieval
+     * Returns structured data for smart session recall
+     */
+    async generateSessionMetadata(session) {
+        if (!this.anthropicClient || session.conversation.length === 0) {
+            return null;
+        }
+        try {
+            // Sanitize conversation to remove invalid Unicode that causes JSON parsing errors
+            const sanitizedConversation = session.conversation
+                .map(msg => this.sanitizeString(msg))
+                .join("\n");
+            const response = await this.anthropicClient.messages.create({
+                model: "claude-haiku-4-5-20251001",
+                max_tokens: 600,
+                messages: [
+                    {
+                        role: "user",
+                        content: `Analyze this conversation and extract memory metadata. Return JSON only, no other text.
+
+Conversation:
+${sanitizedConversation}
+
+Return this exact JSON structure:
+{
+  "headline": "1-sentence summary, max 50 chars",
+  "topics": "comma-separated tags like: workflow, bug, insight, app, setup, question, config, data, report",
+  "entities": "specific names mentioned: workflow names, app names, user names",
+  "outcome": "one of: resolved, pending, escalated, info",
+  "summary": "2-3 sentence summary of what was discussed and accomplished"
+}
+
+JSON:`,
+                    },
+                ],
+            });
+            const textBlock = response.content.find((b) => b.type === "text");
+            if (!textBlock?.text) {
+                return null;
+            }
+            // Parse JSON response
+            const jsonMatch = textBlock.text.match(/\{[\s\S]*\}/);
+            if (!jsonMatch) {
+                this.logger.warn("Failed to parse session metadata JSON", { response: textBlock.text.substring(0, 200) });
+                return null;
+            }
+            const metadata = JSON.parse(jsonMatch[0]);
+            // Validate and truncate
+            return {
+                headline: (metadata.headline || "").substring(0, 60),
+                topics: (metadata.topics || "").substring(0, 200),
+                entities: (metadata.entities || "").substring(0, 200),
+                outcome: ["resolved", "pending", "escalated", "info"].includes(metadata.outcome)
+                    ? metadata.outcome
+                    : "info",
+                summary: (metadata.summary || "").substring(0, 1000),
+            };
+        }
+        catch (error) {
+            this.logger.warn("Failed to generate session metadata", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return null;
+        }
+    }
+    /**
+     * Generate a conversation summary using LLM (legacy, uses new method internally)
+     */
+    async generateConversationSummary(session) {
+        const metadata = await this.generateSessionMetadata(session);
+        return metadata?.summary || null;
+    }
+    /**
+     * Load memory entries for an activity from SESSION_LOG
+     * Returns past conversation summaries for context injection
+     *
+     * NOTE: ActivityLink fields store objects {_id, name}, so we fetch recent
+     * session logs and filter client-side by checking the nested _id.
+     */
+    async loadMemoryForActivity(activityId, workspaceId, limit = 5) {
+        if (!activityId || !workspaceId) {
+            return [];
+        }
+        // Get dynamic schema for this workspace
+        const schema = this.getSessionLogSchema(workspaceId);
+        if (!schema) {
+            this.logger.debug("Cannot load memory - no Session Log workflow in workspace", { workspaceId });
+            return [];
+        }
+        // Get field IDs from schema
+        const contextSummaryFieldId = schema.fields["contextSummary"] || schema.fields["Context summary"];
+        const linkedWorkFieldId = schema.fields["linkedWork"] || schema.fields["Most relevant link to work"];
+        const phaseId = schema.phases["active"] || Object.values(schema.phases)[0];
+        if (!contextSummaryFieldId || !linkedWorkFieldId || !phaseId) {
+            this.logger.debug("Cannot load memory - missing required fields in schema");
+            return [];
+        }
+        try {
+            // Query SESSION_LOG for recent sessions (fetch more to filter client-side)
+            // ActivityLink filters don't work with simple equals, so we filter after
+            const result = await this.callMcpTool("list_activities", {
+                workflowId: schema.workflowId,
+                phaseId,
+                fields: [contextSummaryFieldId, linkedWorkFieldId],
+                limit: 50, // Fetch more, filter client-side
+                sortBy: "created",
+                sortOrder: "desc",
+            });
+            const resultText = result?.content?.[0]?.text;
+            if (!resultText) {
+                return [];
+            }
+            // Parse the response to extract memory entries
+            const entries = [];
+            // Try to parse as JSON array
+            try {
+                const parsed = JSON.parse(resultText);
+                const activities = parsed.activities || parsed.data || parsed;
+                if (Array.isArray(activities)) {
+                    for (const activity of activities) {
+                        // Get linkedWork field - it's an ActivityLink with nested {_id, name}
+                        const linkedWorkField = activity.fields?.[linkedWorkFieldId];
+                        const linkedWorkId = linkedWorkField?.value?._id || linkedWorkField?._id;
+                        // Filter: only include entries linked to our target activity
+                        if (linkedWorkId !== activityId) {
+                            continue;
+                        }
+                        // Get context summary
+                        const summaryField = activity.fields?.[contextSummaryFieldId];
+                        const summary = summaryField?.value || summaryField;
+                        if (summary) {
+                            // Extract conversation summary section if present
+                            const conversationMatch = summary.match(/\*\*Conversation:\*\*\s*([\s\S]*?)(?=\n\n\*\*|---\n|$)/);
+                            const memorySummary = conversationMatch?.[1]?.trim() || summary;
+                            entries.push({
+                                sessionId: activity._id,
+                                timestamp: activity.created || Date.now(),
+                                summary: memorySummary,
+                                linkedActivityId: activityId,
+                            });
+                            // Stop once we have enough
+                            if (entries.length >= limit) {
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            catch {
+                // Not JSON, try regex extraction (fallback)
+                this.logger.debug("Failed to parse as JSON, using regex fallback");
+            }
+            this.logger.debug("Loaded memory entries", {
+                activityId,
+                count: entries.length,
+            });
+            return entries;
+        }
+        catch (error) {
+            this.logger.warn("Failed to load memory for activity", {
+                activityId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return [];
+        }
+    }
+    /**
+     * Format memory entries for injection into conversation context
+     */
+    formatMemoryForContext(entries) {
+        if (entries.length === 0) {
+            return "";
+        }
+        const lines = ["<previous_memory>", "Past interactions with this activity:"];
+        for (const entry of entries) {
+            const date = new Date(entry.timestamp).toLocaleDateString();
+            lines.push(`- [${date}] ${entry.summary}`);
+        }
+        lines.push("</previous_memory>");
+        return lines.join("\n");
+    }
+    /**
+     * Load memory headlines for a discussion (for smart context injection)
+     * Returns lightweight headlines instead of full summaries
+     *
+     * @param discussionId - Discussion to load memory for
+     * @param workspaceId - Workspace context
+     * @param options - Search options
+     */
+    async loadMemoryForDiscussion(discussionId, workspaceId, options = {}) {
+        const { limit = 3, keywords, maxAgeDays = 7 } = options;
+        if (!discussionId || !workspaceId) {
+            return [];
+        }
+        const schema = this.getSessionLogSchema(workspaceId);
+        if (!schema) {
+            this.logger.debug("Cannot load memory - no Session Log workflow", { workspaceId });
+            return [];
+        }
+        // Get field IDs
+        const headlineFieldId = schema.fields["headline"];
+        const topicsFieldId = schema.fields["topics"];
+        const outcomeFieldId = schema.fields["outcome"];
+        const discussionIdFieldId = schema.fields["discussionId"];
+        const phaseId = schema.phases["active"] || Object.values(schema.phases)[0];
+        if (!headlineFieldId || !discussionIdFieldId || !phaseId) {
+            this.logger.debug("Cannot load memory - missing required fields (headline, discussionId)");
+            return [];
+        }
+        try {
+            // Build query params
+            const queryParams = {
+                workflowId: schema.workflowId,
+                phaseId,
+                fields: [headlineFieldId, topicsFieldId, outcomeFieldId, discussionIdFieldId].filter(Boolean),
+                limit: 20, // Fetch more to filter client-side
+                sortBy: "created",
+                sortOrder: "desc",
+            };
+            // Add keyword search if provided
+            if (keywords && topicsFieldId) {
+                queryParams.search = keywords;
+            }
+            const result = await this.callMcpTool("list_activities", queryParams);
+            const resultText = result?.content?.[0]?.text;
+            if (!resultText) {
+                return [];
+            }
+            const entries = [];
+            const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1000;
+            const cutoffTime = Date.now() - maxAgeMs;
+            try {
+                // Extract JSON from response
+                const jsonMatch = resultText.match(/\[[\s\S]*\]/);
+                if (!jsonMatch) {
+                    return [];
+                }
+                const activities = JSON.parse(jsonMatch[0]);
+                for (const activity of activities) {
+                    // Filter by discussionId
+                    const actDiscussionId = activity.fieldsAndValues?.find((f) => f.fieldId === discussionIdFieldId)?.value || activity.fields?.[discussionIdFieldId]?.value;
+                    if (actDiscussionId !== discussionId) {
+                        continue;
+                    }
+                    // Filter by age
+                    const created = activity.created || Date.now();
+                    if (created < cutoffTime) {
+                        continue;
+                    }
+                    // Extract fields
+                    const headline = activity.fieldsAndValues?.find((f) => f.fieldId === headlineFieldId)?.value || activity.fields?.[headlineFieldId]?.value || "";
+                    const topics = activity.fieldsAndValues?.find((f) => f.fieldId === topicsFieldId)?.value || activity.fields?.[topicsFieldId]?.value || "";
+                    const outcome = activity.fieldsAndValues?.find((f) => f.fieldId === outcomeFieldId)?.value || activity.fields?.[outcomeFieldId]?.value || "info";
+                    if (headline) {
+                        entries.push({
+                            sessionId: activity._id,
+                            timestamp: created,
+                            headline,
+                            topics,
+                            outcome,
+                        });
+                    }
+                    if (entries.length >= limit) {
+                        break;
+                    }
+                }
+            }
+            catch (parseError) {
+                this.logger.debug("Failed to parse memory response", { error: parseError });
+            }
+            this.logger.debug("Loaded memory headlines", {
+                discussionId: discussionId.substring(0, 8),
+                count: entries.length,
+            });
+            return entries;
+        }
+        catch (error) {
+            this.logger.warn("Failed to load memory for discussion", {
+                discussionId: discussionId.substring(0, 8),
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return [];
+        }
+    }
+    /**
+     * Format memory headlines for context injection (lightweight)
+     * Returns ~50 tokens for 3 entries
+     */
+    formatHeadlinesForContext(entries) {
+        if (entries.length === 0) {
+            return "";
+        }
+        const lines = ["[Recent context from this conversation]"];
+        for (const entry of entries) {
+            const ago = this.formatTimeAgo(entry.timestamp);
+            const status = entry.outcome !== "info" ? ` (${entry.outcome})` : "";
+            lines.push(`• ${ago}: ${entry.headline}${status}`);
+        }
+        return lines.join("\n");
+    }
+    /**
+     * Format timestamp as relative time (e.g., "2h ago", "yesterday")
+     */
+    formatTimeAgo(timestamp) {
+        const now = Date.now();
+        const diffMs = now - timestamp;
+        const diffMins = Math.floor(diffMs / 60000);
+        const diffHours = Math.floor(diffMs / 3600000);
+        const diffDays = Math.floor(diffMs / 86400000);
+        if (diffMins < 60) {
+            return `${diffMins}m ago`;
+        }
+        else if (diffHours < 24) {
+            return `${diffHours}h ago`;
+        }
+        else if (diffDays === 1) {
+            return "yesterday";
+        }
+        else {
+            return `${diffDays}d ago`;
+        }
+    }
+}
+exports.SessionLoggerService = SessionLoggerService;
+//# sourceMappingURL=session-logger.js.map