@clowder-ai/companion 0.1.0-alpha.12 → 0.1.0-alpha.14

package/README.md

@@ -10,10 +10,19 @@ visible and ends the call in one click. Screen sharing has its own explicit
 picker and termination badge. There is no microphone action on a double-click,
 page load, body tap or drag.
 
+When a compatible Host advertises receive-only audio, **只听** opens the same
+conversation with playback but never requests or toggles a microphone. Older
+Hosts omit that capability, so the control stays hidden and ordinary voice keeps
+the exact legacy connect request. Text remains available independently.
+
 Typing works with voice off. The Host uses the existing owner conversation,
 configured duty cat, ordinary message routing and idempotency. The small history
 view reads a bounded recent subset; **完整聊天** opens the canonical conversation.
 No second transcript database, credentials or selectable Host identity live here.
+When the Host supplies a valid per-message identity snapshot, each history row
+keeps its real author while separately showing the partner, Live carrier and
+deep cat saved with that message. Legacy rows omit this context instead of
+borrowing today's selected companion.
 
 ## Host integration
 

package/manifest.json

@@ -1,6 +1,6 @@
 {
   "pluginId": "official.companion",
-  "version": "0.1.0-alpha.12",
+  "version": "0.1.0-alpha.14",
   "contractVersion": "0.1.0",
   "name": "猫猫球",
   "icon": {
@@ -40,7 +40,7 @@
       "bridgeVersion": "1.3.0",
       "surface": {
         "entrypoint": "renderer/index.html",
-        "integrity": "sha256-x3ponGs/dhxPH5D1rT9JrLqJpFA6rxrgMjSImhksoHQ="
+        "integrity": "sha256-UH8VFfr3q9a5gI2pPPXinKzCTjaGI8ZdvrJngy6i+M0="
       },
       "presentation": {
         "width": 300,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clowder-ai/companion",
-  "version": "0.1.0-alpha.12",
+  "version": "0.1.0-alpha.14",
   "description": "The desktop voice body for your Clowder companion",
   "license": "MIT",
   "type": "module",
@@ -21,13 +21,15 @@
   "scripts": {
     "build": "node scripts/build.mjs",
     "test": "node --test test/*.test.mjs",
+    "test:browser": "pnpm build && node --test test/panel-layout.browser.mjs",
     "typecheck": "node scripts/check.mjs",
     "lint": "node scripts/check.mjs",
     "prepack": "pnpm build"
   },
   "devDependencies": {
-    "@clowder-ai/plugin-contract": "0.1.0-beta.20",
-    "@clowder-ai/plugin-sdk": "0.1.0-beta.16"
+    "@clowder-ai/plugin-contract": "0.1.0-beta.23",
+    "@clowder-ai/plugin-sdk": "0.1.0-beta.19",
+    "playwright": "1.61.1"
   },
   "repository": {
     "type": "git",

package/plugin.yaml

@@ -1,6 +1,6 @@
 {
   "pluginId": "official.companion",
-  "version": "0.1.0-alpha.12",
+  "version": "0.1.0-alpha.14",
   "contractVersion": "0.1.0",
   "name": "猫猫球",
   "icon": {
@@ -40,7 +40,7 @@
       "bridgeVersion": "1.3.0",
       "surface": {
         "entrypoint": "renderer/index.html",
-        "integrity": "sha256-x3ponGs/dhxPH5D1rT9JrLqJpFA6rxrgMjSImhksoHQ="
+        "integrity": "sha256-UH8VFfr3q9a5gI2pPPXinKzCTjaGI8ZdvrJngy6i+M0="
       },
       "presentation": {
         "width": 300,

package/renderer/call-transcript-view.mjs

@@ -0,0 +1,238 @@
+const MAX_LIVE_ROWS = 8;
+
+/**
+ * Projection of the Host-bound transcript for one trusted call.
+ *
+ * Durable rows are keyed only by Host messageId. Ephemeral audio is keyed by
+ * provider item/turn identity and is discarded when the Host projects the
+ * matching durable source. Text equality is deliberately never used.
+ */
+export class CallTranscriptView {
+  constructor(container, { onUnread = () => {} } = {}) {
+    this.container = container;
+    this.onUnread = onUnread;
+    this.durableRows = new Map();
+    this.liveRows = new Map();
+    this.liveSequence = 0;
+    this.optimisticIds = new Set();
+    this.unread = 0;
+    this.initialized = false;
+    container.addEventListener?.('scroll', () => {
+      if (this.nearBottom()) this.setUnread(0);
+    });
+  }
+
+  setCall(callId) {
+    if (this.callId === callId) return;
+    this.callId = callId ?? null;
+    this.scope = undefined;
+    this.durableRows.clear();
+    this.liveRows.clear();
+    this.liveSequence = 0;
+    this.optimisticIds.clear();
+    this.initialized = false;
+    this.container.replaceChildren();
+    this.container.dataset.callId = this.callId ?? '';
+    this.container.dataset.hasMore = 'false';
+    this.setUnread(0);
+  }
+
+  reset() { this.setCall(null); }
+
+  nearBottom() {
+    return this.container.scrollHeight - this.container.scrollTop - this.container.clientHeight < 32;
+  }
+
+  scrollToBottom() {
+    this.container.scrollTop = this.container.scrollHeight;
+    this.setUnread(0);
+  }
+
+  setUnread(count) {
+    if (this.unread === count) return;
+    this.unread = count;
+    this.onUnread(count);
+  }
+
+  visibleAnchor() {
+    const viewport = this.container.getBoundingClientRect?.();
+    if (!viewport) return null;
+    for (const [id, row] of this.durableRows) {
+      const rect = row.getBoundingClientRect?.();
+      if (rect && rect.bottom > viewport.top && rect.top < viewport.bottom) {
+        return { id, offset: rect.top - viewport.top };
+      }
+    }
+    return null;
+  }
+
+  createRow() {
+    return this.container.ownerDocument.createElement('p');
+  }
+
+  updateDurable(row, value) {
+    row.className = `call-transcript-row ${value.source.kind} ${value.role}`;
+    row.textContent = value.text;
+    row.dataset.messageId = value.messageId;
+    row.dataset.source = value.source.kind;
+    row.dataset.role = value.role;
+    delete row.dataset.live;
+    delete row.dataset.itemId;
+    delete row.dataset.turnId;
+    delete row.dataset.optimistic;
+    if (value.source.kind === 'voice') {
+      row.dataset.itemId = value.source.nativeItemId;
+      if (value.source.nativeTurnId) row.dataset.turnId = value.source.nativeTurnId;
+      delete row.dataset.clientMessageId;
+    } else {
+      row.dataset.clientMessageId = value.source.clientMessageId;
+    }
+    row.setAttribute?.('aria-label', value.source.kind === 'typed'
+      ? `你打字说：${value.text}`
+      : value.role === 'assistant' ? `猫猫：${value.text}` : `语音转写：${value.text}`);
+    return row;
+  }
+
+  removeReconciledLive(source) {
+    if (source.kind !== 'voice') return false;
+    let removed = false;
+    for (const [key, row] of this.liveRows) {
+      if ((row.dataset.itemId && row.dataset.itemId === source.nativeItemId)
+        || (source.nativeTurnId && row.dataset.turnId === source.nativeTurnId)) {
+        this.liveRows.delete(key);
+        removed = true;
+      }
+    }
+    return removed;
+  }
+
+  render() {
+    this.container.replaceChildren(...this.durableRows.values(), ...this.liveRows.values());
+  }
+
+  load(reply) {
+    if (!this.callId || reply?.kind !== 'transcript' || reply.scope?.callId !== this.callId) return false;
+    const pinned = this.nearBottom();
+    const readingPosition = this.container.scrollTop;
+    const anchor = pinned ? null : this.visibleAnchor();
+    const previous = this.durableRows;
+    const previousIds = new Set(previous.keys());
+    const next = new Map();
+    let added = 0;
+
+    for (const value of reply.rows) {
+      const reconciledLive = this.removeReconciledLive(value.source);
+      const row = previous.get(value.messageId) ?? this.createRow();
+      this.updateDurable(row, value);
+      this.optimisticIds.delete(value.messageId);
+      next.set(value.messageId, row);
+      if (this.initialized && !previousIds.has(value.messageId) && !reconciledLive) added += 1;
+    }
+    // An accepted delivery already has a durable Host messageId. A transcript
+    // read can race the MessageStore projection, so keep that exact row until
+    // the same id appears; never fall back to matching its text.
+    for (const id of this.optimisticIds) {
+      const row = previous.get(id);
+      if (row && !next.has(id)) next.set(id, row);
+    }
+
+    this.scope = reply.scope;
+    this.durableRows = next;
+    this.container.dataset.callId = reply.scope.callId;
+    this.container.dataset.hasMore = String(reply.hasMore);
+    this.render();
+
+    if (pinned) {
+      this.container.scrollTop = this.container.scrollHeight;
+      this.setUnread(0);
+    } else if (anchor) {
+      const row = this.durableRows.get(anchor.id) ?? this.durableRows.values().next().value;
+      const rect = row?.getBoundingClientRect?.();
+      const viewport = this.container.getBoundingClientRect?.();
+      this.container.scrollTop = rect && viewport
+        ? this.container.scrollTop + rect.top - viewport.top - anchor.offset
+        : readingPosition;
+      if (added) this.setUnread(this.unread + added);
+    } else {
+      this.container.scrollTop = readingPosition;
+      if (added) this.setUnread(this.unread + added);
+    }
+    this.initialized = true;
+    return true;
+  }
+
+  liveKey(event) {
+    if (event.itemId) return `item:${event.itemId}`;
+    if (event.turnId) return `turn:${event.turnId}`;
+    return `ephemeral:${++this.liveSequence}`;
+  }
+
+  appendLive(event) {
+    if (!this.callId || event?.type !== 'transcript' || event.callId !== this.callId) return false;
+    const pinned = this.nearBottom();
+    const key = this.liveKey(event);
+    let row = this.liveRows.get(key);
+    const isNew = !row;
+    if (!row) {
+      row = this.createRow();
+      row.className = `call-transcript-row voice ${event.role}`;
+      row.dataset.live = 'true';
+      row.dataset.source = 'voice';
+      row.dataset.role = event.role;
+      if (event.itemId) row.dataset.itemId = event.itemId;
+      if (event.turnId) row.dataset.turnId = event.turnId;
+      this.liveRows.set(key, row);
+      while (this.liveRows.size > MAX_LIVE_ROWS) this.liveRows.delete(this.liveRows.keys().next().value);
+    }
+    row.textContent = `${row.textContent}${event.text}`.slice(-16000);
+    row.setAttribute?.('aria-label', `${event.role === 'assistant' ? '猫猫' : '语音转写'}，实时：${row.textContent}`);
+    this.render();
+    if (pinned) {
+      this.container.scrollTop = this.container.scrollHeight;
+      this.setUnread(0);
+    } else if (isNew) this.setUnread(this.unread + 1);
+    return true;
+  }
+
+  appendTyped({ receipt, text }) {
+    if (!this.callId || receipt?.delivery !== 'accepted' || receipt.callId !== this.callId) return false;
+    const pinned = this.nearBottom();
+    let row = this.durableRows.get(receipt.messageId);
+    const isNew = !row;
+    if (!row) {
+      row = this.createRow();
+      this.durableRows.set(receipt.messageId, row);
+    }
+    this.updateDurable(row, {
+      messageId: receipt.messageId,
+      role: 'user',
+      text,
+      source: { kind: 'typed', clientMessageId: receipt.clientMessageId, callId: receipt.callId },
+    });
+    row.dataset.optimistic = 'true';
+    this.optimisticIds.add(receipt.messageId);
+    while (this.optimisticIds.size > MAX_LIVE_ROWS) {
+      const oldest = this.optimisticIds.values().next().value;
+      this.optimisticIds.delete(oldest);
+      if (this.durableRows.get(oldest)?.dataset.optimistic === 'true') this.durableRows.delete(oldest);
+    }
+    this.render();
+    if (pinned) {
+      this.container.scrollTop = this.container.scrollHeight;
+      this.setUnread(0);
+    } else if (isNew) this.setUnread(this.unread + 1);
+    return true;
+  }
+
+  finish(event) {
+    if (!this.callId || event?.type !== 'turn-done' || event.callId !== this.callId) return false;
+    for (const row of this.liveRows.values()) {
+      const matchesTurn = event.turnId && row.dataset.turnId === event.turnId;
+      const matchesUnkeyedRole = !event.turnId && event.role && !row.dataset.itemId
+        && !row.dataset.turnId && row.dataset.role === event.role;
+      if (matchesTurn || matchesUnkeyedRole) row.dataset.complete = 'true';
+    }
+    this.render();
+    return true;
+  }
+}

package/renderer/client.mjs

@@ -19,7 +19,7 @@ export function createCompanionClient(bridge) {
     return {
         state: () => invoke({ kind: 'state' }, 'state'),
         prepare: () => invoke({ kind: 'prepare' }, 'state'),
-        connectAudio: () => invoke({ kind: 'audio.connect' }, 'ok'),
+        connectAudio: (mode) => invoke(mode === undefined ? { kind: 'audio.connect' } : { kind: 'audio.connect', mode }, 'ok'),
         closeAudio: () => invoke({ kind: 'audio.close' }, 'ok'),
         muteMicrophone: (muted) => invoke({ kind: 'audio.microphone', muted }, 'ok'),
         muteSpeaker: (muted) => invoke({ kind: 'audio.speaker', muted }, 'ok'),
@@ -42,7 +42,12 @@ export function createCompanionClient(bridge) {
         layout: (panel, width, height) => invoke({ kind: 'view.layout', panel, width, height }, 'layout'),
         drag: (phase) => invoke({ kind: 'view.drag', phase }, 'ok'),
         hide: () => invoke({ kind: 'view.hide' }, 'ok'),
+        resetPosition: () => invoke({ kind: 'view.reset' }, 'ok'),
+        readSettings: () => invoke({ kind: 'settings.read' }, 'settings'),
+        updateSetting: (field, value) => invoke({ kind: 'settings.update', field, value }, 'settings-update'),
+        disableCompanion: () => invoke({ kind: 'companion.disable' }, 'companion-lifecycle'),
         readConversation: () => invoke({ kind: 'conversation.read' }, 'conversation'),
+        readTranscript: () => invoke({ kind: 'transcript.read' }, 'transcript'),
         subscribe: (listener) => bridge.subscribe(listener),
     };
 }

package/renderer/companion-identity.mjs

@@ -1,12 +1,13 @@
 const named = value => typeof value === 'string' && value.trim().length > 0;
 const actor = value => value && named(value.catId) && named(value.displayName);
 const model = value => value === null || (named(value) && value.length <= 160);
+const snapshotActor = value => actor(value) && value.catId.length <= 160 && value.displayName.length <= 160;
 
 function validSnapshot(value) {
   return value?.v === 1 && value.name === '猫猫球'
-    && actor(value.partner) && named(value.partner.skin)
-    && actor(value.live) && value.live.transport === 'gpt_live_v3' && model(value.live.verifiedModel)
-    && actor(value.deep) && value.deep.catId === value.partner.catId && model(value.deep.verifiedModel);
+    && snapshotActor(value.partner) && named(value.partner.skin) && value.partner.skin.length <= 160
+    && snapshotActor(value.live) && value.live.transport === 'gpt_live_v3' && model(value.live.verifiedModel)
+    && snapshotActor(value.deep) && value.deep.catId === value.partner.catId && model(value.deep.verifiedModel);
 }
 
 function display(snapshot, partnerLabel) {

package/renderer/conversation.mjs

@@ -7,42 +7,107 @@ export class CompanionConversation {
     this.active = false;
     this.generation = 0;
     this.phase = 'idle';
+    this.audioMode = null;
+    this.retryMode = null;
     this.muted = false;
     this.silent = false;
     this.failed = false;
+    this.recovering = false;
+    this.retiredCallId = null;
   }
   show(message) {
     this.message = message;
-    this.render({ phase: this.phase, identity: this.identity, muted: this.muted, silent: this.silent, failed: this.failed, message });
+    this.render({ phase: this.phase, identity: this.identity, audioMode: this.audioMode, retryMode: this.retryMode,
+      muted: this.muted, silent: this.silent, failed: this.failed, recovering: this.recovering,
+      callId: this.callId, message });
   }
   current(generation) { return this.active && generation === this.generation; }
-  listening() { return this.muted ? '麦克风已静音' : '正在听，直接说话就好'; }
-  async begin() {
+  listening() {
+    if (this.audioMode === 'receive_only') return '只听模式 · 麦克风未启用';
+    return this.muted ? '麦克风已静音' : '正在听，直接说话就好';
+  }
+  retrying(prefix) {
+    return this.audioMode === 'receive_only'
+      ? `${prefix} · 麦克风未启用，点击只听重试`
+      : `${prefix} · 点击语音通话重试`;
+  }
+  stoppedMessage() {
+    return this.audioMode === 'receive_only'
+      ? '只听已结束 · 麦克风未启用'
+      : '语音通话已结束 · 麦克风已关闭';
+  }
+  expectHostStop() {
+    if (!this.active) return false;
+    this.expectedHostStop = { generation: this.generation, pending: true };
+    return true;
+  }
+  async settleExpectedHostStop(callStopped) {
+    const expected = this.expectedHostStop;
+    if (!expected || expected.generation !== this.generation) return;
+    if (callStopped === false) {
+      this.expectedHostStop = undefined;
+      return;
+    }
+    if (callStopped === null) {
+      expected.pending = false;
+      return;
+    }
+    this.expectedHostStop = undefined;
+    if (!this.active) return;
+    this.failed = false;
+    await this.releaseLocal(this.stoppedMessage());
+  }
+  async begin(mode = 'duplex') {
     if (this.active || this.stopping || this.changingDocuments) return;
+    if (mode === 'receive_only' && !this.identity?.audio?.supportedModes?.includes(mode)) return;
+    if (!['duplex', 'receive_only'].includes(mode)) return;
     this.active = true;
+    this.audioMode = mode;
+    this.retryMode = null;
     this.failed = false;
+    this.recovering = false;
     this.phase = 'connecting';
+    this.callId = null;
+    this.expectedHostStop = undefined;
     const generation = ++this.generation;
     // Must reach the isolated preload while the click still has user activation.
     const preparation = this.client.prepare();
     this.show('正在连接…');
-    this.deadline = setTimeout(() => { if (this.current(generation)) void this.end('连接超时 · 点击语音聊重试', true); }, 60_000);
+    this.deadline = setTimeout(() => { if (this.current(generation)) void this.end(this.retrying('连接超时'), true); }, 60_000);
     try {
       const peer = this.createPeer(event => {
         if (!this.current(generation)) return;
-        if (event.type === 'connected') { clearTimeout(this.deadline); this.phase = 'talking'; this.show(this.listening()); }
-        if (event.type === 'recovering') this.show('连接暂时中断 · 正在等待恢复');
-        if (event.type === 'recovered') this.show(this.listening());
+        if (event.type === 'error' && !this.callId && event.callId === this.retiredCallId) return;
+        if (event.type === 'connected') {
+          if (this.callId && this.callId !== event.callId) return;
+          this.callId = event.callId;
+          this.recovering = false;
+          clearTimeout(this.deadline); this.phase = 'talking'; this.show(this.listening());
+        }
+        if (event.type === 'error' && (!event.callId || !this.callId || event.callId === this.callId)) {
+          void this.end(explainError(event), true);
+          return;
+        }
+        if (!this.callId || event.callId !== this.callId) return;
+        if (event.type === 'recovering') {
+          this.recovering = true;
+          this.show('恢复后通话继续，无需重新连接');
+        }
+        if (event.type === 'recovered') {
+          this.recovering = false;
+          this.show(this.listening());
+        }
         if (event.type === 'transcript' || event.type === 'turn-done') this.transcript(event);
-        if (event.type === 'error') void this.end(explainError(event), true);
       });
       this.peer = peer;
-      peer.muteMic(this.muted); peer.muteSpeaker(this.silent);
+      if (mode === 'duplex') peer.muteMic(this.muted);
+      peer.muteSpeaker(this.silent);
       // Submit capture intent while this same click is active. The Host waits
       // for its matching preparation before creating the media document.
-      const [identity] = await Promise.all([preparation, peer.connect()]);
+      const [identity] = await Promise.all([preparation, peer.connect(mode === 'receive_only' ? mode : undefined)]);
       if (!this.current(generation)) { await peer.close(); return; }
       if (identity.phase !== 'ready') throw { code: 'unavailable' };
+      if (mode === 'receive_only' && !identity.audio?.supportedModes?.includes(mode)) throw { code: 'unavailable' };
       this.identity = identity;
       this.show(this.message);
     } catch (error) {
@@ -51,35 +116,57 @@ export class CompanionConversation {
   }
   async releaseLocal(message) {
     this.active = false;
+    this.expectedHostStop = undefined;
+    if (this.callId) this.retiredCallId = this.callId;
     ++this.generation;
     this.pendingText = undefined;
     clearTimeout(this.deadline);
     const peer = this.peer;
     this.peer = undefined;
+    const releasedMode = this.audioMode;
+    this.audioMode = null;
+    this.retryMode = this.failed ? releasedMode : null;
     this.phase = 'idle';
+    this.recovering = false;
+    this.callId = null;
     this.show(message);
     await Promise.allSettled([peer?.close(), this.stopScreen()]);
   }
-  async end(message = '语音已结束 · 麦克风已关闭', failed = false) {
+  async end(message, failed = false) {
     if (this.stopping) return this.stopping;
+    const receiveOnly = this.audioMode === 'receive_only';
+    message ??= this.stoppedMessage();
     this.failed = failed;
     const local = this.releaseLocal(message);
     const operation = Promise.all([local, this.client.stop()]);
     this.stopping = operation;
     try { await operation; }
-    catch { this.show('麦克风已关闭 · 连接收尾尚未确认'); }
+    catch { this.show(receiveOnly ? '麦克风未启用 · 连接收尾尚未确认' : '麦克风已关闭 · 连接收尾尚未确认'); }
     finally { if (this.stopping === operation) this.stopping = undefined; }
   }
   async hostStopped(reason) {
     // Stop echoes must not erase a more useful local failure or manual ending.
     if (!this.active) return;
-    const messages = {
-      locked: '屏幕已锁定 · 语音已停止，解锁后可点击语音聊继续',
-      suspended: '电脑已休眠 · 语音已停止，可点击语音聊继续',
-      hidden: '猫猫已收起 · 语音已停止',
+    if (reason === 'revoked' && this.expectedHostStop?.generation === this.generation) {
+      this.expectedHostStop = undefined;
+      this.failed = false;
+      await this.releaseLocal(this.stoppedMessage());
+      return;
+    }
+    const receiveOnly = this.audioMode === 'receive_only';
+    const messages = receiveOnly ? {
+      locked: '屏幕已锁定 · 只听已停止，解锁后可点击只听继续',
+      suspended: '电脑已休眠 · 只听已停止，可点击只听继续',
+      hidden: '猫猫已收起 · 只听已停止',
+    } : {
+      locked: '屏幕已锁定 · 语音通话已停止，解锁后可点击语音通话继续',
+      suspended: '电脑已休眠 · 语音通话已停止，可点击语音通话继续',
+      hidden: '猫猫已收起 · 语音通话已停止',
     };
     this.failed = !Object.hasOwn(messages, reason);
-    await this.releaseLocal(messages[reason] ?? '语音连接已中断 · 麦克风已关闭，点击语音聊重试');
+    await this.releaseLocal(messages[reason] ?? (receiveOnly
+      ? '只听连接已中断 · 麦克风未启用，点击只听重试'
+      : '语音通话已中断 · 麦克风已关闭，点击语音通话重试'));
   }
   async refresh() {
     if (this.refreshing) return;
@@ -89,9 +176,18 @@ export class CompanionConversation {
       const identity = await this.client.state();
       if (generation !== this.generation) return;
       this.identity = identity;
+      if (this.active && identity.audio?.activeMode) this.audioMode = identity.audio.activeMode;
       if (this.active && ['closed', 'failed', 'idle'].includes(identity.phase)) {
-        await this.end('语音连接已中断 · 点击语音聊重试', true);
-      } else this.show(this.message ?? '点开始聊天，直接对我说话');
+        if (this.expectedHostStop?.generation === this.generation) {
+          this.expectedHostStop = undefined;
+          this.failed = false;
+          await this.releaseLocal(this.stoppedMessage());
+        } else await this.end(this.retrying('语音连接已中断'), true);
+      } else {
+        if (this.expectedHostStop?.generation === this.generation && !this.expectedHostStop.pending)
+          this.expectedHostStop = undefined;
+        this.show(this.message ?? '点击语音通话，直接对我说话');
+      }
     } catch (error) {
       if (generation === this.generation) {
         if (this.active) await this.end(explainError(error), true);
@@ -109,7 +205,7 @@ export class CompanionConversation {
       const identity = await changing;
       await local;
       this.identity = identity;
-      this.show(allowed ? '资料查询已开启 · 点击开始聊天继续' : '资料查询已暂停 · 点击开始聊天继续');
+      this.show(allowed ? '资料查询已开启 · 点击语音通话继续' : '资料查询已暂停 · 点击语音通话继续');
     } catch (error) { this.show(explainError(error)); }
     finally { this.changingDocuments = false; }
   }
@@ -121,12 +217,16 @@ export class CompanionConversation {
     const generation = this.generation;
     this.sending = true;
     try {
-      await this.client.text(input.text, input.id);
+      const receipt = await this.client.text(input.text, input.id);
+      if (receipt?.delivery !== 'accepted') {
+        if (generation === this.generation) this.show(explainError({ code: 'unconfirmed' }));
+        return false;
+      }
       if (this.pendingText === input) this.pendingText = undefined;
       // Voice may have ended; an accepted message still retires this draft.
       // Keep the newer voice status rather than announcing that we are listening.
       if (generation !== this.generation) return true;
-      this.transcript({ type: 'transcript', role: 'user', text, typed: true });
+      this.transcript({ type: 'typed', role: 'user', text, receipt });
       this.show(this.active ? this.listening() : '已发送 · 回答会留在同一段聊天中');
       return true;
     } catch (error) {
@@ -134,6 +234,10 @@ export class CompanionConversation {
       return false;
     } finally { this.sending = false; }
   }
-  muteMic() { this.muted = !this.muted; this.peer?.muteMic(this.muted); this.show(this.phase === 'talking' ? this.listening() : this.message); }
+  muteMic() {
+    if (this.audioMode === 'receive_only') return;
+    this.muted = !this.muted; this.peer?.muteMic(this.muted);
+    this.show(this.phase === 'talking' ? this.listening() : this.message);
+  }
   muteSpeaker() { this.silent = !this.silent; this.peer?.muteSpeaker(this.silent); this.show(this.message); }
 }

package/renderer/decision-view.mjs

@@ -1,13 +1,11 @@
 /** F246 remains the decision truth; linked F310 receipts are enrichment, not another item. */
 export function decisionBadge(page) {
   if (!page || page.status !== 'available')
-    return { visible: true, label: '?', title: '待决事项暂不可读' };
-  const total = page.approvalCount + page.otherNeedsMeCount;
-  return {
-    visible: total > 0,
-    label: total > 99 ? '99+' : String(total),
-    title: `${page.approvalCount} 项审批事项，${page.otherNeedsMeCount} 项其他待处理`,
-  };
+    return { visible: true, label: '?', title: '待办暂不可读', state: 'unavailable' };
+  const hasKnownRows = (page.approvals?.length ?? 0) > 0 || (page.otherNeedsMe?.length ?? 0) > 0
+    || page.approvalCount > 0 || page.needsMeCount > 0 || page.otherNeedsMeCount > 0;
+  if (hasKnownRows) return { visible: true, label: '有待办', title: '有待办', state: 'available' };
+  return { visible: false, label: '0', title: '现在没有待办', state: 'empty' };
 }
 
 export function decisionRows(page) {
@@ -19,7 +17,7 @@ export function decisionRows(page) {
   return [
     ...page.approvals.map(item => ({
       title: item.summary || '待决策事项',
-      meta: `${item.sourceFeatureId} · ${state[item.resolution] ?? '状态待核'} · ${item.materializationState === 'outcome_unknown' ? '结果未知' : item.materializationState === 'failed' ? '执行失败' : item.linkedNeedsMe ? '已关联任务' : '原处卡片'}`,
+      meta: `审批 · ${state[item.resolution] ?? '状态待核'} · ${item.materializationState === 'outcome_unknown' ? '结果未知' : item.materializationState === 'failed' ? '执行失败' : item.linkedNeedsMe ? '已关联待办' : '原处卡片'}`,
       proposalId: item.proposalId,
       previewable: item.sourceFeatureId === 'F221' &&
         /^[A-Za-z0-9_-]{1,200}$/.test(item.proposalId) &&

package/renderer/errors.mjs

@@ -1,8 +1,8 @@
 const messages = {
-  permission_required: '请点击开始聊天，或在系统提示中允许本次使用',
-  session_required: '连接已结束 · 点击开始聊天继续',
-  busy: '上一段交流正在收尾 · 稍后再开始',
-  selection_changed: '猫猫球的选择已更新 · 点击开始聊天继续',
+  permission_required: '请点击语音通话，或在系统提示中允许本次使用',
+  session_required: '连接已结束 · 点击语音通话继续',
+  busy: '会话暂时被占用，请稍后重试',
+  selection_changed: '猫猫球的选择已更新 · 点击语音通话继续',
   carrier_unavailable: '实时语音暂不可用 · 可以打开聊天继续交流',
   cancelled: '操作已取消',
   unconfirmed: '发送尚未确认 · 文字已保留，可检查聊天记录后重试',