elanous 0.2.0 → 0.2.4

package/src/voice/channel-adapters/discord-voice-adapter.ts

@@ -1,202 +0,0 @@
-// X9 (2026-04-30) — Discord voice message attachment adapter.
-//
-// Discord users can send voice notes / audio attachments inside text
-// channels and DMs. This adapter turns those files into transcripts
-// and, optionally, synthesized voice replies. Unlike the Telegram
-// adapter, Discord's product flavor is text-first: callers typically
-// keep the assistant transcript in the channel and may add a voice
-// attachment as a second artifact rather than replacing text entirely.
-
-import { spawn } from 'node:child_process';
-import { debug } from '../../debug/log.js';
-import type { STTProvider } from '../stt-provider.js';
-import type { TTSProvider } from '../tts/tts-provider.js';
-import {
-  generateVoiceMessageReply,
-  normalizeVoiceMessageReplyMode,
-  transcribeVoiceMessageInput,
-  type VoiceMessageCodec,
-  type VoiceMessageReplyMode,
-} from './voice-message-core.js';
-
-export type DiscordVoiceReplyMode = VoiceMessageReplyMode;
-
-export interface DiscordVoiceTranscriptResult {
-  transcript: string;
-  language?: string;
-  durationMs?: number;
-}
-
-export interface DiscordVoiceReply {
-  text: string;
-  voiceAttachment: Buffer | null;
-}
-
-export interface DiscordVoiceCodec extends VoiceMessageCodec {}
-
-export interface DiscordVoiceAttachmentInfo {
-  filename?: string;
-  contentType?: string;
-}
-
-export interface DiscordVoiceAdapter {
-  readonly available: boolean;
-  readonly unavailableReason: string | null;
-  readonly replyMode: DiscordVoiceReplyMode;
-  transcribeAttachment(
-    input: Buffer,
-    attachment?: DiscordVoiceAttachmentInfo,
-    opts?: { language?: string },
-  ): Promise<DiscordVoiceTranscriptResult>;
-  generateReply(replyText: string, opts: { fromVoice: boolean }): Promise<DiscordVoiceReply>;
-}
-
-export class DiscordVoiceUnavailableError extends Error {
-  constructor(hint: string) {
-    super(`Discord voice message unavailable — ${hint}`);
-    this.name = 'DiscordVoiceUnavailableError';
-  }
-}
-
-interface SoxBinarySpec {
-  binaryPath?: string;
-}
-
-export function createSoxDiscordVoiceCodec(spec: SoxBinarySpec = {}): DiscordVoiceCodec {
-  const bin = spec.binaryPath ?? 'sox';
-  return {
-    inputToPcm16k(input) {
-      const inputType = sniffDiscordInputType(input);
-      return runSoxConversion(bin, input, [
-        '-q',
-        '-t', inputType, '-',
-        '-t', 'raw', '-r', '16000', '-e', 'signed', '-b', '16', '-c', '1',
-        '-',
-      ]);
-    },
-    pcm24kToOutput(pcm) {
-      return runSoxConversion(bin, pcm, [
-        '-q',
-        '-t', 'raw', '-r', '24000', '-e', 'signed', '-b', '16', '-c', '1', '-',
-        '-t', 'ogg', '-C', '-1',
-        '-',
-      ]);
-    },
-  };
-}
-
-function sniffDiscordInputType(input: Buffer): 'ogg' | 'wav' | 'mp3' | 'flac' {
-  if (input.byteLength >= 4) {
-    const head4 = input.subarray(0, 4).toString('ascii');
-    if (head4 === 'OggS') return 'ogg';
-    if (head4 === 'RIFF') return 'wav';
-    if (head4 === 'fLaC') return 'flac';
-    if (head4 === 'ID3\x04' || head4.startsWith('ID3')) return 'mp3';
-  }
-  if (input.byteLength >= 2 && input[0] === 0xff && (input[1] & 0xe0) === 0xe0) {
-    return 'mp3';
-  }
-  return 'ogg';
-}
-
-async function runSoxConversion(bin: string, input: Buffer, args: string[]): Promise<Buffer> {
-  return new Promise<Buffer>((resolve, reject) => {
-    const child = spawn(bin, args, { stdio: ['pipe', 'pipe', 'pipe'] });
-    const chunks: Buffer[] = [];
-    let stderr = '';
-    child.stdout.on('data', (c: Buffer) => chunks.push(c));
-    child.stderr.on('data', (c: Buffer) => { stderr += c.toString(); });
-    child.on('error', reject);
-    child.on('close', (code) => {
-      if (code === 0) {
-        resolve(Buffer.concat(chunks));
-      } else {
-        reject(new Error(`sox exited with code ${code}: ${stderr.trim()}`));
-      }
-    });
-    child.stdin.end(input);
-  });
-}
-
-export interface DiscordVoiceAdapterOpts {
-  sttProvider: STTProvider | null | undefined;
-  ttsProvider?: TTSProvider | null | undefined;
-  replyMode?: DiscordVoiceReplyMode;
-  codec?: DiscordVoiceCodec;
-  voiceLanguage?: string;
-}
-
-export function createDiscordVoiceAdapter(
-  opts: DiscordVoiceAdapterOpts,
-): DiscordVoiceAdapter {
-  const replyMode: DiscordVoiceReplyMode = opts.replyMode ?? 'auto';
-  const codec = opts.codec ?? createSoxDiscordVoiceCodec();
-
-  if (!opts.sttProvider) {
-    const reason = 'sttProvider not supplied — Discord voice message path requires an STT provider';
-    if (debug.enabled)
-      debug.log('voice.discord.msg', 'unavailable', { reason });
-    return {
-      available: false,
-      unavailableReason: reason,
-      replyMode,
-      transcribeAttachment: () => Promise.reject(new DiscordVoiceUnavailableError(reason)),
-      generateReply: () => Promise.reject(new DiscordVoiceUnavailableError(reason)),
-    };
-  }
-
-  const stt = opts.sttProvider;
-  const tts = opts.ttsProvider ?? null;
-
-  async function transcribeAttachment(
-    input: Buffer,
-    _attachment?: DiscordVoiceAttachmentInfo,
-    opts2: { language?: string } = {},
-  ): Promise<DiscordVoiceTranscriptResult> {
-    if (debug.enabled)
-      debug.log('voice.discord.msg', 'transcribe.begin', { bytes: input.byteLength });
-    const lang = opts2.language ?? opts.voiceLanguage;
-    const result = await transcribeVoiceMessageInput(
-      codec,
-      stt,
-      input,
-      lang ? { language: lang } : {},
-    );
-    if (debug.enabled)
-      debug.log('voice.discord.msg', 'transcribe.ok', {
-        chars: result.transcript.length,
-        language: result.language ?? null,
-      });
-    return result;
-  }
-
-  async function generateReply(
-    replyText: string,
-    opts2: { fromVoice: boolean },
-  ): Promise<DiscordVoiceReply> {
-    if (debug.enabled && tts)
-      debug.log('voice.discord.msg', 'reply.tts.begin', { chars: replyText.length });
-    const reply = await generateVoiceMessageReply(
-      codec,
-      tts,
-      replyMode,
-      replyText,
-      opts2,
-    );
-    if (debug.enabled && reply.voiceBlob)
-      debug.log('voice.discord.msg', 'reply.tts.ok', { bytes: reply.voiceBlob.byteLength });
-    return { text: reply.text, voiceAttachment: reply.voiceBlob };
-  }
-
-  return {
-    available: true,
-    unavailableReason: null,
-    replyMode,
-    transcribeAttachment,
-    generateReply,
-  };
-}
-
-export function normalizeDiscordVoiceReplyMode(v: unknown): DiscordVoiceReplyMode {
-  return normalizeVoiceMessageReplyMode(v);
-}

