@xdfnet/ispeak 1.6.2 → 1.6.4

package/Docs/ARCHITECTURE.md

@@ -4,8 +4,8 @@
 
 iSpeak 是一个运行在 macOS 上的本地 TTS 播报守护进程，通过 Unix Socket 接收文本，调用火山引擎 TTS 流式 API，边合成边播放。
 
-当前版本采用“任务仓库 + 单 speak worker”流式链路：
-- speak worker：领取待合成任务，SSE 每到一段音频就写入播放器 stdin
+当前版本采用“任务仓库 + 单 transaction worker”流式链路：
+- transaction worker：领取待执行任务，SSE 每到一段音频就写入播放器 stdin
 - 播放器优先使用 `ffplay -i pipe:0`，没有 `ffplay` 时回退到完整音频 `afplay`
 
 ## 系统架构
@@ -28,15 +28,15 @@ iSpeak 是一个运行在 macOS 上的本地 TTS 播报守护进程，通过 Uni
 │  ┌───────────────────────────────────────────────────────┐  │
 │  │  Task Repository (in-memory)                         │  │
 │  │  - tasks: map[uint64]*Task                           │  │
-│  │  - pendingSynth: []uint64 (FIFO)                     │  │
+│  │  - pending: []uint64 (FIFO)                          │  │
 │  └───────────────────────────────────────────────────────┘  │
 │             │                                               │
 │             ▼                                               │
-│  Speak Worker (single)                                      │
-│  - pending_synth -> speaking                                │
-│  - 调用 TTS 流式接口（失败重试1次）                          │
+│  Transaction Worker (single)                               │
+│  - pending -> running                                      │
+│  - 调用 TTS 流式接口（失败直接删除，不重试）                  │
 │  - SSE audio chunk -> StreamPlayer.Write                    │
