@livx.cc/agentx 0.99.107 → 0.99.109

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-BYW5qPAJ.js';
+import { o as RouterState, H as Hooks, p as RunResult, R as ReasoningEffort, C as ChannelMode, A as Agent } from './secondChannel-3IPP3Qgh.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

@@ -10509,6 +10509,14 @@ function nameScore(want, have) {
 var RESERVED_EVENT_MARKER = /\[task\b[^\]\n]*\b(?:completed|failed|progress|asks)\b/i;
 var RESERVED_EVENT_OPENER = /\[\s*task\b/i;
 var STAGE_DIRECTION_RE = /^\(\s*(?:(?:waiting|checking|searching|thinking|processing|loading|working|fetching|looking)\b[^)]*|[^)]*(?:\.\.\.|…)\s*)\)$/i;
+function hostContextBlock(context) {
+  return `<host_context>
+${context.trim()}
+</host_context>
+(Above: context and instructions from the app \u2014 NOT the user's words. Never read it aloud, quote it, or attribute it to the user. The user's line follows.)
+
+`;
+}
 function nowLine() {
   return `Current date and time: ${(/* @__PURE__ */ new Date()).toLocaleString("en-US", { weekday: "long", year: "numeric", month: "long", day: "numeric", hour: "numeric", minute: "2-digit", timeZoneName: "short" })}`;
 }
@@ -11002,9 +11010,9 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
   /** One reflex model call for a turn; a turn rejected for load (rateLimited) that has not spoken or dispatched yet is rolled
    *  back and re-run once on `reflexFallbackModel` — a re-prompt of the same model (the dead-air nudge) only hits the
    *  same limit and ends in "could you say that again?". */
-  async reflexSend(content) {
+  async reflexSend(content, context) {
     const base = this.voice.transcript.length;
-    const res = await this.voice.send(content);
+    const res = await this.sendWithContext(content, context);
     const fb = this.options.reflexFallbackModel, model = this.voice.options.model;
     if (res.finishReason !== "error" || !rateLimited(res.error) || !fb || fb === model || fb.includes("/") && model.includes("/") && fb.split("/")[0] !== model.split("/")[0] || this.turnDispatched || this.turnSpoken.trim()) return res;
     log23.warn(`reflex ${model} rate-limited \u2014 re-running the turn on ${fb}`);
@@ -11012,11 +11020,25 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
     this.voice.transcript.length = base;
     this.voice.options.model = fb;
     try {
-      return await this.voice.send(content);
+      return await this.sendWithContext(content, context);
     } finally {
       this.voice.options.model = model;
     }
   }
+  /** The host's per-line context (call rules, browser context, earlier conversation) rides THIS call only, fenced as the app's —
+   *  inside the user turn it read as the user's own words (live #938: "repeat everything I said" recited the call rules). The
+   *  stored turn keeps only what the user said, so later turns, briefs and the saved session never carry it. A block, not a
+   *  mid-transcript system message: the Anthropic/Google adapters keep only the leading system message. */
+  async sendWithContext(content, context) {
+    if (!context?.trim() || typeof content !== "string") return this.voice.send(content);
+    const base = this.voice.transcript.length;
+    try {
+      return await this.voice.send(hostContextBlock(context) + content);
+    } finally {
+      const m = this.voice.transcript.slice(base).find((x) => x.role === "user");
+      if (m) m.content = content;
+    }
+  }
   /** The turn SAID it is on it ("got it — checking…") but called no tool and nothing is running: a promise nothing
    *  keeps — the user waits on silence (live Para #798: a follow-up while the reflex believed a finished task still ran). */
   get hollowPromise() {
@@ -11220,6 +11242,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
    *  second Act). The host gets `turn_replace` {id, replaces, rolledBack, followed?}: only a rollback drops the replaced
    *  line; `followed` = the kept turn whose follow-up ran (absent: the merged text ran). */
   send(content, opts) {
+    const ctx = opts?.context;
     this.clearHoldResume();
     this.holdResumed = false;
     if (opts?.replaces) this.replaceTurn(opts.replaces);
@@ -11245,7 +11268,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
         if (intent === "resume" && !reflexCut) return this.resumeParked();
         if (intent === "aside" || intent === "resume") {
           const told = intent === "aside" ? [...this.parkedRedeliver] : [];
-          return this.sendTurn(intent === "aside" ? content + this.asideNote(told) : content, true, rec, ext).then(async (r) => {
+          return this.sendTurn(intent === "aside" ? content + this.asideNote(told) : content, true, rec, ext, ctx).then(async (r) => {
             if (r.finishReason === "aborted" || this.heldThisTurn) return r;
             const missed = unsaidClauses(told.map((p) => p.text), this.turnSpoken, this.options.decider);
             const turn = this.turn;
@@ -11260,10 +11283,10 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
             return r;
           });
         }
-        return this.sendTurn(content, false, rec, ext);
+        return this.sendTurn(content, false, rec, ext, ctx);
       });
     }
-    return this.sendTurn(typeof content === "string" ? content + this.acceptNote(content) : content, false, rec, ext);
+    return this.sendTurn(typeof content === "string" ? content + this.acceptNote(content) : content, false, rec, ext, ctx);
   }
   /** Host-named user turns (send opts.id), so a later send can replace one. Bounded; a replace that arrives
    *  BEFORE its target (the host's dispatch hops can reorder) leaves a pre-superseded record behind. */
@@ -11331,7 +11354,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
       return { text: "", steps: 0, finishReason: "stop", messages: [] };
     });
   }
