@livx.cc/agentx 0.99.10 → 0.99.11

package/dist/index.d.ts

@@ -886,6 +886,9 @@ interface TaskRecord {
      *  delivery is suppressed (don't talk over the new topic), but its full result still lands in the
      *  transcript so the reflex can surface it on request. See parkInFlightDeliveries(). */
     deliveryParked?: boolean;
+    /** Accumulated `<spoken>` delivery text (every segment, whether or not it was actually voiced). Used to
+     *  RESUME a parked delivery after a trivial barge — see isTrivialBarge / redeliverParked. */
+    spokenText?: string;
 }
 type WorkerTier = 'act' | 'think';
 declare class DuplexAgentOptions {
@@ -961,6 +964,14 @@ declare class DuplexAgent {
     private queue;
     private seq;
     private pendingEvents;
+    /** Spoken text of parked deliveries that have SETTLED, awaiting a trivial-barge resume decision on the
+     *  next turn (a substantive turn clears it — the result stays in the transcript, recoverable by asking). */
+    private parkedRedeliver;
+    /** A trivial barge arrived while a parked delivery was STILL RUNNING → resume it the moment it settles. */
+    private awaitTrivialRedeliver;
+    /** Set by a SUBSTANTIVE turn after a barge: the user moved on, so a parked delivery that settles LATER
+     *  must NOT arm a resume (else a much-later "go on" replays a stale result). Reset by a fresh barge. */
+    private suppressParkedResume;
     /** Out-of-band follow-up attribution for the events coalescing into the next flush turn: TRUE iff ≥1 of
      *  the tasks being integrated was NON-CLEAN (early-stop/failure). Carried out-of-band on the enqueue call
      *  by the caller that KNOWS the outcome — a plain boolean the MODEL CANNOT PERTURB. It is NOT scanned from
@@ -1077,6 +1088,12 @@ declare class DuplexAgent {
      *  tasks keep running and still fold their result into the transcript — recoverable, just not spoken.
      *  Returns the parked ids (for logging). Does NOT cancel: that's a deliberate reflex/user action. */
     parkInFlightDeliveries(): string[];
+    /** True while there is a parked delivery to potentially resume: either one already settled (queued) or
+     *  one still running that was parked by a barge. */
+    private hasParkedDelivery;
+    /** Speak any settled-and-queued parked delivery now (trivial-barge resume). Returns false if nothing was
+     *  queued yet (the caller then arms awaitTrivialRedeliver so the task resumes the instant it settles). */
+    private redeliverParked;
     /** Resolve when all queued voice turns AND all in-flight worker tasks have settled (tests, graceful shutdown). */
     idle(): Promise<void>;
     /** Promise-chain mutex: turns run strictly one at a time; a failed turn doesn't poison the chain. */

package/dist/index.js

@@ -6017,6 +6017,16 @@ var DuplexAgentOptions = class {
 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 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" })}`;
+}
+function isTrivialBarge(text) {
+  const t = text.trim().toLowerCase().replace(/[.,!?…\s]+$/g, "").replace(/^[.,!?…\s]+/, "");
+  if (!t) return false;
+  if (/\b(stop|cancel|no|nope|nah|never\s?mind|nvm|forget it|drop it|don'?t|quiet|shut up|enough|hold on|wait|pause|hang on|actually)\b/.test(t)) return false;
+  const core = t.replace(/^(?:oh|um+|uh+|er+|hmm+|ah+|well|so|okay|ok|yeah|yep)[\s,]+/, "").trim();
+  return /^(?:oh|um+|uh+|er+|hmm+|ah+|sorry|oops|whoops|my bad|pardon|excuse me|apologies|go on|go ahead|continue|keep going|carry on|as you were|please continue|you were saying|sorry go on|sorry continue|go on then|go on please)$/.test(core || t);
+}
 var VOICE_SYSTEM_PROMPT = 'You are a spoken voice assistant \u2014 the user HEARS everything you say. Use short sentences. One idea per sentence. No markdown, no bullet lists, no code blocks, no headings, no emoji. Never emit stage directions or parenthetical asides about your own process \u2014 nothing like "(waiting for the result...)" or "(checking)"; while work runs, either say it as plain speech or end your turn.\nThis holds even when asked to "print", "list", "show", or "make a table" \u2014 there is no screen for the spoken channel. Speak it as flowing prose ("Tuesday is half a meter, Wednesday a bit less\u2026"), or if they truly need it on screen, route it to Act to render. Never emit dashes or pipes into speech.\nKeep turns SHORT \u2014 one to three sentences, then stop. Never lecture, enumerate cases, or add caveats unprompted. Conversation is a fast exchange: give the one thing asked, and let the user pull more if they want it.\nYou have three cognitive tiers \u2014 like a human brain:\n\u2022 YOU (reflex) \u2014 instant, lightweight. Handle greetings, simple questions, status checks, QuickLook.\n\u2022 `Act` \u2014 your hands. A background worker with its own configured tools and access to the user\'s environment (files and shell{{WORKER_WEB}}). Use for reading, editing, searching, running tasks, building \u2014 any real work.\n{{THINK_SLOT}}\nWhen you are unsure whether you can do or access something, do NOT assume and do NOT claim a capability you have not confirmed. To check what you can do, QuickLook `capabilities` (instant \u2014 it lists your worker\'s real tools) and answer from that. Never promise an ability that is not in your capabilities; if it is not there, tell the user plainly you can\'t. To actually DO real work, call `Act`. When the user mentions their project, folder, files, or environment ("this project", "the current folder", "my code"), call `Act` IMMEDIATELY \u2014 do not ask for paths or details the worker can discover itself. Never pretend to have done the work or invent results \u2014 the worker\'s report is your only source.\nYou cannot mute the microphone or stop voice capture yourself \u2014 no tool does it. If the user asks you to stop listening or turn the voice off, never claim you did: tell them to say exactly "voice off" (handled by the app directly), or type /voice.\nYou are NOT a knowledge base. For any question whose answer needs SPECIFIC verifiable facts you do not already have in hand \u2014 how to build/configure/implement something, exact API, library, entitlement, command or option names, current events, or particular numbers, dates, or names \u2014 do NOT answer from your own memory: you will confidently make things up (a fake API, a wrong entitlement, an event that did not happen). Route it to `Act`, which can search and verify, and speak only what its report says. DELEGATION RULE \u2014 decide for yourself, the user never has to push: if you cannot answer confidently from the conversation plus trivial well-known knowledge, do NOT refuse and do NOT guess \u2014 dispatch `Act` immediately with a clear brief and say you are checking. Anything needing CURRENT data (weather, news, prices, dates, sky/astronomy, "right now"), real computation, or verification is an automatic dispatch \u2014 never a refusal. The user should never need to say "search the web" or "think harder" to make you act; needing fresh or verified information IS the trigger. Refuse only what your worker genuinely cannot do (check `capabilities`), and say why. Answer inline ONLY for general conversation, chit-chat, and trivia you are sure of, or facts you can see via QuickLook. When elaborating on a completed task ("tell me more", "the gist"), stay strictly within what that result actually said \u2014 if the user asks for something the result did not cover, that is NEW information: dispatch `Act`, do not improvise.\nALWAYS react before you work: the FIRST thing in your turn is a brief spoken acknowledgement of what you heard and what you are about to do ("got it \u2014 opening that now", "sure, let me pull it up", "okay, checking"). NEVER call a tool (Act, Think, QuickLook) silently \u2014 the user must hear you react before you go quiet to work. After dispatching Act or Think, that same one short sentence IS your turn \u2014 end it and do not wait for the result.\nA completed task speaks its OWN result to the user (the worker voices what matters as it finishes) \u2014 you do NOT re-voice clean task results. A FAILED or INCOMPLETE task still arrives as a "[task t1 failed] \u2026" event for you to handle. The completed result stays in YOUR context \u2014 it is yours to draw on. When the user follows up ("tell me more", "what else", "and?"), answer FROM that result first: you already have the detail, so elaborate on what you have. Do NOT spawn a fresh worker to re-search or re-gather what you were just handed. Re-dispatch ONLY when genuinely new information is needed \u2014 e.g. the user wants the full contents of a SPECIFIC source, which is one WebFetch of that URL, not a brand-new search. "[task t1 progress] \u2026" events are interim status, NOT results \u2014 give at most a half-sentence aside ("still on it \u2014 running tests now") and end your turn. Never present progress as a finished result.\nCRITICAL: while a task is still running you have NO answer yet \u2014 never state a specific result of any kind (a number, size, count, name, path, or value). The real answer arrives ONLY in the "[task \u2026 completed]" event; inventing one meanwhile (a made-up disk size, commit count, etc.) is a serious error. Until then, only acknowledge and wait.\nNever read raw file paths, diffs, or code aloud verbatim.\nDo NOT end every turn with the same canned offer ("want a rundown?", "want the steps?"). Offer once at most; if the user pushes back, repeats themselves, or sounds unsatisfied ("you know what I mean?", "think deeper", "are you sure?"), do NOT re-offer the same thing \u2014 change approach: dispatch `Act`/`Think` to actually dig in, or ask one concrete clarifying question. Repeating a non-answer is worse than silence.\n"[task t1 asks] \u2026" events are QUESTIONS from a background task \u2014 relay to the user in your own words, short, then end your turn. When the user answers, call `AnswerTask` with that id and their answer. NEVER answer on the user\'s behalf for permissions or risky operations; if their reply is ambiguous, confirm first.\nIf the user\'s message sounds INCOMPLETE \u2014 trailing off mid-sentence, a fragment that needs more context ("and then we", "but the problem is"), hesitation fillers ("uh", "um") \u2014 call `Hold` instead of answering. This keeps listening for the rest of their thought. Only respond with substance when you have a complete question or request.\nDispatch discipline: send ONE self-contained task per request \u2014 a single worker with the full brief beats several workers with fragments (each worker starts fresh and re-discovers context). NEVER dispatch a worker just to read files or gather information \u2014 workers explore and discover context themselves; pass on what you already know and let one worker do the whole job. Split into parallel tasks only when the user asks for genuinely independent things. When a task completes, report its result and stop \u2014 do NOT dispatch follow-up work (verification, polish, extras) the user did not ask for, unless the report itself signals failure or doubt.\nDo not fire a second Act/Think for work already in flight, and NEVER spawn a second task to re-count, cross-check, or verify a result a worker already gave you \u2014 trust its answer; a single question gets ONE task. Call `TaskStatus` at most ONCE per turn; if a task is still running, just say "still on it" and end the turn \u2014 never poll it again and again in a loop. Use `CancelTask` when the user asks to stop something.\nPRIORITY: when the user says goodbye or wants to end/finish/wrap up the session ("ok bye", "that\'s all", "let\'s finish", "let\'s end", "goodnight", "exit", "wrap up"), call `ExitSession` IMMEDIATELY \u2014 do not act, do not check status, just exit.\nFor TRIVIAL instant lookups only \u2014 current time, git branch, listing a folder, peeking at a small file, or checking your own `capabilities`/tools \u2014 use `QuickLook` (instant, no task). Whenever the user asks what you can do or whether you have some ability, QuickLook `capabilities` and answer from that \u2014 never guess. Anything requiring searching, reasoning, running commands, or editing goes through `Act`.\n{{MEMORY_SLOT}}\nUser messages may arrive via speech-to-text and can carry transcription artifacts \u2014 odd words, cut-offs, homophones ("for you" vs "folder"). Read for INTENT, not surface text. If a message seems garbled, surprising, or only half-parses, do NOT guess an action or improvise content from it \u2014 briefly confirm what they meant ("did you mean\u2026?") and wait. A one-line confirm beats a confident wrong answer or an invented response to a request you did not actually understand.';
 var THINK_GUIDANCE = "\u2022 `Think` \u2014 your brain. A premium reasoning model, FAR more expensive than Act. Reserve it for open-ended architecture/design questions, or a problem Act already FAILED at. ALL implementation work \u2014 coding, refactoring, debugging, edge cases, tests \u2014 goes to Act; Act is highly capable. Never send the same work to both.";
 var THINK_DISABLED_GUIDANCE = "(Think tier is not available \u2014 use Act for all escalations.)";
@@ -6029,6 +6039,14 @@ var DuplexAgent = class _DuplexAgent {
   queue = Promise.resolve();
   seq = 0;
   pendingEvents = [];
+  /** Spoken text of parked deliveries that have SETTLED, awaiting a trivial-barge resume decision on the
+   *  next turn (a substantive turn clears it — the result stays in the transcript, recoverable by asking). */
+  parkedRedeliver = [];
+  /** A trivial barge arrived while a parked delivery was STILL RUNNING → resume it the moment it settles. */
+  awaitTrivialRedeliver = false;
+  /** Set by a SUBSTANTIVE turn after a barge: the user moved on, so a parked delivery that settles LATER
+   *  must NOT arm a resume (else a much-later "go on" replays a stale result). Reset by a fresh barge. */
+  suppressParkedResume = false;
   /** Out-of-band follow-up attribution for the events coalescing into the next flush turn: TRUE iff ≥1 of
    *  the tasks being integrated was NON-CLEAN (early-stop/failure). Carried out-of-band on the enqueue call
    *  by the caller that KNOWS the outcome — a plain boolean the MODEL CANNOT PERTURB. It is NOT scanned from
@@ -6110,7 +6128,7 @@ var DuplexAgent = class _DuplexAgent {
     ];
     const workerMcp = mcpNames.length ? `, and it can use these MCP servers: ${[...new Set(mcpNames)].join(", ")}` + (mcpNames.some((n) => /browser/i.test(n)) ? ' \u2014 including driving a REAL browser (open tabs, navigate, click, screenshot), so answer "yes" if asked whether you can control/drive a browser and route an actual browse to Act' : "") : "";
     const prompt = VOICE_SYSTEM_PROMPT.replace("{{MEMORY_SLOT}}", memSlot).replace("{{THINK_SLOT}}", thinkSlot).replace("{{WORKER_WEB}}", workerWeb + workerMcp) + (o.voiceStyle === "conversational" ? "\n" + VOICE_STYLE_CONVERSATIONAL : "") + (o.emotionTags ? "\n" + EMOTION_TAGS_GUIDANCE : "") + `
-Today's date: ${(/* @__PURE__ */ new Date()).toDateString()}.`;
+${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today", "now", "current", "recent", "latest", "this year" \u2014 to THIS moment. When the user asks about something recent (news, sports, events), they mean near this date, not a well-known past instance; brief your worker with the current year so it searches for what is happening NOW, not a famous older event.`;
     const tools = [
       ...o.reflexOptions?.tools ?? [],
       this.actTool(),
@@ -6290,6 +6308,14 @@ Today's date: ${(/* @__PURE__ */ new Date()).toDateString()}.`;
    *  host NOW (this is the latency win) and streaming continues live. Any other content aborts the
    *  speculation first (rolled back silently) and runs a normal turn behind it. */
   send(content) {
+    if (typeof content === "string" && isTrivialBarge(content) && this.hasParkedDelivery()) {
+      if (this.spec) this.abortSpeculation();
+      return this.enqueue(async () => {
+        this.resetTurn();
+        if (!this.redeliverParked()) this.awaitTrivialRedeliver = true;
+        return { text: "", steps: 0, finishReason: "stop", messages: [] };
+      });
+    }
     const spec = this.spec;
     if (spec?.state === "pending") {
       if (typeof content === "string" && speculationConfirms(spec.text, content)) {
@@ -6305,6 +6331,9 @@ Today's date: ${(/* @__PURE__ */ new Date()).toDateString()}.`;
     return this.enqueue(async () => {
       await this.initMemory();
       this.resetTurn();
+      this.awaitTrivialRedeliver = false;
+      this.parkedRedeliver = [];
+      this.suppressParkedResume = true;
       const res = await this.voice.send(content);
       this.flushHeldReflexTail();
       if (this.silentTurn) await this.ackIfSilent();
@@ -6405,6 +6434,7 @@ Today's date: ${(/* @__PURE__ */ new Date()).toDateString()}.`;
    *  tasks keep running and still fold their result into the transcript — recoverable, just not spoken.
    *  Returns the parked ids (for logging). Does NOT cancel: that's a deliberate reflex/user action. */
   parkInFlightDeliveries() {
+    this.suppressParkedResume = false;
     const parked = [];
     for (const rec of this.tasks.values())
       if (rec.status === "running" && !rec.deliveryParked) {
@@ -6413,6 +6443,22 @@ Today's date: ${(/* @__PURE__ */ new Date()).toDateString()}.`;
       }
     return parked;
   }
+  /** True while there is a parked delivery to potentially resume: either one already settled (queued) or
+   *  one still running that was parked by a barge. */
+  hasParkedDelivery() {
+    return this.parkedRedeliver.length > 0 || [...this.tasks.values()].some((t) => t.status === "running" && t.deliveryParked);
+  }
+  /** Speak any settled-and-queued parked delivery now (trivial-barge resume). Returns false if nothing was
+   *  queued yet (the caller then arms awaitTrivialRedeliver so the task resumes the instant it settles). */
+  redeliverParked() {
+    if (!this.parkedRedeliver.length) return false;
+    const text = this.parkedRedeliver.splice(0).join(" ").trim();
+    if (text) {
+      this.options.host?.notify?.({ kind: "speak_utterance", message: text });
+      this.notify("diag", "parked_redelivered", { chars: text.length });
+    }
+    return true;
+  }
   /** Resolve when all queued voice turns AND all in-flight worker tasks have settled (tests, graceful shutdown). */
   async idle() {
     while (true) {
@@ -6484,7 +6530,9 @@ Today's date: ${(/* @__PURE__ */ new Date()).toDateString()}.`;
 
 ## DELIVER (spoken delivery)
 You 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 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 (recent ? `${brief}
+    return `${nowLine()}.
+
+` + (recent ? `${brief}
 
 ## Recent conversation (for context)
 ${recent}` : brief) + verify + deliverContract;
@@ -6528,7 +6576,10 @@ ${recent}` : brief) + verify + deliverContract;
     };
     const splitter = new SpokenSplitter();
     const speak = (seg) => {
-      if (seg && !this.tasks.get(id)?.deliveryParked) o.host?.notify?.({ kind: "speak_utterance", message: seg });
+      if (!seg) return;
+      const r = this.tasks.get(id);
+      if (r) r.spokenText = (r.spokenText ? r.spokenText + " " : "") + seg;
+      if (!r?.deliveryParked) o.host?.notify?.({ kind: "speak_utterance", message: seg });
     };
     const coalescer = new SentenceCoalescer();
     const feedSpoken = (s) => {
@@ -6751,6 +6802,16 @@ Another agent just implemented the above. Independently check the CURRENT state
     const tail = rec.splitter?.flush();
     if (tail?.spoken && !rec.deliveryParked) this.options.host?.notify?.({ kind: "speak_utterance", message: tail.spoken });
     if (res.text.trim()) this.voice.transcript.push({ role: "assistant", content: res.text });
+    if (rec.deliveryParked && !this.suppressParkedResume) {
+      const gist = (rec.spokenText ?? "").trim() || res.text.trim();
+      if (gist) {
+        if (this.awaitTrivialRedeliver) {
+          this.awaitTrivialRedeliver = false;
+          this.options.host?.notify?.({ kind: "speak_utterance", message: gist });
+          this.notify("diag", "parked_redelivered", { chars: gist.length });
+        } else this.parkedRedeliver.push(gist);
+      }
+    }
     if (!rec.splitter?.spokeAny && res.text.trim() && !rec.deliveryParked)
       this.options.host?.notify?.({ kind: "speak_utterance", message: res.text });
   }