@livx.cc/agentx 0.99.108 → 0.99.109

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;
@@ -22497,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 } : {} });