@rikaidev/yomi 0.4.2 → 0.6.0

package/dist/ambient/summaries/summary-engine.js

@@ -0,0 +1,128 @@
+import { createHash } from 'node:crypto';
+export const CURRENT_SUMMARY_ENGINE_VERSION = 1;
+const EPISODE_GAP_MS = 45 * 60 * 1000; // 45 minutes
+const ROLLUP_INTERVAL_MS = 6 * 60 * 60 * 1000; // 6 hours
+function computeDigest(content) {
+    return createHash('sha256').update(content).digest('hex').slice(0, 16);
+}
+function inferDialogueActs(events) {
+    const acts = new Set();
+    for (const event of events) {
+        const text = event.text ?? '';
+        const isQuestion = /[?？]/.test(text);
+        if (isQuestion) {
+            acts.add('ask');
+        }
+        if (['image', 'video', 'file'].includes(event.contentType)) {
+            acts.add('deliver');
+        }
+        if (event.mentionsSelf || (event.metadata.mentionMids?.length ?? 0) > 0) {
+            acts.add('directive');
+        }
+        if (event.contentType === 'sticker') {
+            acts.add('acknowledge');
+        }
+        if (text.length > 0 && !isQuestion) {
+            acts.add('inform');
+        }
+    }
+    return [...acts];
+}
+export function buildEpisodeSummaries(events, engineVersion = CURRENT_SUMMARY_ENGINE_VERSION) {
+    if (events.length === 0)
+        return [];
+    const byChat = new Map();
+    for (const event of events) {
+        const list = byChat.get(event.chatId) ?? [];
+        list.push(event);
+        byChat.set(event.chatId, list);
+    }
+    const summaries = [];
+    for (const [chatId, chatEvents] of byChat) {
+        const sorted = [...chatEvents].sort((a, b) => a.sentAt - b.sentAt);
+        let currentEpisode = [];
+        const flush = () => {
+            if (currentEpisode.length === 0)
+                return;
+            const minSentAt = currentEpisode[0].sentAt;
+            const maxSentAt = currentEpisode[currentEpisode.length - 1].sentAt;
+            const messageIds = currentEpisode.map((e) => e.messageId);
+            const participantNames = [
+                ...new Set(currentEpisode
+                    .map((e) => e.senderName)
+                    .filter((n) => Boolean(n))),
+            ];
+            const ownerHints = [
+                ...new Set(currentEpisode.flatMap((e) => e.metadata.mentionNames ?? [])),
+            ];
+            const hasMentionsSelf = currentEpisode.some((e) => e.mentionsSelf);
+            const hasQuestions = currentEpisode.some((e) => /[?？]/.test(e.text ?? ''));
+            const hasMedia = currentEpisode.some((e) => ['image', 'video', 'file', 'audio'].includes(e.contentType));
+            const dialogueActs = inferDialogueActs(currentEpisode);
+            const hasSelfQuestion = currentEpisode.some((e) => e.isSelf && /[?？]/.test(e.text ?? ''));
+            const selfQuestionIdx = currentEpisode.findIndex((e) => e.isSelf && /[?？]/.test(e.text ?? ''));
+            const hasReplyAfterSelfQuestion = selfQuestionIdx >= 0 &&
+                currentEpisode.slice(selfQuestionIdx + 1).some((e) => !e.isSelf);
+            const responseState = hasReplyAfterSelfQuestion
+                ? 'received'
+                : hasSelfQuestion
+                    ? 'waiting'
+                    : 'observing';
+            const digest = computeDigest(`${chatId}:${minSentAt}:${messageIds.join(',')}`);
+            const episodeId = `ep-${chatId.slice(0, 8)}-${minSentAt}`;
+            summaries.push({
+                episodeId,
+                chatId,
+                minSentAt,
+                maxSentAt,
+                messageIds,
+                participantNames,
+                dialogueActs,
+                ownerHints,
+                responseState,
+                hasMentionsSelf,
+                hasQuestions,
+                hasMedia,
+                candidateCount: hasMentionsSelf || hasSelfQuestion ? 1 : 0,
+                digest,
+                engineVersion,
+            });
+            currentEpisode = [];
+        };
+        for (const event of sorted) {
+            if (currentEpisode.length > 0 &&
+                event.sentAt - currentEpisode[currentEpisode.length - 1].sentAt >
+                    EPISODE_GAP_MS) {
+                flush();
+            }
+            currentEpisode.push(event);
+        }
+        flush();
+    }
+    return summaries.sort((a, b) => a.minSentAt - b.minSentAt);
+}
+export function buildRollupSummary(windowStart, windowEnd, episodes, engineVersion = CURRENT_SUMMARY_ENGINE_VERSION) {
+    const matching = episodes.filter((ep) => ep.maxSentAt >= windowStart && ep.minSentAt <= windowEnd);
+    const activeChatIds = [...new Set(matching.map((ep) => ep.chatId))];
+    const episodeIds = matching.map((ep) => ep.episodeId);
+    const totalEvents = matching.reduce((sum, ep) => sum + ep.messageIds.length, 0);
+    const unresolvedFrontierCount = matching.filter((ep) => ep.responseState === 'waiting' || ep.hasMentionsSelf).length;
+    const topics = matching
+        .filter((ep) => ep.dialogueActs.length > 0)
+        .map((ep) => `${ep.chatId}:${ep.dialogueActs.join('+')}`)
+        .slice(0, 10);
+    const rollupId = `rollup-${Math.floor(windowStart / ROLLUP_INTERVAL_MS)}`;
+    const digest = computeDigest(`${rollupId}:${episodeIds.join(',')}:${totalEvents}`);
+    return {
+        rollupId,
+        windowStart,
+        windowEnd,
+        activeChatIds,
+        episodeIds,
+        totalEvents,
+        unresolvedFrontierCount,
+        topics,
+        digest,
+        engineVersion,
+    };
+}

