@livx.cc/agentx 0.99.118 → 0.99.120

package/dist/cli.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-import { o as RouterState, H as Hooks, p as RunResult, R as ReasoningEffort, C as ChannelMode, A as Agent } from './secondChannel-BCEr_QyM.js';
+import { o as RouterState, H as Hooks, p as RunResult, R as ReasoningEffort, C as ChannelMode, A as Agent } from './secondChannel-DepBV0Zv.js';
 import { IFilesystem } from '@livx.cc/wcli/core';
 import { M as Message, U as UserQuestion, H as HostBridge, c as ContentPart, o as MessageContent } from './tools-DZHZIyxh.js';
 

package/dist/cli.js

@@ -13436,11 +13436,26 @@ var SecondChannel = class {
   }
   /** Hard gates every line passes, whoever proposed it. */
   allowed(k) {
-    if (!this.o.kinds.includes(k)) return false;
-    if (this.audioLocked || this.inflight || this.o.now() - this.lastAt < this.o.minGapMs || k === this.lastKind && (k !== "backchannel" || this.o.now() - this.lastAt < this.o.backchannelGapMs)) return false;
-    if (k === "backchannel") return this.o.aec && this.userSpeaking && this.main === "idle" && !this.capped();
-    if (k === "filler") return !this.userSpeaking && this.main === "idle";
-    return (this.main === "queued" || this.main === "thinking") && !this.bridged;
+    return !this.blocked(k);
+  }
+  /** Why a line of kind `k` can't play now ('' = it can) — the call's ledger names a missing bridge's cause. */
+  blocked(k) {
+    if (!this.o.kinds.includes(k)) return "kind off";
+    if (this.audioLocked) return `main audio (${this.main})`;
+    if (this.inflight) return "a line still playing";
+    if (this.o.now() - this.lastAt < this.o.minGapMs) return `${Math.round(this.o.now() - this.lastAt)}ms since the last line`;
+    if (k === this.lastKind && (k !== "backchannel" || this.o.now() - this.lastAt < this.o.backchannelGapMs)) return "same kind as the last line";
+    if (k === "backchannel") return this.o.aec && this.userSpeaking && this.main === "idle" && !this.capped() ? "" : "not a backchannel moment";
+    if (k === "filler") return !this.userSpeaking && this.main === "idle" ? "" : "not a filler moment";
+    return this.bridged ? "bridged already" : this.main === "queued" || this.main === "thinking" ? "" : `main ${this.main}`;
+  }
+  /** Why this turn gets no bridge by rule ('' = it may) — language, a quick/phatic turn, or blocked(). */
+  bridgeBlock() {
+    const w = words3(this.heard);
+    if (!this.lang) return "language unknown";
+    if (w.length <= 3 || w.length <= 6 && isPhatic(this.heard, this.bank)) return w.length <= 3 ? "quick turn" : "phatic";
+    if (w.length < this.o.bridgeMinWords) return `under ${this.o.bridgeMinWords} words`;
+    return this.blocked("bridge");
   }
   bcTimes = [];
   capped() {
@@ -13487,7 +13502,10 @@ var SecondChannel = class {
     return breath || /[,;:…]$/.test(this.heard);
   }
   async consider(trigger, pauseMs, breath = false, cue = null) {
-    if (this.busy) return;
+    if (this.busy) {
+      if (trigger === "working") this.o.onEvent({ trigger, rule: "silence", ms: 0, acted: "silence", reason: "deciding another line" });
+      return;
+    }
     const n0 = words3(this.heard).length;
     this.decidedAt = n0;
     if (!(this.o.anticipate && this.plan && trigger === "interim")) cue = null;
@@ -13497,7 +13515,10 @@ var SecondChannel = class {
       log27.info("chatty mode without echo cancellation \u2014 normal timing (our lines would re-trigger the mic)");
     }
     const rule = this.rule(trigger, pauseMs, breath, cue);
-    if (rule === "silence") return;
+    if (rule === "silence") {
+      if (trigger === "working") this.o.onEvent({ trigger, rule, ms: 0, acted: "silence", reason: this.bridgeBlock() || "rule" });
+      return;
+    }
     this.busy = true;
     const gen = this.gen, t0 = this.o.now();
     const ev = (e) => this.o.onEvent({ trigger, rule, ms: Math.round(this.o.now() - t0), ...cue ? { cue: cue.line } : {}, ...e });
@@ -13691,6 +13712,9 @@ var VoiceCallOptions = class {
   channel = {};
   onMetric = () => {
   };
+  /** The host reports when a fill line's audio REALLY starts (heard()). Off: a line handed to `speak` counts as heard —
+   *  right only for a host whose speak() plays at once (a relay host would count lines its player later dropped). */
+  hostAudio = false;
   now = () => performance.now();
   /** An aside (aside()) needs this long since the last one — a cue answered every time sounds scripted. */
   asideGapMs = 8e3;
@@ -13710,11 +13734,17 @@ var VoiceCall = class {
       } : {},
       mode: o.mode,
       aec: o.aec,
-      bridgeDelayMs: 700,
+      // v3 §3: first sound <1.2s p50 from the last word — the endpoint takes ~0.6s and the bridge's TTS ~0.2s, so the bridge
+      // goes 300ms after the turn if MAIN is still silent (it always is that early: warm MAIN's first token is ≥1s), no veto
+      bridgeDelayMs: 300,
       instantBridge: true,
-      // v3 §3: first sound <1.2s p50 — a bridge at 700ms if MAIN is still silent, no veto, no wait
       ...this.lang ? { lang: this.lang } : {},
       ...o.channel,
+      // the ledger: a turn's bridge moment that stayed silent, and why (its wait then has no first sound until MAIN speaks)
+      onEvent: (e) => {
+        if (e.trigger === "working" && e.acted !== "spoken") o.onMetric({ name: "drop", ...this.cur ? { id: this.cur.id } : {}, kind: `no bridge: ${e.reason ?? e.acted}`, ...e.text ? { text: e.text } : {} });
+        o.channel.onEvent?.(e);
+      },
       speak: (text, kind) => this.say(text, kind),
       show: (text, kind) => o.show(text, kind),
       cancel: () => o.cancel(),
@@ -13741,6 +13771,10 @@ var VoiceCall = class {
   lastAudibleAt = -Infinity;
   firstFinalAt = null;
   // the first final of the turn being formed (hold/merge)
+  lastWordAt = null;
+  // the user's last word before the turn being formed (its latest final's)
+  earlyHeard = null;
+  // a fill line heard while that turn was still held
   progressTimer = null;
   ended = false;
   get o() {
@@ -13769,12 +13803,37 @@ var VoiceCall = class {
     this.follow(text);
     this.fill.onInterim(text);
   }
-  /** STT final → TurnGate. */
-  final(text, sttId) {
+  /** STT final → TurnGate. `lastWordAgoMs`: how long ago the user's last word of it ended (the STT's word clock,
+   *  bod-voice UtteranceMeta.lastWordAgoMs) — the turn's latency anchor; absent = the final's arrival. `lang`: the
+   *  language the STT identified for it (UtteranceMeta.language) — what the turn's words follow when they alone can't tell
+   *  (a short English line after a Hebrew one left the fill channel on Hebrew: its bridge was refused, the turn silent). */
+  final(text, sttId, o = {}) {
     if (this.ended) return;
-    this.firstFinalAt ??= this.o.now();
+    const now4 = this.o.now(), { lastWordAgoMs } = o;
+    this.firstFinalAt ??= now4;
+    this.sttLang = o.lang ? primaryLang(o.lang) : null;
+    this.lastWordAt = typeof lastWordAgoMs === "number" && lastWordAgoMs >= 0 ? now4 - lastWordAgoMs : null;
+    this.finalAt = now4;
     this.gate.final(text, sttId);
   }
+  finalAt = 0;
+  sttLang = null;
+  // the STT's language for the final being followed
+  /** The host's player started a line's audio now (or in `inMs`): `fill`/`progress` = the fill channel's, `main` = MAIN's
+   *  reply (as main({type:'audio'})). With hostAudio this is what first_sound counts. */
+  heard(by, inMs = 0) {
+    if (this.ended) return;
+    if (by === "main") return this.main({ type: "audio", ...this.cur ? { id: this.cur.id } : {} }, inMs);
+    const at = this.o.now() + Math.max(0, inMs);
+    if (this.gate.holding || !this.cur || this.cur.closed) {
+      this.earlyHeard ??= { at, by };
+      return;
+    }
+    this.lastAudibleAt = at;
+    const c = this.cur;
+    c.marks.fillAudio ??= at;
+    this.sounded(c, by, at);
+  }
   /** A v2 host that decides turns itself: the user's line already went to MAIN (no TurnGate, no sendTurn) — the fill
    *  channel follows its language and covers the wait. */
   hostTurn(text) {
@@ -13785,8 +13844,8 @@ var VoiceCall = class {
   pause(ms) {
     if (!this.ended) this.fill.onPause(ms);
   }
-  /** MAIN's stream. */
-  main(ev) {
+  /** MAIN's stream. (`inMs`: an audio event's start is that far ahead — the host player's queue.) */
+  main(ev, inMs = 0) {
     const c = this.cur;
     if (!c || ev.id && ev.id !== c.id) return;
     switch (ev.type) {
@@ -13795,6 +13854,8 @@ var VoiceCall = class {
         return;
       case "text":
         if (!ev.text) return;
+        c.marks.mainFirst ??= this.o.now();
+        c.marks.mainText ??= this.o.now();
         if (!c.streamed) {
           c.streamed = true;
           this.gate.replyStarted(c.id);
@@ -13804,25 +13865,32 @@ var VoiceCall = class {
         this.fill.onMainTokens(ev.text);
         return;
       case "tool":
+        c.marks.mainFirst ??= this.o.now();
         this.gate.replyStarted(c.id);
         void this.onTool(c, ev.name ?? "", ev.args);
         return;
       case "tool_done":
         return;
-      case "audio":
-        this.lastAudibleAt = this.o.now();
+      case "audio": {
+        const at = this.o.now() + Math.max(0, inMs);
+        this.lastAudibleAt = at;
         this.fill.onAgentState("first_audio");
-        this.sounded(c, "main");
+        this.sounded(c, "main", at);
         if (!c.worded) {
           c.worded = true;
-          this.o.onMetric({ name: "first_word", id: c.id, ms: Math.round(this.o.now() - c.at), by: "main" });
+          c.marks.mainAudio = at;
+          this.o.onMetric({ name: "first_word", id: c.id, ms: Math.round(at - c.at), by: "main" });
         }
+        if (c.done) this.close(c, "answered");
         return;
+      }
       case "done":
       case "error":
         c.running = false;
+        c.done = true;
         this.clearProgress();
         this.fill.onAgentState("idle");
+        if (c.worded) this.close(c, "answered");
         return;
     }
   }
@@ -13839,6 +13907,7 @@ var VoiceCall = class {
       this.cur.running = false;
       this.o.abortTurn(this.cur.id);
     }
+    if (this.cur && !this.cur.worded) this.cur.end ??= "cut";
   }
   /** Soft barge-in: keep (a listener cue — no turn) or cut (→ barge()). */
   async overlap(text) {
@@ -13868,6 +13937,7 @@ var VoiceCall = class {
     return this.fill.drain();
   }
   end() {
+    if (this.cur) this.close(this.cur);
     this.ended = true;
     this.gate.end();
     this.clearProgress();
@@ -13876,24 +13946,39 @@ var VoiceCall = class {
   /** Follow the user's language from their own words: a confident detection, else the current language if the words
    *  fit it, else unknown (silent). Pinned into the channel so its own detection never diverges. */
   follow(text) {
-    const l = detectLanguage(text) ?? (this.lang && fitsLanguage(text, this.lang) ? this.lang : null);
+    const fits = (l2) => l2 && fitsLanguage(text, l2) ? l2 : null;
+    const l = detectLanguage(text) ?? fits(this.sttLang) ?? fits(this.lang);
     if (l !== this.lang) this.o.onMetric({ name: "lang", lang: l, text });
     this.lang = l;
     if (l) this.fill.setLanguage(l, true);
   }
   onTurn(t) {
-    const at = this.firstFinalAt ?? this.o.now();
+    const now4 = this.o.now(), lastWord = this.lastWordAt !== null;
+    const at = this.lastWordAt ?? this.firstFinalAt ?? now4;
+    const finalAt = this.finalAt || now4;
     this.firstFinalAt = null;
+    this.lastWordAt = null;
+    if (this.cur) this.close(this.cur, t.replaces === this.cur.id ? "replaced" : void 0);
     this.follow(t.text);
     this.clearProgress();
-    this.cur = { id: t.id, text: t.text, at, running: true, streamed: false, sounded: false, worded: false };
+    this.cur = { id: t.id, text: t.text, at, finalAt, lastWord, running: true, streamed: false, sounded: false, worded: false, done: false, marks: { sent: now4 }, closed: false };
+    const early = this.earlyHeard;
+    this.earlyHeard = null;
+    if (early && early.at >= at) {
+      this.cur.marks.fillAudio = early.at;
+      this.sounded(this.cur, early.by, early.at);
+    }
     this.progress.turn();
     this.o.onMetric({ name: "turn", id: t.id, kind: t.kind, text: t.text });
     this.o.sendTurn(t.text, { id: t.id, ...t.replaces ? { replaces: t.replaces } : {} });
     if (t.kind === "new") this.fill.onUserTurn(t.text);
   }
   onDrop(text, why) {
-    if (!this.gate.holding) this.firstFinalAt = null;
+    if (!this.gate.holding) {
+      this.firstFinalAt = null;
+      this.lastWordAt = null;
+      this.earlyHeard = null;
+    }
     this.o.onMetric({ name: "drop", kind: why, text });
   }
   /** Every fill/progress line passes here: only in the turn's known language, never after the call ended. */
@@ -13907,16 +13992,48 @@ var VoiceCall = class {
       return false;
     }
     if (r === false) return false;
-    this.lastAudibleAt = this.o.now();
     this.o.onMetric({ name: "fill", kind, text, lang: this.lang });
-    if (this.cur && (kind === "bridge" || kind === "progress")) this.sounded(this.cur, kind === "progress" ? "progress" : "fill");
-    else if (this.cur && this.cur.running && !this.cur.sounded && kind === "filler") this.sounded(this.cur, "fill");
+    const c = this.cur && !this.cur.closed ? this.cur : void 0;
+    const forTurn = !!c && (kind === "bridge" || kind === "progress" || kind === "filler" && c.running && !c.sounded);
+    if (c && forTurn && c.marks.fill === void 0) {
+      c.marks.fill = this.o.now();
+      c.fillKind = kind;
+    }
+    if (this.o.hostAudio) return r;
+    this.lastAudibleAt = this.o.now();
+    if (c && forTurn) {
+      c.marks.fillAudio ??= this.o.now();
+      this.sounded(c, kind === "progress" ? "progress" : "fill");
+    }
     return r;
   }
-  sounded(c, by) {
+  sounded(c, by, at = this.o.now()) {
     if (c.sounded) return;
     c.sounded = true;
-    this.o.onMetric({ name: "first_sound", id: c.id, ms: Math.round(this.o.now() - c.at), by });
+    this.o.onMetric({ name: "first_sound", id: c.id, ms: Math.round(at - c.at), by });
+  }
+  /** The turn is over (answered + audible, replaced, the next turn, the call's end): its timeline, once. A turn whose MAIN
+   *  never became audible still reports first_word — with no ms and why (cut / replaced / silent) — so every turn has one. */
+  close(c, end) {
+    if (c.closed) return;
+    c.closed = true;
+    c.end = c.worded ? "answered" : end ?? c.end ?? "silent";
+    if (!c.worded) this.o.onMetric({ name: "first_word", id: c.id, by: "main", kind: c.end });
+    const rel = (t) => t === void 0 ? void 0 : Math.round(t - c.at);
+    const m = c.marks, tl = {
+      final: rel(c.finalAt),
+      sent: rel(m.sent),
+      fill: rel(m.fill),
+      ...c.fillKind ? { fillKind: c.fillKind } : {},
+      fillAudio: rel(m.fillAudio),
+      mainFirst: rel(m.mainFirst),
+      mainText: rel(m.mainText),
+      mainAudio: rel(m.mainAudio),
+      lastWord: c.lastWord,
+      end: c.end
+    };
+    for (const k of Object.keys(tl)) if (tl[k] === void 0) delete tl[k];
+    this.o.onMetric({ name: "timeline", id: c.id, text: c.text, timeline: tl });
   }
   async onTool(c, name, args) {
     const lang = this.lang;
@@ -22707,6 +22824,8 @@ async function channelServe(args, ai, cfg) {
     channel: channelOptions(ai, process.env.AGENTX_CHANNEL_MODEL || model, args.voiceGender),
     speak: () => true,
     // the host plays {type:'channel'} lines (shown via show)
+    hostAudio: true,
+    // …and says when one really plays ({type:'heard'}) — a line its player drops never counts as sound
     show: (text, kind) => out({ type: "channel", kind, text }),
     sendTurn: (text, o) => out({ type: "turn", id: o.id, text, ...o.replaces ? { replaces: o.replaces } : {} }),
     abortTurn: (id) => out({ type: "abort", id }),
@@ -22731,7 +22850,8 @@ async function channelServe(args, ai, cfg) {
     if (m.type === "interim") {
       if (typeof m.lang === "string") call.setLanguage(m.lang);
       if (typeof m.text === "string") call.interim(m.text, Date.now(), typeof m.aec === "boolean" ? m.aec : void 0);
-    } else if (m.type === "final" && typeof m.text === "string") call.final(m.text, m.sttId === void 0 ? void 0 : String(m.sttId));
+    } else if (m.type === "final" && typeof m.text === "string") call.final(m.text, m.sttId === void 0 ? void 0 : String(m.sttId), { ...typeof m.lastWordAgoMs === "number" ? { lastWordAgoMs: m.lastWordAgoMs } : {}, ...typeof m.lang === "string" ? { lang: m.lang } : {} });
+    else if (m.type === "heard" && ["fill", "progress", "main"].includes(m.by)) call.heard(m.by, typeof m.inMs === "number" ? m.inMs : 0);
     else if (m.type === "main" && m.ev && typeof m.ev.type === "string") call.main(m.ev);
     else if (m.type === "barge") call.barge();
     else if (channelInput(call.fill, m)) return;