@livx.cc/agentx 0.99.109 → 0.99.110

package/dist/index.d.ts

@@ -1119,6 +1119,12 @@ declare class DuplexAgentOptions {
     /** User-scope memory dir for global facts (type=user/feedback). Forwarded to Remember's routing. */
     memoryUserDir?: string;
 }
+/** The host side of a user line: `context` = volatile per-line rules (they stay in force for later reflex calls — results,
+ *  reminders — until the next line replaces them); `note` = persistent background, stored fenced in that turn. */
+type HostInfo = {
+    context?: string;
+    note?: string;
+};
 declare const VOICE_SYSTEM_PROMPT: string;
 /**
  * The duplex orchestrator. `send()` enqueues a user turn on the reflex agent; `Act`/`Think`
@@ -1280,6 +1286,8 @@ declare class DuplexAgent {
      *  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. */
     private sendWithContext;
+    /** The last line's host context (call rules, browser context): every reflex call runs under it, not only the user's line. */
+    private 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). */
     private get hollowPromise();
@@ -1346,8 +1354,7 @@ declare class DuplexAgent {
         id?: string;
         replaces?: string;
         followUp?: string | Record<string, string>;
-        context?: string;
-    }): Promise<RunResult>;
+    } & HostInfo): Promise<RunResult>;
     /** 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. */
     private userTurns;

package/dist/index.js

@@ -10183,6 +10183,14 @@ ${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() {
@@ -10678,9 +10686,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, context) {
-    const base = this.voice.transcript.length;
-    const res = await this.sendWithContext(content, context);
+  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;
     log24.warn(`reflex ${model} rate-limited \u2014 re-running the turn on ${fb}`);
@@ -10688,7 +10696,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
     this.voice.transcript.length = base;
     this.voice.options.model = fb;
     try {
-      return await this.sendWithContext(content, context);
+      return await this.sendWithContext(content, context, note);
     } finally {
       this.voice.options.model = model;
     }
@@ -10697,16 +10705,18 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
    *  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;
+  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(hostContextBlock(context) + content);
+      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 = content;
+      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() {
@@ -10728,7 +10738,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) {
       log24.warn(`follow-through nudge failed: ${e instanceof Error ? e.message : e}`);
     } finally {
@@ -10871,7 +10881,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) {
       log24.warn(`ack nudge failed: ${e instanceof Error ? e.message : e}`);
     } finally {
@@ -10910,7 +10920,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;
+    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);
@@ -11022,12 +11032,17 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
       return { text: "", steps: 0, finishReason: "stop", messages: [] };
     });
   }
-  sendTurn(content, keepParked = false, rec, ext, context) {
+  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 });
@@ -11074,8 +11089,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, context);
+        res = await this.reflexSend(content, host?.note);
       } finally {
         if (signal) {
           this.voice.options.signal = ext;
@@ -11124,7 +11140,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) {
         log24.warn(`speculative turn failed: ${e instanceof Error ? e.message : e}`);
       } finally {
@@ -11403,7 +11419,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()}.
@@ -11411,7 +11427,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) {