dsh-live-voice 0.3.2 → 0.4.1

package/src/modules/conversation/components/RecognitionBar.tsx

@@ -0,0 +1,14 @@
+import React from 'react';
+import { Waveform } from './Waveform.js';
+export function RecognitionBar({ controller, listening, label, status, leading, children }: any) {
+  return (
+    <div className="dlv-pill" role="group" aria-label={label}>
+      {leading}
+      <Waveform controller={controller} enabled={Boolean(listening)} />
+      <span className="dlv-status" role="status" aria-live="polite">
+        {status}
+      </span>
+      {children}
+    </div>
+  );
+}

package/src/modules/conversation/components/ScrollingSpeechCaption.tsx

@@ -0,0 +1,100 @@
+import React from 'react';
+
+/** Visual approximation only: no word-level timing is available. */
+export function ScrollingSpeechCaption({
+  text,
+  label,
+  controller,
+  segment,
+  paused,
+  loading,
+}: {
+  text: string;
+  label: string;
+  controller: any;
+  segment: number;
+  paused: boolean;
+  loading: boolean;
+}) {
+  const viewport = React.useRef<HTMLDivElement>(null);
+  const line = React.useRef<HTMLSpanElement>(null);
+  const marker = React.useRef<HTMLSpanElement>(null);
+  const current = React.useRef({ paused, loading });
+  current.current = { paused, loading };
+  React.useEffect(() => {
+    const box = viewport.current;
+    const content = line.current;
+    const band = marker.current;
+    if (!box || !content || !band) return;
+    const host = box.ownerDocument.defaultView!;
+    let width = box.clientWidth;
+    let textWidth = content.scrollWidth;
+    let fraction = 0;
+    let previousTime = 0;
+    let frame = 0;
+    box.scrollLeft = 0;
+    band.style.transform = 'translateX(0px)';
+    const measure = () => {
+      width = box.clientWidth;
+      textWidth = content.scrollWidth;
+    };
+    const observer =
+      typeof host.ResizeObserver === 'function' ? new host.ResizeObserver(measure) : null;
+    observer?.observe(box);
+    observer?.observe(content);
+    const reduced = host.matchMedia?.('(prefers-reduced-motion: reduce)').matches;
+    const tick = (time: number) => {
+      const delta = Math.min(100, previousTime ? time - previousTime : 16);
+      previousTime = time;
+      const state = current.current;
+      if (!state.paused && !state.loading) {
+        const progress = controller.getSpeechProgress?.();
+        if (
+          progress &&
+          Number.isFinite(progress.durationSeconds) &&
+          progress.durationSeconds > 0 &&
+          Number.isFinite(progress.positionSeconds)
+        ) {
+          const target = Math.max(
+            0,
+            Math.min(1, progress.positionSeconds / progress.durationSeconds),
+          );
+          fraction = reduced
+            ? target
+            : fraction + (target - fraction) * (1 - Math.exp(-delta / 90));
+        }
+      }
+      const bandWidth = Math.min(90, width, textWidth);
+      const position = fraction * Math.max(0, textWidth - bandWidth);
+      const scroll = Math.max(
+        0,
+        Math.min(Math.max(0, textWidth - width), position - (width - bandWidth) / 2),
+      );
+      box.scrollLeft = scroll;
+      band.style.width = bandWidth + 'px';
+      band.style.transform = 'translateX(' + Math.max(0, position - box.scrollLeft) + 'px)';
+      band.style.opacity = state.loading ? '0' : '1';
+      frame = host.requestAnimationFrame(tick);
+    };
+    frame = host.requestAnimationFrame(tick);
+    return () => {
+      host.cancelAnimationFrame(frame);
+      observer?.disconnect();
+    };
+  }, [controller, text, segment]);
+  return (
+    <div className="dlv-caption-stage">
+      <div
+        ref={viewport}
+        className="dlv-caption dlv-caption-scroll"
+        title={text}
+        aria-label={label}
+      >
+        <span ref={line} className="dlv-caption-line">
+          {text}
+        </span>
+      </div>
+      <span ref={marker} className="dlv-caption-marker" aria-hidden="true" />
+    </div>
+  );
+}