-│  - 播放完成后删除任务；连续失败删除任务                       │
+│  - 播放完成后删除任务；失败直接删除任务                       │
 │                                                             │
 └─────────────────────────────────────────────────────────────┘
 ```
@@ -48,7 +48,7 @@ iSpeak 是一个运行在 macOS 上的本地 TTS 播报守护进程，通过 Uni
 ```go
 type Task struct {
     ID     uint64     // 任务 ID（递增）
-    Text   string     // 过滤后的待合成文本
+    Text   string     // 过滤后的待执行文本
     Status TaskStatus // 当前状态
     Voice  VoiceInfo  // 任务音色快照
     Cfg    Config     // 任务配置快照（提交时）
@@ -59,8 +59,8 @@ type Task struct {
 
 ```go
 const (
-    TaskStatusPendingSynth TaskStatus = iota // 待合成
-    TaskStatusSpeaking                       // 流式合成播放中
+    TaskStatusPending TaskStatus = iota // 待执行
+    TaskStatusRunning                   // 合成播放事务执行中
 )
 ```
 
@@ -76,9 +76,9 @@ type TaskEngine struct {
 
     nextID       uint64
     tasks        map[uint64]*Task
-    pendingSynth []uint64
-
-    synthWake chan struct{}
+    latestID     uint64
+    pending      []uint64
+    wake chan struct{}
 
     synthesizeStreamFn func(ctx context.Context, cfg Config, text string, voice *VoiceInfo, onAudio func([]byte) error) error
     newStreamPlayerFn  func() (StreamPlayer, error)
@@ -100,28 +100,30 @@ type StreamPlayer interface {
 ### 状态流转
 
 ```
-pending_synth -> speaking -> delete
+pending -> running -> delete
 ```
 
 ### 任务提交（核心规则）
 
 `Submit(cleanedText, voice, cfg)` 原子执行：
-1. 删除所有 `pending_synth` 任务
-2. 创建新任务（`pending_synth`）
-3. 唤醒 speak worker
+1. 删除所有 `pending` 任务
+2. 不打断当前 `running` 事务
+3. 创建新任务（`pending`）
+4. 唤醒 transaction worker
 
 策略说明：
-- 只清理“未开始合成”的任务
-- 不打断 `speaking`
+- 未开始的旧任务直接删除
+- 已领取但过期的旧任务在事务执行前跳过
+- 正在合成/播放的任务自然结束
 
-### Speak worker 规则
+### Transaction worker 规则
 
-1. FIFO 领取 `pending_synth` 任务并置 `speaking`
+1. FIFO 领取 `pending` 任务并置 `running`
 2. 启动 `StreamPlayer`
 3. 调用 TTS 流式接口，SSE 每解析出一个音频 chunk 就写入播放器
 4. TTS 结束后关闭播放器 stdin 并等待播放结束
 5. 成功：删除任务
-6. 连续失败：删除任务
+6. 失败：删除任务，不重试
 
 ## 消息流程
 
@@ -130,12 +132,25 @@ pending_synth -> speaking -> delete
 `handleConnection()`：
 - 读取 socket 文本
 - 解析 `{source:xxx}` 音色前缀
-- `cleanText()` 过滤 Markdown/表格符号
+- `cleanText()` 生成语音友好的文本
 - 将“过滤后文本”提交给 `TaskEngine.Submit`
 
+`cleanText()` 只影响 TTS 播报，不改变屏幕显示内容。当前清洗规则：
+
+- Markdown 格式符号：标题、加粗、反引号、引用符
+- Markdown 表格整块：表头、分隔线、表格内容
+- 代码块、artifact、HTML 页面源码
+- Markdown 链接 URL，仅保留链接标题
+- 绝对路径简化为“路径”
+- 长 commit hash、UUID、长 ID
+- 明显文件列表、模型分片列表、下载清单
+- 下载进度、速度、进度条、ANSI 控制符等终端噪声
+
+清洗目标是保留适合听的内容：结论、成功/失败状态、下一步动作、关键错误原因。
+
 ### 2. 流式合成播放阶段
 
-- speak worker 领取任务
+- transaction worker 领取任务
 - HTTP POST 火山引擎 TTS 接口
 - 解析 SSE 流并 base64 解码音频 chunk
 - 优先将 chunk 写入 `ffplay` stdin 实时播放
@@ -145,15 +160,15 @@ pending_synth -> speaking -> delete
 ## 并发与一致性
 
 - 单引擎锁 `mu` 保护任务仓库与 FIFO 队列
-- 单 speak worker，保证播报顺序稳定
-- `synthWake` 为缓冲 1 的唤醒信号，防止重复唤醒堆积
+- 单 transaction worker，保证播报顺序稳定
+- `wake` 为缓冲 1 的唤醒信号，防止重复唤醒堆积
 - FIFO 保证未开始任务公平顺序
 
 ## 失败与成本策略
 
-- 新任务到达时仅清理 `pending_synth`，避免无效合成
-- 流式合成/播放失败：整条播报重试 1 次后删除
-- 执行中任务不打断，行为稳定、可预期
+- 新任务到达时只清理 `pending`，不打断当前任务
+- 流式合成/播放失败：直接删除任务，不重试，避免重复播报
+- 只保留最新消息优先播报，降低 TTS 成本
 
 ## 文件布局
 

package/README.md

@@ -1,6 +1,6 @@
 # iSpeak
 
-![Version](https://img.shields.io/badge/version-1.6.2-blue)
+![Version](https://img.shields.io/badge/version-1.6.3-blue)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 [![Go Version](https://img.shields.io/badge/Go-1.26-blue)](https://golang.org/dl/)
 ![Platform](https://img.shields.io/badge/platform-macOS-green)
@@ -26,8 +26,8 @@ ispeak-codex "构建完成，耗时 12 秒"
 
 | 问题 | 方案 |
 |------|------|
-| AI 生成多条回复，TTS 账单飞涨 | 新消息只保留最新待合成任务，避免无效合成 |
-| 回复快慢不一，音频播报乱序 | 单 speak worker，FIFO 顺序稳定 |
+| AI 生成多条回复，TTS 账单飞涨 | 新消息只保留最新待执行任务，避免无效合成 |
+| 回复快慢不一，音频播报乱序 | 单 transaction worker，FIFO 顺序稳定 |
 | 修改配置要重启服务 | 热更新：编辑 `config.json` 立即生效 |
 | 默认音色太无聊 | 来源专属音色，Claude 和 Codex 声音不同 |
 
@@ -72,7 +72,7 @@ ispeak "iSpeak 准备好了"
 │         │                                            │
 │         ▼                                           │
 │   任务引擎                                           │
-│   （pending_synth → speaking → delete）              │
+│   （pending → running → delete）              │
 │         │                                            │
 │         ▼                                           │
 │   单 Worker 流式链路                                 │
@@ -86,9 +86,29 @@ ispeak "iSpeak 准备好了"
 
 **任务状态流转：**
 ```
-pending_synth → speaking → delete
+pending → running → delete
 ```
 
+新消息到达时只清理未开始任务，不打断当前合成/播放；当前事务结束后再播最新消息。
+
+## 语音清洗规则
+
+清洗只影响 TTS 播报内容，不改变 Claude/Codex 屏幕显示内容。
+
+播报前会过滤或简化这些内容：
+
+- Markdown 格式符号：标题 `#`、加粗 `**`、反引号、引用 `>`
+- Markdown 表格整块：表头、分隔线、表格内容都不播
+- 代码块：``` 包裹的内容不播
+- artifact / HTML 内容：不播生成的页面源码
+- Markdown 链接：只保留链接标题，不播 URL
+- 绝对路径：简化为“路径”
+- 长 commit hash、UUID、长 ID：不播
+- 明显文件列表：如模型分片、代码文件列表、下载文件清单
+- 下载进度和终端噪声：百分比、速度、进度条、ANSI 控制符
+
+保留优先级：结论、成功/失败状态、需要用户操作的下一步、关键错误原因。
+
 ## 全部命令
 
 ```bash

package/main.go

@@ -17,6 +17,7 @@ import (
 	"os/exec"
 	"os/signal"
 	"path/filepath"
+	"regexp"
 	"strings"
 	"sync"
 	"syscall"
@@ -25,11 +26,6 @@ import (
 	"gopkg.in/natefinch/lumberjack.v2"
 )
 
-const (
-	ttsMaxAttempts  = 2
-	ttsRetryBackoff = 400 * time.Millisecond
-)
-
 var configDir = os.ExpandEnv("$HOME/.config/iSpeak")
 
 var (
@@ -47,6 +43,25 @@ var tempDir string
 
 var errAlreadyRunning = errors.New("iSpeak already running")
 
+var (
+	markdownLinkRe     = regexp.MustCompile(`\[[^\]]+\]\(([^)]*)\)`)
+	absolutePathRe     = regexp.MustCompile(`/(?:Users|private|tmp|var|opt|usr|bin|sbin|etc|Library|Applications)/\S+`)
+	commitHashRe       = regexp.MustCompile(`\b[0-9a-f]{7,40}\b`)
+	uuidRe             = regexp.MustCompile(`\b[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\b`)
+	urlRe              = regexp.MustCompile(`https?://\S+`)
+	ansiEscapeRe       = regexp.MustCompile(`\x1b\[[0-9;]*[A-Za-z]`)
+	multiSpaceRe       = regexp.MustCompile(`\s+`)
+	markdownListRe     = regexp.MustCompile(`^\s*(?:[-*+]\s+|\d+[.)]\s+)`)
+	htmlTagRe          = regexp.MustCompile(`<[^>]+>`)
+	codeFenceStartRe   = regexp.MustCompile("^```")
+	artifactStartRe    = regexp.MustCompile(`(?i)^<artifact\b`)
+	htmlDocumentLineRe = regexp.MustCompile(`(?i)^<!doctype html|^<html\b|^<head\b|^<body\b|^<style\b|^</`)
+	progressNoiseRe    = regexp.MustCompile(`(?i)(^\s*\d{1,3}%\s*$|\d{1,3}%.*\d+(?:\.\d+)?\s*(?:kb|mb|gb)/s|\bETA\b|^\s*[-=]{3,}\s*$)`)
+	speedNoiseRe       = regexp.MustCompile(`(?i)\d+(?:\.\d+)?\s*(?:kb|mb|gb)/s`)
+	etaNoiseRe         = regexp.MustCompile(`(?i)\bETA\b|预计剩余|剩余时间`)
+	fileListNoiseRe    = regexp.MustCompile(`(?i)\.(?:go|js|ts|tsx|jsx|json|md|yaml|yml|toml|sum|mod|lock|html|css|sh|plist|safetensors|mp3|wav|png|jpg|jpeg|pdf|docx)\b`)
+)
+
 type StreamPlayer interface {
 	Write(audio []byte) error
 	CloseAndWait() error
@@ -54,9 +69,13 @@ type StreamPlayer interface {
 }
 
 type ffplayStreamPlayer struct {
-	path  string
-	cmd   *exec.Cmd
-	stdin io.WriteCloser
+	path string
+	cmd  *exec.Cmd
+
+	mu       sync.Mutex
+	stdin    io.WriteCloser
+	waitOnce sync.Once
+	waitErr  error
 }
 
 func newDefaultStreamPlayer() (StreamPlayer, error) {
@@ -99,35 +118,55 @@ func (p *ffplayStreamPlayer) Write(audio []byte) error {
 	if len(audio) == 0 {
 		return nil
 	}
-	if _, err := p.stdin.Write(audio); err != nil {
+	p.mu.Lock()
+	stdin := p.stdin
+	p.mu.Unlock()
+	if stdin == nil {
+		return fmt.Errorf("播放器输入已关闭")
+	}
+	if _, err := stdin.Write(audio); err != nil {
 		return fmt.Errorf("写入播放器失败: %w", err)
 	}
 	return nil
 }
 
 func (p *ffplayStreamPlayer) CloseAndWait() error {
-	if p.stdin != nil {
-		if err := p.stdin.Close(); err != nil {
+	p.mu.Lock()
+	stdin := p.stdin
+	p.stdin = nil
+	p.mu.Unlock()
+	if stdin != nil {
+		if err := stdin.Close(); err != nil {
 			return fmt.Errorf("关闭播放器输入失败: %w", err)
 		}
-		p.stdin = nil
 	}
-	if err := p.cmd.Wait(); err != nil {
+	if err := p.wait(); err != nil {
 		return fmt.Errorf("ffplay failed: %w", err)
 	}
 	return nil
 }
 
 func (p *ffplayStreamPlayer) Abort() error {
-	if p.stdin != nil {
-		_ = p.stdin.Close()
-		p.stdin = nil
+	p.mu.Lock()
+	stdin := p.stdin
+	p.stdin = nil
+	p.mu.Unlock()
+	if stdin != nil {
+		_ = stdin.Close()
 	}
 	if p.cmd != nil && p.cmd.Process != nil {
 		_ = p.cmd.Process.Kill()
-		_ = p.cmd.Wait()
 	}
-	return nil
+	return p.wait()
+}
+
+func (p *ffplayStreamPlayer) wait() error {
+	p.waitOnce.Do(func() {
+		if p.cmd != nil {
+			p.waitErr = p.cmd.Wait()
+		}
+	})
+	return p.waitErr
 }
 
 type bufferedStreamPlayer struct {
@@ -161,12 +200,12 @@ func (p *bufferedStreamPlayer) Abort() error {
 }
 
 // 任务状态
-// 生命周期：pending_synth -> speaking -> delete
+// 生命周期：pending -> running -> delete
 type TaskStatus int
 
 const (
-	TaskStatusPendingSynth TaskStatus = iota
-	TaskStatusSpeaking
+	TaskStatusPending TaskStatus = iota
+	TaskStatusRunning
 )
 
 // 单个 TTS 任务
@@ -178,15 +217,16 @@ type Task struct {
 	Cfg    Config
 }
 
-// 任务引擎：任务仓库 + 单流式合成播放 worker
+// 任务引擎：任务仓库 + 单事务 worker
 type TaskEngine struct {
 	mu sync.Mutex
 
-	nextID       uint64
-	tasks        map[uint64]*Task
-	pendingSynth []uint64
+	nextID   uint64
+	latestID uint64
+	tasks    map[uint64]*Task
+	pending  []uint64
 
-	synthWake chan struct{}
+	wake chan struct{}
 
 	synthesizeStreamFn func(ctx context.Context, cfg Config, text string, voice *VoiceInfo, onAudio func([]byte) error) error
 	newStreamPlayerFn  func() (StreamPlayer, error)
@@ -195,56 +235,58 @@ type TaskEngine struct {
 func NewTaskEngine() *TaskEngine {
 	return &TaskEngine{
 		tasks:              make(map[uint64]*Task),
-		synthWake:          make(chan struct{}, 1),
+		wake:               make(chan struct{}, 1),
 		synthesizeStreamFn: synthesizeStream,
 		newStreamPlayerFn:  newDefaultStreamPlayer,
 	}
 }
 
 func (e *TaskEngine) Start() {
-	go e.speakWorker()
+	go e.transactionWorker()
 }
 
 func (e *TaskEngine) Submit(text string, voice VoiceInfo, cfg Config) uint64 {
 	e.mu.Lock()
-	defer e.mu.Unlock()
 
-	// 新任务进来先删所有未开始合成任务
-	for _, id := range e.pendingSynth {
+	// 新任务进来先删所有未开始的任务。
+	for _, id := range e.pending {
 		delete(e.tasks, id)
-		log.Printf("删除待合成任务: id=%d", id)
+		log.Printf("删除待执行任务: id=%d", id)
 	}
-	e.pendingSynth = e.pendingSynth[:0]
+	e.pending = e.pending[:0]
 
 	e.nextID++
 	task := &Task{
 		ID:     e.nextID,
 		Text:   text,
-		Status: TaskStatusPendingSynth,
+		Status: TaskStatusPending,
 		Voice:  voice,
 		Cfg:    cfg,
 	}
 	e.tasks[task.ID] = task
-	e.pendingSynth = append(e.pendingSynth, task.ID)
+	e.latestID = task.ID
+	e.pending = append(e.pending, task.ID)
 	log.Printf("任务创建: id=%d text=%s", task.ID, text)
 
-	notify(e.synthWake)
+	notify(e.wake)
+	e.mu.Unlock()
+
 	return task.ID
 }
 
-func (e *TaskEngine) speakWorker() {
+func (e *TaskEngine) transactionWorker() {
 	for {
-		id := e.claimPendingSynth()
+		id := e.claimPending()
 		if id == 0 {
-			<-e.synthWake
+			<-e.wake
 			continue
 		}
 
-		e.processSpeakTask(id)
+		e.processTransaction(id)
 	}
 }
 
-func (e *TaskEngine) processSpeakTask(id uint64) {
+func (e *TaskEngine) processTransaction(id uint64) {
 	defer func() {
 		if r := recover(); r != nil {
 			log.Printf("播报任务崩溃并删除: id=%d err=%v", id, r)
@@ -256,20 +298,14 @@ func (e *TaskEngine) processSpeakTask(id uint64) {
 	if !ok {
 		return
 	}
-
-	var lastErr error
-	for i := 1; i <= ttsMaxAttempts; i++ {
-		lastErr = e.speakOnce(context.Background(), task)
-		if lastErr == nil {
-			break
-		}
-		if i < ttsMaxAttempts {
-			time.Sleep(ttsRetryBackoff)
-		}
+	if !e.isLatestTask(id) {
+		log.Printf("跳过过期播报任务: id=%d", id)
+		e.deleteTask(id)
+		return
 	}
 
-	if lastErr != nil {
-		log.Printf("播报失败并删除任务: id=%d err=%v", id, lastErr)
+	if err := e.runTransaction(task); err != nil {
+		log.Printf("播报失败并删除任务: id=%d err=%v", id, err)
 		e.deleteTask(id)
 		return
 	}
@@ -278,7 +314,7 @@ func (e *TaskEngine) processSpeakTask(id uint64) {
 	e.deleteTask(id)
 }
 
-func (e *TaskEngine) speakOnce(ctx context.Context, task *Task) error {
+func (e *TaskEngine) runTransaction(task *Task) error {
 	startedAt := time.Now()
 	player, err := e.newStreamPlayerFn()
 	if err != nil {
@@ -294,11 +330,12 @@ func (e *TaskEngine) speakOnce(ctx context.Context, task *Task) error {
 		return player.Write(audio)
 	}
 
-	if err := e.synthesizeStreamFn(ctx, task.Cfg, task.Text, &task.Voice, onAudio); err != nil {
+	if err := e.synthesizeStreamFn(context.Background(), task.Cfg, task.Text, &task.Voice, onAudio); err != nil {
 		_ = player.Abort()
 		return err
 	}
 	log.Printf("TTS 流结束: id=%d elapsed=%s", task.ID, time.Since(startedAt).Round(time.Millisecond))
+
 	if err := player.CloseAndWait(); err != nil {
 		_ = player.Abort()
 		return err
@@ -306,21 +343,21 @@ func (e *TaskEngine) speakOnce(ctx context.Context, task *Task) error {
 	return nil
 }
 
-func (e *TaskEngine) claimPendingSynth() uint64 {
+func (e *TaskEngine) claimPending() uint64 {
 	e.mu.Lock()
 	defer e.mu.Unlock()
 
-	for len(e.pendingSynth) > 0 {
-		id := e.pendingSynth[0]
-		e.pendingSynth = e.pendingSynth[1:]
+	for len(e.pending) > 0 {
+		id := e.pending[0]
+		e.pending = e.pending[1:]
 		task, ok := e.tasks[id]
 		if !ok {
 			continue
 		}
-		if task.Status != TaskStatusPendingSynth {
+		if task.Status != TaskStatusPending {
 			continue
 		}
-		task.Status = TaskStatusSpeaking
+		task.Status = TaskStatusRunning
 		return id
 	}
 	return 0
@@ -344,6 +381,12 @@ func (e *TaskEngine) deleteTask(id uint64) {
 	delete(e.tasks, id)
 }
 
+func (e *TaskEngine) isLatestTask(id uint64) bool {
+	e.mu.Lock()
+	defer e.mu.Unlock()
+	return e.latestID == id
+}
+
 func notify(ch chan struct{}) {
 	select {
 	case ch <- struct{}{}:
@@ -648,29 +691,56 @@ func extractAudioBase64(event map[string]any) string {
 	return ""
 }
 
-// 过滤格式符号，保留自然朗读文本
+// 过滤格式符号，保留自然朗读文本。
+// 顺序很重要：先跳过跨行块结构，再跳过整行噪声，最后清理行内符号。
 func cleanText(text string) string {
 	var lines []string
-	for _, line := range strings.Split(text, "\n") {
+	rawLines := strings.Split(text, "\n")
+	inCodeBlock := false
+	inArtifact := false
+	inMarkdownTable := false
+	for i := 0; i < len(rawLines); i++ {
+		line := rawLines[i]
 		line = strings.TrimSpace(line)
-		if strings.HasPrefix(line, "|---") || strings.HasPrefix(line, "|:---") {
+		if line == "" {
+			inMarkdownTable = false
+			continue
+		}
+		if codeFenceStartRe.MatchString(line) {
+			inCodeBlock = !inCodeBlock
 			continue
 		}
-		if strings.HasPrefix(line, "---") && strings.Count(line, "-") > 3 {
+		if inCodeBlock {
 			continue
 		}
-		// 过滤纯表格分隔行（|---|---|、:---|:---| 等）
-		if strings.Trim(line, "|-: ") == "" {
+		if artifactStartRe.MatchString(line) {
+			inArtifact = !strings.Contains(strings.ToLower(line), "</artifact>")
 			continue
 		}
-		cleaned := strings.NewReplacer(
-			"**", "",
-			"*", "",
-			"`", "",
-			"#", "",
-			">", "",
-		).Replace(line)
-		cleaned = strings.TrimSpace(cleaned)
+		if inArtifact {
+			if strings.Contains(strings.ToLower(line), "</artifact>") {
+				inArtifact = false
+			}
+			continue
+		}
+		if isMarkdownTableSeparator(line) {
+			if len(lines) > 0 && isMarkdownTableRow(strings.TrimSpace(rawLines[i-1])) {
+				lines = lines[:len(lines)-1]
+			}
+			inMarkdownTable = true
+			continue
+		}
+		if inMarkdownTable {
+			if isMarkdownTableRow(line) {
+				continue
+			}
+			inMarkdownTable = false
+		}
+		if shouldSkipSpeechLine(line) {
+			continue
+		}
+
+		cleaned := cleanSpeechLine(line)
 		if cleaned != "" {
 			lines = append(lines, cleaned)
 		}
@@ -678,6 +748,110 @@ func cleanText(text string) string {
 	return strings.Join(lines, "，")
 }
 
+func shouldSkipSpeechLine(line string) bool {
+	if isMarkdownTableSeparator(line) {
+		return true
+	}
+	if strings.HasPrefix(line, "---") && strings.Count(line, "-") > 3 {
+		return true
+	}
+	if htmlDocumentLineRe.MatchString(line) {
+		return true
+	}
+	if isProgressNoiseLine(line) {
+		return true
+	}
+	if isMostlyTableRow(line) {
+		return true
+	}
+	if isMostlyFileListLine(line) {
+		return true
+	}
+	return false
+}
+
+func isMarkdownTableSeparator(line string) bool {
+	line = strings.TrimSpace(line)
+	return strings.Contains(line, "|") && strings.Trim(line, "|-: ") == ""
+}
+
+func isMarkdownTableRow(line string) bool {
+	line = strings.TrimSpace(line)
+	return strings.Count(line, "|") >= 2
+}
+
+func cleanSpeechLine(line string) string {
+	// Markdown 链接必须在 URL 删除前处理，否则会丢掉链接标题。
+	line = ansiEscapeRe.ReplaceAllString(line, "")
+	line = markdownListRe.ReplaceAllString(line, "")
+	line = markdownLinkRe.ReplaceAllStringFunc(line, func(match string) string {
+		if end := strings.Index(match, "]"); end > 1 {
+			return match[1:end]
+		}
+		return ""
+	})
+	line = urlRe.ReplaceAllString(line, "")
+	line = absolutePathRe.ReplaceAllString(line, " 路径 ")
+	// UUID 必须在短 hash 前处理，避免先删短片段后破坏 UUID 识别。
+	line = uuidRe.ReplaceAllString(line, "")
+	line = commitHashRe.ReplaceAllString(line, "")
+	line = htmlTagRe.ReplaceAllString(line, "")
+	line = strings.NewReplacer(
+		"**", "",
+		"*", "",
+		"`", "",
+		"#", "",
+		">", "",
+		"✅", "",
+		"❌", "",
+		"✓", "",
+		"✗", "",
+		"→", "到",
+	).Replace(line)
+	line = strings.Trim(line, " \t-:|")
+	line = multiSpaceRe.ReplaceAllString(line, " ")
+	return strings.TrimSpace(line)
+}
+
+func isMostlyTableRow(line string) bool {
+	if !strings.Contains(line, "|") {
+		return false
+	}
+	return strings.Count(line, "|") >= 2 && len([]rune(line)) > 40
+}
+
+func isProgressNoiseLine(line string) bool {
+	if !progressNoiseRe.MatchString(line) {
+		return false
+	}
+	if speedNoiseRe.MatchString(line) || etaNoiseRe.MatchString(line) {
+		return true
+	}
+	return !containsCJK(line)
+}
+
+func isMostlyFileListLine(line string) bool {
+	if !fileListNoiseRe.MatchString(line) {
+		return false
+	}
+	if containsCJK(line) {
+		return false
+	}
+	if strings.Contains(line, ".safetensors") {
+		return true
+	}
+	return strings.Count(line, ".") >= 2 || strings.Contains(line, "/") || strings.Contains(line, " - ")
+}
+
+func containsCJK(s string) bool {
+	for _, r := range s {
+		if r >= '\u4e00' && r <= '\u9fff' {
+			return true
+		}
+	}
+	return false
+}
+
 func main() {
 	log.SetFlags(log.Ltime | log.Lshortfile)
 
@@ -847,6 +1021,9 @@ func handleConnection(conn net.Conn, engine *TaskEngine) {
 	scanner := bufio.NewScanner(conn)
 	scanner.Buffer(make([]byte, 1*1024*1024), 1*1024*1024)
 	for scanner.Scan() {
+		if sb.Len() > 0 {
+			sb.WriteByte('\n')
+		}
 		sb.WriteString(scanner.Text())
 	}
 	if err := scanner.Err(); err != nil {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xdfnet/ispeak",
-  "version": "1.6.2",
+  "version": "1.6.4",
   "description": "Local macOS TTS daemon for AI coding assistants, powered by Volcengine streaming TTS.",
   "license": "MIT",
   "homepage": "https://github.com/xdfnet/iSpeak#readme",

package/scripts/ispeak

@@ -2,7 +2,7 @@
 # ispeak — iSpeak 控制命令
 set -euo pipefail
 
-VERSION="1.6.2"
+VERSION="1.6.3"
 SOCK="$HOME/.config/iSpeak/ispeak.sock"
 PLIST="$HOME/Library/LaunchAgents/com.iSpeak.plist"
 CMD_NAME="$(basename "$0")"