package/dist/ambient/summaries/types.js

@@ -0,0 +1,4 @@
+/**
+ * Types for Hierarchical Summaries (10-minute Episodes & 6-hour Rollups).
+ */
+export {};

package/dist/attention/policy.js

@@ -0,0 +1,101 @@
+import { getDefaultEmbedder } from '../search/default-embedder.js';
+// Natural-language intent descriptions, not trigger-word lists. The local
+// transformer embeds both descriptions and messages; vector similarity does
+// the classification even when no words literally overlap.
+const INTENT_ANCHORS = {
+    reply: [
+        '對方直接向我提出問題、請求協助或要求我做決定，正在等待我的答覆',
+        '工作交辦或需要我採取具體行動並回覆結果',
+    ],
+    deadline: [
+        '有明確期限、會議時間、預約或即將到期的工作，需要及時處理',
+        '緊急事故、風險或延誤，若不處理會造成後果',
+    ],
+    transaction: [
+        '與我有關的帳單、付款、訂單、物流、航班、預約或帳號安全狀態異常',
+        '交易失敗、行程變更或服務中斷，需要本人確認',
+    ],
+    important: [
+        '與目前工作或生活直接相關的重要進度與公告，值得本人閱讀但不必回覆',
+        '關鍵人物提供需要掌握的決策背景或狀態更新',
+    ],
+    ordinary: [
+        '一般聊天、問候、貼圖、轉傳或沒有下一步的日常資訊',
+        '內容與本人沒有直接關係，也不需要採取行動',
+    ],
+    promotion: [
+        '品牌官方帳號寄送的行銷廣告、優惠活動、導購內容或宣傳文案',
+        '用吸引人的疑問句包裝促銷活動，但並非真的在等待本人回答',
+    ],
+};
+function dot(a, b) {
+    let value = 0;
+    for (let i = 0; i < Math.min(a.length, b.length); i++)
+        value += a[i] * b[i];
+    return value;
+}
+/** Transformer-embedding semantic classification followed only by explicit
+ * product controls such as mute, mention and manual priority. */
+export async function scoreAttentionBatch(inputs, embedder = getDefaultEmbedder()) {
+    if (inputs.length === 0)
+        return [];
+    const intents = Object.keys(INTENT_ANCHORS);
+    const anchors = intents.flatMap((intent) => INTENT_ANCHORS[intent].map((text) => ({ intent, text })));
+    const vectors = await embedder.embed([
+        ...anchors.map((anchor) => anchor.text),
+        ...inputs.map((input) => input.text || '無文字訊息'),
+    ]);
+    const anchorVectors = vectors.slice(0, anchors.length);
+    const messageVectors = vectors.slice(anchors.length);
+    return inputs.map((input, inputIndex) => {
+        if (input.isMuted)
+            return { score: -100, tier: 'filtered', reason: 'muted' };
+        if (input.explicitPriority)
+            return { score: 70, tier: 'now', reason: 'manual_priority' };
+        if (input.hasMention)
+            return { score: 65, tier: 'now', reason: 'direct_mention' };
+        if (input.isOfficial &&
+            /^\[yomi:(?:image|rich|sticker|video|audio|file|extended_image)\]$/.test(input.text.trim())) {
+            return { score: 0, tier: 'filtered', reason: 'ordinary' };
+        }
+        const similarities = new Map();
+        anchors.forEach((anchor, anchorIndex) => {
+            const similarity = dot(messageVectors[inputIndex], anchorVectors[anchorIndex]);
+            similarities.set(anchor.intent, Math.max(similarities.get(anchor.intent) ?? -Infinity, similarity));
+        });
+        const ranked = [...intents].sort((a, b) => (similarities.get(b) ?? 0) - (similarities.get(a) ?? 0));
+        const intent = ranked[0];
+        if (input.isOfficial && intent !== 'transaction') {
+            return {
+                score: -40,
+                tier: 'filtered',
+                reason: intent === 'promotion' ? 'promotion' : 'ordinary',
+            };
+        }
+        const scoreByIntent = {
+            reply: 55,
+            deadline: 60,
+            transaction: 50,
+            important: 25,
+            ordinary: 0,
+            promotion: -40,
+        };
+        const score = scoreByIntent[intent];
+        const tier = score >= 55
+            ? 'now'
+            : score >= 35
+                ? 'today'
+                : score >= 20
+                    ? 'know'
+                    : 'filtered';
+        const reasons = {
+            reply: 'reply_expected',
+            deadline: 'deadline',
+            transaction: 'transaction',
+            important: 'important',
+            ordinary: 'ordinary',
+            promotion: 'promotion',
+        };
+        return { score, tier, reason: reasons[intent] };
+    });
+}