package/src/modules/conversation/components/SpeechStatusBar.tsx

@@ -0,0 +1,99 @@
+import React from 'react';
+import { useLanguage } from '../../../app/client/i18n/index.js';
+import { ErrorMessage, IconButton } from '../../../shared/design-system/index.js';
+import { useConversationActions, useConversationController } from '../hooks/index.js';
+import { PlaybackControls } from './PlaybackControls.js';
+import { ScrollingSpeechCaption } from './ScrollingSpeechCaption.js';
+export function SpeechStatusBar({ controller }: { controller: any }) {
+  const { scoped: speak } = useLanguage((ctx) => ctx.speak);
+  const { scoped: commons } = useLanguage((ctx) => ctx.commons);
+  const state = useConversationController<any>(controller);
+  const { invoke, error, clearError } = useConversationActions(controller);
+  const [progress, setProgress] = React.useState<any>(null);
+  React.useEffect(() => {
+    setProgress(null);
+    if (!state.speechText || !state.speaking) return;
+    const update = () => setProgress(controller.getSpeechProgress?.() ?? null);
+    update();
+    if (state.paused) return;
+    const timer = setInterval(update, 100);
+    return () => clearInterval(timer);
+  }, [controller, state.speechText, state.speaking, state.paused]);
+  if (
+    !state.speaking &&
+    !state.paused &&
+    !state.speechRunActive &&
+    !(state.speechSegmentsRemaining > 0)
+  )
+    return null;
+  const text = state.speechText ?? '';
+  const ratio =
+    progress &&
+    Number.isFinite(progress.durationSeconds) &&
+    progress.durationSeconds > 0 &&
+    Number.isFinite(progress.positionSeconds)
+      ? Math.max(0, Math.min(1, progress.positionSeconds / progress.durationSeconds))
+      : null;
+  const loading = state.speechLoading === true && state.speaking && !state.paused;
+  const index = state.speechSegmentIndex ?? 0;
+  const total = state.speechSegmentsTotal ?? state.speechSegmentsRemaining ?? 0;
+  return (
+    <div className="dlv-bar-wrap dlv-speech-bar">
+      <div
+        className="dlv-pill dlv-speech-pill"
+        role="group"
+        aria-label={(speak as any).captions.title()}
+      >
+        <IconButton
+          label={(speak as any).playback.previous()}
+          icon="skipPrevious"
+          disabled={!state.speechHasPrevious}
+          onClick={() => invoke('previousSpeechSegment')}
+        />
+        <div className="dlv-caption-stack">
+          <ScrollingSpeechCaption
+            text={text || (speak as any).status.playing()}
+            label={(speak as any).captions.approximate()}
+            controller={controller}
+            segment={index}
+            paused={state.paused || !state.speaking}
+            loading={loading}
+          />
+          <div
+            className="dlv-caption-progress"
+            data-loading={loading ? 'true' : 'false'}
+            role="progressbar"
+            aria-hidden={!loading}
+            aria-label={
+              loading ? (speak as any).captions.loading() : (speak as any).captions.progress()
+            }
+            aria-valuemin={0}
+            aria-valuemax={100}
+            aria-valuenow={loading || ratio === null ? undefined : Math.round(ratio * 100)}
+          >
+            <span style={loading ? undefined : { width: (ratio ?? 0) * 100 + '%' }} />
+          </div>
+        </div>
+        <IconButton
+          label={(speak as any).playback.next()}
+          icon="skipNext"
+          disabled={!(state.speechSegmentsRemaining > 1)}
+          onClick={() => invoke('skipSpeechSegment')}
+        />
+        <span
+          className="dlv-speech-count"
+          aria-label={(speak as any).captions.position({ index, total })}
+        >
+          {index}/{total}
+        </span>
+        <PlaybackControls state={state} invoke={invoke} navigation={false} />
+      </div>
+      <ErrorMessage
+        error={error}
+        dismissLabel={(commons as any).dismissError()}
+        dismissText={(commons as any).dismiss()}
+        onDismiss={clearError}
+      />
+    </div>
+  );
+}

