clawconnect-agent 0.2.6 → 0.2.7

package/dist/hermes/runtime/hermes-runtime-chat.js

@@ -7,13 +7,15 @@ import { buildToolInvocationUpdatedEvent, } from "../../core/relay/timeline-even
 import { forgetHermesSession, getMappedHermesSessionId, rememberHermesSession, } from "../hermes-session-store.js";
 import { CHAT_TIMEOUT_MS, CLAWCONNECT_MOBILE_BRIDGE_HINT, HERMES_INBOX_DIR, SUBPROCESS_ENV, hermesInvocation, isHermesCommandDeniedTimeoutLine, isHermesMissingSessionError, runHermes, sanitizeHermesChatOutput, stripAnsi, stripHermesSessionResumeNotices, } from "./hermes-runtime-process.js";
 import { collectHermesUsageSnapshot, listHermesSessions, readCachedHermesStatusSnapshot, readHermesStatusSnapshotAsync, } from "./hermes-runtime-usage.js";
-import { compactStringArray, sanitizeFileName } from "./hermes-runtime-values.js";
-import { detectHermesHistoryCompletion, selectHermesSessionForCompletedChat, } from "./hermes-runtime-history-completion.js";
-import { captureHermesSessionActiveHead, rewindHermesSessionAfterActiveHead, } from "./hermes-runtime-state-db.js";
-import { tryRunHermesApiChat } from "./hermes-runtime-api-client.js";
+import { compactStringArray, sanitizeFileName, stringValue } from "./hermes-runtime-values.js";
+import { detectHermesHistoryCompletion, hermesSourceRunIdFromMessage, selectHermesSessionForCompletedChat, } from "./hermes-runtime-history-completion.js";
+import { captureHermesSessionActiveHead, readHermesSessionMessages, rewindHermesSessionAfterActiveHead, } from "./hermes-runtime-state-db.js";
+import { ensureHermesApiSessionForMobileRoute, tryRunHermesApiChat } from "./hermes-runtime-api-client.js";
 import { resolveHermesPreloadedSkillContext } from "./hermes-runtime-preloaded-skills.js";
 import { createHermesToolLogWatcher, hermesToolState, } from "./hermes-runtime-tool-log-watcher.js";
 import { isHermesSlashCommandMessage, runHermesSlashCommand, } from "./hermes-runtime-slash-command.js";
+import { clearPendingHermesFileTransfer, getPendingHermesFileTransfer, recordPendingHermesFileTransfer, } from "./hermes-file-transfer-state.js";
+import { clearHermesMobileFileRoute, registerHermesMobileFileRoute, } from "./hermes-mobile-file-route-store.js";
 export { selectHermesSessionForCompletedChat } from "./hermes-runtime-history-completion.js";
 export { latestTerminalAssistantReplyFromHermesExport } from "./hermes-runtime-history-completion.js";
 export { parseHermesToolLogLine } from "./hermes-runtime-tool-log-watcher.js";
@@ -33,6 +35,9 @@ const EMPTY_PRELOADED_SKILL_CONTEXT = {
     requiredToolsets: [],
     skillNames: [],
 };
+const HERMES_FILE_TRANSFER_NOT_SENT_MESSAGE = "文件尚未发送：没有检测到可验证的 clawconnect send-file 成功结果，请补充或确认要发送的文件后重试。";
+const HERMES_FILE_TRANSFER_CONTENT_MISSING_MESSAGE = "本轮没有可显示的结构化回答。";
+const HERMES_FILE_TRANSFER_CANCELLED_MESSAGE = "文件发送已取消。";
 export async function runHermesChat(params, context = {}) {
     const record = params && typeof params === "object" && !Array.isArray(params)
         ? params
@@ -56,8 +61,7 @@ export async function runHermesChat(params, context = {}) {
     const sourceRunId = typeof context.requestId === "string" && context.requestId.trim().length > 0
         ? context.requestId.trim()
         : undefined;
-    const preparationPlan = planHermesChatPreparation(rawMessage);
-    const preparedMessage = await prepareHermesMessage(rawMessage, record.attachments, sessionKey, sourceRunId, preparationPlan);
+    const preparedMessage = await prepareHermesMessage(rawMessage, record.attachments, sessionKey, sourceRunId);
     if (!preparedMessage.cliMessage.trim()) {
         throw new Error("message_required");
     }
@@ -69,7 +73,6 @@ export async function runHermesChat(params, context = {}) {
             sourceRunId,
             hermesSessionId: record.hermesSessionId,
             context,
-            preparationPlan,
         });
     });
 }
