@livx.cc/agentx 0.99.14 → 0.99.15

package/dist/index.d.ts

@@ -6,6 +6,8 @@ export { CommandExecutor, FileMetadata, IFilesystem, IndexedDbFilesystem, MemFil
 import { BodDB } from '@bod.ee/db';
 import { A as AgentTool, C as ChatLike, a as ChatOptions, b as ChatResponse, h as ToolCall, H as HostBridge, U as UserQuestion, e as MessageContent } from './tools-DKf3hN4M.js';
 export { c as ContentPart, d as HostEvent, M as Message, R as Role, S as SandboxJobRegistry, f as StreamChunk, T as TodoItem, g as Tool, i as ToolContext, j as bashTool, k as contentText, l as defaultTools, m as editTool, n as exitSessionTool, o as imagePart, p as makeContext, q as makeJobTools, r as readTool, t as toWireTools, s as todoWriteTool, u as toolRegistry, v as toolsByName } from './tools-DKf3hN4M.js';
+import { SpokenSplitter } from '@bod.ee/voice';
+export { AudioSink, AudioSource, AuthProvider, CartesiaTTS, CartesiaTTSOptions, STT_SAMPLE_RATE, SonioxSTT, SonioxSTTOptions, SttLike, TTS_SAMPLE_RATE, TtsLike, VoiceEngine, VoiceEngineOptions, VoiceState, resolveAuth } from '@bod.ee/voice';
 export { M as McpCall, a as McpImage, b as McpRoute, c as McpRouteResolver, d as McpToolResult, e as McpToolSearchOptions, f as McpToolSpec, g as MountedMcpLike, h as buildMcpCatalog, m as makeLazyMcpToolSearch, i as makeMcpToolSearch, j as makeMcpToolSearchFromMounted, k as mcpToolToAgentTool, l as mcpToolsToAgentTools } from './mcp-DopVRDLx.js';
 import * as libx_js_src_modules_log from 'libx.js/src/modules/log';
 export { log } from 'libx.js/src/modules/log';
@@ -828,24 +830,6 @@ declare function reflectOnRun(o: ReflectOptions): Promise<string | null>;
  */
 declare function loadInstructions(fs: IFilesystem, names?: string[]): Promise<string>;
 
-declare class SpokenSplitter {
-    private buf;
-    private inSpoken;
-    /** True once any spoken char has ever been emitted (drives the no-spoken fallback). */
-    spokeAny: boolean;
-    /** Feed a delta; returns the spoken/detail spans completed by this chunk (either may be ''). */
-    feed(delta: string): {
-        spoken: string;
-        detail: string;
-    };
-    /** Drain any buffered partial. A trailing `<…` that never completed a tag is emitted as detail. */
-    flush(): {
-        spoken: string;
-        detail: string;
-    };
-    private drain;
-}
-
 /**
  * DuplexAgent — voice-optimized three-tier conversational engine, composed on top of `Agent`.
  *
@@ -1240,536 +1224,6 @@ declare function makeTaskBatchTool(opts: TaskToolOptions): AgentTool;
 /** Component-scoped logger (libx.js). debug/verbose gated via DEBUG env/localStorage. */
 declare const forComponent: (name: string) => libx_js_src_modules_log.ComponentLogger;
 
-/**
- * Portable voice I/O contracts — zero platform imports. The engine, STT and TTS clients in this
- * directory run anywhere with a `WebSocket` global (Bun, Node, browser); platform backends
- * (mic capture, audio playback) plug in through these seams.
- */
-type VoiceState = 'idle' | 'listening' | 'thinking' | 'speaking';
-/** STT input sample format — sources MUST deliver this (downsample/convert in the adapter). */
-declare const STT_SAMPLE_RATE = 16000;
-/** Playback format the TTS requests and sinks must play. */
-declare const TTS_SAMPLE_RATE = 44100;
-/** A microphone (or any PCM) source. Emits s16le mono 16kHz chunks.
- *  Node: mic-aec/ffmpeg child process. Web: getUserMedia({ echoCancellation: true }) + worklet. */
-interface AudioSource {
-    /** `aec` = the source is echo-cancelled (assistant's own TTS never reaches the chunks) —
-     *  selects the engine's trivial barge-in path vs the heuristic echo tier. */
-    readonly aec: boolean;
-    start(onChunk: (pcm: Uint8Array) => void): void | Promise<void>;
-    stop(): void;
-    /** Unrecoverable source failure (e.g. mic permission denied → engine produces no audio AND, in the
-     *  duplex AEC engine, no playback). The host should tear voice down rather than spin reconnects. */
-    onFatal?: (message: string) => void;
-}
-/** An audio playback sink for s16le mono 44.1kHz PCM.
- *  Node: per-turn ffplay. Web: AudioContext/worklet ring buffer. */
-interface AudioSink {
-    /** start a new spoken turn (may recycle or recreate the underlying player) */
-    markTurn(): void;
-    write(pcm: Uint8Array): void;
-    /** estimated ms until queued audio finishes playing */
-    drainMs(): number;
-    /** ms of audio actually played this turn */
-    playedMs(): number;
-    /** stop playback NOW (barge-in primitive) */
-    kill(): void;
-    /** optional exact-sample pause/resume — enables the overlap trail-off tier (web: AudioContext
-     *  suspend/resume; CLI AEC helper: control frames). Sinks without it degrade to interrupt-only
-     *  turn-taking. Nothing is lost across a pause; playedMs/drainMs must exclude paused time. */
-    pause?(): void;
-    resume?(): void;
-}
-/** Static key (server/CLI) or an async getter (browser: fetch a short-lived token from YOUR
- *  backend). Getters are invoked on EVERY (re)connect — temp tokens expire, so a reconnect
- *  must re-mint, never reuse the boot-time token. */
-type AuthProvider = string | (() => string | Promise<string>);
-declare function resolveAuth(auth: AuthProvider): Promise<string>;
-
-/** Injectable time source — ALL engine timing (merge windows, barge grace, overlap resume, drain
- *  settles) routes through it. Defaults to real timers; the deterministic bench swaps a virtual
- *  clock so timing scenarios run instantly and exactly. */
-interface EngineClock {
-    now(): number;
-    setTimeout(fn: () => void, ms: number): unknown;
-    clearTimeout(handle: unknown): void;
-}
-/** One structured diagnostic event (fire-and-forget, never affects behavior). `t` = engine clock ms.
- *  Emitted at every DECISION point; kinds + fields are the per-session forensic record
- *  (CLI: `<session>.voice.jsonl`; lab: `<session>.timeline.jsonl`). See mind/11-voice.md §Diagnostics. */
-interface DiagEvent {
-    t: number;
-    kind: string;
-    [k: string]: unknown;
-}
-/** Structural contracts (satisfied by SonioxSTT/CartesiaTTS or test fakes). */
-interface SttLike {
-    usingAec: boolean;
-    onPartial: (text: string) => void;
-    onUtterance: (text: string, endpointAt: number) => void;
-    onLevel: (rms: number) => void;
-    /** Optional: unrecoverable capture failure (e.g. mic produced no audio) — host tears voice down. */
-    onFatal?: (message: string) => void;
-    start(): Promise<void> | void;
-    reset(): void;
-    stop(): void;
-}
-interface TtsLike {
-    onAudio: (chunk: Uint8Array) => void;
-    onDone: () => void;
-    /** Optional word-timestamp seam for karaoke reveal (revealMode==='word'). `start[i]` = seconds
-     *  from turn-audio start. Set `wantTimestamps` to request them from the provider. */
-    onTimestamps?: (words: string[], start: number[]) => void;
-    wantTimestamps?: boolean;
-    connect(): Promise<void> | void;
-    /** Optional: prime the synthesis pipeline right after connect (throwaway context, audio discarded)
-     *  so the FIRST real turn doesn't pay the provider's cold-synthesis spin-up. */
-    warmup?(): void;
-    newContext(): string;
-    speak(text: string, cont: boolean): void;
-    end(): void;
-    cancel(): void;
-    close(): void;
-}
-declare class VoiceEngineOptions {
-    stt: SttLike;
-    tts: TtsLike;
-    player: AudioSink;
-    /** a final utterance arrived (endpoint) — host dispatches it as a turn */
-    onUtterance: (text: string) => void;
-    /** live partial transcript while listening (host renders the 🎤 line) */
-    onPartial: (text: string) => void;
-    onState: (s: VoiceState) => void;
-    /** user spoke/acted over playback — host aborts the in-flight turn (called AFTER audio is killed).
-     *  phase: 'speaking' = cut mid-speech (real interruption); 'drain' = in the final audio tail
-     *  (normal turn-taking — hosts shouldn't alarm). */
-    onBargeIn: (phase: 'speaking' | 'drain') => void;
-    /** spoken micro-ack on utterance endpoint (masks LLM TTFT); '' disables */
-    ackPhrase: string;
-    /** ADAPTIVE micro-ack: on an utterance-dispatched turn, speak a short varied ack ONLY if no reflex
-     *  delta has arrived after this many ms (masks a slow TTFT without acking every turn — a fixed
-     *  per-turn ack was rejected as robotic). First delta / interrupt / hold cancels it. 0 = off. */
-    adaptiveAckMs: number;
-    /** the adaptive ack actually fired (host can mark the turn as spoken — e.g. suppress dead-air repair) */
-    onAdaptiveAck: () => void;
-    /** Endpoint merge window (ms): hold an endpointed utterance briefly — if speech resumes (spelled
-     *  letters, mid-thought pauses), the next utterance MERGES instead of dispatching a truncated one
-     *  ("E-L-Y." / "A."). Costs this much latency per turn; 0 disables. */
-    utteranceMergeMs: number;
-    /** Extended merge window (ms) for utterances that look incomplete (trailing conjunction/filler).
-     *  Gives the user time to finish their thought without triggering a model call. */
-    incompleteMergeMs: number;
-    /** Grace window (ms) after an utterance dispatches, during which the user's own trailing audio cannot
-     *  barge the reply it requested. Soniox keeps finalizing partials past <end>; without this they read
-     *  as a barge and abort the fresh turn (live: mid-sentence self-interruption + steps=1→steps=0 double
-     *  abort). Short enough that a genuine immediate barge ("no wait—") still lands right after. */
-    bargeGraceMs: number;
-    /** Barge-in (talk over the assistant to interrupt). true = full-duplex (needs echo cancellation, or
-     *  the assistant's own TTS bleeds back and self-interrupts). false = HALF-DUPLEX: the engine is deaf
-     *  while audible (speaking + drain tail), so echo can never become a phantom turn — the right mode
-     *  when there's no AEC (e.g. the non-VPIO mic fallback) and no headphones. Cost: can't interrupt. */
-    bargeIn: boolean;
-    /** Filler phrase spoken when holding for an incomplete utterance ('' disables). */
-    holdFiller: string;
-    /** Called when the engine holds an incomplete utterance (host can render a visual cue). */
-    onHold: () => void;
-    /** heuristic (non-AEC) energy barge-in tuning */
-    bargeRmsMult: number;
-    bargeRmsFloor: number;
-    /** Overlap turn-taking (AEC tier, needs player.pause/resume) — human phone-call model, driven by
-     *  the STT ITSELF (a trained speech classifier) instead of energy thresholds (energy could not
-     *  separate residue bursts from speech in every room — hiccup whack-a-mole): a GENUINE partial
-     *  (novel words dominate — echo of our own reply is inert) while speaking → PAUSE (exact-sample
-     *  hold); partial grows into dominant-novel ≥2 words → cede (interrupt; the LLM re-enters); partial
-     *  stalls/endpoints without ceding (backchannel by DURATION, not vocabulary) → resume + drop. false disables. */
-    overlapPause: boolean;
-    /** no new partial activity for this long while paused → resume, drop the interjection */
-    overlapResumeMs: number;
-    /** A genuine barge over a LONG reply is defeated by the dominant-novel gate: Meet echoes our own
-     *  speech back, so the partial is mostly our words + a few of hers → never "dominant novel" → it
-     *  resumes (replaying old audio — the audible "completes the buffer" blip) instead of ceding.
-     *  Mechanism-based discriminator: a re-PAUSE this soon after a resume = a persistent human, not an
-     *  echo blip (which pauses once and stalls). Cede on the re-pause regardless of the novel gate. */
-    overlapRepauseCedeMs: number;
-    /** Speculative ENERGY pre-pause while speaking (AEC tier): two residue gate-passes within 350ms →
-     *  pause ~300ms before the STT tokens land. But energy CANNOT separate residue bursts from speech
-     *  (the documented whack-a-mole) — so a residue spike during loud playback false-pauses with NO user
-     *  speech at all, an audible hiccup. Default OFF: the genuine-gated STT partial is the
-     *  mechanism-correct pause trigger; enable only if barge-in onset feels sluggish in a clean-AEC room. */
-    overlapEnergyHold: boolean;
-    /** SPECULATIVE REFLEX START (the root TTFT fix): a partial transcript that has stopped changing for
-     *  this many ms AND carries ≥ speculativeMinWords is "stable" — `onSpeculate` fires so the host can
-     *  start the reflex EARLY, ~endpoint+merge (500-850ms) before the final would dispatch. The
-     *  speculative call's output is HELD by the host (nothing reaches TTS) until the endpointed final
-     *  confirms it (see speculationConfirms). At most one speculation per turn-in-progress. 0 = off. */
-    speculativeMs: number;
-    /** Minimum word count for a partial to qualify as a speculation trigger. */
-    speculativeMinWords: number;
-    /** A stable partial (speculativeMs) — the host starts a HELD speculative reflex call. */
-    onSpeculate: (text: string) => void;
-    /** AGENT-SIDE BACKCHANNELING (rule-based v1): while LISTENING to a long multi-clause user turn, a
-     *  partial that reaches a clause boundary (trailing [,.;!?] or conjunction/filler) and then stays
-     *  UNCHANGED for this many ms (a micro-pause — before the silence endpoint fires) triggers a short
-     *  quiet TTS blip ("Mm-hm.") on a throwaway context. ZERO floor-claim: no state change, no timers
-     *  touched, no turn context — audio passes a narrow gate bypass and a real turn supersedes it via
-     *  context rotation. Latin-predominant partials only (Hebrew/mixed text never misfires — the
-     *  boundary/conjunction heuristics are English-tuned, so non-Latin turns simply get no blips).
-     *  0 = off (default). ~200-300 recommended: live, Soniox's SEMANTIC endpoint (<end>) lands within
-     *  ~300-400ms of a clause pause — a longer stability window loses the race and never fires. */
-    backchannelMs: number;
-    /** Min gap between blips (rate limit); additionally max 2 blips per user turn-in-progress. */
-    backchannelMinGapMs: number;
-    /** Only multi-clause turns: the partial must carry at least this many words before a blip. */
-    backchannelMinWords: number;
-    /** A backchannel blip was spoken (host renders a timeline event; the blip is NOT a reply). */
-    onBackchannel: (phrase: string) => void;
-    /** The partial outgrew the speculated text (user kept talking) — the host aborts the speculation
-     *  quietly (the endpointed final will also refuse to confirm; this just stops the billing earlier). */
-    onSpeculateAbort: () => void;
-    /** Map inline `[emotion]` tags (emitted by the model, prompt-taught) into Cartesia inline emotion
-     *  tags in the spoken transcript (sonic-3 stitches the prosody). false = strip them silently. */
-    emotions: boolean;
-    /** Show the `[emotion]` tags in the on-screen echo (debug). false = hide (spoken-only). */
-    showEmotions: boolean;
-    /**
-     * Progressive text reveal — the "karaoke" capability, opt-in.
-     *   'off'   — no reveal events (CLI default; the host renders text however it likes).
-     *   'delta' — emit `onReveal(fullText)` as each spoken delta lands (near-free; text grows
-     *             in step with the model stream).
-     *   'word'  — reveal word-by-word synced to the TTS playback CLOCK (true karaoke). Requires a
-     *             timestamp-emitting TTS (CartesiaTTS.wantTimestamps) driven over `AudioSink.playedMs`.
-     */
-    revealMode: 'off' | 'delta' | 'word';
-    /** Called with the cumulative revealed text for the current assistant turn (see `revealMode`).
-     *  Reset to '' at the start of each spoken turn. */
-    onReveal: (revealed: string) => void;
-    /** Time source for every engine timer/timestamp. Default: real time (identical behavior). */
-    clock: EngineClock;
-    /** Structured diagnostic event at every decision point (state transitions, dispatch/drop paths,
-     *  barge-in, overlap pause/resume, acks, speculation, backchannels, echo swallows). Fire-and-forget:
-     *  a throwing handler is caught once and diagnostics disable — engine behavior is never affected. */
-    onDiag: (ev: DiagEvent) => void;
-}
-declare class VoiceEngine {
-    options: VoiceEngineOptions;
-    state: VoiceState;
-    protected stt: SttLike;
-    protected tts: TtsLike;
-    protected player: AudioSink;
-    private speaking;
-    private ctxOpen;
-    private interrupted;
-    private spokeDeltas;
-    private revealText;
-    private wordStarts;
-    private revealedN;
-    private revealPoll;
-    private clock;
-    private drainTimer;
-    private echoWords;
-    private prevReply;
-    private reply;
-    private echoUntil;
-    private baseline;
-    private hot;
-    private suspectUntil;
-    private ackAt;
-    private lastAck;
-    private ackTimer;
-    private bargeGraceUntil;
-    private pendingUtt;
-    private mergePath;
-    private lastGraceDiag;
-    private pendingTimer;
-    private lastDispatchFlat;
-    private lastDispatchWords;
-    private lastDispatchAt;
-    private repliedSinceDispatch;
-    private static readonly DUP_FINAL_MS;
-    private lastInterrupted;
-    private pausedAt;
-    private lastResumeAt;
-    private lastOverlapPartial;
-    private resumeTimer;
-    private turnStartAt;
-    private specPartial;
-    private specTimer;
-    private specText;
-    private specSpent;
-    private bcPartial;
-    private bcTimer;
-    private bcCount;
-    private bcActive;
-    private bcActiveTimer;
-    private lastBcAt;
-    private lastBcPhrase;
-    private recentBc;
-    private uttQueue;
-    private emo;
-    constructor(options?: Partial<VoiceEngineOptions>);
-    start(): Promise<void>;
-    get usingAec(): boolean;
-    /** Flip barge-in at runtime (e.g. the mic fell back to non-VPIO → go half-duplex so echo can't leak). */
-    setBargeIn(on: boolean): void;
-    /** Show/hide the `[emotion]` debug tags in the echo (next turn's stream picks it up). */
-    setShowEmotions(on: boolean): void;
-    /** Diagnostics tap (options.onDiag). Fire-and-forget: a throwing handler disables the tap once —
-     *  it can NEVER perturb engine behavior. Protected so VoiceIO can route provider events through it. */
-    private diagOn;
-    protected diag(kind: string, fields?: Record<string, unknown>): void;
-    private idleWaiters;
-    private setState;
-    /** Resolve when the engine is no longer speaking (immediate if already idle). */
-    awaitIdle(): Promise<void>;
-    /** open a spoken turn (idempotent — safe from both onUtterance and first-delta paths).
-     *  `ack` speaks the configured micro-ack as the context opener (utterance path only —
-     *  masks LLM TTFT; re-voice turns begun by their first delta skip it). */
-    beginSpeech(ack?: boolean): void;
-    /** Feed a spoken delta. Returns the on-screen echo text (emotion tags shown/hidden per config) so the
-     *  host renders the SAME stream that was parsed for TTS — no second, state-doubling parse. */
-    speakDelta(text: string): string;
-    /** Karaoke reveal poll: reveal the display-word prefix up to the count of spoken words whose
-     *  Cartesia start time has been reached on the playback clock (`AudioSink.playedMs`, which excludes
-     *  paused time). Poll-driven (not AudioContext timers) so it's portable across CLI/browser sinks and
-     *  deterministic under the virtual clock. */
-    private startWordReveal;
-    /** Stop the poll. `finalFlush` reveals the whole line once audio has finished, so a timing
-     *  undershoot never leaves the tail unrevealed (skipped after a barge-in — the truncated prefix
-     *  is what was actually spoken). */
-    private stopWordReveal;
-    /** close the spoken turn (idempotent); stays audible until ALL audio arrived AND playback drains */
-    endSpeech(): void;
-    /** text of the reply cut by the last barge-in — consumed by the host to tell the model what
-     *  the user did NOT hear. Cleared on read. */
-    takeInterruptedReply(): {
-        full: string;
-        heard: string;
-    } | null;
-    /** Speak a short filler phrase without starting a model turn (stays in listening mode after). */
-    speakFiller(text: string): void;
-    /** Enqueue a COMPLETE worker utterance (already-split spoken text) onto the central speech queue.
-     *  If nothing is currently speaking it plays immediately; otherwise it queues and plays after the
-     *  current utterance fully ends (settle → pumpQueue) — never spliced into an open reflex utterance. */
-    enqueueUtterance(text: string): void;
-    /** Play the next queued worker utterance as its own one-shot turn (begin → delta → end). Drives the
-     *  next one from the settle completion (endSpeech), so utterances serialize without overlap. */
-    private pumpQueue;
-    /** Short varied adaptive acks (adaptiveAckMs) — two shape pools picked by the dispatched
-     *  utterance (question → thinking-ish, otherwise neutral/on-it), with anti-repetition (never one
-     *  of the last 4 used). A 3-phrase round-robin sounded synthetic live ("started with 'hmm' too
-     *  many times"). All phrases are sub-second and semantically safe for their shape.
-     *  No 'Okay.': a genuine user "Okay." within the 6s squash window would be swallowed as ack echo. */
-    static readonly ACKS_NEUTRAL: string[];
-    static readonly ACKS_QUESTION: string[];
-    private recentAcks;
-    private pickAck;
-    private lastDispatchWasQuestion;
-    private clearAckTimer;
-    /** Cancel a pending adaptive ack without touching the turn — hosts call this when the turn turns out
-     *  to be a Hold (intentionally silent; an ack would read as the start of an answer). */
-    cancelPendingAck(): void;
-    /** barge-in: stop audio NOW, cancel generation, reset for the user's utterance */
-    interrupt(): void;
-    stop(): void;
-    private words;
-    private novelWords;
-    private echoActive;
-    /** Genuine user speech vs our own bleed (AEC tier): novel words must DOMINATE, not merely exist.
-     *  Degraded AEC + an STT mis-hearing manufactures a single novel word out of pure echo (a name or
-     *  rare word in our own reply comes back transcribed slightly differently — 1 novel / N words).
-     *  A real interjection is mostly novel ("stop", "wait what") — short utterances pass on ratio,
-     *  longer ones on count. */
-    private genuine;
-    private handlePartial;
-    /** Speculative-reflex trigger (listening side only — the speaking branch returns before this): a
-     *  partial that hasn't CHANGED for speculativeMs and has ≥ speculativeMinWords is stable → fire
-     *  onSpeculate once. If the user then keeps talking well past the speculated text, onSpeculateAbort
-     *  tells the host to kill the held call early. The confirm/abort DECISION belongs to the host at
-     *  dispatch time (speculationConfirms against the real final) — flushUtterance only resets the
-     *  trigger for the next turn. Merge windows are untouched: no speculation while an endpointed
-     *  utterance is pending (the final would be the MERGED text, which the partial alone never matches). */
-    private trackSpeculation;
-    /** Backchannel blip pool — short, quiet, semantically inert. Chosen to be transcript-safe: if
-     *  imperfect AEC lets a blip reach Soniox MID-user-speech it lands inside their partial stream, so
-     *  every phrase is a word whose accidental presence barely hurts a transcript, and flushUtterance
-     *  strips an isolated echo of the exact phrase at a clause edge within 2s (stripBackchannelEcho).
-     *  'Okay.'/'Right.' are fine here (unlike ACKS_NEUTRAL's no-Okay rule): a standalone user "Okay."
-     *  right after OUR blip is overwhelmingly the blip's echo — the squash guard eating it is the point. */
-    static readonly BACKCHANNELS: string[];
-    /** Backchannel trigger (listening side only — the speaking branch returns before this): a partial
-     *  that reached a clause boundary and then stayed UNCHANGED for backchannelMs (a micro-pause, still
-     *  BEFORE the silence endpoint) fires a blip — if long enough (≥ backchannelMinWords), predominantly
-     *  Latin, rate-limited (backchannelMinGapMs + max 2/turn), and no endpointed text is pending.
-     *  Touches nothing else: merge/endpoint/speculation timers and turn state are never affected. */
-    private trackBackchannel;
-    /** Speak one blip on a THROWAWAY TTS context. Zero floor-claim: no `speaking`, no state change, no
-     *  markTurn, no merge/endpoint/barge timers, no repliedSinceDispatch, no utterance queue. Echo
-     *  pre-seeding happens BEFORE any audio exists: the blip's words join echoWords (its mic echo is
-     *  never "novel"), the ack-squash guard is armed with the exact phrase (a standalone echo final is
-     *  swallowed), and the echo window extends so echo-shaped finals stay gated. */
-    private fireBackchannel;
-    /** A real turn (or shutdown) takes over mid-blip: close the audio bypass + stability timer. */
-    private bcSupersede;
-    /** Strip the mic echo of the LAST blip from a dispatching final, conservatively: only the exact
-     *  phrase, as an isolated token at a clause edge (start/end of utterance or beside punctuation),
-     *  within 2s of the blip. "Right"/"okay" as genuine mid-sentence content words are never touched. */
-    private stripBackchannelEcho;
-    /** Merge a resumed utterance into the pending one, deduping any word-overlap. Soniox re-finalizes
-     *  overlapping audio when the silence-timer and the semantic `<end>` both endpoint a growing
-     *  utterance (or after a reconnect): the next "utterance" repeats the tail of the previous one, and
-     *  a naive `${prev} ${next}` produced the live duplication ("Um, I want to check if Um, I want to
-     *  check if…"). Find the longest suffix of `prev`'s words that prefixes `next` and drop it. */
-    private mergeUtterance;
-    private static normWord;
-    /** Soniox re-finalization of an ALREADY-DISPATCHED utterance, arriving PAST the merge window:
-     *  the new final is a strict word-prefix superset of the last dispatch (the last dispatched word
-     *  may be a char-prefix of the corresponding new word — a mid-word endpoint), and it lands within
-     *  DUP_FINAL_MS of the dispatch. Live: "Hi, please tell me a very short" dispatched, then the full
-     *  "…very short joke." re-finalized ~900ms later → dispatched TWICE (two replies, the second to a
-     *  question already being answered).
-     *  DESIGN — HYBRID at the caller (flushUtterance): this shape check identifies a re-finalization
-     *  (a human physically cannot re-speak a ≥3-word sentence plus extra words within 3s of the
-     *  previous dispatch; a genuine continuation arrives as NEW words, never as a superset), and
-     *  repliedSinceDispatch then picks the action:
-     *  • reply already streaming (the live trace: TTFT ~500ms < the ~900ms re-final) → DROP. True
-     *    "supersede" would mean aborting audible speech mid-word to re-answer nearly the same text —
-     *    worse UX — and needs turn-abort plumbing in every host (the lab bridge has none;
-     *    DuplexAgent.send is a non-cancelable queue, so a second send just stacks a SECOND full reply).
-     *    Soniox's premature endpoint fires at a prosodic boundary, so the loss is trailing word(s).
-     *  • NO reply yet → DISPATCH the fuller text. Live-verified necessity: the reflex Holds on the
-     *    truncated fragment ("Hi, please tell me a very short" → Hold), and dropping the re-final then
-     *    starves the conversation entirely — the fuller final IS the completion the Hold is waiting
-     *    for. A slow-but-answering reflex in this window degrades to today's two-reply behavior (rare
-     *    race), never worse. Fillers ("mhm") deliberately don't count as replies — see speakFiller. */
-    private refinalizes;
-    private static readonly TRAIL_RE;
-    /** The utterance sounds like the user paused mid-thought (trailing conjunction/filler/comma). */
-    private looksIncomplete;
-    private handleUtterance;
-    private flushUtterance;
-    private get overlapCapable();
-    private armResume;
-    private resetOverlap;
-    /** energy two-stage barge-in (heuristic tier only): spike over echo baseline → pause + confirm via STT */
-    private gatePassTimes;
-    private handleLevel;
-}
-
-declare class SonioxSTTOptions {
-    auth: AuthProvider;
-    source: AudioSource;
-    model: string;
-    languageHints: string[];
-    /** Client-side endpoint: finalized text + no new tokens for this long = utterance (don't wait for
-     *  Soniox's semantic <end>, which adds 0.5-1.5s — the difference between ping-pong and lag). */
-    silenceEndpointMs: number;
-    /** No-audio watchdog: if the mic source stops delivering chunks for this long, capture is dead →
-     *  fire onFatal + stop (else Soniox idle-timeouts and reconnect-loops forever). 0 = disable. */
-    noAudioTimeoutMs: number;
-}
-declare class SonioxSTT {
-    options: SonioxSTTOptions;
-    private ws;
-    private stopped;
-    private sourceStarted;
-    onPartial: (text: string) => void;
-    onUtterance: (text: string, endpointAt: number) => void;
-    /** mic energy (RMS) per chunk — drives the energy-based heuristic barge-in tier */
-    onLevel: (rms: number) => void;
-    /** Unrecoverable: the mic source stopped delivering audio (Soniox starves → idle-timeout reconnect
-     *  loop). The host tears voice down instead of spinning forever. */
-    onFatal: (message: string) => void;
-    /** Diagnostic tap (provider errors, ws reconnects, no-audio watchdog). Fire-and-forget: a throwing
-     *  handler disables itself — never affects transcription. Wired by VoiceIO / the lab bridge. */
-    onDiag: (ev: {
-        t: number;
-        kind: string;
-        [k: string]: unknown;
-    }) => void;
-    private diagOn;
-    private diag;
-    private lastChunkAt;
-    private startedChunksAt;
-    private noAudioTimer;
-    private finalText;
-    private partialText;
-    private lastChangeAt;
-    private lastCombined;
-    private endpointTimer;
-    private firstTokenAt;
-    constructor(options?: Partial<SonioxSTTOptions>);
-    get usingAec(): boolean;
-    private connectWs;
-    start(): Promise<void>;
-    private handle;
-    reset(): void;
-    stop(): void;
-}
-
-declare class CartesiaTTSOptions {
-    auth: AuthProvider;
-    voiceId: string;
-    model: string;
-    /** 'apiKey' (server/CLI) → `api_key=` URL param; 'token' (browser, BE-minted) → `access_token=`. */
-    authMode: 'apiKey' | 'token';
-}
-declare class CartesiaTTS {
-    options: CartesiaTTSOptions;
-    private ws;
-    private ctxSeq;
-    ctxId: string;
-    onAudio: (chunk: Uint8Array) => void;
-    onDone: () => void;
-    /** Word-level timestamps for karaoke reveal: `start[i]` = seconds from turn-audio start (absolute
-     *  across continuation chunks). Fired only when a consumer opts into reveal (see `wantTimestamps`). */
-    onTimestamps: (words: string[], start: number[]) => void;
-    /** Request `add_timestamps` from Cartesia. Off by default (saves bandwidth) — the engine sets it
-     *  when revealMode==='word'. */
-    wantTimestamps: boolean;
-    /** Diagnostic tap (provider errors, circuit-breaker open/close, ws reconnects). Fire-and-forget:
-     *  a throwing handler disables itself — never affects synthesis. Wired by VoiceIO / the lab bridge. */
-    onDiag: (ev: {
-        t: number;
-        kind: string;
-        [k: string]: unknown;
-    }) => void;
-    private diagOn;
-    private diag;
-    firstAudioAt: number;
-    /** Circuit breaker: consecutive error count + down flag. */
-    private consecutiveErrors;
-    private consecutiveOk;
-    private down;
-    private downAt;
-    private probeTimer;
-    private static readonly CB_THRESHOLD;
-    private static readonly CB_RECOVER_OK;
-    private static readonly CB_PROBE_MS;
-    constructor(options?: Partial<CartesiaTTSOptions>);
-    private closed;
-    private connecting;
-    connect(): Promise<void>;
-    private doConnect;
-    /** Close the breaker only after CB_RECOVER_OK consecutive good frames, so a single straggler chunk
-     *  after a 503 burst doesn't flap open→recover in <1s. A sub-2s down-window is a transient blip → debug. */
-    private markRecovered;
-    /** Ensure the WS is open before sending — reconnects if idle-closed. */
-    private ensureConnected;
-    /** Prime the synthesis pipeline on a throwaway context right after connect: the FIRST synthesis on
-     *  a fresh WS pays Cartesia's cold spin-up (~1s+ live) — absorb it at mic-on instead of turn one.
-     *  The returned audio is discarded (engine drops onAudio while not speaking; once a real turn calls
-     *  newContext() any stragglers are stale-context-filtered). Respects the circuit breaker. */
-    warmup(): void;
-    newContext(): string;
-    private frame;
-    speak(text: string, cont: boolean): void;
-    end(): void;
-    cancel(): void;
-    private startProbe;
-    private stopProbe;
-    close(): void;
-}
-
 declare function validateWorktreeSlug(slug: string): void;
 declare function worktreeBranchName(slug: string): string;
 interface WorktreeInfo {
@@ -1801,4 +1255,4 @@ declare function exitWorktree(): {
     reason?: string;
 } | null;
 
-export { Agent, type AgentDef, AgentOptions, AgentTool, type AskOptions, type Attempt, type AudioSink, type AudioSource, type AuthProvider, BodDbFilesystem, CartesiaTTS, CartesiaTTSOptions, ChatLike, ChatOptions, ChatResponse, type CommandInfo, ConsoleHostBridge, DEFAULT_DENY, DuplexAgent, DuplexAgentOptions, type DuplexTaskStatus, FakeAIClient, Hooks, HostBridge, JailOptions, JailedFilesystem, type LessonOptions, LessonOptionsDefaults, type LoadMemoryOpts, MEMORY_PROMPT, MessageContent, type Mount, MountFilesystem, NodeDiskFilesystem, OverlayFilesystem, type ReflectOptions, RunResult, SCRATCH_DIR, STT_SAMPLE_RATE, type ScheduledJob, type ScheduledJobSnapshot, Scheduler, type SchedulerOptions, Scratch, type ScratchOptions, ScriptedHostBridge, type SiblingResolver, type SkillInfo, SonioxSTT, SonioxSTTOptions, type SttLike, TTS_SAMPLE_RATE, type TaskRecord, type TaskToolOptions, ToolCall, type ToolSpec, type Trigger, type TriggerCron, type TriggerInterval, type TriggerOneOff, type TtsLike, UserQuestion, VOICE_MEMORY_PROMPT, VOICE_SYSTEM_PROMPT, VoiceEngine, VoiceEngineOptions, type VoiceState, type WebFetchOptions, type WebSearchOptions, type WorkerTier, type WorktreeInfo, type WorktreeSession, applyEditsTool, askUserQuestionTool, checkpointTool, checkpointTools, cleanupWorktree, compileSynthesizedTool, cronMatches, decodeDdgUrl, diskAgentOptions, enterWorktree, exitWorktree, expandCommand, expandEntry, expandTemplate, findGitRoot, forComponent, fullAgentOptions, getOrCreateWorktree, getWorktreeSession, globTool, grepTool, htmlToText, idfWeights, lessonCapture, loadAgents, loadCommands, loadInstructions, loadMemory, loadSkills, makeAskTool, makeScheduleTools, makeTaskBatchTool, makeTaskTool, makeWebFetchTool, makeWebSearchAnthropicTool, makeWebSearchTool, mkdirp, multiEditTool, nextCronAfter, parseCron, parseDdgHtml, raceAttempts, reflectOnRun, relevanceScore, repoIndex, repoMapTool, resolveAuth, rollbackTool, sandboxAgentOptions, scanCommands, scanSkills, slugify, tokenize, toolCall, topByRelevance, validateToolCode, validateWorktreeSlug, webFetchTool, webSearchAnthropicTool, webSearchTool, worktreeBranchName, writeFact, writeTool };
+export { Agent, type AgentDef, AgentOptions, AgentTool, type AskOptions, type Attempt, BodDbFilesystem, ChatLike, ChatOptions, ChatResponse, type CommandInfo, ConsoleHostBridge, DEFAULT_DENY, DuplexAgent, DuplexAgentOptions, type DuplexTaskStatus, FakeAIClient, Hooks, HostBridge, JailOptions, JailedFilesystem, type LessonOptions, LessonOptionsDefaults, type LoadMemoryOpts, MEMORY_PROMPT, MessageContent, type Mount, MountFilesystem, NodeDiskFilesystem, OverlayFilesystem, type ReflectOptions, RunResult, SCRATCH_DIR, type ScheduledJob, type ScheduledJobSnapshot, Scheduler, type SchedulerOptions, Scratch, type ScratchOptions, ScriptedHostBridge, type SiblingResolver, type SkillInfo, type TaskRecord, type TaskToolOptions, ToolCall, type ToolSpec, type Trigger, type TriggerCron, type TriggerInterval, type TriggerOneOff, UserQuestion, VOICE_MEMORY_PROMPT, VOICE_SYSTEM_PROMPT, type WebFetchOptions, type WebSearchOptions, type WorkerTier, type WorktreeInfo, type WorktreeSession, applyEditsTool, askUserQuestionTool, checkpointTool, checkpointTools, cleanupWorktree, compileSynthesizedTool, cronMatches, decodeDdgUrl, diskAgentOptions, enterWorktree, exitWorktree, expandCommand, expandEntry, expandTemplate, findGitRoot, forComponent, fullAgentOptions, getOrCreateWorktree, getWorktreeSession, globTool, grepTool, htmlToText, idfWeights, lessonCapture, loadAgents, loadCommands, loadInstructions, loadMemory, loadSkills, makeAskTool, makeScheduleTools, makeTaskBatchTool, makeTaskTool, makeWebFetchTool, makeWebSearchAnthropicTool, makeWebSearchTool, mkdirp, multiEditTool, nextCronAfter, parseCron, parseDdgHtml, raceAttempts, reflectOnRun, relevanceScore, repoIndex, repoMapTool, rollbackTool, sandboxAgentOptions, scanCommands, scanSkills, slugify, tokenize, toolCall, topByRelevance, validateToolCode, validateWorktreeSlug, webFetchTool, webSearchAnthropicTool, webSearchTool, worktreeBranchName, writeFact, writeTool };