package/src/modules/conversation/components/Waveform.tsx

@@ -3,6 +3,8 @@ import React from 'react';
 export type WaveformProps = { controller: any; enabled: boolean };
 export function Waveform({ controller, enabled }: WaveformProps) {
   const ref = React.useRef<HTMLCanvasElement>(null);
+  const current = React.useRef({ controller, enabled });
+  current.current = { controller, enabled };
   React.useEffect(() => {
     const canvas = ref.current;
     const context = canvas?.getContext('2d');
@@ -18,8 +20,10 @@ export function Waveform({ controller, enabled }: WaveformProps) {
       width = Math.max(1, bounds.width);
       height = Math.max(1, bounds.height || 40);
       ratio = Math.max(1, window.devicePixelRatio || 1);
-      canvas.width = Math.round(width * ratio);
-      canvas.height = Math.round(height * ratio);
+      const nextWidth = Math.round(width * ratio);
+      const nextHeight = Math.round(height * ratio);
+      if (canvas.width !== nextWidth) canvas.width = nextWidth;
+      if (canvas.height !== nextHeight) canvas.height = nextHeight;
     }
     const observer = typeof ResizeObserver === 'function' ? new ResizeObserver(resize) : null;
     observer?.observe(canvas);
@@ -30,6 +34,7 @@ export function Waveform({ controller, enabled }: WaveformProps) {
       if (ratio !== Math.max(1, window.devicePixelRatio || 1)) resize();
       context.setTransform(ratio, 0, 0, ratio, 0, 0);
       context.clearRect(0, 0, width, height);
+      const { controller, enabled } = current.current;
       const raw = Number(controller.meter?.level?.() ?? 0);
       const level = enabled && Number.isFinite(raw) ? Math.min(1, Math.max(0, raw)) : 0;
       const color = getComputedStyle(canvas).color;
@@ -63,6 +68,6 @@ export function Waveform({ controller, enabled }: WaveformProps) {
       observer?.disconnect();
       window.removeEventListener('resize', resize);
     };
-  }, [controller, enabled]);
+  }, []);
   return <canvas ref={ref} className="dlv-wave" aria-hidden />;
 }

package/src/modules/conversation/components/conversationStatus.ts

@@ -8,9 +8,7 @@ export function resolveConversationStatus(
   if (state.answeringQuestion && state.listening) return recognition.status.awaitingAnswer();
   if (remaining) return settings.autoSend.countdown({ remaining });
   if (state.starting) return recognition.microphone.starting();
-  if (state.paused) return speak.status.paused();
-  if (state.speaking) return speak.status.playing();
-  if (state.recognizing) return recognition.status.processing();
+  if (state.recognizing || state.pendingTranscriptions > 0) return recognition.status.processing();
   if (state.listening) return recognition.status.listening();
   if (state.conversation) return commons.conversation.idle();
   return commons.status.ready();

package/src/modules/conversation/components/createConversationComponents.tsx

@@ -421,7 +421,7 @@ export function createConversationComponents(
                       : 'dsh-live-voice.commons.input.listening',
                   ),
                 })}
