opencharm 0.1.0 → 0.3.0

package/dist/main.mjs

@@ -1,15 +1,17 @@
 #!/usr/bin/env node
-import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { chmodSync, createWriteStream, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { dirname, extname, isAbsolute, join, normalize, resolve, sep } from "node:path";
 import { z } from "zod";
 import { createConnection, createServer } from "node:net";
 import { createInterface } from "node:readline";
-import { execFile, spawn, spawnSync } from "node:child_process";
+import { execFile, execFileSync, spawn, spawnSync } from "node:child_process";
 import { createHash, randomBytes, randomInt, randomUUID, scrypt, timingSafeEqual } from "node:crypto";
 import { createServer as createServer$1 } from "node:http";
-import { WebSocketServer } from "ws";
+import WebSocket, { WebSocketServer } from "ws";
 import { Readable, Writable } from "node:stream";
+import { pipeline } from "node:stream/promises";
 import * as acp from "@agentclientprotocol/sdk";
 import OpusScript from "opusscript";
 import { fileURLToPath } from "node:url";
@@ -455,12 +457,20 @@ const audioParams = z.object({
 	channels: z.number().int().min(1).max(2),
 	frame_duration: z.number().int().positive()
 });
+const plain = (max) => z.string().min(1).max(max).regex(/^[\w.@+-]+$/);
+const charmBuild = z.object({
+	kind: plain(16),
+	version: plain(64),
+	commit: plain(40)
+});
+const build = charmBuild.optional().catch(void 0);
 const clientHello = z.object({
 	type: z.literal("hello"),
 	version: z.number().int().positive(),
 	features: z.record(z.string(), z.boolean()).optional(),
 	transport: z.literal("websocket"),
-	audio_params: audioParams
+	audio_params: audioParams,
+	build
 });
 const listen = z.object({
 	session_id: sessionId,
@@ -702,7 +712,7 @@ const secret = {
 	apiKey: z.string().min(1).optional(),
 	apiKeyEnv: z.string().min(1).optional()
 };
-const voiceSchema = z.discriminatedUnion("provider", [
+const legacyVoiceSchema = z.discriminatedUnion("provider", [
 	z.object({
 		provider: z.literal("fake"),
 		transcript: z.string().optional()
@@ -721,6 +731,52 @@ const voiceSchema = z.discriminatedUnion("provider", [
 		voice: z.string().optional()
 	}).strict()
 ]);
+const languageCode = z.string().regex(/^[a-z]{2}$/);
+const listenSchema = z.discriminatedUnion("provider", [
+	z.object({ provider: z.literal("local") }).strict(),
+	z.object({
+		provider: z.literal("whisper"),
+		model: z.string().optional(),
+		command: z.string().optional()
+	}).strict(),
+	z.object({
+		provider: z.literal("openai"),
+		...secret,
+		baseUrl: z.url().optional(),
+		model: z.string().optional()
+	}).strict(),
+	z.object({
+		provider: z.literal("fake"),
+		transcript: z.string().optional()
+	}).strict()
+]);
+const speakSchema = z.discriminatedUnion("provider", [
+	z.object({
+		provider: z.literal("microsoft"),
+		voices: z.record(languageCode, z.string().regex(/^[A-Za-z]{2,3}-[A-Za-z]{2,4}-\w+$/)).optional()
+	}).strict(),
+	z.object({
+		provider: z.literal("local"),
+		speaker: z.number().int().min(0).max(9).optional()
+	}).strict(),
+	z.object({
+		provider: z.literal("system"),
+		voice: z.string().optional()
+	}).strict(),
+	z.object({
+		provider: z.literal("openai"),
+		...secret,
+		baseUrl: z.url().optional(),
+		model: z.string().optional(),
+		voice: z.string().optional()
+	}).strict(),
+	z.object({ provider: z.literal("fake") }).strict()
+]);
+const voiceSchema = z.union([legacyVoiceSchema, z.object({
+	listen: listenSchema,
+	speak: speakSchema,
+	language: languageCode.default("en")
+}).strict()]);
 const agentSchema = z.discriminatedUnion("adapter", [
 	z.object({ adapter: z.literal("fake") }).strict(),
 	z.object({
@@ -801,6 +857,52 @@ function resolveAgent(agent, base) {
 		...agent.projects ? { projects: agent.projects.map((p) => expandPath(p, base)) } : {}
 	};
 }
+function normalizeVoice(voice) {
+	if ("listen" in voice) return voice;
+	switch (voice.provider) {
+		case "fake": return {
+			listen: {
+				provider: "fake",
+				...voice.transcript ? { transcript: voice.transcript } : {}
+			},
+			speak: { provider: "fake" },
+			language: "en"
+		};
+		case "local": return {
+			listen: voice.whisperModel ? {
+				provider: "whisper",
+				model: voice.whisperModel
+			} : { provider: "local" },
+			speak: voice.sayVoice ? {
+				provider: "system",
+				voice: voice.sayVoice
+			} : { provider: "local" },
+			language: "en"
+		};
+		case "openai": {
+			const { sttModel, ttsModel, voice: name } = voice;
+			const rest = {
+				...voice.apiKey ? { apiKey: voice.apiKey } : {},
+				...voice.apiKeyEnv ? { apiKeyEnv: voice.apiKeyEnv } : {},
+				...voice.baseUrl ? { baseUrl: voice.baseUrl } : {}
+			};
+			return {
+				listen: {
+					provider: "openai",
+					...rest,
+					...sttModel ? { model: sttModel } : {}
+				},
+				speak: {
+					provider: "openai",
+					...rest,
+					...ttsModel ? { model: ttsModel } : {},
+					...name ? { voice: name } : {}
+				},
+				language: "en"
+			};
+		}
+	}
+}
 function parseConfig(input, baseDir) {
 	const result = schema.safeParse(input);
 	if (!result.success) {
@@ -816,7 +918,8 @@ function parseConfig(input, baseDir) {
 		...config,
 		statePath,
 		adminSocket: config.adminSocket ?? defaultAdminSocket(statePath),
-		agent
+		agent,
+		voice: normalizeVoice(config.voice)
 	};
 }
 function loadConfig(path, options = {}) {
@@ -858,7 +961,7 @@ function sendAdmin(socketPath, request) {
 }
 //#endregion
 //#region package.json
-var version = "0.1.0";
+var version = "0.3.0";
 function channelToCube(value) {
 	if (value < 48) return 0;
 	if (value < 115) return 1;
@@ -999,6 +1102,18 @@ function promptHidden(question) {
 }
 //#endregion
 //#region src/commands/admin.ts
+const statusSchema = z.object({
+	charmd: z.string().regex(/^[\w.@+() -]{1,96}$/).optional().catch(void 0),
+	starter: z.string().regex(/^[0-9a-f]{4,40}$/).optional().catch(void 0),
+	voice: z.string().regex(/^[\w.+()%· -]{1,160}$/).optional().catch(void 0),
+	charms: z.array(z.object({
+		name: z.string(),
+		state: z.string(),
+		blocked: z.boolean(),
+		failedTries: z.number(),
+		build: charmBuild.optional().catch(void 0)
+	}))
+});
 const DONE = {
 	lock: "Locked",
 	unlock: "Unblocked and unlocked",
@@ -1083,14 +1198,17 @@ async function look(ctx, args, deps) {
 	if (Object.keys(update).length === 0) return;
 	ctx.out.write(`${result.connected === 0 ? "No charm is unlocked right now: it gets the look when it unlocks." : `Sent to ${result.connected} charm${result.connected === 1 ? "" : "s"}.`} It lasts until charmd restarts; to keep it, set "charm" in opencharm.json.\n`);
 }
-function printStatus(ctx, charms) {
+function printStatus(ctx, charms, charmd, starter, voice) {
+	if (charmd) ctx.out.write(`charmd ${charmd}\n`);
+	if (voice) ctx.out.write(`voice ${voice}\n`);
+	if (starter) ctx.out.write(`workspace from starter ${starter}\n`);
 	if (charms.length === 0) {
 		ctx.out.write("No charms paired yet. Start one and run: opencharm pair <code>\n");
 		return;
 	}
 	for (const charm of charms) {
-		const note = charm.blocked ? "blocked (opencharm unlock to clear)" : charm.failedTries > 0 ? `${charm.failedTries} wrong PIN(s)` : "";
-		ctx.out.write(`${charm.name.padEnd(16)} ${charm.state.padEnd(10)} ${note}\n`.trimEnd() + "\n");
+		const details = [charm.blocked ? "blocked (opencharm unlock to clear)" : charm.failedTries > 0 ? `${charm.failedTries} wrong PIN(s)` : "", charm.build ? `${charm.build.kind} ${charm.build.version} (${charm.build.commit})` : ""].filter(Boolean).join("  ");
+		ctx.out.write(`${charm.name.padEnd(16)} ${charm.state.padEnd(10)} ${details}`.trimEnd() + "\n");
 	}
 }
 async function runAdminCommand(ctx, command, args, deps) {
@@ -1108,8 +1226,13 @@ async function runAdminCommand(ctx, command, args, deps) {
 			return;
 		}
 		if (command === "status") {
-			const { charms } = await deps.send(deps.socket, { cmd: "status" });
-			printStatus(ctx, charms);
+			const answer = statusSchema.safeParse(await deps.send(deps.socket, { cmd: "status" }));
+			if (!answer.success) {
+				fail$2(ctx, "Unexpected answer from charmd: is it the same version as this CLI?");
+				return;
+			}
+			const { charms, charmd, starter, voice } = answer.data;
+			printStatus(ctx, charms, charmd, starter, voice);
 			return;
 		}
 		const charm = firstPositional(args);
@@ -1323,6 +1446,7 @@ function runHelp(ctx) {
     opencharm setup --domain <d>    install charmd as a service (Linux, sudo)   [--dry-run]
     opencharm serve                 start charmd   [--config <file>]
     opencharm sim                   the charm on screen, in your browser   [--url <ws>] [--port <n>]
+    opencharm voice                 the local voice's models   [install: download them now]
     opencharm pair <code>           pair the charm showing <code>   [--name <name>]
     opencharm status                paired charms and their state
     opencharm lock <charm>          lock a charm now
@@ -1347,6 +1471,10 @@ function runHelp(ctx) {
 //#endregion
 //#region src/commands/init.ts
 const STARTER = "https://github.com/opencharm-labs/opencharm-starter.git";
+const DEFAULT_VOICE = {
+	listen: { provider: "local" },
+	speak: { provider: "microsoft" }
+};
 function checkLook(options) {
 	const result = z.object({
 		name: lookFields.name,
@@ -1383,13 +1511,9 @@ function initWorkspace(target, options) {
 	const path = join(target, "opencharm.json");
 	if (!existsSync(path)) throw new Error(`${from} has no opencharm.json: is it an OpenCharm starter? (${target} was cloned; delete it)`);
 	const config = JSON.parse(readFileSync(path, "utf8"));
-	const voice = options.platform === "darwin" ? "local" : "fake";
 	const hasLook = Object.keys(look).length > 0;
-	if (config.voice?.provider === voice && config.agent?.agent === agent && !hasLook) return;
-	config.voice = {
-		...config.voice,
-		provider: voice
-	};
+	if (JSON.stringify(config.voice) === JSON.stringify(DEFAULT_VOICE) && config.agent?.agent === agent && !hasLook) return;
+	config.voice = DEFAULT_VOICE;
 	config.agent = {
 		...config.agent,
 		agent
@@ -1408,8 +1532,7 @@ function runInit(ctx, args) {
 			from: flagValue(args, "--from"),
 			agent: flagValue(args, "--agent"),
 			name,
-			colour: flagValue(args, "--colour") ?? flagValue(args, "--color"),
-			platform: process.platform
+			colour: flagValue(args, "--colour") ?? flagValue(args, "--color")
 		});
 	} catch (error) {
 		ctx.err.write(`${error instanceof Error ? error.message : String(error)}\n`);
@@ -1425,7 +1548,8 @@ function runInit(ctx, args) {
   opencharm sim            no charm yet? it appears in your browser (another terminal)
   opencharm pair <code>    the code on the charm (or the emulator); you choose its PIN
 
-  The charm is called ${charm}: its name, colour and greeting are in opencharm.json ("charm"). README.md has the voice setup.
+  The charm is called ${charm}: its name, colour and greeting are in opencharm.json ("charm").
+  ${ctx.style.dim("Voice: it listens on this computer; it speaks with Microsoft's free voices, so the text of each spoken reply goes to Microsoft. To keep everything here, set \"speak\": { \"provider\": \"local\" } in opencharm.json. The first start downloads the voice models (about 620 MB): opencharm voice.")}
 `);
 }
 //#endregion
@@ -1705,7 +1829,7 @@ function parseInput(schema, input) {
 	if (!result.success) throw new Error(result.error.issues.map((i) => i.message).join("; "));
 	return result.data;
 }
-function createAdminActions({ store, pairing, sessions, look, agentCanChangeLook }) {
+function createAdminActions({ store, pairing, sessions, look, agentCanChangeLook, identity, starter, voice }) {
 	function sessionsOf(charmId) {
 		return [...sessions()].filter((s) => s.charmId === charmId && s.state !== "closed");
 	}
@@ -1811,17 +1935,23 @@ function createAdminActions({ store, pairing, sessions, look, agentCanChangeLook
 			});
 		},
 		status() {
-			return { charms: store.list().map((charm) => {
-				const live = sessionsOf(charm.id).at(-1);
-				return {
-					id: charm.id,
-					name: charm.name,
-					blocked: charm.blocked,
-					failedTries: charm.failedTries,
-					connected: live !== void 0,
-					state: live?.state ?? "offline"
-				};
-			}) };
+			return {
+				charmd: identity ?? "unknown",
+				...starter ? { starter } : {},
+				...voice ? { voice: voice() } : {},
+				charms: store.list().map((charm) => {
+					const live = sessionsOf(charm.id).at(-1);
+					return {
+						id: charm.id,
+						name: charm.name,
+						blocked: charm.blocked,
+						failedTries: charm.failedTries,
+						connected: live !== void 0,
+						state: live?.state ?? "offline",
+						build: live?.build
+					};
+				})
+			};
 		}
 	};
 }
@@ -2085,6 +2215,7 @@ var Session = class {
 	sessionId = randomBytes(8).toString("hex");
 	#state = "awaiting_hello";
 	#charmId;
+	#build;
 	#queue = Promise.resolve();
 	#turn;
 	#asks = Promise.resolve();
@@ -2097,6 +2228,9 @@ var Session = class {
 	get state() {
 		return this.#state;
 	}
+	get build() {
+		return this.#build;
+	}
 	get charmId() {
 		return this.#charmId;
 	}
@@ -2150,6 +2284,7 @@ var Session = class {
 			type: "charm",
 			op: "unlocked"
 		});
+		this.#activeTurn()?.warm();
 	}
 	#issuePairCode() {
 		try {
@@ -2181,6 +2316,7 @@ var Session = class {
 				this.#close(CLOSE_POLICY$1);
 				return;
 			}
+			this.#build = message.build;
 			this.#onHello();
 			return;
 		}
@@ -2621,6 +2757,449 @@ function readOggOpus(data) {
 	};
 }
 //#endregion
+//#region ../charmd/src/voice/language.ts
+const COMMON_WORDS = {
+	en: [
+		"the",
+		"and",
+		"is",
+		"are",
+		"you",
+		"to",
+		"of",
+		"it",
+		"that",
+		"what",
+		"this",
+		"for",
+		"with",
+		"have",
+		"i",
+		"my",
+		"your",
+		"do",
+		"can",
+		"on",
+		"in",
+		"be",
+		"was",
+		"will",
+		"not",
+		"me",
+		"please",
+		"tomorrow",
+		"today"
+	],
+	it: [
+		"il",
+		"lo",
+		"la",
+		"gli",
+		"le",
+		"di",
+		"che",
+		"è",
+		"e",
+		"un",
+		"una",
+		"per",
+		"con",
+		"non",
+		"sono",
+		"mi",
+		"ti",
+		"ho",
+		"hai",
+		"cosa",
+		"come",
+		"del",
+		"della",
+		"dei",
+		"delle",
+		"nel",
+		"nella",
+		"fai",
+		"oggi",
+		"domani",
+		"anche",
+		"questo",
+		"quello",
+		"sì",
+		"grazie"
+	],
+	es: [
+		"el",
+		"los",
+		"las",
+		"de",
+		"que",
+		"es",
+		"y",
+		"un",
+		"una",
+		"por",
+		"con",
+		"no",
+		"para",
+		"lo",
+		"mi",
+		"tu",
+		"qué",
+		"cómo",
+		"está",
+		"son",
+		"hoy",
+		"mañana",
+		"gracias",
+		"pero",
+		"muy",
+		"también"
+	],
+	fr: [
+		"le",
+		"les",
+		"des",
+		"de",
+		"et",
+		"est",
+		"un",
+		"une",
+		"pour",
+		"avec",
+		"pas",
+		"je",
+		"tu",
+		"vous",
+		"nous",
+		"que",
+		"qui",
+		"ce",
+		"cette",
+		"dans",
+		"sur",
+		"aujourd'hui",
+		"demain",
+		"merci",
+		"oui",
+		"mais",
+		"très"
+	],
+	de: [
+		"der",
+		"die",
+		"das",
+		"und",
+		"ist",
+		"ein",
+		"eine",
+		"nicht",
+		"ich",
+		"du",
+		"sie",
+		"wir",
+		"mit",
+		"für",
+		"auf",
+		"zu",
+		"den",
+		"dem",
+		"was",
+		"wie",
+		"heute",
+		"morgen",
+		"danke",
+		"ja",
+		"auch",
+		"bitte"
+	],
+	pt: [
+		"o",
+		"os",
+		"as",
+		"de",
+		"que",
+		"é",
+		"e",
+		"um",
+		"uma",
+		"para",
+		"com",
+		"não",
+		"eu",
+		"você",
+		"do",
+		"da",
+		"dos",
+		"das",
+		"no",
+		"na",
+		"hoje",
+		"amanhã",
+		"obrigado",
+		"obrigada",
+		"sim",
+		"também",
+		"muito"
+	]
+};
+const LANGUAGES = Object.keys(COMMON_WORDS);
+const WORDS = new Map(LANGUAGES.map((language) => [language, new Set(COMMON_WORDS[language])]));
+function guessLanguage(text, among = LANGUAGES) {
+	const words = text.toLowerCase().match(/[\p{L}]+(?:'(?:hui))?/gu) ?? [];
+	const [best, second] = among.map((language) => ({
+		language,
+		score: words.filter((word) => WORDS.get(language)?.has(word)).length
+	})).sort((a, b) => b.score - a.score);
+	if (!best || best.score < 2) return void 0;
+	return best.score > (second?.score ?? 0) ? best.language : void 0;
+}
+//#endregion
+//#region ../charmd/src/voice/models.ts
+const RELEASES = "https://github.com/k2-fsa/sherpa-onnx/releases/download";
+const MODELS = {
+	parakeet: {
+		label: "Parakeet (listening)",
+		url: `${RELEASES}/asr-models/sherpa-onnx-nemo-parakeet-tdt-0.6b-v3-int8.tar.bz2`,
+		sha256: "5793d0fd397c5778d2cf2126994d58e9d56b1be7c04d13c7a15bb1b4eafb16bf",
+		bytes: 487170055,
+		folder: "sherpa-onnx-nemo-parakeet-tdt-0.6b-v3-int8",
+		files: [
+			"encoder.int8.onnx",
+			"decoder.int8.onnx",
+			"joiner.int8.onnx",
+			"tokens.txt"
+		]
+	},
+	supertonic: {
+		label: "Supertonic (speaking)",
+		url: `${RELEASES}/tts-models/sherpa-onnx-supertonic-3-tts-int8-2026-05-11.tar.bz2`,
+		sha256: "82fa96f91c4ef8abaae3a14a3f4153facf88bed821d1f7331cec2700f432c427",
+		bytes: 128774318,
+		folder: "sherpa-onnx-supertonic-3-tts-int8-2026-05-11",
+		files: [
+			"duration_predictor.int8.onnx",
+			"text_encoder.int8.onnx",
+			"vector_estimator.int8.onnx",
+			"vocoder.int8.onnx",
+			"tts.json",
+			"unicode_indexer.bin",
+			"voice.bin"
+		]
+	}
+};
+var VoiceNotReady = class extends Error {};
+const ABANDONED_MS = 36e5;
+const states = /* @__PURE__ */ new Map();
+const installing = /* @__PURE__ */ new Map();
+function defaultModelsDir() {
+	return join(homedir(), ".opencharm", "models");
+}
+function isInstalled(spec, dir) {
+	return spec.files.every((file) => existsSync(join(dir, spec.folder, file)));
+}
+function untar(archive, into) {
+	return new Promise((resolve, reject) => {
+		execFile("tar", [
+			"-xjf",
+			archive,
+			"-C",
+			into
+		], (error, _out, stderr) => {
+			if (!error) resolve();
+			else reject(/* @__PURE__ */ new Error(`Couldn't unpack the model: ${stderr.trim().slice(0, 200) || error.message}`));
+		});
+	});
+}
+async function download(spec, archive, options) {
+	const response = await fetch(spec.url, { signal: options.signal ?? null });
+	if (!response.ok || !response.body) throw new Error(`Couldn't download ${spec.label}: ${response.status} ${response.statusText}`);
+	const total = Number(response.headers.get("content-length")) || spec.bytes;
+	const hash = createHash("sha256");
+	let received = 0;
+	const body = Readable.fromWeb(response.body);
+	body.on("data", (chunk) => {
+		hash.update(chunk);
+		received += chunk.length;
+		if (spec.bytes && received > spec.bytes) body.destroy(/* @__PURE__ */ new Error(`${spec.label} was bigger than expected, so it was discarded`));
+		else options.onProgress?.(received, total);
+	});
+	await pipeline(body, createWriteStream(archive, { mode: 384 }), { ...options.signal ? { signal: options.signal } : {} });
+	if (spec.bytes && received !== spec.bytes || hash.digest("hex") !== spec.sha256) throw new Error(`${spec.label} didn't match its pinned checksum, so it was discarded`);
+}
+function removeAbandoned(dir, folder) {
+	for (const name of readdirSync(dir)) {
+		if (!name.startsWith(`.download-${folder}-`)) continue;
+		const path = join(dir, name);
+		try {
+			if (Date.now() - statSync(path).mtimeMs > ABANDONED_MS) rmSync(path, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+	}
+}
+async function install(spec, dir, options) {
+	mkdirSync(dir, { recursive: true });
+	removeAbandoned(dir, spec.folder);
+	const temp = join(dir, `.download-${spec.folder}-${randomBytes(6).toString("hex")}`);
+	mkdirSync(temp);
+	try {
+		const archive = join(temp, "model.tar.bz2");
+		await download(spec, archive, options);
+		const unpacked = join(temp, "unpacked");
+		mkdirSync(unpacked);
+		await untar(archive, unpacked);
+		if (!isInstalled(spec, unpacked)) throw new Error(`${spec.label} is missing files`);
+		rmSync(join(dir, spec.folder), {
+			recursive: true,
+			force: true
+		});
+		renameSync(join(unpacked, spec.folder), join(dir, spec.folder));
+		return join(dir, spec.folder);
+	} finally {
+		rmSync(temp, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+function modelState(id, dir = defaultModelsDir()) {
+	if (isInstalled(MODELS[id], dir)) return { state: "ready" };
+	return states.get(join(dir, id)) ?? { state: "missing" };
+}
+function installModel(id, options = {}) {
+	const spec = options.spec ?? MODELS[id];
+	const dir = options.dir ?? defaultModelsDir();
+	if (isInstalled(spec, dir)) return Promise.resolve(join(dir, spec.folder));
+	const key = join(dir, id);
+	const running = installing.get(key);
+	if (running) return running;
+	states.set(key, {
+		state: "downloading",
+		received: 0,
+		total: spec.bytes
+	});
+	const work = install(spec, dir, {
+		...options,
+		onProgress: (received, total) => {
+			states.set(key, {
+				state: "downloading",
+				received,
+				total
+			});
+			options.onProgress?.(received, total);
+		}
+	}).then((path) => {
+		states.set(key, { state: "ready" });
+		return path;
+	}).catch((error) => {
+		states.set(key, {
+			state: "failed",
+			error: error instanceof Error ? error.message : String(error),
+			at: Date.now()
+		});
+		throw error;
+	}).finally(() => installing.delete(key));
+	installing.set(key, work);
+	return work;
+}
+//#endregion
+//#region ../charmd/src/voice/packets.ts
+function asError(problem) {
+	if (problem instanceof Error) return problem;
+	return new Error(typeof problem === "string" ? problem : "The voice failed");
+}
+var PacketStream = class {
+	#packets = [];
+	#done = false;
+	#error;
+	#waiters = [];
+	constructor(source) {
+		this.#pump(source);
+	}
+	async #pump(source) {
+		try {
+			for await (const packet of source) {
+				this.#packets.push(packet);
+				this.#wake();
+			}
+		} catch (error) {
+			this.#error = asError(error);
+		} finally {
+			this.#done = true;
+			this.#wake();
+		}
+	}
+	#wake() {
+		for (const waiter of this.#waiters.splice(0)) waiter();
+	}
+	#next() {
+		return new Promise((resolve) => this.#waiters.push(resolve));
+	}
+	async first() {
+		while (this.#packets.length === 0) {
+			if (this.#error !== void 0) throw this.#error;
+			if (this.#done) throw new Error("The voice produced no audio");
+			await this.#next();
+		}
+	}
+	async *[Symbol.asyncIterator]() {
+		let index = 0;
+		for (;;) {
+			if (index < this.#packets.length) {
+				yield this.#packets[index++];
+				continue;
+			}
+			if (this.#error !== void 0) throw this.#error;
+			if (this.#done) return;
+			await this.#next();
+		}
+	}
+};
+function packetsOf(speaker, text, signal, language) {
+	if (speaker.stream) return speaker.stream(text, signal, language);
+	return (async function* () {
+		yield* readOggOpus(await speaker.synthesize(text, signal, language)).packets;
+	})();
+}
+function createChannel() {
+	const items = [];
+	let done = false;
+	let error;
+	let waiter;
+	const wake = () => {
+		waiter?.();
+		waiter = void 0;
+	};
+	return {
+		push(item) {
+			items.push(item);
+			wake();
+		},
+		end() {
+			done = true;
+			wake();
+		},
+		fail(problem) {
+			error = asError(problem);
+			done = true;
+			wake();
+		},
+		async *[Symbol.asyncIterator]() {
+			for (;;) {
+				const item = items.shift();
+				if (item !== void 0) {
+					yield item;
+					continue;
+				}
+				if (error !== void 0) throw error;
+				if (done) return;
+				await new Promise((resolve) => waiter = resolve);
+			}
+		}
+	};
+}
+//#endregion
 //#region ../charmd/src/turn/sentences.ts
 const MIN_CHARS = 10;
 const ABBREVIATIONS = /* @__PURE__ */ new Set([
@@ -2635,9 +3214,12 @@ const ABBREVIATIONS = /* @__PURE__ */ new Set([
 	"no."
 ]);
 const BOUNDARY = /[.!?…]+(?=\s)|\n+/g;
+const FIRST_BOUNDARY = /[.!?…]+(?=\s)|[,;:](?=\s)|\n+/g;
+const FIRST_CLAUSE_CHARS = 20;
 var SentenceSplitter = class {
 	#buffer = "";
 	#pending = "";
+	#started = false;
 	#take(piece) {
 		const text = piece.replace(/\s+/g, " ").trim();
 		if (!text) return [];
@@ -2645,14 +3227,16 @@ var SentenceSplitter = class {
 		if (this.#pending.length < MIN_CHARS) return [];
 		const out = this.#pending;
 		this.#pending = "";
+		this.#started = true;
 		return [out];
 	}
 	push(chunk) {
 		this.#buffer += chunk;
 		const out = [];
 		let start = 0;
-		for (const match of this.#buffer.matchAll(BOUNDARY)) {
+		for (const match of this.#buffer.matchAll(this.#started ? BOUNDARY : FIRST_BOUNDARY)) {
 			const end = match.index + match[0].length;
+			if (/^[,;:]/.test(match[0]) && (this.#started || this.#pending.length + end - start < FIRST_CLAUSE_CHARS)) continue;
 			const lastWord = this.#buffer.slice(start, end).trim().split(/\s+/).at(-1)?.toLowerCase() ?? "";
 			if (match[0].startsWith(".") && ABBREVIATIONS.has(lastWord)) continue;
 			out.push(...this.#take(this.#buffer.slice(start, end)));
@@ -2675,12 +3259,13 @@ function cleanForSpeech(text) {
 //#endregion
 //#region ../charmd/src/turn/turn.ts
 const MAX_FRAMES = 1e3;
+const LOOKAHEAD = 2;
 const AGENT_LABELS = { ...Object.fromEntries(Object.entries(ACP_AGENTS).map(([name, agent]) => [name, agent.label])) };
 var TurnTimeout = class extends Error {};
 var StageError = class extends Error {
 	stage;
 	constructor(stage, cause) {
-		super(cause instanceof Error ? cause.message : String(cause));
+		super(cause instanceof Error ? cause.message : String(cause), { cause });
 		this.stage = stage;
 	}
 };
@@ -2742,6 +3327,10 @@ var TurnController = class {
 		});
 		this.#speaking = false;
 	}
+	warm() {
+		this.#deps.agent.warm?.(this.#deps.sessionKey);
+		this.#deps.voice.warm?.().catch(() => void 0);
+	}
 	listenStart() {
 		if (this.#state === "thinking" || this.#state === "speaking") this.#cancel();
 		this.#state = "listening";
@@ -2783,6 +3372,21 @@ var TurnController = class {
 		let outcome = "done";
 		const startClock = () => setTimeout(() => controller.abort(new TurnTimeout()), this.#deps.timeoutMs);
 		let timer = startClock();
+		let speakingStarted = false;
+		let asking = false;
+		const restartClock = () => {
+			clearTimeout(timer);
+			timer = startClock();
+		};
+		const clock = {
+			started: () => {
+				speakingStarted = true;
+				restartClock();
+			},
+			touch: () => {
+				if (speakingStarted && !asking) restartClock();
+			}
+		};
 		const timeoutGuard = new Promise((_, reject) => signal.addEventListener("abort", () => {
 			if (signal.reason instanceof TurnTimeout) reject(signal.reason);
 		}));
@@ -2807,6 +3411,7 @@ var TurnController = class {
 			const ask = this.#deps.ask;
 			const label = AGENT_LABELS[this.#deps.agent.name] ?? "Your agent";
 			if (ask) this.#asking = async (text, options) => {
+				asking = true;
 				clearTimeout(timer);
 				try {
 					return await ask(text, {
@@ -2814,6 +3419,7 @@ var TurnController = class {
 						signal
 					});
 				} finally {
+					asking = false;
 					if (!signal.aborted) timer = startClock();
 				}
 			};
@@ -2823,7 +3429,7 @@ var TurnController = class {
 				signal,
 				...ask ? { ask: (action) => this.ask(`${label} wants to ${action}.`) } : {}
 			});
-			said = await this.#speak(reply, signal, live, timings, started, timeoutGuard);
+			said = await this.#speak(reply, signal, live, timings, started, timeoutGuard, guessLanguage(heard) ?? this.#deps.voice.language ?? "en", clock);
 			if (!live()) return;
 			if (this.#speaking) this.#deps.send({
 				type: "tts",
@@ -2835,6 +3441,7 @@ var TurnController = class {
 			this.#endFace = void 0;
 			this.#face(end.state, end.text);
 		} catch (error) {
+			if (!signal.aborted) controller.abort(error);
 			outcome = error instanceof TurnTimeout ? "timeout" : error instanceof StageError ? `${error.stage}-error` : "error";
 			if (!live()) return;
 			if (this.#speaking) this.#deps.send({
@@ -2864,9 +3471,18 @@ var TurnController = class {
 			});
 		}
 	}
-	async #speak(source, signal, live, timings, started, timeoutGuard) {
+	async #speak(source, signal, live, timings, started, timeoutGuard, language, clock) {
 		const now = this.#deps.now ?? Date.now;
+		const going = () => live() && !signal.aborted;
+		let speaking = language;
 		const queue = [];
+		let playing = 0;
+		const startUpTo = (end) => {
+			for (let i = playing; i < Math.min(end, queue.length); i++) {
+				const item = queue[i];
+				item.packets ??= new PacketStream(packetsOf(this.#deps.voice, item.text, signal, item.language));
+			}
+		};
 		let wake = () => void 0;
 		let sourceDone = false;
 		let said = "";
@@ -2874,19 +3490,23 @@ var TurnController = class {
 			const text = cleanForSpeech(sentence);
 			if (!text) return;
 			said += `${text} `;
-			const pending = inStage("tts", () => this.#deps.voice.synthesize(text, signal)).then((audio) => ({
+			speaking = guessLanguage(text) ?? speaking;
+			const sentenceLanguage = speaking;
+			timings.firstSentenceMs ??= now() - started;
+			queue.push({
 				text,
-				ogg: audio
-			}));
-			pending.catch(() => void 0);
-			queue.push(pending);
+				language: sentenceLanguage
+			});
+			startUpTo(playing + LOOKAHEAD);
 			wake();
 		};
 		const produce = (async () => {
 			const splitter = new SentenceSplitter();
 			await inStage("agent", async () => {
 				for await (const chunk of source) {
-					if (!live()) return;
+					if (!going()) return;
+					timings.agentFirstMs ??= now() - started;
+					clock.touch();
 					for (const sentence of splitter.push(chunk)) enqueue(sentence);
 				}
 			});
@@ -2897,19 +3517,23 @@ var TurnController = class {
 		});
 		produce.catch(() => void 0);
 		const play = async () => {
-			let index = 0;
 			for (;;) {
-				if (index >= queue.length) {
+				if (!going()) return;
+				if (playing >= queue.length) {
 					if (sourceDone) return;
 					await new Promise((resolve) => wake = resolve);
 					continue;
 				}
-				const { text, ogg } = await Promise.race([queue[index++], timeoutGuard]);
-				if (!live()) return;
+				startUpTo(playing + LOOKAHEAD);
+				const { text, packets } = queue[playing];
+				if (!packets) throw new Error("A sentence wasn't started");
+				await Promise.race([inStage("tts", () => packets.first()), timeoutGuard]);
+				if (!going()) return;
 				if (!this.#speaking) {
 					this.#speaking = true;
 					this.#state = "speaking";
 					timings.firstAudioMs = now() - started;
+					clock.started();
 					this.#deps.send({
 						type: "tts",
 						state: "start"
@@ -2920,7 +3544,8 @@ var TurnController = class {
 					state: "sentence_start",
 					text
 				});
-				await this.#sendPaced(readOggOpus(ogg).packets, live);
+				await Promise.race([inStage("tts", () => this.#sendPaced(packets, going, clock.touch)), timeoutGuard]);
+				playing += 1;
 			}
 		};
 		await Promise.all([Promise.race([produce, timeoutGuard]), play()]);
@@ -2932,7 +3557,16 @@ var TurnController = class {
 		const live = () => this.#generation === generation;
 		const controller = new AbortController();
 		this.#controller = controller;
-		const timer = setTimeout(() => controller.abort(new TurnTimeout()), this.#deps.timeoutMs);
+		const startClock = () => setTimeout(() => controller.abort(new TurnTimeout()), this.#deps.timeoutMs);
+		let timer = startClock();
+		const restartClock = () => {
+			clearTimeout(timer);
+			timer = startClock();
+		};
+		const clock = {
+			started: restartClock,
+			touch: restartClock
+		};
 		const timeoutGuard = new Promise((_, reject) => controller.signal.addEventListener("abort", () => {
 			if (controller.signal.reason instanceof TurnTimeout) reject(controller.signal.reason);
 		}));
@@ -2941,7 +3575,7 @@ var TurnController = class {
 			yield await Promise.resolve(text);
 		}
 		try {
-			await this.#speak(once(), controller.signal, live, {}, Date.now(), timeoutGuard);
+			await this.#speak(once(), controller.signal, live, {}, Date.now(), timeoutGuard, guessLanguage(text) ?? this.#deps.voice.language ?? "en", clock);
 			if (!live()) return;
 			if (this.#speaking) this.#deps.send({
 				type: "tts",
@@ -2951,6 +3585,7 @@ var TurnController = class {
 			this.#state = "idle";
 			this.#face("idle");
 		} catch (error) {
+			if (!controller.signal.aborted) controller.abort(error);
 			if (!live()) return;
 			if (this.#speaking) this.#deps.send({
 				type: "tts",
@@ -2965,16 +3600,19 @@ var TurnController = class {
 	}
 	#failureLine(error) {
 		if (error instanceof TurnTimeout) return "That took too long.";
+		if (error instanceof StageError && error.cause instanceof VoiceNotReady) return error.cause.message;
 		if (error instanceof StageError && error.stage === "stt") return "I couldn't hear that.";
 		if (error instanceof StageError && error.stage === "tts") return "I couldn't speak that.";
 		return `Can't reach ${AGENT_LABELS[this.#deps.agent.name] ?? "your agent"}`;
 	}
-	async #sendPaced(packets, live) {
+	async #sendPaced(packets, live, onPacket) {
 		const sleep = this.#deps.sleep ?? sleepMs;
-		for (const [index, packet] of packets.entries()) {
+		let index = 0;
+		for await (const packet of packets) {
 			if (!live()) return;
 			this.#deps.sendAudio(packet);
-			if (index >= 2) await sleep(opusPacketSamples48k(packet) / 48);
+			onPacket();
+			if (index++ >= 2) await sleep(opusPacketSamples48k(packet) / 48);
 		}
 	}
 	dispose() {
@@ -3484,6 +4122,205 @@ function createLocalVoice(options) {
 	};
 }
 //#endregion
+//#region ../charmd/src/audio/webm-opus.ts
+const SEGMENT = 408125543;
+const CLUSTER = 524531317;
+const BLOCK_GROUP = 160;
+const BLOCK = 161;
+const SIMPLE_BLOCK = 163;
+const CONTAINERS = /* @__PURE__ */ new Set([
+	SEGMENT,
+	CLUSTER,
+	BLOCK_GROUP
+]);
+var CutShort = class extends Error {};
+function readVint(data, offset, keepMarker) {
+	const first = data[offset];
+	if (first === void 0) throw new CutShort();
+	if (first === 0) throw new Error("Not a WebM file: bad element header");
+	const length = Math.clz32(first) - 23;
+	if (offset + length > data.length) throw new CutShort();
+	let value = keepMarker ? first : first & 255 >> length;
+	let allOnes = value === 255 >> length;
+	for (let i = 1; i < length; i++) {
+		const byte = data[offset + i];
+		value = value * 256 + byte;
+		allOnes &&= byte === 255;
+	}
+	return {
+		value,
+		length,
+		unknown: !keepMarker && allOnes
+	};
+}
+function frameOf(block) {
+	const track = readVint(block, 0, false);
+	const flags = block[track.length + 2];
+	if (flags === void 0) throw new Error("Not a WebM file: empty block");
+	if (flags & 6) throw new Error("WebM lacing isn't supported");
+	return block.subarray(track.length + 3);
+}
+function parse(data) {
+	const packets = [];
+	let offset = 0;
+	while (offset < data.length) {
+		let id;
+		let size;
+		try {
+			id = readVint(data, offset, true);
+			size = readVint(data, offset + id.length, false);
+		} catch (error) {
+			if (error instanceof CutShort) break;
+			throw error;
+		}
+		const body = offset + id.length + size.length;
+		if (CONTAINERS.has(id.value)) {
+			offset = body;
+			continue;
+		}
+		if (size.unknown) throw new Error("Not a WebM file: an element of unknown size");
+		const end = body + size.value;
+		if (end > data.length) break;
+		if (id.value === SIMPLE_BLOCK || id.value === BLOCK) {
+			const frame = frameOf(data.subarray(body, end));
+			if (frame.length) packets.push(frame);
+		}
+		offset = end;
+	}
+	return {
+		packets,
+		consumed: offset
+	};
+}
+var WebmOpusReader = class {
+	#pending = Buffer.alloc(0);
+	push(chunk) {
+		this.#pending = Buffer.concat([this.#pending, chunk]);
+		const { packets, consumed } = parse(this.#pending);
+		this.#pending = this.#pending.subarray(consumed);
+		return packets;
+	}
+	get complete() {
+		return this.#pending.length === 0;
+	}
+};
+//#endregion
+//#region ../charmd/src/voice/microsoft.ts
+const TRUSTED_CLIENT_TOKEN = "6A5AA1D4EAFF4E9FB37E23D68491D6F4";
+const SERVICE_URL = "wss://speech.platform.bing.com/consumer/speech/synthesize/readaloud/edge/v1";
+const GEC_VERSION = "1-143.0.3650.96";
+const USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0";
+const ORIGIN = "chrome-extension://jdiccldimpdaibmpdkjnbmckianbfold";
+const OUTPUT_FORMAT = "webm-24khz-16bit-mono-opus";
+const DEFAULT_VOICES = {
+	en: "en-US-AvaMultilingualNeural",
+	it: "it-IT-IsabellaNeural",
+	es: "es-ES-ElviraNeural",
+	fr: "fr-FR-DeniseNeural",
+	de: "de-DE-KatjaNeural",
+	pt: "pt-BR-FranciscaNeural"
+};
+const WINDOWS_EPOCH_SECONDS = 11644473600;
+function secMsGec(nowMs = Date.now()) {
+	const seconds = Math.floor(nowMs / 1e3) + WINDOWS_EPOCH_SECONDS;
+	const ticks = BigInt(seconds - seconds % 300) * 10000000n;
+	return createHash("sha256").update(`${ticks}${TRUSTED_CLIENT_TOKEN}`).digest("hex").toUpperCase();
+}
+function escapeXml(text) {
+	return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function ssml(text, voice) {
+	return `<speak version='1.0' xmlns='http://www.w3.org/2001/10/synthesis' xml:lang='${voice.split("-").slice(0, 2).join("-")}'><voice name='${voice}'><prosody pitch='+0Hz' rate='+0%' volume='+0%'>${escapeXml(text)}</prosody></voice></speak>`;
+}
+function message(path, contentType, body, requestId) {
+	return `X-Timestamp:${(/* @__PURE__ */ new Date()).toISOString()}\r\n` + (requestId ? `X-RequestId:${requestId}\r\n` : "") + `Content-Type:${contentType}\r\nPath:${path}\r\n\r\n${body}`;
+}
+function audioOf(frame) {
+	if (frame.length < 2) return void 0;
+	const headerLength = frame.readUInt16BE(0);
+	return frame.subarray(2, 2 + headerLength).toString().includes("Path:audio") ? frame.subarray(2 + headerLength) : void 0;
+}
+function voiceFor(language, voices) {
+	return voices[language] ?? voices.en ?? DEFAULT_VOICES.en;
+}
+function connect(text, language, voices, signal, options) {
+	const timeoutMs = options.timeoutMs ?? 15e3;
+	const connection = randomUUID().replace(/-/g, "");
+	const url = `${options.url ?? SERVICE_URL}?TrustedClientToken=${TRUSTED_CLIENT_TOKEN}&Sec-MS-GEC=${secMsGec()}&Sec-MS-GEC-Version=${GEC_VERSION}&ConnectionId=${connection}`;
+	const packets = createChannel();
+	const reader = new WebmOpusReader();
+	let sent = 0;
+	let settled = false;
+	const socket = new WebSocket(url, {
+		headers: {
+			"User-Agent": USER_AGENT,
+			Origin: ORIGIN
+		},
+		handshakeTimeout: timeoutMs
+	});
+	const finish = (error) => {
+		if (settled) return;
+		settled = true;
+		clearTimeout(timer);
+		signal.removeEventListener("abort", onAbort);
+		socket.terminate();
+		if (error) packets.fail(error);
+		else if (sent === 0) packets.fail(/* @__PURE__ */ new Error("Microsoft's voice sent no audio"));
+		else packets.end();
+	};
+	const onAbort = () => finish(signal.reason instanceof Error ? signal.reason : /* @__PURE__ */ new Error("Aborted"));
+	const timer = setTimeout(() => finish(/* @__PURE__ */ new Error("Microsoft's voice took too long")), timeoutMs);
+	if (signal.aborted) onAbort();
+	else signal.addEventListener("abort", onAbort, { once: true });
+	socket.on("open", () => {
+		socket.send(message("speech.config", "application/json; charset=utf-8", JSON.stringify({ context: { synthesis: { audio: {
+			metadataoptions: {
+				sentenceBoundaryEnabled: "false",
+				wordBoundaryEnabled: "false"
+			},
+			outputFormat: OUTPUT_FORMAT
+		} } } })));
+		socket.send(message("ssml", "application/ssml+xml", ssml(text, voiceFor(language, voices)), connection));
+	});
+	socket.on("message", (data, isBinary) => {
+		const frame = Buffer.isBuffer(data) ? data : Buffer.concat(data);
+		if (!isBinary) {
+			if (frame.toString().includes("Path:turn.end")) finish();
+			return;
+		}
+		const audio = audioOf(frame);
+		if (!audio?.length) return;
+		try {
+			for (const packet of reader.push(audio)) {
+				sent += 1;
+				packets.push(packet);
+			}
+		} catch (error) {
+			finish(error instanceof Error ? error : new Error(String(error)));
+		}
+	});
+	socket.on("unexpected-response", (_request, response) => finish(/* @__PURE__ */ new Error(`Microsoft's voice refused the request: ${response.statusCode}`)));
+	socket.on("error", (error) => finish(/* @__PURE__ */ new Error(`Microsoft's voice failed: ${error.message}`)));
+	socket.on("close", () => finish(/* @__PURE__ */ new Error("Microsoft's voice closed before it finished")));
+	return packets;
+}
+function createMicrosoftSpeaker(options = {}) {
+	const voices = {
+		...DEFAULT_VOICES,
+		...options.voices
+	};
+	const stream = (text, signal, language = "en") => connect(text, language, voices, signal, options);
+	return {
+		name: "microsoft",
+		stream,
+		async synthesize(text, signal, language = "en") {
+			const packets = [];
+			for await (const packet of stream(text, signal, language)) packets.push(packet);
+			return writeOggOpus(packets, { inputSampleRate: 24e3 });
+		}
+	};
+}
+//#endregion
 //#region ../charmd/src/voice/openai.ts
 function createOpenAiVoice(options) {
 	const apiKey = options.apiKey ?? process.env.OPENAI_API_KEY;
@@ -3527,22 +4364,260 @@ function createOpenAiVoice(options) {
 	};
 }
 //#endregion
+//#region ../charmd/src/voice/sherpa.ts
+const SUPERTONIC_LANGUAGES = /* @__PURE__ */ new Set([
+	"en",
+	"it",
+	"es",
+	"fr",
+	"de",
+	"pt"
+]);
+const DEFAULT_SPEAKER = 5;
+const OUTPUT_RATE = 24e3;
+let sherpa;
+function loadSherpa() {
+	if (sherpa) return sherpa;
+	try {
+		sherpa = createRequire(import.meta.url)("sherpa-onnx-node");
+		return sherpa;
+	} catch (error) {
+		throw new Error(`The local voice can't run on this computer: sherpa-onnx didn't load (${error instanceof Error ? error.message.split("\n")[0] : String(error)})`, { cause: error });
+	}
+}
+function ready(id, dir) {
+	const state = modelState(id, dir);
+	if (state.state === "ready") return join(dir, MODELS[id].folder);
+	if (state.state === "failed" && Date.now() - state.at < 3e5) throw new VoiceNotReady(`Couldn't get ${MODELS[id].label}: ${state.error}`.slice(0, 160));
+	if (state.state !== "downloading") installModel(id, { dir }).catch(() => void 0);
+	const now = modelState(id, dir);
+	const percent = now.state === "downloading" && now.total ? ` (${Math.floor(now.received * 100 / now.total)}%)` : "";
+	throw new VoiceNotReady(`${MODELS[id].label} is still downloading${percent}`);
+}
+function toFloat(pcm) {
+	const out = new Float32Array(pcm.length / 2);
+	for (let i = 0; i < out.length; i++) out[i] = pcm.readInt16LE(i * 2) / 32768;
+	return out;
+}
+function toPcm(samples) {
+	const out = Buffer.alloc(samples.length * 2);
+	for (let i = 0; i < samples.length; i++) out.writeInt16LE(Math.round(Math.max(-1, Math.min(1, samples[i] ?? 0)) * 32767), i * 2);
+	return out;
+}
+function createParakeetListener(options = {}) {
+	const dir = options.modelsDir ?? defaultModelsDir();
+	let recognizer;
+	const load = () => {
+		const folder = ready("parakeet", dir);
+		recognizer ??= loadSherpa().OfflineRecognizer.createAsync({
+			featConfig: {
+				sampleRate: 16e3,
+				featureDim: 80
+			},
+			modelConfig: {
+				transducer: {
+					encoder: join(folder, "encoder.int8.onnx"),
+					decoder: join(folder, "decoder.int8.onnx"),
+					joiner: join(folder, "joiner.int8.onnx")
+				},
+				tokens: join(folder, "tokens.txt"),
+				modelType: "nemo_transducer",
+				numThreads: options.threads ?? 4,
+				provider: "cpu"
+			}
+		}).catch((error) => {
+			recognizer = void 0;
+			throw error;
+		});
+		return recognizer;
+	};
+	return {
+		name: "local",
+		warm: async () => {
+			await load();
+		},
+		async transcribe(ogg) {
+			const engine = await load();
+			const stream = engine.createStream();
+			stream.acceptWaveform({
+				samples: toFloat(oggOpusToPcm(ogg, 16e3)),
+				sampleRate: 16e3
+			});
+			return ((await engine.decodeAsync(stream)).text ?? "").replace(/\s+/g, " ").trim();
+		}
+	};
+}
+function createSupertonicSpeaker(options = {}) {
+	const dir = options.modelsDir ?? defaultModelsDir();
+	let tts;
+	const load = () => {
+		const folder = ready("supertonic", dir);
+		const file = (name) => join(folder, name);
+		tts ??= loadSherpa().OfflineTts.createAsync({
+			model: {
+				supertonic: {
+					durationPredictor: file("duration_predictor.int8.onnx"),
+					textEncoder: file("text_encoder.int8.onnx"),
+					vectorEstimator: file("vector_estimator.int8.onnx"),
+					vocoder: file("vocoder.int8.onnx"),
+					ttsJson: file("tts.json"),
+					unicodeIndexer: file("unicode_indexer.bin"),
+					voiceStyle: file("voice.bin")
+				},
+				numThreads: options.threads ?? 4,
+				provider: "cpu"
+			},
+			maxNumSentences: 1
+		}).catch((error) => {
+			tts = void 0;
+			throw error;
+		});
+		return tts;
+	};
+	return {
+		name: "local",
+		onDevice: true,
+		warm: async () => {
+			await load();
+		},
+		async synthesize(text, signal, language = "en") {
+			const engine = await load();
+			const sherpaModule = loadSherpa();
+			const audio = await engine.generateAsync({
+				text,
+				generationConfig: new sherpaModule.GenerationConfig({
+					sid: options.speaker ?? DEFAULT_SPEAKER,
+					numSteps: 8,
+					extra: { lang: SUPERTONIC_LANGUAGES.has(language) ? language : "en" }
+				}),
+				onProgress: () => signal.aborted ? 0 : 1
+			});
+			signal.throwIfAborted();
+			return pcmToOggOpus(toPcm(audio.sampleRate === OUTPUT_RATE ? audio.samples : new sherpaModule.LinearResampler(audio.sampleRate, OUTPUT_RATE).flush(audio.samples)), OUTPUT_RATE);
+		}
+	};
+}
+//#endregion
+//#region ../charmd/src/voice/speak.ts
+const FIRST_AUDIO_MS = 3e3;
+const REST_MS = 6e4;
+async function firstWithin(packets, ms, name) {
+	let timer;
+	try {
+		await Promise.race([packets.first(), new Promise((_, reject) => {
+			timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`${name} had no audio within ${ms} ms`)), ms);
+		})]);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+function speakWithFallback(chain, options = {}) {
+	const [first] = chain;
+	if (!first) throw new Error("No voice to speak with");
+	if (chain.length === 1) return first;
+	const now = options.now ?? Date.now;
+	const resting = /* @__PURE__ */ new Map();
+	async function* stream(text, signal, language) {
+		let lastError;
+		for (const [index, speaker] of chain.entries()) {
+			const last = index === chain.length - 1;
+			if (!last && (resting.get(speaker) ?? 0) > now()) continue;
+			const controller = new AbortController();
+			const abort = () => controller.abort(signal.reason);
+			signal.addEventListener("abort", abort, { once: true });
+			const packets = new PacketStream(packetsOf(speaker, text, controller.signal, language));
+			try {
+				if (last || speaker.onDevice) await packets.first();
+				else await firstWithin(packets, options.timeoutMs ?? FIRST_AUDIO_MS, speaker.name);
+			} catch (error) {
+				signal.removeEventListener("abort", abort);
+				controller.abort(error);
+				signal.throwIfAborted();
+				lastError = error;
+				resting.set(speaker, now() + (options.restMs ?? REST_MS));
+				continue;
+			}
+			try {
+				yield* packets;
+			} finally {
+				signal.removeEventListener("abort", abort);
+			}
+			return;
+		}
+		throw lastError instanceof Error ? lastError : new Error(String(lastError));
+	}
+	return {
+		name: first.name,
+		stream,
+		async synthesize(text, signal, language) {
+			const packets = [];
+			for await (const packet of stream(text, signal, language)) packets.push(packet);
+			return writeOggOpus(packets, { inputSampleRate: 24e3 });
+		},
+		warm: async () => {
+			await Promise.allSettled(chain.map((speaker) => speaker.warm?.() ?? Promise.resolve()));
+		}
+	};
+}
+//#endregion
 //#region ../charmd/src/wiring.ts
 function key(config, fallbackEnv) {
 	const env = config.apiKeyEnv ?? fallbackEnv;
 	return config.apiKey ?? (env ? process.env[env] : void 0);
 }
-function createVoiceFromConfig(config) {
-	const voice = config.voice;
-	switch (voice.provider) {
-		case "fake": return createFakeVoice({ transcript: voice.transcript });
-		case "local": return createLocalVoice(voice);
+function createListener(config) {
+	switch (config.provider) {
+		case "fake": return createFakeVoice(config);
+		case "local": return createParakeetListener();
+		case "whisper": return createLocalVoice({
+			...config.model ? { whisperModel: config.model } : {},
+			...config.command ? { whisperCommand: config.command } : {}
+		});
 		case "openai": return createOpenAiVoice({
-			...voice,
-			apiKey: key(voice, "OPENAI_API_KEY")
+			...config,
+			apiKey: key(config, "OPENAI_API_KEY"),
+			...config.model ? { sttModel: config.model } : {}
 		});
 	}
 }
+function createSpeaker(config) {
+	switch (config.provider) {
+		case "fake": return createFakeVoice();
+		case "microsoft": return createMicrosoftSpeaker(config.voices ? { voices: config.voices } : {});
+		case "local": return createSupertonicSpeaker(config.speaker === void 0 ? {} : { speaker: config.speaker });
+		case "system": return {
+			...createLocalVoice(config.voice ? { sayVoice: config.voice } : {}),
+			name: "system",
+			onDevice: true
+		};
+		case "openai": return createOpenAiVoice({
+			...config,
+			apiKey: key(config, "OPENAI_API_KEY"),
+			...config.model ? { ttsModel: config.model } : {}
+		});
+	}
+}
+function speakerChain(config) {
+	if (config.provider === "fake" || config.provider === "system") return createSpeaker(config);
+	const chain = [createSpeaker(config)];
+	if (config.provider === "microsoft") chain.push(createSupertonicSpeaker());
+	if (process.platform === "darwin") chain.push(createSpeaker({ provider: "system" }));
+	return speakWithFallback(chain);
+}
+function createVoiceFromConfig(config) {
+	const listener = createListener(config.voice.listen);
+	const speaker = speakerChain(config.voice.speak);
+	return {
+		name: listener.name === speaker.name ? listener.name : `${listener.name}+${speaker.name}`,
+		transcribe: listener.transcribe,
+		synthesize: speaker.synthesize,
+		...speaker.stream ? { stream: speaker.stream } : {},
+		language: config.voice.language,
+		warm: async () => {
+			await Promise.allSettled([listener.warm?.(), speaker.warm?.()]);
+		}
+	};
+}
 function charmToolsServers(config, tools) {
 	const agent = config.agent;
 	if (agent.adapter !== "acp" || !agent.charmTools || !tools) return [];
@@ -3595,6 +4670,7 @@ async function startDaemon(config, options = {}) {
 	});
 	const sessions = /* @__PURE__ */ new Map();
 	const voice = createVoiceFromConfig(config);
+	voice.warm?.().catch(() => void 0);
 	const log = options.log ?? ((entry) => {
 		if (!options.quiet) console.log(JSON.stringify({
 			time: (/* @__PURE__ */ new Date()).toISOString(),
@@ -3612,7 +4688,17 @@ async function startDaemon(config, options = {}) {
 		pairing,
 		sessions: () => sessions.values(),
 		look,
-		agentCanChangeLook
+		agentCanChangeLook,
+		identity: options.identity,
+		starter: options.starter,
+		voice: () => {
+			const downloading = ["parakeet", "supertonic"].flatMap((id) => {
+				const state = modelState(id);
+				if (state.state === "failed") return [`${MODELS[id].label} failed`];
+				return state.state === "downloading" && state.total ? [`${MODELS[id].label} downloading ${Math.floor(state.received * 100 / state.total)}%`] : [];
+			});
+			return [voice.name, ...downloading].join(" · ");
+		}
 	});
 	const adminServer = await startAdminServer(config.adminSocket, admin);
 	let websocketUrl = config.publicUrl ?? "";
@@ -3699,7 +4785,12 @@ async function startDaemon(config, options = {}) {
 	const { port } = http.address();
 	const url = `ws://${config.listen.host.includes(":") ? `[${config.listen.host}]` : config.listen.host}:${port}/charm`;
 	websocketUrl = config.publicUrl ?? url;
-	if (!options.quiet) console.log(`charmd listening on ${url}`);
+	if (!options.quiet) console.log([
+		"charmd",
+		options.identity,
+		"listening on",
+		url
+	].filter(Boolean).join(" "));
 	return {
 		url,
 		admin,
@@ -3714,14 +4805,53 @@ async function startDaemon(config, options = {}) {
 	};
 }
 //#endregion
+//#region src/identity.ts
+function git(cwd, ...args) {
+	return execFileSync("git", args, {
+		cwd,
+		encoding: "utf8",
+		stdio: [
+			"ignore",
+			"pipe",
+			"ignore"
+		]
+	}).trim();
+}
+function starterCommit(dir) {
+	try {
+		if (!existsSync(join(git(dir, "rev-parse", "--show-toplevel"), "opencharm.json"))) return void 0;
+		return git(dir, "rev-parse", "--short", git(dir, "merge-base", "HEAD", "upstream/HEAD"));
+	} catch {
+		return;
+	}
+}
+function formatIdentity(unit, version, commit) {
+	return `${unit}@${version} (${commit})`;
+}
+let cached;
+function identity() {
+	if (cached) return cached;
+	const commit = "7d76bc9";
+	cached = {
+		version: `cli@${version}`,
+		commit,
+		text: formatIdentity("cli", version, commit)
+	};
+	return cached;
+}
+//#endregion
 //#region src/commands/serve.ts
 async function runServe(ctx, args) {
 	let config;
 	let daemon;
 	try {
-		config = loadConfig(flagValue(args, "--config"));
+		const configPath = flagValue(args, "--config");
+		config = loadConfig(configPath);
+		const workspace = configPath ? dirname(resolve(configPath)) : existsSync("opencharm.json") ? process.cwd() : void 0;
 		daemon = await startDaemon(config, {
 			quiet: true,
+			identity: identity().text,
+			starter: workspace ? starterCommit(workspace) : void 0,
 			charmTools: {
 				command: process.execPath,
 				args: [
@@ -3740,7 +4870,7 @@ async function runServe(ctx, args) {
 		process.exitCode = 1;
 		return;
 	}
-	ctx.out.write(`charmd (the charm daemon) is listening on ${daemon.url}\n`);
+	ctx.out.write(`charmd (the charm daemon) ${identity().text} is listening on ${daemon.url}\n`);
 	ctx.out.write(`Admin socket: ${config.adminSocket}\n`);
 	ctx.out.write("Pair a charm: opencharm pair <code>   Stop: Ctrl-C\n");
 	const stop = () => {
@@ -3750,6 +4880,45 @@ async function runServe(ctx, args) {
 	process.once("SIGTERM", stop);
 }
 //#endregion
+//#region src/commands/voice.ts
+const IDS = Object.keys(MODELS);
+function megabytes(bytes) {
+	return `${Math.round(bytes / 1e6)} MB`;
+}
+async function runVoice(ctx, args, deps = {}) {
+	const install = deps.install ?? installModel;
+	const state = deps.state ?? modelState;
+	const action = firstPositional(args) ?? "";
+	if (action !== "" && action !== "install") {
+		ctx.err.write(`Unknown voice command "${action}". Try: opencharm voice install\n`);
+		process.exitCode = 1;
+		return;
+	}
+	for (const id of IDS) {
+		const model = MODELS[id];
+		if (action === "") {
+			const ready = state(id).state === "ready";
+			ctx.out.write(`${model.label}: ${ready ? "installed" : `not downloaded yet (${megabytes(model.bytes)})`}\n`);
+			continue;
+		}
+		let shown = -1;
+		try {
+			await install(id, { onProgress: (received, total) => {
+				const percent = Math.floor(received * 100 / (total || model.bytes));
+				if (percent >= shown + 10) {
+					shown = percent - percent % 10;
+					ctx.out.write(`${model.label}: ${shown}%\n`);
+				}
+			} });
+			ctx.out.write(`${model.label}: installed\n`);
+		} catch (error) {
+			ctx.err.write(`${error instanceof Error ? error.message : String(error)}\n`);
+			process.exitCode = 1;
+			return;
+		}
+	}
+}
+//#endregion
 //#region src/commands/setup.ts
 const USER = "charmd";
 const STATE_DIR = "/var/lib/charmd";
@@ -3993,7 +5162,10 @@ function createSimServer(dir, charmdUrl) {
 			return;
 		}
 		if (path === "/config.json") {
-			res.writeHead(200, { "content-type": TYPES[".json"] }).end(JSON.stringify({ url: charmdUrl }));
+			res.writeHead(200, { "content-type": TYPES[".json"] }).end(JSON.stringify({
+				url: charmdUrl,
+				version: identity().version
+			}));
 			return;
 		}
 		const file = resolve(root, normalize(`.${path === "/" ? "/index.html" : path}`));
@@ -4086,7 +5258,7 @@ async function main(argv) {
 	const ctx = buildContext(argv);
 	const { command, rest, help, version } = parseArgs(argv);
 	if (version) {
-		ctx.out.write(`${ctx.version}\n`);
+		ctx.out.write(`${identity().text}\n`);
 		return;
 	}
 	if (help || command === "help") {
@@ -4121,6 +5293,9 @@ async function main(argv) {
 		case "serve":
 			await runServe(ctx, rest);
 			return;
+		case "voice":
+			await runVoice(ctx, rest);
+			return;
 		case "mcp": {
 			const socket = flagValue(rest, "--socket") ?? loadConfig(flagValue(rest, "--config")).adminSocket;
 			await serveMcp(process.stdin, process.stdout, {