@livx.cc/agentx 0.99.57 → 0.99.58

package/dist/index.d.ts

@@ -889,6 +889,19 @@ declare function reflectOnRun(o: ReflectOptions): Promise<string | null>;
  */
 declare function loadInstructions(fs: IFilesystem, names?: string[]): Promise<string>;
 
+/** Structural subset of ai.libx.js DecideClient.decide — keeps this module provider-agnostic. */
+interface Decider {
+    decide(o: {
+        state: unknown;
+        questions: Record<string, unknown>;
+    }): Promise<{
+        answers: Record<string, {
+            choice: string;
+            probabilities: Record<string, number>;
+        }>;
+    }>;
+}
+
 /**
  * DuplexAgent — voice-optimized three-tier conversational engine, composed on top of `Agent`.
  *
@@ -928,15 +941,24 @@ interface TaskRecord {
     splitter?: SpokenSplitter;
     /** Set when the user barged in / took the floor while this task was in flight: its remaining SPOKEN
      *  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. */
+     *  transcript so the reflex can surface it on request. See parkInFlightDeliveries().
+     *  'barge' = cut by a barge the user's next line has not resolved yet — a resume revives it (its unheard segments
+     *  are parked); 'moved_on' = the user moved on (a steer, a new dispatch) or its outcome went to an integration turn
+     *  (failed / stopped early) — it stays stale for good: nothing it says is spoken or parked, and no later barge or
+     *  "go on" revives it. */
+    deliveryParked?: 'barge' | 'moved_on';
+    /** Accumulated `<spoken>` delivery text (every segment, whether or not it was actually voiced) — what the task
+     *  SAID (TaskStatus). Never replayed: a resume replays only the unheard part (DuplexAgent.parkedRedeliver). */
     spokenText?: string;
     /** The user-turn counter (DuplexAgent.turn) at dispatch time. parkInFlightDeliveries() parks only tasks
      *  from a PRIOR turn (a superseded topic) — never the task the current turn just launched, so a barge on
      *  stale audio (or a substantive redirect) can't collateral-silence the work the user actually wants. */
     createdTurn: number;