@@ -94,30 +97,66 @@ async function runHermesChatPrepared(params) {
         : undefined;
     const mappedResume = explicitResume ? undefined : await getMappedHermesSessionId(params.sessionKey);
     let resume = explicitResume ?? mappedResume;
-    const preloadedSkillContext = params.preparationPlan.preloadFileTransferSkill
+    const preparationPlan = await planHermesChatPreparation({
+        message: params.rawMessage,
+        gatewayId: params.context.gatewayId ?? "clawconnect",
+        sessionKey: params.sessionKey,
+        sessionId: resume,
+        sourceRunId: params.sourceRunId,
+        fileTransferCapability: params.context.hermesFileTransferCapability,
+    });
+    const preloadedSkillContext = preparationPlan.preloadFileTransferSkill
         ? await resolveHermesPreloadedSkillContext({ forceFileTransfer: true })
         : EMPTY_PRELOADED_SKILL_CONTEXT;
+    if (preparationPlan.preloadFileTransferSkill && !resume && params.sourceRunId) {
+        const ensuredSessionId = await ensureHermesApiSessionForMobileRoute(params.sessionKey);
+        if (ensuredSessionId) {
+            resume = ensuredSessionId;
+            await rememberHermesSession(params.sessionKey, {
+                sessionKey: params.sessionKey,
+                hermesSessionId: ensuredSessionId,
+                displayName: params.sessionKey,
+                kind: "hermes",
+            });
+        }
+    }
     try {
-        const apiChat = await tryRunHermesApiChat({
-            message: params.preparedMessage.apiMessage,
-            instructions: params.preparedMessage.apiInstructions,
-            sessionKey: params.sessionKey,
-            resume,
-            preloadedSkillNames: preloadedSkillContext.skillNames,
-            requiredToolsets: preloadedSkillContext.requiredToolsets,
-            context: params.context,
-        });
+        // File delivery is fail-closed and must be backed by the local
+        // clawconnect send-file tool.  The API stream publishes assistant deltas
+        // before its final tool evidence is persisted, so route these turns
+        // through the CLI path where the answer is buffered until verification.
+        const apiChat = preparationPlan.preloadFileTransferSkill
+            ? undefined
+            : await tryRunHermesApiChat({
+                message: params.preparedMessage.apiMessage,
+                instructions: params.preparedMessage.apiInstructions,
+                sessionKey: params.sessionKey,
+                resume,
+                preloadedSkillNames: preloadedSkillContext.skillNames,
+                requiredToolsets: preloadedSkillContext.requiredToolsets,
+                context: params.context,
+            });
         if (apiChat) {
             const recoveredOutput = await recoverEmptyHermesApiOutputFromHistory({
                 output: apiChat.output,
                 hermesSessionId: apiChat.hermesSessionId,
                 sessionKey: params.sessionKey,
                 userMessage: params.rawMessage,
+                sourceRunId: params.sourceRunId,
                 abortSignal: params.context.abortSignal,
             });
+            const visibleOutput = requireVisibleHermesOutput(recoveredOutput || apiChat.output);
             return {
                 ...apiChat,
-                output: requireVisibleHermesOutput(recoveredOutput || apiChat.output),
+                output: visibleOutput,
+                ...(await verifyHermesFileTransferIfRequired({
+                    plan: preparationPlan,
+                    gatewayId: params.context.gatewayId ?? "clawconnect",
+                    sessionKey: params.sessionKey,
+                    sessionId: apiChat.hermesSessionId,
+                    sourceRunId: params.sourceRunId,
+                    output: visibleOutput,
+                })),
             };
         }
     }
@@ -132,25 +171,37 @@ async function runHermesChatPrepared(params) {
         }
         await forgetHermesSession(params.sessionKey, mappedResume);
         resume = undefined;
-        const retryApiChat = await tryRunHermesApiChat({
-            message: params.preparedMessage.apiMessage,
-            instructions: params.preparedMessage.apiInstructions,
-            sessionKey: params.sessionKey,
-            preloadedSkillNames: preloadedSkillContext.skillNames,
-            requiredToolsets: preloadedSkillContext.requiredToolsets,
-            context: params.context,
-        });
+        const retryApiChat = preparationPlan.preloadFileTransferSkill
+            ? undefined
+            : await tryRunHermesApiChat({
+                message: params.preparedMessage.apiMessage,
+                instructions: params.preparedMessage.apiInstructions,
+                sessionKey: params.sessionKey,
+                preloadedSkillNames: preloadedSkillContext.skillNames,
+                requiredToolsets: preloadedSkillContext.requiredToolsets,
+                context: params.context,
+            });
         if (retryApiChat) {
             const recoveredOutput = await recoverEmptyHermesApiOutputFromHistory({
                 output: retryApiChat.output,
                 hermesSessionId: retryApiChat.hermesSessionId,
                 sessionKey: params.sessionKey,
                 userMessage: params.rawMessage,
+                sourceRunId: params.sourceRunId,
                 abortSignal: params.context.abortSignal,
             });
+            const visibleOutput = requireVisibleHermesOutput(recoveredOutput || retryApiChat.output);
             return {
                 ...retryApiChat,
-                output: requireVisibleHermesOutput(recoveredOutput || retryApiChat.output),
+                output: visibleOutput,
+                ...(await verifyHermesFileTransferIfRequired({
+                    plan: preparationPlan,
+                    gatewayId: params.context.gatewayId ?? "clawconnect",
+                    sessionKey: params.sessionKey,
+                    sessionId: retryApiChat.hermesSessionId,
+                    sourceRunId: params.sourceRunId,
+                    output: visibleOutput,
+                })),
             };
         }
     }