-                icon={state.muted ? 'micOff' : 'mic'}
+                icon="mic"
                 visibleLabel={
                   state.muted
                     ? 'dsh-live-voice.commons.input.ignoringBadge'

package/src/modules/conversation/components/index.ts

@@ -5,4 +5,5 @@ export * from './DeliveryModeButton.js';
 export * from './PlaybackControls.js';
 export * from './MicrophoneButton.js';
 export * from './SpeakButton.js';
+export * from './SpeechStatusBar.js';
 export * from './Waveform.js';

package/src/modules/conversation/components/speechCaption.ts

@@ -0,0 +1,27 @@
+/** Approximate character timing; keep the current word visible. */
+export function remainingSpeechCaption(
+  text: string,
+  progress: { positionSeconds: number; durationSeconds: number } | null,
+) {
+  if (
+    !progress ||
+    !Number.isFinite(progress.durationSeconds) ||
+    progress.durationSeconds <= 0 ||
+    !Number.isFinite(progress.positionSeconds)
+  )
+    return text;
+  const characters = Array.from(text);
+  let index = Math.min(
+    characters.length - 1,
+    Math.floor(
+      characters.length *
+        Math.max(0, Math.min(1, progress.positionSeconds / progress.durationSeconds)),
+    ),
+  );
+  if (/\s/u.test(characters[index])) {
+    while (index < characters.length - 1 && /\s/u.test(characters[index])) index++;
+  } else if (/\s/u.test(text)) {
+    while (index > 0 && !/\s/u.test(characters[index - 1])) index--;
+  }
+  return characters.slice(Math.max(0, index)).join('').trimStart();
+}

package/src/modules/conversation/models/chat.ts

@@ -15,6 +15,7 @@ export function assistantMessages(snapshot) {
         messageId: data.finalNode?.messageId,
         turn: data.turn,
         step: data.step,
+        time: data.time,
         complete: data.status !== 'running',
         interrupted: data.status === 'interrupted',
         text: (data.blocks || [])
@@ -42,7 +43,19 @@ export function latestUserSequence(snapshot) {
   );
 }
 export function addressedTurn(messages, messageId) {
-  const addressed = messages.find((message) => String(message.messageId) === String(messageId));
+  if (messageId == null) return { text: '', ids: [] };
+  const addressed = messages.find(
+    (message) => message.messageId != null && String(message.messageId) === String(messageId),
+  );
   if (!addressed) return { text: '', ids: [] };
-  return { text: addressed.text, id: addressed.id };
+  const turn = messages
+    .filter((message) => message.turn === addressed.turn)
+    .sort((a, b) => a.step - b.step);
+  return {
+    text: turn
+      .map((message) => message.text)
+      .filter((text) => text.trim())
+      .join('\n\n'),
+    id: addressed.id,
+  };
 }

package/src/modules/conversation/models/meeting.ts

@@ -0,0 +1,256 @@
+// @ts-nocheck
+import { MeetingTranscript } from './meetingTranscript.js';
+import { VoiceCoordinator } from '../../core/coordinator.ts';
+
+/** Application-owned capture; each source uses the same independent input policy. */
+export class MeetingController {
+  constructor({ composer, settings, createSource, translate, onActivity, onSpeech, stopSpeech }) {
+    this.composer = composer;
+    this.stopSpeech = stopSpeech;
+    this.inputs = new Map();
+    this.inputOverrides = new Map();
+    this.settings = settings;
+    this.createSource = createSource;
+    this.t = translate;
+    this.onActivity = onActivity;
+    this.onSpeech = onSpeech;
+    this.transcript = new MeetingTranscript(composer);
+    this.jobs = new Map();
+    this.generations = new Map();
+    this.listeners = new Set();
+    this.snapshot = {
+      active: false,
+      timestamps: false,
+      microphone: { starting: false, listening: false, pending: 0, error: null },
+      shared: { starting: false, listening: false, pending: 0, error: null },
+    };
+  }
+  getSnapshot = () => this.snapshot;
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  };
+  patch(source, next) {
+    if (source) {
+      const input = this.inputs.get(source) || (next.listening || next.starting || next.error ? this.input(source) : null);
+      const policy = {};
+      for (const key of ['starting', 'listening', 'error'])
+        if (Object.hasOwn(next, key)) policy[key] = next[key];
+      if (Object.hasOwn(next, 'pending')) policy.pendingTranscriptions = next.pending;
+      input?.patch(policy);
+    }
+    this.snapshot = {
+      ...this.snapshot,
+      ...(source ? { [source]: { ...this.snapshot[source], ...next } } : next),
+    };
+    for (const listener of this.listeners) listener();
+  }
+  input(source = 'shared') {
+    if (this.inputs.has(source)) return this.inputs.get(source);
+    // Capture remains application-owned. This coordinator owns only source policy;
+    // it never acquires the microphone or queues a second assistant playback.
+    const input = new VoiceCoordinator({
+      recognition: { stop: async () => {} }, engines: {},
+      meter: { stop: async () => {} }, settings: { ...this.settings(), microphoneEnabled: true },
+      composer: {
+        getDraft: () => this.composer.getDraft(),
+        setDraft: (text) => this.composer.setDraft(text),
+        appendFinal: (text, startedAt) => {
+          this.transcript.append(source, text, startedAt);
+          return this.composer.getDraft();
+        },
+        submit: (mode) => this.composer.submit?.(mode),
+        handleQuestionResult: (result) => this.composer.handleQuestionResult?.(result),
+        canAutoSend: () => this.composer.canAutoSend?.() !== false,
+      },
+    });
+    this.inputOverrides.set(source, {
+      sendingMode: input.getSnapshot().settings.sendingMode,
+      voiceCommandsEnabled: input.getSnapshot().settings.voiceCommandsEnabled,
+    });
+    const update = input.updateSettings.bind(input);
+    input.updateSettings = (next) => {
+      this.inputOverrides.set(source, { ...this.inputOverrides.get(source), ...next });
+      update(next);
+    };
+    input.clearError = () => this.patch(source, { error: null });
+    input.endConversation = () => this.stop(source);
+    input.stopSpeech = () => this.stopSpeech?.();
+    const updatePolicy = input.updateSettings;
+    input.updateSettings = (next) => {
+      if (Object.hasOwn(next, 'announceAssistantMessages'))
+        this.composer.updatePlaybackSettings?.({ announceAssistantMessages: next.announceAssistantMessages });
+      return updatePolicy(next);
+    };
+    input.toggleTimestamps = () => {
+      const timestamps = !input.getSnapshot().timestamps;
+      this.transcript.setSourceTimestamps(source, timestamps);
+      input.patch({ timestamps });
+    };
+    this.inputs.set(source, input);
+    return input;
+  }
+  applySettings(settings) {
+    for (const [source, input] of this.inputs)
+      VoiceCoordinator.prototype.updateSettings.call(input, {
+        ...settings, ...this.inputOverrides.get(source),
+        microphoneEnabled: !input.getSnapshot().muted,
+      });
+  }
+  composerChanged(draft) {
+    for (const input of this.inputs.values()) input.composerChanged(draft);
+  }
+  refreshDeliveryReadiness() {
+    for (const input of this.inputs.values()) input.refreshDeliveryReadiness();
+  }
+  cancelDelivery() {
+    for (const input of this.inputs.values()) input.cancelAutoSend();
+  }
+  toggleTimestamps() {
+    const enabled = !this.snapshot.timestamps;
+    this.transcript.setTimestamps(enabled);
+    this.patch(null, { timestamps: enabled });
+  }
+  async start(source, request) {
+    if (this.disposed) {
+      request
+        ?.then((stream) => stream.getTracks().forEach((track) => track.stop()))
+        .catch(() => {});
+      return;
+    }
+    this.input(source);
+    const stopping = this.stop(source);
+    const generation = this.generations.get(source);
+    await stopping;
+    if (this.disposed || this.generations.get(source) !== generation) {
+      request
+        ?.then((stream) => stream.getTracks().forEach((track) => track.stop()))
+        .catch(() => {});
+      return;
+    }
+    this.patch(null, { active: true });
+    const abort = new AbortController();
+    const job = { abort };
+    this.jobs.set(source, job);
+    const valid = () => this.jobs.get(source) === job && !abort.signal.aborted;
+    this.patch(source, { starting: true, error: null });
+    try {
+      const settings = this.settings();
+      if (settings.recognitionEngine === 'browser') throw new Error(this.t('httpRequired'));
+      const { meter, engine } = this.createSource(source, settings);
+      const input = this.input(source);
+      input.meter = meter;
+      input.updateSettings({ microphoneEnabled: true });
+      this.applySettings(settings);
+      input.patch({ conversation: true, starting: true, error: null });
+      Object.assign(job, { meter, engine });
+      if (source === 'shared') meter.provide(request);
+      meter.deviceId = settings.inputDeviceId;
+      const capability = await engine.capability();
+      if (!valid()) return;
+      if (!capability.supported) throw new Error(capability.reason || this.t('unavailable'));
+      if (!(await meter.start({ signal: abort.signal }))) {
+        if (valid()) await this.stop(source);
+        return;
+      }
+      if (!valid()) return;
+      this.transcript.setActive(source, true);
+      for (const track of meter.stream?.getTracks() || [])
+        track.addEventListener(
+          'ended',
+          () => {
+            if (valid()) void this.stop(source);
+          },
+          { once: true },
+        );
+      await engine.start({
+        lang: settings.recognitionLang,
+        signal: abort.signal,
+        onResult: ({ final, interim, startedAt }) => {
+          if (!valid()) return;
+          const accepted = this.onSpeech?.(source, final || interim) !== false;
+          if (accepted) input.onResult({ final, interim, startedAt });
+          else if (final) input.patch({ recognizing: false });
+          if (final && !interim) {
+            this.onActivity?.(source, false);
+            input.refreshDeliveryReadiness();
+          }
+        },
+        onActivity: (active) => {
+          if (!valid()) return;
+          if (active) input.cancelAutoSend({ preserveIntent: true });
+          input.patch({ recognizing: active });
+          this.onActivity?.(source, active);
+          input.refreshDeliveryReadiness();
+        },
+        onProcessingChange: ({ pending }) => {
+          if (!valid()) return;
+          input.patch({ pendingTranscriptions: pending });
+          this.patch(source, { pending });
+          if (pending) input.cancelAutoSend({ preserveIntent: true });
+          else if (!input.getSnapshot().muted) input.maybeScheduleAutoSend();
+        },
+        onError: (error) => {
+          if (valid()) {
+            this.patch(source, { error: this.t('failed') });
+            void this.stop(source);
+          }
+        },
+      });
+      if (valid()) {
+        input.patch({ starting: false, listening: true });
+        this.patch(source, { starting: false, listening: true });
+      }
+    } catch (error) {
+      if (valid()) {
+        this.patch(source, {
+          error:
+            source === 'shared' && error.message === 'No shared audio track was returned.'
+              ? this.t('noAudio')
+              : error.message === this.t('httpRequired')
+                ? error.message
+                : this.t('failed'),
+        });
+        await this.stop(source);
+      }
+    } finally {
+      if (!valid()) {
+        await job.engine?.stop();
+        await job.meter?.stop();
+      }
+      if (source === 'shared' && !job.meter?.stream)
+        request
+          ?.then((stream) => stream.getTracks().forEach((track) => track.stop()))
+          .catch(() => {});
+    }
+  }
+  async stop(source) {
+    this.generations.set(source, (this.generations.get(source) || 0) + 1);
+    const job = this.jobs.get(source);
+    this.jobs.delete(source);
+    const input = this.inputs.get(source);
+    input?.cancelAutoSend();
+    input?.patch({ conversation: false, starting: false, listening: false, recognizing: false, pendingTranscriptions: 0 });
+    this.onActivity?.(source, false);
+    job?.abort.abort();
+    this.transcript.setActive(source, false);
+    this.patch(source, { starting: false, listening: false, pending: 0 });
+    await job?.engine?.stop();
+    await job?.meter?.stop();
+  }
+  async end() {
+    await Promise.all(['microphone', 'shared'].map((source) => this.stop(source)));
+    this.transcript.reset();
+    this.patch(null, { active: false });
+  }
+  async dispose() {
+    this.disposed = true;
+    await this.end();
+    for (const input of this.inputs.values()) {
+      input.cancelAutoSend();
+      input.disposed = true;
+      input.listeners.clear();
+    }
+    this.listeners.clear();
+  }
+}

