@dev-anywhere/relay 0.4.84 → 0.5.0

package/dist/{chunk-46NK2URF.js → chunk-2L3L5F4J.js}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/server.ts
-import express from "express";
-import { existsSync as existsSync2 } from "fs";
+import express2 from "express";
+import { existsSync as existsSync3 } from "fs";
 import { createServer } from "http";
 import { homedir } from "os";
 import { dirname as dirname3, resolve } from "path";
@@ -468,13 +468,56 @@ var VoiceSummaryReasonSchema = z7.enum([
   "approval"
 ]);
 
+// ../../packages/shared/dist/schemas/voice-stream.js
+import { z as z8 } from "zod";
+var VoiceAsrAudioEncodingSchema = z8.enum(["pcm_s16le", "mulaw"]);
+var VoiceAsrStartMessageSchema = z8.object({
+  type: z8.literal("start"),
+  sessionId: z8.string().min(1),
+  attemptId: z8.string().min(1),
+  sampleRate: z8.number().int().positive(),
+  encoding: VoiceAsrAudioEncodingSchema
+});
+var VoiceAsrStopMessageSchema = z8.object({
+  type: z8.literal("stop"),
+  attemptId: z8.string().min(1)
+});
+var VoiceAsrClientMessageSchema = z8.discriminatedUnion("type", [
+  VoiceAsrStartMessageSchema,
+  VoiceAsrStopMessageSchema
+]);
+var VoiceAsrServerMessageSchema = z8.discriminatedUnion("type", [
+  z8.object({ type: z8.literal("ready"), attemptId: z8.string().min(1) }),
+  z8.object({
+    type: z8.literal("audio_ack"),
+    attemptId: z8.string().min(1),
+    encodedBytes: z8.number().int().nonnegative(),
+    pcmBytes: z8.number().int().nonnegative(),
+    chunks: z8.number().int().nonnegative()
+  }),
+  z8.object({ type: z8.literal("partial"), attemptId: z8.string().min(1), text: z8.string() }),
+  z8.object({ type: z8.literal("final"), attemptId: z8.string().min(1), text: z8.string() }),
+  z8.object({
+    type: z8.literal("closed"),
+    attemptId: z8.string().min(1),
+    code: z8.number().int().optional(),
+    reason: z8.string().optional()
+  }),
+  z8.object({
+    type: z8.literal("error"),
+    attemptId: z8.string().min(1),
+    error: z8.string().optional(),
+    errorCode: z8.string().optional()
+  })
+]);
+
 // ../../packages/shared/dist/builders/index.js
 function serializeControl(msg) {
   return JSON.stringify(msg);
 }
 
 // ../../packages/shared/dist/schemas/relay-control.js
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // ../../packages/shared/dist/constants/relay-errors.js
 var RelayErrorCode = {
@@ -501,75 +544,75 @@ var ControlErrorCode = {
 };
 
 // ../../packages/shared/dist/schemas/relay-control.js
-var ProxyInfoSchema = z8.object({
+var ProxyInfoSchema = z9.object({
   proxyId: IdSchema,
-  name: z8.string().optional(),
-  online: z8.boolean(),
-  sessions: z8.array(z8.string()).optional()
+  name: z9.string().optional(),
+  online: z9.boolean(),
+  sessions: z9.array(z9.string()).optional()
 });
-var RelayClientInfoSchema = z8.object({
+var RelayClientInfoSchema = z9.object({
   clientId: IdSchema,
   proxyId: IdSchema.optional(),
-  connectedAt: z8.number().int().nonnegative(),
-  current: z8.boolean().optional(),
-  userAgent: z8.string().optional(),
-  platform: z8.string().optional(),
-  maxTouchPoints: z8.number().int().nonnegative().optional(),
-  browserName: z8.string().min(1),
-  osName: z8.string().min(1),
-  deviceKind: z8.enum(["desktop", "tablet", "phone", "unknown"]),
-  remoteAddress: z8.string().optional()
+  connectedAt: z9.number().int().nonnegative(),
+  current: z9.boolean().optional(),
+  userAgent: z9.string().optional(),
+  platform: z9.string().optional(),
+  maxTouchPoints: z9.number().int().nonnegative().optional(),
+  browserName: z9.string().min(1),
+  osName: z9.string().min(1),
+  deviceKind: z9.enum(["desktop", "tablet", "phone", "unknown"]),
+  remoteAddress: z9.string().optional()
 });
-var AgentCliAvailabilitySchema = z8.object({
-  available: z8.boolean(),
-  command: z8.string().optional(),
-  error: z8.string().optional(),
-  suggestions: z8.array(z8.string()).optional()
+var AgentCliAvailabilitySchema = z9.object({
+  available: z9.boolean(),
+  command: z9.string().optional(),
+  error: z9.string().optional(),
+  suggestions: z9.array(z9.string()).optional()
 });
-var AgentCliStatusSchema = z8.object({
+var AgentCliStatusSchema = z9.object({
   claude: AgentCliAvailabilitySchema,
   codex: AgentCliAvailabilitySchema
 });
-var DirEntrySchema = z8.object({ name: z8.string(), isDir: z8.boolean() });
-var FileTreeGroupSchema = z8.object({
-  path: z8.string(),
-  entries: z8.array(DirEntrySchema)
+var DirEntrySchema = z9.object({ name: z9.string(), isDir: z9.boolean() });
+var FileTreeGroupSchema = z9.object({
+  path: z9.string(),
+  entries: z9.array(DirEntrySchema)
 });
-var CommandEntrySchema = z8.object({
-  name: z8.string(),
-  description: z8.string(),
-  argumentHint: z8.string().optional(),
-  source: z8.string()
+var CommandEntrySchema = z9.object({
+  name: z9.string(),
+  description: z9.string(),
+  argumentHint: z9.string().optional(),
+  source: z9.string()
 });
-var HistorySessionSchema = z8.object({
-  id: z8.string(),
-  title: z8.string(),
-  projectDir: z8.string(),
-  updatedAt: z8.number(),
-  provider: z8.enum(providerValues).optional(),
-  preferredMode: z8.enum(sessionModeValues).optional()
+var HistorySessionSchema = z9.object({
+  id: z9.string(),
+  title: z9.string(),
+  projectDir: z9.string(),
+  updatedAt: z9.number(),
+  provider: z9.enum(providerValues).optional(),
+  preferredMode: z9.enum(sessionModeValues).optional()
 });
-var SessionHistoryMessageSchema = z8.object({
-  role: z8.enum(["user", "assistant", "system"]),
-  text: z8.string(),
-  timestamp: z8.number().optional(),
-  cursor: z8.string().optional()
+var SessionHistoryMessageSchema = z9.object({
+  role: z9.enum(["user", "assistant", "system"]),
+  text: z9.string(),
+  timestamp: z9.number().optional(),
+  cursor: z9.string().optional()
 });
 var RequestIdShape = { requestId: IdSchema.optional() };
 var RequiredRequestIdShape = { requestId: IdSchema };
-var ControlErrorCodeSchema = z8.enum(Object.values(ControlErrorCode));
+var ControlErrorCodeSchema = z9.enum(Object.values(ControlErrorCode));
 var RequestErrorShape = {
-  error: z8.string().optional(),
+  error: z9.string().optional(),
   errorCode: ControlErrorCodeSchema.optional()
 };
-var RemoteFileDispositionSchema = z8.enum(["inline", "download"]);
-var RemoteFileUploadKindSchema = z8.enum(["clipboard_image", "file"]);
+var RemoteFileDispositionSchema = z9.enum(["inline", "download"]);
+var RemoteFileUploadKindSchema = z9.enum(["clipboard_image", "file"]);
 function control(type, shape, directions) {
   return {
     type,
     directions: new Set(Array.isArray(directions) ? directions : directions ? [directions] : []),
-    schema: z8.object({
-      type: z8.literal(type),
+    schema: z9.object({
+      type: z9.literal(type),
       ...shape ?? {}
     })
   };
@@ -577,81 +620,81 @@ function control(type, shape, directions) {
 var relayControlDefinitions = [
   control("proxy_register", {
     proxyId: IdSchema,
-    name: z8.string().optional()
+    name: z9.string().optional()
   }),
   control("proxy_register_response", {
-    status: z8.enum(["new", "reconnected"])
+    status: z9.enum(["new", "reconnected"])
   }),
   control("proxy_list_request", RequestIdShape),
   control("proxy_list_response", {
     ...RequestIdShape,
-    proxies: z8.array(ProxyInfoSchema)
+    proxies: z9.array(ProxyInfoSchema)
   }),
   control("relay_client_list_request", RequestIdShape),
   control("relay_client_list_response", {
     ...RequestIdShape,
-    clients: z8.array(RelayClientInfoSchema)
+    clients: z9.array(RelayClientInfoSchema)
   }),
   control("relay_client_kick", { ...RequiredRequestIdShape, clientId: IdSchema }),
   control("relay_client_kick_response", {
     ...RequiredRequestIdShape,
     clientId: IdSchema,
-    success: z8.boolean(),
+    success: z9.boolean(),
     ...RequestErrorShape
   }),
   control("relay_client_kicked", {
-    reason: z8.string().optional()
+    reason: z9.string().optional()
   }),
   control("remote_file_url_request", {
     ...RequiredRequestIdShape,
     sessionId: IdSchema,
-    path: z8.string().min(1),
+    path: z9.string().min(1),
     disposition: RemoteFileDispositionSchema
   }),
   control("remote_file_url_response", {
     ...RequiredRequestIdShape,
     ...RequestErrorShape,
     sessionId: IdSchema,
-    path: z8.string().optional(),
-    success: z8.boolean(),
-    url: z8.string().optional(),
-    expiresAt: z8.number().int().nonnegative().optional()
+    path: z9.string().optional(),
+    success: z9.boolean(),
+    url: z9.string().optional(),
+    expiresAt: z9.number().int().nonnegative().optional()
   }),
   control("remote_file_metadata_request", {
     ...RequiredRequestIdShape,
     sessionId: IdSchema,
-    path: z8.string().min(1)
+    path: z9.string().min(1)
   }),
   control("remote_file_metadata_response", {
     ...RequiredRequestIdShape,
     ...RequestErrorShape,
     sessionId: IdSchema,
-    path: z8.string().optional(),
-    success: z8.boolean(),
-    mimeType: z8.string().optional(),
-    size: z8.number().int().nonnegative().optional(),
-    fileName: z8.string().optional()
+    path: z9.string().optional(),
+    success: z9.boolean(),
+    mimeType: z9.string().optional(),
+    size: z9.number().int().nonnegative().optional(),
+    fileName: z9.string().optional()
   }),
   control("remote_file_stream_request", {
     streamId: IdSchema,
     sessionId: IdSchema,
-    path: z8.string().min(1),
+    path: z9.string().min(1),
     disposition: RemoteFileDispositionSchema
   }),
   control("remote_file_stream_response", {
     ...RequestErrorShape,
     streamId: IdSchema,
     sessionId: IdSchema,
-    success: z8.boolean(),
-    path: z8.string().optional(),
-    mimeType: z8.string().optional(),
-    size: z8.number().int().nonnegative().optional(),
-    fileName: z8.string().optional()
+    success: z9.boolean(),
+    path: z9.string().optional(),
+    mimeType: z9.string().optional(),
+    size: z9.number().int().nonnegative().optional(),
+    fileName: z9.string().optional()
   }),
   control("remote_file_stream_complete", {
     ...RequestErrorShape,
     streamId: IdSchema,
-    success: z8.boolean()
+    success: z9.boolean()
   }),
   control("remote_file_stream_cancel", {
     streamId: IdSchema
@@ -660,25 +703,25 @@ var relayControlDefinitions = [
     ...RequiredRequestIdShape,
     sessionId: IdSchema,
     kind: RemoteFileUploadKindSchema,
-    fileName: z8.string().optional(),
-    mimeType: z8.string().min(1),
-    size: z8.number().int().nonnegative().optional()
+    fileName: z9.string().optional(),
+    mimeType: z9.string().min(1),
+    size: z9.number().int().nonnegative().optional()
   }),
   control("remote_file_upload_url_response", {
     ...RequiredRequestIdShape,
     ...RequestErrorShape,
     sessionId: IdSchema,
-    success: z8.boolean(),
-    uploadUrl: z8.string().optional(),
-    expiresAt: z8.number().int().nonnegative().optional()
+    success: z9.boolean(),
+    uploadUrl: z9.string().optional(),
+    expiresAt: z9.number().int().nonnegative().optional()
   }),
   control("remote_file_upload_stream_request", {
     uploadId: IdSchema,
     sessionId: IdSchema,
     kind: RemoteFileUploadKindSchema,
-    fileName: z8.string().optional(),
-    mimeType: z8.string().min(1),
-    size: z8.number().int().nonnegative().optional()
+    fileName: z9.string().optional(),
+    mimeType: z9.string().min(1),
+    size: z9.number().int().nonnegative().optional()
   }),
   control("remote_file_upload_stream_complete", {
     uploadId: IdSchema
@@ -690,19 +733,19 @@ var relayControlDefinitions = [
     ...RequestErrorShape,
     uploadId: IdSchema,
     sessionId: IdSchema,
-    success: z8.boolean(),
-    path: z8.string().optional()
+    success: z9.boolean(),
+    path: z9.string().optional()
   }),
   control("proxy_select", { ...RequestIdShape, proxyId: IdSchema }),
   control("proxy_select_response", {
     ...RequestIdShape,
-    success: z8.boolean(),
+    success: z9.boolean(),
     proxyId: IdSchema.optional(),
     ...RequestErrorShape
   }),
   control("relay_error", {
-    code: z8.enum(Object.values(RelayErrorCode)),
-    message: z8.string(),
+    code: z9.enum(Object.values(RelayErrorCode)),
+    message: z9.string(),
     // 可选 requestId: relay 把 client 发来 raw 的 requestId 字段透传回来,
     // client 侧 waitForMessage 据此把对应 pending request 立即拒掉而不必等到 timeout。
     requestId: IdSchema.optional()
@@ -721,7 +764,7 @@ var relayControlDefinitions = [
   control("voice_config_update_response", {
     ...RequestIdShape,
     ...RequestErrorShape,
-    success: z8.boolean(),
+    success: z9.boolean(),
     config: VoiceProviderConfigSchema.optional()
   }),
   control("voice_config_test", {
@@ -731,15 +774,15 @@ var relayControlDefinitions = [
   control("voice_config_test_response", {
     ...RequestIdShape,
     ...RequestErrorShape,
-    success: z8.boolean(),
-    audioBase64: z8.string().optional(),
-    audioSampleRate: z8.number().int().positive().optional(),
-    audioEncoding: z8.literal("pcm_s16le").optional(),
-    transcript: z8.string().optional()
+    success: z9.boolean(),
+    audioBase64: z9.string().optional(),
+    audioSampleRate: z9.number().int().positive().optional(),
+    audioEncoding: z9.literal("pcm_s16le").optional(),
+    transcript: z9.string().optional()
   }),
   control("voice_capabilities_request", {
     ...RequestIdShape,
-    region: z8.enum(voiceRegionValues).optional()
+    region: z9.enum(voiceRegionValues).optional()
   }),
   control("voice_capabilities_response", {
     ...RequestIdShape,
@@ -751,37 +794,37 @@ var relayControlDefinitions = [
   control("latency_web_relay_ping", RequiredRequestIdShape),
   control("latency_web_relay_pong", {
     ...RequiredRequestIdShape,
-    relayNow: z8.number().optional()
+    relayNow: z9.number().optional()
   }),
   control("latency_relay_proxy_request", RequiredRequestIdShape),
   control("latency_relay_proxy_response", {
     ...RequiredRequestIdShape,
-    success: z8.boolean(),
-    rttMs: z8.number().nonnegative().optional(),
-    error: z8.string().optional()
+    success: z9.boolean(),
+    rttMs: z9.number().nonnegative().optional(),
+    error: z9.string().optional()
   }),
   control("latency_relay_proxy_ping", {
     ...RequiredRequestIdShape,
-    relayNow: z8.number().optional()
+    relayNow: z9.number().optional()
   }),
   control("latency_relay_proxy_pong", {
     ...RequiredRequestIdShape,
-    proxyNow: z8.number().optional()
+    proxyNow: z9.number().optional()
   }),
   control("latency_web_proxy_ping", RequiredRequestIdShape, "client_to_proxy"),
-  control("latency_web_proxy_pong", { ...RequiredRequestIdShape, proxyNow: z8.number().optional() }, "proxy_to_client"),
+  control("latency_web_proxy_pong", { ...RequiredRequestIdShape, proxyNow: z9.number().optional() }, "proxy_to_client"),
   // 客户端注册协议
   control("client_register", {
     clientId: IdSchema,
-    userAgent: z8.string().optional(),
-    platform: z8.string().optional(),
-    maxTouchPoints: z8.number().int().nonnegative().optional(),
-    browserName: z8.string().min(1),
-    osName: z8.string().min(1),
-    deviceKind: z8.enum(["desktop", "tablet", "phone", "unknown"])
+    userAgent: z9.string().optional(),
+    platform: z9.string().optional(),
+    maxTouchPoints: z9.number().int().nonnegative().optional(),
+    browserName: z9.string().min(1),
+    osName: z9.string().min(1),
+    deviceKind: z9.enum(["desktop", "tablet", "phone", "unknown"])
   }),
   control("client_register_response", {
-    status: z8.enum(["restored", "proxy_offline", "new"]),
+    status: z9.enum(["restored", "proxy_offline", "new"]),
     proxyId: IdSchema.optional()
   }),
   // Proxy 离线通知
@@ -800,51 +843,51 @@ var relayControlDefinitions = [
   control("dir_list_request", {
     proxyId: IdSchema.optional(),
     ...RequestIdShape,
-    path: z8.string()
+    path: z9.string()
   }, "client_to_proxy"),
-  control("dir_list_response", { ...RequestIdShape, ...RequestErrorShape, entries: z8.array(DirEntrySchema), path: z8.string() }, "proxy_to_client"),
+  control("dir_list_response", { ...RequestIdShape, ...RequestErrorShape, entries: z9.array(DirEntrySchema), path: z9.string() }, "proxy_to_client"),
   // 目录创建请求与响应
-  control("dir_create_request", { ...RequestIdShape, path: z8.string() }, "client_to_proxy"),
+  control("dir_create_request", { ...RequestIdShape, path: z9.string() }, "client_to_proxy"),
   control("dir_create_response", {
     ...RequestIdShape,
     ...RequestErrorShape,
-    path: z8.string(),
-    success: z8.boolean()
+    path: z9.string(),
+    success: z9.boolean()
   }, "proxy_to_client"),
   // 命令列表推送，proxy 将可用命令列表推给 client
-  control("command_list_push", { commands: z8.array(CommandEntrySchema) }, "proxy_to_client"),
+  control("command_list_push", { commands: z9.array(CommandEntrySchema) }, "proxy_to_client"),
   // 文件树推送: 按目录分组, 首组 path 即为 session cwd
   // 前端直接把每组写入 tree[path], 与 dir_list_response 共享 cache slot
   control("file_tree_push", {
-    groups: z8.array(FileTreeGroupSchema)
+    groups: z9.array(FileTreeGroupSchema)
   }, "proxy_to_client"),
   // 会话列表请求与权限模式变更
   control("session_list", void 0, ["client_to_proxy", "proxy_to_client"]),
   control("permission_mode_change", {
-    mode: z8.enum(["default", "auto_accept", "plan"]),
+    mode: z9.enum(["default", "auto_accept", "plan"]),
     // sessionId 可选：传入时 proxy 按该会话的 mode 分叉（PTY 发 Tab ANSI），未传走全局日志行为
     sessionId: IdSchema.optional()
   }, "client_to_proxy"),
   // 会话历史浏览
   control("session_history_request", RequestIdShape, "client_to_proxy"),
-  control("session_history_response", { ...RequestIdShape, sessions: z8.array(HistorySessionSchema) }, "proxy_to_client"),
+  control("session_history_response", { ...RequestIdShape, sessions: z9.array(HistorySessionSchema) }, "proxy_to_client"),
   // PTY 语义状态，从 Envelope 迁移到 Control 层
   control("pty_state", { sessionId: IdSchema, payload: PtyStatePayloadSchema }, "proxy_to_client"),
   // Provider 语义状态，来自 Claude/Codex hook 等结构化事件，不从 PTY 字节推断
   control("agent_status", { sessionId: IdSchema, payload: AgentStatusPayloadSchema }, "proxy_to_client"),
   // 终端标题变化，proxy -> client
-  control("terminal_title", { sessionId: IdSchema, title: z8.string() }, "proxy_to_client"),
+  control("terminal_title", { sessionId: IdSchema, title: z9.string() }, "proxy_to_client"),
   // 终端尺寸变化，proxy -> client
-  control("terminal_resize", { sessionId: IdSchema, cols: z8.number().int().positive(), rows: z8.number().int().positive() }, "proxy_to_client"),
-  control("terminal_resize_request", { sessionId: IdSchema, cols: z8.number().int().positive(), rows: z8.number().int().positive() }, "client_to_proxy"),
+  control("terminal_resize", { sessionId: IdSchema, cols: z9.number().int().positive(), rows: z9.number().int().positive() }, "proxy_to_client"),
+  control("terminal_resize_request", { sessionId: IdSchema, cols: z9.number().int().positive(), rows: z9.number().int().positive() }, "client_to_proxy"),
   // 远程终止 JSON 会话，client -> proxy
   control("session_terminate", { sessionId: IdSchema }, "client_to_proxy"),
-  control("session_rename", { ...RequestIdShape, sessionId: IdSchema, name: z8.string() }, "client_to_proxy"),
+  control("session_rename", { ...RequestIdShape, sessionId: IdSchema, name: z9.string() }, "client_to_proxy"),
   control("session_rename_response", {
     ...RequestIdShape,
     sessionId: IdSchema,
-    success: z8.boolean(),
-    name: z8.string().optional(),
+    success: z9.boolean(),
+    name: z9.string().optional(),
     ...RequestErrorShape
   }, "proxy_to_client"),
   // 中断当前 turn，client -> proxy；JSON 由 session-worker 打断 Claude 子进程并保留会话。
@@ -852,55 +895,55 @@ var relayControlDefinitions = [
   // turn 完成信号，proxy -> client，对应 claude stream-json 的 result 事件
   control("turn_result", {
     sessionId: IdSchema,
-    success: z8.boolean(),
-    isError: z8.boolean(),
+    success: z9.boolean(),
+    isError: z9.boolean(),
     // stream-json result.result 是本轮最终文本。assistant_message 流丢失或 CLI 未发增量时，
     // Web 用它作为 JSON 模式兜底展示，避免 turn 已结束但界面空白。
-    result: z8.string().optional()
+    result: z9.string().optional()
   }, "proxy_to_client"),
   // 客户端发送到 PTY 的原始字节（ANSI 序列），不追加换行
-  control("remote_input_raw", { sessionId: IdSchema, data: z8.string(), traceId: IdSchema.optional() }, "client_to_proxy"),
+  control("remote_input_raw", { sessionId: IdSchema, data: z9.string(), traceId: IdSchema.optional() }, "client_to_proxy"),
   // 客户端询问 proxy 的环境信息 (home 路径等), client -> proxy -> response
   // FilePathPicker 用 homePath 作为 select 模式下的默认起点, 新建会话时打开即可浏览
   control("proxy_info_request", RequestIdShape, "client_to_proxy"),
-  control("proxy_info", { ...RequestIdShape, homePath: z8.string(), agentCli: AgentCliStatusSchema }, "proxy_to_client"),
-  control("agent_cli_config_update", { ...RequestIdShape, provider: z8.enum(providerValues), path: z8.string().min(1) }, "client_to_proxy"),
+  control("proxy_info", { ...RequestIdShape, homePath: z9.string(), agentCli: AgentCliStatusSchema }, "proxy_to_client"),
+  control("agent_cli_config_update", { ...RequestIdShape, provider: z9.enum(providerValues), path: z9.string().min(1) }, "client_to_proxy"),
   control("agent_cli_config_update_response", {
     ...RequestIdShape,
-    provider: z8.enum(providerValues),
+    provider: z9.enum(providerValues),
     agentCli: AgentCliStatusSchema.optional(),
     ...RequestErrorShape
   }, "proxy_to_client"),
   // 远程创建 JSON 会话，client -> proxy -> response
   control("session_create", {
     ...RequestIdShape,
-    kind: z8.enum(sessionKindValues).optional(),
-    cwd: z8.string().optional(),
-    name: z8.string().optional(),
-    provider: z8.enum(providerValues).optional(),
-    mode: z8.enum(sessionModeValues).optional(),
-    resumeSessionId: z8.string().optional(),
+    kind: z9.enum(sessionKindValues).optional(),
+    cwd: z9.string().optional(),
+    name: z9.string().optional(),
+    provider: z9.enum(providerValues).optional(),
+    mode: z9.enum(sessionModeValues).optional(),
+    resumeSessionId: z9.string().optional(),
     // 透传给 claude CLI 的 --permission-mode, undefined 时 proxy 兜底为 "default"
-    permissionMode: z8.enum(["default", "auto", "acceptEdits", "plan", "bypassPermissions", "dontAsk"]).optional()
+    permissionMode: z9.enum(["default", "auto", "acceptEdits", "plan", "bypassPermissions", "dontAsk"]).optional()
   }, "client_to_proxy"),
   control("session_create_response", {
     ...RequestIdShape,
     // 失败路径只送 errorCode/error, sessionId 此时无语义。成功路径才有 id。
     sessionId: IdSchema.optional(),
-    name: z8.string().optional(),
-    nameLocked: z8.boolean().optional(),
-    kind: z8.enum(sessionKindValues).optional(),
-    mode: z8.enum(sessionModeValues).optional(),
-    provider: z8.enum(providerValues).optional(),
-    ptyOwner: z8.enum(ptyOwnerValues).optional(),
+    name: z9.string().optional(),
+    nameLocked: z9.boolean().optional(),
+    kind: z9.enum(sessionKindValues).optional(),
+    mode: z9.enum(sessionModeValues).optional(),
+    provider: z9.enum(providerValues).optional(),
+    ptyOwner: z9.enum(ptyOwnerValues).optional(),
     ...RequestErrorShape
   }, "proxy_to_client"),
   // 客户端请求会话历史消息，client -> proxy
   control("session_messages_request", {
     ...RequestIdShape,
     sessionId: IdSchema,
-    limit: z8.number().int().min(1).max(200).optional(),
-    before: z8.string().optional()
+    limit: z9.number().int().min(1).max(200).optional(),
+    before: z9.string().optional()
   }, "client_to_proxy"),
   // 客户端请求会话资源（命令列表 + 文件树），client -> proxy
   control("session_resources_request", { ...RequestIdShape, sessionId: IdSchema }, "client_to_proxy"),
@@ -908,14 +951,14 @@ var relayControlDefinitions = [
     ...RequestIdShape,
     ...RequestErrorShape,
     sessionId: IdSchema,
-    commands: z8.array(CommandEntrySchema),
-    groups: z8.array(FileTreeGroupSchema)
+    commands: z9.array(CommandEntrySchema),
+    groups: z9.array(FileTreeGroupSchema)
   }, "proxy_to_client"),
   // 客户端请求当前 provider 语义状态；不经 relay 缓存，由 proxy 返回当前值
   control("agent_status_request", { ...RequestIdShape, sessionId: IdSchema.optional() }, "client_to_proxy"),
   control("agent_status_response", {
     ...RequestIdShape,
-    statuses: z8.array(z8.object({ sessionId: IdSchema, payload: AgentStatusPayloadSchema }))
+    statuses: z9.array(z9.object({ sessionId: IdSchema, payload: AgentStatusPayloadSchema }))
   }, "proxy_to_client"),
   // 客户端确认已收到审批请求；proxy 只记录送达状态，不把它当成用户决策
   control("permission_request_delivered", { sessionId: IdSchema, requestId: IdSchema }, "client_to_proxy"),
@@ -925,17 +968,17 @@ var relayControlDefinitions = [
   control("permission_decision_result", {
     sessionId: IdSchema,
     requestId: IdSchema,
-    outcome: z8.enum(["allow", "deny"]),
-    delivered: z8.boolean(),
-    message: z8.string().optional()
+    outcome: z9.enum(["allow", "deny"]),
+    delivered: z9.boolean(),
+    message: z9.string().optional()
   }, "proxy_to_client"),
   // proxy 推送当前 pending 的工具审批列表，client 据此恢复审批卡片
   control("pending_approvals_push", {
     sessionId: IdSchema,
-    approvals: z8.array(z8.object({
+    approvals: z9.array(z9.object({
       requestId: IdSchema,
-      toolName: z8.string(),
-      input: z8.record(z8.string(), z8.unknown())
+      toolName: z9.string(),
+      input: z9.record(z9.string(), z9.unknown())
     }))
   }, "proxy_to_client"),
   // Voice Pilot speech summaries are produced by proxy-side Claude Code so it can read project context.
@@ -943,7 +986,7 @@ var relayControlDefinitions = [
     ...RequestIdShape,
     sessionId: IdSchema,
     messageId: IdSchema,
-    text: z8.string().min(1),
+    text: z9.string().min(1),
     reason: VoiceSummaryReasonSchema
   }, "client_to_proxy"),
   control("voice_summary_response", {
@@ -951,31 +994,31 @@ var relayControlDefinitions = [
     ...RequestErrorShape,
     sessionId: IdSchema,
     messageId: IdSchema,
-    success: z8.boolean(),
-    summary: z8.string().min(1).optional()
+    success: z9.boolean(),
+    summary: z9.string().min(1).optional()
   }, "proxy_to_client"),
   // 恢复会话时推送历史消息，proxy -> client
   control("session_history_messages", {
     ...RequestIdShape,
     sessionId: IdSchema,
-    before: z8.string().optional(),
-    messages: z8.array(SessionHistoryMessageSchema),
-    hasMore: z8.boolean().optional(),
-    nextBefore: z8.string().optional()
+    before: z9.string().optional(),
+    messages: z9.array(SessionHistoryMessageSchema),
+    hasMore: z9.boolean().optional(),
+    nextBefore: z9.string().optional()
   }, "proxy_to_client"),
   // proxy 重连后同步活跃 session 列表给 relay。session_sync 由 relay 自消费（更新 proxy-session
   // 关联）不转发给 client，因此**没有** direction 标注——RelayControlDirection 只描述转发流。
   control("session_sync", {
-    sessions: z8.array(z8.object({
-      id: z8.string(),
-      kind: z8.enum(sessionKindValues).optional(),
-      mode: z8.enum(sessionModeValues),
-      provider: z8.enum(providerValues),
-      ptyOwner: z8.enum(ptyOwnerValues).optional(),
-      cwd: z8.string().optional(),
-      name: z8.string().optional(),
-      nameLocked: z8.boolean().optional(),
-      state: z8.enum(sessionStateValues)
+    sessions: z9.array(z9.object({
+      id: z9.string(),
+      kind: z9.enum(sessionKindValues).optional(),
+      mode: z9.enum(sessionModeValues),
+      provider: z9.enum(providerValues),
+      ptyOwner: z9.enum(ptyOwnerValues).optional(),
+      cwd: z9.string().optional(),
+      name: z9.string().optional(),
+      nameLocked: z9.boolean().optional(),
+      state: z9.enum(sessionStateValues)
     }))
   }),
   // PTY 会话订阅，client -> proxy，触发 terminal serialize() 返回当前状态
@@ -983,15 +1026,15 @@ var relayControlDefinitions = [
   // PTY 会话快照，proxy -> client，serialize() 的全量终端状态
   control("session_snapshot", {
     sessionId: IdSchema,
-    cols: z8.number().int().positive(),
-    rows: z8.number().int().positive(),
-    data: z8.string(),
-    outputSeq: z8.number().int().nonnegative(),
+    cols: z9.number().int().positive(),
+    rows: z9.number().int().positive(),
+    data: z9.string(),
+    outputSeq: z9.number().int().nonnegative(),
     requestId: IdSchema.optional()
   }, "proxy_to_client")
 ];
 var relayControlSchemas = relayControlDefinitions.map((definition) => definition.schema);
-var RelayControlSchema = z8.discriminatedUnion("type", relayControlSchemas);
+var RelayControlSchema = z9.discriminatedUnion("type", relayControlSchemas);
 var ProxyToClientRelayControlTypes = new Set(relayControlDefinitions.filter((definition) => definition.directions.has("proxy_to_client")).map((definition) => definition.type));
 function isProxyToClientRelayControlType(type) {
   return ProxyToClientRelayControlTypes.has(type);
@@ -1001,6 +1044,11 @@ function isClientToProxyRelayControlType(type) {
   return ClientToProxyRelayControlTypes.has(type);
 }
 
+// ../../packages/shared/dist/constants/session-create.js
+var SESSION_CREATE_SERVER_DEADLINE_MS = 3e4;
+var SESSION_CREATE_RESPONSE_GRACE_MS = 5e3;
+var SESSION_CREATE_CLIENT_TIMEOUT_MS = SESSION_CREATE_SERVER_DEADLINE_MS + SESSION_CREATE_RESPONSE_GRACE_MS;
+
 // ../../packages/shared/dist/constants/relay-close-codes.js
 var RelayCloseCode = {
   CLIENT_KICKED: 4401,
@@ -1052,6 +1100,25 @@ function decodeFileStreamFrame(view) {
   return { streamId, chunkSeq, data };
 }
 
+// ../../packages/shared/dist/voice-audio-codec.js
+var MU_LAW_BIAS = 132;
+function decodeSample(encodedValue) {
+  const value = ~encodedValue & 255;
+  const sign = value & 128;
+  const exponent = value >> 4 & 7;
+  const mantissa = value & 15;
+  const magnitude = ((mantissa << 3) + MU_LAW_BIAS) * 2 ** exponent - MU_LAW_BIAS;
+  return sign ? -magnitude : magnitude;
+}
+function decodeMuLawToPcm16(encoded) {
+  const pcm = new Uint8Array(encoded.byteLength * 2);
+  const view = new DataView(pcm.buffer);
+  for (let index = 0; index < encoded.byteLength; index += 1) {
+    view.setInt16(index * 2, decodeSample(encoded[index] ?? 255), true);
+  }
+  return pcm;
+}
+
 // ../../packages/shared/dist/state-machine.js
 function computeAbsorbingSet(transitions) {
   const absorbing = /* @__PURE__ */ new Set();
@@ -1228,6 +1295,14 @@ var RelayRegistry = class {
       binding.ws = null;
     }
   }
+  // 连接关闭只能释放自己持有的绑定。旧连接的 close 可能晚于新连接注册，
+  // 此时不能把已经切换到新 WebSocket 的绑定清空。
+  unbindClientSocket(clientId, ws) {
+    const binding = this.clientBindings.get(clientId);
+    if (!binding || binding.ws !== ws) return false;
+    binding.ws = null;
+    return true;
+  }
   getClientBinding(clientId) {
     return this.clientBindings.get(clientId);
   }
@@ -1899,6 +1974,7 @@ function bailianInferenceUrl(region) {
 // src/voice/bailian-asr.ts
 var OPEN = 1;
 var END_OF_SPEECH_SILENCE_MS = 1200;
+var NOISE_RESISTANT_SERVER_VAD_THRESHOLD = 0.8;
 function defaultSocketFactory(url, options) {
   return new WebSocket5(url, options);
 }
@@ -1974,6 +2050,7 @@ var BailianAsrClientImpl = class extends EventEmitter {
   socket;
   isOpen = false;
   isReady = false;
+  hasFinalTranscript = false;
   pending = [];
   sendPcm(chunk) {
     this.sendWhenReady({
@@ -2005,7 +2082,7 @@ var BailianAsrClientImpl = class extends EventEmitter {
         },
         turn_detection: {
           type: "server_vad",
-          threshold: 0,
+          threshold: NOISE_RESISTANT_SERVER_VAD_THRESHOLD,
           silence_duration_ms: END_OF_SPEECH_SILENCE_MS
         }
       }
@@ -2041,11 +2118,21 @@ var BailianAsrClientImpl = class extends EventEmitter {
       if (preview) this.emit("partial", preview);
       return;
     }
-    if (type === "conversation.item.input_audio_transcription.completed" || type === "session.finished") {
+    if (type === "conversation.item.input_audio_transcription.completed") {
       const transcript = extractFinalText(payload);
       if (transcript) {
+        this.hasFinalTranscript = true;
+        this.emit("final", transcript);
+      }
+      return;
+    }
+    if (type === "session.finished") {
+      const transcript = extractFinalText(payload);
+      if (transcript && !this.hasFinalTranscript) {
+        this.hasFinalTranscript = true;
         this.emit("final", transcript);
       }
+      this.socket.close(1e3, "session-finished");
     }
   }
   sendWhenReady(payload) {
@@ -2230,8 +2317,48 @@ function createBailianTtsClient(config, options = {}) {
   );
 }
 
+// src/voice/pcm-resample.ts
+import waveResampler from "wave-resampler";
+var RESAMPLE_DETAILS = {
+  method: "sinc",
+  LPF: true,
+  LPFType: "FIR"
+};
+function resampleMonoPcmS16le(audio, inputSampleRate, outputSampleRate) {
+  if (audio.byteLength % 2 !== 0) {
+    throw new Error("PCM \u97F3\u9891\u6570\u636E\u957F\u5EA6\u65E0\u6548");
+  }
+  if (!validSampleRate(inputSampleRate) || !validSampleRate(outputSampleRate)) {
+    throw new Error("PCM \u97F3\u9891\u91C7\u6837\u7387\u65E0\u6548");
+  }
+  if (inputSampleRate === outputSampleRate) return Buffer.from(audio);
+  const input = new Int16Array(audio.byteLength / 2);
+  for (let index = 0; index < input.length; index += 1) {
+    input[index] = audio.readInt16LE(index * 2);
+  }
+  const samples = waveResampler.resample(
+    input,
+    inputSampleRate,
+    outputSampleRate,
+    RESAMPLE_DETAILS
+  );
+  const output = Buffer.alloc(samples.length * 2);
+  for (let index = 0; index < samples.length; index += 1) {
+    const sample = samples[index];
+    if (typeof sample !== "number" || !Number.isFinite(sample)) {
+      throw new Error("PCM \u97F3\u9891\u91CD\u91C7\u6837\u5931\u8D25");
+    }
+    output.writeInt16LE(Math.max(-32768, Math.min(32767, Math.round(sample))), index * 2);
+  }
+  return output;
+}
+function validSampleRate(sampleRate) {
+  return Number.isSafeInteger(sampleRate) && sampleRate > 0;
+}
+
 // src/voice/config-test.ts
-var TEST_SAMPLE_RATE = 16e3;
+var TTS_TEST_SAMPLE_RATE = 24e3;
+var ASR_TEST_SAMPLE_RATE = 16e3;
 var ASR_TEST_CHUNK_BYTES = 3200;
 var ASR_TEST_CHUNK_INTERVAL_MS = 100;
 function mergeVoiceConfigForTest(current, update) {
@@ -2263,14 +2390,19 @@ function createBailianVoiceConfigTester(options = {}) {
         timeoutMs,
         clientFactory: ttsClientFactory
       });
+      const recognitionAudio = resampleMonoPcmS16le(
+        audio,
+        TTS_TEST_SAMPLE_RATE,
+        ASR_TEST_SAMPLE_RATE
+      );
       const transcript = await recognizeTestAudio({
         config,
-        audio,
+        audio: recognitionAudio,
         sampleText,
         timeoutMs,
         clientFactory: asrClientFactory
       });
-      return { audio, sampleRate: TEST_SAMPLE_RATE, transcript };
+      return { audio, sampleRate: TTS_TEST_SAMPLE_RATE, transcript };
     }
   };
 }
@@ -2281,7 +2413,7 @@ function synthesizeTestAudio(options) {
     region: config.region,
     model: config.ttsModel,
     voice: config.ttsVoice,
-    sampleRate: TEST_SAMPLE_RATE
+    sampleRate: TTS_TEST_SAMPLE_RATE
   });
   return new Promise((resolve2, reject) => {
     let settled = false;
@@ -2324,7 +2456,7 @@ function recognizeTestAudio(options) {
     apiKey: config.apiKey,
     region: config.region,
     model: config.asrModel,
-    sampleRate: TEST_SAMPLE_RATE,
+    sampleRate: ASR_TEST_SAMPLE_RATE,
     language: "zh"
   });
   return new Promise((resolve2, reject) => {
@@ -3036,7 +3168,7 @@ function handleClientConnection(ws, registry, logger, chaos, voiceConfigStore, v
   clientWs.on("close", (code, reason) => {
     registry.removeClientWs(clientWs);
     if (clientWs.clientId) {
-      registry.unbindClientById(clientWs.clientId);
+      registry.unbindClientSocket(clientWs.clientId, clientWs);
     }
     logger.info(
       {
@@ -3242,59 +3374,190 @@ function parseJson(data) {
     return null;
   }
 }
-function isStartMessage(payload) {
-  if (!payload || typeof payload !== "object") return false;
-  const record = payload;
-  return record.type === "start" && typeof record.sessionId === "string";
+function buildStats(payload, config) {
+  return {
+    sessionId: payload.sessionId,
+    attemptId: payload.attemptId,
+    sampleRate: payload.sampleRate,
+    provider: config.provider,
+    region: config.region,
+    asrModel: config.asrModel,
+    encoding: payload.encoding,
+    startedAt: Date.now(),
+    readyAt: null,
+    firstPcmAt: null,
+    encodedBytes: 0,
+    pcmBytes: 0,
+    pcmChunks: 0,
+    partialEvents: 0,
+    finalEvents: 0,
+    finalChars: 0
+  };
+}
+function statsLogFields(stats) {
+  const now = Date.now();
+  return {
+    sessionId: stats.sessionId,
+    attemptId: stats.attemptId,
+    sampleRate: stats.sampleRate,
+    provider: stats.provider,
+    region: stats.region,
+    asrModel: stats.asrModel,
+    encoding: stats.encoding,
+    encodedBytes: stats.encodedBytes,
+    pcmBytes: stats.pcmBytes,
+    pcmChunks: stats.pcmChunks,
+    partialEvents: stats.partialEvents,
+    finalEvents: stats.finalEvents,
+    finalChars: stats.finalChars,
+    durationMs: now - stats.startedAt,
+    readyMs: stats.readyAt === null ? null : stats.readyAt - stats.startedAt,
+    firstPcmMs: stats.firstPcmAt === null ? null : stats.firstPcmAt - stats.startedAt
+  };
 }
 function handleVoiceAsrConnection(ws, store, logger, providers) {
   let provider = null;
+  let activeStats = null;
+  function isCurrent(candidate, stats, event) {
+    if (provider === candidate && activeStats === stats) return true;
+    logger.debug(
+      { attemptId: stats.attemptId, activeAttemptId: activeStats?.attemptId ?? null, event },
+      "Ignored stale Voice ASR provider event"
+    );
+    return false;
+  }
+  function detachProvider(reason) {
+    const previousProvider = provider;
+    const previousStats = activeStats;
+    provider = null;
+    activeStats = null;
+    if (previousStats) {
+      logger.info({ ...statsLogFields(previousStats), reason }, "Voice ASR attempt detached");
+    }
+    previousProvider?.close();
+  }
   function start(payload) {
     const config = store.readSecret();
     if (!config.apiKey) {
       sendJson(ws, {
         type: "error",
+        attemptId: payload.attemptId,
         errorCode: "not_configured",
         error: "Voice provider is not configured"
       });
       return;
     }
-    provider?.close();
-    provider = providers.current(config).createAsrClient(config, {
-      sampleRate: payload.sampleRate ?? 16e3,
-      language: "zh"
+    detachProvider("replaced");
+    const stats = buildStats(payload, config);
+    let currentProvider;
+    try {
+      currentProvider = providers.current(config).createAsrClient(config, {
+        sampleRate: stats.sampleRate,
+        language: "zh"
+      });
+    } catch (error) {
+      logger.warn({ ...statsLogFields(stats), err: error }, "Voice ASR provider creation failed");
+      sendJson(ws, {
+        type: "error",
+        attemptId: payload.attemptId,
+        error: error instanceof Error ? error.message : "ASR failed"
+      });
+      return;
+    }
+    provider = currentProvider;
+    activeStats = stats;
+    logger.info(statsLogFields(stats), "Voice ASR attempt started");
+    currentProvider.on("ready", () => {
+      if (!isCurrent(currentProvider, stats, "ready")) return;
+      stats.readyAt = Date.now();
+      logger.info(statsLogFields(stats), "Voice ASR provider ready");
+      sendJson(ws, { type: "ready", attemptId: stats.attemptId });
+    });
+    currentProvider.on("partial", (text) => {
+      if (!isCurrent(currentProvider, stats, "partial")) return;
+      stats.partialEvents += 1;
+      sendJson(ws, { type: "partial", attemptId: stats.attemptId, text });
+    });
+    currentProvider.on("final", (text) => {
+      if (!isCurrent(currentProvider, stats, "final")) return;
+      stats.finalEvents += 1;
+      stats.finalChars += text.length;
+      sendJson(ws, { type: "final", attemptId: stats.attemptId, text });
+    });
+    currentProvider.on("error", (error) => {
+      if (!isCurrent(currentProvider, stats, "error")) return;
+      logger.warn({ ...statsLogFields(stats), err: error }, "Voice ASR provider reported an error");
+      sendJson(ws, {
+        type: "error",
+        attemptId: stats.attemptId,
+        error: error.message || "ASR failed"
+      });
+    });
+    currentProvider.on("closed", (code, reason) => {
+      if (!isCurrent(currentProvider, stats, "closed")) return;
+      provider = null;
+      activeStats = null;
+      logger.info({ ...statsLogFields(stats), code, reason }, "Voice ASR provider closed");
+      sendJson(ws, { type: "closed", attemptId: stats.attemptId, code, reason });
     });
-    provider.on("ready", () => sendJson(ws, { type: "ready" }));
-    provider.on("partial", (text) => sendJson(ws, { type: "partial", text }));
-    provider.on("final", (text) => sendJson(ws, { type: "final", text }));
-    provider.on(
-      "error",
-      (error) => sendJson(ws, { type: "error", error: error.message || "ASR failed" })
-    );
-    provider.on("closed", (code, reason) => sendJson(ws, { type: "closed", code, reason }));
   }
   ws.on("message", (data, isBinary) => {
     if (isBinary) {
-      provider?.sendPcm(toBuffer(data));
+      const encodedChunk = toBuffer(data);
+      if (provider && activeStats) {
+        const pcmChunk = activeStats.encoding === "mulaw" ? Buffer.from(decodeMuLawToPcm16(encodedChunk)) : encodedChunk;
+        if (activeStats.firstPcmAt === null) activeStats.firstPcmAt = Date.now();
+        activeStats.encodedBytes += encodedChunk.byteLength;
+        activeStats.pcmBytes += pcmChunk.byteLength;
+        activeStats.pcmChunks += 1;
+        provider.sendPcm(pcmChunk);
+        sendJson(ws, {
+          type: "audio_ack",
+          attemptId: activeStats.attemptId,
+          encodedBytes: activeStats.encodedBytes,
+          pcmBytes: activeStats.pcmBytes,
+          chunks: activeStats.pcmChunks
+        });
+      }
+      return;
+    }
+    const parsed = VoiceAsrClientMessageSchema.safeParse(parseJson(data));
+    if (!parsed.success) {
+      logger.debug({ issues: parsed.error.issues }, "Ignored invalid Voice ASR client message");
       return;
     }
-    const payload = parseJson(data);
-    if (isStartMessage(payload)) {
+    const payload = parsed.data;
+    if (payload.type === "start") {
       start(payload);
       return;
     }
-    if (payload && typeof payload === "object" && payload.type === "stop") {
-      provider?.stop();
+    if (payload.type === "stop") {
+      if (!provider || !activeStats || activeStats.attemptId !== payload.attemptId) {
+        logger.debug(
+          { attemptId: payload.attemptId, activeAttemptId: activeStats?.attemptId ?? null },
+          "Ignored stale Voice ASR stop"
+        );
+        return;
+      }
+      logger.info(statsLogFields(activeStats), "Voice ASR stop requested");
+      provider.stop();
     }
   });
-  ws.on("close", () => {
-    provider?.close();
-    provider = null;
+  ws.on("close", (code, reason) => {
+    if (activeStats) {
+      logger.info(
+        { ...statsLogFields(activeStats), code, reason: reason.toString("utf8") },
+        "Voice ASR client websocket closed"
+      );
+    }
+    detachProvider("client-websocket-closed");
   });
   ws.on("error", (err) => {
-    logger.warn({ err }, "Voice ASR websocket error");
-    provider?.close();
-    provider = null;
+    logger.warn(
+      { ...activeStats ? statsLogFields(activeStats) : {}, err },
+      "Voice ASR websocket error"
+    );
+    detachProvider("client-websocket-error");
   });
 }
 
@@ -3321,7 +3584,7 @@ function isSpeakMessage(payload) {
 function nowMs() {
   return Date.now();
 }
-function buildStats(requestId, text, config) {
+function buildStats2(requestId, text, config) {
   return {
     requestId,
     textChars: text.length,
@@ -3335,7 +3598,7 @@ function buildStats(requestId, text, config) {
     audioChunks: 0
   };
 }
-function statsLogFields(stats) {
+function statsLogFields2(stats) {
   const currentTime = nowMs();
   return {
     requestId: stats.requestId,
@@ -3375,7 +3638,7 @@ function handleVoiceTtsConnection(ws, store, logger, providers) {
     });
     providerConfig = config;
     provider.on("started", () => {
-      if (activeStats) logger.info(statsLogFields(activeStats), "Voice TTS started");
+      if (activeStats) logger.info(statsLogFields2(activeStats), "Voice TTS started");
       sendJson2(ws, { type: "started", requestId: activeRequestId });
     });
     provider.on("audio", (chunk) => {
@@ -3387,7 +3650,7 @@ function handleVoiceTtsConnection(ws, store, logger, providers) {
       if (ws.readyState === WebSocket10.OPEN) ws.send(chunk);
     });
     provider.on("finished", () => {
-      if (activeStats) logger.info(statsLogFields(activeStats), "Voice TTS finished");
+      if (activeStats) logger.info(statsLogFields2(activeStats), "Voice TTS finished");
       sendJson2(ws, { type: "finished", requestId: activeRequestId });
       activeRequestId = null;
       activeStats = null;
@@ -3395,7 +3658,7 @@ function handleVoiceTtsConnection(ws, store, logger, providers) {
     provider.on("error", (error) => {
       if (activeStats) {
         logger.warn(
-          { ...statsLogFields(activeStats), err: error },
+          { ...statsLogFields2(activeStats), err: error },
           "Voice TTS provider reported an error"
         );
       }
@@ -3410,7 +3673,7 @@ function handleVoiceTtsConnection(ws, store, logger, providers) {
     provider.on("closed", (code, reason) => {
       if (activeStats) {
         logger.warn(
-          { ...statsLogFields(activeStats), code, reason },
+          { ...statsLogFields2(activeStats), code, reason },
           "Voice TTS provider closed before finishing"
         );
         sendJson2(ws, {
@@ -3449,14 +3712,14 @@ function handleVoiceTtsConnection(ws, store, logger, providers) {
     if (!ensured) return;
     const { client, config } = ensured;
     activeRequestId = payload.requestId;
-    activeStats = buildStats(payload.requestId, payload.text, config);
-    logger.info(statsLogFields(activeStats), "Voice TTS request received");
+    activeStats = buildStats2(payload.requestId, payload.text, config);
+    logger.info(statsLogFields2(activeStats), "Voice TTS request received");
     try {
       client.speak(payload.text);
     } catch (err) {
       if (activeStats) {
         logger.warn(
-          { ...statsLogFields(activeStats), err },
+          { ...statsLogFields2(activeStats), err },
           "Voice TTS request failed before provider accepted it"
         );
       }
@@ -3472,7 +3735,7 @@ function handleVoiceTtsConnection(ws, store, logger, providers) {
   ws.on("close", (code, reason) => {
     if (activeStats) {
       logger.warn(
-        { ...statsLogFields(activeStats), code, reason: closeReasonText(reason) },
+        { ...statsLogFields2(activeStats), code, reason: closeReasonText(reason) },
         "Voice TTS client websocket closed before finishing"
       );
     }
@@ -4042,9 +4305,80 @@ var RemoteFileBridge = class {
   }
 };
 
+// src/web-app.ts
+import compression from "compression";
+import express from "express";
+import { existsSync as existsSync2 } from "fs";
+import { basename, join as join3 } from "path";
+var IMMUTABLE_CACHE_SECONDS = 365 * 24 * 60 * 60;
+var SHORT_CACHE_SECONDS = 60 * 60;
+var RELAY_ROUTE_ROOTS = /* @__PURE__ */ new Set([
+  "/api",
+  "/client",
+  "/fonts",
+  "/health",
+  "/proxy",
+  "/status",
+  "/voice"
+]);
+function isRelayRoute(pathname) {
+  for (const root of RELAY_ROUTE_ROOTS) {
+    if (pathname === root || pathname.startsWith(`${root}/`)) return true;
+  }
+  return false;
+}
+function setStaticCacheHeaders(response, filePath) {
+  const fileName = basename(filePath);
+  const normalizedPath = filePath.replaceAll("\\", "/");
+  if (normalizedPath.includes("/assets/") || /^workbox-.+\.js$/.test(fileName)) {
+    response.setHeader("Cache-Control", `public, max-age=${IMMUTABLE_CACHE_SECONDS}, immutable`);
+    return;
+  }
+  if (fileName === "index.html" || fileName === "sw.js" || fileName === "registerSW.js" || fileName === "manifest.webmanifest") {
+    response.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
+    return;
+  }
+  response.setHeader("Cache-Control", `public, max-age=${SHORT_CACHE_SECONDS}`);
+}
+function mountWebApp(app, options) {
+  const { webAssetDir, logger } = options;
+  const indexPath = join3(webAssetDir, "index.html");
+  if (!existsSync2(indexPath)) {
+    logger.warn({ webAssetDir }, "Web assets not found; Relay will run without the Web UI");
+    return false;
+  }
+  app.use(compression());
+  app.use(
+    express.static(webAssetDir, {
+      index: false,
+      fallthrough: true,
+      setHeaders: setStaticCacheHeaders
+    })
+  );
+  app.use((request, response, next) => {
+    if (request.method !== "GET" && request.method !== "HEAD") {
+      next();
+      return;
+    }
+    if (isRelayRoute(request.path)) {
+      response.status(404).json({ error: "not_found" });
+      return;
+    }
+    if (!request.accepts("html")) {
+      next();
+      return;
+    }
+    response.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
+    response.sendFile(indexPath);
+  });
+  logger.info({ webAssetDir }, "Web UI mounted");
+  return true;
+}
+
 // src/server.ts
 var MODULE_DIR = dirname3(fileURLToPath2(import.meta.url));
 var PACKAGED_FONTS_DIR = resolve(MODULE_DIR, "../assets/fonts");
+var PACKAGED_WEB_DIR = resolve(MODULE_DIR, "../assets/web");
 function firstHeaderValue(value) {
   if (Array.isArray(value)) return value[0];
   return value;
@@ -4099,7 +4433,8 @@ function createRelayServer(options) {
       "Relay chaos mode enabled"
     );
   }
-  const app = express();
+  const app = express2();
+  app.disable("x-powered-by");
   const fontsDir = dataDir ? `${dataDir}/fonts` : `${homedir()}/.dev-anywhere/relay-data/fonts`;
   const fontAssetDir = options.fontAssetDir ?? PACKAGED_FONTS_DIR;
   app.use(
@@ -4108,15 +4443,15 @@ function createRelayServer(options) {
       res.setHeader("Access-Control-Allow-Origin", "*");
       next();
     },
-    express.static(fontsDir, {
+    express2.static(fontsDir, {
       maxAge: "30d",
       immutable: true
     })
   );
-  if (existsSync2(fontAssetDir)) {
+  if (existsSync3(fontAssetDir)) {
     app.use(
       "/fonts",
-      express.static(fontAssetDir, {
+      express2.static(fontAssetDir, {
         maxAge: "30d",
         immutable: true
       })
@@ -4137,6 +4472,10 @@ function createRelayServer(options) {
   app.put("/api/remote-uploads/:token", (req, res) => {
     remoteFileBridge.handleUploadHttpRequest(req, res);
   });
+  const webAssetDir = options.webAssetDir === false ? void 0 : options.webAssetDir ?? PACKAGED_WEB_DIR;
+  if (webAssetDir) {
+    mountWebApp(app, { webAssetDir, logger });
+  }
   const httpServer = createServer(app);
   const proxyWss = new WebSocketServer({ noServer: true });
   const clientWss = new WebSocketServer({ noServer: true });
@@ -4306,4 +4645,4 @@ export {
   parseRelayChaosFromEnv,
   createRelayServer
 };
-//# sourceMappingURL=chunk-46NK2URF.js.map
+//# sourceMappingURL=chunk-2L3L5F4J.js.map