opencharm 0.0.0 → 0.1.0

package/dist/main.mjs

@@ -0,0 +1,4157 @@
+#!/usr/bin/env node
+import { chmodSync, 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 { createHash, randomBytes, randomInt, randomUUID, scrypt, timingSafeEqual } from "node:crypto";
+import { createServer as createServer$1 } from "node:http";
+import { WebSocketServer } from "ws";
+import { Readable, Writable } from "node:stream";
+import * as acp from "@agentclientprotocol/sdk";
+import OpusScript from "opusscript";
+import { fileURLToPath } from "node:url";
+//#endregion
+//#region ../design/src/faces-data.ts
+const facesData = {
+	$comment: "Generated from packages/design/src/charm-face.js by packages/design/scripts/export-faces.ts. Edit the JS, then run npm run design:export.",
+	signal: "#FF5A1F",
+	colours: [
+		{
+			"id": "white",
+			"name": "White",
+			"c": "#FFFFFF",
+			"g": "#F4F3EE",
+			"key": "#1E1F22"
+		},
+		{
+			"id": "cobalt",
+			"name": "Cobalt",
+			"c": "#4574FF",
+			"g": "#9DB6FF",
+			"key": "#FFD166"
+		},
+		{
+			"id": "lime",
+			"name": "Lime",
+			"c": "#BDEB4E",
+			"g": "#D6F78A",
+			"key": "#1E1F22"
+		},
+		{
+			"id": "lilac",
+			"name": "Lilac",
+			"c": "#B39BFA",
+			"g": "#D2C4FF",
+			"key": "#1E1F22"
+		},
+		{
+			"id": "sun",
+			"name": "Sun",
+			"c": "#FFCD5C",
+			"g": "#FFDF93",
+			"key": "#1E1F22"
+		},
+		{
+			"id": "coal",
+			"name": "Coal",
+			"c": "#2B2C30",
+			"g": "#F4F3EE",
+			"key": "#FF5A1F"
+		}
+	],
+	faces: [
+		{
+			"id": "neutral",
+			"text": "o   o",
+			"t": "Neutral",
+			"L": "o",
+			"R": "o"
+		},
+		{
+			"id": "happy",
+			"text": "^   ^",
+			"t": "Happy",
+			"L": "^",
+			"R": "^"
+		},
+		{
+			"id": "joy",
+			"text": "^ v ^",
+			"t": "Joy",
+			"L": "^",
+			"R": "^",
+			"M": "v",
+			"sl": 1.06,
+			"sr": 1.06
+		},
+		{
+			"id": "cute",
+			"text": "^ w ^",
+			"t": "Cute",
+			"L": "^",
+			"R": "^",
+			"M": "w"
+		},
+		{
+			"id": "wink",
+			"text": "^   −",
+			"t": "Wink",
+			"L": "^",
+			"R": "−",
+			"tilt": -5
+		},
+		{
+			"id": "loved",
+			"text": "♥︎   ♥︎",
+			"t": "Loved",
+			"L": "♥︎",
+			"R": "♥︎",
+			"sl": .9,
+			"sr": .9
+		},
+		{
+			"id": "listening",
+			"text": "O   O",
+			"t": "Listening",
+			"L": "O",
+			"R": "O",
+			"gy": -.03
+		},
+		{
+			"id": "thinking",
+			"text": "o _ o",
+			"t": "Thinking",
+			"L": "o",
+			"R": "o",
+			"M": "_",
+			"gx": .05,
+			"gy": -.04,
+			"tilt": 5,
+			"fx": "cursor"
+		},
+		{
+			"id": "focused",
+			"text": "−   −",
+			"t": "Focused",
+			"L": "−",
+			"R": "−",
+			"rl": 9,
+			"rr": -9
+		},
+		{
+			"id": "curious",
+			"text": "o   •",
+			"t": "Curious",
+			"L": "o",
+			"R": "•",
+			"sl": 1.15,
+			"tilt": -8,
+			"gx": .02
+		},
+		{
+			"id": "confused",
+			"text": "o   O",
+			"t": "Confused",
+			"L": "o",
+			"R": "O",
+			"tilt": 7
+		},
+		{
+			"id": "surprised",
+			"text": "O o O",
+			"t": "Surprised",
+			"L": "O",
+			"R": "O",
+			"M": "o"
+		},
+		{
+			"id": "doubtful",
+			"text": "¬   ¬",
+			"t": "Doubtful",
+			"L": "¬",
+			"R": "¬",
+			"gx": .06
+		},
+		{
+			"id": "unamused",
+			"text": "− _ −",
+			"t": "Unamused",
+			"L": "−",
+			"R": "−",
+			"M": "_"
+		},
+		{
+			"id": "strain",
+			"text": ">   <",
+			"t": "Strain",
+			"L": ">",
+			"R": "<"
+		},
+		{
+			"id": "sad",
+			"text": "T   T",
+			"t": "Sad",
+			"L": "T",
+			"R": "T",
+			"gy": .02
+		},
+		{
+			"id": "oops",
+			"text": "x   x",
+			"t": "Oops",
+			"L": "x",
+			"R": "x"
+		},
+		{
+			"id": "dizzy",
+			"text": "@   @",
+			"t": "Dizzy",
+			"L": "@",
+			"R": "@",
+			"tilt": 10,
+			"fx": "spin"
+		},
+		{
+			"id": "sleepy",
+			"text": "−   −",
+			"t": "Sleepy",
+			"L": "−",
+			"R": "−",
+			"dy": .04,
+			"fx": "z"
+		},
+		{
+			"id": "learned",
+			"text": "* v *",
+			"t": "Learned",
+			"L": "*",
+			"R": "*",
+			"M": "v",
+			"sl": 1.1,
+			"sr": 1.1
+		},
+		{
+			"id": "money",
+			"text": "$   $",
+			"t": "Money",
+			"L": "$",
+			"R": "$"
+		},
+		{
+			"id": "ask",
+			"text": "o ? o",
+			"t": "Needs you",
+			"L": "o",
+			"R": "o",
+			"M": "?",
+			"fx": "ask"
+		}
+	],
+	states: [
+		{
+			"id": "greeting",
+			"face": "happy",
+			"name": "Hello",
+			"when": "You pick it up or sit down.",
+			"trigger": "IMU pick-up / first touch of the day"
+		},
+		{
+			"id": "listening",
+			"face": "listening",
+			"name": "Listening",
+			"when": "You hold the key and talk.",
+			"trigger": "Key held (on device)"
+		},
+		{
+			"id": "thinking",
+			"face": "thinking",
+			"name": "Thinking",
+			"when": "The agent is working on an answer.",
+			"trigger": "Agent turn started"
+		},
+		{
+			"id": "working",
+			"face": "focused",
+			"name": "Working",
+			"when": "A tool or a long task is running.",
+			"trigger": "Tool call started"
+		},
+		{
+			"id": "needs_you",
+			"face": "ask",
+			"name": "Needs you",
+			"when": "A question or an approval. Orange ring, one sound.",
+			"trigger": "Approval request / clarifying question"
+		},
+		{
+			"id": "done",
+			"face": "joy",
+			"name": "Done",
+			"when": "A task finished. One line, then back to the face.",
+			"trigger": "Turn complete / cron job done"
+		},
+		{
+			"id": "stuck",
+			"face": "strain",
+			"name": "Stuck",
+			"when": "Retries are piling up.",
+			"trigger": "3 tool errors in a row"
+		},
+		{
+			"id": "failed",
+			"face": "oops",
+			"name": "Failed",
+			"when": "Something broke. It says what, in one line.",
+			"trigger": "Run failed"
+		},
+		{
+			"id": "learned",
+			"face": "learned",
+			"name": "Learned",
+			"when": "It made or improved a skill.",
+			"trigger": "Hermes: skill created or updated"
+		},
+		{
+			"id": "noted",
+			"face": "wink",
+			"name": "Noted",
+			"when": "It saved something about you.",
+			"trigger": "Memory write (e.g. USER.md / MEMORY.md)"
+		},
+		{
+			"id": "cost",
+			"face": "money",
+			"name": "Cost",
+			"when": "Spend passed a limit you set.",
+			"trigger": "Budget threshold"
+		},
+		{
+			"id": "asleep",
+			"face": "sleepy",
+			"name": "Asleep",
+			"when": "Face-down or quiet hours. The agent keeps running.",
+			"trigger": "IMU face-down / schedule"
+		},
+		{
+			"id": "idle",
+			"face": "neutral",
+			"name": "Idle",
+			"when": "Nothing going on. Slow blinks and glances.",
+			"trigger": "No events"
+		}
+	],
+	fields: {
+		"L": "left eye glyph",
+		"R": "right eye glyph",
+		"M": "mouth glyph (optional)",
+		"gx": "gaze x, fraction of screen",
+		"gy": "gaze y, fraction of screen",
+		"dy": "move eyes down, fraction",
+		"dl": "move left eye down, fraction",
+		"dr": "move right eye down, fraction",
+		"rl": "rotate left eye, degrees",
+		"rr": "rotate right eye, degrees",
+		"sl": "scale left eye",
+		"sr": "scale right eye",
+		"tilt": "rotate whole face, degrees",
+		"fx": "cursor | spin | z | ask"
+	}
+};
+//#endregion
+//#region ../charmd/src/agent/acp-agents.ts
+const ACP_AGENTS = {
+	claude: {
+		label: "Claude Code",
+		command: [
+			"npx",
+			"-y",
+			"@agentclientprotocol/claude-agent-acp@0.84.0"
+		],
+		sessionMeta: { claudeCode: { options: {
+			settingSources: ["project", "local"],
+			allowedTools: ["mcp__charm"]
+		} } },
+		mode: "acceptEdits",
+		env: { ENABLE_CLAUDEAI_MCP_SERVERS: "0" }
+	},
+	codex: {
+		label: "Codex",
+		command: [
+			"npx",
+			"-y",
+			"@agentclientprotocol/codex-acp@2.1.0"
+		]
+	},
+	gemini: {
+		label: "Gemini CLI",
+		command: ["gemini", "--acp"]
+	},
+	goose: {
+		label: "goose",
+		command: ["goose", "acp"]
+	},
+	hermes: {
+		label: "Hermes",
+		command: ["hermes", "acp"]
+	},
+	openclaw: {
+		label: "OpenClaw",
+		command: ["openclaw", "acp"]
+	}
+};
+const ACP_AGENT_NAMES = Object.keys(ACP_AGENTS);
+//#endregion
+//#region ../protocol/src/constants.ts
+const AUDIO_DOWN = {
+	format: "opus",
+	sample_rate: 24e3,
+	channels: 1,
+	frame_duration: 60
+};
+const LIMITS = {
+	maxJsonBytes: 16384,
+	maxAudioFrameBytes: 4096,
+	maxTextChars: 2e3
+};
+const TIMEOUTS = {
+	pairCodeSeconds: 300,
+	unpairedIdleSeconds: 120,
+	turnSeconds: 60
+};
+const FACE_STATES = facesData.states.map((state) => state.id);
+const SIGNAL_COLOUR = "#FF5A1F";
+//#endregion
+//#region ../protocol/src/text.ts
+const encoder$1 = new TextEncoder();
+const ELLIPSIS = "…";
+function utf8Length(text) {
+	return encoder$1.encode(text).length;
+}
+function fitUtf8(text, maxBytes) {
+	if (utf8Length(text) <= maxBytes) return text;
+	const budget = maxBytes - utf8Length(ELLIPSIS);
+	let out = "";
+	let used = 0;
+	for (const char of text) {
+		const size = utf8Length(char);
+		if (used + size > budget) break;
+		out += char;
+		used += size;
+	}
+	return out + ELLIPSIS;
+}
+//#endregion
+//#region ../protocol/src/messages.ts
+const sessionId = z.string().min(1).max(128).optional();
+const shownText = (min, maxBytes) => z.string().min(min).refine((text) => utf8Length(text) <= maxBytes, { message: `at most ${maxBytes} bytes` });
+const askId = z.string().regex(/^[A-Za-z0-9_-]{1,32}$/);
+const askLabel = shownText(1, 12);
+const audioParams = z.object({
+	format: z.literal("opus"),
+	sample_rate: z.number().int().positive(),
+	channels: z.number().int().min(1).max(2),
+	frame_duration: z.number().int().positive()
+});
+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
+});
+const listen = z.object({
+	session_id: sessionId,
+	type: z.literal("listen"),
+	state: z.enum([
+		"start",
+		"stop",
+		"detect"
+	]),
+	mode: z.enum([
+		"auto",
+		"manual",
+		"realtime"
+	]).optional(),
+	text: z.string().max(2e3).optional()
+});
+const abort = z.object({
+	session_id: sessionId,
+	type: z.literal("abort"),
+	reason: z.string().max(64).optional()
+});
+const unlock = z.object({
+	type: z.literal("charm"),
+	op: z.literal("unlock"),
+	pin: z.string().regex(/^\d{4,12}$/)
+});
+const answer = z.object({
+	type: z.literal("charm"),
+	op: z.literal("answer"),
+	id: askId,
+	yes: z.boolean()
+});
+const serverHello = z.object({
+	type: z.literal("hello"),
+	transport: z.literal("websocket"),
+	session_id: z.string().min(1).max(128),
+	audio_params: audioParams
+});
+const stt = z.object({
+	session_id: sessionId,
+	type: z.literal("stt"),
+	text: z.string().max(2e3)
+});
+const tts = z.object({
+	session_id: sessionId,
+	type: z.literal("tts"),
+	state: z.enum([
+		"start",
+		"sentence_start",
+		"stop"
+	]),
+	text: z.string().max(2e3).optional()
+});
+const llm = z.object({
+	session_id: sessionId,
+	type: z.literal("llm"),
+	emotion: z.string().max(32),
+	text: z.string().max(32).optional()
+});
+const pairCode = z.object({
+	type: z.literal("charm"),
+	op: z.literal("pair_code"),
+	code: z.string().regex(/^\d{6}$/),
+	expires_in: z.number().int().positive()
+});
+const paired = z.object({
+	type: z.literal("charm"),
+	op: z.literal("paired"),
+	token: z.string().regex(/^[A-Za-z0-9_-]{32,128}$/)
+});
+const unlocked = z.object({
+	type: z.literal("charm"),
+	op: z.literal("unlocked")
+});
+const locked = z.object({
+	type: z.literal("charm"),
+	op: z.literal("locked"),
+	reason: z.enum([
+		"boot",
+		"wrong_pin",
+		"remote",
+		"blocked"
+	]),
+	tries_left: z.number().int().min(0).optional()
+});
+const revoked = z.object({
+	type: z.literal("charm"),
+	op: z.literal("revoked")
+});
+const face = z.object({
+	type: z.literal("charm"),
+	op: z.literal("face"),
+	state: z.enum(FACE_STATES),
+	text: shownText(0, 200).optional()
+});
+const look$1 = z.object({
+	type: z.literal("charm"),
+	op: z.literal("look"),
+	name: shownText(1, 24).refine((name) => [...name].length <= 12, { message: "at most 12 characters" }),
+	glyph: z.string().regex(/^#[0-9A-Fa-f]{6}$/, "a #RRGGBB colour").refine((hex) => hex.toUpperCase() !== SIGNAL_COLOUR, { message: "orange is reserved for 'it needs you'" }),
+	greeting: shownText(0, 40),
+	sleep_ms: z.number().int().min(0).max(864e5),
+	motion: z.enum(["full", "calm"])
+});
+const ask = z.object({
+	type: z.literal("charm"),
+	op: z.literal("ask"),
+	id: askId,
+	text: shownText(1, 200),
+	yes: askLabel.optional(),
+	no: askLabel.optional()
+});
+const askEnd = z.object({
+	type: z.literal("charm"),
+	op: z.literal("ask_end"),
+	id: askId
+});
+const CLIENT_SCHEMAS = {
+	hello: clientHello,
+	listen,
+	abort,
+	"charm:unlock": unlock,
+	"charm:answer": answer
+};
+const SERVER_SCHEMAS = {
+	hello: serverHello,
+	stt,
+	tts,
+	llm,
+	"charm:pair_code": pairCode,
+	"charm:paired": paired,
+	"charm:unlocked": unlocked,
+	"charm:locked": locked,
+	"charm:revoked": revoked,
+	"charm:face": face,
+	"charm:ask": ask,
+	"charm:ask_end": askEnd,
+	"charm:look": look$1
+};
+Object.keys(CLIENT_SCHEMAS);
+Object.keys(SERVER_SCHEMAS);
+function messageKind(message) {
+	return message.type === "charm" ? `charm:${message.op ?? ""}` : message.type;
+}
+//#endregion
+//#region ../charmd/src/look.ts
+const FALLBACK_NAME = "Charm";
+const MAX_NAME_CHARS = 12;
+const MAX_NAME_BYTES = 24;
+const MAX_GREETING_BYTES = 40;
+const COLOUR_IDS = facesData.colours.map((colour) => colour.id);
+const lookName = z.string().min(1, "the name can't be empty").refine((name) => [...name].length <= MAX_NAME_CHARS && utf8Length(name) <= MAX_NAME_BYTES, { message: `at most ${MAX_NAME_CHARS} characters` });
+const lookFields = {
+	name: lookName.optional(),
+	colour: z.enum(COLOUR_IDS, { error: `the colour is one of ${COLOUR_IDS.join(", ")}` }).optional(),
+	greeting: z.string().refine((text) => utf8Length(text) <= MAX_GREETING_BYTES, { message: `at most ${MAX_GREETING_BYTES} bytes` }).optional(),
+	sleepAfterMinutes: z.number().int().min(0).max(1440).optional(),
+	motion: z.enum(["full", "calm"]).optional()
+};
+const lookUpdateSchema = z.object(lookFields).strict();
+function issues(error) {
+	return error.issues.map((issue) => `${issue.path.join(".") || "look"}: ${issue.message}`).join("; ");
+}
+function glyphOf(colourId) {
+	const colour = facesData.colours.find((c) => c.id === colourId);
+	if (!colour) throw new Error(`Unknown colour "${colourId}"`);
+	return colour.g;
+}
+function resolve$1(settings, defaultName) {
+	const name = settings.name ?? defaultName;
+	return {
+		name,
+		colour: settings.colour,
+		glyph: glyphOf(settings.colour),
+		greeting: settings.greeting ?? `Hi! I'm ${name}.`,
+		sleepAfterMinutes: settings.sleepAfterMinutes,
+		motion: settings.motion
+	};
+}
+function toMessage(look) {
+	const message = {
+		type: "charm",
+		op: "look",
+		name: look.name,
+		glyph: look.glyph,
+		greeting: look.greeting,
+		sleep_ms: look.sleepAfterMinutes * 6e4,
+		motion: look.motion
+	};
+	const checked = SERVER_SCHEMAS["charm:look"].safeParse(message);
+	if (!checked.success) throw new Error(`Invalid look: ${issues(checked.error)}`);
+	return message;
+}
+function nameFromAgentsMd(markdown) {
+	const heading = /^# +(.+)$/m.exec(markdown)?.[1]?.trim();
+	if (!heading) return void 0;
+	const name = [...heading].slice(0, MAX_NAME_CHARS).join("").trimEnd();
+	return lookName.safeParse(name).success ? name : void 0;
+}
+function readAgentName(cwd) {
+	const path = cwd ? join(cwd, "AGENTS.md") : void 0;
+	if (!path || !existsSync(path)) return FALLBACK_NAME;
+	return nameFromAgentsMd(readFileSync(path, "utf8")) ?? FALLBACK_NAME;
+}
+var CharmLook = class {
+	#settings;
+	#defaultName;
+	constructor(settings, defaultName) {
+		this.#settings = settings;
+		this.#defaultName = defaultName;
+		this.message();
+	}
+	current() {
+		return resolve$1(this.#settings, this.#defaultName);
+	}
+	message() {
+		return toMessage(this.current());
+	}
+	apply(update) {
+		const parsed = lookUpdateSchema.safeParse(update);
+		if (!parsed.success) throw new Error(issues(parsed.error));
+		const next = { ...this.#settings };
+		for (const [key, value] of Object.entries(parsed.data)) if (value !== void 0) Object.assign(next, { [key]: value });
+		const look = resolve$1(next, this.#defaultName);
+		toMessage(look);
+		this.#settings = next;
+		return look;
+	}
+};
+//#endregion
+//#region ../charmd/src/config/config.ts
+const LOOPBACK = /* @__PURE__ */ new Set([
+	"127.0.0.1",
+	"::1",
+	"localhost"
+]);
+const DEFAULT_SEARCH_PATHS = [join(process.cwd(), "opencharm.json"), "/etc/opencharm/charmd.json"];
+const secret = {
+	apiKey: z.string().min(1).optional(),
+	apiKeyEnv: z.string().min(1).optional()
+};
+const voiceSchema = z.discriminatedUnion("provider", [
+	z.object({
+		provider: z.literal("fake"),
+		transcript: z.string().optional()
+	}).strict(),
+	z.object({
+		provider: z.literal("local"),
+		whisperModel: z.string().optional(),
+		sayVoice: z.string().optional()
+	}).strict(),
+	z.object({
+		provider: z.literal("openai"),
+		...secret,
+		baseUrl: z.url().optional(),
+		sttModel: z.string().optional(),
+		ttsModel: z.string().optional(),
+		voice: z.string().optional()
+	}).strict()
+]);
+const agentSchema = z.discriminatedUnion("adapter", [
+	z.object({ adapter: z.literal("fake") }).strict(),
+	z.object({
+		adapter: z.literal("openai-compatible"),
+		baseUrl: z.url(),
+		model: z.string().min(1),
+		...secret
+	}).strict(),
+	z.object({
+		adapter: z.literal("openclaw"),
+		baseUrl: z.url(),
+		agentId: z.string().min(1).default("main"),
+		...secret
+	}).strict(),
+	z.object({
+		adapter: z.literal("hermes"),
+		baseUrl: z.url().default("http://127.0.0.1:8642/v1"),
+		model: z.string().min(1).default("hermes-agent"),
+		...secret
+	}).strict(),
+	z.object({
+		adapter: z.literal("acp"),
+		agent: z.enum(ACP_AGENT_NAMES).optional(),
+		command: z.array(z.string().min(1)).min(1).optional(),
+		cwd: z.string().min(1).default("."),
+		projects: z.array(z.string().min(1)).optional(),
+		mode: z.string().min(1).optional(),
+		charmTools: z.boolean().default(true)
+	}).strict()
+]);
+const charmSchema = z.object({
+	...lookFields,
+	colour: lookFields.colour.unwrap().default("white"),
+	sleepAfterMinutes: lookFields.sleepAfterMinutes.unwrap().default(4),
+	motion: lookFields.motion.unwrap().default("full"),
+	agentCanChangeLook: z.boolean().default(true)
+}).strict();
+const schema = z.object({
+	listen: z.object({
+		host: z.string().min(1).default("127.0.0.1"),
+		port: z.number().int().min(0).max(65535).default(8787)
+	}).prefault({}),
+	statePath: z.string().min(1).default(join(homedir(), ".opencharm", "state.json")),
+	adminSocket: z.string().min(1).optional(),
+	publicUrl: z.url().optional(),
+	maxConnections: z.number().int().min(1).max(1024).default(16),
+	allowInsecureRemote: z.boolean().default(false),
+	voice: voiceSchema.default({ provider: "fake" }),
+	agent: agentSchema.default({ adapter: "fake" }),
+	turnTimeoutSeconds: z.number().int().min(5).max(600).default(60),
+	logTranscripts: z.boolean().default(false),
+	charm: charmSchema.prefault({})
+}).strict();
+function defaultAdminSocket(statePath) {
+	return process.platform === "win32" ? "\\\\.\\pipe\\opencharm-charmd" : join(dirname(statePath), "charmd.sock");
+}
+function expandPath(path, base) {
+	if (path === "~" || path.startsWith("~/")) return join(homedir(), path.slice(2));
+	return resolve(base, path);
+}
+function resolveAgent(agent, base) {
+	if (agent.adapter === "openclaw") return {
+		...agent,
+		model: `openclaw:${agent.agentId}`
+	};
+	if (agent.adapter !== "acp") return agent;
+	if (Boolean(agent.agent) === Boolean(agent.command)) throw new Error("Invalid charmd config: an ACP agent needs exactly one of \"agent\" (a known name) or \"command\"");
+	const known = agent.agent ? ACP_AGENTS[agent.agent] : void 0;
+	return {
+		adapter: "acp",
+		name: agent.agent ?? "acp",
+		command: known ? [...known.command] : agent.command ?? [],
+		...known?.sessionMeta ? { sessionMeta: known.sessionMeta } : {},
+		...known?.env ? { env: { ...known.env } } : {},
+		...agent.mode ?? known?.mode ? { mode: agent.mode ?? known?.mode } : {},
+		cwd: expandPath(agent.cwd, base),
+		charmTools: agent.charmTools,
+		...agent.projects ? { projects: agent.projects.map((p) => expandPath(p, base)) } : {}
+	};
+}
+function parseConfig(input, baseDir) {
+	const result = schema.safeParse(input);
+	if (!result.success) {
+		const problems = result.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
+		throw new Error(`Invalid charmd config: ${problems}`);
+	}
+	const config = result.data;
+	if (!LOOPBACK.has(config.listen.host) && !config.allowInsecureRemote) throw new Error(`Invalid charmd config: listen.host ${config.listen.host} is not loopback; put Caddy in front, or set "allowInsecureRemote": true for a trusted LAN`);
+	const statePath = baseDir && !isAbsolute(config.statePath) ? resolve(baseDir, config.statePath) : config.statePath;
+	const base = baseDir ?? process.cwd();
+	const agent = resolveAgent(config.agent, base);
+	return {
+		...config,
+		statePath,
+		adminSocket: config.adminSocket ?? defaultAdminSocket(statePath),
+		agent
+	};
+}
+function loadConfig(path, options = {}) {
+	if (path) {
+		if (!existsSync(path)) throw new Error(`Config file not found: ${path}`);
+		return parseConfig(JSON.parse(readFileSync(path, "utf8")), dirname(path));
+	}
+	const found = (options.searchPaths ?? DEFAULT_SEARCH_PATHS).find((p) => existsSync(p));
+	return found ? parseConfig(JSON.parse(readFileSync(found, "utf8")), dirname(found)) : parseConfig({});
+}
+//#endregion
+//#region ../charmd/src/admin/admin-client.ts
+const MAX_REPLY_BYTES = 262144;
+function sendAdmin(socketPath, request) {
+	return new Promise((resolve, reject) => {
+		const socket = createConnection(socketPath);
+		let buffer = "";
+		socket.setEncoding("utf8");
+		socket.on("connect", () => socket.write(`${JSON.stringify(request)}\n`));
+		socket.on("data", (chunk) => {
+			buffer += chunk;
+			if (buffer.length > MAX_REPLY_BYTES) socket.destroy(/* @__PURE__ */ new Error("admin reply too large"));
+		});
+		socket.on("end", () => {
+			try {
+				const reply = JSON.parse(buffer);
+				if (reply.ok) resolve(reply.result);
+				else reject(new Error(reply.error));
+			} catch {
+				reject(/* @__PURE__ */ new Error("charmd sent an unreadable reply"));
+			}
+		});
+		socket.on("error", (error) => {
+			if (error.code === "ENOENT" || error.code === "ECONNREFUSED") reject(/* @__PURE__ */ new Error(`charmd is not running (no admin socket at ${socketPath}). Start it with: opencharm serve`));
+			else if (error.code === "EACCES") reject(/* @__PURE__ */ new Error(`Permission denied on ${socketPath}. Run admin commands as the charmd user: sudo -u charmd opencharm …`));
+			else reject(error);
+		});
+	});
+}
+//#endregion
+//#region package.json
+var version = "0.1.0";
+function channelToCube(value) {
+	if (value < 48) return 0;
+	if (value < 115) return 1;
+	return Math.floor((value - 35) / 40);
+}
+function hexToRgb(hex) {
+	const n = Number.parseInt(hex.slice(1), 16);
+	return [
+		n >> 16 & 255,
+		n >> 8 & 255,
+		n & 255
+	];
+}
+function rgbTo256([r, g, b]) {
+	return 16 + 36 * channelToCube(r) + 6 * channelToCube(g) + channelToCube(b);
+}
+function detectStyleOptions(argv, env, isTTY) {
+	return {
+		color: isTTY && env.TERM !== "dumb" && !("NO_COLOR" in env) && !argv.includes("--no-color"),
+		trueColor: /truecolor|24bit/i.test(env.COLORTERM ?? "")
+	};
+}
+function createStyle({ color, trueColor }) {
+	const paint = (layer) => (hex) => {
+		if (!color) return "";
+		const rgb = hexToRgb(hex);
+		return trueColor ? `[${layer};2;${rgb.join(";")}m` : `[${layer};5;${rgbTo256(rgb)}m`;
+	};
+	return {
+		fg: paint(38),
+		bg: paint(48),
+		bold: (text) => color ? `${text}` : text,
+		dim: (text) => color ? `${text}` : text,
+		reset: color ? `` : ""
+	};
+}
+//#endregion
+//#region src/args.ts
+const VALUE_FLAGS = /* @__PURE__ */ new Set([
+	"--colour",
+	"--color",
+	"--config",
+	"--agent",
+	"--from",
+	"--socket",
+	"--name",
+	"--url",
+	"--port",
+	"--greeting",
+	"--motion"
+]);
+function isPositional(args, index) {
+	const word = args[index];
+	const previous = index > 0 ? args[index - 1] : void 0;
+	return word !== void 0 && !word.startsWith("-") && !(previous !== void 0 && VALUE_FLAGS.has(previous));
+}
+function firstPositional(args) {
+	const index = args.findIndex((_, i) => isPositional(args, i));
+	return index >= 0 ? args[index] : void 0;
+}
+function flagValue(args, flag) {
+	const index = args.indexOf(flag);
+	return index >= 0 ? args[index + 1] : void 0;
+}
+function parseArgs(argv) {
+	const at = argv.findIndex((_, i) => isPositional(argv, i));
+	return {
+		command: at >= 0 ? (argv[at] ?? "").toLowerCase() : "",
+		rest: at >= 0 ? [...argv.slice(0, at), ...argv.slice(at + 1)] : [...argv],
+		help: argv.includes("-h") || argv.includes("--help"),
+		version: argv.includes("-v") || argv.includes("--version")
+	};
+}
+//#endregion
+//#region src/prompt.ts
+function createLineQueue(input) {
+	const lines = [];
+	const waiting = [];
+	let ended = false;
+	const rl = createInterface({
+		input,
+		terminal: false
+	});
+	rl.on("line", (line) => {
+		const waiter = waiting.shift();
+		if (waiter) waiter(line.trim());
+		else lines.push(line.trim());
+	});
+	rl.on("close", () => {
+		ended = true;
+		for (const waiter of waiting.splice(0)) waiter("");
+	});
+	return () => {
+		const line = lines.shift();
+		if (line !== void 0) return Promise.resolve(line);
+		if (ended) return Promise.resolve("");
+		return new Promise((resolve) => waiting.push(resolve));
+	};
+}
+let pipedLines;
+function promptHidden(question) {
+	const input = process.stdin;
+	const output = process.stderr;
+	if (!input.isTTY) {
+		pipedLines ??= createLineQueue(input);
+		output.write(question);
+		return pipedLines().then((line) => {
+			output.write("\n");
+			return line;
+		});
+	}
+	return new Promise((resolve) => {
+		let value = "";
+		output.write(question);
+		input.setRawMode(true);
+		input.resume();
+		input.setEncoding("utf8");
+		const onData = (chunk) => {
+			for (const char of chunk) {
+				if (char === "\r" || char === "\n") {
+					input.setRawMode(false);
+					input.pause();
+					input.off("data", onData);
+					output.write("\n");
+					resolve(value);
+					return;
+				}
+				if (char === "") {
+					input.setRawMode(false);
+					process.exit(130);
+				}
+				if (char === "") value = value.slice(0, -1);
+				else value += char;
+			}
+		};
+		input.on("data", onData);
+	});
+}
+//#endregion
+//#region src/commands/admin.ts
+const DONE = {
+	lock: "Locked",
+	unlock: "Unblocked and unlocked",
+	revoke: "Revoked"
+};
+function fail$2(ctx, message) {
+	ctx.err.write(`${message}\n`);
+	process.exitCode = 1;
+}
+async function pair(ctx, args, deps) {
+	const code = firstPositional(args);
+	if (!code) {
+		fail$2(ctx, "Usage: opencharm pair <code> [--name <name>]   (the 6-digit code on the charm's screen)");
+		return;
+	}
+	const pin = await deps.prompt("Choose a PIN for the charm (4-12 digits): ");
+	if (pin !== await deps.prompt("Type it again: ")) {
+		fail$2(ctx, "The PINs didn't match. Nothing was changed.");
+		return;
+	}
+	const name = flagValue(args, "--name") ?? "charm";
+	const result = await deps.send(deps.socket, {
+		cmd: "pair",
+		code,
+		pin,
+		name
+	});
+	ctx.out.write(`Paired ${result.name}. The charm now asks for its PIN.\n`);
+}
+const DEV_USAGE = "Usage: opencharm dev face <charm> <state> [text]   |   opencharm dev say <charm> <text>   |   opencharm dev ask <charm> <question>";
+function positionals(args) {
+	return args.filter((arg, i) => !arg.startsWith("-") && !VALUE_FLAGS.has(args[i - 1] ?? ""));
+}
+async function dev(ctx, args, deps) {
+	const [sub, charm, ...words] = positionals(args);
+	const text = words.join(" ");
+	if (sub === "face" && charm && words[0]) {
+		const [state, ...line] = words;
+		await deps.send(deps.socket, {
+			cmd: "devFace",
+			charm,
+			state,
+			...line.length ? { text: line.join(" ") } : {}
+		});
+		ctx.out.write(`Face ${state} sent to ${charm}.\n`);
+		return;
+	}
+	if (sub === "ask" && charm && text) {
+		ctx.out.write(`Asking ${charm}: hold the key for yes, press for no (30 s).\n`);
+		const { answer } = await deps.send(deps.socket, {
+			cmd: "devAsk",
+			charm,
+			text
+		});
+		ctx.out.write(answer === "yes" ? `${charm} said yes.\n` : `${charm} said no (or nothing).\n`);
+		return;
+	}
+	if (sub === "say" && charm && text) {
+		await deps.send(deps.socket, {
+			cmd: "devSay",
+			charm,
+			text
+		});
+		ctx.out.write(`${charm} is saying it.\n`);
+		return;
+	}
+	fail$2(ctx, DEV_USAGE);
+}
+async function look(ctx, args, deps) {
+	const flags = {
+		colour: flagValue(args, "--colour") ?? flagValue(args, "--color"),
+		greeting: flagValue(args, "--greeting"),
+		motion: flagValue(args, "--motion")
+	};
+	const update = Object.fromEntries(Object.entries(flags).filter(([, value]) => value !== void 0));
+	const result = await deps.send(deps.socket, {
+		cmd: "look",
+		...update
+	});
+	const sleep = result.sleepAfterMinutes === 0 ? "never sleeps" : `sleeps after ${result.sleepAfterMinutes} min`;
+	ctx.out.write(`${result.name}  ${result.colour}  ${result.motion} motion  ${sleep}\n${result.greeting ? JSON.stringify(result.greeting) : "(no greeting)"}\n`);
+	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) {
+	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");
+	}
+}
+async function runAdminCommand(ctx, command, args, deps) {
+	try {
+		if (command === "pair") {
+			await pair(ctx, args, deps);
+			return;
+		}
+		if (command === "dev") {
+			await dev(ctx, args, deps);
+			return;
+		}
+		if (command === "look") {
+			await look(ctx, args, deps);
+			return;
+		}
+		if (command === "status") {
+			const { charms } = await deps.send(deps.socket, { cmd: "status" });
+			printStatus(ctx, charms);
+			return;
+		}
+		const charm = firstPositional(args);
+		if (!charm) {
+			fail$2(ctx, `Usage: opencharm ${command} <charm>   (see: opencharm status)`);
+			return;
+		}
+		const { connected } = await deps.send(deps.socket, {
+			cmd: command,
+			charm
+		});
+		ctx.out.write(`${DONE[command] ?? "Done"}: ${charm}${connected === 0 ? " (not connected right now)" : ""}.\n`);
+	} catch (error) {
+		fail$2(ctx, error instanceof Error ? error.message : String(error));
+	}
+}
+//#endregion
+//#region src/face-lookup.ts
+const VARIATION_SELECTOR = /︎/g;
+const DEFAULT_COLOUR_ID = "white";
+function glyph(value) {
+	return value.replace(VARIATION_SELECTOR, "");
+}
+function findFace(id) {
+	const wanted = id.toLowerCase();
+	return facesData.faces.find((face) => face.id === id || face.t.toLowerCase() === wanted);
+}
+function randomFace() {
+	return facesData.faces[Math.floor(Math.random() * facesData.faces.length)];
+}
+function faceText(face) {
+	return glyph(face.text);
+}
+function pickColour(args, warn) {
+	const flagAt = args.indexOf("--colour") >= 0 ? args.indexOf("--colour") : args.indexOf("--color");
+	const id = flagAt >= 0 ? (args[flagAt + 1] ?? "").toLowerCase() : DEFAULT_COLOUR_ID;
+	const found = facesData.colours.find((colour) => colour.id === id);
+	if (found) return found;
+	const fallback = facesData.colours[0];
+	if (!fallback) throw new Error("faces.json has no colours");
+	warn(`Unknown colour "${id}". Try: ${facesData.colours.map((c) => c.id).join(", ")}. Using white.`);
+	return fallback;
+}
+//#endregion
+//#region src/screen.ts
+const INNER = 21;
+const ROWS = 5;
+const EYE_LEFT = 5;
+const EYE_RIGHT = 15;
+const MIDDLE = 10;
+const EYE_ROW = 2;
+const MOUTH_ROW = 3;
+const BLINK_GLYPH = "−";
+const SCREEN_BLACK = "#000000";
+function renderScreen(face, colour, style, signal, { blink = false } = {}) {
+	const ring = face.fx === "ask" ? style.fg(signal) : style.fg(colour.c);
+	const ink = style.fg(colour.g);
+	const black = style.bg(SCREEN_BLACK);
+	const left = blink ? BLINK_GLYPH : glyph(face.L);
+	const right = blink ? BLINK_GLYPH : glyph(face.R);
+	const lines = [`${ring}╭${"─".repeat(INNER)}╮${style.reset}`];
+	for (let row = 0; row < ROWS; row++) {
+		const cells = new Array(INNER).fill(" ");
+		if (row === EYE_ROW) {
+			cells[EYE_LEFT] = left;
+			cells[EYE_RIGHT] = right;
+		}
+		if (row === MOUTH_ROW && face.M) cells[MIDDLE] = face.M;
+		if (row === 0 && face.fx === "z") cells[18] = "z";
+		lines.push(`${ring}│${style.reset}${black}${ink}${style.bold(cells.join(""))}${style.reset}${ring}│${style.reset}`);
+	}
+	lines.push(`${ring}╰${"─".repeat(INNER)}╯${style.reset}`);
+	return lines;
+}
+//#endregion
+//#region src/animate.ts
+const BLINK_MS = 130;
+const OPEN_MIN_MS = 900;
+const OPEN_JITTER_MS = 700;
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function redraw(lines) {
+	return `[${lines.length}A${lines.map((line) => `  ${line}`).join("\n")}\n`;
+}
+async function animateFace(face, colour, { out, style, signal, canAnimate, durationMs }) {
+	const draw = (blink) => renderScreen(face, colour, style, signal, { blink });
+	out.write(`${draw(false).map((line) => `  ${line}`).join("\n")}\n`);
+	if (!canAnimate) return;
+	out.write(`[?25l`);
+	const restoreCursor = () => out.write(`[?25h`);
+	process.once("SIGINT", () => {
+		restoreCursor();
+		process.exit(130);
+	});
+	const end = Date.now() + durationMs;
+	let blink = false;
+	while (Date.now() < end) {
+		await sleep(blink ? BLINK_MS : OPEN_MIN_MS + Math.random() * OPEN_JITTER_MS);
+		blink = !blink;
+		out.write(redraw(draw(blink)));
+	}
+	out.write(redraw(draw(false)));
+	restoreCursor();
+}
+//#endregion
+//#region src/commands/face.ts
+const FACE_MS = 2200;
+async function runFace(ctx, args) {
+	const colour = pickColour(args, (message) => ctx.err.write(`${message}\n`));
+	const id = firstPositional(args);
+	const face = id ? findFace(id) : randomFace();
+	if (!face) {
+		ctx.out.write(`No mood called "${id ?? ""}". Try: ${facesData.faces.map((f) => f.id).join(", ")}\n`);
+		process.exitCode = 1;
+		return;
+	}
+	ctx.out.write("\n");
+	await animateFace(face, colour, {
+		...ctx,
+		durationMs: FACE_MS
+	});
+	ctx.out.write(`\n  ${ctx.style.bold(face.t)}  ${ctx.style.dim(faceText(face))}\n\n`);
+}
+//#endregion
+//#region src/commands/faces.ts
+function runFaces(ctx, args) {
+	const { fg, bg, bold, dim, reset } = ctx.style;
+	const colour = pickColour(args, (message) => ctx.err.write(`${message}\n`));
+	ctx.out.write(`\n  ${bold("Moods")} ${dim("(two eyes and an optional mouth, typed)")}\n\n`);
+	for (const face of facesData.faces) {
+		const text = faceText(face).padEnd(7);
+		ctx.out.write(`  ${fg(colour.g)}${bg("#000000")} ${bold(text)} ${reset}  ${face.t.padEnd(10)} ${dim(face.id)}\n`);
+	}
+	ctx.out.write(`\n  ${dim("Write your own: two characters for eyes, one for a mouth. Share it as text.")}\n\n`);
+}
+//#endregion
+//#region src/links.ts
+const LINKS = {
+	site: "https://opencharm.dev",
+	repo: "https://github.com/opencharm-labs/opencharm",
+	board: "https://www.waveshare.com/esp32-s3-touch-amoled-2.16.htm"
+};
+//#endregion
+//#region src/commands/hardware.ts
+function runHardware(ctx) {
+	const { bold, dim } = ctx.style;
+	ctx.out.write(`
+  ${bold("What you need")}
+
+  1. Waveshare ESP32-S3-Touch-AMOLED-2.16, the version with a battery
+     2.16" 480×480 AMOLED, two mics, speaker amp, battery, case.
+     $31.99 at Waveshare's store in September 2026 (check the store; shipping extra).
+     ${LINKS.board}
+  2. A small speaker, 8 ohm 1-2 W with a 2-pin lead (not in the box).
+  3. A USB-C cable that carries data.
+  4. Optional: print your own shell (3 parts, no supports, strap from the seam).
+     STL files: ${LINKS.repo}/tree/main/hardware/stl/print
+
+  ${dim(`Firmware and charmd are in development. Follow along at ${LINKS.site}`)}
+`);
+}
+//#endregion
+//#region src/commands/hello.ts
+const HELLO_MS = 2600;
+async function runHello(ctx, args) {
+	const colour = pickColour(args, (message) => ctx.err.write(`${message}\n`));
+	const face = findFace("happy");
+	if (!face) throw new Error("faces.json lost the \"happy\" face");
+	const { bold, dim } = ctx.style;
+	ctx.out.write("\n");
+	await animateFace(face, colour, {
+		...ctx,
+		durationMs: HELLO_MS
+	});
+	ctx.out.write(`
+  ${bold("OpenCharm")} ${dim(`v${ctx.version}`)}
+  The open-source charm for your AI agent.
+
+  A small device that becomes the face and voice of the agent you already run
+  (Hermes Agent or OpenClaw). A face you can type, one key, about $32 of hardware.
+
+  ${bold("Try")}
+    npx opencharm faces          all ${facesData.faces.length} moods
+    npx opencharm face learned   one mood, big
+    npx opencharm states         what your agent is doing → which face
+    npx opencharm hardware       what to buy and print
+    npx opencharm serve          start charmd, the charm daemon
+
+  ${bold("Links")}
+    ${LINKS.site}
+    ${LINKS.repo}
+`);
+}
+//#endregion
+//#region src/commands/help.ts
+function runHelp(ctx) {
+	const { bold, dim } = ctx.style;
+	ctx.out.write(`
+  ${bold("opencharm")} ${dim(`v${ctx.version}`)}  The open-source charm for your AI agent.
+
+  Usage
+    opencharm                 say hello
+    opencharm faces           list all moods
+    opencharm face [mood]     show one mood (random if omitted)
+    opencharm states          agent states and their faces
+    opencharm hardware        what to buy and print
+
+  charmd, the charm daemon (runs next to your agent)
+    opencharm init [dir]            clone the starter workspace for your agent [--agent claude|codex|gemini|goose|hermes|openclaw] [--from <git url>] [--name <name>] [--colour <colour>]
+    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 pair <code>           pair the charm showing <code>   [--name <name>]
+    opencharm status                paired charms and their state
+    opencharm lock <charm>          lock a charm now
+    opencharm unlock <charm>        clear a block and unlock
+    opencharm revoke <charm>        forget a charm (it must pair again)
+    opencharm look                  show or change the charm's look until charmd restarts   [--colour <c>] [--greeting <text>] [--motion full|calm]
+    opencharm dev face <charm> <state> [text]   show a face (testing)
+    opencharm dev say <charm> <text>            speak through it (testing)
+    opencharm dev ask <charm> <question>        ask it; hold = yes, press = no (testing)
+    opencharm mcp                    the charm's tools for an agent (MCP over stdio) [--config <file>]
+
+  Options
+    --colour <name>   white, cobalt, lime, lilac, sun, coal
+    --no-anim         no blinking
+    --no-color        plain text (also respects NO_COLOR)
+    -v, --version     print the version
+    -h, --help        this help
+
+  ${LINKS.site}
+`);
+}
+//#endregion
+//#region src/commands/init.ts
+const STARTER = "https://github.com/opencharm-labs/opencharm-starter.git";
+function checkLook(options) {
+	const result = z.object({
+		name: lookFields.name,
+		colour: lookFields.colour
+	}).safeParse({
+		name: options.name,
+		colour: options.colour
+	});
+	if (!result.success) throw new Error(result.error.issues.map((issue) => `--${issue.path.join(".")}: ${issue.message}`).join("; "));
+	const { name, colour } = result.data;
+	return {
+		...name ? { name } : {},
+		...colour ? { colour } : {}
+	};
+}
+function initWorkspace(target, options) {
+	const from = options.from ?? STARTER;
+	const agent = options.agent ?? "claude";
+	if (!ACP_AGENT_NAMES.includes(agent)) throw new Error(`Unknown agent "${agent}": choose ${ACP_AGENT_NAMES.join(", ")}`);
+	const look = checkLook(options);
+	if (existsSync(target) && readdirSync(target).length > 0) throw new Error(`${target} is not empty; choose a new folder`);
+	const clone = spawnSync("git", [
+		"clone",
+		"--quiet",
+		"--depth",
+		"1",
+		"--origin",
+		"upstream",
+		from,
+		target
+	], { encoding: "utf8" });
+	if (clone.error) throw new Error("git not found: install git, then run this again");
+	if (clone.status !== 0) throw new Error(`Couldn't clone ${from}: ${clone.stderr.trim().split("\n").at(-1) ?? ""}`);
+	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
+	};
+	config.agent = {
+		...config.agent,
+		agent
+	};
+	if (hasLook) config.charm = {
+		...config.charm,
+		...look
+	};
+	writeFileSync(path, `${JSON.stringify(config, null, 2)}\n`);
+}
+function runInit(ctx, args) {
+	const dir = resolve(firstPositional(args) ?? "my-charm");
+	const name = flagValue(args, "--name");
+	try {
+		initWorkspace(dir, {
+			from: flagValue(args, "--from"),
+			agent: flagValue(args, "--agent"),
+			name,
+			colour: flagValue(args, "--colour") ?? flagValue(args, "--color"),
+			platform: process.platform
+		});
+	} catch (error) {
+		ctx.err.write(`${error instanceof Error ? error.message : String(error)}\n`);
+		process.exitCode = 1;
+		return;
+	}
+	const charm = name ?? readAgentName(join(dir, "charm"));
+	ctx.out.write(`
+  ${ctx.style.bold("Your charm's workspace is ready")} ${ctx.style.dim(dir)}
+
+  cd ${dir}
+  opencharm serve          start charmd here; it runs your agent in charm/
+  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.
+`);
+}
+//#endregion
+//#region src/mcp/server.ts
+const VERSIONS = [
+	"2025-06-18",
+	"2025-03-26",
+	"2024-11-05"
+];
+const FACES = facesData.states.map((state) => state.id);
+const COLOURS = facesData.colours.map((colour) => colour.id);
+const line = z.string().min(1).max(200);
+const label = z.string().min(1).max(12);
+const TOOLS = [
+	{
+		name: "say",
+		description: "Speak a short message out loud on the charm when it is idle (a reminder from a scheduled task, a heads-up). During your reply it is refused: put the words in your reply instead.",
+		inputSchema: {
+			type: "object",
+			properties: { text: {
+				type: "string",
+				description: "One or two short spoken sentences, no markdown."
+			} },
+			required: ["text"]
+		},
+		args: z.object({ text: z.string().min(1).max(500) }),
+		run: async (args, send) => {
+			await send({
+				cmd: "devSay",
+				text: args.text
+			});
+			return "Said on the charm.";
+		}
+	},
+	{
+		name: "show_face",
+		description: "Show a face on the charm's screen, with an optional short line under it. Faces are agent states: done, thinking, working, stuck, learned, noted, asleep and more (see the enum).",
+		inputSchema: {
+			type: "object",
+			properties: {
+				face: {
+					type: "string",
+					enum: FACES
+				},
+				line: {
+					type: "string",
+					description: "Optional, up to 200 characters."
+				}
+			},
+			required: ["face"]
+		},
+		args: z.object({
+			face: z.enum(FACES),
+			line: line.optional()
+		}),
+		run: async (args, send) => {
+			await send({
+				cmd: "devFace",
+				state: args.face,
+				...args.line ? { text: args.line } : {}
+			});
+			return `Showing ${String(args.face)}.`;
+		}
+	},
+	{
+		name: "ask",
+		description: "Ask the person holding the charm a yes/no question before doing something (hold the key = yes, press = no, no answer in 30 s = no). Returns \"yes\" or \"no\". Keep the question short: it's read on a small screen.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				question: {
+					type: "string",
+					description: "Up to 200 characters, e.g. \"Send the email to Ada?\""
+				},
+				yes: {
+					type: "string",
+					description: "Label for yes, up to 12 characters (default ALLOW)."
+				},
+				no: {
+					type: "string",
+					description: "Label for no, up to 12 characters (default NO)."
+				}
+			},
+			required: ["question"]
+		},
+		args: z.object({
+			question: line,
+			yes: label.optional(),
+			no: label.optional()
+		}),
+		run: async (args, send) => {
+			const { answer } = await send({
+				cmd: "devAsk",
+				text: args.question,
+				...args.yes ? { yes: args.yes } : {},
+				...args.no ? { no: args.no } : {}
+			});
+			return answer;
+		}
+	},
+	{
+		name: "notify",
+		description: "Light the charm's orange \"it needs you\" face with a short line, for something that needs the person's attention. It stays until they press the key.",
+		inputSchema: {
+			type: "object",
+			properties: { text: {
+				type: "string",
+				description: "Up to 200 characters."
+			} },
+			required: ["text"]
+		},
+		args: z.object({ text: line }),
+		run: async (args, send) => {
+			await send({
+				cmd: "devFace",
+				state: "needs_you",
+				text: args.text
+			});
+			return "The charm is showing it.";
+		}
+	},
+	{
+		name: "set_look",
+		description: "Change how the charm looks when the person asks (e.g. \"make yourself blue\"): its glyph colour, its greeting after unlock, or calm motion. Lasts until charmd restarts.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				colour: {
+					type: "string",
+					enum: COLOURS,
+					description: "cobalt is blue, lime green, lilac purple, sun yellow; white and coal light the glyphs white."
+				},
+				greeting: {
+					type: "string",
+					description: "Said after unlock, up to 40 characters; \"\" for none."
+				},
+				motion: {
+					type: "string",
+					enum: ["full", "calm"],
+					description: "calm: no glances or bounces, for less movement."
+				}
+			}
+		},
+		args: z.object({
+			colour: z.enum(COLOURS).optional(),
+			greeting: z.string().max(40).optional(),
+			motion: z.enum(["full", "calm"]).optional()
+		}).strict(),
+		run: async (args, send) => {
+			const look = await send({
+				cmd: "look",
+				...args,
+				source: "agent"
+			});
+			return `The charm is now ${look.colour}, ${look.motion} motion, greeting "${look.greeting}".`;
+		}
+	}
+];
+const reply = (id, result) => JSON.stringify({
+	jsonrpc: "2.0",
+	id,
+	result
+});
+const fail$1 = (id, code, message) => JSON.stringify({
+	jsonrpc: "2.0",
+	id,
+	error: {
+		code,
+		message
+	}
+});
+function createCharmMcp({ version, send }) {
+	async function call(id, params) {
+		const { name, arguments: raw } = params ?? {};
+		const tool = TOOLS.find((t) => t.name === name);
+		if (!tool) return fail$1(id, -32602, `Unknown tool: ${String(name)}`);
+		const args = tool.args.safeParse(raw ?? {});
+		if (!args.success) return fail$1(id, -32602, `Invalid arguments for ${tool.name}: ${args.error.issues.map((i) => `${i.path.join(".")} ${i.message}`).join("; ")}`);
+		try {
+			return reply(id, { content: [{
+				type: "text",
+				text: await tool.run(args.data, send)
+			}] });
+		} catch (error) {
+			return reply(id, {
+				isError: true,
+				content: [{
+					type: "text",
+					text: error instanceof Error ? error.message : String(error)
+				}]
+			});
+		}
+	}
+	async function handle(raw) {
+		let parsed;
+		try {
+			parsed = JSON.parse(raw);
+		} catch {
+			return fail$1(null, -32700, "Parse error");
+		}
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return fail$1(null, -32600, "Invalid request: send one JSON-RPC object per line");
+		const { id, method, params } = parsed;
+		if (id === void 0 || id === null) return void 0;
+		switch (method) {
+			case "initialize": {
+				const asked = params?.protocolVersion;
+				return reply(id, {
+					protocolVersion: asked && VERSIONS.includes(asked) ? asked : VERSIONS[0],
+					capabilities: { tools: { listChanged: false } },
+					serverInfo: {
+						name: "opencharm",
+						version
+					},
+					instructions: "Tools for the charm: a small device with a face, a speaker and one key that the person carries. Use them sparingly; everything is seen or heard by the person and anyone nearby."
+				});
+			}
+			case "ping": return reply(id, {});
+			case "tools/list": return reply(id, { tools: TOOLS.map(({ name, description, inputSchema }) => ({
+				name,
+				description,
+				inputSchema
+			})) });
+			case "tools/call": return call(id, params);
+			default: return fail$1(id, -32601, `Method not found: ${String(method)}`);
+		}
+	}
+	return { handle };
+}
+//#endregion
+//#region src/commands/mcp.ts
+async function serveMcp(input, output, deps) {
+	const mcp = createCharmMcp(deps);
+	const pending = [];
+	for await (const line of createInterface({
+		input,
+		crlfDelay: Infinity
+	})) {
+		if (!line.trim()) continue;
+		pending.push(mcp.handle(line).then((reply) => {
+			if (reply !== void 0) output.write(`${reply}\n`);
+		}));
+	}
+	await Promise.all(pending);
+}
+//#endregion
+//#region ../charmd/src/admin/admin-actions.ts
+const pairInput = z.object({
+	code: z.string().regex(/^\d{6}$/, "the code has 6 digits"),
+	pin: z.string().regex(/^\d{4,12}$/, "the PIN is 4 to 12 digits"),
+	name: z.string().regex(/^[a-z0-9][a-z0-9-]{0,39}$/i, "names are letters, digits and hyphens").default("charm")
+});
+const charmInput = z.object({ charm: z.string().min(1) });
+const anyCharmInput = z.object({ charm: z.string().min(1).optional() });
+const devFaceInput = anyCharmInput.extend({
+	state: z.enum(FACE_STATES, { error: "unknown face state" }),
+	text: z.string().max(200).optional()
+});
+const devSayInput = anyCharmInput.extend({ text: z.string().min(1).max(500) });
+const lookInput = z.object({
+	...lookFields,
+	source: z.literal("agent").optional()
+}).strict();
+const devAskInput = anyCharmInput.extend({
+	text: z.string().min(1).max(200),
+	yes: z.string().min(1).max(12).optional(),
+	no: z.string().min(1).max(12).optional()
+});
+function settled(work) {
+	try {
+		return Promise.resolve(work());
+	} catch (error) {
+		return Promise.reject(error instanceof Error ? error : new Error(String(error)));
+	}
+}
+function parseInput(schema, input) {
+	const result = schema.safeParse(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 sessionsOf(charmId) {
+		return [...sessions()].filter((s) => s.charmId === charmId && s.state !== "closed");
+	}
+	function requireCharm(ref) {
+		const charm = store.find(ref);
+		if (!charm) throw new Error(`No charm called "${ref}". See: opencharm status`);
+		return charm;
+	}
+	function requireLive(ref) {
+		if (ref === void 0) {
+			const latest = [...sessions()].filter((s) => s.state === "unlocked").at(-1);
+			if (!latest) throw new Error("No charm is connected and unlocked.");
+			return [latest];
+		}
+		const live = sessionsOf(requireCharm(ref).id).filter((s) => s.state === "unlocked");
+		if (live.length === 0) throw new Error(`"${ref}" is not connected and unlocked.`);
+		return live;
+	}
+	return {
+		async pair(input) {
+			const { code, pin, name } = parseInput(pairInput, input);
+			if (store.find(name)) throw new Error(`A charm called "${name}" already exists.`);
+			const connectionId = pairing.claim(code);
+			const session = connectionId ? [...sessions()].find((s) => s.connectionId === connectionId) : void 0;
+			if (!session) throw new Error("That code is wrong or expired. Use the code on the charm's screen now.");
+			await session.completePairing(name, pin);
+			const charm = requireCharm(name);
+			return {
+				id: charm.id,
+				name: charm.name
+			};
+		},
+		lock(input) {
+			return settled(() => {
+				const live = sessionsOf(requireCharm(parseInput(charmInput, input).charm).id);
+				for (const session of live) session.lockRemote();
+				return { connected: live.length };
+			});
+		},
+		unlock(input) {
+			return settled(() => {
+				const charm = requireCharm(parseInput(charmInput, input).charm);
+				store.put({
+					...charm,
+					blocked: false,
+					failedTries: 0
+				});
+				const live = sessionsOf(charm.id);
+				for (const session of live) session.unlockByAdmin();
+				return { connected: live.length };
+			});
+		},
+		revoke(input) {
+			return settled(() => {
+				const charm = requireCharm(parseInput(charmInput, input).charm);
+				store.remove(charm.id);
+				const live = sessionsOf(charm.id);
+				for (const session of live) session.revoke();
+				return { connected: live.length };
+			});
+		},
+		devFace(input) {
+			return settled(() => {
+				const { charm: ref, state, text } = parseInput(devFaceInput, input);
+				const live = requireLive(ref);
+				for (const session of live) session.devFace(state, text);
+				return { connected: live.length };
+			});
+		},
+		devSay(input) {
+			return settled(() => {
+				const { charm: ref, text } = parseInput(devSayInput, input);
+				const live = requireLive(ref);
+				for (const session of live) session.devSay(text);
+				return { connected: live.length };
+			});
+		},
+		async devAsk(input) {
+			const { charm: ref, text, yes, no } = parseInput(devAskInput, input);
+			const session = requireLive(ref).at(-1);
+			if (session?.state !== "unlocked") throw new Error("The charm must be unlocked first.");
+			return { answer: await session.devAsk(text, {
+				...yes ? { yes } : {},
+				...no ? { no } : {}
+			}) ? "yes" : "no" };
+		},
+		look(input) {
+			return settled(() => {
+				const { source, ...update } = parseInput(lookInput, input);
+				if (Object.keys(update).length === 0) return {
+					...look.current(),
+					connected: 0
+				};
+				if (source === "agent" && !agentCanChangeLook) throw new Error("The agent may not change the charm's look here (charm.agentCanChangeLook is false in opencharm.json).");
+				const next = look.apply(update);
+				const message = look.message();
+				const live = [...sessions()].filter((s) => s.state === "unlocked");
+				for (const session of live) session.sendLook(message);
+				return {
+					...next,
+					connected: live.length
+				};
+			});
+		},
+		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"
+				};
+			}) };
+		}
+	};
+}
+//#endregion
+//#region ../charmd/src/admin/admin-server.ts
+const MAX_REQUEST_BYTES = 16384;
+const COMMANDS = [
+	"pair",
+	"lock",
+	"unlock",
+	"revoke",
+	"status",
+	"devFace",
+	"devSay",
+	"devAsk",
+	"look"
+];
+function isCommand(value) {
+	return typeof value === "string" && COMMANDS.includes(value);
+}
+function socketInUse(path) {
+	return new Promise((resolve) => {
+		const probe = createConnection(path);
+		probe.on("connect", () => {
+			probe.destroy();
+			resolve(true);
+		});
+		probe.on("error", () => resolve(false));
+	});
+}
+async function run$2(actions, request) {
+	const { cmd, ...args } = typeof request === "object" && request !== null ? request : {};
+	if (!isCommand(cmd)) throw new Error(`Unknown command ${JSON.stringify(cmd)}`);
+	return cmd === "status" ? actions.status() : actions[cmd](args);
+}
+function handle(socket, actions) {
+	let buffer = "";
+	socket.setEncoding("utf8");
+	socket.on("data", (chunk) => {
+		buffer += chunk;
+		if (buffer.length > MAX_REQUEST_BYTES) {
+			socket.destroy();
+			return;
+		}
+		const newline = buffer.indexOf("\n");
+		if (newline < 0) return;
+		let request;
+		try {
+			request = JSON.parse(buffer.slice(0, newline));
+		} catch {
+			socket.end(JSON.stringify({
+				ok: false,
+				error: "Request is not JSON"
+			}));
+			return;
+		}
+		run$2(actions, request).then((result) => socket.end(JSON.stringify({
+			ok: true,
+			result
+		})), (error) => socket.end(JSON.stringify({
+			ok: false,
+			error: error instanceof Error ? error.message : String(error)
+		})));
+	});
+	socket.on("error", () => socket.destroy());
+}
+async function startAdminServer(path, actions) {
+	if (process.platform !== "win32") mkdirSync(dirname(path), {
+		recursive: true,
+		mode: 448
+	});
+	if (process.platform !== "win32" && existsSync(path)) {
+		if (await socketInUse(path)) throw new Error(`charmd is already running (admin socket ${path} is in use).`);
+		unlinkSync(path);
+	}
+	const server = createServer((socket) => handle(socket, actions));
+	await new Promise((resolve, reject) => {
+		server.once("error", (error) => reject(error.code === "EADDRINUSE" ? /* @__PURE__ */ new Error(`charmd is already running (admin socket ${path} is in use).`) : error));
+		server.listen(path, resolve);
+	});
+	if (process.platform !== "win32") chmodSync(path, 384);
+	return server;
+}
+//#endregion
+//#region ../charmd/src/auth/secrets.ts
+const SCRYPT = {
+	N: 2 ** 15,
+	r: 8,
+	p: 1,
+	keyLength: 32,
+	saltBytes: 16
+};
+const SCRYPT_MAXMEM = 67108864;
+function scryptAsync(pin, salt, N, r, p) {
+	return new Promise((resolve, reject) => {
+		scrypt(pin, salt, SCRYPT.keyLength, {
+			N,
+			r,
+			p,
+			maxmem: SCRYPT_MAXMEM
+		}, (error, key) => error ? reject(error) : resolve(key));
+	});
+}
+function generateToken() {
+	return randomBytes(32).toString("base64url");
+}
+function hashToken(token) {
+	return createHash("sha256").update(token).digest("hex");
+}
+function generatePairCode() {
+	return String(randomInt(0, 1e6)).padStart(6, "0");
+}
+async function hashPin(pin) {
+	const salt = randomBytes(SCRYPT.saltBytes);
+	const key = await scryptAsync(pin, salt, SCRYPT.N, SCRYPT.r, SCRYPT.p);
+	return [
+		"scrypt",
+		SCRYPT.N,
+		SCRYPT.r,
+		SCRYPT.p,
+		salt.toString("base64url"),
+		key.toString("base64url")
+	].join("$");
+}
+async function verifyPin(pin, stored) {
+	const [scheme, n, r, p, salt, key] = stored.split("$");
+	if (scheme !== "scrypt" || !n || !r || !p || !salt || !key) return false;
+	const expected = Buffer.from(key, "base64url");
+	const actual = await scryptAsync(pin, Buffer.from(salt, "base64url"), Number(n), Number(r), Number(p));
+	return actual.length === expected.length && timingSafeEqual(actual, expected);
+}
+//#endregion
+//#region ../charmd/src/auth/pairing.ts
+var PairingRegistry = class {
+	#options;
+	#byCode = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.#options = {
+			now: Date.now,
+			generate: generatePairCode,
+			...options
+		};
+	}
+	#prune() {
+		const now = this.#options.now();
+		for (const [code, pending] of this.#byCode) if (pending.expiresAt <= now) this.#byCode.delete(code);
+	}
+	issue(connectionId) {
+		this.#prune();
+		this.release(connectionId);
+		if (this.#byCode.size >= this.#options.maxPending) throw new Error("Too many charms waiting to pair; try again shortly.");
+		let code = this.#options.generate();
+		while (this.#byCode.has(code)) code = this.#options.generate();
+		this.#byCode.set(code, {
+			code,
+			connectionId,
+			expiresAt: this.#options.now() + this.#options.ttlMs
+		});
+		return {
+			code,
+			expiresIn: Math.round(this.#options.ttlMs / 1e3)
+		};
+	}
+	claim(code) {
+		this.#prune();
+		const pending = this.#byCode.get(code);
+		if (!pending) return void 0;
+		this.#byCode.delete(code);
+		return pending.connectionId;
+	}
+	release(connectionId) {
+		for (const [code, pending] of this.#byCode) if (pending.connectionId === connectionId) this.#byCode.delete(code);
+	}
+};
+//#endregion
+//#region ../charmd/src/device/ota.ts
+function handleOta(res, websocketUrl) {
+	res.writeHead(200, { "content-type": "application/json" });
+	res.end(JSON.stringify({
+		websocket: { url: websocketUrl },
+		server_time: {
+			timestamp: Date.now(),
+			timezone_offset: 0
+		}
+	}));
+}
+function isOtaRequest(req) {
+	const path = (req.url ?? "").split("?")[0];
+	return (path === "/ota/" || path === "/ota") && (req.method === "GET" || req.method === "POST");
+}
+//#endregion
+//#region ../charmd/src/device/raw-data.ts
+function toBuffer(data) {
+	if (Array.isArray(data)) return Buffer.concat(data);
+	return Buffer.isBuffer(data) ? data : Buffer.from(data);
+}
+//#endregion
+//#region ../charmd/src/device/token.ts
+const TOKEN = /^[A-Za-z0-9_-]{1,256}$/;
+const SUBPROTOCOL = "opencharm";
+const TOKEN_PREFIX = `${SUBPROTOCOL}.token.`;
+function tokenFrom(req) {
+	const header = /^Bearer (.+)$/.exec(req.headers.authorization ?? "")?.[1];
+	if (header !== void 0) return TOKEN.test(header) ? header : void 0;
+	const token = (req.headers["sec-websocket-protocol"] ?? "").split(",").map((p) => p.trim()).find((p) => p.startsWith(TOKEN_PREFIX))?.slice(TOKEN_PREFIX.length);
+	return token && TOKEN.test(token) ? token : void 0;
+}
+//#endregion
+//#region ../protocol/src/parse.ts
+const encoder = new TextEncoder();
+function fail(code, detail) {
+	return {
+		ok: false,
+		error: {
+			code,
+			detail
+		}
+	};
+}
+function parseWith(raw, schemas) {
+	if (encoder.encode(raw).byteLength > LIMITS.maxJsonBytes) return fail("too_large", `over ${LIMITS.maxJsonBytes} bytes`);
+	let data;
+	try {
+		data = JSON.parse(raw);
+	} catch {
+		return fail("invalid_json", "not JSON");
+	}
+	if (typeof data !== "object" || data === null || Array.isArray(data)) return fail("invalid_json", "not a JSON object");
+	const { type, op } = data;
+	if (typeof type !== "string") return fail("unknown_type", "missing type");
+	const kind = messageKind({
+		type,
+		...typeof op === "string" ? { op } : {}
+	});
+	const schema = schemas[kind];
+	if (!schema) return type === "charm" && Object.keys(schemas).some((k) => k.startsWith("charm:")) ? fail("unknown_op", `unknown op ${kind}`) : fail("unknown_type", `unknown type ${type}`);
+	const parsed = schema.safeParse(data);
+	if (!parsed.success) return fail("invalid_fields", parsed.error.issues.map((i) => i.path.join(".") || i.message).join(", "));
+	return {
+		ok: true,
+		message: parsed.data
+	};
+}
+function parseClientMessage(raw) {
+	return parseWith(raw, CLIENT_SCHEMAS);
+}
+//#endregion
+//#region ../charmd/src/device/session.ts
+const MAX_TRIES = 5;
+const ASK_TIMEOUT_MS = 3e4;
+const MAX_ASK_TEXT = 200;
+const MAX_ASK_LABEL = 12;
+const CLOSE_POLICY$1 = 1008;
+const CLOSE_TOO_BIG = 1009;
+const CLOSE_REVOKED = 4001;
+function newCharmId() {
+	return `c_${randomBytes(6).toString("hex")}`;
+}
+var Session = class {
+	connectionId;
+	sessionId = randomBytes(8).toString("hex");
+	#state = "awaiting_hello";
+	#charmId;
+	#queue = Promise.resolve();
+	#turn;
+	#asks = Promise.resolve();
+	#pendingAsk;
+	#deps;
+	constructor(deps) {
+		this.#deps = deps;
+		this.connectionId = deps.connectionId;
+	}
+	get state() {
+		return this.#state;
+	}
+	get charmId() {
+		return this.#charmId;
+	}
+	#send(message) {
+		if (this.#state !== "closed") this.#deps.outbound.send(message);
+	}
+	#endTurn() {
+		this.#turn?.dispose();
+		this.#turn = void 0;
+	}
+	#activeTurn() {
+		if (!this.#turn && this.#deps.createTurn && this.#charmId) this.#turn = this.#deps.createTurn({
+			sessionKey: `opencharm-${this.#charmId}`,
+			send: (message) => this.#send(message),
+			sendAudio: (packet) => {
+				if (this.#state === "unlocked") this.#deps.outbound.sendAudio?.(packet);
+			},
+			ask: (text, options) => this.ask(text, options)
+		});
+		return this.#turn;
+	}
+	#close(code) {
+		if (this.#state === "closed") return;
+		this.#pendingAsk?.drop();
+		this.#endTurn();
+		this.#state = "closed";
+		this.#deps.pairing.release(this.connectionId);
+		this.#deps.outbound.close(code);
+	}
+	#charm() {
+		return this.#charmId ? this.#deps.store.find(this.#charmId) : void 0;
+	}
+	#sendLocked() {
+		const charm = this.#charm();
+		if (charm?.blocked) this.#send({
+			type: "charm",
+			op: "locked",
+			reason: "blocked"
+		});
+		else this.#send({
+			type: "charm",
+			op: "locked",
+			reason: "boot",
+			tries_left: MAX_TRIES - (charm?.failedTries ?? 0)
+		});
+	}
+	#sendUnlocked() {
+		const look = this.#deps.look?.();
+		if (look) this.#send(look);
+		this.#send({
+			type: "charm",
+			op: "unlocked"
+		});
+	}
+	#issuePairCode() {
+		try {
+			const { code, expiresIn } = this.#deps.pairing.issue(this.connectionId);
+			this.#send({
+				type: "charm",
+				op: "pair_code",
+				code,
+				expires_in: expiresIn
+			});
+		} catch {
+			this.#close(CLOSE_POLICY$1);
+		}
+	}
+	onText(raw) {
+		this.#queue = this.#queue.then(() => this.#handleText(raw));
+		return this.#queue;
+	}
+	async #handleText(raw) {
+		if (this.#state === "closed") return;
+		const parsed = parseClientMessage(raw);
+		if (!parsed.ok) {
+			this.#close(CLOSE_POLICY$1);
+			return;
+		}
+		const message = parsed.message;
+		if (this.#state === "awaiting_hello") {
+			if (message.type !== "hello") {
+				this.#close(CLOSE_POLICY$1);
+				return;
+			}
+			this.#onHello();
+			return;
+		}
+		await this.#onMessage(message);
+	}
+	#onHello() {
+		this.#send({
+			type: "hello",
+			transport: "websocket",
+			session_id: this.sessionId,
+			audio_params: AUDIO_DOWN
+		});
+		const { token } = this.#deps;
+		if (token === void 0) {
+			this.#state = "unpaired";
+			this.#issuePairCode();
+			return;
+		}
+		const charm = this.#deps.store.findByTokenHash(hashToken(token));
+		if (!charm) {
+			this.#send({
+				type: "charm",
+				op: "revoked"
+			});
+			this.#close(CLOSE_REVOKED);
+			return;
+		}
+		this.#charmId = charm.id;
+		this.#state = "locked";
+		this.#sendLocked();
+	}
+	async #onMessage(message) {
+		if (message.type === "hello") return;
+		if (this.#state === "unpaired") {
+			this.#issuePairCode();
+			return;
+		}
+		if (message.type === "charm" && message.op === "unlock") {
+			await this.#onUnlock(message.pin);
+			return;
+		}
+		if (this.#state !== "unlocked") {
+			this.#sendLocked();
+			return;
+		}
+		if (message.type === "charm" && message.op === "answer") {
+			if (this.#pendingAsk?.id === message.id) this.#pendingAsk.settle(message.yes);
+			return;
+		}
+		const turn = this.#activeTurn();
+		if (!turn) return;
+		if (message.type === "listen") {
+			if (message.state === "start") turn.listenStart();
+			else if (message.state === "stop") turn.listenStop();
+		} else if (message.type === "abort") turn.abort();
+	}
+	async #onUnlock(pin) {
+		if (this.#state === "unlocked") {
+			this.#sendUnlocked();
+			return;
+		}
+		const charm = this.#charm();
+		if (!charm || charm.blocked) {
+			this.#sendLocked();
+			return;
+		}
+		if (await verifyPin(pin, charm.pinHash)) {
+			this.#deps.store.put({
+				...charm,
+				failedTries: 0
+			});
+			this.#state = "unlocked";
+			this.#sendUnlocked();
+			return;
+		}
+		const failedTries = charm.failedTries + 1;
+		const blocked = failedTries >= MAX_TRIES;
+		this.#deps.store.put({
+			...charm,
+			failedTries,
+			blocked
+		});
+		this.#send(blocked ? {
+			type: "charm",
+			op: "locked",
+			reason: "blocked"
+		} : {
+			type: "charm",
+			op: "locked",
+			reason: "wrong_pin",
+			tries_left: MAX_TRIES - failedTries
+		});
+	}
+	onBinary(frame) {
+		if (frame.byteLength > LIMITS.maxAudioFrameBytes) {
+			this.#close(CLOSE_TOO_BIG);
+			return Promise.resolve();
+		}
+		this.#queue = this.#queue.then(() => this.#handleBinary(frame));
+		return this.#queue;
+	}
+	#handleBinary(frame) {
+		if (this.#state === "closed") return;
+		if (this.#state !== "unlocked") {
+			if (this.#state === "locked") this.#sendLocked();
+			return;
+		}
+		this.#activeTurn()?.audio(frame);
+	}
+	refreshPairCode() {
+		if (this.#state === "unpaired") this.#issuePairCode();
+	}
+	async completePairing(name, pin) {
+		if (this.#state !== "unpaired") throw new Error("This charm is not waiting to pair.");
+		const token = generateToken();
+		const record = {
+			id: newCharmId(),
+			name,
+			tokenHash: hashToken(token),
+			pinHash: await hashPin(pin),
+			failedTries: 0,
+			blocked: false,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		this.#deps.store.put(record);
+		this.#deps.pairing.release(this.connectionId);
+		this.#charmId = record.id;
+		this.#state = "locked";
+		this.#send({
+			type: "charm",
+			op: "paired",
+			token
+		});
+		this.#sendLocked();
+		return token;
+	}
+	ask(text, options = {}) {
+		const next = () => this.#askNow(text, options);
+		const result = this.#asks.then(next, next);
+		this.#asks = result;
+		const { signal } = options;
+		if (!signal) return result;
+		const cancelled = new Promise((resolve) => {
+			if (signal.aborted) resolve(false);
+			signal.addEventListener("abort", () => resolve(false), { once: true });
+		});
+		return Promise.race([result, cancelled]);
+	}
+	#askNow(text, { yes, no, signal }) {
+		if (this.#state !== "unlocked" || signal?.aborted) return Promise.resolve(false);
+		const id = randomBytes(6).toString("hex");
+		return new Promise((resolve) => {
+			const finish = (answer, clearCharm) => {
+				if (this.#pendingAsk?.id !== id) return;
+				this.#pendingAsk = void 0;
+				clearTimeout(timer);
+				signal?.removeEventListener("abort", onAbort);
+				if (clearCharm) this.#send({
+					type: "charm",
+					op: "ask_end",
+					id
+				});
+				resolve(answer);
+			};
+			const onAbort = () => finish(false, true);
+			const timer = setTimeout(() => finish(false, true), this.#deps.askTimeoutMs ?? ASK_TIMEOUT_MS);
+			signal?.addEventListener("abort", onAbort, { once: true });
+			this.#pendingAsk = {
+				id,
+				settle: (answer) => finish(answer, false),
+				drop: () => finish(false, false)
+			};
+			this.#send({
+				type: "charm",
+				op: "ask",
+				id,
+				text: fitUtf8(text, MAX_ASK_TEXT),
+				...yes ? { yes: fitUtf8(yes, MAX_ASK_LABEL) } : {},
+				...no ? { no: fitUtf8(no, MAX_ASK_LABEL) } : {}
+			});
+		});
+	}
+	lockRemote() {
+		if (this.#state !== "unlocked") return;
+		this.#pendingAsk?.drop();
+		this.#endTurn();
+		this.#state = "locked";
+		this.#send({
+			type: "charm",
+			op: "locked",
+			reason: "remote"
+		});
+	}
+	unlockByAdmin() {
+		const charm = this.#charm();
+		if (charm) this.#deps.store.put({
+			...charm,
+			blocked: false,
+			failedTries: 0
+		});
+		if (this.#state === "locked") {
+			this.#state = "unlocked";
+			this.#sendUnlocked();
+		}
+	}
+	sendLook(look) {
+		if (this.#state === "unlocked") this.#send(look);
+	}
+	devFace(state, text) {
+		if (this.#state !== "unlocked") throw new Error("The charm must be unlocked first.");
+		const line = text ? fitUtf8(text, MAX_ASK_TEXT) : void 0;
+		if (this.#turn?.busy) {
+			this.#turn.showFace(state, line);
+			return;
+		}
+		this.#send({
+			type: "charm",
+			op: "face",
+			state,
+			...line ? { text: line } : {}
+		});
+	}
+	devSay(text) {
+		if (this.#state !== "unlocked") throw new Error("The charm must be unlocked first.");
+		const turn = this.#activeTurn();
+		if (!turn) throw new Error("This charmd has no voice configured.");
+		if (turn.busy) throw new Error("The charm is in the middle of a turn: put this in your reply instead.");
+		turn.say(text).catch(() => void 0);
+	}
+	devAsk(text, options = {}) {
+		if (this.#state !== "unlocked") return Promise.reject(/* @__PURE__ */ new Error("The charm must be unlocked first."));
+		return this.#turn ? this.#turn.ask(text, options) : this.ask(text, options);
+	}
+	revoke() {
+		this.#send({
+			type: "charm",
+			op: "revoked"
+		});
+		this.#close(CLOSE_REVOKED);
+	}
+	closed() {
+		if (this.#state === "closed") return;
+		this.#pendingAsk?.drop();
+		this.#endTurn();
+		this.#state = "closed";
+		this.#deps.pairing.release(this.connectionId);
+	}
+};
+//#endregion
+//#region ../charmd/src/store/state-store.ts
+const recordSchema = z.object({
+	id: z.string().regex(/^c_[a-z0-9]{6,}$/),
+	name: z.string().min(1).max(40),
+	tokenHash: z.string().regex(/^[0-9a-f]{64}$/),
+	pinHash: z.string().min(1),
+	failedTries: z.number().int().min(0),
+	blocked: z.boolean(),
+	createdAt: z.string()
+});
+const stateSchema = z.object({
+	version: z.literal(1),
+	charms: z.array(recordSchema)
+});
+var StateStore = class StateStore {
+	#path;
+	#state;
+	constructor(path) {
+		this.#path = path;
+		this.#state = StateStore.#read(path);
+	}
+	static #read(path) {
+		if (!existsSync(path)) return {
+			version: 1,
+			charms: []
+		};
+		try {
+			return stateSchema.parse(JSON.parse(readFileSync(path, "utf8")));
+		} catch (error) {
+			throw new Error(`The charmd state file ${path} is unreadable (${error instanceof Error ? error.message : String(error)}). Fix or move it; charmd won't overwrite it.`);
+		}
+	}
+	#write() {
+		mkdirSync(dirname(this.#path), {
+			recursive: true,
+			mode: 448
+		});
+		const temp = `${this.#path}.${process.pid}.tmp`;
+		writeFileSync(temp, `${JSON.stringify(this.#state, null, 2)}\n`, { mode: 384 });
+		renameSync(temp, this.#path);
+		chmodSync(this.#path, 384);
+	}
+	list() {
+		return this.#state.charms.map((charm) => ({ ...charm }));
+	}
+	find(idOrName) {
+		return this.#state.charms.find((charm) => charm.id === idOrName || charm.name === idOrName);
+	}
+	findByTokenHash(tokenHash) {
+		return this.#state.charms.find((charm) => charm.tokenHash === tokenHash);
+	}
+	put(record) {
+		const next = recordSchema.parse(record);
+		this.#state.charms = [...this.#state.charms.filter((charm) => charm.id !== next.id), next];
+		this.#write();
+	}
+	remove(id) {
+		this.#state.charms = this.#state.charms.filter((charm) => charm.id !== id);
+		this.#write();
+	}
+};
+//#endregion
+//#region ../charmd/src/audio/ogg-opus.ts
+const FIRST_PAGE = 2;
+const LAST_PAGE = 4;
+const MAX_SEGMENTS = 255;
+const DEFAULT_PRE_SKIP = 312;
+const VENDOR = "opencharm";
+const SILK = [
+	480,
+	960,
+	1920,
+	2880
+];
+const HYBRID = [480, 960];
+const CELT = [
+	120,
+	240,
+	480,
+	960
+];
+const CRC_TABLE = (() => {
+	const table = /* @__PURE__ */ new Uint32Array(256);
+	for (let i = 0; i < 256; i++) {
+		let r = i << 24;
+		for (let j = 0; j < 8; j++) r = r & 2147483648 ? r << 1 ^ 79764919 : r << 1;
+		table[i] = r >>> 0;
+	}
+	return table;
+})();
+function crc32(data) {
+	let crc = 0;
+	for (const byte of data) crc = (crc << 8 ^ (CRC_TABLE[(crc >>> 24 ^ byte) & 255] ?? 0)) >>> 0;
+	return crc;
+}
+function lacing(length) {
+	const segments = new Array(Math.floor(length / 255)).fill(255);
+	segments.push(length % 255);
+	return segments;
+}
+function page(flags, granule, serial, sequence, segments, body) {
+	const header = Buffer.alloc(27 + segments.length);
+	header.write("OggS", 0, "ascii");
+	header.writeUInt8(0, 4);
+	header.writeUInt8(flags, 5);
+	header.writeBigUInt64LE(granule, 6);
+	header.writeUInt32LE(serial, 14);
+	header.writeUInt32LE(sequence, 18);
+	header.writeUInt8(segments.length, 26);
+	Buffer.from(segments).copy(header, 27);
+	const out = Buffer.concat([header, body]);
+	out.writeUInt32LE(crc32(out), 22);
+	return out;
+}
+function opusPacketSamples48k(packet) {
+	const toc = packet[0] ?? 0;
+	const config = toc >> 3;
+	const frame = config < 12 ? SILK[config % 4] ?? 0 : config < 16 ? HYBRID[config % 2] ?? 0 : CELT[config % 4] ?? 0;
+	const code = toc & 3;
+	return frame * (code === 0 ? 1 : code === 3 ? (packet[1] ?? 0) & 63 : 2);
+}
+function writeOggOpus(packets, options) {
+	const serial = options.serial ?? 1868785778;
+	const head = Buffer.alloc(19);
+	head.write("OpusHead", 0, "ascii");
+	head.writeUInt8(1, 8);
+	head.writeUInt8(options.channels ?? 1, 9);
+	head.writeUInt16LE(DEFAULT_PRE_SKIP, 10);
+	head.writeUInt32LE(options.inputSampleRate, 12);
+	head.writeInt16LE(0, 16);
+	head.writeUInt8(0, 18);
+	const vendor = Buffer.from(VENDOR, "utf8");
+	const tags = Buffer.alloc(12 + vendor.length + 4);
+	tags.write("OpusTags", 0, "ascii");
+	tags.writeUInt32LE(vendor.length, 8);
+	vendor.copy(tags, 12);
+	tags.writeUInt32LE(0, 12 + vendor.length);
+	const pages = [page(FIRST_PAGE, 0n, serial, 0, lacing(head.length), head), page(0, 0n, serial, 1, lacing(tags.length), tags)];
+	let sequence = 2;
+	let granule = 0n;
+	let segments = [];
+	let bodies = [];
+	const flush = (last) => {
+		pages.push(page(last ? LAST_PAGE : 0, granule, serial, sequence++, segments, Buffer.concat(bodies)));
+		segments = [];
+		bodies = [];
+	};
+	packets.forEach((packet, index) => {
+		const laced = lacing(packet.length);
+		if (laced.length > MAX_SEGMENTS) throw new Error("Opus packet too large for one Ogg page");
+		if (segments.length + laced.length > MAX_SEGMENTS) flush(false);
+		segments.push(...laced);
+		bodies.push(packet);
+		granule += BigInt(opusPacketSamples48k(packet));
+		if (index === packets.length - 1) flush(true);
+	});
+	if (packets.length === 0) flush(true);
+	return Buffer.concat(pages);
+}
+function readOggOpus(data) {
+	const packets = [];
+	let pending = [];
+	let offset = 0;
+	while (offset < data.length) {
+		if (data.toString("ascii", offset, offset + 4) !== "OggS") throw new Error("Not an Ogg stream (missing OggS page)");
+		const count = data.readUInt8(offset + 26);
+		const table = data.subarray(offset + 27, offset + 27 + count);
+		let cursor = offset + 27 + count;
+		for (const size of table) {
+			pending.push(data.subarray(cursor, cursor + size));
+			cursor += size;
+			if (size < 255) {
+				packets.push(Buffer.concat(pending));
+				pending = [];
+			}
+		}
+		offset = cursor;
+	}
+	const [headPacket, tagsPacket, ...audio] = packets;
+	if (!headPacket || headPacket.toString("ascii", 0, 8) !== "OpusHead") throw new Error("Not an Ogg Opus stream (no OpusHead)");
+	if (!tagsPacket || tagsPacket.toString("ascii", 0, 8) !== "OpusTags") throw new Error("Not an Ogg Opus stream (no OpusTags)");
+	return {
+		head: {
+			channels: headPacket.readUInt8(9),
+			preSkip: headPacket.readUInt16LE(10),
+			inputSampleRate: headPacket.readUInt32LE(12)
+		},
+		packets: audio
+	};
+}
+//#endregion
+//#region ../charmd/src/turn/sentences.ts
+const MIN_CHARS = 10;
+const ABBREVIATIONS = /* @__PURE__ */ new Set([
+	"e.g.",
+	"i.e.",
+	"dr.",
+	"mr.",
+	"mrs.",
+	"ms.",
+	"st.",
+	"vs.",
+	"no."
+]);
+const BOUNDARY = /[.!?…]+(?=\s)|\n+/g;
+var SentenceSplitter = class {
+	#buffer = "";
+	#pending = "";
+	#take(piece) {
+		const text = piece.replace(/\s+/g, " ").trim();
+		if (!text) return [];
+		this.#pending = this.#pending ? `${this.#pending} ${text}` : text;
+		if (this.#pending.length < MIN_CHARS) return [];
+		const out = this.#pending;
+		this.#pending = "";
+		return [out];
+	}
+	push(chunk) {
+		this.#buffer += chunk;
+		const out = [];
+		let start = 0;
+		for (const match of this.#buffer.matchAll(BOUNDARY)) {
+			const end = match.index + match[0].length;
+			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)));
+			start = end;
+		}
+		this.#buffer = this.#buffer.slice(start);
+		return out;
+	}
+	flush() {
+		const rest = this.#take(this.#buffer);
+		this.#buffer = "";
+		const tail = this.#pending;
+		this.#pending = "";
+		return tail ? [...rest, tail] : rest;
+	}
+};
+function cleanForSpeech(text) {
+	return text.replace(/\[([^\]]+)\]\([^)]*\)/g, "$1").replace(/^\s*(?:#{1,6}|[-*+]|\d+\.)\s+/gm, "").replace(/[*_`~#>]/g, "").replace(/\s+/g, " ").trim();
+}
+//#endregion
+//#region ../charmd/src/turn/turn.ts
+const MAX_FRAMES = 1e3;
+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));
+		this.stage = stage;
+	}
+};
+function sleepMs(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function inStage(stage, work) {
+	try {
+		return await work();
+	} catch (error) {
+		throw error instanceof TurnTimeout ? error : new StageError(stage, error);
+	}
+}
+var TurnController = class {
+	#state = "idle";
+	#frames = [];
+	#generation = 0;
+	#controller;
+	#speaking = false;
+	#asking;
+	#endFace;
+	#deps;
+	constructor(deps) {
+		this.#deps = deps;
+	}
+	get state() {
+		return this.#state;
+	}
+	#face(state, text) {
+		this.#deps.send({
+			type: "charm",
+			op: "face",
+			state,
+			...text ? { text } : {}
+		});
+	}
+	get busy() {
+		return this.#state !== "idle";
+	}
+	showFace(state, text) {
+		this.#face(state, text);
+		if (this.busy) this.#endFace = {
+			state,
+			...text ? { text } : {}
+		};
+	}
+	ask(text, options = {}) {
+		if (this.#asking) return this.#asking(text, options);
+		return this.#deps.ask ? this.#deps.ask(text, options) : Promise.resolve(false);
+	}
+	#cancel() {
+		this.#endFace = void 0;
+		this.#generation += 1;
+		this.#controller?.abort();
+		this.#controller = void 0;
+		if (this.#speaking) this.#deps.send({
+			type: "tts",
+			state: "stop"
+		});
+		this.#speaking = false;
+	}
+	listenStart() {
+		if (this.#state === "thinking" || this.#state === "speaking") this.#cancel();
+		this.#state = "listening";
+		this.#frames = [];
+		this.#face("listening");
+		this.#deps.agent.warm?.(this.#deps.sessionKey);
+	}
+	audio(frame) {
+		if (this.#state === "listening" && this.#frames.length < MAX_FRAMES) this.#frames.push(frame);
+	}
+	abort() {
+		if (this.#state === "idle") return;
+		this.#cancel();
+		this.#state = "idle";
+		this.#face("idle");
+	}
+	listenStop() {
+		if (this.#state !== "listening") return Promise.resolve();
+		const frames = this.#frames;
+		this.#frames = [];
+		if (frames.length === 0) {
+			this.#state = "idle";
+			this.#face("idle");
+			return Promise.resolve();
+		}
+		return this.#run(frames);
+	}
+	async #run(frames) {
+		const generation = ++this.#generation;
+		const live = () => this.#generation === generation;
+		const controller = new AbortController();
+		this.#controller = controller;
+		const { signal } = controller;
+		const now = this.#deps.now ?? Date.now;
+		const started = now();
+		const timings = {};
+		let heard = "";
+		let said = "";
+		let outcome = "done";
+		const startClock = () => setTimeout(() => controller.abort(new TurnTimeout()), this.#deps.timeoutMs);
+		let timer = startClock();
+		const timeoutGuard = new Promise((_, reject) => signal.addEventListener("abort", () => {
+			if (signal.reason instanceof TurnTimeout) reject(signal.reason);
+		}));
+		timeoutGuard.catch(() => void 0);
+		this.#state = "thinking";
+		this.#face("thinking");
+		try {
+			const ogg = writeOggOpus(frames, { inputSampleRate: 16e3 });
+			heard = await Promise.race([inStage("stt", () => this.#deps.voice.transcribe(ogg, signal)), timeoutGuard]);
+			timings.sttMs = now() - started;
+			if (!live()) return;
+			this.#deps.send({
+				type: "stt",
+				text: heard
+			});
+			if (!heard) {
+				outcome = "nothing-heard";
+				this.#state = "idle";
+				this.#face("idle");
+				return;
+			}
+			const ask = this.#deps.ask;
+			const label = AGENT_LABELS[this.#deps.agent.name] ?? "Your agent";
+			if (ask) this.#asking = async (text, options) => {
+				clearTimeout(timer);
+				try {
+					return await ask(text, {
+						...options,
+						signal
+					});
+				} finally {
+					if (!signal.aborted) timer = startClock();
+				}
+			};
+			const reply = this.#deps.agent.reply({
+				sessionKey: this.#deps.sessionKey,
+				text: heard,
+				signal,
+				...ask ? { ask: (action) => this.ask(`${label} wants to ${action}.`) } : {}
+			});
+			said = await this.#speak(reply, signal, live, timings, started, timeoutGuard);
+			if (!live()) return;
+			if (this.#speaking) this.#deps.send({
+				type: "tts",
+				state: "stop"
+			});
+			this.#speaking = false;
+			this.#state = "idle";
+			const end = this.#endFace ?? { state: "idle" };
+			this.#endFace = void 0;
+			this.#face(end.state, end.text);
+		} catch (error) {
+			outcome = error instanceof TurnTimeout ? "timeout" : error instanceof StageError ? `${error.stage}-error` : "error";
+			if (!live()) return;
+			if (this.#speaking) this.#deps.send({
+				type: "tts",
+				state: "stop"
+			});
+			this.#speaking = false;
+			this.#state = "idle";
+			this.#face("failed", this.#failureLine(error));
+		} finally {
+			clearTimeout(timer);
+			if (live()) {
+				this.#controller = void 0;
+				this.#asking = void 0;
+				this.#endFace = void 0;
+			}
+			this.#deps.log?.({
+				event: "turn",
+				session: this.#deps.sessionKey,
+				outcome: live() ? outcome : "cancelled",
+				...timings,
+				totalMs: now() - started,
+				...this.#deps.logTranscripts ? {
+					heard,
+					said: said.trim()
+				} : {}
+			});
+		}
+	}
+	async #speak(source, signal, live, timings, started, timeoutGuard) {
+		const now = this.#deps.now ?? Date.now;
+		const queue = [];
+		let wake = () => void 0;
+		let sourceDone = false;
+		let said = "";
+		const enqueue = (sentence) => {
+			const text = cleanForSpeech(sentence);
+			if (!text) return;
+			said += `${text} `;
+			const pending = inStage("tts", () => this.#deps.voice.synthesize(text, signal)).then((audio) => ({
+				text,
+				ogg: audio
+			}));
+			pending.catch(() => void 0);
+			queue.push(pending);
+			wake();
+		};
+		const produce = (async () => {
+			const splitter = new SentenceSplitter();
+			await inStage("agent", async () => {
+				for await (const chunk of source) {
+					if (!live()) return;
+					for (const sentence of splitter.push(chunk)) enqueue(sentence);
+				}
+			});
+			for (const sentence of splitter.flush()) enqueue(sentence);
+		})().finally(() => {
+			sourceDone = true;
+			wake();
+		});
+		produce.catch(() => void 0);
+		const play = async () => {
+			let index = 0;
+			for (;;) {
+				if (index >= queue.length) {
+					if (sourceDone) return;
+					await new Promise((resolve) => wake = resolve);
+					continue;
+				}
+				const { text, ogg } = await Promise.race([queue[index++], timeoutGuard]);
+				if (!live()) return;
+				if (!this.#speaking) {
+					this.#speaking = true;
+					this.#state = "speaking";
+					timings.firstAudioMs = now() - started;
+					this.#deps.send({
+						type: "tts",
+						state: "start"
+					});
+				}
+				this.#deps.send({
+					type: "tts",
+					state: "sentence_start",
+					text
+				});
+				await this.#sendPaced(readOggOpus(ogg).packets, live);
+			}
+		};
+		await Promise.all([Promise.race([produce, timeoutGuard]), play()]);
+		return said.trim();
+	}
+	async say(text) {
+		if (this.busy) throw new Error("The charm is in the middle of a turn: put this in your reply instead.");
+		const generation = ++this.#generation;
+		const live = () => this.#generation === generation;
+		const controller = new AbortController();
+		this.#controller = controller;
+		const timer = setTimeout(() => controller.abort(new TurnTimeout()), this.#deps.timeoutMs);
+		const timeoutGuard = new Promise((_, reject) => controller.signal.addEventListener("abort", () => {
+			if (controller.signal.reason instanceof TurnTimeout) reject(controller.signal.reason);
+		}));
+		timeoutGuard.catch(() => void 0);
+		async function* once() {
+			yield await Promise.resolve(text);
+		}
+		try {
+			await this.#speak(once(), controller.signal, live, {}, Date.now(), timeoutGuard);
+			if (!live()) return;
+			if (this.#speaking) this.#deps.send({
+				type: "tts",
+				state: "stop"
+			});
+			this.#speaking = false;
+			this.#state = "idle";
+			this.#face("idle");
+		} catch (error) {
+			if (!live()) return;
+			if (this.#speaking) this.#deps.send({
+				type: "tts",
+				state: "stop"
+			});
+			this.#speaking = false;
+			this.#state = "idle";
+			this.#face("failed", this.#failureLine(error));
+		} finally {
+			clearTimeout(timer);
+		}
+	}
+	#failureLine(error) {
+		if (error instanceof TurnTimeout) return "That took too long.";
+		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) {
+		const sleep = this.#deps.sleep ?? sleepMs;
+		for (const [index, packet] of packets.entries()) {
+			if (!live()) return;
+			this.#deps.sendAudio(packet);
+			if (index >= 2) await sleep(opusPacketSamples48k(packet) / 48);
+		}
+	}
+	dispose() {
+		this.#cancel();
+		this.#state = "idle";
+	}
+};
+//#endregion
+//#region ../charmd/src/agent/acp.ts
+const AUTH_REQUIRED = -32e3;
+const NO_ACCESS = {
+	fs: {
+		readTextFile: false,
+		writeTextFile: false
+	},
+	terminal: false
+};
+function queue() {
+	const items = [];
+	let wake;
+	return {
+		push(item) {
+			items.push(item);
+			wake?.();
+		},
+		async next() {
+			while (items.length === 0) await new Promise((resolve) => wake = resolve);
+			wake = void 0;
+			return items.shift();
+		}
+	};
+}
+function realFolder(path, what) {
+	try {
+		return realpathSync(path);
+	} catch {
+		throw new Error(`${what} ${path} not found`);
+	}
+}
+function describeAction(title, cwd) {
+	const mcp = /^mcp__([^_]+(?:_[^_]+)*)__(.+)$/.exec(title.trim());
+	if (mcp) return `use the ${mcp[1]} tool ${mcp[2]}`;
+	const text = title.trim().split(`${cwd}/`).join("").split(`${dirname(cwd)}/`).join("../").split(homedir()).join("~");
+	const action = text.charAt(0).toLowerCase() + text.slice(1);
+	return action.length > 120 ? `${action.slice(0, 119)}…` : action;
+}
+function friendly(error, program) {
+	if (error instanceof acp.RequestError) {
+		if (error.code === AUTH_REQUIRED) return /* @__PURE__ */ new Error(`${program} needs you to log in first: run it once in a terminal and log in`);
+		const details = error.data?.details;
+		if (typeof details === "string") return new Error(details);
+	}
+	return error instanceof Error ? error : new Error(String(error));
+}
+function createAcpAgent(options) {
+	const [program = "", ...args] = options.command;
+	const log = options.log ?? (() => void 0);
+	const sessions = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Map();
+	const askers = /* @__PURE__ */ new Map();
+	let starting;
+	let running;
+	let child;
+	const home = () => realFolder(options.cwd, "the workspace");
+	async function launch() {
+		const proc = spawn(program, args, {
+			cwd: home(),
+			env: {
+				...process.env,
+				...options.env
+			},
+			shell: process.platform === "win32"
+		});
+		child = proc;
+		let stderr = "";
+		let failure;
+		proc.stderr.on("data", (chunk) => stderr = (stderr + chunk.toString()).slice(-400));
+		proc.stdin.on("error", () => void 0);
+		const connection = acp.client({ name: "charmd" }).onRequest(acp.methods.client.session.requestPermission, async (ctx) => {
+			const { options: offered, toolCall, sessionId } = ctx.params;
+			const title = toolCall.title ?? "use a tool";
+			const allow = offered.find((o) => o.kind === "allow_once");
+			const reject = offered.find((o) => o.kind === "reject_once");
+			const asker = askers.get(sessionId);
+			if (!asker) log(`refused "${title}": nobody can answer (no turn running)`);
+			else if (!allow) log(`refused "${title}": the agent offered no "allow once"`);
+			if ((asker && allow ? await asker.ask(describeAction(title, home())) : false) && allow) return { outcome: {
+				outcome: "selected",
+				optionId: allow.optionId
+			} };
+			if (asker?.signal.aborted) return { outcome: { outcome: "cancelled" } };
+			return reject ? { outcome: {
+				outcome: "selected",
+				optionId: reject.optionId
+			} } : { outcome: { outcome: "cancelled" } };
+		}).onNotification(acp.methods.client.session.update, (ctx) => listeners.get(ctx.params.sessionId)?.(ctx.params.update)).connect(acp.ndJsonStream(Writable.toWeb(proc.stdin), Readable.toWeb(proc.stdout)));
+		const stopped = new Promise((_, reject) => {
+			proc.on("error", (error) => {
+				failure = error.code === "ENOENT" ? /* @__PURE__ */ new Error(`${program} not found: install it, or fix "command" in the config`) : error;
+			});
+			proc.on("close", (code) => {
+				failure ??= /* @__PURE__ */ new Error(`the agent stopped (exit ${code ?? "?"})${stderr.trim() ? `: ${stderr.trim()}` : ""}`);
+				connection.close(failure);
+				if (running?.child === proc) running = void 0;
+				if (child === proc) {
+					starting = void 0;
+					sessions.clear();
+				}
+				for (const listener of listeners.values()) listener({ sessionUpdate: "__stopped" });
+				reject(failure);
+			});
+		});
+		stopped.catch(() => void 0);
+		const explain = async (error) => {
+			await Promise.race([stopped.catch(() => void 0), new Promise((resolve) => setTimeout(resolve, 500))]);
+			return failure ?? friendly(error, program);
+		};
+		const ready = connection.agent.request(acp.methods.agent.initialize, {
+			protocolVersion: acp.PROTOCOL_VERSION,
+			clientCapabilities: NO_ACCESS
+		}).then((init) => {
+			const agent = {
+				child: proc,
+				context: connection.agent,
+				canAttach: Boolean(init.agentCapabilities?.sessionCapabilities?.additionalDirectories),
+				failure: () => failure ?? /* @__PURE__ */ new Error("the agent stopped"),
+				explain
+			};
+			running = agent;
+			return agent;
+		}).catch(async (error) => {
+			proc.kill();
+			throw await explain(error);
+		});
+		return Promise.race([ready, stopped]);
+	}
+	function start() {
+		starting ??= launch();
+		return starting;
+	}
+	function session(sessionKey) {
+		let id = sessions.get(sessionKey);
+		if (!id) {
+			id = start().then(async (agent) => {
+				if (options.projects?.length && !agent.canAttach) throw new Error(`${program} can't open extra folders: remove "projects" from the config`);
+				try {
+					const created = await agent.context.request(acp.methods.agent.session.new, {
+						cwd: home(),
+						mcpServers: options.mcpServers ?? [],
+						...options.sessionMeta ? { _meta: options.sessionMeta } : {},
+						...options.projects?.length ? { additionalDirectories: options.projects.map((path) => realFolder(path, "the project folder")) } : {}
+					});
+					const mode = options.mode;
+					if (mode && created.modes?.currentModeId !== mode) {
+						const offered = created.modes?.availableModes.map((m) => m.id);
+						if (!offered?.includes(mode)) throw new Error(`${program} has no mode "${mode}" (it offers ${offered?.join(", ") || "none"})`);
+						await agent.context.request(acp.methods.agent.session.setMode, {
+							sessionId: created.sessionId,
+							modeId: mode
+						});
+					}
+					return {
+						agent,
+						sessionId: created.sessionId
+					};
+				} catch (error) {
+					throw await agent.explain(error);
+				}
+			});
+			const pending = id;
+			pending.catch(() => {
+				if (sessions.get(sessionKey) === pending) sessions.delete(sessionKey);
+			});
+			sessions.set(sessionKey, pending);
+		}
+		return id;
+	}
+	return {
+		name: options.name ?? "acp",
+		warm: (sessionKey) => void session(sessionKey).catch((error) => log(`agent not ready: ${error.message}`)),
+		dispose: () => child?.kill(),
+		async *reply({ sessionKey, text, signal, ask }) {
+			const { agent, sessionId } = await session(sessionKey);
+			if (signal.aborted) return;
+			const items = queue();
+			let wroteText = false;
+			let breakLine = false;
+			const own = (update) => {
+				if (signal.aborted) return;
+				if (update.sessionUpdate === "__stopped") items.push({ error: agent.failure() });
+				else if (update.sessionUpdate === "agent_message_chunk" && update.content.type === "text") {
+					if (breakLine) items.push({ text: "\n" });
+					breakLine = false;
+					wroteText = true;
+					items.push({ text: update.content.text });
+				} else if (update.sessionUpdate === "tool_call" || update.sessionUpdate === "tool_call_update") breakLine = wroteText;
+			};
+			listeners.set(sessionId, own);
+			const asker = ask ? {
+				ask,
+				signal
+			} : void 0;
+			if (asker) askers.set(sessionId, asker);
+			const onAbort = () => {
+				items.push({ end: true });
+				agent.context.notify(acp.methods.agent.session.cancel, { sessionId }).catch(() => void 0);
+			};
+			signal.addEventListener("abort", onAbort, { once: true });
+			agent.context.request(acp.methods.agent.session.prompt, {
+				sessionId,
+				prompt: [{
+					type: "text",
+					text
+				}]
+			}).then(() => items.push({ end: true }), async (error) => items.push({ error: await agent.explain(error) }));
+			try {
+				for (;;) {
+					const item = await items.next();
+					if (signal.aborted) return;
+					if ("end" in item) return;
+					if ("error" in item) throw item.error;
+					yield item.text;
+				}
+			} finally {
+				signal.removeEventListener("abort", onAbort);
+				if (listeners.get(sessionId) === own) listeners.delete(sessionId);
+				if (asker && askers.get(sessionId) === asker) askers.delete(sessionId);
+			}
+		}
+	};
+}
+//#endregion
+//#region ../charmd/src/agent/fake.ts
+function createFakeAgent(options = {}) {
+	return {
+		name: "fake",
+		async *reply({ text, signal }) {
+			if (options.fail) throw new Error("The fake agent was told to fail");
+			const answer = options.reply ? options.reply(text) : `You said: ${text}.`;
+			for (const word of answer.split(/(?<= )/)) {
+				if (signal.aborted) return;
+				if (options.delayMs) await new Promise((r) => setTimeout(r, options.delayMs));
+				yield word;
+			}
+		}
+	};
+}
+//#endregion
+//#region ../charmd/src/agent/sse.ts
+async function* parseSse(body) {
+	const decoder = new TextDecoder();
+	let buffer = "";
+	let event;
+	let data = [];
+	const reader = body.getReader();
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			buffer += done ? "\n\n" : decoder.decode(value, { stream: true });
+			let newline = buffer.search(/\r?\n/);
+			while (newline >= 0) {
+				const line = buffer.slice(0, newline);
+				buffer = buffer.slice(buffer[newline] === "\r" ? newline + 2 : newline + 1);
+				if (line === "") {
+					if (data.length > 0) yield {
+						event,
+						data: data.join("\n")
+					};
+					event = void 0;
+					data = [];
+				} else if (line.startsWith("data:")) data.push(line.slice(5).replace(/^ /, ""));
+				else if (line.startsWith("event:")) event = line.slice(6).trim();
+				newline = buffer.search(/\r?\n/);
+			}
+			if (done) return;
+		}
+	} finally {
+		reader.releaseLock();
+	}
+}
+//#endregion
+//#region ../charmd/src/agent/http.ts
+async function postStream(url, headers, body, signal) {
+	const response = await fetch(url, {
+		method: "POST",
+		headers: {
+			"content-type": "application/json",
+			accept: "text/event-stream",
+			...headers
+		},
+		body: JSON.stringify(body),
+		signal
+	});
+	if (!response.ok || !response.body) throw new Error(`The agent answered ${response.status} ${response.statusText} at ${url}`);
+	return response.body;
+}
+async function* sseJson(body) {
+	for await (const { data } of parseSse(body)) {
+		if (data === "[DONE]") return;
+		try {
+			yield JSON.parse(data);
+		} catch {}
+	}
+}
+//#endregion
+//#region ../charmd/src/agent/hermes.ts
+function createHermesAgent(options) {
+	return {
+		name: "hermes",
+		async *reply({ sessionKey, text, signal }) {
+			const body = await postStream(`${options.baseUrl.replace(/\/$/, "")}/responses`, {
+				...options.apiKey ? { authorization: `Bearer ${options.apiKey}` } : {},
+				"x-hermes-session-key": sessionKey
+			}, {
+				model: options.model,
+				stream: true,
+				input: text,
+				conversation: sessionKey,
+				store: true
+			}, signal);
+			for await (const event of sseJson(body)) {
+				const { type, delta } = event;
+				if (type === "response.output_text.delta" && delta) yield delta;
+			}
+		}
+	};
+}
+//#endregion
+//#region ../charmd/src/agent/openai-compatible.ts
+function createOpenAiCompatibleAgent(options) {
+	return {
+		name: "openai-compatible",
+		async *reply({ sessionKey, text, signal }) {
+			const body = await postStream(`${options.baseUrl.replace(/\/$/, "")}/chat/completions`, options.apiKey ? { authorization: `Bearer ${options.apiKey}` } : {}, {
+				model: options.model,
+				stream: true,
+				user: sessionKey,
+				messages: [{
+					role: "user",
+					content: text
+				}]
+			}, signal);
+			for await (const chunk of sseJson(body)) {
+				const content = chunk.choices?.[0]?.delta?.content;
+				if (content) yield content;
+			}
+		}
+	};
+}
+//#endregion
+//#region ../charmd/src/audio/opus-codec.ts
+const FRAME_MS = 60;
+function pcmToOggOpus(pcm, sampleRate) {
+	const samples = sampleRate * FRAME_MS / 1e3;
+	const frameBytes = samples * 2;
+	const encoder = new OpusScript(sampleRate, 1, OpusScript.Application.AUDIO);
+	const packets = [];
+	try {
+		for (let i = 0; i < pcm.length; i += frameBytes) {
+			const frame = Buffer.alloc(frameBytes);
+			pcm.copy(frame, 0, i, Math.min(i + frameBytes, pcm.length));
+			packets.push(Buffer.from(encoder.encode(frame, samples)));
+		}
+	} finally {
+		encoder.delete();
+	}
+	return writeOggOpus(packets, { inputSampleRate: sampleRate });
+}
+function oggOpusToPcm(ogg, sampleRate) {
+	const decoder = new OpusScript(sampleRate, 1);
+	try {
+		return Buffer.concat(readOggOpus(ogg).packets.map((packet) => Buffer.from(decoder.decode(packet))));
+	} finally {
+		decoder.delete();
+	}
+}
+//#endregion
+//#region ../charmd/src/voice/fake.ts
+const SAMPLE_RATE = 24e3;
+const MS_PER_CHAR = 55;
+function createFakeVoice(options = {}) {
+	return {
+		name: "fake",
+		transcribe: () => options.fail ? Promise.reject(/* @__PURE__ */ new Error("The fake voice was told to fail")) : Promise.resolve(options.transcript ?? "hello"),
+		synthesize: (text) => {
+			const samples = Math.round(text.length * MS_PER_CHAR * SAMPLE_RATE / 1e3);
+			const pcm = Buffer.alloc(samples * 2);
+			for (let i = 0; i < samples; i++) pcm.writeInt16LE(Math.round(Math.sin(2 * Math.PI * 220 * i / SAMPLE_RATE) * 2e3), i * 2);
+			return Promise.resolve(pcmToOggOpus(pcm, SAMPLE_RATE));
+		}
+	};
+}
+//#endregion
+//#region ../charmd/src/voice/wav.ts
+function writeWav(pcm, sampleRate, channels = 1) {
+	const header = Buffer.alloc(44);
+	header.write("RIFF", 0, "ascii");
+	header.writeUInt32LE(36 + pcm.length, 4);
+	header.write("WAVEfmt ", 8, "ascii");
+	header.writeUInt32LE(16, 16);
+	header.writeUInt16LE(1, 20);
+	header.writeUInt16LE(channels, 22);
+	header.writeUInt32LE(sampleRate, 24);
+	header.writeUInt32LE(sampleRate * channels * 2, 28);
+	header.writeUInt16LE(channels * 2, 32);
+	header.writeUInt16LE(16, 34);
+	header.write("data", 36, "ascii");
+	header.writeUInt32LE(pcm.length, 40);
+	return Buffer.concat([header, pcm]);
+}
+function readWav(data) {
+	if (data.toString("ascii", 0, 4) !== "RIFF" || data.toString("ascii", 8, 12) !== "WAVE") throw new Error("Not a WAV file");
+	let offset = 12;
+	let format;
+	while (offset + 8 <= data.length) {
+		const id = data.toString("ascii", offset, offset + 4);
+		const size = data.readUInt32LE(offset + 4);
+		const body = offset + 8;
+		if (id === "fmt ") format = {
+			channels: data.readUInt16LE(body + 2),
+			sampleRate: data.readUInt32LE(body + 4),
+			bits: data.readUInt16LE(body + 14)
+		};
+		else if (id === "data") {
+			if (!format || format.bits !== 16) throw new Error("Only 16-bit PCM WAV is supported");
+			return {
+				sampleRate: format.sampleRate,
+				channels: format.channels,
+				pcm: data.subarray(body, body + size)
+			};
+		}
+		offset = body + size + size % 2;
+	}
+	throw new Error("WAV file has no data chunk");
+}
+//#endregion
+//#region ../charmd/src/voice/local.ts
+const DEFAULT_SAY_VOICE = "Samantha";
+function defaultWhisperModel() {
+	return join(homedir(), ".opencharm", "models", "ggml-base.en.bin");
+}
+function run$1(command, args, signal) {
+	return new Promise((resolve, reject) => {
+		execFile(command, args, {
+			signal,
+			maxBuffer: 1048576
+		}, (error, stdout, stderr) => {
+			if (!error) {
+				resolve(stdout);
+				return;
+			}
+			const missing = error.code === "ENOENT";
+			reject(/* @__PURE__ */ new Error(missing ? `The local voice needs "${command}" installed` : `${command} failed: ${stderr.trim().slice(0, 200)}`));
+		});
+	});
+}
+function sayArgs(voice, input, wav) {
+	return [
+		"-v",
+		voice || DEFAULT_SAY_VOICE,
+		"-f",
+		input,
+		"-o",
+		wav,
+		"--file-format=WAVE",
+		"--data-format=LEI16@24000"
+	];
+}
+async function withTempDir(work) {
+	const dir = mkdtempSync(join(tmpdir(), "opencharm-voice-"));
+	try {
+		return await work(dir);
+	} finally {
+		rmSync(dir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+function createLocalVoice(options) {
+	const model = options.whisperModel ?? defaultWhisperModel();
+	return {
+		name: "local",
+		transcribe: (ogg, signal) => withTempDir(async (dir) => {
+			const wav = join(dir, "in.wav");
+			writeFileSync(wav, writeWav(oggOpusToPcm(ogg, 16e3), 16e3));
+			return (await run$1(options.whisperCommand ?? "whisper-cli", [
+				"-m",
+				model,
+				"-f",
+				wav,
+				"-nt",
+				"-np",
+				"-l",
+				"auto"
+			], signal)).replace(/\s+/g, " ").trim();
+		}),
+		synthesize: (text, signal) => withTempDir(async (dir) => {
+			const input = join(dir, "text.txt");
+			const wav = join(dir, "out.wav");
+			writeFileSync(input, text);
+			await run$1("say", sayArgs(options.sayVoice, input, wav), signal);
+			const { pcm, sampleRate } = readWav(readFileSync(wav));
+			if (sampleRate !== 24e3) throw new Error(`say produced ${sampleRate} Hz, expected 24000`);
+			return pcmToOggOpus(pcm, 24e3);
+		})
+	};
+}
+//#endregion
+//#region ../charmd/src/voice/openai.ts
+function createOpenAiVoice(options) {
+	const apiKey = options.apiKey ?? process.env.OPENAI_API_KEY;
+	if (!apiKey) throw new Error("The openai voice needs an API key: set voice.openai.apiKey or OPENAI_API_KEY");
+	const baseUrl = (options.baseUrl ?? "https://api.openai.com/v1").replace(/\/$/, "");
+	const auth = { authorization: `Bearer ${apiKey}` };
+	return {
+		name: "openai",
+		async transcribe(ogg, signal) {
+			const form = new FormData();
+			form.append("model", options.sttModel ?? "gpt-4o-mini-transcribe");
+			form.append("file", new Blob([new Uint8Array(ogg)], { type: "audio/ogg" }), "speech.ogg");
+			const response = await fetch(`${baseUrl}/audio/transcriptions`, {
+				method: "POST",
+				headers: auth,
+				body: form,
+				signal
+			});
+			if (!response.ok) throw new Error(`Speech-to-text failed: ${response.status} ${response.statusText}`);
+			const { text } = await response.json();
+			return (text ?? "").trim();
+		},
+		async synthesize(text, signal) {
+			const response = await fetch(`${baseUrl}/audio/speech`, {
+				method: "POST",
+				headers: {
+					...auth,
+					"content-type": "application/json"
+				},
+				body: JSON.stringify({
+					model: options.ttsModel ?? "gpt-4o-mini-tts",
+					input: text,
+					voice: options.voice ?? "alloy",
+					response_format: "opus"
+				}),
+				signal
+			});
+			if (!response.ok) throw new Error(`Text-to-speech failed: ${response.status} ${response.statusText}`);
+			return Buffer.from(await response.arrayBuffer());
+		}
+	};
+}
+//#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);
+		case "openai": return createOpenAiVoice({
+			...voice,
+			apiKey: key(voice, "OPENAI_API_KEY")
+		});
+	}
+}
+function charmToolsServers(config, tools) {
+	const agent = config.agent;
+	if (agent.adapter !== "acp" || !agent.charmTools || !tools) return [];
+	return [{
+		name: "charm",
+		command: tools.command,
+		args: [
+			...tools.args,
+			"--socket",
+			config.adminSocket
+		],
+		env: []
+	}];
+}
+function createAgentFromConfig(config, log = () => void 0, tools) {
+	const agent = config.agent;
+	switch (agent.adapter) {
+		case "fake": return createFakeAgent();
+		case "openai-compatible": return createOpenAiCompatibleAgent({
+			...agent,
+			apiKey: key(agent)
+		});
+		case "openclaw": return createOpenAiCompatibleAgent({
+			...agent,
+			apiKey: key(agent, "OPENCLAW_GATEWAY_TOKEN")
+		});
+		case "hermes": return createHermesAgent({
+			...agent,
+			apiKey: key(agent, "API_SERVER_KEY")
+		});
+		case "acp": return createAcpAgent({
+			...agent,
+			log,
+			mcpServers: charmToolsServers(config, tools)
+		});
+	}
+}
+//#endregion
+//#region ../charmd/src/daemon.ts
+const CLOSE_POLICY = 1008;
+const CLOSE_BUSY = 1013;
+const HEARTBEAT_MS = 3e4;
+async function startDaemon(config, options = {}) {
+	const unpairedIdleMs = options.timings?.unpairedIdleMs ?? TIMEOUTS.unpairedIdleSeconds * 1e3;
+	const pairCodeMs = options.timings?.pairCodeMs ?? TIMEOUTS.pairCodeSeconds * 1e3;
+	const store = new StateStore(config.statePath);
+	const pairing = new PairingRegistry({
+		ttlMs: pairCodeMs,
+		maxPending: config.maxConnections
+	});
+	const sessions = /* @__PURE__ */ new Map();
+	const voice = createVoiceFromConfig(config);
+	const log = options.log ?? ((entry) => {
+		if (!options.quiet) console.log(JSON.stringify({
+			time: (/* @__PURE__ */ new Date()).toISOString(),
+			...entry
+		}));
+	});
+	const agent = createAgentFromConfig(config, (message) => log({
+		event: "agent",
+		message
+	}), options.charmTools);
+	const { agentCanChangeLook, ...lookSettings } = config.charm;
+	const look = new CharmLook(lookSettings, readAgentName(config.agent.adapter === "acp" ? config.agent.cwd : void 0));
+	const admin = createAdminActions({
+		store,
+		pairing,
+		sessions: () => sessions.values(),
+		look,
+		agentCanChangeLook
+	});
+	const adminServer = await startAdminServer(config.adminSocket, admin);
+	let websocketUrl = config.publicUrl ?? "";
+	const http = createServer$1((req, res) => {
+		if (isOtaRequest(req)) {
+			handleOta(res, websocketUrl);
+			return;
+		}
+		res.writeHead(404).end();
+	});
+	const wss = new WebSocketServer({
+		server: http,
+		path: "/charm",
+		maxPayload: LIMITS.maxJsonBytes,
+		handleProtocols: (protocols) => protocols.has("opencharm") ? SUBPROTOCOL : false
+	});
+	wss.on("error", () => void 0);
+	const answered = /* @__PURE__ */ new WeakSet();
+	const heartbeat = setInterval(() => {
+		for (const client of wss.clients) {
+			if (!answered.has(client)) {
+				client.terminate();
+				continue;
+			}
+			answered.delete(client);
+			client.ping();
+		}
+	}, options.timings?.heartbeatMs ?? HEARTBEAT_MS);
+	wss.on("connection", (ws, req) => {
+		if (sessions.size >= config.maxConnections) {
+			ws.close(CLOSE_BUSY);
+			return;
+		}
+		const session = new Session({
+			store,
+			pairing,
+			connectionId: randomUUID(),
+			token: tokenFrom(req),
+			look: () => look.message(),
+			outbound: {
+				send: (message) => ws.send(JSON.stringify(message)),
+				sendAudio: (packet) => ws.send(packet, { binary: true }),
+				close: (code) => ws.close(code)
+			},
+			createTurn: (io) => new TurnController({
+				...io,
+				voice,
+				agent,
+				timeoutMs: config.turnTimeoutSeconds * 1e3,
+				logTranscripts: config.logTranscripts,
+				log
+			})
+		});
+		sessions.set(session.connectionId, session);
+		answered.add(ws);
+		ws.on("pong", () => answered.add(ws));
+		const idle = setTimeout(() => {
+			if (session.state === "awaiting_hello" || session.state === "unpaired") ws.close(CLOSE_POLICY);
+		}, unpairedIdleMs);
+		const refresh = setInterval(() => session.refreshPairCode(), pairCodeMs);
+		ws.on("message", (data, isBinary) => {
+			const buffer = toBuffer(data);
+			if (isBinary) session.onBinary(buffer);
+			else session.onText(buffer.toString("utf8"));
+		});
+		ws.on("close", () => {
+			clearTimeout(idle);
+			clearInterval(refresh);
+			session.closed();
+			sessions.delete(session.connectionId);
+		});
+		ws.on("error", () => ws.terminate());
+	});
+	try {
+		await new Promise((resolve, reject) => {
+			http.once("error", reject);
+			http.listen(config.listen.port, config.listen.host, resolve);
+		});
+	} catch (error) {
+		clearInterval(heartbeat);
+		await new Promise((resolve) => adminServer.close(() => resolve()));
+		throw error;
+	}
+	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}`);
+	return {
+		url,
+		admin,
+		close: async () => {
+			clearInterval(heartbeat);
+			for (const client of wss.clients) client.terminate();
+			agent.dispose?.();
+			await new Promise((resolve) => wss.close(() => resolve()));
+			await new Promise((resolve) => http.close(() => resolve()));
+			await new Promise((resolve) => adminServer.close(() => resolve()));
+		}
+	};
+}
+//#endregion
+//#region src/commands/serve.ts
+async function runServe(ctx, args) {
+	let config;
+	let daemon;
+	try {
+		config = loadConfig(flagValue(args, "--config"));
+		daemon = await startDaemon(config, {
+			quiet: true,
+			charmTools: {
+				command: process.execPath,
+				args: [
+					...process.execArgv.filter((arg) => !arg.startsWith("--inspect")),
+					process.argv[1] ?? "",
+					"mcp"
+				]
+			},
+			log: (entry) => ctx.out.write(`${JSON.stringify({
+				time: (/* @__PURE__ */ new Date()).toISOString(),
+				...entry
+			})}\n`)
+		});
+	} catch (error) {
+		ctx.err.write(`charmd could not start: ${error instanceof Error ? error.message : String(error)}\n`);
+		process.exitCode = 1;
+		return;
+	}
+	ctx.out.write(`charmd (the charm daemon) 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 = () => {
+		daemon.close().then(() => process.exit(0));
+	};
+	process.once("SIGINT", stop);
+	process.once("SIGTERM", stop);
+}
+//#endregion
+//#region src/commands/setup.ts
+const USER = "charmd";
+const STATE_DIR = "/var/lib/charmd";
+const CONFIG_DIR = "/etc/opencharm";
+const CONFIG = `${CONFIG_DIR}/charmd.json`;
+const ENV = `${CONFIG_DIR}/charmd.env`;
+const UNIT = "/etc/systemd/system/charmd.service";
+const HOST = /^(?=.{1,253}$)(?!.*\.\d+$)([a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)(\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)+$/i;
+const HIDDEN = /^\/(home|root)(\/|$)/;
+function unit(node, cli) {
+	return `# Installed by opencharm setup. charmd, the charm daemon, runs as its own user so the agent
+# running on this machine can't read its tokens, PINs or keys.
+[Unit]
+Description=charmd, the OpenCharm charm daemon
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+User=${USER}
+Group=${USER}
+EnvironmentFile=${ENV}
+ExecStart=${node} ${cli} serve --config ${CONFIG}
+Restart=on-failure
+RestartSec=2
+NoNewPrivileges=yes
+ProtectSystem=strict
+ProtectHome=yes
+PrivateTmp=yes
+PrivateDevices=yes
+ReadWritePaths=${STATE_DIR}
+CapabilityBoundingSet=
+AmbientCapabilities=
+RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6
+RestrictNamespaces=yes
+RestrictRealtime=yes
+RestrictSUIDSGID=yes
+LockPersonality=yes
+ProtectKernelTunables=yes
+ProtectKernelModules=yes
+ProtectKernelLogs=yes
+ProtectControlGroups=yes
+ProtectClock=yes
+ProtectHostname=yes
+SystemCallArchitectures=native
+UMask=0077
+
+[Install]
+WantedBy=multi-user.target
+`;
+}
+function planSetup({ domain, node, cli, exists }) {
+	if (!HOST.test(domain)) throw new Error(`"${domain}" is not a domain name (e.g. charm.example.com)`);
+	for (const path of [node, cli]) if (HIDDEN.test(path)) throw new Error(`${path} is under /home or /root, which the hardened service can't see; install Node system-wide (e.g. NodeSource) and run: sudo npm install -g opencharm`);
+	const config = {
+		listen: {
+			host: "127.0.0.1",
+			port: 8787
+		},
+		statePath: `${STATE_DIR}/state.json`,
+		publicUrl: `wss://${domain}/charm`,
+		voice: { provider: "openai" },
+		agent: { adapter: "hermes" },
+		logTranscripts: false
+	};
+	const env = `# Keys for charmd (read by systemd; readable by root and charmd only).
+OPENAI_API_KEY=
+# Hermes' API server key (API_SERVER_KEY in Hermes' own .env).
+API_SERVER_KEY=
+`;
+	const steps = [
+		{
+			kind: "user",
+			name: USER,
+			home: STATE_DIR
+		},
+		{
+			kind: "dir",
+			path: STATE_DIR,
+			mode: 448,
+			owner: USER,
+			group: USER
+		},
+		{
+			kind: "dir",
+			path: CONFIG_DIR,
+			mode: 488,
+			owner: "root",
+			group: USER
+		}
+	];
+	if (!exists(CONFIG)) steps.push({
+		kind: "file",
+		path: CONFIG,
+		mode: 416,
+		owner: "root",
+		group: USER,
+		content: `${JSON.stringify(config, null, 2)}\n`
+	});
+	if (!exists(ENV)) steps.push({
+		kind: "file",
+		path: ENV,
+		mode: 416,
+		owner: "root",
+		group: USER,
+		content: env
+	});
+	steps.push({
+		kind: "file",
+		path: UNIT,
+		mode: 420,
+		owner: "root",
+		group: "root",
+		content: unit(node, cli)
+	}, {
+		kind: "run",
+		command: ["systemctl", "daemon-reload"]
+	}, {
+		kind: "run",
+		command: [
+			"systemctl",
+			"enable",
+			"charmd"
+		]
+	});
+	return steps;
+}
+function describe(step) {
+	switch (step.kind) {
+		case "user": return `create system user ${step.name} (no login, home ${step.home})`;
+		case "dir": return `folder ${step.path} ${step.mode.toString(8)} ${step.owner}:${step.group}`;
+		case "file": return `file ${step.path} ${step.mode.toString(8)} ${step.owner}:${step.group}`;
+		case "run": return `run ${step.command.join(" ")}`;
+	}
+}
+function run(command) {
+	const [program, ...args] = command;
+	if (spawnSync(program ?? "", args, { stdio: "inherit" }).status !== 0) throw new Error(`${command.join(" ")} failed`);
+}
+function apply(step) {
+	switch (step.kind) {
+		case "user":
+			if (spawnSync("id", ["-u", step.name]).status !== 0) run([
+				"useradd",
+				"--system",
+				"--home-dir",
+				step.home,
+				"--no-create-home",
+				"--shell",
+				"/usr/sbin/nologin",
+				step.name
+			]);
+			return;
+		case "dir":
+			mkdirSync(step.path, { recursive: true });
+			chmodSync(step.path, step.mode);
+			run([
+				"chown",
+				`${step.owner}:${step.group}`,
+				step.path
+			]);
+			return;
+		case "file":
+			writeFileSync(step.path, step.content, { mode: step.mode });
+			chmodSync(step.path, step.mode);
+			run([
+				"chown",
+				`${step.owner}:${step.group}`,
+				step.path
+			]);
+			return;
+		case "run": run(step.command);
+	}
+}
+function runSetup(ctx, args) {
+	const fail = (message) => {
+		ctx.err.write(`${message}\n`);
+		process.exitCode = 1;
+	};
+	const domain = flagValue(args, "--domain");
+	if (!domain) return fail("Usage: sudo opencharm setup --domain charm.example.com [--dry-run]");
+	const dryRun = args.includes("--dry-run");
+	let steps;
+	try {
+		steps = planSetup({
+			domain,
+			node: process.execPath,
+			cli: realpathSync(fileURLToPath(import.meta.url)),
+			exists: existsSync
+		});
+	} catch (error) {
+		return fail(error instanceof Error ? error.message : String(error));
+	}
+	ctx.out.write(`opencharm setup will:\n${steps.map((s) => `  - ${describe(s)}`).join("\n")}\n\n`);
+	if (!dryRun) {
+		if (process.platform !== "linux") return fail("setup installs a systemd service; run it on the Linux machine next to your agent (try --dry-run here).");
+		if (process.getuid?.() !== 0) return fail("setup changes system folders and users; run it with sudo.");
+		try {
+			for (const step of steps) apply(step);
+		} catch (error) {
+			return fail(`setup stopped: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	ctx.out.write(`${dryRun ? "Dry run: nothing changed.\n\n" : ""}Next:
+  1. Put your keys in ${ENV}, then: sudo systemctl start charmd
+  2. Caddy (/etc/caddy/Caddyfile), then: sudo systemctl reload caddy
+
+     ${domain} {
+       reverse_proxy 127.0.0.1:8787
+     }
+
+  3. Pair a charm: sudo -u ${USER} opencharm pair <code> --config ${CONFIG}
+  4. Check: sudo -u ${USER} opencharm status --config ${CONFIG}
+`);
+}
+//#endregion
+//#region src/commands/sim.ts
+const DEFAULT_PORT = 5174;
+const TYPES = {
+	".html": "text/html; charset=utf-8",
+	".js": "text/javascript; charset=utf-8",
+	".css": "text/css; charset=utf-8",
+	".wasm": "application/wasm",
+	".json": "application/json"
+};
+function simDir() {
+	let dir = dirname(fileURLToPath(import.meta.url));
+	for (let i = 0; i < 4; i++) {
+		const candidate = join(dir, "sim");
+		if (existsSync(join(candidate, "charm_sim.wasm"))) return candidate;
+		dir = dirname(dir);
+	}
+}
+function createSimServer(dir, charmdUrl) {
+	const root = resolve(dir);
+	return createServer$1((req, res) => {
+		let path;
+		try {
+			path = decodeURIComponent(new URL(req.url ?? "/", "http://localhost").pathname);
+		} catch {
+			res.writeHead(400).end();
+			return;
+		}
+		if (path === "/config.json") {
+			res.writeHead(200, { "content-type": TYPES[".json"] }).end(JSON.stringify({ url: charmdUrl }));
+			return;
+		}
+		const file = resolve(root, normalize(`.${path === "/" ? "/index.html" : path}`));
+		if (!file.startsWith(root + sep) || !existsSync(file) || !statSync(file).isFile()) {
+			res.writeHead(404).end();
+			return;
+		}
+		res.writeHead(200, {
+			"content-type": TYPES[extname(file)] ?? "application/octet-stream",
+			"cache-control": "no-store"
+		}).end(readFileSync(file));
+	});
+}
+function charmdUrlFrom(args) {
+	const explicit = flagValue(args, "--url");
+	if (explicit) return explicit;
+	try {
+		const { listen } = loadConfig(flagValue(args, "--config"));
+		const host = listen.host === "0.0.0.0" || listen.host === "::" ? "127.0.0.1" : listen.host;
+		return `ws://${host.includes(":") ? `[${host}]` : host}:${listen.port}/charm`;
+	} catch {
+		return "ws://127.0.0.1:8787/charm";
+	}
+}
+function openBrowser(url) {
+	const [command, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", [
+		"/c",
+		"start",
+		"",
+		url
+	]] : ["xdg-open", [url]];
+	spawn(command, args, {
+		stdio: "ignore",
+		detached: true
+	}).on("error", () => void 0).unref();
+}
+async function runSim(ctx, args) {
+	const dir = simDir();
+	if (!dir) {
+		ctx.err.write("The emulator isn't built in this install. From the repo: npm run firmware:sim\n");
+		process.exitCode = 1;
+		return;
+	}
+	const url = charmdUrlFrom(args);
+	const port = Number(flagValue(args, "--port") ?? DEFAULT_PORT);
+	const server = createSimServer(dir, url);
+	try {
+		await new Promise((resolveListen, reject) => {
+			server.once("error", reject);
+			server.listen(port, "127.0.0.1", resolveListen);
+		});
+	} catch (error) {
+		ctx.err.write(`The emulator could not start: ${error instanceof Error ? error.message : String(error)}\n`);
+		process.exitCode = 1;
+		return;
+	}
+	const page = `http://127.0.0.1:${port}/`;
+	ctx.out.write(`The emulator is at ${page} (charmd: ${url}). Hold Space to talk. Stop: Ctrl-C\n`);
+	if (!args.includes("--no-open")) openBrowser(page);
+}
+//#endregion
+//#region src/commands/states.ts
+function runStates(ctx, args) {
+	const { fg, bg, bold, dim, reset } = ctx.style;
+	const colour = pickColour(args, (message) => ctx.err.write(`${message}\n`));
+	ctx.out.write(`\n  ${bold("What your agent is doing → the face")}\n\n`);
+	for (const state of facesData.states) {
+		const face = findFace(state.face);
+		const text = (face ? faceText(face) : state.face).padEnd(7);
+		const ink = state.face === "ask" ? ctx.signal : colour.g;
+		ctx.out.write(`  ${fg(ink)}${bg("#000000")} ${bold(text)} ${reset}  ${bold(state.name.padEnd(10))} ${state.when}\n  ${" ".repeat(12)}${dim(`trigger: ${state.trigger}`)}\n`);
+	}
+	ctx.out.write(`\n  ${dim("Orange means one thing only: it needs you.")}\n\n`);
+}
+//#endregion
+//#region src/main.ts
+const DEFAULT_SIGNAL = "#FF5A1F";
+function buildContext(argv) {
+	const options = detectStyleOptions(argv, process.env, process.stdout.isTTY === true);
+	return {
+		out: process.stdout,
+		err: process.stderr,
+		style: createStyle(options),
+		canAnimate: options.color && !argv.includes("--no-anim") && !process.env.CI,
+		version,
+		signal: facesData.signal || DEFAULT_SIGNAL
+	};
+}
+async function main(argv) {
+	const ctx = buildContext(argv);
+	const { command, rest, help, version } = parseArgs(argv);
+	if (version) {
+		ctx.out.write(`${ctx.version}\n`);
+		return;
+	}
+	if (help || command === "help") {
+		runHelp(ctx);
+		return;
+	}
+	switch (command) {
+		case "":
+			await runHello(ctx, argv);
+			return;
+		case "face":
+			await runFace(ctx, rest);
+			return;
+		case "faces":
+			runFaces(ctx, rest);
+			return;
+		case "states":
+			runStates(ctx, rest);
+			return;
+		case "hardware":
+			runHardware(ctx);
+			return;
+		case "init":
+			runInit(ctx, rest);
+			return;
+		case "sim":
+			await runSim(ctx, rest);
+			return;
+		case "setup":
+			runSetup(ctx, rest);
+			return;
+		case "serve":
+			await runServe(ctx, rest);
+			return;
+		case "mcp": {
+			const socket = flagValue(rest, "--socket") ?? loadConfig(flagValue(rest, "--config")).adminSocket;
+			await serveMcp(process.stdin, process.stdout, {
+				version: ctx.version,
+				send: (request) => sendAdmin(socket, request)
+			});
+			return;
+		}
+		case "pair":
+		case "lock":
+		case "unlock":
+		case "revoke":
+		case "status":
+		case "dev":
+		case "look":
+			await runAdminCommand(ctx, command, rest, {
+				socket: loadConfig(flagValue(rest, "--config")).adminSocket,
+				send: sendAdmin,
+				prompt: promptHidden
+			});
+			return;
+		default:
+			ctx.out.write(`Unknown command "${command}".\n`);
+			runHelp(ctx);
+			process.exitCode = 1;
+	}
+}
+process.stdout.on("error", (error) => {
+	if (error.code === "EPIPE") process.exit(0);
+	throw error;
+});
+await main(process.argv.slice(2));
+//#endregion
+export {};