package/src/modules/conversation/models/meetingTranscript.ts

@@ -0,0 +1,63 @@
+export type MeetingSource = 'microphone' | 'shared';
+
+/** One composer writer; independent recognizers deliver final chunks in arrival order. */
+export class MeetingTranscript {
+  private active = new Set<MeetingSource>();
+  private last: MeetingSource | null = null;
+  private expected: string | null = null;
+  private timestamps = false;
+  private sourceTimestamps = new Map<MeetingSource, boolean>();
+  setSourceTimestamps(source: MeetingSource, enabled: boolean) {
+    if (this.sourceTimestamps.get(source) === enabled) return;
+    this.sourceTimestamps.set(source, enabled);
+    this.last = null;
+  }
+  setTimestamps(enabled: boolean) {
+    this.timestamps = enabled;
+    this.last = null;
+  }
+  constructor(private composer: { getDraft(): string; setDraft(text: string): void }) {}
+  setActive(source: MeetingSource, enabled: boolean) {
+    if (enabled) this.active.add(source);
+    else this.active.delete(source);
+    this.last = null;
+  }
+  append(source: MeetingSource, text: string, startedAt?: number) {
+    const chunk = text.trim();
+    if (!chunk || !this.active.has(source)) return;
+    const draft = this.composer.getDraft();
+    if (draft !== this.expected) this.last = null;
+    const labelled = this.active.size > 1;
+    const timestamps = this.sourceTimestamps.get(source) ?? this.timestamps;
+    const changed = (labelled || timestamps) && this.last !== source;
+    const date = new Date(Number.isFinite(startedAt) ? startedAt! : Date.now());
+    const pad = (value: number) => String(value).padStart(2, '0');
+    const stamp =
+      timestamps && changed
+        ? '[' +
+          date.getFullYear() +
+          '/' +
+          pad(date.getMonth() + 1) +
+          '/' +
+          pad(date.getDate()) +
+          ' ' +
+          pad(date.getHours()) +
+          ':' +
+          pad(date.getMinutes()) +
+          ':' +
+          pad(date.getSeconds()) +
+          '] '
+        : '';
+    const prefix = changed ? stamp + (labelled ? (source === 'microphone' ? 'Me: ' : 'Them: ') : '') : '';
+    const separator = draft ? (changed ? '\n\n' : '\n') : '';
+    const next = draft + separator + prefix + chunk;
+    this.composer.setDraft(next);
+    this.expected = next;
+    this.last = labelled || timestamps ? source : null;
+  }
+  reset() {
+    this.active.clear();
+    this.last = null;
+    this.expected = null;
+  }
+}

