@livx.cc/agentx 0.99.25 → 0.99.26

package/dist/index.d.ts

@@ -879,6 +879,10 @@ interface TaskRecord {
     /** Accumulated `<spoken>` delivery text (every segment, whether or not it was actually voiced). Used to
      *  RESUME a parked delivery after a trivial barge — see isTrivialBarge / redeliverParked. */
     spokenText?: string;
+    /** The user-turn counter (DuplexAgent.turn) at dispatch time. parkInFlightDeliveries() parks only tasks
+     *  from a PRIOR turn (a superseded topic) — never the task the current turn just launched, so a barge on
+     *  stale audio (or a substantive redirect) can't collateral-silence the work the user actually wants. */
+    createdTurn: number;
 }
 type WorkerTier = 'act' | 'think';
 declare class DuplexAgentOptions {
@@ -953,6 +957,9 @@ declare class DuplexAgent {
     readonly tasks: Map<string, TaskRecord>;
     private queue;
     private seq;
+    /** Monotonic user-turn counter (bumped once per SUBSTANTIVE turn). Stamped onto each task at dispatch
+     *  (TaskRecord.createdTurn) so parking can tell a prior-topic task from the current turn's fresh one. */
+    private turn;
     private pendingEvents;
     /** Spoken text of parked deliveries that have SETTLED, awaiting a trivial-barge resume decision on the
      *  next turn (a substantive turn clears it — the result stays in the transcript, recoverable by asking). */
@@ -1073,11 +1080,17 @@ declare class DuplexAgent {
     abortSpeculation(): void;
     /** 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[];
+    /** Barge-in (or a dispatch-driven supersede): suppress running tasks' remaining SPOKEN delivery so a
+     *  superseded topic never talks over the new one (the debt-after-jokes regression). Tasks keep running and
+     *  still fold their result into the transcript — recoverable, just not spoken. Returns parked ids (logging).
+     *  Does NOT cancel. Two callers, two shapes:
+     *   - BARGE (default): the user interrupted AUDIO. Park EVERY running task (including this turn's) — the
+     *     worker they cut off must stop, whatever turn launched it — and re-arm trivial-barge auto-resume so a
+     *     following "go on" can bring the parked delivery back.
+     *   - SUPERSEDE (`priorTurnsOnly`, `reenableResume:false`, from dispatch()): a new dispatch redirected to
+     *     fresh work. Park only PRIOR-turn tasks so parallel siblings dispatched in the SAME turn don't silence
+     *     each other, and keep them suppressed (the user moved on — don't resurface on a stray "go on"). */
+    parkInFlightDeliveries(reenableResume?: boolean, priorTurnsOnly?: boolean): string[];
     /** True while there is a parked delivery to potentially resume: either one already settled (queued) or
      *  one still running that was parked by a barge. */
     private hasParkedDelivery;
@@ -1142,6 +1155,13 @@ declare class DuplexAgent {
     private integrationPrompt;
     private onWorkerSettled;
     private onWorkerFailed;
+    /** A delivery the user has SUPERSEDED — parked AND moved on (suppressParkedResume, set by a redirect) —
+     *  must not hijack the voice when it settles late (partial or failed): that would talk over the new topic
+     *  and, worse, auto-escalate work the user already abandoned. Fold a recoverable note into the transcript
+     *  instead (the reflex can surface it if asked) and report true so the caller skips queueRevoice. A merely
+     *  barge-parked task (suppressParkedResume false — a "go on" may still resume it) is NOT superseded: it
+     *  keeps the normal surfacing path so a failure the user still cares about is not swallowed. */
+    private foldIfSuperseded;
     private failTask;
     /** Live-switch the think tier: `false` disables (removes the Think tool from the voice agent),
      *  a model id enables (adds the tool if missing). The system-prompt THINK_SLOT text is frozen at

package/dist/index.js

@@ -6734,6 +6734,9 @@ var DuplexAgent = class _DuplexAgent {
   tasks = /* @__PURE__ */ new Map();
   queue = Promise.resolve();
   seq = 0;
+  /** Monotonic user-turn counter (bumped once per SUBSTANTIVE turn). Stamped onto each task at dispatch
+   *  (TaskRecord.createdTurn) so parking can tell a prior-topic task from the current turn's fresh one. */
+  turn = 0;
   pendingEvents = [];
   /** Spoken text of parked deliveries that have SETTLED, awaiting a trivial-barge resume decision on the
    *  next turn (a substantive turn clears it — the result stays in the transcript, recoverable by asking). */
@@ -7027,6 +7030,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
     return this.enqueue(async () => {
       await this.initMemory();
       this.resetTurn();
+      this.turn++;
       this.awaitTrivialRedeliver = false;
       this.parkedRedeliver = [];
       this.suppressParkedResume = true;
@@ -7125,15 +7129,21 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
     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() {
-    this.suppressParkedResume = false;
+  /** Barge-in (or a dispatch-driven supersede): suppress running tasks' remaining SPOKEN delivery so a
+   *  superseded topic never talks over the new one (the debt-after-jokes regression). Tasks keep running and
+   *  still fold their result into the transcript — recoverable, just not spoken. Returns parked ids (logging).
+   *  Does NOT cancel. Two callers, two shapes:
+   *   - BARGE (default): the user interrupted AUDIO. Park EVERY running task (including this turn's) — the
+   *     worker they cut off must stop, whatever turn launched it — and re-arm trivial-barge auto-resume so a
+   *     following "go on" can bring the parked delivery back.
+   *   - SUPERSEDE (`priorTurnsOnly`, `reenableResume:false`, from dispatch()): a new dispatch redirected to
+   *     fresh work. Park only PRIOR-turn tasks so parallel siblings dispatched in the SAME turn don't silence
+   *     each other, and keep them suppressed (the user moved on — don't resurface on a stray "go on"). */
+  parkInFlightDeliveries(reenableResume = true, priorTurnsOnly = false) {
+    if (reenableResume) this.suppressParkedResume = false;
     const parked = [];
     for (const rec of this.tasks.values())
-      if (rec.status === "running" && !rec.deliveryParked) {
+      if (rec.status === "running" && !rec.deliveryParked && (!priorTurnsOnly || rec.createdTurn < this.turn)) {
         rec.deliveryParked = true;
         parked.push(rec.id);
       }
@@ -7319,7 +7329,7 @@ ${recent}` : brief) + verify + deliverContract;
       flushSpoken();
       return res;
     }).then((res) => this.maybeVerify(id, brief, res, tier, agentOpts, askBridge)).then((res) => this.onWorkerSettled(id, res)).catch((err) => this.onWorkerFailed(id, err));
-    this.tasks.set(id, { id, label, status: "running", controller, promise, tail, brief, followUp, splitter });
+    this.tasks.set(id, { id, label, status: "running", controller, promise, tail, brief, followUp, splitter, createdTurn: this.turn });
     if (this.tasks.size > this.options.maxTaskRecords)
       for (const [tid, rec] of this.tasks) {
         if (this.tasks.size <= this.options.maxTaskRecords) break;
@@ -7493,6 +7503,7 @@ Another agent just implemented the above. Independently check the CURRENT state
       toolCalls: res.messages.filter((m) => m.role === "tool").length
     });
     if (incomplete) {
+      if (this.foldIfSuperseded(rec, res.text)) return;
       return this.queueRevoice(this.integrationPrompt(rec, "incomplete", res.text, res.finishReason), true);
     }
     const tail = rec.splitter?.flush();
@@ -7514,12 +7525,25 @@ Another agent just implemented the above. Independently check the CURRENT state
   onWorkerFailed(id, err) {
     this.failTask(this.tasks.get(id), err instanceof Error ? err.message : String(err));
   }
+  /** A delivery the user has SUPERSEDED — parked AND moved on (suppressParkedResume, set by a redirect) —
+   *  must not hijack the voice when it settles late (partial or failed): that would talk over the new topic
+   *  and, worse, auto-escalate work the user already abandoned. Fold a recoverable note into the transcript
+   *  instead (the reflex can surface it if asked) and report true so the caller skips queueRevoice. A merely
+   *  barge-parked task (suppressParkedResume false — a "go on" may still resume it) is NOT superseded: it
+   *  keeps the normal surfacing path so a failure the user still cares about is not swallowed. */
+  foldIfSuperseded(rec, note) {
+    if (!(rec.deliveryParked && this.suppressParkedResume)) return false;
+    if (note.trim()) this.voice.transcript.push({ role: "assistant", content: note });
+    log13.verbose(`task ${rec.id} settled but superseded (${rec.status}) \u2014 folded into transcript, not voiced`);
+    return true;
+  }
   failTask(rec, msg) {
     this.dropAsk(rec.id);
     rec.status = "error";
     rec.result = msg;
     log13.warn(`task ${rec.id} failed: ${msg}`);
     this.notify("task_error", `task ${rec.id} (${rec.label}) failed: ${msg}`);
+    if (this.foldIfSuperseded(rec, `The "${rec.label}" task failed: ${msg}`)) return;
     this.queueRevoice(this.integrationPrompt(rec, "error", msg, "error"), true);
   }
   // --- voice tools (closures over this instance) ---
@@ -7540,6 +7564,7 @@ Another agent just implemented the above. Independently check the CURRENT state
   async dispatch(brief, tier = "act", label, followUp = false) {
     if (tier === "think" && this.options.thinkModel === false) tier = "act";
     if (followUp) this.autoEscalations++;
+    this.parkInFlightDeliveries(false, true);
     const id = `t${++this.seq}`;
     const lbl = label ?? tier;
     await this.options.onTaskStart?.(id, lbl);