package/src/voice/voice-pwa-dispatch.ts

@@ -1,245 +0,0 @@
-// PR-S1V.16 (sprint 22 §B · 2026-04-30) — PWA voice onFinalTranscript
-// dispatcher.
-//
-// Glues the §1.1 streaming-STT singleton + §1.2 PWA TTS bridge + §C
-// session emit hooks together by:
-//
-//   1. Registering the PWA-minted sessionId in the daemon's session
-//      history (idempotent — `register()` is a no-op when the id is
-//      already known).
-//   2. Building the LLM message array from the history's running tail
-//      + the new user message.
-//   3. Calling the injected `llmStream` (bound to the daemon's chosen
-//      provider) and pushing each chunk into the TTS bridge as it
-//      arrives — chunk-streaming is the explicit recommendation in
-//      the §B HANDOFF since `history.onAppend` already provides
-//      fan-out and we don't want to wait for the whole turn before
-//      synthesis starts.
-//   4. Persisting the user + assistant messages to history once the
-//      stream resolves so subsequent turns see the full context.
-//   5. Flushing the TTS bridge so the buffered text synthesises into
-//      a PCM blob and emits to the browser via the bridge's attached
-//      emitter (wired in §C's onSessionOpen hook).
-//
-// Errors are swallowed at this layer so a transient LLM/TTS failure
-// can't kill the WS endpoint — debug.log captures every branch for
-// triage. The dispatcher is provider-agnostic: tests inject a fake
-// `llmStream` and the daemon boot wires the real `streamLLM`.
-
-import { debug } from '../debug/log.js';
-import { buildTurnOutputTextBlocks } from '../input/turn-output-block.js';
-import { selectTurnOutputTextForSink } from '../input/turn-output-sink-registry.js';
-import type { LLMMessage } from '../llm.js';
-import type { PwaTtsBridge } from './voice-pwa-tts-bridge.js';
-
-/** Subset of `DaemonSessionHistory` the dispatcher actually uses.
- *  Keeping the surface narrow lets tests use a 30-line fake instead
- *  of standing up the disk-backed singleton. */
-export interface PwaDispatchHistory {
-  has(sessionId: string): boolean;
-  register(sessionId: string, initialMessages?: LLMMessage[]): void;
-  get(sessionId: string): LLMMessage[];
-  append(sessionId: string, msgs: LLMMessage[]): void;
-}
-
-/** LLM streaming primitive — matches `streamLLM` in `src/llm.ts` minus
- *  the optional `opts` argument (caller binds defaults). */
-export type PwaDispatchLLMStream = (
-  messages: LLMMessage[],
-  onChunk: (delta: string, full: string) => void,
-) => Promise<string>;
-
-export interface PwaDispatchDeps {
-  history: PwaDispatchHistory;
-  ttsBridge: PwaTtsBridge | null;
-  llmStream: PwaDispatchLLMStream;
-  /** Optional system prompt prepended once at session-register time
-   *  (only when the session is newly minted). When omitted, no
-   *  system message is seeded — the LLM provider's own default
-   *  applies. */
-  systemPrompt?: string;
-  /** 2026-04-30 — receives assistant LLM response chunks for live
-   *  display in the browser. Daemon boot wires this to
-   *  `session.emitTranscript({kind:'assistant', text})` so the PWA
-   *  can render the response text alongside the synthesized audio.
-   *  When omitted, transcripts are dropped (audio-only path). */
-  emitAssistantChunk?: (sessionId: string, chunk: string) => void;
-  /** 2026-04-30 — late-bound lookup for the dashboard voice-input-host.
-   *  In `tui-bridge` dispatch mode the dispatcher calls
-   *  `dictateTranscript(text)` so the user's phone transcript appears
-   *  in the focused dashboard input. Returns null when the dashboard
-   *  isn't running in this process — the dispatcher then short-
-   *  circuits with `skippedReason: 'tui-bridge-not-wired'`. */
-  getVoiceInputHost?: () => {
-    dictateTranscript: (text: string) => boolean | Promise<boolean>;
-  } | null;
-}
-
-export interface PwaDispatchOutcome {
-  /** True when the dispatcher pushed a turn through the LLM. False
-   *  when it short-circuited (mode is tui-bridge, or bridge missing,
-   *  or text was empty). */
-  dispatched: boolean;
-  /** Number of characters in the assistant response. */
-  responseChars: number;
-  /** Reason string when `dispatched === false`. */
-  skippedReason?: string;
-}
-
-/**
- * Run a single PWA voice turn from a final transcript.
- *
- * - `dispatchMode === 'tui-bridge'`: short-circuits with `skippedReason
- *   = 'tui-bridge-deferred'`. The voice-input-host bridge wire is
- *   dashboard-scope and lands on a separate sprint.
- * - `dispatchMode === 'daemon-direct'`: runs the LLM stream and
- *   pipes chunks into the TTS bridge. When `ttsBridge` is null the
- *   dispatcher still updates history but skips synthesis (returns
- *   `skippedReason = 'no-tts-bridge'`).
- */
-export async function dispatchPwaFinalTranscript(
-  sessionId: string,
-  text: string,
-  dispatchMode: 'daemon-direct' | 'tui-bridge',
-  deps: PwaDispatchDeps,
-): Promise<PwaDispatchOutcome> {
-  if (debug.enabled) {
-    // Capture the actual STT-produced transcript text so
-    // language-misdetection (e.g. openai-realtime-stt returning
-    // Japanese for Korean speech) is visible in log/debug-*.log
-    // — added 2026-05-05 after a Korean/Japanese root-cause hunt.
-    debug.log('voice.pwa.dispatch', 'final.received', {
-      sessionId, chars: text.length, mode: dispatchMode, text,
-    });
-  }
-
-  const trimmed = text.trim();
-  if (!trimmed) {
-    return { dispatched: false, responseChars: 0, skippedReason: 'empty-transcript' };
-  }
-
-  if (dispatchMode === 'tui-bridge') {
-    const host = deps.getVoiceInputHost?.() ?? null;
-    if (!host) {
-      if (debug.enabled) {
-        debug.log('voice.pwa.dispatch', 'tui-bridge.not-wired', {
-          sessionId,
-          hint: 'dashboard runtime not active in this process — switch to daemon-direct',
-        });
-      }
-      return {
-        dispatched: false,
-        responseChars: 0,
-        skippedReason: 'tui-bridge-not-wired',
-      };
-    }
-    let landed: boolean;
-    try {
-      landed = await host.dictateTranscript(trimmed);
-    } catch (err) {
-      if (debug.enabled) {
-        debug.log('voice.pwa.dispatch', 'tui-bridge.dictate.error', {
-          sessionId, err: err instanceof Error ? err.message : String(err),
-        }, { level: 'error' });
-      }
-      return {
-        dispatched: false,
-        responseChars: 0,
-        skippedReason: 'tui-bridge-dictate-error',
-      };
-    }
-    if (debug.enabled) {
-      debug.log('voice.pwa.dispatch', 'tui-bridge.dispatched', {
-        sessionId, chars: trimmed.length, landed,
-      });
-    }
-    return {
-      dispatched: landed,
-      responseChars: 0,
-      ...(landed ? {} : { skippedReason: 'tui-bridge-no-input-target' }),
-    };
-  }
-
-  // Register session if needed — register() is idempotent so this is
-  // safe to always call on the cold path; the `has()` guard just
-  // avoids an extra noop write to disk under a hot session.
-  if (!deps.history.has(sessionId)) {
-    const seed: LLMMessage[] = deps.systemPrompt
-      ? [{ role: 'system', content: deps.systemPrompt }]
-      : [];
-    deps.history.register(sessionId, seed);
-    if (debug.enabled) {
-      debug.log('voice.pwa.dispatch', 'session.registered', {
-        sessionId, seeded: seed.length,
-      });
-    }
-  }
-
-  const userMsg: LLMMessage = { role: 'user', content: trimmed };
-  const messages: LLMMessage[] = [...deps.history.get(sessionId), userMsg];
-  if (debug.enabled) {
-    // What actually goes into the LLM (role + first 200 chars per
-    // message). Distinguishes STT misdetection from a missing system
-    // prompt as the cause of off-language replies.
-    debug.log('voice.pwa.dispatch', 'llm.input', {
-      sessionId,
-      messages: messages.map((m) => ({
-        role: m.role,
-        content: typeof m.content === 'string'
-          ? m.content.slice(0, 200)
-          : '[non-string]',
-      })),
-    });
-  }
-
-  let assistantText = '';
-  try {
-    assistantText = await deps.llmStream(messages, (delta) => {
-      if (!delta) return;
-      if (deps.ttsBridge) {
-        deps.ttsBridge.pushChunk(sessionId, delta);
-      }
-      if (deps.emitAssistantChunk) {
-        const fanoutText = selectTurnOutputTextForSink(
-          'fan-out-pwa',
-          buildTurnOutputTextBlocks(delta),
-        ) ?? delta;
-        try { deps.emitAssistantChunk(sessionId, fanoutText); }
-        catch { /* isolation — never let UI bridge break the LLM stream */ }
-      }
-    });
-  } catch (err) {
-    if (debug.enabled) {
-      debug.log('voice.pwa.dispatch', 'llm.error', {
-        sessionId, err: err instanceof Error ? err.message : String(err),
-      }, { level: 'error' });
-    }
-    return { dispatched: false, responseChars: 0, skippedReason: 'llm-error' };
-  }
-
-  // Persist user + assistant once the stream completes — keeps
-  // history in sync with the just-finished turn so the next final
-  // sees prior context.
-  deps.history.append(sessionId, [
-    userMsg,
-    { role: 'assistant', content: assistantText },
-  ]);
-
-  if (deps.ttsBridge) {
-    await deps.ttsBridge.flush(sessionId);
-  }
-
-  if (debug.enabled) {
-    debug.log('voice.pwa.dispatch', 'turn.done', {
-      sessionId,
-      assistantChars: assistantText.length,
-      ttsBridge: deps.ttsBridge ? 'wired' : 'absent',
-    });
-  }
-
-  return {
-    dispatched: true,
-    responseChars: assistantText.length,
-    ...(deps.ttsBridge ? {} : { skippedReason: 'no-tts-bridge' }),
-  };
-}