package/src/modules/core/ARCHITECTURE.md

@@ -2,4 +2,4 @@
 
 `core` owns policy and reusable voice-domain state, not DSH slot/route registration or provider-specific presentation. `coordinator.ts` serializes input transitions, owns conversation state and speech queues, and invalidates stale async work with generations. `ownership.ts` arbitrates microphone and speaker use between sessions and Settings self-tests. `transcript.ts` enforces append-only final recognition text (interim hypotheses never own or rewrite composer content), `microphone.ts` manages capture and activity, `filters.ts` handles voice commands and speech text filtering, and `settings.ts` normalizes persisted values and defaults.
 
-The `qwen/` subtree contains shared Qwen host configuration and its settings UI; recognition and speaking adapters live in their respective modules. Keep the client/host dependency graphs separate. Preserve the persisted `dsh-live-voice.settings` key and normalization compatibility. Distinguish capture, recognition, playback, and generation; do not conflate pausing with cancellation or resume obsolete speech after a new turn. Consult [voice lifecycle](../../../docs/VOICE-LIFECYCLE.md) for expected transitions.
+The `qwen/` subtree contains shared Qwen host configuration and its settings UI; recognition and speaking adapters live in their respective modules. Keep the client/host dependency graphs separate. Preserve the persisted `dsh-live-voice.settings` key and normalization compatibility. Distinguish capture, recognition, playback, and generation; do not conflate pausing with cancellation or resume obsolete speech after a new turn. Consult [voice lifecycle](../../../../../docs/VOICE-LIFECYCLE.md) for expected transitions.