@elizaos/shared 2.0.3-beta.2 → 2.0.3-beta.3

package/voice/owner-inference.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Owner-candidate inference for voice (#8785).
+ *
+ * "How does the agent know which speaker is the device OWNER?" Today the owner
+ * entity must be enrolled explicitly (the first-run voice flow). But when no
+ * owner is set, the agent should still be able to FORM a hypothesis from what it
+ * hears — the person who speaks to it most, most confidently, and clearly more
+ * than anyone else is the likely owner. This is the pure decision logic a
+ * provider/evaluator runs when the owner is unknown: it accumulates recognized
+ * voice turns and proposes a candidate only when the evidence is both sufficient
+ * (enough confident observations) and unambiguous (a clear lead over the
+ * runner-up). Otherwise it stays UNDECIDED — it never guesses an owner from one
+ * stray turn, because a wrong owner is a security and personalization hazard.
+ *
+ * Pure (no I/O, no models); the runtime feeds it the diarized/recognized
+ * observations and acts on a decided candidate (e.g. prompt to confirm, or set
+ * the owner setting). The Voice Workbench exercises the SAME function so the
+ * inference is benchmarked, not just shipped.
+ */
+/** One recognized voice turn: which enrolled/clustered speaker, how confident. */
+export interface OwnerObservation {
+    /** The entity/cluster the recognized voice resolved to (null = unrecognized). */
+    entityId: string | null;
+    /** Recognition confidence 0..1 (cosine-rescaled by the attribution pipeline). */
+    confidence: number;
+}
+export interface OwnerInferenceOptions {
+    /** Minimum qualifying observations before any candidate is proposed. */
+    minObservations?: number;
+    /** Confidence floor; observations below it don't count toward a candidate. */
+    minConfidence?: number;
+    /**
+     * Minimum lead (in confidence-weighted score) the top speaker must hold over
+     * the runner-up to be unambiguous. Prevents naming an owner in a two-equals
+     * household.
+     */
+    minMargin?: number;
+}
+export interface OwnerInferenceResult {
+    /** The proposed owner entity, or null when the evidence is insufficient. */
+    ownerEntityId: string | null;
+    /** Confidence-weighted share of the proposed owner (0..1), 0 when undecided. */
+    share: number;
+    /** Number of qualifying (confident, recognized) observations considered. */
+    qualifyingObservations: number;
+    /** Why the function decided / declined — surfaced for the provider's logs. */
+    reason: string;
+}
+/**
+ * Propose the most likely owner from recognized voice observations, or stay
+ * undecided. A candidate is returned only when there are at least
+ * `minObservations` confident, recognized turns AND the top speaker leads the
+ * runner-up by at least `minMargin` (confidence-weighted). Ties and thin
+ * evidence yield `ownerEntityId: null`.
+ */
+export declare function resolveOwnerCandidate(observations: ReadonlyArray<OwnerObservation>, options?: OwnerInferenceOptions): OwnerInferenceResult;
+//# sourceMappingURL=owner-inference.d.ts.map

package/voice/owner-inference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"owner-inference.d.ts","sourceRoot":"","sources":["../../src/voice/owner-inference.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,kFAAkF;AAClF,MAAM,WAAW,gBAAgB;IAC/B,iFAAiF;IACjF,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,iFAAiF;IACjF,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,qBAAqB;IACpC,wEAAwE;IACxE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,8EAA8E;IAC9E,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,oBAAoB;IACnC,4EAA4E;IAC5E,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,gFAAgF;IAChF,KAAK,EAAE,MAAM,CAAC;IACd,4EAA4E;IAC5E,sBAAsB,EAAE,MAAM,CAAC;IAC/B,8EAA8E;IAC9E,MAAM,EAAE,MAAM,CAAC;CAChB;AAMD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,YAAY,EAAE,aAAa,CAAC,gBAAgB,CAAC,EAC7C,OAAO,GAAE,qBAA0B,GAClC,oBAAoB,CA4CtB"}

package/voice/owner-inference.js

@@ -0,0 +1,73 @@
+/**
+ * Owner-candidate inference for voice (#8785).
+ *
+ * "How does the agent know which speaker is the device OWNER?" Today the owner
+ * entity must be enrolled explicitly (the first-run voice flow). But when no
+ * owner is set, the agent should still be able to FORM a hypothesis from what it
+ * hears — the person who speaks to it most, most confidently, and clearly more
+ * than anyone else is the likely owner. This is the pure decision logic a
+ * provider/evaluator runs when the owner is unknown: it accumulates recognized
+ * voice turns and proposes a candidate only when the evidence is both sufficient
+ * (enough confident observations) and unambiguous (a clear lead over the
+ * runner-up). Otherwise it stays UNDECIDED — it never guesses an owner from one
+ * stray turn, because a wrong owner is a security and personalization hazard.
+ *
+ * Pure (no I/O, no models); the runtime feeds it the diarized/recognized
+ * observations and acts on a decided candidate (e.g. prompt to confirm, or set
+ * the owner setting). The Voice Workbench exercises the SAME function so the
+ * inference is benchmarked, not just shipped.
+ */
+const DEFAULT_MIN_OBSERVATIONS = 3;
+const DEFAULT_MIN_CONFIDENCE = 0.7;
+const DEFAULT_MIN_MARGIN = 1;
+/**
+ * Propose the most likely owner from recognized voice observations, or stay
+ * undecided. A candidate is returned only when there are at least
+ * `minObservations` confident, recognized turns AND the top speaker leads the
+ * runner-up by at least `minMargin` (confidence-weighted). Ties and thin
+ * evidence yield `ownerEntityId: null`.
+ */
+export function resolveOwnerCandidate(observations, options = {}) {
+    const minObservations = options.minObservations ?? DEFAULT_MIN_OBSERVATIONS;
+    const minConfidence = options.minConfidence ?? DEFAULT_MIN_CONFIDENCE;
+    const minMargin = options.minMargin ?? DEFAULT_MIN_MARGIN;
+    const scores = new Map();
+    let qualifying = 0;
+    let totalScore = 0;
+    for (const obs of observations) {
+        if (obs.entityId === null)
+            continue;
+        if (!(obs.confidence >= minConfidence))
+            continue;
+        qualifying += 1;
+        const next = (scores.get(obs.entityId) ?? 0) + obs.confidence;
+        scores.set(obs.entityId, next);
+        totalScore += obs.confidence;
+    }
+    if (qualifying < minObservations) {
+        return {
+            ownerEntityId: null,
+            share: 0,
+            qualifyingObservations: qualifying,
+            reason: `insufficient evidence (${qualifying}/${minObservations} confident observations)`,
+        };
+    }
+    const ranked = [...scores.entries()].sort((a, b) => b[1] - a[1]);
+    const [topId, topScore] = ranked[0];
+    const runnerUpScore = ranked[1]?.[1] ?? 0;
+    if (topScore - runnerUpScore < minMargin) {
+        return {
+            ownerEntityId: null,
+            share: totalScore > 0 ? topScore / totalScore : 0,
+            qualifyingObservations: qualifying,
+            reason: `ambiguous lead (top ${topScore.toFixed(2)} vs runner-up ${runnerUpScore.toFixed(2)}, margin < ${minMargin})`,
+        };
+    }
+    return {
+        ownerEntityId: topId,
+        share: totalScore > 0 ? topScore / totalScore : 0,
+        qualifyingObservations: qualifying,
+        reason: `dominant speaker (${topScore.toFixed(2)} of ${totalScore.toFixed(2)} over ${qualifying} observations)`,
+    };
+}
+//# sourceMappingURL=owner-inference.js.map

package/voice/owner-inference.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"owner-inference.js","sourceRoot":"","sources":["../../src/voice/owner-inference.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAkCH,MAAM,wBAAwB,GAAG,CAAC,CAAC;AACnC,MAAM,sBAAsB,GAAG,GAAG,CAAC;AACnC,MAAM,kBAAkB,GAAG,CAAC,CAAC;AAE7B;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB,CACnC,YAA6C,EAC7C,UAAiC,EAAE;IAEnC,MAAM,eAAe,GAAG,OAAO,CAAC,eAAe,IAAI,wBAAwB,CAAC;IAC5E,MAAM,aAAa,GAAG,OAAO,CAAC,aAAa,IAAI,sBAAsB,CAAC;IACtE,MAAM,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,kBAAkB,CAAC;IAE1D,MAAM,MAAM,GAAG,IAAI,GAAG,EAAkB,CAAC;IACzC,IAAI,UAAU,GAAG,CAAC,CAAC;IACnB,IAAI,UAAU,GAAG,CAAC,CAAC;IACnB,KAAK,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAC/B,IAAI,GAAG,CAAC,QAAQ,KAAK,IAAI;YAAE,SAAS;QACpC,IAAI,CAAC,CAAC,GAAG,CAAC,UAAU,IAAI,aAAa,CAAC;YAAE,SAAS;QACjD,UAAU,IAAI,CAAC,CAAC;QAChB,MAAM,IAAI,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,GAAG,GAAG,CAAC,UAAU,CAAC;QAC9D,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;QAC/B,UAAU,IAAI,GAAG,CAAC,UAAU,CAAC;IAC/B,CAAC;IAED,IAAI,UAAU,GAAG,eAAe,EAAE,CAAC;QACjC,OAAO;YACL,aAAa,EAAE,IAAI;YACnB,KAAK,EAAE,CAAC;YACR,sBAAsB,EAAE,UAAU;YAClC,MAAM,EAAE,0BAA0B,UAAU,IAAI,eAAe,0BAA0B;SAC1F,CAAC;IACJ,CAAC;IAED,MAAM,MAAM,GAAG,CAAC,GAAG,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACjE,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IACpC,MAAM,aAAa,GAAG,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IAC1C,IAAI,QAAQ,GAAG,aAAa,GAAG,SAAS,EAAE,CAAC;QACzC,OAAO;YACL,aAAa,EAAE,IAAI;YACnB,KAAK,EAAE,UAAU,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;YACjD,sBAAsB,EAAE,UAAU;YAClC,MAAM,EAAE,uBAAuB,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,iBAAiB,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,cAAc,SAAS,GAAG;SACtH,CAAC;IACJ,CAAC;IAED,OAAO;QACL,aAAa,EAAE,KAAK;QACpB,KAAK,EAAE,UAAU,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;QACjD,sBAAsB,EAAE,UAAU;QAClC,MAAM,EAAE,qBAAqB,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,UAAU,gBAAgB;KAChH,CAAC;AACJ,CAAC"}

package/voice/respond-gate.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Canonical client-side shouldRespond / echo-rejection gate for always-on voice.
+ *
+ * In always-on ("hands-free") mode the mic is open continuously, so the
+ * recognizer transcribes EVERYTHING it hears — the agent's own text-to-speech
+ * bleeding back into the mic, the speaker's disfluent thinking noises ("um…"),
+ * and other people in the room. Sending those as turns makes the agent reply to
+ * itself, to filler, or to a bystander — the "responding when it's not
+ * appropriate" problem.
+ *
+ * This is the SINGLE definition of that gate, shared by:
+ *   - the UI shell capture loop (`@elizaos/ui` `voice/should-respond` +
+ *     `voice/voice-turn-signal` re-export from here), and
+ *   - the Voice Workbench headless runner (the plugin's real-decision-logic
+ *     services adapter calls these so the benchmark exercises the SAME code the
+ *     client runs — no drift between what we test and what we ship).
+ *
+ * Pure (no DOM, no I/O); the only dependency is the canonical syntactic EOT
+ * heuristic in `@elizaos/shared/voice-eot`.
+ */
+/** How recent the agent's reply must be for the echo guard to apply. */
+export declare const ECHO_WINDOW_MS = 9000;
+/** Word-overlap fraction above which a turn is treated as TTS echo. */
+export declare const ECHO_OVERLAP_THRESHOLD = 0.7;
+export interface ShouldRespondContext {
+    /** The agent's most recent spoken reply, for the echo guard. */
+    recentAgentReply?: string;
+    /** Age of that reply in ms; the echo guard applies while it's recent. */
+    replyAgeMs?: number;
+    /**
+     * True while the agent is CURRENTLY speaking. Forces the echo guard on
+     * regardless of `replyAgeMs`, because a long reply's TTS is actively bleeding
+     * into the open mic even though its message was created many seconds ago (the
+     * age-only window would have already expired mid-speech).
+     */
+    agentSpeaking?: boolean;
+}
+/**
+ * Whether a transcribed voice turn should be sent to the agent (i.e. warrants a
+ * response). Returns false for pure disfluency and for near-verbatim echoes of
+ * the agent's recent speech.
+ */
+export declare function shouldRespondToVoiceTurn(transcript: string, context?: ShouldRespondContext): boolean;
+/** Mirrors the server-side VoiceTurnSignalMetadata shape the gate parses. */
+export interface VoiceTurnSignal {
+    endOfTurnProbability: number;
+    nextSpeaker: "agent" | "user" | "unknown";
+    agentShouldSpeak: boolean;
+    source: string;
+}
+/** Live speaker attribution from diarization (only where audio frames exist). */
+export interface VoiceTurnSpeakerAttribution {
+    /** Enrolled entity this turn was attributed to, or null when unknown. */
+    entityId: string | null;
+    /** Match confidence 0..1 (cosine-rescaled by the attribution pipeline). */
+    confidence: number;
+    /** True when attributed to the device owner / primary enrolled speaker. */
+    isOwner?: boolean;
+}
+export interface BuildVoiceTurnSignalContext extends ShouldRespondContext {
+    /** Speaker attribution for this turn (diarization; desktop/server only). */
+    speaker?: VoiceTurnSpeakerAttribution;
+    /** True when a wake word ("hey eliza") fired within the recent listen window. */
+    wakeWordActive?: boolean;
+    /** Entity ids the agent answers to without a wake word (owner + enrolled). */
+    knownSpeakerEntityIds?: readonly string[];
+    /**
+     * Cosine similarity (0..1) of THIS turn's speaker embedding against the
+     * agent's own TTS-voice imprint, when the speaker encoder is available. High =
+     * the agent is hearing ITSELF (its TTS bled back into the mic). This is the
+     * ACOUSTIC self-echo signal — it catches an echo the transcript word-overlap
+     * guard misses (a mis-transcribed echo whose words don't match the reply).
+     */
+    selfVoiceSimilarity?: number;
+}
+/** Server SUPPRESS threshold for EOT — below this reads as "user still talking". */
+export declare const SERVER_EOT_SUPPRESS_THRESHOLD = 0.4;
+/** Only a CONFIDENT bystander attribution is allowed to silence a turn. */
+export declare const BYSTANDER_SUPPRESS_CONFIDENCE = 0.7;
+/**
+ * Cosine at/above which an incoming turn is treated as the agent's OWN voice and
+ * hard-suppressed. WeSpeaker enrolls the device owner at ~0.78; the agent's own
+ * TTS imprint is a tighter, single-source match, so a slightly lower bar is
+ * safe and catches echo the transcript guard cannot.
+ */
+export declare const AGENT_SELF_VOICE_THRESHOLD = 0.7;
+export declare function buildVoiceTurnSignal(transcript: string, context?: BuildVoiceTurnSignalContext): VoiceTurnSignal;
+//# sourceMappingURL=respond-gate.d.ts.map

package/voice/respond-gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"respond-gate.d.ts","sourceRoot":"","sources":["../../src/voice/respond-gate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAqBH,wEAAwE;AACxE,eAAO,MAAM,cAAc,OAAO,CAAC;AACnC,uEAAuE;AACvE,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAU1C,MAAM,WAAW,oBAAoB;IACnC,gEAAgE;IAChE,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,yEAAyE;IACzE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAuBT;AAED,6EAA6E;AAC7E,MAAM,WAAW,eAAe;IAC9B,oBAAoB,EAAE,MAAM,CAAC;IAC7B,WAAW,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC;IAC1C,gBAAgB,EAAE,OAAO,CAAC;IAC1B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,iFAAiF;AACjF,MAAM,WAAW,2BAA2B;IAC1C,yEAAyE;IACzE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,2EAA2E;IAC3E,UAAU,EAAE,MAAM,CAAC;IACnB,2EAA2E;IAC3E,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,2BAA4B,SAAQ,oBAAoB;IACvE,4EAA4E;IAC5E,OAAO,CAAC,EAAE,2BAA2B,CAAC;IACtC,iFAAiF;IACjF,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,8EAA8E;IAC9E,qBAAqB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C;;;;;;OAMG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,oFAAoF;AACpF,eAAO,MAAM,6BAA6B,MAAM,CAAC;AACjD,2EAA2E;AAC3E,eAAO,MAAM,6BAA6B,MAAM,CAAC;AACjD;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,MAAM,CAAC;AAE9C,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,2BAAgC,GACxC,eAAe,CA0DjB"}

package/voice/respond-gate.js

@@ -0,0 +1,139 @@
+/**
+ * Canonical client-side shouldRespond / echo-rejection gate for always-on voice.
+ *
+ * In always-on ("hands-free") mode the mic is open continuously, so the
+ * recognizer transcribes EVERYTHING it hears — the agent's own text-to-speech
+ * bleeding back into the mic, the speaker's disfluent thinking noises ("um…"),
+ * and other people in the room. Sending those as turns makes the agent reply to
+ * itself, to filler, or to a bystander — the "responding when it's not
+ * appropriate" problem.
+ *
+ * This is the SINGLE definition of that gate, shared by:
+ *   - the UI shell capture loop (`@elizaos/ui` `voice/should-respond` +
+ *     `voice/voice-turn-signal` re-export from here), and
+ *   - the Voice Workbench headless runner (the plugin's real-decision-logic
+ *     services adapter calls these so the benchmark exercises the SAME code the
+ *     client runs — no drift between what we test and what we ship).
+ *
+ * Pure (no DOM, no I/O); the only dependency is the canonical syntactic EOT
+ * heuristic in `@elizaos/shared/voice-eot`.
+ */
+import { scoreEndOfTurnHeuristic } from "../voice-eot.js";
+/** Pure disfluencies — never a meaningful turn on their own. NOT answers. */
+const DISFLUENCIES = new Set([
+    "um",
+    "uh",
+    "uhh",
+    "uhm",
+    "umm",
+    "hmm",
+    "hm",
+    "mm",
+    "mmm",
+    "er",
+    "erm",
+    "ah",
+    "eh",
+]);
+/** How recent the agent's reply must be for the echo guard to apply. */
+export const ECHO_WINDOW_MS = 9000;
+/** Word-overlap fraction above which a turn is treated as TTS echo. */
+export const ECHO_OVERLAP_THRESHOLD = 0.7;
+function words(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^a-z0-9'\s-]/gi, "")
+        .split(/\s+/)
+        .filter(Boolean);
+}
+/**
+ * Whether a transcribed voice turn should be sent to the agent (i.e. warrants a
+ * response). Returns false for pure disfluency and for near-verbatim echoes of
+ * the agent's recent speech.
+ */
+export function shouldRespondToVoiceTurn(transcript, context = {}) {
+    const w = words(transcript);
+    if (w.length === 0)
+        return false;
+    // Pure disfluency ("um", "uh huh"… with nothing substantive) → ignore.
+    if (w.every((word) => DISFLUENCIES.has(word)))
+        return false;
+    // Self-echo: the agent's own TTS heard back through the mic. Only consider it
+    // while the reply is recent, and only for multi-word turns (a one-word answer
+    // shouldn't be suppressed just because the word also appears in the reply).
+    const reply = context.recentAgentReply?.trim();
+    const age = context.replyAgeMs ?? Number.POSITIVE_INFINITY;
+    const echoActive = context.agentSpeaking === true || age <= ECHO_WINDOW_MS;
+    if (reply && echoActive && w.length >= 2) {
+        const replyWords = new Set(words(reply));
+        if (replyWords.size > 0) {
+            const overlap = w.filter((word) => replyWords.has(word)).length / w.length;
+            if (overlap >= ECHO_OVERLAP_THRESHOLD)
+                return false;
+        }
+    }
+    return true;
+}
+/** Server SUPPRESS threshold for EOT — below this reads as "user still talking". */
+export const SERVER_EOT_SUPPRESS_THRESHOLD = 0.4;
+/** Only a CONFIDENT bystander attribution is allowed to silence a turn. */
+export const BYSTANDER_SUPPRESS_CONFIDENCE = 0.7;
+/**
+ * Cosine at/above which an incoming turn is treated as the agent's OWN voice and
+ * hard-suppressed. WeSpeaker enrolls the device owner at ~0.78; the agent's own
+ * TTS imprint is a tighter, single-source match, so a slightly lower bar is
+ * safe and catches echo the transcript guard cannot.
+ */
+export const AGENT_SELF_VOICE_THRESHOLD = 0.7;
+export function buildVoiceTurnSignal(transcript, context = {}) {
+    const endOfTurnProbability = scoreEndOfTurnHeuristic(transcript);
+    // Transcript-level gate: the agent's own TTS echoed back through the mic, or
+    // pure thinking-noise ("um", "uh").
+    let agentShouldSpeak = shouldRespondToVoiceTurn(transcript, context);
+    // Audio-frame gate (only when diarization attributed the turn): a CONFIDENT
+    // bystander — someone who is neither the owner nor an enrolled speaker — who
+    // did NOT say the wake word is cross-talk, not a turn addressed to the agent.
+    // An uncertain attribution must never silence a real turn (fail open).
+    const speaker = context.speaker;
+    if (agentShouldSpeak && speaker && context.wakeWordActive !== true) {
+        const known = new Set(context.knownSpeakerEntityIds ?? []);
+        const enrolled = speaker.isOwner === true ||
+            (speaker.entityId !== null && known.has(speaker.entityId));
+        const confidentBystander = !enrolled &&
+            speaker.entityId !== null &&
+            speaker.confidence >= BYSTANDER_SUPPRESS_CONFIDENCE;
+        if (confidentBystander)
+            agentShouldSpeak = false;
+    }
+    // The wake word is an explicit address: it overrides bystander doubt and a
+    // soft echo/disfluency miss, because the user deliberately summoned the agent.
+    if (context.wakeWordActive === true)
+        agentShouldSpeak = true;
+    // Acoustic self-voice rejection: if the incoming voice MATCHES the agent's own
+    // TTS imprint while it is (or just was) speaking, it is the agent hearing
+    // itself — hard-suppress, even past the wake word. This is definitive (the
+    // owner cannot sound like the agent's synthetic voice) and catches the echo
+    // the transcript word-overlap guard misses (e.g. a mis-transcribed echo, or a
+    // "hey eliza" that the agent itself spoke).
+    const replyRecent = context.agentSpeaking === true ||
+        (context.replyAgeMs ?? Number.POSITIVE_INFINITY) <= ECHO_WINDOW_MS;
+    const isSelfVoice = context.selfVoiceSimilarity !== undefined &&
+        context.selfVoiceSimilarity >= AGENT_SELF_VOICE_THRESHOLD &&
+        replyRecent;
+    if (isSelfVoice)
+        agentShouldSpeak = false;
+    const nextSpeaker = !agentShouldSpeak
+        ? "user"
+        : endOfTurnProbability < SERVER_EOT_SUPPRESS_THRESHOLD
+            ? "user"
+            : "agent";
+    const source = isSelfVoice
+        ? "client-ambient+self-voice"
+        : context.wakeWordActive
+            ? "client-ambient+wakeword"
+            : speaker
+                ? "client-ambient+diarization"
+                : "client-ambient";
+    return { endOfTurnProbability, nextSpeaker, agentShouldSpeak, source };
+}
+//# sourceMappingURL=respond-gate.js.map

package/voice/respond-gate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"respond-gate.js","sourceRoot":"","sources":["../../src/voice/respond-gate.ts"],"names":[],"mappings":"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"}

