@rikaidev/yomi 0.4.2 → 0.6.0

package/README.md

@@ -51,6 +51,34 @@ Guides: **[What is a LINE MCP server?](https://rikaidev.github.io/yomi/line-mcp/
 
 ## Getting started
 
+### Native Desktop preview
+
+Yomi Desktop puts the LINE inbox and local agent workspace in one native app.
+It bundles its own runtime: **users do not install Node, open Terminal, clone
+this repository, or configure `YOMI_RUN_MJS`.** Native Desktop is separate from
+the Claude Desktop MCPB extension described below.
+
+| Platform | General-user package | Signing status | Install experience |
+| --- | --- | --- | --- |
+| macOS 14+, Apple Silicon | `Yomi-Desktop-macOS-arm64-<version>.dmg` | Developer ID signed and Apple notarized | Open DMG → drag Yomi to Applications → open Yomi |
+| Windows 10/11 x64 | `Yomi-Desktop-Windows-x64-<version>-Setup.exe` | Trusted OSS signing application in progress | Download remains unavailable until signing and installer smoke pass |
+
+The macOS package has been tested through the real downloaded-app path:
+quarantined DMG, install to `/Applications`, Gatekeeper assessment, first
+launch, bundled-runtime message refresh, and no-terminal LINE login form. The
+Windows installer contains the equivalent in-app phone/PIN login flow and is
+tested on a native Windows runner before release.
+
+Desktop builds are experimental and unofficial. LINE changes may break them,
+and running an additional client may put an account at risk. Prefer a test
+account and keep a current backup. Preview installers are published as GitHub
+pre-releases only after platform signing is available.
+
+See the [desktop release process](DESKTOP-RELEASING.md),
+[code-signing policy](CODE_SIGNING.md), and [privacy policy](PRIVACY.md).
+
+### MCP server and Desktop Extension
+
 You need [Node.js](https://nodejs.org) and a LINE account. Yomi runs locally
 through `npx`; you do not need to clone this repository, install Bun, or build
 anything. Run `node --version` first, and install the current LTS if the command
@@ -479,6 +507,11 @@ fake success.
 this device a sign-in prompt — this is the single most common reason a first login
 appears to hang.
 
+> **⚠️ Single Desktop Session Limit:** LINE allows only **one desktop client session at a time**
+> per account. Because Yomi connects as a desktop secondary device (`DESKTOPMAC`), logging into Yomi
+> will sign out your official LINE Desktop app (and signing back into LINE Desktop will invalidate
+> Yomi's session). You cannot use Yomi and the official LINE Desktop client simultaneously.
+
 You only need to give the agent your phone number in E.164 form — it supplies the
 region itself (e.g. `TW` for a `+886` number) when it calls the tool.
 
@@ -516,16 +549,16 @@ entirely**.
 ### Sessions and credentials
 
 Yomi owns its own login. On startup it calls `resumeSession()` once, reading the
-LINE session from the macOS Keychain (service `com.yomi.credentials`, account
+LINE session from the macOS Keychain (service `dev.rikai.yomi.credentials`, account
 `line`) and silently refreshing the token if needed.
 
 - **First-party credentials.** The passwordless login persists the auth token,
   refresh token, certificate, MID, and the E2EE keypair itself — then reads them
   back to verify the write actually landed. A login that can't be persisted fails
   loudly at login, not silently at the next restart.
-- **Backward compatibility.** If no session is found under `com.yomi.credentials`,
-  Yomi reads the legacy `com.inboxd.credentials` entry once, migrates it forward,
-  and never deletes it. An existing session keeps working with no re-login.
+- **Shared session.** The session is stored in the canonical `dev.rikai.yomi.credentials`
+  keychain entry (or local credential store), allowing Yomi MCP and Yomi Desktop to
+  share the exact same LINE login session seamlessly.
 - **Platform note.** On macOS the session lives in the login Keychain. On **Linux
   and Windows** Yomi currently falls back to a local JSON file — functional, but
   less protected than an OS secret store, and less exercised than the macOS path.
@@ -590,6 +623,15 @@ Yomi runs as a **secondary device** on your account. That shapes what it can see
   per-epoch group keys, not a bug here. It can also cut sideways: the epoch your phone
   holds and the epoch Yomi holds need not be the same, so the **two devices can each
   read a different slice** of the very same group.
+- **Installing Yomi does not itself rotate anything, so "before I installed Yomi" is
+  the wrong boundary.** Yomi only ever *resolves* an existing group key; it never
+  registers (mints) one, because minting rotates the group's shared secret for every
+  member and strands every message encrypted under the previous one. So a fresh install
+  picks up the **current** key and reads back to the last rotation — which may predate
+  the install by months. The boundary is the last rekey, not your install date. And
+  once Yomi has seen an epoch it keeps that key, so a rotation *after* install leaves
+  it able to read both sides. If a group comes back undecryptable all the way to
+  **today**, that is not this limitation — please report it.
 - **1:1 media** uses the account-level E2EE keychain, which a secondary device fully
   possesses (LINE syncs it during pairing) — Yomi **can** decrypt 1:1 images/files it
   can see.

package/dist/ambient/ambient-event-graph.js

@@ -0,0 +1,172 @@
+function characterBigrams(value) {
+    const normalized = (value ?? '')
+        .normalize('NFKC')
+        .toLocaleLowerCase()
+        .replace(/[\p{P}\p{S}\s]+/gu, '');
+    const values = new Set();
+    for (let index = 0; index + 1 < normalized.length; index++) {
+        values.add(normalized.slice(index, index + 2));
+    }
+    return values;
+}
+function overlap(left, right) {
+    const a = characterBigrams(left);
+    const b = characterBigrams(right);
+    if (a.size === 0 || b.size === 0)
+        return 0;
+    let shared = 0;
+    for (const value of a)
+        if (b.has(value))
+            shared += 1;
+    return shared / (a.size + b.size - shared);
+}
+function quantile(values, fraction) {
+    if (values.length === 0)
+        return 0;
+    const sorted = [...values].sort((left, right) => left - right);
+    const index = Math.min(sorted.length - 1, Math.floor((sorted.length - 1) * fraction));
+    return sorted[index];
+}
+/** Derive a session scale from each conversation instead of a global fixed window. */
+function conversationSessionScale(messages) {
+    const gaps = messages
+        .slice(1)
+        .map((message, index) => message.sentAt - messages[index].sentAt)
+        .filter((gap) => gap > 0);
+    const observed = quantile(gaps, 0.75) * 2.5;
+    return Math.min(90 * 60_000, Math.max(15 * 60_000, observed || 15 * 60_000));
+}
+function temporalAffinity(deltaMs, sessionScaleMs) {
+    return Math.exp(-Math.max(0, deltaMs) / Math.max(1, sessionScaleMs));
+}
+function normalizedEntropy(weights) {
+    if (weights.length <= 1)
+        return 0;
+    const exponentials = weights.map((weight) => Math.exp(weight * 4));
+    const total = exponentials.reduce((sum, value) => sum + value, 0);
+    const probabilities = exponentials.map((value) => value / total);
+    const entropy = -probabilities.reduce((sum, value) => sum + (value > 0 ? value * Math.log(value) : 0), 0);
+    return entropy / Math.log(probabilities.length);
+}
+function scoreParent(parent, child, sessionScaleMs, consecutive) {
+    const reasons = [];
+    const direct = child.chatId.startsWith('u');
+    const alternating = parent.isSelf !== child.isSelf;
+    const parentQuestion = /[?？]/.test(parent.text ?? '');
+    const delta = child.sentAt - parent.sentAt;
+    const withinSession = delta >= 0 && delta <= sessionScaleMs;
+    let weight = 0;
+    if (withinSession && consecutive && alternating) {
+        weight += 0.18 + 0.2 * temporalAffinity(delta, sessionScaleMs);
+        weight += direct ? 0.24 : 0.16;
+        reasons.push(direct ? 'dyadic_turn' : 'local_turn_exchange');
+    }
+    else if (withinSession && consecutive && direct) {
+        weight += 0.2 + 0.16 * temporalAffinity(delta, sessionScaleMs);
+        reasons.push('dyadic_continuation');
+    }
+    else if (withinSession &&
+        consecutive &&
+        parent.isSelf === true &&
+        child.isSelf === true) {
+        weight += 0.2 + 0.16 * temporalAffinity(delta, sessionScaleMs);
+        reasons.push('self_continuation');
+    }
+    if (parentQuestion && alternating) {
+        weight += direct ? 0.52 : 0.34;
+        reasons.push('adjacency_pair');
+    }
+    if (parent.senderName && child.mentionNames?.includes(parent.senderName)) {
+        weight += 0.52;
+        reasons.push('mentions_parent');
+    }
+    if (child.senderName && parent.mentionNames?.includes(child.senderName)) {
+        weight += 0.72;
+        reasons.push('addressed_responder');
+    }
+    if (parent.mentionsSelf && child.isSelf) {
+        weight += 0.7;
+        reasons.push('self_answers_mention');
+    }
+    const semanticOverlap = withinSession ? overlap(parent.text, child.text) : 0;
+    if (parent.senderName &&
+        parent.senderName === child.senderName &&
+        (semanticOverlap >= 0.08 || parent.mediaType || child.mediaType)) {
+        weight += 0.18;
+        reasons.push('same_speaker_continuation');
+    }
+    if (semanticOverlap > 0) {
+        weight += Math.min(0.28, semanticOverlap * 0.4);
+        reasons.push('lexical_overlap');
+    }
+    return { weight, reasons };
+}
+export function inferAmbientEventGraph(messages) {
+    const edges = [];
+    const byChat = new Map();
+    for (const message of messages) {
+        const rows = byChat.get(message.chatId) ?? [];
+        rows.push(message);
+        byChat.set(message.chatId, rows);
+    }
+    for (const rows of byChat.values()) {
+        const sorted = [...rows].sort((a, b) => a.sentAt - b.sentAt);
+        const sessionScaleMs = conversationSessionScale(sorted);
+        for (let index = 1; index < sorted.length; index++) {
+            const child = sorted[index];
+            const candidates = sorted
+                .slice(Math.max(0, index - 100), index)
+                .map((parent, candidateIndex, candidates) => ({
+                parent,
+                ...scoreParent(parent, child, sessionScaleMs, candidateIndex === candidates.length - 1),
+            }))
+                .filter((candidate) => candidate.weight >= 0.3)
+                .sort((a, b) => b.weight - a.weight);
+            if (candidates.length === 0)
+                continue;
+            const entropy = normalizedEntropy(candidates.slice(0, 8).map((candidate) => candidate.weight));
+            const best = candidates[0];
+            const selected = [
+                best,
+                ...(entropy >= 0.72
+                    ? candidates
+                        .slice(1)
+                        .filter((candidate) => best.weight - candidate.weight <= 0.08)
+                        .slice(0, 1)
+                    : []),
+            ];
+            for (const candidate of selected) {
+                edges.push({
+                    parentId: candidate.parent.messageId,
+                    childId: child.messageId,
+                    weight: Number(candidate.weight.toFixed(4)),
+                    entropy: Number(entropy.toFixed(4)),
+                    reasons: candidate.reasons,
+                });
+            }
+        }
+    }
+    const children = new Map();
+    for (const edge of edges) {
+        const values = children.get(edge.parentId) ?? [];
+        values.push(edge.childId);
+        children.set(edge.parentId, values);
+    }
+    return {
+        edges,
+        descendants(messageIds) {
+            const found = new Set();
+            const queue = [...messageIds];
+            while (queue.length > 0) {
+                const current = queue.shift();
+                for (const child of children.get(current) ?? []) {
+                    if (found.has(child))
+                        continue;
+                    found.add(child);
+                    queue.push(child);
+                }
+            }
+            return found;
+        },
+    };
+}

package/dist/ambient/ambient-observer.js

@@ -0,0 +1,71 @@
+import { sanitizeMessagePreview } from '../line/core/message-preview.js';
+import { LineProtocolService } from '../line/core/service.js';
+import { MAX_LOOKBACK_MS, reduceAmbientObservations, } from './event-graph-reducer.js';
+import { LineIngestionAdapter } from './ingestion-adapter.js';
+function mediaType(contentType) {
+    return ({
+        1: 'image',
+        2: 'video',
+        3: 'audio',
+        7: 'sticker',
+        14: 'file',
+    }[contentType] ?? null);
+}
+function mentionMids(metadata) {
+    try {
+        const value = typeof metadata?.MENTION === 'string'
+            ? JSON.parse(metadata.MENTION)
+            : metadata?.MENTION;
+        const mentions = value?.MENTIONEES ?? value?.MENTIONS ?? [];
+        return mentions
+            .map((item) => item?.M ?? item?.mid)
+            .filter((mid) => typeof mid === 'string');
+    }
+    catch {
+        return [];
+    }
+}
+export function normalizeSquareObservationRows(chat, messages) {
+    const senderNames = new Map(messages
+        .filter((message) => message?.fromMid && message?.fromName)
+        .map((message) => [String(message.fromMid), String(message.fromName)]));
+    return messages.map((message) => {
+        const type = mediaType(Number(message.contentType ?? 0));
+        const mentions = mentionMids(message.contentMetadata);
+        return {
+            messageId: String(message.id),
+            chatId: chat.id,
+            senderName: message.fromName ? String(message.fromName) : null,
+            sentAt: Number(message.createdTime ?? 0),
+            text: sanitizeMessagePreview(message.text) || null,
+            mediaType: type,
+            fileName: message.fileName ? String(message.fileName) : null,
+            ocrEligible: true,
+            isSelf: message.isSelf === true,
+            mentionsSelf: Boolean(chat.memberMid && mentions.includes(String(chat.memberMid))),
+            sourceUrl: type === 'sticker' && message.contentMetadata?.STKID
+                ? `https://stickershop.line-scdn.net/stickershop/v1/sticker/${message.contentMetadata.STKID}/android/sticker.png`
+                : null,
+            mentionNames: mentions
+                .map((mid) => senderNames.get(mid))
+                .filter((name) => Boolean(name)),
+        };
+    });
+}
+export function buildAmbientObservations(rows, chatNames, now = Date.now(), requestedWindowStart = now - MAX_LOOKBACK_MS) {
+    return reduceAmbientObservations(rows, chatNames, now, requestedWindowStart);
+}
+export async function scanAmbientObservations(requestedWindowStart, now = Date.now()) {
+    const service = new LineProtocolService();
+    if (!(await service.resumeSession()))
+        throw new Error('LINE session unavailable');
+    const windowStart = Math.max(requestedWindowStart ?? now - MAX_LOOKBACK_MS, now - MAX_LOOKBACK_MS);
+    const adapter = new LineIngestionAdapter(service);
+    const ingestion = await adapter.collectRecentEvents({ windowStart });
+    const report = reduceAmbientObservations(ingestion.events, ingestion.chatNames, now, windowStart);
+    report.coverageLimited = ingestion.coverageLimited;
+    report.chatsScanned = ingestion.chatsScanned;
+    report.messagesScanned = ingestion.messagesScanned;
+    report.officialChatsSkipped = ingestion.officialChatsSkipped;
+    return report;
+}

package/dist/ambient/event-graph-reducer.js

@@ -0,0 +1,300 @@
+import { createHash } from 'node:crypto';
+import { inferAmbientEventGraph } from './ambient-event-graph.js';
+export const MAX_LOOKBACK_MS = 14 * 24 * 60 * 60 * 1000;
+const EPISODE_GAP_MS = 45 * 60 * 1000;
+const MEDIA_ATTACH_GAP_MS = 5 * 60 * 1000;
+const STICKER_RESPONSE_GAP_MS = 30 * 60 * 1000;
+const SEMANTIC_THRESHOLD = 0.58;
+export function toWorkingEvidence(event) {
+    return {
+        messageId: event.messageId,
+        chatId: event.chatId,
+        senderName: event.senderName,
+        sentAt: event.sentAt,
+        text: event.text,
+        mediaType: event.contentType,
+        fileName: event.metadata.fileName ?? null,
+        ocrEligible: event.ocrEligible,
+        isSelf: event.isSelf,
+        mentionsSelf: event.mentionsSelf,
+        sourceUrl: event.metadata.sourceUrl ?? null,
+        mentionNames: event.metadata.mentionNames,
+    };
+}
+function cosine(a, b) {
+    let dot = 0;
+    let aa = 0;
+    let bb = 0;
+    const length = Math.min(a.length, b.length);
+    for (let index = 0; index < length; index++) {
+        dot += a[index] * b[index];
+        aa += a[index] * a[index];
+        bb += b[index] * b[index];
+    }
+    return aa && bb ? dot / Math.sqrt(aa * bb) : 0;
+}
+function observationId(chatId, firstMessageId) {
+    return createHash('sha256')
+        .update(`${chatId}\0${firstMessageId}`)
+        .digest('hex')
+        .slice(0, 20);
+}
+function titleFor(evidence) {
+    const text = evidence
+        .find((item) => item.text)
+        ?.text?.replace(/\s+/g, ' ')
+        .trim();
+    if (text)
+        return text.slice(0, 72);
+    return '';
+}
+function semanticClusters(rows) {
+    const clusters = [];
+    for (const row of rows) {
+        if (!row.vector) {
+            if (row.mediaType === 'sticker' && row.isSelf !== true) {
+                const questionCluster = [...clusters].reverse().find((cluster) => {
+                    const last = cluster.rows[cluster.rows.length - 1];
+                    return (row.sentAt - last.sentAt <= STICKER_RESPONSE_GAP_MS &&
+                        cluster.rows.some((item) => item.isSelf === true && /[?？]/.test(item.text ?? '')));
+                });
+                if (questionCluster) {
+                    questionCluster.rows.push(row);
+                    continue;
+                }
+                const handoffCluster = [...clusters].reverse().find((cluster) => {
+                    const last = cluster.rows[cluster.rows.length - 1];
+                    return (row.sentAt - last.sentAt <= STICKER_RESPONSE_GAP_MS &&
+                        cluster.rows.some((item) => ['image', 'video', 'file'].includes(item.mediaType ?? '') &&
+                            item.senderName !== row.senderName));
+                });
+                if (handoffCluster) {
+                    handoffCluster.rows.push(row);
+                    continue;
+                }
+            }
+            const nearest = [...clusters]
+                .reverse()
+                .find((cluster) => row.sentAt - cluster.rows[cluster.rows.length - 1].sentAt <=
+                MEDIA_ATTACH_GAP_MS);
+            if (nearest)
+                nearest.rows.push(row);
+            else
+                clusters.push({ rows: [row], vectorCount: 0 });
+            continue;
+        }
+        let best;
+        let bestScore = -1;
+        for (const cluster of clusters) {
+            if (!cluster.centroid)
+                continue;
+            const score = cosine(row.vector, cluster.centroid);
+            if (score > bestScore) {
+                bestScore = score;
+                best = cluster;
+            }
+        }
+        if (!best || bestScore < SEMANTIC_THRESHOLD) {
+            clusters.push({ rows: [row], centroid: [...row.vector], vectorCount: 1 });
+            continue;
+        }
+        best.rows.push(row);
+        const count = best.vectorCount + 1;
+        best.centroid = best.centroid?.map((value, index) => (value * best.vectorCount + row.vector[index]) / count);
+        best.vectorCount = count;
+    }
+    return clusters.map((cluster) => cluster.rows);
+}
+export function reduceAmbientObservations(inputRows, chatNames, now = Date.now(), requestedWindowStart = now - MAX_LOOKBACK_MS) {
+    const rows = inputRows.map((r) => 'eventId' in r ? toWorkingEvidence(r) : r);
+    const windowStart = Math.max(requestedWindowStart, now - MAX_LOOKBACK_MS);
+    const groups = new Map();
+    for (const row of rows.filter((item) => item.sentAt >= windowStart)) {
+        const values = groups.get(row.chatId) ?? [];
+        values.push(row);
+        groups.set(row.chatId, values);
+    }
+    const candidates = [];
+    for (const [chatId, unsorted] of groups) {
+        const sorted = [...unsorted].sort((a, b) => a.sentAt - b.sentAt);
+        let episode = [];
+        const flush = () => {
+            if (episode.length === 0)
+                return;
+            for (const cluster of semanticClusters(episode)) {
+                const imageCount = cluster.filter((item) => item.mediaType === 'image').length;
+                const ownerHints = [
+                    ...new Set(cluster.flatMap((item) => item.mentionNames ?? [])),
+                ];
+                const hasQuestionMark = cluster.some((item) => /[?？]/.test(item.text ?? ''));
+                const outboundQuestion = cluster.some((item) => item.isSelf === true && /[?？]/.test(item.text ?? ''));
+                const inboundDirectQuestion = chatId.startsWith('u') &&
+                    cluster.some((item) => item.isSelf !== true && /[?？]/.test(item.text ?? ''));
+                const outboundQuestionIndex = cluster.findIndex((item) => item.isSelf === true && /[?？]/.test(item.text ?? ''));
+                const receivedResponse = outboundQuestionIndex >= 0 &&
+                    cluster
+                        .slice(outboundQuestionIndex + 1)
+                        .some((item) => item.isSelf !== true);
+                const mediaIndex = cluster.findIndex((item) => ['image', 'video', 'file'].includes(item.mediaType ?? ''));
+                const mediaHandoff = mediaIndex >= 0 &&
+                    cluster
+                        .slice(mediaIndex + 1)
+                        .some((item) => item.senderName !== cluster[mediaIndex].senderName);
+                const selfMediaHandoff = mediaIndex >= 0 &&
+                    cluster[mediaIndex].isSelf === true &&
+                    cluster.slice(mediaIndex + 1).some((item) => item.isSelf !== true);
+                const directedResponse = cluster.length >= 2 &&
+                    (ownerHints.length > 0 || hasQuestionMark) &&
+                    cluster
+                        .slice(1)
+                        .some((item) => item.senderName !== cluster[0].senderName);
+                const mentionsSelf = cluster.some((item) => item.mentionsSelf === true);
+                const senders = new Set(cluster.map((item) => item.senderName).filter(Boolean));
+                const vectorRows = cluster.filter((item) => item.vector);
+                const coherence = vectorRows.length >= 2
+                    ? vectorRows
+                        .slice(1)
+                        .reduce((sum, item, index) => sum + cosine(vectorRows[index].vector, item.vector), 0) /
+                        (vectorRows.length - 1)
+                    : 0;
+                const reasons = [
+                    ...(cluster.length >= 3 ? ['message_burst'] : []),
+                    ...(imageCount >= 3 ? ['media_burst'] : []),
+                    ...(ownerHints.length > 0 ? ['explicit_mention'] : []),
+                    ...(mentionsSelf ? ['mentions_self'] : []),
+                    ...(hasQuestionMark ? ['question_mark'] : []),
+                    ...(outboundQuestion ? ['outbound_question'] : []),
+                    ...(inboundDirectQuestion ? ['direct_message_question'] : []),
+                    ...(receivedResponse ? ['response_received'] : []),
+                    ...(mediaHandoff ? ['media_handoff'] : []),
+                    ...(directedResponse ? ['directed_response'] : []),
+                    ...(senders.size >= 2 ? ['multi_party'] : []),
+                    ...(coherence >= 0.65 ? ['semantic_coherence'] : []),
+                ];
+                const qualifies = mentionsSelf ||
+                    outboundQuestion ||
+                    inboundDirectQuestion ||
+                    selfMediaHandoff ||
+                    (vectorRows.length >= 2 && coherence >= 0.72);
+                if (!qualifies)
+                    continue;
+                const startedAt = cluster[0].sentAt;
+                const updatedAt = cluster[cluster.length - 1].sentAt;
+                const confidence = Math.min(0.92, 0.3 +
+                    Math.min(0.18, cluster.length * 0.03) +
+                    (imageCount >= 3 ? 0.14 : 0) +
+                    (mediaHandoff ? 0.12 : 0) +
+                    (inboundDirectQuestion ? 0.12 : 0) +
+                    (mentionsSelf ? 0.16 : ownerHints.length > 0 ? 0.04 : 0) +
+                    (senders.size >= 2 ? 0.08 : 0) +
+                    coherence * 0.18);
+                candidates.push({
+                    id: observationId(chatId, cluster[0].messageId),
+                    chatId,
+                    chatName: chatNames.get(chatId) ?? 'LINE conversation',
+                    topic: 'unclassified',
+                    title: titleFor(cluster),
+                    startedAt,
+                    updatedAt,
+                    confidence: Number(confidence.toFixed(2)),
+                    status: 'candidate',
+                    ownerHints,
+                    relevance: mentionsSelf || outboundQuestion || inboundDirectQuestion
+                        ? 'self'
+                        : ownerHints.length > 0 ||
+                            (mediaHandoff &&
+                                !cluster.some((item) => item.isSelf === true))
+                            ? 'other'
+                            : 'unassigned',
+                    responseState: receivedResponse || mediaHandoff || directedResponse
+                        ? 'received'
+                        : outboundQuestion || inboundDirectQuestion
+                            ? 'waiting'
+                            : 'observing',
+                    reasons,
+                    evidence: cluster
+                        .slice(-20)
+                        .map(({ mentionNames: _mentions, vector: _vector, ...item }) => item),
+                });
+            }
+            episode = [];
+        };
+        for (const row of sorted) {
+            if (episode.length > 0 &&
+                row.sentAt - episode[episode.length - 1].sentAt > EPISODE_GAP_MS) {
+                flush();
+            }
+            episode.push(row);
+        }
+        flush();
+    }
+    const candidateMessageIds = new Set(candidates.flatMap((candidate) => candidate.evidence.map((item) => item.messageId)));
+    for (const row of rows.filter((item) => item.mediaType === 'file' && !candidateMessageIds.has(item.messageId))) {
+        const target = candidates
+            .filter((candidate) => candidate.chatId === row.chatId &&
+            row.sentAt >= candidate.startedAt &&
+            row.sentAt - candidate.updatedAt <= 48 * 60 * 60 * 1000)
+            .filter((candidate) => candidate.evidence.some((item) => /請|麻煩|協助|撰寫|繳交|進度|報告|提供/.test(item.text ?? '')))
+            .sort((a, b) => b.updatedAt - a.updatedAt)[0];
+        if (!target)
+            continue;
+        const { mentionNames: _mentionNames, vector: _vector, ...evidence } = row;
+        target.evidence.push(evidence);
+        target.updatedAt = Math.max(target.updatedAt, row.sentAt);
+        target.responseState = 'received';
+        target.reasons.push('file_delivery');
+        candidateMessageIds.add(row.messageId);
+    }
+    const graph = inferAmbientEventGraph(rows);
+    const rowByID = new Map(rows.map((row) => [row.messageId, row]));
+    for (const candidate of candidates) {
+        if (candidate.responseState === 'received')
+            continue;
+        const trigger = rowByID.get(candidate.evidence[0]?.messageId);
+        if (!trigger)
+            continue;
+        const descendantIDs = graph.descendants([trigger.messageId]);
+        const responseRows = [...descendantIDs]
+            .map((id) => rowByID.get(id))
+            .filter((row) => Boolean(row))
+            .sort((a, b) => a.sentAt - b.sentAt);
+        const inboundDirectQuestion = trigger.chatId.startsWith('u') &&
+            trigger.isSelf !== true &&
+            /[?？]/.test(trigger.text ?? '');
+        const outboundQuestion = trigger.isSelf === true && /[?？]/.test(trigger.text ?? '');
+        const response = responseRows.find((row) => {
+            if (inboundDirectQuestion || trigger.mentionsSelf)
+                return row.isSelf === true;
+            if (outboundQuestion)
+                return row.isSelf !== true;
+            return (row.senderName !== null && candidate.ownerHints.includes(row.senderName));
+        });
+        if (!response)
+            continue;
+        const existingIDs = new Set(candidate.evidence.map((item) => item.messageId));
+        candidate.evidence.push(...responseRows
+            .filter((row) => !existingIDs.has(row.messageId))
+            .slice(0, 6)
+            .map(({ mentionNames: _mentions, vector: _vector, ...row }) => row));
+        candidate.updatedAt = Math.max(candidate.updatedAt, ...responseRows.map((row) => row.sentAt));
+        candidate.responseState = 'received';
+        candidate.reasons.push('graph_response_received');
+    }
+    const relevanceRank = { self: 0, unassigned: 1, other: 2 };
+    const actionRank = (candidate) => candidate.responseState === 'received'
+        ? 3
+        : relevanceRank[candidate.relevance];
+    candidates.sort((a, b) => actionRank(a) - actionRank(b) ||
+        b.updatedAt - a.updatedAt ||
+        b.confidence - a.confidence);
+    return {
+        engineVersion: 16,
+        generatedAt: now,
+        windowStart,
+        coverageLimited: false,
+        chatsScanned: new Set(rows.map((row) => row.chatId)).size,
+        messagesScanned: rows.length,
+        officialChatsSkipped: 0,
+        candidates: candidates.slice(0, 24),
+    };
+}