package/src/window-picker-modal.ts

@@ -1,135 +0,0 @@
-// Window picker modal — T2-P4.
-//
-// Sibling of session-picker-modal.ts. Wraps createSearchModal with a
-// list of live VirtualWindow entries so the user can fuzz-match a
-// title and press Enter to switch to it. Bound to the VW navigation
-// chord's onPicker callback (^B 0) but also reusable from any slash
-// command.
-//
-// Label format mirrors the terminal-session picker for visual
-// consistency:
-//
-//   ● win:2  project-build        3 panes   5m   (title)
-//   ○ win:3  notes                1 pane   12m
-//
-//   ●/○  foreground marker
-//   win:N  window id (stable)
-//   N panes  pane count (pluralized)
-//   relative-age
-//   title
-//
-// Accept calls onAccept(window) — typical host behavior is
-// registry.switchTo(window.id). Cancel disposes the modal.
-
-import type { SearchItem, SearchModalHandle } from './chat/search/modal.js';
-import type { ThemeTokens } from './theme/tokens.js';
-import type { ModalBounds } from './display/modal-stack.js';
-import type { WindowRegistry } from './virtual-windows/window-registry.js';
-import type { VirtualWindow } from './virtual-windows/virtual-window.js';
-import { filterPickerItemsByLabel } from './ui/chrome/picker-query.js';
-import { createVwFilterPickerModal } from './ui/vw-filter-picker-modal.js';
-import {
-  searchItemsToPickerSpec,
-  type PickerSearchItem,
-  type PickerSpec,
-} from './expression/index.js';
-
-export interface OpenWindowPickerOpts {
-  registry: WindowRegistry;
-  bounds: ModalBounds;
-  width: number;
-  maxVisible?: number;
-  /** Called when the user picks a window. Default action is
-   *  registry.switchTo(window.id); callers may override to do
-   *  close / inspect / rename instead. */
-  onAccept: (window: VirtualWindow | 'main') => void;
-  onCancel?: () => void;
-  theme?: ThemeTokens;
-}
-
-export function createWindowPickerModal(opts: OpenWindowPickerOpts): SearchModalHandle {
-  let selectedPayload: string | number = 'main';
-  const items = (): SearchItem[] => {
-    const wins = opts.registry.list();
-    return [
-      {
-        label: formatMainLabel(selectedPayload === 'main'),
-        payload: 'main',
-      },
-      ...wins.map((w): SearchItem => ({
-        label: formatWindowLabel(w, selectedPayload === w.id),
-        payload: w.id,
-      })),
-    ];
-  };
-
-  return createVwFilterPickerModal({
-    id: `window-picker:${Date.now().toString(36)}`,
-    bounds: opts.bounds,
-    title: 'Windows',
-    width: opts.width,
-    maxVisible: opts.maxVisible ?? 9,
-    primaryActionLabel: 'switch',
-    cancelActionLabel: 'cancel',
-    onQuery: (q) => {
-      const all = items();
-      return filterPickerItemsByLabel(all, q, (it) => String(it.label ?? ''));
-    },
-    onAccept: (item) => {
-      if (item.payload === 'main') {
-        opts.onAccept('main');
-        return;
-      }
-      const w = opts.registry.get(Number(item.payload));
-      if (w) opts.onAccept(w);
-    },
-    onCancel: opts.onCancel,
-    theme: opts.theme,
-    requeryOnSelectionChange: true,
-    onSelectionChange: (item) => {
-      selectedPayload =
-        item?.payload === 'main' || typeof item?.payload === 'number'
-          ? item.payload
-          : 'main';
-    },
-  });
-}
-
-function formatMainLabel(isForeground: boolean): string {
-  const stateGlyph = isForeground ? '●' : '○';
-  return `  ${stateGlyph} Main`;
-}
-
-function formatWindowLabel(w: VirtualWindow, isForeground: boolean): string {
-  const stateGlyph = isForeground ? '●' : '○';
-  const title = w.title.length > 32 ? w.title.slice(0, 31) + '…' : w.title;
-  return `  ${stateGlyph} ${title}`;
-}
-
-/** Build an expression `PickerSpec` describing the live virtual
- *  windows. Pure helper — see `buildSessionPickerSpec` for shape +
- *  rationale.
- *
- *  Each item's `description` carries the pane count + foreground
- *  marker as plain text so SR users learn the same signal the visual
- *  glyph conveys. Adapter strips ANSI from `formatWindowLabel`.
- *
- *  2026-04-28 (Pick A PR-S2) — picker family a11y integration. */
-export function buildWindowPickerSpec(registry: WindowRegistry): PickerSpec {
-  const wins = registry.list();
-  const current = registry.current();
-  const items: PickerSearchItem[] = wins.map((w) => {
-    const panes = w.listPanes();
-    const paneLabel = panes.length === 1 ? '1 pane' : `${panes.length} panes`;
-    const fg = w === current ? 'foreground' : 'background';
-    return {
-      label: formatWindowLabel(w, w === current),
-      payload: String(w.id),
-      description: `${fg} · ${paneLabel}`,
-    };
-  });
-  return searchItemsToPickerSpec(items, {
-    id: 'window-picker',
-    title: 'Virtual windows',
-  });
-}