@livx.cc/agentx 0.99.25 → 0.99.26

package/dist/cli.js

@@ -6649,6 +6649,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). */
@@ -6942,6 +6945,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;
@@ -7040,15 +7044,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);
       }
@@ -7234,7 +7244,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((err2) => this.onWorkerFailed(id, err2));
-    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;
@@ -7408,6 +7418,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();
@@ -7429,12 +7440,25 @@ Another agent just implemented the above. Independently check the CURRENT state
   onWorkerFailed(id, err2) {
     this.failTask(this.tasks.get(id), err2 instanceof Error ? err2.message : String(err2));
   }
+  /** 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 });
+    log12.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;
     log12.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) ---
@@ -7455,6 +7479,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);