@tensorkit/raydr 0.0.0-stage → 0.1.0

package/dist/main.js

@@ -0,0 +1,2745 @@
+import {
+  DEFAULT_PORT,
+  SPEECH_PROVIDERS,
+  TRANSCRIPTION_PROVIDERS,
+  defaultEnvFile,
+  disableSession,
+  enableSession,
+  isEnabled,
+  loadConfig,
+  migrateEnvFile,
+  newAccessKey,
+  parseEnvFile,
+  validSessionId
+} from "./chunk-KYTKA3YV.js";
+import {
+  VERSION
+} from "./chunk-NRB77EMM.js";
+
+// src/main.ts
+import { spawn as spawn3, spawnSync as spawnSync2 } from "node:child_process";
+import {
+  copyFileSync,
+  existsSync as existsSync10,
+  mkdirSync as mkdirSync7,
+  readFileSync as readFileSync8,
+  renameSync as renameSync3,
+  writeFileSync as writeFileSync6
+} from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { dirname as dirname6, join as join10, resolve as resolve3 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// ../../apps/server/dist/providers.js
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// ../../apps/server/dist/speech-elevenlabs.js
+import { Readable } from "node:stream";
+var ElevenLabsSpeech = class {
+  name = "elevenlabs";
+  opts;
+  constructor(opts) {
+    this.opts = { modelId: "eleven_flash_v2_5", ...opts };
+  }
+  async synthesize(text) {
+    const url = `https://api.elevenlabs.io/v1/text-to-speech/${encodeURIComponent(this.opts.voiceId)}/stream?output_format=mp3_44100_128`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "xi-api-key": this.opts.apiKey, "content-type": "application/json" },
+      body: JSON.stringify({ text, model_id: this.opts.modelId }),
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!res.ok || !res.body) {
+      const detail = await res.text().catch(() => "");
+      throw new Error(`ElevenLabs ${res.status}: ${detail.slice(0, 200)}`);
+    }
+    return Readable.fromWeb(res.body);
+  }
+};
+
+// ../../apps/server/dist/speech-local.js
+import { Readable as Readable2 } from "node:stream";
+var KokoroSpeech = class {
+  name = "kokoro";
+  baseUrl;
+  voice;
+  key;
+  constructor(port, voice, key, host = "127.0.0.1") {
+    this.baseUrl = `http://${host}:${port}`;
+    this.voice = voice;
+    this.key = key;
+  }
+  async synthesize(text) {
+    let res;
+    try {
+      res = await fetch(`${this.baseUrl}/tts`, {
+        method: "POST",
+        headers: { "content-type": "application/json", "x-raydr-key": this.key },
+        body: JSON.stringify({ text, voice: this.voice }),
+        signal: AbortSignal.timeout(12e4)
+      });
+    } catch (err) {
+      throw new Error(`local sidecar unreachable at ${this.baseUrl}: ${err.message}`);
+    }
+    if (!res.ok || !res.body) {
+      const detail = await res.text().catch(() => "");
+      throw new Error(`Kokoro ${res.status}: ${detail.slice(0, 200)}`);
+    }
+    return Readable2.fromWeb(res.body);
+  }
+};
+
+// ../../apps/server/dist/speech-openai.js
+import { Readable as Readable3 } from "node:stream";
+var OpenAISpeech = class {
+  name = "openai";
+  opts;
+  constructor(opts) {
+    this.opts = { model: "gpt-4o-mini-tts", baseUrl: "https://api.openai.com", ...opts };
+  }
+  async synthesize(text) {
+    const res = await fetch(`${this.opts.baseUrl}/v1/audio/speech`, {
+      method: "POST",
+      headers: { authorization: `Bearer ${this.opts.apiKey}`, "content-type": "application/json" },
+      body: JSON.stringify({
+        model: this.opts.model,
+        voice: this.opts.voice,
+        input: text,
+        // Only the instructable models accept a delivery instruction.
+        ...this.opts.model.includes("mini-tts") ? { instructions: this.opts.instructions } : {},
+        response_format: "mp3"
+      }),
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!res.ok || !res.body) {
+      const detail = await res.text().catch(() => "");
+      throw new Error(`OpenAI ${res.status}: ${detail.slice(0, 200)}`);
+    }
+    return Readable3.fromWeb(res.body);
+  }
+};
+
+// ../../apps/server/dist/transcription.js
+var TranscriptionError = class extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+};
+
+// ../../apps/server/dist/transcription-elevenlabs.js
+var ElevenLabsTranscription = class {
+  name = "elevenlabs";
+  apiKey;
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  async transcribe(audio, filename) {
+    const form = new FormData();
+    form.set("model_id", "scribe_v2");
+    form.set("file", audio, filename);
+    const res = await fetch("https://api.elevenlabs.io/v1/speech-to-text", {
+      method: "POST",
+      headers: { "xi-api-key": this.apiKey },
+      body: form,
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!res.ok) {
+      const detail = await res.text().catch(() => "");
+      throw new TranscriptionError(res.status, `ElevenLabs STT ${res.status}: ${detail.slice(0, 200)}`);
+    }
+    const body = await res.json();
+    return typeof body.text === "string" ? body.text : "";
+  }
+};
+
+// ../../apps/server/dist/transcription-local.js
+var WhisperTranscription = class {
+  name = "whisper";
+  baseUrl;
+  key;
+  constructor(port, key, host = "127.0.0.1") {
+    this.baseUrl = `http://${host}:${port}`;
+    this.key = key;
+  }
+  async transcribe(audio, filename) {
+    const form = new FormData();
+    form.set("file", audio, filename);
+    let res;
+    try {
+      res = await fetch(`${this.baseUrl}/stt`, {
+        method: "POST",
+        headers: { "x-raydr-key": this.key },
+        body: form,
+        signal: AbortSignal.timeout(12e4)
+      });
+    } catch (err) {
+      throw new TranscriptionError(503, `local sidecar unreachable: ${err.message}`);
+    }
+    if (!res.ok) {
+      const detail = await res.text().catch(() => "");
+      throw new TranscriptionError(res.status, `whisper ${res.status}: ${detail.slice(0, 200)}`);
+    }
+    const body = await res.json();
+    return typeof body.text === "string" ? body.text : "";
+  }
+};
+
+// ../../apps/server/dist/transcription-openai.js
+var OpenAITranscription = class {
+  name = "openai";
+  opts;
+  constructor(opts) {
+    this.opts = { model: "gpt-4o-mini-transcribe", baseUrl: "https://api.openai.com", ...opts };
+  }
+  async transcribe(audio, filename) {
+    const form = new FormData();
+    form.set("model", this.opts.model);
+    form.set("response_format", "json");
+    form.set("file", audio, filename);
+    const res = await fetch(`${this.opts.baseUrl}/v1/audio/transcriptions`, {
+      method: "POST",
+      headers: { authorization: `Bearer ${this.opts.apiKey}` },
+      body: form,
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!res.ok) {
+      const detail = await res.text().catch(() => "");
+      throw new TranscriptionError(res.status, `OpenAI STT ${res.status}: ${detail.slice(0, 200)}`);
+    }
+    const body = await res.json();
+    return typeof body.text === "string" ? body.text : "";
+  }
+};
+
+// ../../apps/server/dist/providers.js
+function localPython(cfg) {
+  return join(cfg.localDir, "venv", "bin", "python");
+}
+function localSetupMarker(cfg) {
+  return join(cfg.localDir, "setup.json");
+}
+function localReady(cfg) {
+  if (!existsSync(localPython(cfg)))
+    return false;
+  try {
+    const rec = JSON.parse(readFileSync(localSetupMarker(cfg), "utf8"));
+    return rec.whisperModel === cfg.whisperModel && rec.kokoroVoice === cfg.kokoroVoice;
+  } catch {
+    return false;
+  }
+}
+function speechReadiness(cfg) {
+  const provider = cfg.speechProvider;
+  switch (provider) {
+    case "elevenlabs":
+      return cfg.elevenLabsApiKey ? { provider, ready: true } : { provider, ready: false, missing: "ELEVENLABS_API_KEY", fix: "raydr init" };
+    case "openai":
+      return cfg.openAiApiKey ? { provider, ready: true } : { provider, ready: false, missing: "OPENAI_API_KEY", fix: "raydr init" };
+    case "kokoro":
+      return localReady(cfg) ? { provider, ready: true } : { provider, ready: false, missing: "local models", fix: "raydr local setup" };
+  }
+}
+function transcriptionReadiness(cfg) {
+  const provider = cfg.transcriptionProvider;
+  switch (provider) {
+    case "elevenlabs":
+      return cfg.elevenLabsApiKey ? { provider, ready: true } : { provider, ready: false, missing: "ELEVENLABS_API_KEY", fix: "raydr init" };
+    case "openai":
+      return cfg.openAiApiKey ? { provider, ready: true } : { provider, ready: false, missing: "OPENAI_API_KEY", fix: "raydr init" };
+    case "whisper":
+      return localReady(cfg) ? { provider, ready: true } : { provider, ready: false, missing: "local models", fix: "raydr local setup" };
+  }
+}
+function usesLocal(cfg) {
+  return cfg.speechProvider === "kokoro" || cfg.transcriptionProvider === "whisper";
+}
+function selectSpeechProvider(cfg) {
+  if (!speechReadiness(cfg).ready)
+    return null;
+  switch (cfg.speechProvider) {
+    case "elevenlabs":
+      return new ElevenLabsSpeech({
+        apiKey: cfg.elevenLabsApiKey ?? "",
+        voiceId: cfg.elevenLabsVoiceId
+      });
+    case "openai":
+      return new OpenAISpeech({
+        apiKey: cfg.openAiApiKey ?? "",
+        voice: cfg.openAiVoice,
+        instructions: cfg.speechInstructions
+      });
+    case "kokoro":
+      return new KokoroSpeech(cfg.localPort, cfg.kokoroVoice, cfg.accessKey);
+  }
+}
+function selectTranscriptionProvider(cfg) {
+  if (!transcriptionReadiness(cfg).ready)
+    return null;
+  switch (cfg.transcriptionProvider) {
+    case "elevenlabs":
+      return new ElevenLabsTranscription(cfg.elevenLabsApiKey ?? "");
+    case "openai":
+      return new OpenAITranscription({ apiKey: cfg.openAiApiKey ?? "" });
+    case "whisper":
+      return new WhisperTranscription(cfg.localPort, cfg.accessKey);
+  }
+}
+
+// ../../apps/server/dist/server.js
+import { randomUUID, timingSafeEqual } from "node:crypto";
+import { existsSync as existsSync4 } from "node:fs";
+import { createServer } from "node:http";
+import { dirname as dirname2, join as join5, resolve } from "node:path";
+import { PassThrough as PassThrough2 } from "node:stream";
+import { fileURLToPath } from "node:url";
+
+// ../../apps/server/dist/audio-store.js
+import { EventEmitter, once } from "node:events";
+import { createReadStream, createWriteStream, existsSync as existsSync2, mkdirSync, statSync } from "node:fs";
+import { readdir, rename, stat, unlink } from "node:fs/promises";
+import { join as join2 } from "node:path";
+import { PassThrough } from "node:stream";
+var AudioStore = class {
+  jobs = /* @__PURE__ */ new Map();
+  dir;
+  constructor(dir) {
+    this.dir = dir;
+    mkdirSync(dir, { recursive: true });
+  }
+  pathFor(id) {
+    return join2(this.dir, `${id}.mp3`);
+  }
+  /** True when a complete clip is on disk. */
+  has(id) {
+    return existsSync2(this.pathFor(id));
+  }
+  partPathFor(id) {
+    return `${this.pathFor(id)}.part`;
+  }
+  /** Persist a stream under `id`. Resolves when the file is fully written. */
+  async write(id, source) {
+    const job = { chunks: [], done: false, failed: false, events: new EventEmitter() };
+    job.events.setMaxListeners(0);
+    this.jobs.set(id, job);
+    const part = this.partPathFor(id);
+    const file = createWriteStream(part);
+    const opened = once(file, "open");
+    opened.catch(() => {
+    });
+    let fileError = null;
+    file.on("error", (err) => {
+      fileError = err;
+    });
+    let ready = false;
+    try {
+      for await (const chunk of source) {
+        if (!ready) {
+          await opened;
+          ready = true;
+        }
+        if (fileError)
+          throw fileError;
+        const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        job.chunks.push(buf);
+        file.write(buf);
+        job.events.emit("chunk", buf);
+      }
+      if (!ready)
+        await opened;
+      if (fileError)
+        throw fileError;
+      await new Promise((resolve4, reject) => file.end((err) => err ? reject(err) : resolve4()));
+      await rename(part, this.pathFor(id));
+    } catch (err) {
+      job.failed = true;
+      if (!file.closed) {
+        file.destroy();
+        await once(file, "close");
+      }
+      await unlink(part).catch(() => {
+      });
+      throw err;
+    } finally {
+      job.done = true;
+      job.events.emit("done");
+      this.jobs.delete(id);
+    }
+  }
+  /**
+   * Open a readable for `id`. Returns the total size when the clip is complete on disk,
+   * null while it is still streaming, or undefined when unknown. Partial files are never served.
+   */
+  open(id) {
+    const job = this.jobs.get(id);
+    if (job && !job.done) {
+      const out = new PassThrough();
+      for (const c of job.chunks)
+        out.write(c);
+      const onChunk = (c) => out.write(c);
+      const onDone = () => {
+        job.events.off("chunk", onChunk);
+        if (job.failed)
+          out.destroy(new Error("speech synthesis failed"));
+        else
+          out.end();
+      };
+      job.events.on("chunk", onChunk);
+      job.events.once("done", onDone);
+      out.once("close", () => {
+        job.events.off("chunk", onChunk);
+        job.events.off("done", onDone);
+      });
+      return { stream: out, size: null };
+    }
+    const path = this.pathFor(id);
+    if (!existsSync2(path))
+      return void 0;
+    return { stream: createReadStream(path), size: statSync(path).size };
+  }
+  /** Delete clips (complete or partial) older than `maxAgeMs`. Other files are left alone. */
+  async prune(maxAgeMs) {
+    const cutoff = Date.now() - maxAgeMs;
+    let removed = 0;
+    for (const name of await readdir(this.dir)) {
+      if (!name.endsWith(".mp3") && !name.endsWith(".mp3.part"))
+        continue;
+      const path = join2(this.dir, name);
+      const info = await stat(path).catch(() => null);
+      if (info?.isFile() && info.mtimeMs < cutoff) {
+        await unlink(path).catch(() => {
+        });
+        removed++;
+      }
+    }
+    return removed;
+  }
+};
+
+// ../../apps/server/dist/herdr.js
+import { execFile } from "node:child_process";
+var CommandError = class extends Error {
+  code;
+  constructor(code, message = code) {
+    super(message);
+    this.code = code;
+  }
+};
+function herdr(args) {
+  return new Promise((resolve4, reject) => {
+    execFile("herdr", args, { timeout: 15e3 }, (err, stdout, stderr) => {
+      if (err)
+        reject(new Error(`herdr ${args.slice(0, 2).join(" ")} failed: ${stderr || err.message}`));
+      else
+        resolve4(stdout);
+    });
+  });
+}
+var herdrCli = {
+  async status(pane) {
+    const out = JSON.parse(await herdr(["agent", "get", pane]));
+    return out.result?.agent?.agent_status ?? "unknown";
+  },
+  async sendKeys(pane, keys) {
+    await herdr(["agent", "send-keys", pane, ...keys]);
+  },
+  async prompt(pane, text) {
+    await herdr(["agent", "prompt", pane, text]);
+  }
+};
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function keysForQuestion(question, rawSelection) {
+  const count = question.options.length;
+  const selection = [...new Set(rawSelection)];
+  if (selection.length === 0)
+    throw new CommandError("other_not_supported", "free-text answers are not supported yet");
+  if (selection.length > count)
+    throw new CommandError("bad_selection", `at most ${count} option(s) can be chosen`);
+  for (const idx of selection) {
+    if (!Number.isInteger(idx) || idx < 1 || idx > count) {
+      throw new CommandError("bad_selection", `option ${idx} is out of range 1..${count}`);
+    }
+  }
+  if (!question.multiSelect) {
+    if (selection.length !== 1)
+      throw new CommandError("bad_selection", "single-select question takes one option");
+    return [String(selection[0])];
+  }
+  const keys = [];
+  let cursor = 1;
+  for (const idx of [...selection].sort((a, b) => a - b)) {
+    for (; cursor < idx; cursor++)
+      keys.push("down");
+    keys.push("space");
+  }
+  keys.push("right");
+  return keys;
+}
+async function answerQuestion(term, pane, questions, selections) {
+  if (selections.length !== questions.length) {
+    throw new CommandError("bad_selection", `expected ${questions.length} selection(s), got ${selections.length}`);
+  }
+  const plan = questions.map((q, i) => keysForQuestion(q, selections[i] ?? []));
+  for (let i = 0; i < plan.length; i++) {
+    if (i > 0)
+      await sleep(300);
+    await term.sendKeys(pane, plan[i] ?? []);
+  }
+  if (questions.some((q) => q.multiSelect)) {
+    await sleep(300);
+    await term.sendKeys(pane, ["enter"]);
+  }
+}
+async function replyPermission(term, pane, decision) {
+  await term.sendKeys(pane, [decision === "allow" ? "1" : "esc"]);
+}
+async function say(term, pane, text) {
+  const status = await term.status(pane);
+  if (status === "blocked")
+    throw new CommandError("agent_blocked", "a dialog is open; answer it first");
+  await term.prompt(pane, text);
+}
+
+// ../../apps/server/dist/commands.js
+var isObject = (v) => typeof v === "object" && v !== null;
+var str = (v) => typeof v === "string" ? v : "";
+function parseCommand(body) {
+  if (!isObject(body))
+    return null;
+  const commandId = str(body.commandId);
+  const sessionId = str(body.sessionId);
+  if (!commandId || !sessionId)
+    return null;
+  switch (body.type) {
+    case "answer_question": {
+      const toolUseId = str(body.toolUseId);
+      const selections = body.selections;
+      if (!toolUseId || !Array.isArray(selections) || !selections.every((s) => Array.isArray(s) && s.every((n) => typeof n === "number"))) {
+        return null;
+      }
+      return {
+        type: "answer_question",
+        commandId,
+        sessionId,
+        toolUseId,
+        selections
+      };
+    }
+    case "permission_reply":
+      if (body.decision !== "allow" && body.decision !== "deny")
+        return null;
+      return { type: "permission_reply", commandId, sessionId, decision: body.decision };
+    case "say": {
+      const text = str(body.text).trim();
+      if (!text)
+        return null;
+      return { type: "say", commandId, sessionId, text };
+    }
+    default:
+      return null;
+  }
+}
+var PERMISSION_TTL_MS = 5 * 60 * 1e3;
+var CommandRunner = class {
+  pending = /* @__PURE__ */ new Map();
+  /** Session id -> when the prompt was reported; entries older than PERMISSION_TTL_MS are ignored. */
+  pendingPermission = /* @__PURE__ */ new Map();
+  now;
+  term;
+  sessions;
+  constructor(term, sessions, now = Date.now) {
+    this.term = term;
+    this.sessions = sessions;
+    this.now = now;
+  }
+  /** Remember the menu currently open in a session so answers can be validated against it. */
+  setPending(sessionId, question) {
+    this.pending.set(sessionId, question);
+  }
+  /** A permission dialog is open in the session (Claude Code told us via Notification). */
+  setPendingPermission(sessionId) {
+    this.pendingPermission.set(sessionId, this.now());
+  }
+  /** The turn moved on: no menu or dialog is answerable any more. */
+  clearPending(sessionId) {
+    this.pending.delete(sessionId);
+    this.pendingPermission.delete(sessionId);
+  }
+  /** Throws CommandError with a short code on any failure. */
+  async run(cmd) {
+    const session2 = this.sessions.get(cmd.sessionId);
+    if (!session2)
+      throw new CommandError("unknown_session");
+    if (!session2.paneId)
+      throw new CommandError("no_pane", "session is not running in a Herdr pane");
+    const pane = session2.paneId;
+    switch (cmd.type) {
+      case "answer_question": {
+        const open2 = this.pending.get(cmd.sessionId);
+        if (!open2 || open2.toolUseId !== cmd.toolUseId)
+          throw new CommandError("unknown_question", "that question is no longer open");
+        await answerQuestion(this.term, pane, open2.questions, cmd.selections);
+        this.pending.delete(cmd.sessionId);
+        return;
+      }
+      case "permission_reply": {
+        const since = this.pendingPermission.get(cmd.sessionId);
+        if (since === void 0 || this.now() - since > PERMISSION_TTL_MS) {
+          this.pendingPermission.delete(cmd.sessionId);
+          throw new CommandError("no_pending_permission", "no permission prompt is open");
+        }
+        if (await this.term.status(pane) !== "blocked") {
+          throw new CommandError("agent_not_blocked", "the session is not waiting on a dialog");
+        }
+        await replyPermission(this.term, pane, cmd.decision);
+        this.pendingPermission.delete(cmd.sessionId);
+        return;
+      }
+      case "say":
+        await say(this.term, pane, cmd.text);
+        return;
+    }
+  }
+};
+
+// ../../apps/server/dist/event-bus.js
+var EventBus = class {
+  nextId = Date.now() * 1e3;
+  history = [];
+  clients = /* @__PURE__ */ new Set();
+  historySize;
+  constructor(historySize = 200) {
+    this.historySize = historySize;
+  }
+  publish(event) {
+    const envelope = { ...event, id: this.nextId++, ts: (/* @__PURE__ */ new Date()).toISOString() };
+    this.history.push(envelope);
+    if (this.history.length > this.historySize)
+      this.history.shift();
+    const frame = format(envelope);
+    for (const res of this.clients)
+      res.write(frame);
+    return envelope;
+  }
+  subscribe(res, lastEventId) {
+    res.writeHead(200, {
+      "content-type": "text/event-stream",
+      "cache-control": "no-cache",
+      connection: "keep-alive",
+      "x-accel-buffering": "no"
+    });
+    res.write(": connected\n\n");
+    for (const e of this.history)
+      if (e.id > lastEventId)
+        res.write(format(e));
+    res.write("event: live\ndata: {}\n\n");
+    this.clients.add(res);
+    const keepalive = setInterval(() => res.write(": ping\n\n"), 25e3);
+    res.on("close", () => {
+      clearInterval(keepalive);
+      this.clients.delete(res);
+    });
+  }
+  get clientCount() {
+    return this.clients.size;
+  }
+};
+function format(e) {
+  return `id: ${e.id}
+data: ${JSON.stringify(e)}
+
+`;
+}
+
+// ../../apps/server/dist/hooks.js
+var isObject2 = (v) => typeof v === "object" && v !== null;
+var str2 = (v) => typeof v === "string" ? v : "";
+function parseHookPayload(body) {
+  if (!isObject2(body))
+    return null;
+  const sessionId = str2(body.session_id);
+  const cwd = str2(body.cwd);
+  if (!sessionId || !cwd)
+    return null;
+  const common = {
+    sessionId,
+    cwd,
+    transcriptPath: str2(body.transcript_path) || null
+  };
+  switch (body.hook_event_name) {
+    case "Stop":
+      return { ...common, kind: "stop", text: str2(body.last_assistant_message).trim() };
+    case "PreToolUse": {
+      if (body.tool_name !== "AskUserQuestion") {
+        return { ...common, kind: "ignore", reason: `tool ${str2(body.tool_name)}` };
+      }
+      const input = isObject2(body.tool_input) ? body.tool_input : {};
+      const questions = Array.isArray(input.questions) ? input.questions.filter(isObject2).map(parseQuestion) : [];
+      if (questions.length === 0)
+        return { ...common, kind: "ignore", reason: "no questions" };
+      return { ...common, kind: "question", toolUseId: str2(body.tool_use_id), questions };
+    }
+    case "Notification": {
+      if (body.notification_type !== "permission_prompt") {
+        return { ...common, kind: "ignore", reason: `notification ${str2(body.notification_type)}` };
+      }
+      return {
+        ...common,
+        kind: "permission",
+        message: str2(body.message) || "Claude needs your permission"
+      };
+    }
+    default:
+      return { ...common, kind: "ignore", reason: `event ${str2(body.hook_event_name)}` };
+  }
+}
+function parseQuestion(q) {
+  const options = Array.isArray(q.options) ? q.options.filter(isObject2).map((o) => ({ label: str2(o.label), description: str2(o.description) })) : [];
+  return {
+    question: str2(q.question),
+    header: str2(q.header),
+    multiSelect: q.multiSelect === true,
+    options
+  };
+}
+var ORDINALS = ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"];
+function questionSpeech(questions) {
+  return questions.map((q) => {
+    const opts = q.options.map((o, i) => `${ORDINALS[i] ?? String(i + 1)}, ${o.label}.`).join(" ");
+    return `Question: ${q.question} Options: ${opts}`;
+  }).join(" ");
+}
+function truncateSpeech(text, max) {
+  if (text.length <= max)
+    return text;
+  const head = text.slice(0, max);
+  const windowStart = Math.max(0, max - 200);
+  const window = head.slice(windowStart);
+  const end = Math.max(window.lastIndexOf("."), window.lastIndexOf("!"), window.lastIndexOf("?"));
+  return end >= 0 ? head.slice(0, windowStart + end + 1) : head;
+}
+
+// ../../apps/server/dist/label-clips.js
+var RETRY_AFTER_MS = 6e4;
+var LabelClips = class _LabelClips {
+  store;
+  synthesize;
+  inflight = /* @__PURE__ */ new Map();
+  /** id -> time of the last failed synthesis; not retried within RETRY_AFTER_MS. */
+  failedAt = /* @__PURE__ */ new Map();
+  now;
+  constructor(store, synthesize, now = Date.now) {
+    this.store = store;
+    this.synthesize = synthesize;
+    this.now = now;
+  }
+  static idFor(label) {
+    const slug = label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+    return `label-${slug || "session"}`;
+  }
+  /** Resolves to the clip URL, synthesising it on first use; null when synthesis failed. */
+  urlFor(label) {
+    const id = _LabelClips.idFor(label);
+    const url = `/audio/${id}.mp3`;
+    if (this.store.has(id))
+      return Promise.resolve(url);
+    const pending = this.inflight.get(id);
+    if (pending)
+      return pending;
+    const failed = this.failedAt.get(id);
+    if (failed !== void 0 && this.now() - failed < RETRY_AFTER_MS)
+      return Promise.resolve(null);
+    const job = (async () => {
+      try {
+        await this.store.write(id, await this.synthesize(spokenLabel(label)));
+        this.failedAt.delete(id);
+        return url;
+      } catch {
+        this.failedAt.set(id, this.now());
+        return null;
+      } finally {
+        this.inflight.delete(id);
+      }
+    })();
+    this.inflight.set(id, job);
+    return job;
+  }
+};
+function spokenLabel(label) {
+  return label.replace(/[-_.]+/g, " ").trim();
+}
+
+// ../../apps/server/dist/sessions.js
+import { basename } from "node:path";
+var SessionRegistry = class {
+  sessions = /* @__PURE__ */ new Map();
+  labelUrls = /* @__PURE__ */ new Map();
+  settings;
+  constructor(settings = { get: () => void 0 }) {
+    this.settings = settings;
+  }
+  /** Record a sighting. Returns the info and whether anything user-visible changed. */
+  touch(sessionId, cwd, paneId) {
+    const prev = this.sessions.get(sessionId);
+    const pane = validPane(paneId) ?? prev?.paneId;
+    const label = basename(cwd) || cwd;
+    const labelAudioUrl = this.labelUrls.get(label);
+    const info = {
+      sessionId,
+      cwd,
+      label,
+      ...pane ? { paneId: pane } : {},
+      lastSeen: (/* @__PURE__ */ new Date()).toISOString(),
+      ...labelAudioUrl ? { labelAudioUrl } : {},
+      speakMode: this.speakMode(cwd)
+    };
+    this.sessions.set(sessionId, info);
+    const changed = !prev || prev.cwd !== cwd || prev.paneId !== info.paneId || prev.labelAudioUrl !== info.labelAudioUrl || prev.speakMode !== info.speakMode;
+    return { info, changed };
+  }
+  /** Remember where a label's spoken clip lives; sessions with that label pick it up. */
+  setLabelAudio(label, url) {
+    this.labelUrls.set(label, url);
+    const updated = [];
+    for (const [id, info] of this.sessions) {
+      if (info.label === label && info.labelAudioUrl !== url) {
+        const next = { ...info, labelAudioUrl: url };
+        this.sessions.set(id, next);
+        updated.push(next);
+      }
+    }
+    return updated;
+  }
+  /** Re-read settings for every session in `cwd`; returns the ones that changed. */
+  refreshSettings(cwd) {
+    const updated = [];
+    for (const [id, info] of this.sessions) {
+      if (info.cwd !== cwd)
+        continue;
+      const speakMode = this.speakMode(cwd);
+      if (info.speakMode === speakMode)
+        continue;
+      const next = { ...info, speakMode };
+      this.sessions.set(id, next);
+      updated.push(next);
+    }
+    return updated;
+  }
+  speakMode(cwd) {
+    return this.settings.get(cwd)?.speakMode ?? "full";
+  }
+  /** Forget a session that opted out; returns whether it was known. */
+  remove(sessionId) {
+    return this.sessions.delete(sessionId);
+  }
+  get(sessionId) {
+    return this.sessions.get(sessionId);
+  }
+  list() {
+    return [...this.sessions.values()].sort((a, b) => b.lastSeen.localeCompare(a.lastSeen));
+  }
+};
+function validPane(paneId) {
+  return paneId && /^[\w:.][\w:.-]*$/.test(paneId) ? paneId : null;
+}
+
+// ../../apps/server/dist/settings-store.js
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+var MODES = ["full", "summary"];
+function isSpeakMode(v) {
+  return typeof v === "string" && MODES.includes(v);
+}
+var SettingsStore = class {
+  file;
+  byCwd = /* @__PURE__ */ new Map();
+  constructor(file) {
+    this.file = file;
+    try {
+      const parsed = JSON.parse(readFileSync2(file, "utf8"));
+      if (typeof parsed === "object" && parsed !== null) {
+        for (const [cwd, value] of Object.entries(parsed)) {
+          const mode = value?.speakMode;
+          if (isSpeakMode(mode))
+            this.byCwd.set(cwd, { speakMode: mode });
+        }
+      }
+    } catch {
+    }
+  }
+  get(cwd) {
+    return this.byCwd.get(cwd);
+  }
+  set(cwd, settings) {
+    this.byCwd.set(cwd, settings);
+    mkdirSync2(dirname(this.file), { recursive: true });
+    const tmp = `${this.file}.tmp-${process.pid}`;
+    writeFileSync(tmp, `${JSON.stringify(Object.fromEntries(this.byCwd), null, 2)}
+`);
+    renameSync(tmp, this.file);
+  }
+};
+
+// ../../apps/server/dist/speech-render.js
+var UUID = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi;
+var HEX_HASH = /\b(?=[0-9a-f]*[0-9])(?=[0-9a-f]*[a-f])[0-9a-f]{7,64}\b/gi;
+var URL2 = /\bhttps?:\/\/([^\s/)\]>"']+)[^\s)\]>"']*/gi;
+var PATH = /(?<![\w@])(?:~\/|\.{1,2}\/|\/)?(?:[\w.@-]+\/)+[\w.@-]+(?:\.\w{1,10})?(?![\w/])|(?<![\w@/])(?:~\/|\.{1,2}\/)[\w.@-]+/g;
+var INLINE_CODE = /`([^`\n]+)`/g;
+var FENCE = /^(`{3,}|~{3,})[^\n]*\n([\s\S]*?)^\1[ \t]*$/gm;
+function renderSpeech(text, options = {}) {
+  let out = text.replace(/\r\n?/g, "\n");
+  out = out.replace(FENCE, (_m, _fence, body) => {
+    const lines2 = body.split("\n").filter((l) => l.trim() !== "").length;
+    return `
+code block, ${lines2} ${lines2 === 1 ? "line" : "lines"}.
+`;
+  });
+  out = renderTables(out);
+  out = out.replace(INLINE_CODE, (_m, code) => code.length <= 30 ? code : "code");
+  out = out.replace(/^[ \t]{0,3}#{1,6}[ \t]+(.+?)[ \t]*#*[ \t]*$/gm, `${HEADING}$1.`);
+  out = out.replace(/\[([^\]]+)\]\([^)]*\)/g, "$1");
+  out = out.replace(/!\[([^\]]*)\]\([^)]*\)/g, "$1");
+  out = out.replace(/^\s*(?:[-*+]|\d+[.)])\s+/gm, "");
+  out = out.replace(/^\s*>\s?/gm, "");
+  out = out.replace(/^\s*([-*_])\s*(?:\1\s*){2,}$/gm, "");
+  out = out.replace(/(\*\*|__)(.+?)\1/g, "$2");
+  out = out.replace(/(?<![\w*])[*_](?![\s*_])(.+?)(?<![\s*_])[*_](?![\w*])/g, "$1");
+  out = out.replace(/~~(.+?)~~/g, "$1");
+  out = out.replace(URL2, (_m, host) => host);
+  out = out.replace(UUID, "an id");
+  out = out.replace(HEX_HASH, "an id");
+  out = out.replace(PATH, (m) => spokenPath(m));
+  out = out.replace(/(?<=[A-Za-z_])\d{3,}(?=[A-Za-z_]|\b)/g, "");
+  out = out.replace(/\b\d{5,}(?![a-z]{1,2}\b)(?=[A-Za-z_])/g, "");
+  let lines = out.split("\n").map((l) => l.replace(/\s+/g, " ").trim());
+  if (options.summary)
+    lines = firstParagraph(lines);
+  return lines.map((l) => l.replaceAll(HEADING, "")).filter((l) => l.length > 0).map((l) => /[.!?:;,]$/.test(l) ? l : `${l}.`).join(" ").replace(/\s+/g, " ").trim();
+}
+var HEADING = "
";
+function firstParagraph(lines) {
+  const blocks = [];
+  let current = [];
+  for (const line of lines) {
+    if (line.length === 0) {
+      if (current.length)
+        blocks.push(current);
+      current = [];
+    } else
+      current.push(line);
+  }
+  if (current.length)
+    blocks.push(current);
+  const out = [];
+  for (const block of blocks) {
+    out.push(...block);
+    const titleOnly = block.length === 1 && (block[0]?.startsWith(HEADING) || !/\s/.test(block[0] ?? ""));
+    if (!titleOnly)
+      break;
+  }
+  return out;
+}
+function spokenPath(path) {
+  const last = path.split("/").filter(Boolean).pop() ?? path;
+  return last.replace(/\./g, " dot ").replace(/\s+/g, " ").trim();
+}
+function renderTables(text) {
+  const lines = text.split("\n");
+  const out = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const next = lines[i + 1] ?? "";
+    if (/^\s*\|.*\|\s*$/.test(line) && /^\s*\|?\s*:?-{3,}/.test(next)) {
+      let j = i + 2;
+      while (j < lines.length && /^\s*\|.*\|\s*$/.test(lines[j] ?? ""))
+        j++;
+      const rows = j - (i + 2);
+      out.push(`table with ${rows} ${rows === 1 ? "row" : "rows"}.`);
+      i = j - 1;
+      continue;
+    }
+    out.push(line);
+  }
+  return out.join("\n");
+}
+
+// ../../apps/server/dist/static.js
+import { createReadStream as createReadStream2, existsSync as existsSync3, statSync as statSync2 } from "node:fs";
+import { extname, join as join3, normalize } from "node:path";
+var TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".json": "application/json",
+  ".webmanifest": "application/manifest+json",
+  ".woff2": "font/woff2"
+};
+function serveStatic(dir, req, res, pathname) {
+  const safe = normalize(decodeURIComponent(pathname)).replace(/^(\.\.[/\\])+/, "");
+  let file = join3(dir, safe);
+  if (!file.startsWith(dir) || !existsSync3(file) || statSync2(file).isDirectory()) {
+    file = join3(dir, "index.html");
+  }
+  if (!existsSync3(file)) {
+    res.writeHead(404).end("web app not built; run pnpm build");
+    return;
+  }
+  const isAsset = safe.startsWith("/assets/");
+  res.writeHead(200, {
+    "content-type": TYPES[extname(file)] ?? "application/octet-stream",
+    "content-length": statSync2(file).size,
+    "cache-control": isAsset ? "public, max-age=31536000, immutable" : "no-cache"
+  });
+  if (req.method === "HEAD")
+    res.end();
+  else
+    createReadStream2(file).pipe(res);
+}
+
+// ../../apps/server/dist/transcript.js
+import { realpathSync } from "node:fs";
+import { open, realpath } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join as join4, sep } from "node:path";
+var TAIL_BYTES = 256 * 1024;
+function transcriptRoot() {
+  const dir = join4(homedir(), ".claude", "projects");
+  try {
+    return realpathSync(dir) + sep;
+  } catch {
+    return dir + sep;
+  }
+}
+async function lastAssistantText(transcriptPath, root = transcriptRoot()) {
+  let path;
+  try {
+    path = await realpath(transcriptPath);
+  } catch {
+    return null;
+  }
+  if (!path.startsWith(root) || !path.endsWith(".jsonl"))
+    return null;
+  let raw;
+  try {
+    const fh = await open(path, "r");
+    try {
+      const { size } = await fh.stat();
+      const length = Math.min(size, TAIL_BYTES);
+      const buf = Buffer.alloc(length);
+      await fh.read(buf, 0, length, size - length);
+      raw = buf.toString("utf8");
+      if (length < size)
+        raw = raw.slice(raw.indexOf("\n") + 1);
+    } finally {
+      await fh.close();
+    }
+  } catch {
+    return null;
+  }
+  const lines = raw.split("\n");
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i]?.trim();
+    if (!line)
+      continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const text = assistantText(entry);
+    if (text)
+      return text;
+  }
+  return "";
+}
+function assistantText(entry) {
+  if (typeof entry !== "object" || entry === null)
+    return "";
+  const e = entry;
+  if (e.type !== "assistant" || !Array.isArray(e.message?.content))
+    return "";
+  return e.message.content.filter((b) => b?.type === "text" && typeof b.text === "string").map((b) => b.text).join("\n").trim();
+}
+
+// ../../apps/server/dist/server.js
+var HOOK_BODY_LIMIT = 1e6;
+var COMMAND_BODY_LIMIT = 64 * 1024;
+var UPLOAD_LIMIT = 10 * 1024 * 1024;
+var TRANSCRIPT_LAG_MS = 750;
+var AUDIO_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+async function startServer(cfg) {
+  if (!cfg.accessKey)
+    throw new Error("RAYDR_ACCESS_KEY is empty; run raydr init or raydr serve");
+  const audio = new AudioStore(cfg.cacheDir);
+  const pruned = await audio.prune(AUDIO_MAX_AGE_MS);
+  if (pruned)
+    log(`pruned ${pruned} stale audio file(s)`);
+  const speech = selectSpeechProvider(cfg);
+  log(speech ? `speech provider: ${speech.name}` : "speech disabled (no provider credentials)");
+  const transcription = selectTranscriptionProvider(cfg);
+  const bus = new EventBus();
+  const settings = new SettingsStore(join5(cfg.stateDir, "sessions.json"));
+  const sessions = new SessionRegistry(settings);
+  const labels = speech ? new LabelClips(audio, (text) => speech.synthesize(text)) : null;
+  const webDir = cfg.webDir ?? defaultWebDir();
+  const commands = new CommandRunner(herdrCli, sessions);
+  const app = {
+    cfg,
+    audio,
+    speech,
+    transcription,
+    bus,
+    sessions,
+    settings,
+    labels,
+    commands,
+    webDir,
+    startedAt: Date.now()
+  };
+  const server = createServer((req, res) => {
+    handle(app, req, res).catch((err) => {
+      log(`request error: ${err.message}`);
+      if (!res.headersSent)
+        res.writeHead(500);
+      res.end();
+    });
+  });
+  await new Promise((resolve4, reject) => {
+    server.once("error", reject);
+    server.listen(cfg.port, cfg.host, () => resolve4());
+  });
+  log(`listening on http://${cfg.host}:${cfg.port}`);
+  if (!webDir)
+    log("web app not built; only the API is available");
+  return {
+    server,
+    bus,
+    sessions,
+    close: () => new Promise((resolve4) => {
+      server.closeAllConnections();
+      server.close(() => resolve4());
+    })
+  };
+}
+async function handle(app, req, res) {
+  const url = new URL(req.url ?? "/", "http://raydr");
+  const path = url.pathname;
+  if (path === "/healthz") {
+    res.writeHead(200, { "content-type": "application/json" });
+    res.end(JSON.stringify({
+      ok: true,
+      speech: app.speech?.name ?? null,
+      clients: app.bus.clientCount,
+      pid: process.pid,
+      uptimeSeconds: Math.round((Date.now() - app.startedAt) / 1e3),
+      port: app.cfg.port
+    }));
+    return;
+  }
+  if (req.method === "POST" && path.startsWith("/hooks/")) {
+    if (!authorized(app.cfg.accessKey, req, url)) {
+      logUnauthorizedHook(req);
+      res.writeHead(401).end();
+      return;
+    }
+    if (!(req.headers["content-type"] ?? "").startsWith("application/json")) {
+      res.writeHead(415).end();
+      return;
+    }
+    const body = await readJson(req);
+    res.writeHead(200).end();
+    const paneId = headerValue(req, "x-raydr-pane") ?? headerValue(req, "x-raydar-pane");
+    processHook(app, body, paneId).catch((err) => log(`hook error: ${err.message}`));
+    return;
+  }
+  if (path === "/events" || path === "/sessions" || path.startsWith("/sessions/") || path === "/commands" || path === "/transcribe" || path.startsWith("/audio/")) {
+    if (!authorized(app.cfg.accessKey, req, url)) {
+      res.writeHead(401, { "content-type": "text/plain" }).end("access key required");
+      return;
+    }
+  }
+  if (path === "/events") {
+    const last = Number(req.headers["last-event-id"] ?? url.searchParams.get("lastEventId") ?? 0);
+    app.bus.subscribe(res, Number.isFinite(last) ? last : 0);
+    return;
+  }
+  if (path === "/commands" && req.method === "POST") {
+    const cmd = parseCommand(await readJson(req, COMMAND_BODY_LIMIT));
+    if (!cmd) {
+      res.writeHead(400, { "content-type": "application/json" });
+      res.end(JSON.stringify({ error: "bad_command" }));
+      return;
+    }
+    res.writeHead(202, { "content-type": "application/json" });
+    res.end(JSON.stringify({ commandId: cmd.commandId }));
+    runCommand(app, cmd).catch((err) => log(`command error: ${err.message}`));
+    return;
+  }
+  if (path === "/transcribe" && req.method === "POST") {
+    await transcribe(app, req, res);
+    return;
+  }
+  if (path === "/sessions/announce" && req.method === "POST") {
+    const body = await readJson(req, COMMAND_BODY_LIMIT);
+    const sessionId = typeof body?.sessionId === "string" ? body.sessionId : "";
+    const cwd = typeof body?.cwd === "string" ? body.cwd : "";
+    const state = body?.state;
+    if (!/^[A-Za-z0-9-]{8,64}$/.test(sessionId) || !cwd || state !== "joined" && state !== "left") {
+      res.writeHead(400, { "content-type": "application/json" });
+      res.end(JSON.stringify({ error: "bad_announcement" }));
+      return;
+    }
+    if (state === "joined") {
+      const paneId = typeof body?.paneId === "string" ? body.paneId : null;
+      const { info } = app.sessions.touch(sessionId, cwd, paneId);
+      publishSession(app, info);
+      log(`session joined: ${info.label} (${sessionId.slice(0, 8)})`);
+    } else if (app.sessions.remove(sessionId)) {
+      app.commands.clearPending(sessionId);
+      app.bus.publish({ type: "session_left", sessionId });
+      log(`session left: ${sessionId.slice(0, 8)}`);
+    }
+    res.writeHead(200, { "content-type": "application/json" });
+    res.end(JSON.stringify({ state }));
+    return;
+  }
+  const settingsMatch = req.method === "PUT" && /^\/sessions\/([^/]+)\/settings$/.exec(path);
+  if (settingsMatch) {
+    const session2 = app.sessions.get(safeDecode(settingsMatch[1] ?? ""));
+    const body = await readJson(req, COMMAND_BODY_LIMIT);
+    if (!session2) {
+      res.writeHead(404, { "content-type": "application/json" });
+      res.end(JSON.stringify({ error: "unknown_session" }));
+      return;
+    }
+    if (!isSpeakMode(body?.speakMode)) {
+      res.writeHead(400, { "content-type": "application/json" });
+      res.end(JSON.stringify({ error: "bad_settings" }));
+      return;
+    }
+    app.settings.set(session2.cwd, { speakMode: body.speakMode });
+    for (const info of app.sessions.refreshSettings(session2.cwd))
+      publishSession(app, info);
+    log(`speak mode for ${session2.label}: ${body.speakMode}`);
+    res.writeHead(200, { "content-type": "application/json" });
+    res.end(JSON.stringify({ speakMode: body.speakMode }));
+    return;
+  }
+  if (path === "/sessions") {
+    res.writeHead(200, { "content-type": "application/json" });
+    res.end(JSON.stringify(app.sessions.list()));
+    return;
+  }
+  if (path.startsWith("/audio/")) {
+    const id = path.slice("/audio/".length).replace(/\.mp3$/, "");
+    if (!/^[\w-]+$/.test(id)) {
+      res.writeHead(400).end();
+      return;
+    }
+    const clip = app.audio.open(id);
+    if (!clip) {
+      res.writeHead(404).end();
+      return;
+    }
+    const headers = {
+      "content-type": "audio/mpeg",
+      "cache-control": "private, max-age=3600"
+    };
+    if (clip.size !== null)
+      headers["content-length"] = clip.size;
+    res.writeHead(200, headers);
+    clip.stream.on("error", () => res.destroy());
+    clip.stream.pipe(res);
+    return;
+  }
+  if ((req.method === "GET" || req.method === "HEAD") && app.webDir) {
+    serveStatic(app.webDir, req, res, path);
+    return;
+  }
+  res.writeHead(404).end();
+}
+async function processHook(app, body, paneId) {
+  const hook = parseHookPayload(body);
+  if (!hook) {
+    log("hook: unparseable payload");
+    return;
+  }
+  const { info, changed } = app.sessions.touch(hook.sessionId, hook.cwd, paneId);
+  if (changed)
+    publishSession(app, info);
+  if (app.labels && !info.labelAudioUrl) {
+    const label = info.label;
+    app.labels.urlFor(label).then((url) => {
+      if (url)
+        for (const updated of app.sessions.setLabelAudio(label, url))
+          publishSession(app, updated);
+    });
+  }
+  const event = await toEvent(app, hook);
+  if (!event)
+    return;
+  if (event.type === "question") {
+    app.commands.setPending(hook.sessionId, {
+      toolUseId: event.toolUseId,
+      questions: event.questions
+    });
+  } else if (event.type === "permission") {
+    app.commands.setPendingPermission(hook.sessionId);
+  } else if (event.type === "assistant_message") {
+    app.commands.clearPending(hook.sessionId);
+  }
+  app.bus.publish(event);
+  log(`${hook.kind} from ${info.label} (${hook.sessionId.slice(0, 8)})${"audioUrl" in event && event.audioUrl ? ` -> ${event.audioUrl}` : ""}`);
+}
+async function toEvent(app, hook) {
+  switch (hook.kind) {
+    case "ignore":
+      return null;
+    case "stop": {
+      let text = hook.text;
+      if (!text && hook.transcriptPath) {
+        await new Promise((r) => setTimeout(r, TRANSCRIPT_LAG_MS));
+        const fromTranscript = await lastAssistantText(hook.transcriptPath);
+        if (fromTranscript === null)
+          log(`transcript rejected: ${hook.transcriptPath}`);
+        text = fromTranscript ?? "";
+      }
+      if (!text)
+        return null;
+      return {
+        type: "assistant_message",
+        sessionId: hook.sessionId,
+        text,
+        ...spoken(app, renderSpeech(text, { summary: app.sessions.speakMode(hook.cwd) === "summary" }))
+      };
+    }
+    case "question":
+      return {
+        type: "question",
+        sessionId: hook.sessionId,
+        toolUseId: hook.toolUseId,
+        questions: hook.questions,
+        ...spoken(app, renderSpeech(questionSpeech(hook.questions)))
+      };
+    case "permission":
+      return {
+        type: "permission",
+        sessionId: hook.sessionId,
+        notificationType: "permission_prompt",
+        message: hook.message,
+        ...spoken(app, renderSpeech(hook.message))
+      };
+  }
+}
+function publishSession(app, info) {
+  app.bus.publish({
+    type: "session_seen",
+    sessionId: info.sessionId,
+    cwd: info.cwd,
+    label: info.label,
+    ...info.paneId ? { paneId: info.paneId } : {},
+    lastSeen: info.lastSeen,
+    ...info.labelAudioUrl ? { labelAudioUrl: info.labelAudioUrl } : {},
+    speakMode: info.speakMode ?? "full"
+  });
+}
+function spoken(app, speech) {
+  const text = truncateSpeech(speech, app.cfg.maxSpeechChars);
+  const url = text ? speak(app, text) : null;
+  return url ? { speech: text, audioUrl: url } : { speech: text };
+}
+async function runCommand(app, cmd) {
+  const base = {
+    type: "command_result",
+    sessionId: cmd.sessionId,
+    commandId: cmd.commandId
+  };
+  try {
+    await app.commands.run(cmd);
+    app.bus.publish({ ...base, ok: true });
+    log(`command ${cmd.type} ok (${cmd.commandId})`);
+  } catch (err) {
+    const error = err instanceof CommandError ? err.code : "internal_error";
+    log(`command ${cmd.type} failed: ${error}: ${err.message}`);
+    app.bus.publish({ ...base, ok: false, error });
+  }
+}
+async function transcribe(app, req, res) {
+  if (!app.transcription) {
+    res.writeHead(503, { "content-type": "application/json" });
+    res.end(JSON.stringify({ error: "transcription_unavailable" }));
+    return;
+  }
+  const contentType = req.headers["content-type"] ?? "";
+  if (!contentType.startsWith("multipart/form-data")) {
+    res.writeHead(415).end();
+    return;
+  }
+  let body;
+  try {
+    body = await readBody(req, UPLOAD_LIMIT);
+  } catch {
+    res.writeHead(413).end();
+    return;
+  }
+  const bytes = new Uint8Array(body);
+  let file;
+  try {
+    const form = await new Response(bytes, { headers: { "content-type": contentType } }).formData();
+    file = form.get("file");
+  } catch {
+    res.writeHead(400, { "content-type": "application/json" });
+    res.end(JSON.stringify({ error: "bad_multipart" }));
+    return;
+  }
+  if (!(file instanceof Blob) || file.size === 0) {
+    res.writeHead(400, { "content-type": "application/json" });
+    res.end(JSON.stringify({ error: "missing_file" }));
+    return;
+  }
+  const filename = file instanceof File ? file.name : "audio";
+  let text;
+  try {
+    text = await app.transcription.transcribe(file, filename);
+  } catch (err) {
+    const invalid = err instanceof TranscriptionError && err.status === 400;
+    log(`transcription failed: ${err.message}`);
+    res.writeHead(invalid ? 400 : 502, { "content-type": "application/json" });
+    res.end(JSON.stringify({ error: invalid ? "invalid_audio" : "transcription_failed" }));
+    return;
+  }
+  log(`transcribed ${file.size} bytes -> ${text.length} chars`);
+  res.writeHead(200, { "content-type": "application/json" });
+  res.end(JSON.stringify({ text }));
+}
+function speak(app, text) {
+  if (!app.speech)
+    return null;
+  const id = randomUUID();
+  const speech = app.speech;
+  const pending = new PassThrough2();
+  app.audio.write(id, pending).catch((err) => log(`speech failed: ${err.message}`));
+  speech.synthesize(text).then((stream) => {
+    stream.on("error", (err) => pending.destroy(err));
+    stream.pipe(pending);
+  }).catch((err) => pending.destroy(err));
+  return `/audio/${id}.mp3`;
+}
+function authorized(key, req, url) {
+  const header = req.headers.authorization;
+  const supplied = header?.startsWith("Bearer ") ? header.slice(7) : url.searchParams.get("key");
+  if (!supplied)
+    return false;
+  const a = Buffer.from(supplied);
+  const b = Buffer.from(key);
+  return a.length === b.length && timingSafeEqual(a, b);
+}
+var lastUnauthorizedLog = 0;
+function logUnauthorizedHook(req) {
+  const now = Date.now();
+  if (now - lastUnauthorizedLog < 6e4)
+    return;
+  lastUnauthorizedLog = now;
+  log(`unauthorized hook POST from ${req.socket.remoteAddress ?? "?"}; reinstall hooks if this is Claude Code`);
+}
+function safeDecode(segment) {
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return "";
+  }
+}
+function headerValue(req, name) {
+  const v = req.headers[name];
+  const s = Array.isArray(v) ? v[0] : v;
+  return s?.trim() || null;
+}
+async function readJson(req, limit = HOOK_BODY_LIMIT) {
+  const body = await readBody(req, limit);
+  try {
+    return body.length ? JSON.parse(body.toString("utf8")) : null;
+  } catch {
+    return null;
+  }
+}
+function readBody(req, limit) {
+  return new Promise((resolve4, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on("data", (c) => {
+      size += c.length;
+      if (size > limit) {
+        reject(new Error("body too large"));
+        req.destroy();
+        return;
+      }
+      chunks.push(c);
+    });
+    req.on("end", () => resolve4(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+function defaultWebDir() {
+  const here = dirname2(fileURLToPath(import.meta.url));
+  const candidates = [resolve(here, "..", "web"), resolve(here, "..", "..", "web", "dist")];
+  return candidates.find((dir) => existsSync4(join5(dir, "index.html"))) ?? null;
+}
+function log(msg) {
+  console.log(`[raydr ${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}`);
+}
+
+// src/command.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync3, unlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname3, join as join6 } from "node:path";
+
+// src/command-text.ts
+var RAYDR_COMMAND = "---\nname: raydr\nallowed-tools: Bash(raydr session:*)\ndescription: Turn raydr on or off for this session, or show its state\n---\n\n## Your task\n\nraydr speaks this session's replies and prompts on the user's phone. Run exactly one command\nwith the Bash tool, chosen by `$ARGUMENTS`, then print its single output line verbatim, with no\ncommentary and no extra formatting:\n\n| Arguments | Run |\n|---|---|\n| empty | `raydr session toggle` |\n| `on` | `raydr session on` |\n| `off` | `raydr session off` |\n| `status` | `raydr session status` |\n\nIf the command fails with `command not found`, raydr is not on this session's PATH. Print\nexactly:\n`raydr is not installed here: run npm i -g @tensorkit/raydr (or, from a checkout, cd packages/cli && npm link), then run /raydr again`\n\nAny other argument: print `usage: /raydr [on|off|status]` and stop.\n\nNote: when the environment has `RAYDR_SESSIONS=all`, every session is heard and this toggle\nchanges nothing; the command's output line says so.\n";
+
+// src/command.ts
+var MARKER = "name: raydr";
+function commandText() {
+  return RAYDR_COMMAND;
+}
+function commandFileFor(settingsPath) {
+  return join6(dirname3(settingsPath), "commands", "raydr.md");
+}
+function installCommand(target) {
+  mkdirSync3(dirname3(target), { recursive: true });
+  writeFileSync2(target, RAYDR_COMMAND);
+  const old = join6(dirname3(target), "raydar.md");
+  if (existsSync5(old) && readFileSync3(old, "utf8").includes("name: raydar")) unlinkSync(old);
+  return target;
+}
+function isRaydrCommandFile(path) {
+  try {
+    return readFileSync3(path, "utf8").includes(MARKER);
+  } catch {
+    return false;
+  }
+}
+function removeCommand(path) {
+  if (!existsSync5(path) || !isRaydrCommandFile(path)) return false;
+  unlinkSync(path);
+  return true;
+}
+
+// src/doctor.ts
+import { execFile as execFile2 } from "node:child_process";
+import { existsSync as existsSync8, readFileSync as readFileSync6, statSync as statSync3 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join9, resolve as resolve2 } from "node:path";
+
+// src/hooks-config.ts
+var HOOK_TIMEOUT_SECONDS = 5;
+function raydrHookGroups(cliEntry2, url, nodePath = process.execPath) {
+  const hook = (event) => ({
+    type: "command",
+    command: `${quote(nodePath)} ${quote(cliEntry2)} hook ${event}${url ? ` --url ${quote(url)}` : ""}`,
+    timeout: HOOK_TIMEOUT_SECONDS
+  });
+  return {
+    PreToolUse: { matcher: "AskUserQuestion", hooks: [hook("pretooluse")] },
+    Stop: { hooks: [hook("stop")] },
+    Notification: { hooks: [hook("notification")] }
+  };
+}
+function quote(s) {
+  return /^[\w./:@-]+$/.test(s) ? s : `'${s.replace(/'/g, "'\\''")}'`;
+}
+function isRaydrHook(hook) {
+  if (typeof hook !== "object" || hook === null) return false;
+  const h = hook;
+  if (h.type === "command" && typeof h.command === "string") {
+    return /\S*index\.js\S* hook (pretooluse|stop|notification)\b/.test(h.command);
+  }
+  if (h.type === "http" && typeof h.url === "string") {
+    const hasPaneHeader = typeof h.headers === "object" && h.headers !== null && "X-Raydr-Pane" in h.headers;
+    return hasPaneHeader && /\/hooks\/(pretooluse|stop|notification)$/.test(h.url);
+  }
+  return false;
+}
+function uninstallHooks(settings) {
+  const out = { ...settings };
+  if (!settings.hooks) return out;
+  const hooks = {};
+  for (const [event, groups] of Object.entries(settings.hooks)) {
+    const kept = groups.map((g) => ({ ...g, hooks: g.hooks.filter((h) => !isRaydrHook(h)) })).filter((g) => g.hooks.length > 0);
+    if (kept.length > 0) hooks[event] = kept;
+  }
+  if (Object.keys(hooks).length > 0) out.hooks = hooks;
+  else delete out.hooks;
+  return out;
+}
+function installHooks(settings, cliEntry2, url, nodePath = process.execPath) {
+  const out = uninstallHooks(settings);
+  const hooks = { ...out.hooks ?? {} };
+  for (const [event, group] of Object.entries(raydrHookGroups(cliEntry2, url, nodePath))) {
+    hooks[event] = [...hooks[event] ?? [], group];
+  }
+  out.hooks = hooks;
+  return out;
+}
+function installedEvents(settings) {
+  return Object.entries(settings.hooks ?? {}).filter(([, groups]) => groups.some((g) => g.hooks.some(isRaydrHook))).map(([event]) => event);
+}
+
+// src/lifecycle.ts
+import { spawn as spawn2 } from "node:child_process";
+import { existsSync as existsSync7, mkdirSync as mkdirSync5, openSync, readFileSync as readFileSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import { connect } from "node:net";
+import { join as join8 } from "node:path";
+
+// src/local.ts
+import { execFileSync, spawn, spawnSync } from "node:child_process";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync4, statfsSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname4, join as join7 } from "node:path";
+var SPACY_MODEL_URL = "https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.8.0/en_core_web_sm-3.8.0-py3-none-any.whl";
+var TORCH_CPU_INDEX = "https://download.pytorch.org/whl/cpu";
+var PACKAGES = ["kokoro", "lameenc", "faster-whisper", "numpy"];
+var IMPORTS = ["kokoro", "lameenc", "faster_whisper", "numpy", "en_core_web_sm"];
+var MIN_FREE_BYTES = 3 * 1024 * 1024 * 1024;
+function sidecarScript(cliEntry2) {
+  return join7(dirname4(cliEntry2), "..", "local", "raydr_local.py");
+}
+function sidecarEnv(cfg) {
+  return {
+    ...process.env,
+    HF_HOME: join7(cfg.localDir, "models"),
+    HF_HUB_DISABLE_PROGRESS_BARS: "1",
+    RAYDR_KOKORO_VOICE: cfg.kokoroVoice,
+    RAYDR_WHISPER_MODEL: cfg.whisperModel,
+    RAYDR_LOCAL_PORT: String(cfg.localPort),
+    // The sidecar requires this on every POST; it travels in the environment, never argv.
+    RAYDR_ACCESS_KEY: cfg.accessKey
+  };
+}
+function readSetup(cfg) {
+  try {
+    return JSON.parse(readFileSync4(localSetupMarker(cfg), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function ok(cmd, args, env = process.env) {
+  const r = spawnSync(cmd, args, { encoding: "utf8", env, timeout: 6e5 });
+  if (r.error && r.error.code === "ETIMEDOUT") {
+    return {
+      ok: false,
+      out: `${cmd} ${args[0] ?? ""} timed out after 10 minutes; re-running raydr local setup resumes where it stopped`
+    };
+  }
+  return { ok: r.status === 0, out: `${r.stdout ?? ""}${r.stderr ?? ""}`.trim() };
+}
+function freeBytes(dir) {
+  mkdirSync4(dir, { recursive: true });
+  const fs = statfsSync(dir);
+  return Number(fs.bavail) * Number(fs.bsize);
+}
+function pythonVersion(bin) {
+  const r = ok(bin, ["-c", "import sys;print(sys.version_info[0],sys.version_info[1])"]);
+  if (!r.ok) return null;
+  const [maj, min] = r.out.split(/\s+/).map(Number);
+  return maj !== void 0 && min !== void 0 ? [maj, min] : null;
+}
+function findPython(cfg, log2) {
+  if (ok("uv", ["--version"]).ok) {
+    log2("[ ok ] uv on PATH; it provides Python 3.12 for the sidecar");
+    return { kind: "uv", bin: "uv" };
+  }
+  for (const candidate of ["python3.13", "python3.12", "python3.11", "python3.10", "python3"]) {
+    const v = pythonVersion(candidate);
+    if (v && v[0] === 3 && v[1] >= 10 && v[1] <= 13) {
+      log2(`[ ok ] ${candidate} is ${v[0]}.${v[1]}`);
+      return { kind: "system", bin: candidate };
+    }
+  }
+  const sys = pythonVersion("python3");
+  throw new Error(
+    `no usable Python: the sidecar needs 3.10\u20133.13 (python3 is ${sys ? sys.join(".") : "missing"}) and Kokoro's dependencies have no wheels for newer versions. Install uv (curl -LsSf https://astral.sh/uv/install.sh | sh) and run raydr local setup again`
+  );
+}
+async function localSetup(cfg, cliEntry2, opts = {}) {
+  const log2 = opts.log ?? ((line) => console.log(line));
+  const env = sidecarEnv(cfg);
+  mkdirSync4(cfg.localDir, { recursive: true });
+  const free = freeBytes(cfg.localDir);
+  if (free < MIN_FREE_BYTES) {
+    throw new Error(
+      `only ${(free / 1024 ** 3).toFixed(1)} GB free on the filesystem holding ${cfg.localDir}; the sidecar needs about 3 GB (venv 1.5 GB, models 0.8 GB, downloads). Free space or set RAYDR_LOCAL_DIR`
+    );
+  }
+  const py = findPython(cfg, log2);
+  if (ok("espeak-ng", ["--version"]).ok) log2("[ ok ] espeak-ng on PATH");
+  else
+    log2(
+      "[info] espeak-ng not on PATH; the bundled copy is used (apt install espeak-ng / brew install espeak-ng if speech skips words)"
+    );
+  const python = localPython(cfg);
+  if (existsSync6(python)) {
+    log2(`[ ok ] venv at ${join7(cfg.localDir, "venv")}`);
+  } else {
+    log2(`[....] creating venv at ${join7(cfg.localDir, "venv")}`);
+    const r2 = py.kind === "uv" ? ok("uv", ["venv", "--python", "3.12", join7(cfg.localDir, "venv")], env) : ok(py.bin, ["-m", "venv", join7(cfg.localDir, "venv")], env);
+    if (!r2.ok) throw new Error(`could not create the venv: ${r2.out.slice(-300)}`);
+    log2("[ ok ] venv created");
+  }
+  const missing = IMPORTS.filter((m) => !ok(python, ["-c", `import ${m}`], env).ok);
+  if (missing.length === 0) {
+    log2("[ ok ] packages present (kokoro, faster-whisper, lameenc, numpy, spaCy English)");
+  } else {
+    log2(`[....] installing ${missing.join(", ")} (CPU torch about 200 MB, the rest about 300 MB)`);
+    const pip = (args) => py.kind === "uv" ? ok("uv", ["pip", "install", "--python", python, ...args], env) : ok(python, ["-m", "pip", "install", ...args], env);
+    const previous = readSetup(cfg)?.torch;
+    const torch = pip([previous ? `torch==${previous}` : "torch", "--index-url", TORCH_CPU_INDEX]);
+    if (!torch.ok) throw new Error(`torch install failed: ${torch.out.slice(-300)}`);
+    const pinned = torchVersion(python, env);
+    const rest = pip([...PACKAGES, SPACY_MODEL_URL, ...pinned ? [`torch==${pinned}`] : []]);
+    if (!rest.ok) throw new Error(`package install failed: ${rest.out.slice(-300)}`);
+    log2("[ ok ] packages installed");
+  }
+  const script = sidecarScript(cliEntry2);
+  const hub = join7(cfg.localDir, "models", "hub");
+  const have = (name) => existsSync6(join7(hub, name, "snapshots"));
+  const need = [
+    ...have("models--hexgrad--Kokoro-82M") ? [] : ["Kokoro-82M about 330 MB"],
+    ...have(`models--Systran--faster-whisper-${cfg.whisperModel}`) ? [] : [
+      `faster-whisper ${cfg.whisperModel} about ${cfg.whisperModel.startsWith("small") ? "460" : cfg.whisperModel.startsWith("base") ? "150" : "500+"} MB`
+    ]
+  ];
+  log2(need.length ? `[....] downloading ${need.join(" and ")}` : "[....] verifying model caches");
+  const r = ok(python, [script, "--download"], env);
+  if (!r.ok) throw new Error(`model download failed: ${r.out.slice(-300)}`);
+  log2(
+    need.length ? "[ ok ] models downloaded" : `[ ok ] models verified under ${join7(cfg.localDir, "models")}`
+  );
+  const espeak = ok(python, [script, "--probe-espeak"], env);
+  if (espeak.ok) log2("[ ok ] espeak-ng phonemizer works");
+  else
+    log2(
+      "[warn] bundled espeak-ng cannot load its data; Kokoro will skip words it has no pronunciation for"
+    );
+  const record = {
+    python,
+    noEspeak: !espeak.ok,
+    whisperModel: cfg.whisperModel,
+    kokoroVoice: cfg.kokoroVoice,
+    torch: torchVersion(python, env) ?? readSetup(cfg)?.torch ?? "",
+    at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeFileSync3(localSetupMarker(cfg), `${JSON.stringify(record, null, 2)}
+`);
+  log2(`[ ok ] setup recorded at ${localSetupMarker(cfg)}`);
+  return record;
+}
+function torchVersion(python, env) {
+  const r = ok(python, ["-c", "import torch;print(torch.__version__)"], env);
+  return r.ok ? r.out.split("\n").pop()?.trim() || null : null;
+}
+function sidecarArgs(cfg, cliEntry2, extra = []) {
+  const rec = readSetup(cfg);
+  return [
+    sidecarScript(cliEntry2),
+    "--port",
+    String(cfg.localPort),
+    "--voice",
+    cfg.kokoroVoice,
+    "--model",
+    cfg.whisperModel,
+    ...rec?.noEspeak ? ["--no-espeak"] : [],
+    ...extra
+  ];
+}
+function spawnSidecarInline(cfg, cliEntry2) {
+  const child = spawn(localPython(cfg), sidecarArgs(cfg, cliEntry2, ["--warm"]), {
+    env: sidecarEnv(cfg),
+    stdio: "inherit"
+  });
+  child.on("error", (err) => console.error(`local sidecar failed to start: ${err.message}`));
+  child.on("exit", (code, signal) => {
+    if (code !== 0)
+      console.error(
+        `local sidecar exited (${signal ?? `code ${code}`}); speech and transcription are off until raydr is restarted`
+      );
+  });
+  return child;
+}
+async function sidecarHealth(cfg) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${cfg.localPort}/healthz`, {
+      signal: AbortSignal.timeout(1500)
+    });
+    return res.ok ? await res.json() : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/lifecycle.ts
+function pidFile(cfg) {
+  return join8(cfg.stateDir, "server.pid");
+}
+function logFile(cfg) {
+  return join8(cfg.stateDir, "server.log");
+}
+function localPidFile(cfg) {
+  return join8(cfg.stateDir, "local.pid");
+}
+function localLogFile(cfg) {
+  return join8(cfg.stateDir, "local.log");
+}
+function readLocalPid(cfg) {
+  try {
+    const pid = Number(readFileSync5(localPidFile(cfg), "utf8").trim());
+    return Number.isInteger(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+function isSidecarPid(pid, procRoot = "/proc") {
+  if (!alive(pid)) return "stale";
+  try {
+    const argv = readFileSync5(`${procRoot}/${pid}/cmdline`, "utf8").split("\0");
+    return argv.some((a) => a.endsWith("raydr_local.py")) ? "raydr" : "stale";
+  } catch (err) {
+    return err.code === "ENOENT" ? "unverifiable" : "stale";
+  }
+}
+async function startSidecar(cfg, cliEntry2) {
+  if (!usesLocal(cfg)) return null;
+  if (!localReady(cfg)) return "local provider selected but not set up; run raydr local setup";
+  if (await sidecarHealth(cfg))
+    return `local sidecar already running on http://127.0.0.1:${cfg.localPort}`;
+  await requireLocalPortFree(cfg);
+  mkdirSync5(cfg.stateDir, { recursive: true });
+  const log2 = openSync(localLogFile(cfg), "a");
+  const child = spawn2(localPython(cfg), sidecarArgs(cfg, cliEntry2, ["--warm"]), {
+    detached: true,
+    stdio: ["ignore", log2, log2],
+    env: sidecarEnv(cfg)
+  });
+  child.unref();
+  if (child.pid === void 0) return "could not spawn the local sidecar";
+  writeFileSync4(localPidFile(cfg), `${child.pid}
+`);
+  return `local sidecar started (pid ${child.pid}) on http://127.0.0.1:${cfg.localPort}; models load in the background`;
+}
+async function stopSidecar(cfg) {
+  const pid = readLocalPid(cfg);
+  if (pid === null) return null;
+  const verdict = isSidecarPid(pid);
+  if (verdict === "unverifiable")
+    return `cannot verify that pid ${pid} is the sidecar (no /proc); stop it manually`;
+  if (verdict === "stale") {
+    if (existsSync7(localPidFile(cfg))) unlinkSync2(localPidFile(cfg));
+    return "local sidecar pid file was stale; removed it";
+  }
+  process.kill(pid, "SIGTERM");
+  const deadline = Date.now() + 5e3;
+  while (Date.now() < deadline) {
+    await sleep2(100);
+    if (!alive(pid)) {
+      unlinkSync2(localPidFile(cfg));
+      return `local sidecar stopped (pid ${pid})`;
+    }
+  }
+  return `sidecar pid ${pid} did not exit within 5 s; kill it manually`;
+}
+function readPid(cfg) {
+  try {
+    const pid = Number(readFileSync5(pidFile(cfg), "utf8").trim());
+    return Number.isInteger(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+function alive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isRaydrPid(pid, cfg, cliEntry2, procRoot = "/proc") {
+  if (!alive(pid)) return "stale";
+  const h = await health(cfg);
+  if (h?.pid === pid) return "raydr";
+  try {
+    const argv = readFileSync5(`${procRoot}/${pid}/cmdline`, "utf8").split("\0");
+    return argv.includes(cliEntry2) && argv.includes("serve") ? "raydr" : "stale";
+  } catch (err) {
+    return err.code === "ENOENT" ? "unverifiable" : "stale";
+  }
+}
+async function requireLocalPortFree(cfg) {
+  if (await portBound({ ...cfg, host: "127.0.0.1", port: cfg.localPort })) {
+    throw new Error(
+      `port ${cfg.localPort} is in use by another program; set RAYDR_LOCAL_PORT to move the sidecar`
+    );
+  }
+}
+function portBound(cfg) {
+  return new Promise((resolve4) => {
+    const socket = connect({ host: cfg.host, port: cfg.port });
+    socket.setTimeout(1e3);
+    socket.once("connect", () => {
+      socket.destroy();
+      resolve4(true);
+    });
+    socket.once("error", () => resolve4(false));
+    socket.once("timeout", () => {
+      socket.destroy();
+      resolve4(false);
+    });
+  });
+}
+async function health(cfg) {
+  try {
+    const res = await fetch(`http://${cfg.host}:${cfg.port}/healthz`, {
+      signal: AbortSignal.timeout(1500)
+    });
+    if (!res.ok) return null;
+    const body = await res.json();
+    return body.ok ? body : null;
+  } catch {
+    return null;
+  }
+}
+var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+async function start(cfg, cliEntry2, opts = {}) {
+  if (await portBound(cfg)) {
+    const h = await health(cfg);
+    if (h)
+      throw new Error(`raydr is already running on port ${cfg.port} (pid ${h.pid ?? "unknown"})`);
+    throw new Error(`port ${cfg.port} is in use by another program; set RAYDR_PORT to move raydr`);
+  }
+  mkdirSync5(cfg.stateDir, { recursive: true });
+  const child = opts.spawnServer ? opts.spawnServer() : spawnServer(cfg, cliEntry2, opts.serveArgs ?? []);
+  if (child.pid === void 0) throw new Error("could not spawn the server");
+  writeFileSync4(pidFile(cfg), `${child.pid}
+`);
+  const deadline = Date.now() + (opts.timeoutMs ?? 1e4);
+  while (Date.now() < deadline) {
+    await sleep2(Math.min(200, opts.timeoutMs ?? 200));
+    const h = await health(cfg);
+    if (h)
+      return `raydr started (pid ${child.pid}) on http://${cfg.host}:${cfg.port}
+log: ${logFile(cfg)}`;
+    if (!alive(child.pid)) {
+      unlinkSync2(pidFile(cfg));
+      throw new Error(`the server exited during startup; see ${logFile(cfg)}`);
+    }
+  }
+  return `raydr is still starting (pid ${child.pid}); check \`raydr status\`
+log: ${logFile(cfg)}`;
+}
+function spawnServer(cfg, cliEntry2, serveArgs) {
+  const log2 = openSync(logFile(cfg), "a");
+  const child = spawn2(process.execPath, [cliEntry2, "serve", ...serveArgs], {
+    detached: true,
+    stdio: ["ignore", log2, log2],
+    env: process.env
+  });
+  child.unref();
+  return { pid: child.pid };
+}
+async function stop(cfg, cliEntry2, procRoot = "/proc") {
+  const pid = readPid(cfg);
+  if (pid === null) {
+    const h = await health(cfg);
+    if (h?.pid)
+      throw new Error(
+        `raydr (pid ${h.pid}) was not started by \`raydr start\`; stop it where it runs`
+      );
+    return "raydr is not running";
+  }
+  const verdict = await isRaydrPid(pid, cfg, cliEntry2, procRoot);
+  if (verdict === "unverifiable") {
+    throw new Error(`cannot verify that pid ${pid} is raydr (no /proc); stop it manually`);
+  }
+  if (verdict === "stale") {
+    if (existsSync7(pidFile(cfg))) unlinkSync2(pidFile(cfg));
+    return `pid file was stale (pid ${pid} is not a raydr server); removed it`;
+  }
+  process.kill(pid, "SIGTERM");
+  const deadline = Date.now() + 5e3;
+  while (Date.now() < deadline) {
+    await sleep2(100);
+    if (!alive(pid)) {
+      unlinkSync2(pidFile(cfg));
+      return `raydr stopped (pid ${pid})`;
+    }
+  }
+  throw new Error(`pid ${pid} did not exit within 5 s; kill it manually`);
+}
+function formatUptime(seconds) {
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor(seconds % 3600 / 60);
+  const s = seconds % 60;
+  return h > 0 ? `${h}h ${m}m` : m > 0 ? `${m}m ${s}s` : `${s}s`;
+}
+function tailLog(cfg, lines = 50) {
+  try {
+    const all = readFileSync5(logFile(cfg), "utf8").split("\n");
+    if (all.at(-1) === "") all.pop();
+    return all.slice(-lines).join("\n");
+  } catch {
+    return `(no log yet at ${logFile(cfg)})`;
+  }
+}
+
+// src/doctor.ts
+async function doctor(cfg, cliEntry2, offline) {
+  const checks = [];
+  const major = Number(process.versions.node.split(".")[0]);
+  checks.push(
+    major >= 24 ? { level: "ok", name: "node", detail: `v${process.versions.node}` } : {
+      level: "fail",
+      name: "node",
+      detail: `v${process.versions.node}; raydr needs 24 or newer`
+    }
+  );
+  checks.push({
+    level: "ok",
+    name: "raydr",
+    detail: `v${VERSION}, ${/[\\/]node_modules[\\/](@tensorkit[\\/])?raydr[\\/]/.test(cliEntry2) ? "npm package" : "linked checkout"} at ${cliEntry2}`
+  });
+  checks.push(await herdrCheck());
+  if (!existsSync8(cfg.envFile)) {
+    checks.push({
+      level: "fail",
+      name: "env file",
+      detail: `${cfg.envFile} missing; run raydr init`
+    });
+  } else {
+    const mode = statSync3(cfg.envFile).mode & 511;
+    checks.push(
+      (mode & 63) === 0 ? { level: "ok", name: "env file", detail: `${cfg.envFile} (mode ${mode.toString(8)})` } : {
+        level: "warn",
+        name: "env file",
+        detail: `${cfg.envFile} is mode ${mode.toString(8)}; run chmod 600`
+      }
+    );
+  }
+  checks.push(...await providerChecks(cfg, offline));
+  checks.push(hooksCheck(cliEntry2));
+  const h = await health(cfg);
+  checks.push(
+    h ? {
+      level: "ok",
+      name: "server",
+      detail: `http://${cfg.host}:${cfg.port} pid ${h.pid ?? "?"}, speech ${h.speech ?? "off"}`
+    } : {
+      level: "warn",
+      name: "server",
+      detail: `nothing on http://${cfg.host}:${cfg.port}; run raydr start (log: ${logFile(cfg)})`
+    }
+  );
+  return checks;
+}
+function herdrCheck() {
+  return new Promise((resolve4) => {
+    execFile2("herdr", ["status", "server"], { timeout: 5e3 }, (err, stdout) => {
+      if (err) {
+        const missing = err.code === "ENOENT";
+        resolve4({
+          level: "warn",
+          name: "herdr",
+          detail: missing ? "not on PATH; replies are heard but menus cannot be answered from the app" : `on PATH but not reachable: ${err.message.split("\n")[0]}`
+        });
+        return;
+      }
+      resolve4({ level: "ok", name: "herdr", detail: stdout.trim().split("\n")[0] || "reachable" });
+    });
+  });
+}
+function hooksCheck(cliEntry2) {
+  const files = [
+    join9(homedir2(), ".claude", "settings.json"),
+    resolve2(".claude", "settings.local.json")
+  ];
+  const found = [];
+  let stale = false;
+  for (const file of files) {
+    if (!existsSync8(file)) continue;
+    let settings;
+    try {
+      settings = JSON.parse(readFileSync6(file, "utf8"));
+    } catch {
+      continue;
+    }
+    const events = installedEvents(settings);
+    if (events.length === 0) continue;
+    found.push(`${file} (${events.join(", ")})`);
+    const commands = Object.values(settings.hooks ?? {}).flatMap((groups) => groups.flatMap((g) => g.hooks)).filter(isRaydrHook).map((h) => h.command ?? "");
+    if (commands.some((c) => !c.includes(cliEntry2))) stale = true;
+  }
+  if (found.length === 0)
+    return { level: "fail", name: "hooks", detail: "not installed; run raydr hooks install" };
+  if (stale)
+    return {
+      level: "warn",
+      name: "hooks",
+      detail: `installed but point at another checkout; re-run raydr hooks install (${found.join("; ")})`
+    };
+  return { level: "ok", name: "hooks", detail: found.join("; ") };
+}
+async function elevenLabsCheck(apiKey, voiceId) {
+  try {
+    const res = await fetch(
+      `https://api.elevenlabs.io/v1/text-to-speech/${encodeURIComponent(voiceId)}/stream?output_format=mp3_22050_32`,
+      {
+        method: "POST",
+        headers: { "xi-api-key": apiKey, "content-type": "application/json" },
+        body: JSON.stringify({ text: "hi", model_id: "eleven_flash_v2_5" }),
+        signal: AbortSignal.timeout(1e4)
+      }
+    );
+    if (res.ok) {
+      await res.body?.cancel();
+      return {
+        level: "ok",
+        name: "elevenlabs api",
+        detail: "key accepted (2-character synthesis)"
+      };
+    }
+    return {
+      level: "fail",
+      name: "elevenlabs api",
+      detail: `HTTP ${res.status} ${(await res.text()).slice(0, 120)}`
+    };
+  } catch (err) {
+    return {
+      level: "fail",
+      name: "elevenlabs api",
+      detail: `unreachable: ${err.message}`
+    };
+  }
+}
+function formatChecks(checks) {
+  const mark = { ok: " ok ", warn: "warn", fail: "FAIL" };
+  return checks.map((c) => `[${mark[c.level]}] ${c.name.padEnd(15)} ${c.detail}`).join("\n");
+}
+async function providerChecks(cfg, offline) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [kind, r] of [
+    ["speech", speechReadiness(cfg)],
+    ["transcription", transcriptionReadiness(cfg)]
+  ]) {
+    if (!r.ready) {
+      out.push({
+        level: "fail",
+        name: kind,
+        detail: `${r.provider}: missing ${r.missing}; run ${r.fix}`
+      });
+      continue;
+    }
+    out.push({ level: "ok", name: kind, detail: r.provider });
+    const backend = r.provider === "kokoro" || r.provider === "whisper" ? "local" : r.provider;
+    if (seen.has(backend)) continue;
+    seen.add(backend);
+    if (r.provider === "elevenlabs") {
+      out.push(
+        offline ? skipped("elevenlabs api") : await elevenLabsCheck(cfg.elevenLabsApiKey ?? "", cfg.elevenLabsVoiceId)
+      );
+    } else if (r.provider === "openai") {
+      out.push(
+        offline ? skipped("openai api") : await openAiCheck(cfg.openAiApiKey ?? "", cfg.openAiVoice)
+      );
+    } else {
+      out.push(await localCheck(cfg));
+    }
+  }
+  return out;
+}
+function skipped(name) {
+  return { level: "ok", name, detail: "skipped (--offline)" };
+}
+async function localCheck(cfg) {
+  if (!localReady(cfg))
+    return { level: "fail", name: "local models", detail: "not set up; run raydr local setup" };
+  const rec = readSetup(cfg);
+  const h = await sidecarHealth(cfg);
+  const models = `models under ${cfg.localDir}${rec?.noEspeak ? ", espeak fallback off" : ""}`;
+  return h ? {
+    level: "ok",
+    name: "local sidecar",
+    detail: `answering on http://127.0.0.1:${cfg.localPort} (${h.tts && h.stt ? "models loaded" : "models loading"}); ${models}`
+  } : {
+    level: "warn",
+    name: "local sidecar",
+    detail: `not answering on http://127.0.0.1:${cfg.localPort}; raydr start launches it; ${models}`
+  };
+}
+async function openAiCheck(apiKey, voice) {
+  try {
+    const res = await fetch("https://api.openai.com/v1/audio/speech", {
+      method: "POST",
+      headers: { authorization: `Bearer ${apiKey}`, "content-type": "application/json" },
+      body: JSON.stringify({
+        model: "gpt-4o-mini-tts",
+        voice,
+        input: "hi",
+        response_format: "mp3"
+      }),
+      signal: AbortSignal.timeout(15e3)
+    });
+    if (res.ok) {
+      await res.body?.cancel();
+      return { level: "ok", name: "openai api", detail: "key accepted (2-character synthesis)" };
+    }
+    return {
+      level: "fail",
+      name: "openai api",
+      detail: `HTTP ${res.status} ${(await res.text()).slice(0, 120)}`
+    };
+  } catch (err) {
+    return { level: "fail", name: "openai api", detail: `unreachable: ${err.message}` };
+  }
+}
+
+// src/init.ts
+import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync7, renameSync as renameSync2, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname5 } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { Writable } from "node:stream";
+var pick = (value, allowed) => value && allowed.includes(value) ? value : null;
+async function init(opts) {
+  const envFile = defaultEnvFile();
+  const existing = existsSync9(envFile) ? withLegacyNames(parseEnvFile(readFileSync7(envFile, "utf8"))) : {};
+  const initialised = Object.keys(existing).some((k) => k !== "RAYDR_ACCESS_KEY");
+  if (initialised && !opts.force) {
+    throw new Error(`${envFile} already exists; re-run with --force to replace it`);
+  }
+  const interactive = process.stdin.isTTY === true;
+  if (opts.speech !== void 0 && !pick(opts.speech, SPEECH_PROVIDERS)) {
+    throw new Error(`--speech must be one of ${SPEECH_PROVIDERS.join(", ")}`);
+  }
+  if (opts.transcription !== void 0 && !pick(opts.transcription, TRANSCRIPTION_PROVIDERS)) {
+    throw new Error(`--transcription must be one of ${TRANSCRIPTION_PROVIDERS.join(", ")}`);
+  }
+  const speech = pick(opts.speech, SPEECH_PROVIDERS) ?? (interactive ? await choose("Speech provider", SPEECH_PROVIDERS) : "elevenlabs");
+  const transcription = pick(opts.transcription, TRANSCRIPTION_PROVIDERS) ?? (interactive ? await choose("Transcription provider", TRANSCRIPTION_PROVIDERS) : "elevenlabs");
+  const needsElevenLabs = speech === "elevenlabs" || transcription === "elevenlabs";
+  const needsOpenAi = speech === "openai" || transcription === "openai";
+  const keep = (name) => opts.force ? existing[name] : void 0;
+  const elevenLabsKey = opts.elevenLabsKey ?? keep("ELEVENLABS_API_KEY") ?? (needsElevenLabs && interactive ? await ask("ElevenLabs API key (hidden): ", true) : "");
+  const openAiKey = opts.openAiKey ?? keep("OPENAI_API_KEY") ?? (needsOpenAi && interactive ? await ask("OpenAI API key (hidden): ", true) : "");
+  const voice = opts.voiceId ?? keep("ELEVENLABS_VOICE_ID") ?? (speech === "elevenlabs" && interactive ? await ask("ElevenLabs voice id (blank for default): ") : "");
+  const port = opts.port ?? keep("RAYDR_PORT") ?? (interactive ? await ask(`Port (blank for ${DEFAULT_PORT}): `) : "");
+  if (port && !/^\d{2,5}$/.test(port)) throw new Error(`"${port}" is not a port number`);
+  const accessKey = !opts.rotateKey && existing.RAYDR_ACCESS_KEY ? existing.RAYDR_ACCESS_KEY : newAccessKey();
+  const lines = [
+    "# raydr configuration; read by the server and the Claude Code hooks",
+    `RAYDR_SPEECH_PROVIDER=${speech}`,
+    `RAYDR_TRANSCRIPTION_PROVIDER=${transcription}`,
+    `ELEVENLABS_API_KEY=${elevenLabsKey ?? ""}`,
+    `ELEVENLABS_VOICE_ID=${voice ?? ""}`,
+    `OPENAI_API_KEY=${openAiKey ?? ""}`,
+    ...port ? [`RAYDR_PORT=${port}`] : [],
+    // Anything else the previous file had (RAYDR_SESSIONS, local options) survives a --force.
+    ...Object.entries(existing).filter(([k]) => !KNOWN.has(k)).map(([k, v]) => `${k}=${v}`),
+    `RAYDR_ACCESS_KEY=${accessKey}`,
+    ""
+  ];
+  mkdirSync6(dirname5(envFile), { recursive: true, mode: 448 });
+  const tmp = `${envFile}.tmp-${process.pid}`;
+  writeFileSync5(tmp, lines.join("\n"), { mode: 384, flag: "wx" });
+  renameSync2(tmp, envFile);
+  const local = speech === "kokoro" || transcription === "whisper";
+  let localSetupPending = local;
+  if (local && opts.runLocalSetup) localSetupPending = !await opts.runLocalSetup();
+  const notes = [
+    `wrote ${envFile} (mode 600): speech ${speech}, transcription ${transcription}`,
+    needsElevenLabs && !elevenLabsKey ? "no ElevenLabs key: add ELEVENLABS_API_KEY before starting" : "",
+    needsOpenAi && !openAiKey ? "no OpenAI key: add OPENAI_API_KEY before starting" : "",
+    localSetupPending ? "local models: run raydr local setup before starting" : "",
+    opts.rotateKey ? "access key rotated; the web app will ask for the new one" : "",
+    "next: raydr hooks install, then raydr start"
+  ];
+  return {
+    envFile,
+    speech,
+    transcription,
+    localSetupPending,
+    message: notes.filter(Boolean).join("\n")
+  };
+}
+function withLegacyNames(env) {
+  const out = {};
+  for (const [k, v] of Object.entries(env)) {
+    if (k.startsWith("RAYDAR_")) {
+      const key = `RAYDR_${k.slice("RAYDAR_".length)}`;
+      if (env[key] === void 0) out[key] = v;
+    } else out[k] = v;
+  }
+  return out;
+}
+var KNOWN = /* @__PURE__ */ new Set([
+  "RAYDR_SPEECH_PROVIDER",
+  "RAYDR_TRANSCRIPTION_PROVIDER",
+  "ELEVENLABS_API_KEY",
+  "ELEVENLABS_VOICE_ID",
+  "OPENAI_API_KEY",
+  "RAYDR_PORT",
+  "RAYDR_ACCESS_KEY"
+]);
+async function choose(label, allowed) {
+  for (; ; ) {
+    const answer = await ask(`${label} (${allowed.join(" / ")}) [${allowed[0]}]: `);
+    if (answer === "") return allowed[0];
+    const picked = pick(answer, allowed);
+    if (picked) return picked;
+    process.stdout.write(`  "${answer}" is not one of ${allowed.join(", ")}
+`);
+  }
+}
+async function ask(question, hidden = false) {
+  const muted = new Writable({ write: (_chunk, _enc, cb) => cb() });
+  const rl = createInterface({
+    input: process.stdin,
+    output: hidden ? muted : process.stdout,
+    terminal: true
+  });
+  if (hidden) process.stdout.write(question);
+  try {
+    const answer = await rl.question(hidden ? "" : question);
+    if (hidden) process.stdout.write("\n");
+    return answer.trim();
+  } finally {
+    rl.close();
+  }
+}
+async function confirm(question) {
+  const answer = (await ask(`${question} [Y/n] `)).toLowerCase();
+  return answer === "" || answer === "y" || answer === "yes";
+}
+
+// src/session.ts
+import { basename as basename2 } from "node:path";
+async function session(verb, cfg, env, cwd = env.PWD ?? process.cwd()) {
+  const sessionId = env.CLAUDE_CODE_SESSION_ID;
+  if (!sessionId) {
+    throw new Error(
+      "not inside a Claude Code session (CLAUDE_CODE_SESSION_ID is not set); run /raydr in Claude Code"
+    );
+  }
+  if (!validSessionId(sessionId)) {
+    throw new Error("CLAUDE_CODE_SESSION_ID is not a Claude Code session id");
+  }
+  const pane = env.HERDR_PANE_ID && !env.HERDR_PANE_ID.startsWith("$") ? env.HERDR_PANE_ID : void 0;
+  const label = basename2(cwd) || cwd;
+  const wasOn = isEnabled(cfg.stateDir, sessionId);
+  const want = verb === "toggle" ? wasOn ? "off" : "on" : verb;
+  if (want === "on") {
+    enableSession(cfg.stateDir, {
+      sessionId,
+      cwd,
+      label,
+      ...pane ? { paneId: pane } : {},
+      enabledAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  } else if (want === "off") {
+    disableSession(cfg.stateDir, sessionId);
+  }
+  const announced = want === "status" ? null : await announce(cfg, {
+    sessionId,
+    cwd,
+    label,
+    ...pane ? { paneId: pane } : {},
+    state: want === "on" ? "joined" : "left"
+  });
+  const on = want === "status" ? wasOn : want === "on";
+  const where = `${label}${pane ? `, pane ${pane}` : ""}`;
+  const server = announced === true ? `server running on http://${cfg.host}:${cfg.port}` : await health(cfg) ? `server running on http://${cfg.host}:${cfg.port}` : "server not answering";
+  const mode = cfg.sessionsMode === "all" ? " \xB7 RAYDR_SESSIONS=all, every session is heard" : "";
+  return `raydr: ${on ? `on for this session (${where})` : "off for this session"} \xB7 ${server}${mode}`;
+}
+async function announce(cfg, body) {
+  if (!cfg.accessKey) return false;
+  try {
+    const res = await fetch(`http://${cfg.host}:${cfg.port}/sessions/announce`, {
+      method: "POST",
+      headers: { authorization: `Bearer ${cfg.accessKey}`, "content-type": "application/json" },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(2e3)
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+// src/main.ts
+var USAGE = `raydr \u2014 hear your Claude Code sessions
+
+Set up:
+  raydr init [--speech P] [--transcription P] [--voice-id V] [--port P] [--force] [--rotate-key]
+  raydr init --migrate-env           Rename RAYDAR_* lines in the env file to RAYDR_* (one-shot)
+                                     Create ~/.config/raydr/env: pick providers, then the keys
+                                     they need (--elevenlabs-key K / --openai-key K only for
+                                     scripts; they land in shell history)
+  raydr local setup                 Install the Python sidecar for kokoro / whisper (idempotent)
+  raydr local serve                 Run the sidecar in the foreground
+  raydr hooks install [options]     Add raydr's hooks and the /raydr command to Claude Code
+  raydr doctor [--offline]          Check node, herdr, env file, hooks, server, ElevenLabs
+
+Run:
+  raydr start | stop | status       Run the server in the background (per login session)
+  raydr logs [-f]                   Show the background server's log
+  raydr serve                       Run the server in the foreground
+  (start and serve take --no-speech to run without a configured provider)
+
+Claude Code:
+  raydr session on|off|toggle|status
+                                     Opt this Claude Code session in or out (what /raydr runs)
+  raydr command                     Print the /raydr command file (also: --command, --skill)
+  raydr command --install [--project]
+                                     Write it to ~/.claude/commands/raydr.md (or ./.claude/commands)
+  raydr hooks uninstall [options]   Remove the hooks and the command again
+  raydr hooks status                Show which settings files carry raydr hooks
+  raydr hook <event>                Used by the installed hooks; forwards stdin to the server
+
+  raydr --version | --help          Print the version, or this text
+
+Options:
+  --settings <path>   Settings file (default ~/.claude/settings.json)
+  --project           Use ./.claude/settings.local.json in the current directory instead
+  --url <url>         Server URL to bake into the hooks (default: from the raydr env file)
+`;
+var VALUE_FLAGS = {
+  "--settings": "settings",
+  "--url": "url",
+  "--elevenlabs-key": "elevenLabsKey",
+  "--openai-key": "openAiKey",
+  "--speech": "speech",
+  "--transcription": "transcription",
+  "--voice-id": "voiceId",
+  "--port": "port"
+};
+var BOOL_FLAGS = {
+  "--project": "project",
+  "--force": "force",
+  "--install": "install",
+  "--migrate-env": "migrateEnv",
+  "--no-speech": "noSpeech",
+  "--rotate-key": "rotateKey",
+  "--offline": "offline",
+  "-f": "follow",
+  "--follow": "follow"
+};
+var USER_SETTINGS = join10(homedir3(), ".claude", "settings.json");
+var PROJECT_SETTINGS = resolve3(".claude", "settings.local.json");
+function parseArgs(argv) {
+  const args = {
+    positional: [],
+    settings: USER_SETTINGS,
+    project: false,
+    url: void 0,
+    elevenLabsKey: void 0,
+    openAiKey: void 0,
+    speech: void 0,
+    transcription: void 0,
+    voiceId: void 0,
+    port: void 0,
+    force: false,
+    install: false,
+    migrateEnv: false,
+    noSpeech: false,
+    rotateKey: false,
+    offline: false,
+    follow: false
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i] ?? "";
+    const valueFlag = VALUE_FLAGS[a];
+    const boolFlag = BOOL_FLAGS[a];
+    if (valueFlag) {
+      const v = argv[++i];
+      if (!v) fail(`${a} needs a value`);
+      args[valueFlag] = v;
+    } else if (boolFlag) {
+      args[boolFlag] = true;
+    } else if (a.startsWith("-")) {
+      fail(`unknown option ${a}`);
+    } else {
+      args.positional.push(a);
+    }
+  }
+  if (args.project) args.settings = PROJECT_SETTINGS;
+  return args;
+}
+function fail(msg) {
+  console.error(`raydr: ${msg}
+
+${USAGE}`);
+  process.exit(2);
+}
+function readSettings(path) {
+  if (!existsSync10(path)) return {};
+  const parsed = JSON.parse(readFileSync8(path, "utf8"));
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    fail(`${path} is not a JSON object`);
+  }
+  return parsed;
+}
+function writeSettings(path, settings) {
+  mkdirSync7(dirname6(path), { recursive: true });
+  if (existsSync10(path)) {
+    const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const backup = `${path}.raydr-backup-${stamp}`;
+    copyFileSync(path, backup);
+    console.log(`backup written to ${backup}`);
+  }
+  const tmp = `${path}.raydr-tmp-${process.pid}`;
+  writeFileSync6(tmp, `${JSON.stringify(settings, null, 2)}
+`);
+  renameSync3(tmp, path);
+}
+function raydrOnPath() {
+  const result = spawnSync2("sh", ["-c", "command -v raydr"], { stdio: "ignore" });
+  return result.status === 0;
+}
+function cliEntry() {
+  return join10(dirname6(fileURLToPath2(import.meta.url)), "index.js");
+}
+async function main(argv) {
+  if (argv.length === 0 || ["--help", "-h", "help"].includes(argv[0] ?? "")) {
+    console.log(USAGE);
+    return;
+  }
+  const normalised = argv.map((a) => a === "--command" || a === "--skill" ? "command" : a);
+  const args = parseArgs(normalised);
+  const [cmd, sub] = args.positional;
+  if (cmd === "serve") {
+    requireProviders(loadConfig(), args.noSpeech);
+    const cfg = loadConfig(void 0, { generateKey: true });
+    const sidecar = usesLocal(cfg) && !args.noSpeech && localReady(cfg) && !await sidecarHealth(cfg) ? await (async () => {
+      await requireLocalPortFree(cfg);
+      return spawnSidecarInline(cfg, cliEntry());
+    })() : null;
+    let running;
+    try {
+      running = await startServer(cfg);
+    } catch (err) {
+      sidecar?.kill("SIGTERM");
+      throw err;
+    }
+    const shutdown = () => {
+      sidecar?.kill("SIGTERM");
+      void running.close().then(() => process.exit(0));
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    return;
+  }
+  if (cmd === "local") {
+    const cfg = loadConfig();
+    if (sub === "setup") {
+      await localSetup(cfg, cliEntry());
+      console.log(
+        "local models ready; select them with RAYDR_SPEECH_PROVIDER=kokoro and RAYDR_TRANSCRIPTION_PROVIDER=whisper (raydr init does)"
+      );
+      return;
+    }
+    if (sub === "serve") {
+      const child = spawnSidecarInline(cfg, cliEntry());
+      await new Promise((r) => child.on("exit", () => r()));
+      return;
+    }
+    fail("local needs one of: setup, serve");
+  }
+  if (cmd === "init" && args.migrateEnv) {
+    const file = defaultEnvFile();
+    const n = migrateEnvFile(file);
+    console.log(
+      n ? `renamed ${n} RAYDAR_ line(s) to RAYDR_ in ${file}` : `no RAYDAR_ lines in ${file}`
+    );
+    return;
+  }
+  if (cmd === "init") {
+    const result = await init({
+      ...args.speech !== void 0 ? { speech: args.speech } : {},
+      ...args.transcription !== void 0 ? { transcription: args.transcription } : {},
+      ...args.elevenLabsKey !== void 0 ? { elevenLabsKey: args.elevenLabsKey } : {},
+      ...args.openAiKey !== void 0 ? { openAiKey: args.openAiKey } : {},
+      ...args.voiceId !== void 0 ? { voiceId: args.voiceId } : {},
+      ...args.port !== void 0 ? { port: args.port } : {},
+      force: args.force,
+      rotateKey: args.rotateKey,
+      runLocalSetup: async () => {
+        if (process.stdin.isTTY !== true) return false;
+        if (!await confirm("Set up the local models now (Python venv, about 2 GB)?"))
+          return false;
+        await localSetup(loadConfig(), cliEntry());
+        return true;
+      }
+    });
+    console.log(result.message);
+    return;
+  }
+  if (cmd === "start") {
+    requireProviders(loadConfig(), args.noSpeech);
+    const cfg = loadConfig(void 0, { generateKey: true });
+    const sidecar = args.noSpeech ? null : await startSidecar(cfg, cliEntry());
+    if (sidecar) console.log(sidecar);
+    console.log(await start(cfg, cliEntry(), { serveArgs: args.noSpeech ? ["--no-speech"] : [] }));
+    return;
+  }
+  if (cmd === "stop") {
+    const cfg = loadConfig();
+    let failure = null;
+    try {
+      console.log(await stop(cfg, cliEntry()));
+    } catch (err) {
+      failure = err;
+    }
+    const sidecar = await stopSidecar(cfg);
+    if (sidecar) console.log(sidecar);
+    if (failure) throw failure;
+    return;
+  }
+  if (cmd === "status") {
+    const cfg = loadConfig();
+    const pid = readPid(cfg);
+    const h = await health(cfg);
+    const lines = [
+      `raydr:  v${VERSION}`,
+      `server:  ${h ? `running on http://${cfg.host}:${cfg.port}, pid ${h.pid ?? "?"}, up ${formatUptime(h.uptimeSeconds ?? 0)}, speech ${h.speech ?? "off"}, ${h.clients ?? 0} client(s)` : `not answering on http://${cfg.host}:${cfg.port}`}`,
+      `pid file: ${pid === null ? "none" : `${pid} (${pidLabel(await isRaydrPid(pid, cfg, cliEntry()))})`}`,
+      `log:     ${logFile(cfg)}`
+    ];
+    if (usesLocal(cfg)) {
+      const lp = readLocalPid(cfg);
+      const lh = await sidecarHealth(cfg);
+      lines.push(
+        `sidecar: ${lh ? `running on http://127.0.0.1:${cfg.localPort}, models ${lh.tts && lh.stt ? "loaded" : "loading"}` : "not answering"}${lp !== null ? ` (pid ${lp}, ${isSidecarPid(lp) === "raydr" ? "alive" : "stale"})` : ""}; log ${localLogFile(cfg)}`
+      );
+    }
+    for (const file of [USER_SETTINGS, PROJECT_SETTINGS]) {
+      if (!existsSync10(file)) continue;
+      const events = installedEvents(readSettings(file));
+      lines.push(`hooks:   ${file}: ${events.length ? events.join(", ") : "none"}`);
+    }
+    console.log(lines.join("\n"));
+    initHint();
+    return;
+  }
+  if (cmd === "logs") {
+    const cfg = loadConfig();
+    if (!args.follow) {
+      console.log(tailLog(cfg));
+      return;
+    }
+    const tail = spawn3("tail", ["-n", "50", "-f", logFile(cfg)], { stdio: "inherit" });
+    await new Promise((r) => tail.on("exit", () => r()));
+    return;
+  }
+  if (cmd === "doctor") {
+    const checks = await doctor(loadConfig(), cliEntry(), args.offline);
+    console.log(formatChecks(checks));
+    console.log("add the /raydr command: raydr --command > ~/.claude/commands/raydr.md");
+    initHint();
+    if (checks.some((c) => c.level === "fail")) process.exitCode = 1;
+    return;
+  }
+  if (cmd === "command") {
+    if (sub === "--install" || args.install) {
+      const target = installCommand(commandFileFor(args.settings));
+      console.log(`installed /raydr command at ${target}`);
+      return;
+    }
+    process.stdout.write(commandText());
+    return;
+  }
+  if (cmd === "session") {
+    if (sub !== "on" && sub !== "off" && sub !== "toggle" && sub !== "status") {
+      fail("session needs one of: on, off, toggle, status");
+    }
+    console.log(await session(sub, loadConfig(), process.env));
+    initHint();
+    return;
+  }
+  if (cmd === "hooks") {
+    if (sub === "install") {
+      const before = readSettings(args.settings);
+      writeSettings(args.settings, installHooks(before, cliEntry(), args.url));
+      console.log(`installed hooks in ${args.settings}`);
+      const command = installCommand(commandFileFor(args.settings));
+      console.log(`installed /raydr command at ${command}`);
+      if (!raydrOnPath()) {
+        console.log(
+          "warning: `raydr` is not on PATH, so /raydr will not work until it is: npm i -g @tensorkit/raydr, or from a checkout cd packages/cli && npm link"
+        );
+      }
+      console.log(`they will post to ${args.url ?? serverUrlFromConfig()}`);
+      initHint();
+      return;
+    }
+    if (sub === "uninstall") {
+      const before = readSettings(args.settings);
+      const after = uninstallHooks(before);
+      if (JSON.stringify(after) === JSON.stringify(before)) {
+        console.log(`no raydr hooks in ${args.settings}`);
+        return;
+      }
+      writeSettings(args.settings, after);
+      console.log(`removed hooks from ${args.settings}`);
+      const command = commandFileFor(args.settings);
+      if (removeCommand(command)) console.log(`removed ${command}`);
+      return;
+    }
+    if (sub === "status") {
+      const files = [.../* @__PURE__ */ new Set([args.settings, USER_SETTINGS, PROJECT_SETTINGS])];
+      for (const file of files) {
+        if (!existsSync10(file)) continue;
+        const events = installedEvents(readSettings(file));
+        console.log(`${file}: ${events.length ? events.join(", ") : "no raydr hooks"}`);
+        const command = commandFileFor(file);
+        console.log(
+          `${command}: ${isRaydrCommandFile(command) ? "/raydr command installed" : "no /raydr command"}`
+        );
+      }
+      console.log(`server: ${serverUrlFromConfig()}`);
+      initHint();
+      return;
+    }
+  }
+  fail(cmd ? `unknown command ${[cmd, sub].filter(Boolean).join(" ")}` : "no command given");
+}
+function requireProviders(cfg, noSpeech) {
+  if (noSpeech) return;
+  for (const [kind, r] of [
+    ["speech", speechReadiness(cfg)],
+    ["transcription", transcriptionReadiness(cfg)]
+  ]) {
+    if (r.ready) continue;
+    console.error(
+      `${kind} provider ${r.provider} is not configured: missing ${r.missing}; run ${r.fix}`
+    );
+    process.exit(1);
+  }
+}
+function initHint() {
+  if (!existsSync10(defaultEnvFile())) {
+    console.log(`run raydr init to set up ${defaultEnvFile().replace(homedir3(), "~")}`);
+  }
+}
+function pidLabel(verdict) {
+  return verdict === "raydr" ? "alive" : verdict === "stale" ? "stale" : "unverified, no /proc";
+}
+function serverUrlFromConfig() {
+  const cfg = loadConfig();
+  return `http://${cfg.host}:${cfg.port}`;
+}
+export {
+  main
+};