@rikaidev/yomi 0.5.0 → 0.6.0

package/dist/work-item/work-event-matcher.js

@@ -0,0 +1,105 @@
+function ngrams(value, size = 2) {
+    const normalized = value
+        .normalize('NFKC')
+        .toLocaleLowerCase()
+        .replace(/[\p{P}\p{S}\s]+/gu, '');
+    if (!normalized)
+        return new Set();
+    if (normalized.length <= size)
+        return new Set([normalized]);
+    return new Set(Array.from({ length: normalized.length - size + 1 }, (_, index) => normalized.slice(index, index + size)));
+}
+function jaccard(left, right) {
+    if (left.size === 0 && right.size === 0)
+        return 1;
+    if (left.size === 0 || right.size === 0)
+        return 0;
+    let intersection = 0;
+    for (const value of left)
+        if (right.has(value))
+            intersection += 1;
+    return intersection / (left.size + right.size - intersection);
+}
+function actionText(event) {
+    if (!event.action)
+        return '';
+    return [
+        event.action.predicate,
+        event.action.object,
+        event.action.expectedOutcome,
+    ]
+        .filter(Boolean)
+        .join(' ');
+}
+export function workEventSimilarity(previous, incoming) {
+    if (previous.chatId !== incoming.chatId ||
+        previous.createsWork !== incoming.createsWork)
+        return 0;
+    const evidence = jaccard(new Set(previous.evidence.map((item) => item.messageId)), new Set(incoming.evidence.map((item) => item.messageId)));
+    const action = jaccard(ngrams(actionText(previous)), ngrams(actionText(incoming)));
+    const previousOwners = new Set(previous.ownership.owners.map((owner) => owner.kind));
+    const incomingOwners = new Set(incoming.ownership.owners.map((owner) => owner.kind));
+    const ownership = jaccard(previousOwners, incomingOwners);
+    return Number((evidence * 0.45 + action * 0.45 + ownership * 0.1).toFixed(4));
+}
+/** Maximum-weight one-to-one matching keeps sibling events distinct across revisions. */
+export function matchWorkEventRevisions(previous, incoming, minimumScore = 0.55) {
+    const candidates = incoming
+        .flatMap((next, incomingIndex) => previous.map((prior, previousIndex) => ({
+        incomingIndex,
+        previousIndex,
+        score: workEventSimilarity(prior, next),
+    })))
+        .filter((match) => match.score >= minimumScore)
+        .sort((left, right) => right.score - left.score ||
+        left.incomingIndex - right.incomingIndex ||
+        left.previousIndex - right.previousIndex);
+    if (previous.length <= 16 && incoming.length <= 16) {
+        const byIncoming = new Map();
+        for (const candidate of candidates) {
+            byIncoming.set(candidate.incomingIndex, [
+                ...(byIncoming.get(candidate.incomingIndex) ?? []),
+                candidate,
+            ]);
+        }
+        const memo = new Map();
+        const solve = (incomingIndex, claimedMask) => {
+            if (incomingIndex >= incoming.length)
+                return { score: 0, matches: [] };
+            const key = `${incomingIndex}:${claimedMask}`;
+            const cached = memo.get(key);
+            if (cached)
+                return cached;
+            let best = solve(incomingIndex + 1, claimedMask);
+            for (const candidate of byIncoming.get(incomingIndex) ?? []) {
+                const bit = 1 << candidate.previousIndex;
+                if ((claimedMask & bit) !== 0)
+                    continue;
+                const rest = solve(incomingIndex + 1, claimedMask | bit);
+                const option = {
+                    score: candidate.score + rest.score,
+                    matches: [candidate, ...rest.matches],
+                };
+                if (option.score > best.score ||
+                    (option.score === best.score &&
+                        option.matches.length > best.matches.length))
+                    best = option;
+            }
+            memo.set(key, best);
+            return best;
+        };
+        return solve(0, 0).matches.sort((left, right) => left.incomingIndex - right.incomingIndex);
+    }
+    const claimedIncoming = new Set();
+    const claimedPrevious = new Set();
+    const matches = [];
+    for (const candidate of candidates) {
+        if (claimedIncoming.has(candidate.incomingIndex) ||
+            claimedPrevious.has(candidate.previousIndex))
+            continue;
+        claimedIncoming.add(candidate.incomingIndex);
+        claimedPrevious.add(candidate.previousIndex);
+        matches.push(candidate);
+    }
+    return matches.sort((left, right) => left.incomingIndex - right.incomingIndex);
+}