@@ -160,17 +211,21 @@ async function runHermesChatPrepared(params) {
         : undefined;
     let rawOutput;
     try {
-        rawOutput = await runHermesChatOnce({
+        rawOutput = await runHermesChatOnceWithMobileFileRoute({
             message: params.preparedMessage.cliMessage,
             sessionKey: params.sessionKey,
             resume,
             context: params.context,
             preloadedSkillArgs: preloadedSkillContext.cliArgs,
+            enableFileTransferRoute: preparationPlan.preloadFileTransferSkill,
+            gatewayId: params.context.gatewayId ?? "clawconnect",
+            sourceRunId: params.sourceRunId,
             historyCompletion: () => detectHermesHistoryCompletion({
                 beforeSessions,
                 resume,
                 sessionKey: params.sessionKey,
                 userMessage: params.rawMessage,
+                sourceRunId: params.sourceRunId,
             }),
         });
     }
@@ -191,15 +246,19 @@ async function runHermesChatPrepared(params) {
         await forgetHermesSession(params.sessionKey, mappedResume);
         resume = undefined;
         cliActiveHead = undefined;
-        rawOutput = await runHermesChatOnce({
+        rawOutput = await runHermesChatOnceWithMobileFileRoute({
             message: params.preparedMessage.cliMessage,
             sessionKey: params.sessionKey,
             context: params.context,
             preloadedSkillArgs: preloadedSkillContext.cliArgs,
+            enableFileTransferRoute: preparationPlan.preloadFileTransferSkill,
+            gatewayId: params.context.gatewayId ?? "clawconnect",
+            sourceRunId: params.sourceRunId,
             historyCompletion: () => detectHermesHistoryCompletion({
                 beforeSessions,
                 sessionKey: params.sessionKey,
                 userMessage: params.rawMessage,
+                sourceRunId: params.sourceRunId,
             }),
         });
     }
@@ -214,6 +273,14 @@ async function runHermesChatPrepared(params) {
     if (mappedSession) {
         await rememberHermesSession(params.sessionKey, mappedSession);
     }
+    const verifiedFileTransfer = await verifyHermesFileTransferIfRequired({
+        plan: preparationPlan,
+        gatewayId: params.context.gatewayId ?? "clawconnect",
+        sessionKey: params.sessionKey,
+        sessionId: resume ?? mappedSession?.hermesSessionId,
+        sourceRunId: params.sourceRunId,
+        output,
+    });
     const usage = mappedSession?.hermesSessionId
         ? await collectHermesUsageSnapshot(mappedSession.hermesSessionId)
         : await readHermesStatusSnapshotAsync();
@@ -222,6 +289,7 @@ async function runHermesChatPrepared(params) {
         sessionKey: params.sessionKey,
         artifactPaths: [],
         usage,
+        ...verifiedFileTransfer,
     };
 }
 function isHermesChatAbortedError(error) {
@@ -289,6 +357,7 @@ async function recoverEmptyHermesApiOutputFromHistory(params) {
             resume: params.hermesSessionId,
             sessionKey: params.sessionKey,
             userMessage: params.userMessage,
+            sourceRunId: params.sourceRunId,
         });
         if (detectedOutput) {
             return detectedOutput;
@@ -327,6 +396,25 @@ async function runHermesChatOnce(params) {
         ? await runHermesChatStreaming(args, params.sessionKey, params.context, runId, env, params.historyCompletion)
         : runHermes(args, CHAT_TIMEOUT_MS, env);
 }
+async function runHermesChatOnceWithMobileFileRoute(params) {
+    const hermesSessionId = params.resume?.trim();
+    const sourceRunId = params.sourceRunId?.trim();
+    if (!params.enableFileTransferRoute || !hermesSessionId || !sourceRunId) {
+        return await runHermesChatOnce(params);
+    }
+    await registerHermesMobileFileRoute({
+        hermesSessionId,
+        gatewayId: params.gatewayId,
+        sessionKey: params.sessionKey,
+        sourceRunId,
+    });
+    try {
+        return await runHermesChatOnce(params);
+    }
+    finally {
+        await clearHermesMobileFileRoute(hermesSessionId, sourceRunId);
+    }
+}
 async function runHermesChatStreaming(args, sessionKey, context, runId, env, historyCompletion) {
     const invocation = hermesInvocation(args);
     const child = spawn(invocation.command, invocation.args, {
@@ -653,7 +741,7 @@ function buildClawConnectMobileTurnMetadata(sourceRunId, sessionKey) {
         `sessionKey: ${sessionKey}`,
     ].join("\n");
 }
-async function prepareHermesMessage(message, attachments, sessionKey, sourceRunId, preparationPlan = planHermesChatPreparation(message)) {
+async function prepareHermesMessage(message, attachments, sessionKey, sourceRunId) {
     const refs = [];
     if (Array.isArray(attachments)) {
         await cleanupExpiredHermesInbox();
@@ -742,32 +830,319 @@ export async function cleanupExpiredHermesInbox(inboxDir = HERMES_INBOX_DIR, now
         }));
     }));
 }
-function planHermesChatPreparation(message) {
+export async function planHermesChatPreparation(params) {
+    // A continuation is enabled only by a durable host-side pending state from
+    // the same gateway/mobile/Hermes session.  The user's wording is deliberately
+    // opaque to this router; Hermes receives the full history and decides what it
+    // means (including any language, selection, or clarification).
+    const pending = params.sessionId
+        ? await getPendingHermesFileTransfer({
+            gatewayId: params.gatewayId,
+            sessionKey: params.sessionKey,
+            hermesSessionId: params.sessionId,
+            sourceRunId: params.sourceRunId,
+        })
+        : undefined;
     return {
-        preloadFileTransferSkill: shouldPreloadHermesFileTransferSkill(message),
+        // The mobile relay explicitly grants the typed CLI file-transfer
+        // capability on every turn. The model/tool protocol, rather than a
+        // language-specific intent table, decides whether a send is needed. This
+        // deliberately trades the API fast path for a buffered CLI path on mobile
+        // turns, where send-file receipts are persisted atomically.
+        preloadFileTransferSkill: params.fileTransferCapability === "cli" || pending !== undefined,
+        fileTransferMode: pending ? "continuation" : undefined,
+        ...(pending ? { pendingFileTransfer: pending } : {}),
     };
 }
-function shouldPreloadHermesFileTransferSkill(message) {
-    const text = message.trim();
-    const lower = text.toLowerCase();
-    if (!text) {
+function normalizeHermesRole(value) {
+    return typeof value === "string" ? value.trim().toLowerCase() : "";
+}
+export async function verifyHermesFileTransferIfRequired(params) {
+    if (!params.plan.preloadFileTransferSkill) {
+        return {};
+    }
+    const messages = params.sessionId ? await readHermesSessionMessages(params.sessionId) : undefined;
+    const evidence = params.sourceRunId
+        ? collectHermesFileTransferEvidence(messages, params.sourceRunId)
+        : [];
+    if (evidence.length > 0) {
+        await clearPendingHermesFileTransfer(params.gatewayId, params.sessionKey, params.plan.pendingFileTransfer?.sourceRunId);
+        return {
+            verifiedFileTransferCount: evidence.length,
+            output: `已发送 ${evidence.length} 个文件，请查收。`,
+        };
+    }
+    const outcome = params.sourceRunId
+        ? collectHermesFileTransferOutcome(messages, params.sourceRunId)
+        : undefined;
+    if (outcome?.kind === "clarification") {
+        if (params.sessionId && params.sourceRunId) {
+            await recordPendingHermesFileTransfer({
+                gatewayId: params.gatewayId,
+                sessionKey: params.sessionKey,
+                hermesSessionId: params.sessionId,
+                sourceRunId: params.sourceRunId,
+                continuation: false,
+            });
+        }
+        // Only the typed content field is displayable. Raw assistant prose is
+        // deliberately discarded, and this outcome is never delivery evidence.
+        return {
+            output: outcome.assistantText ?? HERMES_FILE_TRANSFER_CONTENT_MISSING_MESSAGE,
+        };
+    }
+    if (outcome?.kind === "cancelled") {
+        await clearPendingHermesFileTransfer(params.gatewayId, params.sessionKey, params.plan.pendingFileTransfer?.sourceRunId);
+        return {
+            output: outcome.assistantText ?? HERMES_FILE_TRANSFER_CANCELLED_MESSAGE,
+        };
+    }
+    if (outcome?.kind === "ordinary") {
+        await clearPendingHermesFileTransfer(params.gatewayId, params.sessionKey, params.plan.pendingFileTransfer?.sourceRunId);
+        // Ordinary chat is shown only through the typed assistantText field. The
+        // model's ordinary label is routing metadata, never proof of delivery.
+        return {
+            output: outcome.assistantText ?? HERMES_FILE_TRANSFER_CONTENT_MISSING_MESSAGE,
+        };
+    }
+    if (outcome?.kind === "attempted") {
+        await clearPendingHermesFileTransfer(params.gatewayId, params.sessionKey, params.plan.pendingFileTransfer?.sourceRunId);
+        return {
+            verifiedFileTransferCount: 0,
+            output: HERMES_FILE_TRANSFER_NOT_SENT_MESSAGE,
+        };
+    }
+    if (params.sourceRunId && hasHermesSendFileAttempt(messages, params.sourceRunId)) {
+        return {
+            verifiedFileTransferCount: 0,
+            output: HERMES_FILE_TRANSFER_NOT_SENT_MESSAGE,
+        };
+    }
+    // File-transfer capability is available on every mobile turn, but capability
+    // alone does not turn ordinary chat into a file operation. Preserve the Host
+    // answer unless this exact turn emitted a typed outcome or actually invoked
+    // the first-party terminal command. This keeps failure closed around a real
+    // send attempt without replacing unrelated Hermes replies.
+    return {};
+}
+function hasHermesSendFileAttempt(messages, sourceRunId) {
+    const currentIndex = currentHermesTurnIndex(messages, sourceRunId);
+    if (currentIndex < 0 || !messages)
         return false;
+    for (const message of messages.slice(currentIndex + 1)) {
+        if (normalizeHermesRole(message.role) === "user")
+            break;
+        if (normalizeHermesRole(message.role) !== "assistant")
+            continue;
+        const rawToolCalls = typeof message.tool_calls === "string"
+            ? parseJsonValue(message.tool_calls)
+            : message.tool_calls;
+        if (!Array.isArray(rawToolCalls))
+            continue;
+        for (const rawToolCall of rawToolCalls) {
+            const toolCall = rawToolCall && typeof rawToolCall === "object" && !Array.isArray(rawToolCall)
+                ? rawToolCall
+                : undefined;
+            const fn = toolCall?.function && typeof toolCall.function === "object" && !Array.isArray(toolCall.function)
+                ? toolCall.function
+                : undefined;
+            const functionName = normalizeHermesRole(fn?.name);
+            if (functionName === "clawconnect_send_file")
+                return true;
+            if (functionName !== "terminal")
+                continue;
+            const rawArguments = typeof fn?.arguments === "string"
+                ? parseJsonValue(fn.arguments)
+                : fn?.arguments;
+            const args = rawArguments && typeof rawArguments === "object" && !Array.isArray(rawArguments)
+                ? rawArguments
+                : undefined;
+            if (typeof args?.command === "string" && isClawConnectSendFileCommand(args.command)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function isClawConnectSendFileCommand(command) {
+    return /(?:^|[\s;&|])(?:["'][^"']*clawconnect["']|[^\s;&|]*clawconnect)\s+send-file(?:\s|$)/i.test(command);
+}
+function parseJsonValue(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Read only first-party terminal outcome records for the exact current turn. */
+export function collectHermesFileTransferOutcome(messages, sourceRunId) {
+    const currentIndex = currentHermesTurnIndex(messages, sourceRunId);
+    if (currentIndex < 0 || !messages)
+        return undefined;
+    const outcomes = [];
+    for (const message of messages.slice(currentIndex + 1)) {
+        if (normalizeHermesRole(message.role) === "user")
+            break;
+        if (normalizeHermesRole(message.role) !== "tool" || normalizeHermesRole(message.tool_name) !== "terminal")
+            continue;
+        for (const record of terminalResultRecords(message)) {
+            if (record.protocol !== "clawconnect.hermes-file-transfer-outcome.v1"
+                || record.sourceRunId !== sourceRunId
+                || record.sourceRole !== "assistant"
+                || record.status !== "completed"
+                || record.exit_code !== 0
+                || (record.kind !== "ordinary" && record.kind !== "clarification" && record.kind !== "attempted" && record.kind !== "cancelled"))
+                continue;
+            const assistantText = typeof record.assistantText === "string" ? record.assistantText.trim() : "";
+            if (record.kind !== "attempted" && !assistantText)
+                continue;
+            outcomes.push({
+                protocol: "clawconnect.hermes-file-transfer-outcome.v1",
+                kind: record.kind,
+                sourceRunId,
+                sourceRole: "assistant",
+                status: "completed",
+                ...(assistantText ? { assistantText } : {}),
+            });
+        }
+    }
+    if (outcomes.length !== 1)
+        return undefined;
+    return outcomes[0];
+}
+export function collectHermesFileTransferEvidence(messages, sourceRunId) {
+    if (!messages) {
+        return [];
+    }
+    const currentIndex = currentHermesTurnIndex(messages, sourceRunId);
+    if (currentIndex < 0) {
+        return [];
+    }
+    const ids = new Set();
+    for (const message of messages.slice(currentIndex + 1)) {
+        if (normalizeHermesRole(message.role) === "user") {
+            break;
+        }
+        if (normalizeHermesRole(message.role) !== "tool")
+            continue;
+        const toolName = normalizeHermesRole(message.tool_name);
+        if (toolName === "clawconnect_send_file") {
+            const receipt = parseJsonRecord(stringValue(message.content) ?? "");
+            if (receipt?.ok === true
+                && receipt.sourceRunId === sourceRunId
+                && receipt.status === "completed"
+                && typeof receipt.fileId === "string"
+                && /^file_[a-z0-9]+$/i.test(receipt.fileId)) {
+                ids.add(receipt.fileId);
+            }
+            continue;
+        }
+        // Only the legacy first-party terminal result is additional evidence. A
+        // delegate summary, wrapper output, or assistant claim cannot manufacture
+        // an attachment by repeating the command name and a success word.
+        if (toolName !== "terminal")
+            continue;
+        for (const record of terminalResultRecords(message)) {
+            if (record.sourceRunId !== sourceRunId
+                || record.sourceRole !== "assistant"
+                || record.status !== "completed"
+                || record.exit_code !== 0
+                || typeof record.fileId !== "string"
+                || !/^file_[a-z0-9]+$/i.test(record.fileId)) {
+                continue;
+            }
+            ids.add(record.fileId);
+        }
+    }
+    return [...ids];
+}
+function currentHermesTurnIndex(messages, sourceRunId) {
+    if (!messages || !sourceRunId.trim())
+        return -1;
+    let currentIndex = -1;
+    for (let index = 0; index < messages.length; index += 1) {
+        const message = messages[index];
+        if (normalizeHermesRole(message?.role) === "user" && hermesSourceRunIdFromMessage(message) === sourceRunId) {
+            currentIndex = index;
+        }
+    }
+    return currentIndex;
+}
+function terminalResultRecords(message) {
+    const content = stringValue(message.content);
+    if (!content) {
+        return [];
+    }
+    const outer = parseJsonRecord(content);
+    if (!outer) {
+        return [];
+    }
+    const records = [outer];
+    const output = stringValue(outer.output);
+    if (output) {
+        for (const fragment of extractJsonObjects(output)) {
+            const record = parseJsonRecord(fragment);
+            if (record) {
+                // Hermes stores the command envelope's exit_code beside the textual
+                // send-file JSON payload; the payload itself carries the Relay fields.
+                records.push(record.exit_code === undefined && outer.exit_code !== undefined
+                    ? { ...record, exit_code: outer.exit_code }
+                    : record);
+            }
+        }
+    }
+    return records;
+}
+function parseJsonRecord(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function extractJsonObjects(value) {
+    const fragments = [];
+    let start = -1;
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let index = 0; index < value.length; index += 1) {
+        const character = value[index];
+        if (inString) {
+            if (escaped) {
+                escaped = false;
+            }
+            else if (character === "\\") {
+                escaped = true;
+            }
+            else if (character === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (character === '"') {
+            inString = true;
+        }
+        else if (character === "{") {
+            if (depth === 0) {
+                start = index;
+            }
+            depth += 1;
+        }
+        else if (character === "}" && depth > 0) {
+            depth -= 1;
+            if (depth === 0 && start >= 0) {
+                fragments.push(value.slice(start, index + 1));
+                start = -1;
+            }
+        }
     }
-    if (/\bfile-transfer\b|clawconnect\s+send-file/.test(lower)) {
-        return true;
-    }
-    const pathOrExtension = /(?:^|\s|["'“”‘’])(?:~|\/|[a-z]:\\)|\.(?:png|jpe?g|gif|webp|heic|pdf|docx?|xlsx?|pptx?|zip|txt|md)\b/i.test(text);
-    const englishSend = /\b(send|transfer|upload|attach|share|copy)\b/i.test(text);
-    const englishFile = /\b(file|image|photo|picture|screenshot|document|attachment)\b/i.test(text) || pathOrExtension;
-    const englishTarget = /\b(phone|iphone|mobile|clawlink|this device|me)\b/i.test(text);
-    if (englishSend && englishFile && englishTarget) {
-        return true;
-    }
-    const chineseSend = /发送|发给|发到|发过来|传到|传给|传输|上传|分享|转发|给我|发/.test(text);
-    const chineseFile = /文件|图片|照片|截图|文档|附件|桌面|本机|路径|微信图片/.test(text) || pathOrExtension;
-    const chineseTarget = /手机|移动端|这台|给我|发过来|iPhone|ClawLink/i.test(text);
-    // 文件传输技能会触发 Hermes CLI 的 skills list；普通文本必须不走这条慢路径。
-    return chineseSend && chineseFile && chineseTarget;
+    return fragments;
 }
 export function buildHermesRuntimeContextHint(snapshot) {
     const details = compactStringArray([