package/dist/auth/credential-store.js

@@ -13,9 +13,8 @@
  * rotated auth token during `resumeSession`), not only by a direct login.
  *
  * Keychain account: namespace (e.g. 'line')
- * KeychainService service name: see keychain.ts — writes go to Yomi's own
- * canonical namespace; a legacy namespace from before this split is read
- * as a fallback and migrated forward, never written to or deleted.
+ * KeychainService service name: see keychain.ts — stored in Yomi's canonical
+ * namespace (`dev.rikai.yomi.credentials`), shared across Yomi MCP and Yomi Desktop.
  *
  * The Keychain is machine-global: it is NOT scoped by YOMI_DATA_DIR, so on
  * macOS an automated run that only redirected the data dir would still find —
@@ -87,7 +86,7 @@ class VolatileCacheStore {
     cache = new Map();
     loaded = false;
     dirty = false;
-    writing = false;
+    flushPromise = null;
     constructor(filePath) {
         this.filePath = filePath;
     }
@@ -140,11 +139,10 @@ class VolatileCacheStore {
     /** Coalesce bursts of writes into a single atomic flush cycle. */
     scheduleFlush() {
         this.dirty = true;
-        if (this.writing) {
+        if (this.flushPromise) {
             return;
         }
-        this.writing = true;
-        void (async () => {
+        this.flushPromise = (async () => {
             const fs = await import('node:fs/promises');
             while (this.dirty) {
                 this.dirty = false;
@@ -170,8 +168,13 @@ class VolatileCacheStore {
                     // Best-effort cache persistence; in-memory copy still serves reads.
                 }
             }
-            this.writing = false;
-        })();
+        })().finally(() => {
+            this.flushPromise = null;
+        });
+    }
+    async flush() {
+        while (this.flushPromise)
+            await this.flushPromise;
     }
 }
 /**
@@ -197,8 +200,13 @@ export class CredentialStore {
         this.filePath = fallbackFilePath;
         this.cache = new Map();
         this.loaded = false;
+        // Desktop background bridges are deliberately read-only.  They must use
+        // the user-isolated credential file and never invoke `security` to mutate
+        // the Keychain during a 15s poll (which causes repeated macOS prompts).
         this.secureStorageEnabled =
-            process.platform === 'darwin' && process.env.YOMI_NO_KEYCHAIN !== '1';
+            process.platform === 'darwin' &&
+                process.env.YOMI_NO_KEYCHAIN !== '1' &&
+                process.env.YOMI_READ_ONLY_SESSION !== '1';
         this.keychainService = this.secureStorageEnabled
             ? getKeychainService()
             : null;
@@ -217,20 +225,31 @@ export class CredentialStore {
      * @returns Serialized credential blob or null when missing.
      */
     async readPersistedBlob() {
+        try {
+            const fs = await import('node:fs/promises');
+            const fileData = await fs.readFile(this.filePath, 'utf-8');
+            if (fileData?.trim()) {
+                return fileData;
+            }
+        }
+        catch { }
         if (this.secureStorageEnabled && this.keychainService) {
             const result = await this.keychainService.getCredential(this.keychainAccount);
             if (result.success && result.password) {
+                try {
+                    const fs = await import('node:fs/promises');
+                    await fs.mkdir(dirname(this.filePath), {
+                        recursive: true,
+                        mode: 0o700,
+                    });
+                    await fs.writeFile(this.filePath, result.password, { mode: 0o600 });
+                }
+                catch { }
                 return result.password;
             }
             return null;
         }
-        try {
-            const fs = await import('node:fs/promises');
-            return await fs.readFile(this.filePath, 'utf-8');
-        }
-        catch {
-            return null;
-        }
+        return null;
     }
     /**
      * Load all credentials into cache from keychain or file.
@@ -263,6 +282,12 @@ export class CredentialStore {
         }
         if (this.secureStorageEnabled && this.keychainService) {
             await this.keychainService.setCredential(this.keychainAccount, blob);
+            try {
+                const fs = await import('node:fs/promises');
+                await fs.mkdir(dirname(this.filePath), { recursive: true, mode: 0o700 });
+                await fs.writeFile(this.filePath, blob, { mode: 0o600 });
+            }
+            catch { }
             this.lastPersistedBlob = blob;
             return;
         }
@@ -340,6 +365,11 @@ export class CredentialStore {
             return persisted;
         });
     }
+    /** Await durable and volatile write queues, primarily for orderly shutdown. */
+    async flush() {
+        await this.persistQueue;
+        await this.volatile.flush();
+    }
     /**
      * Delete a credential and persist.
      * @param key - Credential key to delete.

package/dist/auth/keychain.js

@@ -8,20 +8,12 @@
 import { spawn } from 'node:child_process';
 import { createCliLogger } from '../util/log.js';
 /**
- * Yomi's own Keychain service name. Yomi performs a first-party
+ * Yomi's Keychain service name. Yomi performs a first-party
  * passwordless LINE login (see the `login` MCP tool) and persists the
  * resulting session here — auth token, certificate, refresh token, mid,
- * and the E2EE NaCl keypair. All writes go through this namespace only.
+ * and the E2EE NaCl keypair. Shared between Yomi MCP and Yomi Desktop.
  */
-const SERVICE_NAME = 'com.yomi.credentials';
-/**
- * Legacy keychain service name, read-only. Predates Yomi owning its own
- * credentials; kept solely so a live session created before this split
- * keeps working without forcing the operator through a phone-PIN
- * re-login. Entries here are read and migrated forward into
- * `SERVICE_NAME`, never written to and never deleted.
- */
-const LEGACY_SERVICE_NAME = 'com.inboxd.credentials';
+const SERVICE_NAME = 'dev.rikai.yomi.credentials';
 const authLog = createCliLogger('AUTH');
 /**
  * Wrapper for macOS `security` keychain CLI commands.
@@ -49,6 +41,7 @@ class KeychainCommands {
                 '-w',
                 password,
                 '-U',
+                '-A',
             ]);
             let stderr = '';
             child.stderr.on('data', (data) => {
@@ -166,20 +159,12 @@ class KeychainCommands {
 /**
  * Service for managing macOS Keychain credentials.
  *
- * Reads try the canonical namespace first, then fall back to the legacy
- * namespace and migrate a hit forward. Writes and deletes only ever touch
- * the canonical namespace — the legacy entry is never deleted.
+ * Direct reads, writes, and deletes on the canonical Yomi namespace.
  */
 export class KeychainService {
     commands;
-    legacyCommands;
-    // Accounts whose canonical entry this process has already seen (read or
-    // written). Once seen, a later read miss is treated as transient and must
-    // NOT fall back to the legacy namespace — see getCredential.
-    canonicalSeen = new Set();
     constructor() {
         this.commands = new KeychainCommands(SERVICE_NAME);
-        this.legacyCommands = new KeychainCommands(LEGACY_SERVICE_NAME);
     }
     /**
      * Stores a credential in Keychain.
@@ -189,52 +174,20 @@ export class KeychainService {
      * @returns Promise resolving to credential result.
      */
     async setCredential(account, password) {
-        // `add-generic-password -U` updates the item in place when it exists, so
-        // this is a single atomic keychain op. Do NOT delete-then-add: that leaves
-        // a window where the entry is absent, during which a concurrent read falls
-        // through to the legacy namespace and resurrects stale credentials over the
-        // current ones (the root of the "session silently logged out" bug).
-        const result = await this.commands.set(account, password);
-        if (result.success) {
-            this.canonicalSeen.add(account);
-        }
-        return result;
+        return await this.commands.set(account, password);
     }
     /**
      * Retrieves a credential from Keychain.
      *
-     * Tries the canonical namespace first. Only if this process has NEVER seen
-     * the canonical entry does it fall back to the legacy namespace and migrate a
-     * hit forward (one-time). Once the canonical entry has been seen, a later
-     * miss is transient (item mid-update) and returns the miss as-is rather than
-     * resurrecting a stale legacy copy on top of the live session.
-     *
      * @param account - Account name.
      * @returns Promise resolving to credential result.
      */
     async getCredential(account) {
-        const primary = await this.commands.get(account);
-        if (primary.success) {
-            this.canonicalSeen.add(account);
-            return primary;
-        }
-        if (this.canonicalSeen.has(account)) {
-            return primary;
-        }
-        const legacy = await this.legacyCommands.get(account);
-        if (legacy.success && legacy.password) {
-            await this.commands.set(account, legacy.password);
-            this.canonicalSeen.add(account);
-            authLog.info('keychain.migrated_from_legacy', { account });
-        }
-        return legacy;
+        return await this.commands.get(account);
     }
     /**
      * Deletes a credential from Keychain.
      *
-     * Operates on the canonical namespace only. The legacy namespace is
-     * never deleted, even here.
-     *
      * @param account - Account name.
      * @returns Promise resolving to credential result.
      */