package/dist/work-item/work-event-model-manifest.js

@@ -0,0 +1,39 @@
+function validDigest(value) {
+    return /^[a-f0-9]{64}$/u.test(value);
+}
+export function productionEligibilityErrors(manifest) {
+    const errors = [];
+    if (manifest.schemaVersion !== 1)
+        errors.push('manifest_schema_unsupported');
+    if (!manifest.modelId)
+        errors.push('model_id_missing');
+    if (!validDigest(manifest.artifactSha256))
+        errors.push('artifact_digest_invalid');
+    if (!manifest.quantization)
+        errors.push('quantization_missing');
+    if (!manifest.sourceModel)
+        errors.push('source_model_missing');
+    if (!manifest.datasetRevision)
+        errors.push('dataset_revision_missing');
+    for (const [name, evidence] of Object.entries({
+        conversationSplit: manifest.conversationSplit,
+        factorizedCoverage: manifest.factorizedCoverage,
+        publicAcceptance: manifest.publicAcceptance,
+        privateAcceptance: manifest.privateAcceptance,
+        quantizationValidation: manifest.quantizationValidation,
+        targetHardwareBenchmark: manifest.targetHardwareBenchmark,
+    })) {
+        if (!evidence?.passed)
+            errors.push(`${name}_not_passed`);
+        if (!evidence || !validDigest(evidence.reportSha256))
+            errors.push(`${name}_report_digest_invalid`);
+    }
+    if (!manifest.modelOwnerApproved)
+        errors.push('model_owner_not_approved');
+    return errors;
+}
+export function assertProductionEligibleModel(manifest) {
+    const errors = productionEligibilityErrors(manifest);
+    if (errors.length > 0)
+        throw new Error(`Work-event model is not production eligible: ${errors.join(', ')}`);
+}

package/dist/work-item/work-event-store.js

