@ubundi/openclaw-cortex 2.9.1 → 2.9.2

package/dist/features/bridge/handler.js

@@ -0,0 +1,677 @@
+import { createHash } from "node:crypto";
+import { isHeartbeatTurn } from "../../internal/heartbeat-detect.js";
+import { filterConversationMessagesForMemory, shouldUseUserMessageForMemory, } from "../../internal/message-provenance.js";
+import { isLowSignal, sanitizeConversationText } from "../capture/filter.js";
+const LINK_STATUS_TTL_MS = 60_000;
+const HANDLED_REQUEST_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+const HANDLED_REQUEST_MAX = 1000;
+const MIN_ANSWER_CHARS = 5;
+const MAX_QUESTION_CHARS = 400;
+const MAX_ANSWER_CHARS = 5000;
+const MIN_REFLECTIVE_MESSAGE_CHARS = 24;
+const MIN_REFLECTIVE_MESSAGE_WORDS = 5;
+const BRIDGE_QUESTION_COOLDOWN_TURNS = 4;
+const BRIDGE_ANSWER_COOLDOWN_TURNS = 8;
+const BRIDGE_QUESTION_COOLDOWN_MS = 10 * 60 * 1000;
+const LOOKUP_SHAPE_RE = /^(?:what (?:is|are|does|do)|which|where|when|how (?:many|much|long))\b/i;
+const TECHNICAL_LOOKUP_RE = /\b(?:file|files|repo|repository|package|dependency|dependencies|endpoint|api|port|timeout|ttl|database|schema|migration|commit|branch|log(?:s)?|stack trace|error|test(?:s)?|env|environment variable|config|setting|settings|version|runtime|token|cache|enum|function|method|class|module|library|table|column|redis)\b/i;
+const LOW_SIGNAL_ANSWER_RE = /^(?:ok|okay|yes|no|maybe|not sure|i don't know|idk|sure|sounds good|thanks|thank you)[.!?]*$/i;
+const CLARIFYING_QUESTION_RE = /^(?:what|why|how|who|where|when|which|can|could|would|do|does|did|is|are|am|should|will|have|has)\b/i;
+const REFLECTIVE_OPENING_RE = /\b(?:i(?:'m| am)?\s+(?:rethinking|wondering|feeling|struggling|stuck|lost|burned out|burnt out|questioning)|i(?:'ve| have) been\s+(?:rethinking|wondering|feeling|struggling)|i(?:'m| am) trying to figure out\b|what matters to me\b|what i want from\b|who i am\b|my future\b|i want my (?:life|work|future)\b)\b/i;
+const REFLECTIVE_SIGNAL_RE = /\b(?:value|values|believe|belief|care about|important|meaningful|purpose|aligned|future|dream|dreams|hope|aspire|fear|afraid|stuck|burned out|burnt out|lost|curious|wondering|rethinking|figuring out|non-negotiable|remembered|fulfilling|matters most)\b/i;
+const PERSONAL_DISCOVERY_RE = /\b(?:about myself|for me|to me|who i am|my (?:life|work|future|career|purpose|values|identity)|what matters to me|what i want from|what would feel (?:meaningful|aligned)|how i want to be remembered)\b/i;
+const FIRST_PERSON_RE = /\b(?:i|i'm|i’ve|i've|me|my|myself)\b/i;
+const DIRECT_TASKING_RE = /\b(?:fix|debug|solve|implement|write|update|edit|change|refactor|add|remove|delete|check|review|look at|show me|tell me|give me|explain|run|test|build|deploy)\b/i;
+const TOOLING_HINT_RE = /\b(?:npm|pnpm|yarn|uv|pytest|vitest|tsc|git|docker|kubernetes|postgres|redis)\b/i;
+const CODEISH_HINT_RE = /`[^`]+`|\b[A-Za-z_][\w]*\([^)]*\)|=>|(?:^|\s)(?:\/|\.\/|\.\.\/)[\w./-]+/;
+const SECTION_HINTS = [
+    {
+        section: "coreValues",
+        patterns: [
+            /\bwhat do you value(?: most)?\b/i,
+            /\bwhat matters most to you\b/i,
+            /\bwhat do you care about(?: most)?\b/i,
+            /\bwhat feels most important to you\b/i,
+            /\bwhat makes .* feel meaningful\b/i,
+        ],
+        keywords: [
+            "value",
+            "values",
+            "matters most",
+            "care about",
+            "important to you",
+            "meaningful",
+            "worthwhile",
+            "drive",
+            "drives you",
+            "motivates",
+            "motivate",
+            "purpose",
+        ],
+    },
+    {
+        section: "beliefs",
+        patterns: [
+            /\bwhat do you believe\b/i,
+            /\bwhat belief(?:s)? shape\b/i,
+            /\bwhat feels true to you\b/i,
+            /\bwhat assumption(?:s)? do you carry\b/i,
+            /\bwhat worldview\b/i,
+        ],
+        keywords: ["believe", "belief", "beliefs", "true to you", "assumption", "assumptions", "worldview", "conviction"],
+    },
+    {
+        section: "principles",
+        patterns: [
+            /\bwhat principle(?:s)? guide you\b/i,
+            /\bwhat rule(?:s)? do you live by\b/i,
+            /\bwhat line won't you cross\b/i,
+            /\bwhat standard do you hold yourself to\b/i,
+            /\bwhat principle(?:s)? matter most\b/i,
+        ],
+        keywords: [
+            "principle",
+            "principles",
+            "rule",
+            "rules",
+            "standard",
+            "line won't",
+            "won't cross",
+            "boundary",
+            "boundaries",
+            "non-negotiable",
+            "non-negotiables",
+        ],
+    },
+    {
+        section: "ideas",
+        patterns: [
+            /\bwhat idea(?:s)? are you exploring\b/i,
+            /\bwhat idea(?:s)? keep pulling at you\b/i,
+            /\bwhat are you curious about\b/i,
+            /\bwhat do you want to (?:create|build|explore|learn)\b/i,
+            /\bwhat possibility excites you\b/i,
+        ],
+        keywords: ["idea", "ideas", "curious", "curiosity", "explore", "exploring", "build", "create", "possibility", "learn"],
+    },
+    {
+        section: "dreams",
+        patterns: [
+            /\bwhat do you dream about\b/i,
+            /\bwhat do you hope for\b/i,
+            /\bwhat do you want your (?:life|work|future)\b/i,
+            /\bwhat would your ideal\b/i,
+            /\bwhat future are you trying to build\b/i,
+        ],
+        keywords: ["dream", "dreams", "hope", "future", "ideal", "aspire", "aspiration", "want your life", "want your work"],
+    },
+    {
+        section: "practices",
+        patterns: [
+            /\bwhat practice(?:s)? keep you grounded\b/i,
+            /\bwhat habit(?:s)? help you\b/i,
+            /\bwhat routine(?:s)? matter most\b/i,
+            /\bhow do you stay grounded\b/i,
+            /\bhow do you keep yourself aligned\b/i,
+            /\bwhat helps you reset\b/i,
+        ],
+        keywords: ["practice", "practices", "habit", "habits", "routine", "routines", "ritual", "grounded", "aligned", "reset"],
+    },
+    {
+        section: "shadows",
+        patterns: [
+            /\bwhat fear(?:s)? keep showing up\b/i,
+            /\bwhat do you avoid\b/i,
+            /\bwhat gets in your own way\b/i,
+            /\bwhere do you hold yourself back\b/i,
+            /\bwhat insecurity\b/i,
+            /\bwhat part of yourself is hard to face\b/i,
+        ],
+        keywords: [
+            "fear",
+            "fears",
+            "avoid",
+            "avoiding",
+            "hold yourself back",
+            "gets in your own way",
+            "stuck",
+            "insecurity",
+            "shadow",
+            "self-sabotage",
+        ],
+    },
+    {
+        section: "legacy",
+        patterns: [
+            /\bhow do you want to be remembered\b/i,
+            /\bwhat impact do you want to leave\b/i,
+            /\bwhat do you want to leave behind\b/i,
+            /\bwhat contribution do you hope to make\b/i,
+            /\bwhat legacy\b/i,
+        ],
+        keywords: ["remembered", "impact", "leave behind", "legacy", "contribution", "outlast"],
+    },
+];
+function extractContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((block) => {
+            if (typeof block !== "object" || block === null)
+                return "";
+            const typed = block;
+            if (typed.type === "text" && typeof typed.text === "string")
+                return typed.text;
+            if (typed.type === "tool_result")
+                return extractContent(typed.content);
+            return "";
+        })
+            .filter(Boolean)
+            .join("\n");
+    }
+    return "";
+}
+function normalizeRequestText(text) {
+    return text.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function trimHandledRequests(handledRequestIds) {
+    const now = Date.now();
+    for (const [requestId, seenAt] of handledRequestIds) {
+        if (now - seenAt > HANDLED_REQUEST_TTL_MS)
+            handledRequestIds.delete(requestId);
+    }
+    if (handledRequestIds.size <= HANDLED_REQUEST_MAX)
+        return;
+    const stale = [...handledRequestIds.entries()]
+        .sort((a, b) => a[1] - b[1])
+        .slice(0, handledRequestIds.size - HANDLED_REQUEST_MAX);
+    for (const [requestId] of stale)
+        handledRequestIds.delete(requestId);
+}
+function countKeywordMatches(text, keywords) {
+    return keywords.reduce((total, keyword) => total + (text.includes(keyword) ? 1 : 0), 0);
+}
+function countWords(text) {
+    return text
+        .trim()
+        .split(/\s+/)
+        .filter(Boolean)
+        .length;
+}
+export function extractLastQuestion(text) {
+    const lines = text
+        .replace(/\r\n/g, "\n")
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const line = lines[i];
+        const lastQuestionIndex = line.lastIndexOf("?");
+        if (lastQuestionIndex === -1)
+            continue;
+        let candidate = line.slice(0, lastQuestionIndex + 1).trim();
+        const previousQuestionIndex = candidate.lastIndexOf("?", candidate.length - 2);
+        if (previousQuestionIndex !== -1) {
+            candidate = candidate.slice(previousQuestionIndex + 1).trim();
+        }
+        const boundary = Math.max(candidate.lastIndexOf(". "), candidate.lastIndexOf("! "), candidate.lastIndexOf(": "), candidate.lastIndexOf("; "));
+        if (boundary !== -1) {
+            candidate = candidate.slice(boundary + 2).trim();
+        }
+        candidate = candidate.replace(/^[>\-*•\d.)\s]+/, "").replace(/\s+/g, " ").trim();
+        if (candidate.endsWith("?"))
+            return candidate;
+    }
+    return undefined;
+}
+export function inferTargetSection(question) {
+    const normalized = question.replace(/\s+/g, " ").trim();
+    if (!normalized.endsWith("?"))
+        return undefined;
+    if (normalized.length === 0 || normalized.length > MAX_QUESTION_CHARS)
+        return undefined;
+    if (LOOKUP_SHAPE_RE.test(normalized) && TECHNICAL_LOOKUP_RE.test(normalized))
+        return undefined;
+    const scored = SECTION_HINTS
+        .map(({ section, patterns, keywords }, priority) => ({
+        section,
+        priority,
+        score: patterns.reduce((total, pattern) => total + (pattern.test(normalized) ? 2 : 0), 0) +
+            countKeywordMatches(normalized.toLowerCase(), keywords),
+    }))
+        .filter((entry) => entry.score > 0)
+        .sort((a, b) => b.score - a.score || a.priority - b.priority);
+    return scored[0]?.section;
+}
+function isExplicitAnswer(answer) {
+    const normalized = answer.replace(/\s+/g, " ").trim();
+    const withoutLeadIn = normalized.replace(/^(?:and|also|but|plus|so)[,\s]+/i, "");
+    if (normalized.length < MIN_ANSWER_CHARS || normalized.length > MAX_ANSWER_CHARS)
+        return false;
+    if (LOW_SIGNAL_ANSWER_RE.test(normalized))
+        return false;
+    if (isLowSignal(normalized))
+        return false;
+    if (withoutLeadIn.endsWith("?") && CLARIFYING_QUESTION_RE.test(withoutLeadIn))
+        return false;
+    return true;
+}
+function normalizeConversationMessages(messages) {
+    const candidates = filterConversationMessagesForMemory(messages.flatMap((message, index) => {
+        if (typeof message !== "object" || message === null)
+            return [];
+        const typed = message;
+        if (typed.role !== "assistant" && typed.role !== "user")
+            return [];
+        if (!("content" in typed))
+            return [];
+        return [{
+                role: typed.role,
+                content: typed.content,
+                provenance: typed.provenance,
+                originalIndex: index,
+            }];
+    }));
+    return candidates
+        .map((message) => ({
+        role: message.role,
+        content: sanitizeConversationText(extractContent(message.content)).replace(/\s+/g, " ").trim(),
+        originalIndex: message.originalIndex,
+        provenance: message.provenance,
+    }))
+        .filter((message) => message.content.length > 0);
+}
+function getLatestEligibleUserMessage(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i].role === "user")
+            return messages[i];
+    }
+    return undefined;
+}
+function looksTechnicalTurn(text) {
+    return (TECHNICAL_LOOKUP_RE.test(text) ||
+        TOOLING_HINT_RE.test(text) ||
+        CODEISH_HINT_RE.test(text));
+}
+function isReflectiveOpportunity(latestUserText, messages) {
+    const normalized = latestUserText.replace(/\s+/g, " ").trim();
+    if (normalized.length < MIN_REFLECTIVE_MESSAGE_CHARS)
+        return false;
+    if (countWords(normalized) < MIN_REFLECTIVE_MESSAGE_WORDS)
+        return false;
+    if (LOW_SIGNAL_ANSWER_RE.test(normalized))
+        return false;
+    if (isLowSignal(normalized))
+        return false;
+    if (looksTechnicalTurn(normalized))
+        return false;
+    if (DIRECT_TASKING_RE.test(normalized) && !REFLECTIVE_OPENING_RE.test(normalized))
+        return false;
+    if (REFLECTIVE_OPENING_RE.test(normalized))
+        return true;
+    if (FIRST_PERSON_RE.test(normalized) && (REFLECTIVE_SIGNAL_RE.test(normalized) || PERSONAL_DISCOVERY_RE.test(normalized))) {
+        return true;
+    }
+    const recentContext = messages
+        .slice(-4)
+        .map((message) => `${message.role}: ${message.content}`)
+        .join("\n");
+    return FIRST_PERSON_RE.test(recentContext) && PERSONAL_DISCOVERY_RE.test(recentContext) && REFLECTIVE_SIGNAL_RE.test(recentContext);
+}
+function buildBridgeQuestionId(input) {
+    return createHash("sha256")
+        .update(JSON.stringify({
+        v: 1,
+        sessionKey: input.sessionKey,
+        assistantIndex: input.assistantIndex,
+        question: normalizeRequestText(input.question),
+    }))
+        .digest("hex")
+        .slice(0, 32);
+}
+function detectBridgeQuestions(input) {
+    const normalized = normalizeConversationMessages(input.messages);
+    if (normalized.length === 0)
+        return [];
+    const questions = [];
+    const seenQuestionIds = new Set();
+    for (const message of normalized) {
+        if (message.role !== "assistant")
+            continue;
+        const question = extractLastQuestion(message.content);
+        if (!question)
+            continue;
+        const targetSection = inferTargetSection(question);
+        if (!targetSection)
+            continue;
+        const questionId = buildBridgeQuestionId({
+            sessionKey: input.sessionKey,
+            assistantIndex: message.originalIndex,
+            question,
+        });
+        if (seenQuestionIds.has(questionId))
+            continue;
+        seenQuestionIds.add(questionId);
+        questions.push({
+            question,
+            targetSection,
+            assistantIndex: message.originalIndex,
+            questionId,
+        });
+    }
+    return questions.sort((a, b) => a.assistantIndex - b.assistantIndex);
+}
+export function buildBridgeRequestId(input) {
+    const digest = createHash("sha256")
+        .update(JSON.stringify({
+        v: 1,
+        agentUserId: input.agentUserId,
+        sessionKey: input.sessionKey,
+        assistantIndex: input.assistantIndex,
+        userIndex: input.userIndex,
+        question: normalizeRequestText(input.question),
+        answer: normalizeRequestText(input.answer),
+    }))
+        .digest("hex")
+        .slice(0, 32);
+    return `openclaw-bridge-${digest}`;
+}
+export function detectBridgeExchanges(input) {
+    const normalized = normalizeConversationMessages(input.messages);
+    if (normalized.length < 2)
+        return [];
+    const exchanges = [];
+    const seenRequestIds = new Set();
+    for (let userCursor = normalized.length - 1; userCursor >= 0; userCursor--) {
+        if (normalized[userCursor].role !== "user")
+            continue;
+        const answer = normalized[userCursor].content;
+        if (!isExplicitAnswer(answer))
+            continue;
+        let priorAssistantIndex = -1;
+        for (let assistantCursor = userCursor - 1; assistantCursor >= 0; assistantCursor--) {
+            if (normalized[assistantCursor].role === "assistant") {
+                priorAssistantIndex = assistantCursor;
+                break;
+            }
+        }
+        if (priorAssistantIndex === -1)
+            continue;
+        const question = extractLastQuestion(normalized[priorAssistantIndex].content);
+        if (!question)
+            continue;
+        const targetSection = inferTargetSection(question);
+        if (!targetSection)
+            continue;
+        const assistantIndex = normalized[priorAssistantIndex].originalIndex;
+        const userIndex = normalized[userCursor].originalIndex;
+        const requestId = buildBridgeRequestId({
+            agentUserId: input.agentUserId,
+            sessionKey: input.sessionKey,
+            assistantIndex,
+            userIndex,
+            question,
+            answer,
+        });
+        if (seenRequestIds.has(requestId))
+            continue;
+        seenRequestIds.add(requestId);
+        exchanges.push({
+            question,
+            answer,
+            targetSection,
+            requestId,
+            assistantIndex,
+            userIndex,
+            sessionKey: input.sessionKey,
+        });
+    }
+    return exchanges.sort((a, b) => a.userIndex - b.userIndex);
+}
+export function detectBridgeExchange(input) {
+    return detectBridgeExchanges(input).at(-1);
+}
+export function buildTooTooBridgePrompt() {
+    return [
+        "<tootoo_bridge>",
+        "[NOTE: The current user linked this agent to TooToo. Treat this as behavioral guidance.]",
+        "When it fits the moment, you may ask one natural discovery question that grows out of the current conversation.",
+        "Keep it grounded in what the user is already discussing and do not derail practical help.",
+        "Prefer reflective questions about values, beliefs, principles, ideas, dreams, practices, shadows, or legacy.",
+        "Do not force a questionnaire or ask repeated discovery questions in back-to-back turns.",
+        "Only explicit user answers count. Do not infer or restate personal content the user did not clearly say.",
+        "</tootoo_bridge>",
+    ].join("\n");
+}
+function extractErrorStatusCode(err) {
+    const match = /\bfailed:\s*(\d{3})\b/.exec(String(err));
+    return match ? Number(match[1]) : undefined;
+}
+function isRetryableBridgeError(err) {
+    if (typeof err === "object" && err !== null && "name" in err && err.name === "AbortError") {
+        return true;
+    }
+    const message = String(err);
+    if (/AbortError/.test(message) ||
+        /Failed to fetch/i.test(message) ||
+        /fetch failed/i.test(message) ||
+        /network/i.test(message) ||
+        /ECONN|ENOTFOUND|ETIMEDOUT/i.test(message)) {
+        return true;
+    }
+    const status = extractErrorStatusCode(err);
+    return status === 429 || (status !== undefined && status >= 500);
+}
+export function createBridgeHandler(client, options) {
+    const { logger, retryQueue, getUserId, userIdReady, pluginSessionId, auditLogger, } = options;
+    let linkStatus = {
+        linked: false,
+        checkedAt: 0,
+    };
+    let pendingLinkStatusCheck = null;
+    const handledRequestIds = new Map();
+    const handledQuestionIds = new Map();
+    const sessionStates = new Map();
+    function resolveBridgeSessionKey(event) {
+        return event.sessionKey ?? event.sessionId ?? pluginSessionId ?? "__default__";
+    }
+    function getSessionState(sessionKey) {
+        let state = sessionStates.get(sessionKey);
+        if (!state) {
+            state = { userTurns: 0 };
+            sessionStates.set(sessionKey, state);
+        }
+        return state;
+    }
+    async function refreshLinkStatus(force = false) {
+        if (userIdReady)
+            await userIdReady;
+        const agentUserId = getUserId();
+        if (!agentUserId) {
+            linkStatus = { linked: false, checkedAt: Date.now() };
+            return linkStatus;
+        }
+        if (!force && pendingLinkStatusCheck)
+            return pendingLinkStatusCheck;
+        if (!force && linkStatus.checkedAt > 0 && Date.now() - linkStatus.checkedAt < LINK_STATUS_TTL_MS) {
+            return linkStatus;
+        }
+        pendingLinkStatusCheck = client.getLinkStatus(agentUserId)
+            .then((result) => {
+            const next = {
+                linked: result.linked,
+                checkedAt: Date.now(),
+            };
+            if (next.linked !== linkStatus.linked) {
+                logger.info(`Cortex bridge: TooToo link ${next.linked ? "active" : "inactive"}`);
+            }
+            linkStatus = next;
+            return next;
+        })
+            .catch((err) => {
+            logger.debug?.(`Cortex bridge: link status check failed: ${String(err)}`);
+            linkStatus = { ...linkStatus, checkedAt: Date.now() };
+            return linkStatus;
+        })
+            .finally(() => {
+            pendingLinkStatusCheck = null;
+        });
+        return pendingLinkStatusCheck;
+    }
+    async function getPromptContext() {
+        const status = await refreshLinkStatus();
+        return status.linked ? buildTooTooBridgePrompt() : undefined;
+    }
+    async function shouldInjectPrompt(event) {
+        if (isHeartbeatTurn(event.prompt ?? ""))
+            return false;
+        if (!Array.isArray(event.messages) || event.messages.length === 0)
+            return false;
+        const latestRawUser = [...event.messages]
+            .reverse()
+            .find((message) => (typeof message === "object" &&
+            message !== null &&
+            shouldUseUserMessageForMemory(message)));
+        if (!latestRawUser)
+            return false;
+        const normalizedMessages = normalizeConversationMessages(event.messages);
+        const latestUser = getLatestEligibleUserMessage(normalizedMessages);
+        if (!latestUser)
+            return false;
+        const sessionKey = resolveBridgeSessionKey(event);
+        const sessionState = getSessionState(sessionKey);
+        sessionState.userTurns += 1;
+        if (sessionState.lastAnsweredTurn != null &&
+            sessionState.userTurns - sessionState.lastAnsweredTurn < BRIDGE_ANSWER_COOLDOWN_TURNS) {
+            logger.debug?.(`Cortex bridge: prompt suppressed by answer cooldown sessionId=${sessionKey}`);
+            return false;
+        }
+        if (sessionState.lastQuestionTurn != null &&
+            sessionState.userTurns - sessionState.lastQuestionTurn < BRIDGE_QUESTION_COOLDOWN_TURNS) {
+            logger.debug?.(`Cortex bridge: prompt suppressed by turn cooldown sessionId=${sessionKey}`);
+            return false;
+        }
+        if (sessionState.lastQuestionAt != null &&
+            Date.now() - sessionState.lastQuestionAt < BRIDGE_QUESTION_COOLDOWN_MS) {
+            logger.debug?.(`Cortex bridge: prompt suppressed by time cooldown sessionId=${sessionKey}`);
+            return false;
+        }
+        if (!isReflectiveOpportunity(latestUser.content, normalizedMessages))
+            return false;
+        const status = await refreshLinkStatus();
+        if (!status.linked)
+            return false;
+        return true;
+    }
+    async function handleAgentEnd(event) {
+        if (event.aborted)
+            return false;
+        if (!Array.isArray(event.messages) || event.messages.length === 0)
+            return false;
+        if (userIdReady)
+            await userIdReady;
+        const agentUserId = getUserId();
+        if (!agentUserId)
+            return false;
+        const status = await refreshLinkStatus();
+        if (!status.linked)
+            return false;
+        trimHandledRequests(handledRequestIds);
+        trimHandledRequests(handledQuestionIds);
+        const sessionKey = resolveBridgeSessionKey(event);
+        const sessionState = getSessionState(sessionKey);
+        const questions = detectBridgeQuestions({
+            messages: event.messages,
+            sessionKey,
+        });
+        const latestNewQuestion = [...questions].reverse().find((question) => !handledQuestionIds.has(question.questionId));
+        if (latestNewQuestion) {
+            handledQuestionIds.set(latestNewQuestion.questionId, Date.now());
+            sessionState.lastQuestionTurn = sessionState.userTurns;
+            sessionState.lastQuestionAt = Date.now();
+        }
+        const exchanges = detectBridgeExchanges({
+            messages: event.messages,
+            agentUserId,
+            sessionKey,
+        });
+        const pendingExchanges = exchanges.filter((exchange) => {
+            if (handledRequestIds.has(exchange.requestId)) {
+                logger.debug?.(`Cortex bridge: duplicate exchange skipped requestId=${exchange.requestId}`);
+                return false;
+            }
+            return true;
+        });
+        if (pendingExchanges.length === 0)
+            return false;
+        const performSubmit = async (exchange) => {
+            const request = {
+                user_id: agentUserId,
+                request_id: exchange.requestId,
+                entries: [
+                    {
+                        question: exchange.question,
+                        answer: exchange.answer,
+                        target_section: exchange.targetSection,
+                    },
+                ],
+            };
+            if (auditLogger) {
+                await auditLogger.log({
+                    feature: "bridge-qa",
+                    method: "POST",
+                    endpoint: "/v1/bridge/qa",
+                    payload: JSON.stringify(request, null, 2),
+                    sessionId: exchange.sessionKey,
+                    userId: agentUserId,
+                    messageCount: 2,
+                });
+            }
+            const response = await client.submitBridgeQA(request);
+            if (!response.accepted) {
+                throw new Error(`Cortex bridge/qa failed: accepted=false requestId=${exchange.requestId}`);
+            }
+            logger.info(`Cortex bridge: accepted requestId=${exchange.requestId} forwarded=${response.forwarded} queuedForRetry=${response.queued_for_retry} entries=${response.entries_sent}`);
+        };
+        let handledAny = false;
+        for (const exchange of pendingExchanges) {
+            handledRequestIds.set(exchange.requestId, Date.now());
+            logger.info(`Cortex bridge: detected discovery exchange requestId=${exchange.requestId} sessionId=${exchange.sessionKey} section=${exchange.targetSection}`);
+            try {
+                await performSubmit(exchange);
+                handledAny = true;
+            }
+            catch (err) {
+                const statusCode = extractErrorStatusCode(err);
+                if (statusCode === 404) {
+                    linkStatus = {
+                        linked: false,
+                        checkedAt: Date.now(),
+                    };
+                }
+                if (retryQueue && isRetryableBridgeError(err)) {
+                    logger.warn(`Cortex bridge failed, queuing retry requestId=${exchange.requestId}: ${String(err)}`);
+                    retryQueue.enqueue(() => performSubmit(exchange), `bridge-${exchange.requestId}`);
+                    handledAny = true;
+                    continue;
+                }
+                logger.warn(`Cortex bridge failed requestId=${exchange.requestId}: ${String(err)}`);
+                if (!linkStatus.linked)
+                    break;
+            }
+        }
+        if (handledAny) {
+            sessionState.userTurns = Math.max(sessionState.userTurns, 1);
+            sessionState.lastAnsweredTurn = sessionState.userTurns;
+        }
+        return handledAny;
+    }
+    return {
+        refreshLinkStatus,
+        getPromptContext,
+        shouldInjectPrompt,
+        handleAgentEnd,
+    };
+}
+//# sourceMappingURL=handler.js.map