@livx.cc/agentx 0.97.5 → 0.97.9

package/dist/index.d.ts

@@ -858,6 +858,10 @@ interface TaskRecord {
     /** Per-worker `<spoken>` splitter — the worker OWNS delivery: spoken segments stream during its run.
      *  Read at settle (spokeAny) to decide the no-spoken fallback. */
     splitter?: SpokenSplitter;
+    /** Set when the user barged in / took the floor while this task was in flight: its remaining SPOKEN
+     *  delivery is suppressed (don't talk over the new topic), but its full result still lands in the
+     *  transcript so the reflex can surface it on request. See parkInFlightDeliveries(). */
+    deliveryParked?: boolean;
 }
 type WorkerTier = 'act' | 'think';
 declare class DuplexAgentOptions {
@@ -998,6 +1002,11 @@ declare class DuplexAgent {
     send(content: MessageContent): Promise<RunResult>;
     /** Cancel a running background task — shared by the CancelTask tool and the CLI /tasks picker. */
     cancelTask(id: string): string;
+    /** Barge-in: the user took the floor while task(s) were running. Suppress those tasks' remaining SPOKEN
+     *  delivery so a superseded topic never talks over the new one (the debt-after-jokes regression). The
+     *  tasks keep running and still fold their result into the transcript — recoverable, just not spoken.
+     *  Returns the parked ids (for logging). Does NOT cancel: that's a deliberate reflex/user action. */
+    parkInFlightDeliveries(): string[];
     /** Resolve when all queued voice turns AND all in-flight worker tasks have settled (tests, graceful shutdown). */
     idle(): Promise<void>;
     /** Promise-chain mutex: turns run strictly one at a time; a failed turn doesn't poison the chain. */

package/dist/index.js

@@ -4651,6 +4651,8 @@ init_logging();
 // src/voice/spokenSplitter.ts
 var OPEN = "<spoken>";
 var CLOSE = "</spoken>";
+var CLOSERS = `"')]}\xBB\u201D\u2019`;
+var hasSpeech = (s) => /[\p{L}\p{N}]/u.test(s);
 var SentenceCoalescer = class _SentenceCoalescer {
   buf = "";
   static isEnd(c) {
@@ -4661,14 +4663,15 @@ var SentenceCoalescer = class _SentenceCoalescer {
     let cut = -1;
     for (let i = 0; i < this.buf.length; i++) if (_SentenceCoalescer.isEnd(this.buf[i])) cut = i;
     if (cut < 0) return "";
+    if (this.buf[cut] !== "\n") while (cut + 1 < this.buf.length && CLOSERS.includes(this.buf[cut + 1])) cut++;
     const ready = this.buf.slice(0, cut + 1).trim();
     this.buf = this.buf.slice(cut + 1);
-    return ready;
+    return hasSpeech(ready) ? ready : "";
   }
   flush() {
     const s = this.buf.trim();
     this.buf = "";
-    return s;
+    return hasSpeech(s) ? s : "";
   }
 };
 var SpokenSplitter = class {
@@ -5011,6 +5014,19 @@ Today's date: ${(/* @__PURE__ */ new Date()).toDateString()}.`;
     rec.controller.abort();
     return `Task ${rec.id} (${rec.label}) cancelled.`;
   }
+  /** Barge-in: the user took the floor while task(s) were running. Suppress those tasks' remaining SPOKEN
+   *  delivery so a superseded topic never talks over the new one (the debt-after-jokes regression). The
+   *  tasks keep running and still fold their result into the transcript — recoverable, just not spoken.
+   *  Returns the parked ids (for logging). Does NOT cancel: that's a deliberate reflex/user action. */
+  parkInFlightDeliveries() {
+    const parked = [];
+    for (const rec of this.tasks.values())
+      if (rec.status === "running" && !rec.deliveryParked) {
+        rec.deliveryParked = true;
+        parked.push(rec.id);
+      }
+    return parked;
+  }
   /** Resolve when all queued voice turns AND all in-flight worker tasks have settled (tests, graceful shutdown). */
   async idle() {
     while (true) {
@@ -5108,7 +5124,7 @@ ${recent}` : brief) + verify + deliverContract;
     };
     const splitter = new SpokenSplitter();
     const speak = (seg) => {
-      if (seg) o.host?.notify?.({ kind: "speak_utterance", message: seg });
+      if (seg && !this.tasks.get(id)?.deliveryParked) o.host?.notify?.({ kind: "speak_utterance", message: seg });
     };
     const coalescer = new SentenceCoalescer();
     const feedSpoken = (s) => {
@@ -5329,9 +5345,9 @@ Another agent just implemented the above. Independently check the CURRENT state
       return this.queueRevoice(this.integrationPrompt(rec, "incomplete", res.text, res.finishReason), true);
     }
     const tail = rec.splitter?.flush();
-    if (tail?.spoken) this.options.host?.notify?.({ kind: "speak_utterance", message: tail.spoken });
+    if (tail?.spoken && !rec.deliveryParked) this.options.host?.notify?.({ kind: "speak_utterance", message: tail.spoken });
     if (res.text.trim()) this.voice.transcript.push({ role: "assistant", content: res.text });
-    if (!rec.splitter?.spokeAny && res.text.trim())
+    if (!rec.splitter?.spokeAny && res.text.trim() && !rec.deliveryParked)
       this.options.host?.notify?.({ kind: "speak_utterance", message: res.text });
   }
   onWorkerFailed(id, err) {
@@ -5946,7 +5962,7 @@ var VoiceEngine = class _VoiceEngine {
    *  If nothing is currently speaking it plays immediately; otherwise it queues and plays after the
    *  current utterance fully ends (settle → pumpQueue) — never spliced into an open reflex utterance. */
   enqueueUtterance(text) {
-    if (!text || !text.trim()) return;
+    if (!text || !/[\p{L}\p{N}]/u.test(text)) return;
     this.uttQueue.push(text);
     if (!this.speaking) this.pumpQueue();
   }