@hailer/mcp 1.2.0 → 2.0.0-beta.1

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

@@ -1,724 +0,0 @@
-"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