@@ -0,0 +1,125 @@
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { yomiDataPath } from '../util/data-dir.js';
+function digest(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function persist(revision) {
+    return {
+        eventIdHash: digest(revision.eventId),
+        chatIdHash: digest(revision.chatId),
+        schemaVersion: 1,
+        revision: revision.revision,
+        previousRevision: revision.previousRevision,
+        active: revision.active,
+        evidence: revision.evidence.map((item) => ({
+            messageIdHash: digest(item.messageId),
+            sentAt: item.sentAt,
+            speaker: item.speaker,
+        })),
+        dialogue: revision.dialogue.map((item) => ({
+            ...item,
+            messageId: digest(item.messageId),
+        })),
+        createsWork: revision.createsWork,
+        workConfidence: revision.workConfidence,
+        action: revision.action
+            ? {
+                predicateHash: digest(revision.action.predicate),
+                objectHash: revision.action.object
+                    ? digest(revision.action.object)
+                    : null,
+                expectedOutcomeHash: revision.action.expectedOutcome
+                    ? digest(revision.action.expectedOutcome)
+                    : null,
+                dueAt: revision.action.dueAt,
+                confidence: revision.action.confidence,
+                evidenceMessageIdHashes: revision.action.evidenceMessageIds.map(digest),
+            }
+            : null,
+        ownership: {
+            state: revision.ownership.state,
+            confidence: revision.ownership.confidence,
+            evidenceMessageIdHashes: revision.ownership.evidenceMessageIds.map(digest),
+            owners: revision.ownership.owners.map((owner) => ({
+                kind: owner.kind,
+                stableIdHash: owner.stableId ? digest(owner.stableId) : null,
+                displayNameHash: owner.displayName ? digest(owner.displayName) : null,
+            })),
+        },
+        dependency: {
+            state: revision.dependency.state,
+            confidence: revision.dependency.confidence,
+            evidenceMessageIdHashes: revision.dependency.evidenceMessageIds.map(digest),
+            on: revision.dependency.on
+                ? {
+                    kind: revision.dependency.on.kind,
+                    stableIdHash: revision.dependency.on.stableId
+                        ? digest(revision.dependency.on.stableId)
+                        : null,
+                    displayNameHash: revision.dependency.on.displayName
+                        ? digest(revision.dependency.on.displayName)
+                        : null,
+                }
+                : null,
+        },
+        lifecycle: revision.lifecycle,
+        completion: {
+            ...revision.completion,
+            evidenceMessageIds: revision.completion.evidenceMessageIds.map(digest),
+        },
+        sourceModel: revision.sourceModel,
+        inferredAt: revision.inferredAt,
+        reasons: revision.reasons,
+    };
+}
+/** Metadata-only audit history; decrypted text remains in the secure UI cache. */
+export class WorkEventRevisionStore {
+    path;
+    maxRevisions;
+    writeQueue = Promise.resolve();
+    constructor(path = yomiDataPath('work-event-revisions.json'), maxRevisions = 2000) {
+        this.path = path;
+        this.maxRevisions = maxRevisions;
+    }
+    async append(revision) {
+        await this.appendMany([revision]);
+    }
+    async appendMany(incoming) {
+        if (incoming.length === 0)
+            return;
+        const run = async () => {
+            const current = await this.read();
+            const rows = incoming.map(persist);
+            const incomingKeys = new Set(rows.map((row) => `${row.eventIdHash}:${row.revision}`));
+            const revisions = [
+                ...rows,
+                ...current.filter((item) => !incomingKeys.has(`${item.eventIdHash}:${item.revision}`)),
+            ]
+                .sort((left, right) => right.inferredAt - left.inferredAt)
+                .slice(0, this.maxRevisions);
+            await mkdir(dirname(this.path), { recursive: true });
+            const temporary = `${this.path}.tmp-${process.pid}`;
+            await writeFile(temporary, JSON.stringify({ schemaVersion: 1, revisions }), { mode: 0o600 });
+            await rename(temporary, this.path);
+        };
+        this.writeQueue = this.writeQueue.then(run, run);
+        await this.writeQueue;
+    }
+    async list() {
+        await this.writeQueue;
+        return this.read();
+    }
+    async read() {
+        try {
+            const value = JSON.parse(await readFile(this.path, 'utf8'));
+            return value.schemaVersion === 1 && Array.isArray(value.revisions)
+                ? value.revisions
+                : [];
+        }
+        catch {
+            return [];
+        }
+    }
+}

package/dist/work-item/work-event.js

@@ -0,0 +1,123 @@
+function sameValue(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+function evidenceUnion(previous, incoming) {
+    return [
+        ...new Map([...previous, ...incoming].map((item) => [item.messageId, item])).values(),
+    ].sort((left, right) => left.sentAt - right.sentAt);
+}
+/**
+ * Append a new authoritative revision without making lifecycle monotonic.
+ * A later event window may disprove an earlier completion and reopen work.
+ */
+export function reviseWorkEvent(previous, inference, explicitReasons = []) {
+    if (!previous) {
+        return {
+            ...inference,
+            schemaVersion: 1,
+            revision: 1,
+            previousRevision: null,
+            active: inference.createsWork,
+            reasons: ['created', ...explicitReasons],
+        };
+    }
+    if (previous.eventId !== inference.eventId) {
+        throw new Error('Cannot revise a different work event');
+    }
+    const evidence = evidenceUnion(previous.evidence, inference.evidence);
+    const evidenceAdded = evidence.length > previous.evidence.length;
+    const inferenceChanged = !sameValue({
+        dialogue: previous.dialogue,
+        createsWork: previous.createsWork,
+        action: previous.action,
+        ownership: previous.ownership,
+        dependency: previous.dependency,
+        lifecycle: previous.lifecycle,
+        completion: previous.completion,
+    }, {
+        dialogue: inference.dialogue,
+        createsWork: inference.createsWork,
+        action: inference.action,
+        ownership: inference.ownership,
+        dependency: inference.dependency,
+        lifecycle: inference.lifecycle,
+        completion: inference.completion,
+    });
+    const wasClosed = ['accepted', 'cancelled', 'resolved'].includes(previous.lifecycle);
+    const isOpen = ['proposed', 'committed', 'in_progress', 'blocked'].includes(inference.lifecycle);
+    const reasons = [
+        ...(evidenceAdded ? ['evidence_added'] : []),
+        ...(inferenceChanged ? ['inference_changed'] : []),
+        ...(wasClosed && isOpen ? ['reopened'] : []),
+        ...explicitReasons,
+    ];
+    return {
+        ...inference,
+        evidence,
+        schemaVersion: 1,
+        revision: previous.revision + 1,
+        previousRevision: previous.revision,
+        active: inference.createsWork &&
+            !['accepted', 'cancelled', 'resolved'].includes(inference.lifecycle),
+        reasons: [...new Set(reasons)],
+    };
+}
+export function excludeWorkEvent(previous, temporary = false) {
+    return {
+        ...previous,
+        revision: previous.revision + 1,
+        previousRevision: previous.revision,
+        active: false,
+        reasons: [temporary ? 'temporarily_excluded' : 'excluded'],
+    };
+}
+export function splitWorkEvent(previous, childInferences) {
+    if (childInferences.length < 2)
+        throw new Error('A split requires at least two child events');
+    const previousEvidence = new Set(previous.evidence.map((item) => item.messageId));
+    const childIds = new Set();
+    for (const child of childInferences) {
+        if (childIds.has(child.eventId))
+            throw new Error('Split children require distinct event ids');
+        childIds.add(child.eventId);
+        if (child.evidence.length === 0)
+            throw new Error('Split child requires evidence');
+        for (const evidence of child.evidence) {
+            if (!previousEvidence.has(evidence.messageId))
+                throw new Error('Split child contains evidence outside the parent event');
+        }
+    }
+    const superseded = {
+        ...previous,
+        revision: previous.revision + 1,
+        previousRevision: previous.revision,
+        active: false,
+        reasons: ['split'],
+    };
+    return {
+        superseded,
+        children: childInferences.map((child) => ({
+            ...reviseWorkEvent(null, child, ['split']),
+            previousRevision: previous.revision,
+        })),
+    };
+}
+export function mergeWorkEvents(previous, mergedInference) {
+    if (previous.length < 2)
+        throw new Error('A merge requires at least two source events');
+    const sourceEvidence = new Set(previous.flatMap((event) => event.evidence.map((item) => item.messageId)));
+    for (const evidence of mergedInference.evidence) {
+        if (!sourceEvidence.has(evidence.messageId))
+            throw new Error('Merged event contains unknown evidence');
+    }
+    return {
+        superseded: previous.map((event) => ({
+            ...event,
+            revision: event.revision + 1,
+            previousRevision: event.revision,
+            active: false,
+            reasons: ['merged'],
+        })),
+        merged: reviseWorkEvent(null, mergedInference, ['merged']),
+    };
+}

package/package.json

@@ -3,7 +3,7 @@
   "engines": {
     "node": ">=22.13.0 <23.0.0 || >=23.4.0"
   },
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Open-source personal LINE MCP server for AI agents. Read, reply, send images, and search LINE conversations locally with Letter-Sealing E2EE.",
   "type": "module",
   "license": "MIT",
@@ -45,11 +45,32 @@
     "lint:fix": "biome check --write src/",
     "lint:comments": "node scripts/lint-comments.mjs",
     "hooks:install": "git config core.hooksPath .githooks",
-    "pretest": "npm run lint:comments",
+    "pretest": "npm run lint:comments && npm run test:fixture-hygiene",
     "format": "biome format --write src/",
     "test": "bun test",
+    "predesktop:build": "npm run build",
+    "desktop:build": "bash scripts/build-swift-desktop.sh",
+    "desktop:clean": "node scripts/clean-desktop-artifacts.mjs",
+    "desktop:clean:all": "node scripts/clean-desktop-artifacts.mjs --all",
+    "desktop:harness": "node scripts/desktop-harness.mjs",
+    "desktop:qos": "node scripts/desktop-qos-harness.mjs",
+    "desktop:flex-parity": "npm run build && node scripts/flex-layout-parity-harness.mjs",
+    "desktop:swift-quality": "bash scripts/swift-quality.sh",
+    "desktop:i18n-harness": "node scripts/swift-i18n-harness.mjs",
+    "desktop:restart": "node scripts/desktop-harness.mjs --restart",
+    "desktop:run": "./desktop/mac-native/Yomi.app/Contents/MacOS/Yomi",
+    "desktop:core:macos": "node scripts/package-desktop-core.mjs --platform macos --output build/desktop-core-macos --semantic full",
+    "desktop:core:windows": "node scripts/package-desktop-core.mjs --platform windows --output build/desktop-core-windows --semantic full",
+    "desktop:package:harness": "node scripts/desktop-package-harness.mjs",
+    "desktop:windows:build": "cargo build --manifest-path desktop/Cargo.toml --release --target x86_64-pc-windows-msvc",
+    "desktop:windows:lint": "cargo fmt --manifest-path desktop/Cargo.toml -- --check && cargo clippy --manifest-path desktop/Cargo.toml --target x86_64-pc-windows-msvc -- -D warnings",
+    "desktop:windows:qc": "npm run typecheck && npm run lint && npm run lint:comments && cargo test --manifest-path desktop/Cargo.toml && npm run desktop:windows:lint",
+    "desktop:windows:i18n": "node scripts/windows-i18n-harness.mjs",
+    "desktop:windows:harness": "node scripts/windows-desktop-harness.mjs",
     "version": "node scripts/sync-version.mjs && git add src/version.ts",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "test:fixture-hygiene": "node scripts/test-fixture-hygiene.mjs",
+    "desktop:install-local": "bash scripts/install-swift-desktop-local.sh"
   },
   "dependencies": {
     "@huggingface/transformers": "^4.2.0",

package/run.mjs

@@ -46,6 +46,15 @@ const ext = built ? '.js' : '.ts';
 /** Import a module by its path under src/, resolved to dist/ when built. */
 const load = (path) => import(new URL(path + ext, base).href);
 
+const writeStdout = (text) =>
+  new Promise((resolve, reject) => {
+    process.stdout.write(text, (error) => {
+      if (error) reject(error);
+      else resolve();
+    });
+  });
+const writeJson = (value) => writeStdout(`${JSON.stringify(value)}\n`);
+
 const args = process.argv.slice(2);
 const cmd = args[0] ?? 'serve';
 
@@ -80,10 +89,91 @@ switch (cmd) {
     const { cliListConversationsJson } = await load('cli/query');
     const limit = args[1] && args[1] !== 'all' ? parseInt(args[1], 10) : undefined;
     const attentionOnly = args.includes('--attention-only');
-    const firstPage = args.includes('--first-page');
     const semantic = args.includes('--semantic');
-    const json = await cliListConversationsJson({ limit, attentionOnly, firstPage, semantic });
-    console.log(JSON.stringify(json));
+    const json = await cliListConversationsJson({ limit, attentionOnly, semantic });
+    await writeJson(json);
+    process.exit(0);
+  }
+  case 'desktop-inbox': {
+    // Keep one authenticated LINE runtime for the complete desktop startup
+    // pass. Its resume result is the session authority; do not infer logout
+    // from an empty list, a cache miss, or a second probe process.
+    const { LineProtocolService } = await load('line/core/service');
+    const { cliListConversationsJson } = await load('cli/query');
+    const service = new LineProtocolService();
+    const connected = await service.resumeSession();
+    if (!connected) {
+      await writeJson({
+        session: { connected: false, reason: service.loginReason ?? 'unavailable' },
+        chats: [],
+      });
+      process.exit(0);
+    }
+    const chats = await cliListConversationsJson({}, service);
+    await writeJson({ session: { connected: true, reason: null }, chats });
+    process.exit(0);
+  }
+  case 'desktop-startup-messages': {
+    // One shared runtime warms all requested rooms at launch. This is a
+    // startup batch, not a click-triggered series of independent sessions.
+    const { LineProtocolService } = await load('line/core/service');
+    const { cliGetChatMessagesJson } = await load('cli/query');
+    const chatIds = args.slice(1).filter(Boolean);
+    const service = new LineProtocolService();
+    const connected = await service.resumeSession();
+    if (!connected) {
+      await writeJson({
+        session: { connected: false, reason: service.loginReason ?? 'unavailable' },
+        messages: {},
+      });
+      process.exit(0);
+    }
+    const messages = {};
+    for (const chatId of chatIds) {
+      messages[chatId] = await cliGetChatMessagesJson(chatId, 40, service);
+    }
+    await writeJson({ session: { connected: true, reason: null }, messages });
+    process.exit(0);
+  }
+  case 'work-item': {
+    const operation = args[1] || 'create';
+    let input = '';
+    for await (const chunk of process.stdin) input += chunk;
+    let payload;
+    try {
+      payload = JSON.parse(input || '{}');
+    } catch {
+      console.error(JSON.stringify({ error: 'invalid JSON payload' }));
+      process.exit(1);
+    }
+    const { cliCreateWorkItemDraftJson, cliWorkItemOperationJson } = await load('cli/work-item');
+    try {
+      const result = operation === 'create'
+        ? await cliCreateWorkItemDraftJson(
+            payload.messages || payload.message,
+            payload.options || {},
+          )
+        : await cliWorkItemOperationJson(operation, payload.draft);
+      await writeJson(result);
+      process.exit(0);
+    } catch (error) {
+      console.error(JSON.stringify({ error: error instanceof Error ? error.message : String(error) }));
+      process.exit(1);
+    }
+  }
+  case 'ambient-observe': {
+    const { scanAmbientObservations } = await load('ambient/ambient-observer');
+    const since = args[1] ? Number(args[1]) : undefined;
+    const report = await scanAmbientObservations(Number.isFinite(since) ? since : undefined);
+    // Work-event promotion intentionally abstains until the factorized model
+    // contract passes its independent acceptance suite. Ambient candidates
+    // remain available as revisable evidence; no flat classifier is allowed
+    // to create authoritative work items.
+    await writeJson({ ...report, workItems: [] });
+    process.exit(0);
+  }
+  case 'work-items': {
+    await writeJson([]);
     process.exit(0);
   }
   case 'messages':
@@ -96,7 +186,20 @@ switch (cmd) {
       process.exit(1);
     }
     const json = await cliGetChatMessagesJson(chatId, count);
-    console.log(JSON.stringify(json));
+    await writeJson(json);
+    process.exit(0);
+  }
+  case 'rich-menu': {
+    const chatId = args[1];
+    if (!chatId) {
+      console.error(JSON.stringify({ error: 'chatId required' }));
+      process.exit(1);
+    }
+    const { LineProtocolService } = await load('line/core/service');
+    const service = new LineProtocolService();
+    if (!(await service.resumeSession())) process.exit(1);
+    const menu = await service.client.getBuddyRichMenu(chatId);
+    await writeJson(menu);
     process.exit(0);
   }
   case 'attention-classify': {
@@ -104,13 +207,13 @@ switch (cmd) {
     let input = '';
     for await (const chunk of process.stdin) input += chunk;
     const items = JSON.parse(input || '[]');
-    console.log(JSON.stringify(await cliClassifyAttentionJson(items)));
+    await writeJson(await cliClassifyAttentionJson(items));
     process.exit(0);
   }
   case 'list-stickers': {
     const { cliListStickersJson } = await load('cli/query');
     const language = args[1] || 'zh_TW';
-    console.log(JSON.stringify(await cliListStickersJson(language)));
+    await writeJson(await cliListStickersJson(language));
     process.exit(0);
   }
   case 'sticker-previews': {
@@ -122,7 +225,7 @@ switch (cmd) {
       console.error(JSON.stringify({ error: 'packageId required' }));
       process.exit(1);
     }
-    console.log(JSON.stringify(await cliStickerPreviewsJson(packageId, limit, language)));
+    await writeJson(await cliStickerPreviewsJson(packageId, limit, language));
     process.exit(0);
   }
   case 'send-sticker': {
@@ -215,6 +318,32 @@ switch (cmd) {
     }));
     process.exit(0);
   }
