@livx.cc/agentx 0.99.24 → 0.99.26

package/dist/cli.d.ts

@@ -144,6 +144,7 @@ interface Args {
     worktree?: string;
     updateCheck?: boolean;
     update?: boolean;
+    listModels?: boolean;
 }
 declare function parseArgs(argv: string[]): Args;
 declare function makeHost(format?: 'text' | 'json' | 'stream-json', opts?: {

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);
@@ -12075,8 +12100,13 @@ function parseArgs(argv) {
     const x = argv[i];
     if (x === "-h" || x === "--help") a.help = true;
     else if (x === "-v" || x === "--version") a.version = true;
-    else if (x === "-m" || x === "--model") a.model = val(++i, x);
-    else if (x === "-C" || x === "--cwd") a.cwd = val(++i, x);
+    else if (x === "-m" || x === "--model") {
+      const nxt = argv[i + 1];
+      if (nxt === void 0 || nxt.startsWith("-") || nxt === "list" || nxt === "ls" || nxt === "?") {
+        a.listModels = true;
+        if (nxt === "list" || nxt === "ls" || nxt === "?") i++;
+      } else a.model = argv[++i];
+    } else if (x === "-C" || x === "--cwd") a.cwd = val(++i, x);
     else if (x === "-p" || x === "--print") {
       const nxt = argv[i + 1];
       if (nxt !== void 0 && !nxt.startsWith("-")) a.task = argv[++i];
@@ -12149,7 +12179,7 @@ var HELP = `agentx \u2014 agent runtime CLI
   agentx -c "<task>"              continue the most recent session
 
 Flags:
-  -m, --model <id>     model (default anthropic/claude-sonnet-4-6)
+  -m, --model <id>     model (default anthropic/claude-sonnet-4-6); bare -m or -m list = list all models
   -C, --cwd <dir>      working dir / project root (default .)
   -c, --continue       resume the most recent session in this dir
   -r, --resume [id]    resume a session \u2014 with an id, or bare for an interactive picker
@@ -12229,6 +12259,24 @@ REPL paste: large/multi-line pastes collapse to a [Pasted text +N lines] preview
 function newestModel() {
   return listModels().slice().sort((a, b) => (getModelInfo(b)?.releaseDate ?? "").localeCompare(getModelInfo(a)?.releaseDate ?? ""))[0] ?? "";
 }
+function printModels() {
+  const byProvider = /* @__PURE__ */ new Map();
+  for (const id of listModels()) {
+    const provider = getProviderFromModel(id) ?? "other";
+    if (!byProvider.has(provider)) byProvider.set(provider, []);
+    byProvider.get(provider).push(id);
+  }
+  for (const [provider, ids] of Array.from(byProvider.entries()).sort((a, b) => a[0].localeCompare(b[0]))) {
+    console.log(`
+${provider}`);
+    ids.sort((a, b) => (getModelInfo(b)?.releaseDate ?? "").localeCompare(getModelInfo(a)?.releaseDate ?? ""));
+    for (const id of ids) {
+      const info = getModelInfo(id);
+      const meta = [info?.displayName, info?.releaseDate].filter(Boolean).join(" \xB7 ");
+      console.log(`  ${id}${meta ? `  (${meta})` : ""}`);
+    }
+  }
+}
 function resolveModelOrNewest(model) {
   const want = model ?? new AgentOptions().model;
   const resolved = resolveModel(want);
@@ -15492,6 +15540,10 @@ async function main() {
     console.log(HELP);
     return;
   }
+  if (args.listModels) {
+    printModels();
+    return;
+  }
   if (args.update) {
     const msg = await checkForUpdate(VERSION).catch(() => null);
     if (!msg) {