-  sendTurn(content, keepParked = false, rec, ext) {
+  sendTurn(content, keepParked = false, rec, ext, context) {
     const spec = this.spec;
     if (spec?.state === "pending") {
       if (typeof content === "string" && speculationConfirms(spec.text, content)) {
@@ -11384,7 +11407,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
       if (typeof content === "string") content += spellingNote(content);
       let res;
       try {
-        res = await this.reflexSend(content);
+        res = await this.reflexSend(content, context);
       } finally {
         if (signal) {
           this.voice.options.signal = ext;
@@ -13022,6 +13045,9 @@ var SecondChannelOptions = class {
   /** A bridge waits this long after the user's turn is dispatched, and plays only if channel-1 has said nothing yet
    *  (a fast reply/ack needs no bridge — one before it reads as the agent starting a different sentence). 0 = at once. */
   bridgeDelayMs = 1200;
+  /** Duplex v3 (§3 first sound): a bridge skips the decider (the veto stays for backchannels/fillers) and speaks a
+   *  canned line at once; a generated one is started at dispatch and used only if it already landed. */
+  instantBridge = false;
   /** No new interim for this long → a pause (hosts may also call onPause). */
   fillerPauseMs = 700;
   fillerMinWords = 4;
@@ -13093,6 +13119,8 @@ var SecondChannel = class {
   // the line the last barge actually cut (spoke())
   bridged = false;
   // one bridge per main turn
+  bridgeDraft = null;
+  // a bridge generated ahead, used only if ready in time
   recent = [];
   picks = /* @__PURE__ */ new Map();
   inflight = null;
@@ -13228,6 +13256,7 @@ var SecondChannel = class {
         if (this[k]) clearTimeout(this[k]);
         this[k] = null;
       }
+      if (this.o.instantBridge) this.prefetchBridge();
       const wait = Math.max(this.o.bridgeDelayMs, this.o.minGapMs - (this.o.now() - this.lastAt));
       if (wait > 0) this.bridgeTimer = setTimeout(() => {
         this.bridgeTimer = null;
@@ -13360,7 +13389,7 @@ var SecondChannel = class {
     try {
       let kind = rule;
       let choice;
-      if (this.o.decide && !cue) {
+      if (this.o.decide && !cue && !(rule === "bridge" && this.o.instantBridge)) {
         const ac = new AbortController();
         const d = await withBudget(this.o.decide(this.tail(), { ...this.state(pauseMs), rule }, ac.signal), this.o.decisionBudgetMs, "channel decision", ac);
         choice = d?.choice;
@@ -13394,7 +13423,24 @@ var SecondChannel = class {
       call_ms: Math.round(now4 - this.startedAt)
     };
   }
+  /** Start writing this turn's bridge now, so it may be ready by bridgeDelayMs. The bridge never waits for it. */
+  prefetchBridge() {
+    this.bridgeDraft = null;
+    if (!this.o.generate || !this.o.generateFor.includes("bridge") || !this.lang || !this.heard) return;
+    const gen = this.gen, ac = new AbortController();
+    const ctx = { kind: "bridge", heard: this.tail(), state: this.main, avoid: [...this.recent], lang: this.lang };
+    void withBudget(this.o.generate(ctx, ac.signal), Math.max(this.o.generateBudgetMs, this.o.bridgeDelayMs), "bridge generate", ac).then((raw) => {
+      const text = cleanLine(raw ?? "", ctx.lang);
+      if (text && gen === this.gen) this.bridgeDraft = { gen, text };
+    }).catch((e) => log27.debug(`bridge prefetch failed: ${e?.message ?? e}`));
+  }
   async line(kind, react = true) {
+    if (kind === "bridge" && this.o.instantBridge) {
+      const d = this.bridgeDraft?.gen === this.gen ? this.bridgeDraft.text : "";
+      this.bridgeDraft = null;
+      if (d && !this.recent.some((r) => norm3(r) === norm3(d))) return d;
+      return this.pick(kind);
+    }
     if (this.o.generate && this.o.generateFor.includes(kind) && (kind !== "backchannel" || react)) {
       const ac = new AbortController();
       const ctx = { kind, heard: this.tail(), state: this.main, avoid: [...this.recent], lang: this.lang, ...kind === "backchannel" && this.o.reactionGapMs ? { react: true } : {} };
@@ -13544,6 +13590,9 @@ var VoiceCall = class {
       } : {},
       mode: o.mode,
       aec: o.aec,
+      bridgeDelayMs: 700,
+      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,
       speak: (text, kind) => this.say(text, kind),
@@ -22471,7 +22520,7 @@ async function duplexServe(args, ai, cfg, cwd) {
         const done2 = () => {
           if (seq === scTurn) sc?.onAgentState("idle");
         };
-        void runTurn(dx.voice, store, session, m.text + note, void 0, cwd, (c) => dx.send(c, { id, replaces: m.replaces ? String(m.replaces) : void 0, followUp: typeof m.followUp === "string" || m.followUp && typeof m.followUp === "object" ? m.followUp : void 0 })).then(({ res, error }) => {
+        void runTurn(dx.voice, store, session, m.text + note, void 0, cwd, (c) => dx.send(c, { id, replaces: m.replaces ? String(m.replaces) : void 0, followUp: typeof m.followUp === "string" || m.followUp && typeof m.followUp === "object" ? m.followUp : void 0, context: typeof m.context === "string" ? m.context : void 0 })).then(({ res, error }) => {
           const why = (res?.finishReason ?? "error") === "error" ? duplexError(res?.error ?? error, dx.options.reflexModel) : "";
           done2();
           out({ type: "turn_done", id, finishReason: res?.finishReason ?? "error", ...why ? { error: why } : {} });