@livx.cc/agentx 0.99.108 → 0.99.110

package/dist/cli.js

@@ -10509,6 +10509,22 @@ 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 hostNoteBlock(note) {
+  return `<host_note>
+${note.trim()}
+</host_note>
+(Above: background from the app \u2014 NOT the user's words on this line. Never read it aloud as theirs. 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 +11018,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) {
-    const base = this.voice.transcript.length;
-    const res = await this.voice.send(content);
+  async reflexSend(content, note) {
+    const base = this.voice.transcript.length, context = this.lastContext;
+    const res = await this.sendWithContext(content, context, note);
     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 +11028,27 @@ ${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, note);
     } 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, note) {
+    if (typeof content !== "string" || !context?.trim() && !note?.trim()) return this.voice.send(content);
+    const stored = (note?.trim() ? hostNoteBlock(note) : "") + content, base = this.voice.transcript.length;
+    try {
+      return await this.voice.send((context?.trim() ? hostContextBlock(context) : "") + stored);
+    } finally {
+      const m = this.voice.transcript.slice(base).find((x) => x.role === "user");
+      if (m) m.content = stored;
+    }
+  }
+  /** The last line's host context (call rules, browser context): every reflex call runs under it, not only the user's line. */
+  lastContext;
   /** 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() {
@@ -11038,7 +11070,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
     this.stepMarks = [];
     this.dropJudge();
     try {
-      await this.voice.send(reminder);
+      await this.sendWithContext(reminder, this.lastContext);
     } catch (e) {
       log23.warn(`follow-through nudge failed: ${e instanceof Error ? e.message : e}`);
     } finally {
@@ -11181,7 +11213,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
     if (this.dispatchAt >= 0) this.dispatchAt = 0;
     this.nudging = true;
     try {
-      await this.voice.send(reminder);
+      await this.sendWithContext(reminder, this.lastContext);
     } catch (e) {
       log23.warn(`ack nudge failed: ${e instanceof Error ? e.message : e}`);
     } finally {
@@ -11220,6 +11252,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 && (opts.context !== void 0 || opts.note !== void 0) ? { context: opts.context, note: opts.note } : void 0;
     this.clearHoldResume();
     this.holdResumed = false;
     if (opts?.replaces) this.replaceTurn(opts.replaces);
@@ -11245,7 +11278,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 +11293,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,12 +11364,17 @@ ${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, host) {
     const spec = this.spec;
     if (spec?.state === "pending") {
       if (typeof content === "string" && speculationConfirms(spec.text, content)) {
         spec.state = "confirmed";
         spec.finalText = content;
+        if (host?.context !== void 0) this.lastContext = host.context;
+        if (host?.note?.trim()) {
+          const m = [...this.voice.transcript].reverse().find((x) => x.role === "user" && x.content === spec.text);
+          if (m) m.content = hostNoteBlock(host.note) + spec.text;
+        }
         if (rec) {
           spec.rec = rec;
           rec.ctl.signal.addEventListener("abort", () => spec.ctl.abort(), { once: true });
@@ -11383,8 +11421,9 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
       }
       if (typeof content === "string") content += spellingNote(content);
       let res;
+      if (host?.context !== void 0) this.lastContext = host.context;
       try {
-        res = await this.reflexSend(content);
+        res = await this.reflexSend(content, host?.note);
       } finally {
         if (signal) {
           this.voice.options.signal = ext;
@@ -11433,7 +11472,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
       this.voice.options.signal = spec.ctl.signal;
       let res;
       try {
-        res = await this.voice.send(spec.text);
+        res = await this.sendWithContext(spec.text, this.lastContext);
       } catch (e) {
         log23.warn(`speculative turn failed: ${e instanceof Error ? e.message : e}`);
       } finally {
@@ -11712,7 +11751,7 @@ Update: ${brief}`;
     return this.voice.transcript.filter((m) => (m.role === "user" || m.role === "assistant") && contentText(m.content).trim()).slice(-turns).map((m) => `${m.role}: ${contentText(m.content)}`).join("\n");
   }
   buildBrief(brief, tier = "act", deliver = true) {
-    const recent = this.recentExcerpt();
+    const recent = this.recentExcerpt(), host = this.lastContext?.trim();
     const verify = tier === "act" ? "\n\nBefore reporting done: re-read what you changed and check it against EVERY requirement above \u2014 fix any gap first. Your report is trusted without review. A command exiting 0 or echoing its input means it was ACCEPTED, not that it worked: before you say a web address was opened or reached, confirm it exists (its host resolves in DNS and answers an HTTP request); if it does not, report that it does not exist instead of success, and name the address you tried." : "";
     const deliverContract = deliver ? '\n\n## DELIVER (spoken delivery)\nYou are reporting back to a user who is LISTENING. Stream your work normally \u2014 your prose is the written work record and detail, and is NOT spoken. Wrap anything the user should HEAR in <spoken>\u2026</spoken> tags. LEAD WITH the actual content they asked for: if they asked for a specific piece of content \u2014 a value, a name, the actual lines, the writing itself \u2014 that content goes INSIDE the <spoken> tags, not a remark about it. Your FIRST <spoken> segment is substantive \u2014 never a greeting or an acknowledgement (the front-end has already acked; do not double-ack). Keep spoken text concise and natural for the ear: short sentences, no markdown. Never read a file path, URL, command or code aloud, nor spell one out ("slash \u2026 slash \u2026") \u2014 say it the way a person would, by the name of the folder, project, file or site; the exact text stays in your written prose. ' + (this.options.spokenBudgetChars ? `Speak a SHORT summary only: at most three short sentences with the one thing that matters most, then ONE short offer that names what else you have, as a question they can answer in a word \u2014 under ${this.options.spokenBudgetChars} characters in all, the offer included. Everything else stays in your written prose (it is kept and they can ask for it); spoken text past that budget is cut and held until they ask. ` : "") + `NEVER enumerate in speech \u2014 no numbered or bulleted lists ("One. \u2026 Two. \u2026" is robotic). Deliver multiple items as flowing conversation with brief connective phrasing ("here's one\u2026", "and another\u2026", "oh, and\u2026"), pausing between items with sentence breaks, not numbers.` + (this.options.emotionTags ? " Inside <spoken>, you may prefix a sentence with an inline [emotion] tag (e.g. [excited], [curious]) to color how it is voiced \u2014 only when it genuinely fits, and vary it; [laughter] gives a natural laugh." : "") : "";
     return `${nowLine()}.
@@ -11720,7 +11759,10 @@ Update: ${brief}`;
 ` + (recent ? `${brief}
 
 ## Recent conversation (for context)
-${recent}` : brief) + verify + deliverContract;
+${recent}` : brief) + (host ? `
+
+## The app's context for this line (not the user's words)
+${host}` : "") + verify + deliverContract;
   }
   /** Spawn a detached worker for task `id`; its settlement notifies + enqueues the re-voice turn. */
   spawnWorker(id, label, briefText, tier, brief, followUp) {
@@ -18789,6 +18831,8 @@ Flags:
   --timeout <sec>      wall-clock kill-switch (default 120)
   --input-format stream-json  with --duplex|--voice + --output-format stream-json: headless duplex for a host app
                        (NDJSON turns/barge-ins on stdin, reflex text + worker speech + task events on stdout)
+                       a user line's {context, note} = host info fenced as the app's (context: per-line rules, kept for
+                       results/reminders; note: persistent background) \u2014 never stored as the user's words
                        with -p: the first {"type":"user","text"} line is the prompt; later ones STEER the running turn
                        (unconsumed steers come back as the result's \`unsteered\`)
   --keep-alive         with -p --input-format stream-json: stay up after a turn \u2014 each {"type":"user"} line while idle
@@ -22497,7 +22541,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, note: typeof m.note === "string" ? m.note : 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 } : {} });