package/voice-eot.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Heuristic end-of-turn (EOT) scoring — the single source of truth (#8786).
+ *
+ * The semantic "is the speaker done?" syntactic heuristic used to be implemented
+ * twice with drifted behavior: the UI shell capture path
+ * (`packages/ui/src/voice/end-of-turn.ts:scoreEndOfTurn`) and the plugin's
+ * Tier-3 classifier (`plugin-local-inference .../voice/eot-classifier.ts:
+ * HeuristicEotClassifier`). The two had diverged — different rule ORDERING
+ * (the plugin scored a 2-word trail-off like "and so" as a complete short
+ * command; the UI correctly held it), a missing ellipsis rule on the plugin
+ * side, and a different question-tag set. This module is the one canonical
+ * implementation both surfaces consume.
+ *
+ * It lives in `@elizaos/shared` (which both already depend on), is pure +
+ * browser-safe (no Node deps), and ships via the `@elizaos/shared/voice-eot`
+ * subpath without pulling the whole barrel — mirroring `voice-wer`.
+ *
+ * The fused composite EOT (ABI v11, `CompositeEotClassifier`) is preferred when
+ * the loaded native build wires the semantic model; it blends THIS heuristic as
+ * its high-precision syntactic co-signal, so consolidating here also feeds the
+ * model path one definition.
+ */
+/**
+ * Probability in [0,1] that `transcript` is a COMPLETE turn (the speaker is
+ * done). High → commit; low → the utterance trails off, keep listening.
+ *
+ * Rules fire in priority order; the first match wins:
+ *
+ *   1  Trailing ellipsis ("…" / "..")                       0.20  (trail-off)
+ *   2  Sentence-final punctuation (. ! ?)                   0.95
+ *   3  Question-tag suffix ("right?", "yeah", "correct")    0.85
+ *   4  Trailing conjunction (and / but / because / …)       0.15  (mid-clause)
+ *   5  Trailing preposition / article (to / the / with …)   0.20  (incomplete NP)
+ *   6  Short utterance (< 3 words, no trail-off)            0.70  (command/ack)
+ *   7  No signal                                            0.50
+ *
+ * Note the conjunction/preposition checks precede the short-utterance rule so a
+ * 2-word trail-off ("and so", "going to") is NOT misread as a complete short
+ * command.
+ */
+export declare function scoreEndOfTurnHeuristic(transcript: string): number;
+//# sourceMappingURL=voice-eot.d.ts.map

package/voice-eot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"voice-eot.d.ts","sourceRoot":"","sources":["../src/voice-eot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAqFH;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAkClE"}

package/voice-eot.js

@@ -0,0 +1,158 @@
+/**
+ * Heuristic end-of-turn (EOT) scoring — the single source of truth (#8786).
+ *
+ * The semantic "is the speaker done?" syntactic heuristic used to be implemented
+ * twice with drifted behavior: the UI shell capture path
+ * (`packages/ui/src/voice/end-of-turn.ts:scoreEndOfTurn`) and the plugin's
+ * Tier-3 classifier (`plugin-local-inference .../voice/eot-classifier.ts:
+ * HeuristicEotClassifier`). The two had diverged — different rule ORDERING
+ * (the plugin scored a 2-word trail-off like "and so" as a complete short
+ * command; the UI correctly held it), a missing ellipsis rule on the plugin
+ * side, and a different question-tag set. This module is the one canonical
+ * implementation both surfaces consume.
+ *
+ * It lives in `@elizaos/shared` (which both already depend on), is pure +
+ * browser-safe (no Node deps), and ships via the `@elizaos/shared/voice-eot`
+ * subpath without pulling the whole barrel — mirroring `voice-wer`.
+ *
+ * The fused composite EOT (ABI v11, `CompositeEotClassifier`) is preferred when
+ * the loaded native build wires the semantic model; it blends THIS heuristic as
+ * its high-precision syntactic co-signal, so consolidating here also feeds the
+ * model path one definition.
+ */
+/** Conjunctions that strongly suggest the speaker is mid-clause. */
+const TRAILING_CONJUNCTIONS = new Set([
+    "and",
+    "but",
+    "or",
+    "nor",
+    "yet",
+    "so",
+    "because",
+    "although",
+    "though",
+    "while",
+    "whereas",
+    "if",
+    "unless",
+    "until",
+    "since",
+    "when",
+    "where",
+    "which",
+    "that",
+    "who",
+    "whom",
+    "whose",
+]);
+/** Prepositions / articles that imply an incomplete noun phrase follows. */
+const TRAILING_INCOMPLETE = new Set([
+    "a",
+    "an",
+    "the",
+    "to",
+    "of",
+    "in",
+    "on",
+    "at",
+    "by",
+    "for",
+    "with",
+    "from",
+    "into",
+    "about",
+    "through",
+    "between",
+    "against",
+    "during",
+    "before",
+    "after",
+    "without",
+    "under",
+    "over",
+    "above",
+    "below",
+    "around",
+    "beside",
+    "beyond",
+    "like",
+    "near",
+    "past",
+    "via",
+]);
+/**
+ * Question-tag suffixes that end an utterance (matched case-insensitively).
+ * The union of both prior surfaces: punctuated forms (the UI set) plus the
+ * bare forms (`right` / `yeah` / `correct`) the plugin relied on for the
+ * no-trailing-`?` case. A punctuated tag is also caught by the sentence-final
+ * punctuation rule, which fires first.
+ */
+const QUESTION_TAGS = [
+    "right?",
+    "yeah?",
+    "ok?",
+    "okay?",
+    "correct?",
+    "hm?",
+    "huh?",
+    "eh?",
+    "right",
+    "yeah",
+    "correct",
+];
+/**
+ * Probability in [0,1] that `transcript` is a COMPLETE turn (the speaker is
+ * done). High → commit; low → the utterance trails off, keep listening.
+ *
+ * Rules fire in priority order; the first match wins:
+ *
+ *   1  Trailing ellipsis ("…" / "..")                       0.20  (trail-off)
+ *   2  Sentence-final punctuation (. ! ?)                   0.95
+ *   3  Question-tag suffix ("right?", "yeah", "correct")    0.85
+ *   4  Trailing conjunction (and / but / because / …)       0.15  (mid-clause)
+ *   5  Trailing preposition / article (to / the / with …)   0.20  (incomplete NP)
+ *   6  Short utterance (< 3 words, no trail-off)            0.70  (command/ack)
+ *   7  No signal                                            0.50
+ *
+ * Note the conjunction/preposition checks precede the short-utterance rule so a
+ * 2-word trail-off ("and so", "going to") is NOT misread as a complete short
+ * command.
+ */
+export function scoreEndOfTurnHeuristic(transcript) {
+    const text = transcript.trim();
+    if (text.length === 0)
+        return 0.5;
+    // A trailing ellipsis is the strongest trail-off signal — the speaker paused
+    // mid-thought. Checked BEFORE sentence-final punctuation, since "..." ends in ".".
+    if (/(\.{2,}|…)$/.test(text))
+        return 0.2;
+    // Sentence-final punctuation → almost certainly done.
+    if (/[.!?]$/.test(text))
+        return 0.95;
+    const lower = text.toLowerCase();
+    for (const tag of QUESTION_TAGS) {
+        if (lower.endsWith(tag))
+            return 0.85;
+    }
+    const words = lower
+        .replace(/[^a-z0-9'\s-]/gi, "")
+        .split(/\s+/)
+        .filter(Boolean);
+    if (words.length === 0)
+        return 0.5;
+    const lastWord = words[words.length - 1].replace(/[',;:-]+$/, "");
+    // Trailing conjunction / preposition / article → mid-clause, the speaker is
+    // continuing. Checked BEFORE the short-utterance rule so a 2-word trail-off
+    // ("going to", "and so") is NOT misread as a complete short command.
+    if (TRAILING_CONJUNCTIONS.has(lastWord))
+        return 0.15;
+    if (TRAILING_INCOMPLETE.has(lastWord))
+        return 0.2;
+    // Short utterance that doesn't trail off (a command / acknowledgement) →
+    // likely complete ("go home", "yes", "stop").
+    if (words.length < 3)
+        return 0.7;
+    // No strong signal either way — the recognizer's silence is enough.
+    return 0.5;
+}
+//# sourceMappingURL=voice-eot.js.map

package/voice-eot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"voice-eot.js","sourceRoot":"","sources":["../src/voice-eot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,oEAAoE;AACpE,MAAM,qBAAqB,GAAG,IAAI,GAAG,CAAC;IACpC,KAAK;IACL,KAAK;IACL,IAAI;IACJ,KAAK;IACL,KAAK;IACL,IAAI;IACJ,SAAS;IACT,UAAU;IACV,QAAQ;IACR,OAAO;IACP,SAAS;IACT,IAAI;IACJ,QAAQ;IACR,OAAO;IACP,OAAO;IACP,MAAM;IACN,OAAO;IACP,OAAO;IACP,MAAM;IACN,KAAK;IACL,MAAM;IACN,OAAO;CACR,CAAC,CAAC;AAEH,4EAA4E;AAC5E,MAAM,mBAAmB,GAAG,IAAI,GAAG,CAAC;IAClC,GAAG;IACH,IAAI;IACJ,KAAK;IACL,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,KAAK;IACL,MAAM;IACN,MAAM;IACN,MAAM;IACN,OAAO;IACP,SAAS;IACT,SAAS;IACT,SAAS;IACT,QAAQ;IACR,QAAQ;IACR,OAAO;IACP,SAAS;IACT,OAAO;IACP,MAAM;IACN,OAAO;IACP,OAAO;IACP,QAAQ;IACR,QAAQ;IACR,QAAQ;IACR,MAAM;IACN,MAAM;IACN,MAAM;IACN,KAAK;CACN,CAAC,CAAC;AAEH;;;;;;GAMG;AACH,MAAM,aAAa,GAAG;IACpB,QAAQ;IACR,OAAO;IACP,KAAK;IACL,OAAO;IACP,UAAU;IACV,KAAK;IACL,MAAM;IACN,KAAK;IACL,OAAO;IACP,MAAM;IACN,SAAS;CACV,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,uBAAuB,CAAC,UAAkB;IACxD,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,EAAE,CAAC;IAC/B,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,GAAG,CAAC;IAElC,6EAA6E;IAC7E,mFAAmF;IACnF,IAAI,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC;QAAE,OAAO,GAAG,CAAC;IACzC,sDAAsD;IACtD,IAAI,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IAErC,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;IACjC,KAAK,MAAM,GAAG,IAAI,aAAa,EAAE,CAAC;QAChC,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC;YAAE,OAAO,IAAI,CAAC;IACvC,CAAC;IAED,MAAM,KAAK,GAAG,KAAK;SAChB,OAAO,CAAC,iBAAiB,EAAE,EAAE,CAAC;SAC9B,KAAK,CAAC,KAAK,CAAC;SACZ,MAAM,CAAC,OAAO,CAAC,CAAC;IACnB,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,GAAG,CAAC;IAEnC,MAAM,QAAQ,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;IAClE,4EAA4E;IAC5E,4EAA4E;IAC5E,qEAAqE;IACrE,IAAI,qBAAqB,CAAC,GAAG,CAAC,QAAQ,CAAC;QAAE,OAAO,IAAI,CAAC;IACrD,IAAI,mBAAmB,CAAC,GAAG,CAAC,QAAQ,CAAC;QAAE,OAAO,GAAG,CAAC;IAElD,yEAAyE;IACzE,8CAA8C;IAC9C,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,GAAG,CAAC;IAEjC,oEAAoE;IACpE,OAAO,GAAG,CAAC;AACb,CAAC"}

package/voice.d.ts

@@ -35,8 +35,8 @@ export declare const VOICE_PROVIDERS: Array<{
  * ASR (automatic speech recognition) provider catalogue. Mirrors
  * `VOICE_PROVIDERS` so the settings UI can render a provider picker for
  * speech-to-text. The legacy whisper.cpp pipeline has been retired —
- * on-device transcription now runs through the local-inference Qwen3-ASR
- * bundle instead.
+ * on-device transcription now runs through the local-inference ASR bundle.
+ * Release catalog checks gate the bundle lineage before it can be selected.
  */
 export declare const ASR_PROVIDERS: Array<{
     id: "local-inference" | "eliza-cloud" | "openai";

package/voice.js

@@ -278,15 +278,15 @@ export const VOICE_PROVIDERS = [
  * ASR (automatic speech recognition) provider catalogue. Mirrors
  * `VOICE_PROVIDERS` so the settings UI can render a provider picker for
  * speech-to-text. The legacy whisper.cpp pipeline has been retired —
- * on-device transcription now runs through the local-inference Qwen3-ASR
- * bundle instead.
+ * on-device transcription now runs through the local-inference ASR bundle.
+ * Release catalog checks gate the bundle lineage before it can be selected.
  */
 export const ASR_PROVIDERS = [
     {
         id: "local-inference",
         label: "Local inference",
         labelKey: "asr.provider.localInference",
-        hint: "On-device Qwen3-ASR",
+        hint: "On-device local ASR",
         hintKey: "asr.provider.localInference.hint",
         needsKey: false,
     },