+    /** Chars of this delivery voiced so far (spokenBudgetChars); `budgetSpent` once it was cut — a resume goes on unbudgeted. */
+    voicedChars?: number;
+    budgetSpent?: boolean;
+    /** The budget offer spoken in place of the cut rest — folded into the transcript after the written result. */
+    capOffer?: string;
 }
 type WorkerTier = 'act' | 'think';
 declare class DuplexAgentOptions {
@@ -972,6 +994,13 @@ declare class DuplexAgentOptions {
     /** Teach the model to emit inline `[emotion]` tags for Cartesia emotion control. Only set when the
      *  TTS actually speaks them — text-duplex (no TTS) would otherwise print literal tags. */
     emotionTags: boolean;
+    /** Judge a post-barge line while a delivery is parked: resume it now, answer an aside and carry it on (the reflex,
+     *  told what was heard — see asideNote), or drop it (steer/stop). Unset → the conservative `isTrivialBarge` allowlist (resume | steer); a throwing judge
+     *  falls back to it too. */
+    bargeIntent?: (text: string) => Promise<'resume' | 'aside' | 'steer' | 'stop'>;
+    /** Typed-decision model (e.g. ai.libx.js DecideClient → Jev). Judges reflex sentences the leak screen flags as
+     *  SUSPECT (src/voice/leak.ts) — only suspects pay the ~300ms call. Unset → only the strict leak shapes are cut. */
+    decider?: Decider;
     /** Awaited BEFORE a worker spawns — open a per-task checkpoint frame, audit, etc.
      *  (post-spawn would race the worker's first edits). */
     onTaskStart?: (id: string, label: string) => void | Promise<void>;
@@ -980,6 +1009,13 @@ declare class DuplexAgentOptions {
     progressUpdates: boolean;
     /** Min ms between progress re-voices per task. */
     progressIntervalMs: number;
+    /** Spoken budget of ONE task delivery (chars, ~3 short sentences). Past it the rest is parked — cut at a sentence
+     *  boundary, `spokenOffer` spoken instead — so "go on" continues it once (the parked/resume path) and an aside or
+     *  steer handles it like any parked delivery. The worker is also asked for a short spoken summary + one offer (the
+     *  source); this is the backstop. Live 20260924-093945: ~20s and ~70s monologues whose closing choice went unspoken.
+     *  The full result always folds into the transcript. 0 = unbudgeted. */
+    spokenBudgetChars: number;
+    spokenOffer: string;
     /** Relay worker questions (AskUserQuestion + permission asks via parkQuestion) through the VOICE:
      *  the question re-voices as '[task <id> asks] …', the user answers conversationally, and the
      *  voice model resolves it with the AnswerTask tool. Off → host.ask passthrough (text menus). */
@@ -1015,14 +1051,22 @@ declare class DuplexAgent {
      *  (TaskRecord.createdTurn) so parking can tell a prior-topic task from the current turn's fresh one. */
     private turn;
     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). */
+    /** THE parked delivery: every piece the user has NOT heard, in speaking order — the unheard rest a barge cut out of
+     *  the voice queue (parkCutDelivery) followed by each segment a barge-parked task produced since (deliverSegment).
+     *  Nothing already voiced is ever added, so a resume never repeats what was heard. The next line's barge intent
+     *  decides: resume → spoken verbatim, aside → handed to the reflex to carry on after its answer (asideNote) — both
+     *  send the barge-parked tasks live again; steer/stop → cleared, and those tasks
+     *  are moved on from (the full result stays in the transcript, recoverable by asking). `task` = the owner, so a
+     *  task whose outcome goes to an integration turn takes its pieces back (dropParked). */
     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;
+    /** parkedRedeliver length when the last barge parked (parkInFlightDeliveries): the cut it hands over later
+     *  (parkCutDelivery) was voiced BEFORE anything parked since, so it is inserted here. */
+    private bargeMark;
+    /** The last barge cut a REFLEX reply (parkCutDelivery): a "go on" is then the reflex's to answer — it runs a normal
+     *  turn (the host's interruption note continues the reply), and only then does the parked delivery resume. */
+    private reflexCut;
+    /** Recent live task segments → their task id: attributes a cut delivery (parkCutDelivery) to the task that spoke it. */
+    private voicedBy;
     /** 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
@@ -1045,6 +1089,15 @@ declare class DuplexAgent {
     private reflexBuf;
     private reflexForwarded;
     private fabricationCut;
+    private leakCuts;
+    private leakStep;
+    private leakHit;
+    private stepMarks;
+    private leakVerdicts;
+    private judging?;
+    private turnGen;
+    private turnSpoken;
+    private turnBase;
     /** TRUE for the duration of a re-voice turn that is integrating ≥1 NON-CLEAN task (turn-eligibility,
      *  carried out-of-band — NOT derived from any worker/brief string). ANY Act/Think dispatched in such a
      *  turn is stamped followUp:true. This GUARANTEES the dangerous direction is impossible: a genuine
@@ -1082,9 +1135,38 @@ declare class DuplexAgent {
     constructor(options?: Partial<DuplexAgentOptions>);
     /** Resolve memory tools + inject index into voice system prompt (once). */
     private initMemory;
-    /** Flush any held-back trailing fragment (a possible `[task` opener that never completed) once the
-     *  turn's stream is done — so a legit message ending in "[t" isn't silently dropped. */
-    private flushHeldReflexTail;
+    /** Forward what the reflex's spoken-stream gates allow (text_delta → host/TTS; forwarded audio can't be unsent):
+     *  - hold a trailing fragment that could be a `[task` opener split across deltas ("[ta" + "sk"), and an UNCLOSED
+     *    "(" (a stage direction is judged — and dropped — only once its ")" arrives; bounded at 80 chars);
+     *  - the leak gate: whole sentences only, each screened by isLeakSuspect the moment it completes — a strict match
+     *    is cut, any other suspect waits for the decider's verdict (judgeLeak) while the rest queues behind it.
+     *  `final` = the stream is done: release the holds and judge whatever is left as a sentence. Text before a step
+     *  boundary (stepMarks) is complete — no holds, its tail is a sentence. Idempotent; re-run as verdicts land. */
+    private pumpReflex;
+    private forwardReflex;
+    /** Leak verdict for one complete sentence: false = speak, true = cut, undefined = the judge is still out.
+     *  Non-suspects pass free; strict shapes are cut without a call; other suspects go to the decider (if any) —
+     *  one call at a time, cached per turn. A failed/slow judge fails OPEN (speech is never muted on a guess). */
+    private leakVerdict;
+    private static readonly LEAK_JUDGE_TIMEOUT_MS;
+    /** The stream is done: settle every pending verdict and release everything the gates still hold. */
+    private drainReflex;
+    /** Drop any in-flight judge of the current stream (its verdict must not pump a stream that moved on). */
+    private dropJudge;
+    /** Remove a cut analysis leak from this turn's assistant message(s) — left in, it primes the next turn to
+     *  leak again and reads as something we said. Keeps any legit prefix; drops a message left empty. */
+    private scrubLeakFromTranscript;
+    /** A Hold turn is silent BY DESIGN: every reflex text after the Hold is muted (voiceHost drops it), so none of it may
+     *  persist either — the transcript is what the agent SAID. Live 20260923-125143 msg 10: the model's reasoning ("We
+     *  need to respond according to guidelines… So we should hold") was saved as an assistant reply and fed every later
+     *  turn. Strips the text of assistant messages after the Hold call (tool calls stay — they happened); a message left
+     *  empty is removed. */
+    private scrubHeldText;
+    /** Shared turn epilogue (user turn, confirmed speculation, re-voice): release held text, scrub a cut leak,
+     *  then repair dead air — unless the turn was ABORTED: the user took the floor (barge-in / Esc), which is
+     *  not dead air, and a nudge would run on the same aborted signal (live: the "[reminder]" landed in the
+     *  transcript as a user turn with no reply, session 20260923-101910 msg 27). */
+    private endTurn;
     /** Remove complete stage-direction parentheticals from the UNFORWARDED reflex text (STAGE_DIRECTION_RE).
      *  Only the unforwarded region is touched — already-spoken audio can't be unsent, and splicing before
      *  reflexForwarded would corrupt the forward offset. */
@@ -1115,13 +1197,35 @@ declare class DuplexAgent {
      *  hosts/tests key on it. */
     private static readonly FALLBACK_ACKS;
     private static readonly FALLBACK_RETRY;
+    private static readonly FALLBACK_OWN;
     private lastFallback;
     /** One user turn: the voice agent streams the reply (and may Act/Think). Serialized with re-voice turns.
      *  If a speculative reflex call is pending and this content CONFIRMS it (the final matches the
      *  speculated partial), the in-flight call is adopted as THE turn: its buffered output flushes to the
      *  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: MessageContent): Promise<RunResult>;
+     *  speculation first (rolled back silently) and runs a normal turn behind it.
+     *  `opts.id` names the turn; `opts.replaces` names an earlier one this content REPLACES — the voice engine's
+     *  fuller re-finalization of an utterance whose reply had not started ("…previous" → "…previous
+     *  conversation."). The replaced turn is skipped if it has not run yet, else aborted and rolled back out of
+     *  the transcript (kept only if it already dispatched work) — one reply, to the full text. */
+    send(content: MessageContent, opts?: {
+        id?: string;
+        replaces?: string;
+    }): 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;
+    private turnSignal?;
+    private trackTurn;
+    private replaceTurn;
+    private static replacedResult;
+    /** A turn replaced mid-run: mute whatever it still holds, and erase it from the transcript (the replacing turn
+     *  carries the user's full words) — unless it already dispatched work or SPOKE: the task is real, and the user
+     *  heard those words, so both stay visible to the replacing turn. An aborted stream never reaches the transcript,
+     *  so what was spoken is recorded as the replaced turn's reply. */
+    private dropReplacedTurn;
+    private resumeParked;
+    private sendTurn;
     /** Start a HELD speculative reflex turn on a stable partial (VoiceEngine.onSpeculate). Its spoken
      *  output buffers in emitHost; send() later confirms (flush + adopt) or aborts it. The turn holds the
      *  voice mutex until that decision (bounded by a safety timeout), so no other turn can interleave
@@ -1138,18 +1242,45 @@ declare class DuplexAgent {
      *  superseded topic never talks over the new one (the debt-after-jokes regression). Tasks keep running and
      *  still fold their result into the transcript — recoverable, just not spoken. Returns parked ids (logging).
      *  Does NOT cancel. Two callers, two shapes:
-     *   - BARGE (default): the user interrupted AUDIO. Park EVERY running task (including this turn's) — the
-     *     worker they cut off must stop, whatever turn launched it — and re-arm trivial-barge auto-resume so a
-     *     following "go on" can bring the parked delivery back.
-     *   - SUPERSEDE (`priorTurnsOnly`, `reenableResume:false`, from dispatch()): a new dispatch redirected to
-     *     fresh work. Park only PRIOR-turn tasks so parallel siblings dispatched in the SAME turn don't silence
-     *     each other, and keep them suppressed (the user moved on — don't resurface on a stray "go on"). */
-    parkInFlightDeliveries(reenableResume?: boolean, priorTurnsOnly?: boolean): 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. */
+     *   - BARGE (default): the user interrupted AUDIO. Park EVERY live running task (including this turn's) — the
+     *     worker they cut off must stop, whatever turn launched it — as 'barge', so a following "go on" can bring
+     *     it back. A task the user already moved on from stays moved on: a barge never revives it.
+     *   - SUPERSEDE (`priorTurnsOnly`, `barge:false`, from dispatch()): a new dispatch redirected to fresh work.
+     *     Park only PRIOR-turn live tasks so parallel siblings dispatched in the SAME turn don't silence each other,
+     *     as 'moved_on' (don't resurface on a stray "go on"). */
+    parkInFlightDeliveries(barge?: boolean, priorTurnsOnly?: boolean): string[];
+    /** A barge-in cut a worker delivery the VOICE ENGINE was still speaking — the queued utterances it dropped plus the
+     *  unheard rest of the one playing (cli splitCut). It joins the parked delivery AHEAD of whatever parked tasks
+     *  produced since the barge (it was voiced first); the user's next line runs the barge-intent judge — resume it,
+     *  answer an aside and carry it on, or drop it on a steer/stop. `heard` = the cut utterance's part the user DID hear
+     *  (the aside note tells the reflex what was heard vs missed).
+     *  Live 20260923-125143: "Oh, that— that's new." cut an iOS-news delivery and its 6 remaining utterances vanished.
+     *  `reflexCut` = the barge cut a REFLEX reply (the host's cut had a reply): a "go on" then runs the reflex (see send).
+     *  A cut spoken by a task the user moved on from (or whose outcome went to an integration turn) is not parked. */
+    parkCutDelivery(text: string, reflexCut?: boolean, heard?: string): void;
+    /** One spoken segment of a task's delivery — the ONLY path a worker's speech takes (streamed segments, the settle
+     *  tail, the no-spoken fallback). Live → the voice queue; barge-parked → the parked delivery, in order; superseded
+     *  (the user moved on) → nowhere (the result still folds into the transcript at settle). */
+    private deliverSegment;
+    /** Split a delivery segment at the spoken budget (whole sentences; the first sentence always speaks): what to voice
+     *  now, and the rest to park. Marks the budget spent on a cut, so a resumed delivery runs on unbudgeted. */
+    private budgetSplit;
+    /** The cap offer last spoken and the task whose rest it offers — a barge over it is not a delivery to park
+     *  (parkCutDelivery). */
+    private offer;
+    /** The cap offer was the last thing voiced (no delivery or turn has spoken since) — a plain yes accepts it (send). */
+    private offerOpen;
+    /** The task's outcome now belongs to its integration turn (failed / stopped early): take back its parked pieces and
+     *  keep it from being revived — a "go on" must not replay raw segments of a result the reflex is about to explain. */
+    private dropParked;
+    /** True while there is a parked delivery the next line may resume: unheard text already parked, or a barge-parked
+     *  task still running (one the user moved on from does not count). */
     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). */
+    /** The note for an aside over a parked delivery: the same reply-interruption note a cut reflex reply gets
+     *  (interruptionNote), over the delivery as it was being said — the cut utterance's heard part, then every unheard
+     *  piece. Nothing parked yet (the task is still working) → its result simply follows the answer. */
+    private asideNote;
+    /** Speak the parked delivery now (resume), in order, and clear it. */
     private redeliverParked;
     /** Resolve when all queued voice turns AND all in-flight worker tasks have settled (tests, graceful shutdown). */
     idle(): Promise<void>;
@@ -1170,6 +1301,8 @@ declare class DuplexAgent {
      *  Act briefs get a self-verify footer — the worker's report is trusted without review, so it
      *  must check its own work before reporting (nearly free under prompt caching; measured honest:
      *  it does NOT fix one-shot logic bugs — see mind/10). Think tasks are pure reasoning — no footer. */
+    /** Static text snapshot of the last `turns` user/assistant messages (`role: text` lines). */
+    recentExcerpt(turns?: number): string;
     private buildBrief;
     /** Spawn a detached worker for task `id`; its settlement notifies + enqueues the re-voice turn. */
     private spawnWorker;
@@ -1209,11 +1342,11 @@ declare class DuplexAgent {
     private integrationPrompt;
     private onWorkerSettled;
     private onWorkerFailed;
-    /** A delivery the user has SUPERSEDED — parked AND moved on (suppressParkedResume, set by a redirect) —
+    /** A delivery the user has SUPERSEDED — moved on from (deliveryParked 'moved_on', set by a redirect) —
      *  must not hijack the voice when it settles late (partial or failed): that would talk over the new topic
      *  and, worse, auto-escalate work the user already abandoned. Fold a recoverable note into the transcript
      *  instead (the reflex can surface it if asked) and report true so the caller skips queueRevoice. A merely
-     *  barge-parked task (suppressParkedResume false — a "go on" may still resume it) is NOT superseded: it
+     *  barge-parked task ('barge' — a "go on" may still resume it) is NOT superseded: it
      *  keeps the normal surfacing path so a failure the user still cares about is not swallowed. */
     private foldIfSuperseded;
     private failTask;
@@ -1226,6 +1359,11 @@ declare class DuplexAgent {
      *  `followUp` marks an automatic escalation/re-delegation (set by the integration turn) so the new
      *  task's own integration turn won't escalate again — capping auto-follow-ups to one hop. */
     dispatch(brief: string, tier?: WorkerTier, label?: string, followUp?: boolean): Promise<string>;
+    /** Tool result for a dispatch. The task is ALREADY RUNNING — live, the terse "Acknowledge briefly" drew
+     *  "Did you want me to look up today's news?" right after dispatching exactly that (session 20260923-101910
+     *  msg 18). Also truthful about delivery: a clean result is spoken by the worker itself and lands in
+     *  context (TaskStatus returns it); only failures come back as a [task … failed] event. */
+    private dispatchResult;
     private actTool;
     private thinkTool;
     private taskStatusTool;