+  case 'send-audio': {
+    const chatId = args[1];
+    const filePath = args[2];
+    const fileName = args[3];
+    if (!chatId || !filePath) {
+      console.error(JSON.stringify({ error: 'chatId and filePath required' }));
+      process.exit(1);
+    }
+    const { LineProtocolService } = await load('line/core/service');
+    const { readFile } = await import('node:fs/promises');
+    const { basename } = await import('node:path');
+    const service = new LineProtocolService();
+    if (!(await service.resumeSession())) process.exit(1);
+    const bytes = await readFile(filePath);
+    if (bytes.length === 0) {
+      console.error(JSON.stringify({ error: 'audio is empty' }));
+      process.exit(1);
+    }
+    const sent = await service.sendAudio(chatId, bytes, fileName || basename(filePath));
+    console.log(JSON.stringify({
+      sent: true,
+      messageId: sent?.messageId ?? sent?.id ?? null,
+      oid: sent?.oid ?? null,
+    }));
+    process.exit(0);
+  }
   case 'media-preview': {
     const chatId = args[1];
     const messageId = args[2];
@@ -227,11 +356,21 @@ switch (cmd) {
     const service = new LineProtocolService();
     if (!(await service.resumeSession())) process.exit(1);
     const result = await fetchLineMessageMedia(service, chatId, messageId, args[3] !== 'original');
-    console.log(JSON.stringify({
+    if (args.includes('--file-output')) {
+      const { mkdtemp, writeFile } = await import('node:fs/promises');
+      const { join } = await import('node:path');
+      const { tmpdir } = await import('node:os');
+      const directory = await mkdtemp(join(tmpdir(), 'yomi-media-'));
+      const filePath = join(directory, 'payload');
+      await writeFile(filePath, result.bytes, { mode: 0o600 });
+      await writeJson({ filePath, mimeType: result.mimeType, fileName: result.fileName ?? null });
+      process.exit(0);
+    }
+    await writeJson({
       data: result.bytes.toString('base64'),
       mimeType: result.mimeType,
       fileName: result.fileName ?? null,
-    }));
+    });
     process.exit(0);
   }
   case 'mark-read': {
@@ -246,6 +385,20 @@ switch (cmd) {
     console.log(JSON.stringify(res));
     process.exit(0);
   }
+  case 'set-chat-muted': {
+    const chatId = args[1];
+    const disabled = args[2] === 'true';
+    if (!chatId?.startsWith('u') || !['true', 'false'].includes(args[2])) {
+      console.error(JSON.stringify({ error: '1:1 chatId and true|false required' }));
+      process.exit(1);
+    }
+    const { LineProtocolService } = await load('line/core/service');
+    const service = new LineProtocolService();
+    if (!(await service.resumeSession())) process.exit(1);
+    await service.client.updateContactNotificationDisabled(chatId, disabled);
+    console.log(JSON.stringify({ success: true, chatId, isMuted: disabled }));
+    process.exit(0);
+  }
   case 'summary':
   case 'recent':
   case 'query': {