dsh-agent-voice 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+## 0.1.0
+- Initial release: `dsh_agent_voice` tool (speak / attention / test / status / voices).
+- Local TTS worker (Piper + XTTS v2) on 127.0.0.1:7863.
+- Automatic announcements on subagent/workflow completion and approval requests.
+- Main-interface settings panel with voice picker, language, volume, and toggles.
+- Curated Piper voices: jirka, kasandra, lessac, ryan (+ XTTS v2).

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Michal Ožuch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.cs.md

@@ -0,0 +1,43 @@
+# dsh-agent-voice
+
+Dejte svému agentovi v DeepSeek Harness hlas. Agent čte nahlas, když **dokončí úkol** a když **potřebuje vaši pozornost** — nikdy nečte své úvahy, průběh ani mezivýsledky.
+
+- Lokální, offline převod řeči (Piper hlasy + XTTS v2), žádné cloud API.
+- Kurátorovaná sada hlasů (česky + anglicky) z [rhasspy/piper-voices](https://huggingface.co/rhasspy/piper-voices).
+- Pěkné nastavení přímo v hlavním rozhraní s živým náhledem.
+- Automatické hlášení, když skončí subagent / workflow, a když agent žádá o rozhodnutí.
+
+**🇬🇧 [English guide →](README.md)**
+
+## Instalace
+
+```bash
+dsh plugin add dsh-agent-voice
+```
+
+Restartujte DSH a otevřete záložku **🔊 Agent Voice** v hlavním rozhraní.
+
+## Jak to funguje
+
+| Akce | Kdy | Příklad |
+| --- | --- | --- |
+| `dsh_agent_voice action='speak' text='…'` | Úkol dokončen | *"Úkol dokončen."* |
+| `dsh_agent_voice action='attention'` | Agent vás potřebuje | *"Potřebuji tě u počítače."* |
+
+Agent má pokyn **nikdy** nečíst nahlas své úvahy ani průběžné kroky a držet hlasové zprávy na jednu větu.
+
+## Hlasy
+
+| id | Hlas | Jazyk |
+| --- | --- | --- |
+| `jirka` | Jirka (medium) | cs |
+| `kasandra` | Kasandra (medium) | cs |
+| `lessac` | Lessac (medium) | en |
+| `ryan` | Ryan (high) | en |
+| `xtts` | XTTS v2 (multilingual) | cs, en |
+
+Hlasy se stahují z HuggingFace při prvním použití (Piper `.onnx` modely) do `~/.local/share/piper/`.
+
+## Licence
+
+MIT. Piper hlasy mají licenci MIT (rhasspy/piper-voices). XTTS v2 podléhá nekomerční licenci CPML od Coqui; pro souhlas nastavte `COQUI_TOS_AGREED=1` (plugin to dělá automaticky).

package/README.md

@@ -0,0 +1,43 @@
+# dsh-agent-voice
+
+Give your DeepSeek Harness agent a voice. The agent speaks aloud when it **finishes a task** and when it **needs your attention** — never its reasoning, progress, or interim reports.
+
+- Local, offline TTS (Piper voices + XTTS v2), no cloud API required.
+- A curated set of voices (Czech + English) from [rhasspy/piper-voices](https://huggingface.co/rhasspy/piper-voices).
+- Nice settings panel in the main interface, with live preview.
+- Automatic announcements when subagents / workflows settle, and when the agent asks for a decision.
+
+**🇨🇿 [Český návod →](README.cs.md)**
+
+## Install
+
+```bash
+dsh plugin add dsh-agent-voice
+```
+
+Restart DSH, then open the **🔊 Agent Voice** tab in the main interface.
+
+## How it works
+
+| Action | When | Example |
+| --- | --- | --- |
+| `dsh_agent_voice action='speak' text='…'` | A task completed | *"Úkol dokončen."* |
+| `dsh_agent_voice action='attention'` | The agent needs you | *"Potřebuji tě u počítače."* |
+
+The agent is instructed to **never** read its reasoning or intermediate steps aloud, and to keep spoken messages to one sentence.
+
+## Voices
+
+| id | Voice | Language |
+| --- | --- | --- |
+| `jirka` | Jirka (medium) | cs |
+| `kasandra` | Kasandra (medium) | cs |
+| `lessac` | Lessac (medium) | en |
+| `ryan` | Ryan (high) | en |
+| `xtts` | XTTS v2 (multilingual) | cs, en |
+
+Voices are downloaded from HuggingFace on first use (Piper `.onnx` models) into `~/.local/share/piper/`.
+
+## License
+
+MIT. Piper voice models are MIT-licensed (rhasspy/piper-voices). XTTS v2 is subject to Coqui's non-commercial CPML license; set `COQUI_TOS_AGREED=1` to agree (the plugin does this automatically).

package/cordis.patch.yml

@@ -0,0 +1,6 @@
+# dsh-agent-voice bundle patch: register the host row that gives the agent a
+# voice — a `dsh_agent_voice` tool, a lightweight local TTS worker (Piper +
+# XTTS v2), and the Agent Voice settings + live audio playback.
+- insert:
+    - id: agent-voice
+      name: 'dsh-agent-voice'

package/lib/client.js

@@ -0,0 +1,156 @@
+window.__ModuleLoader__.load({
+  id: "dsh-agent-voice",
+  factory: (require) => {
+    var module = { exports: {} };
+    var exports = module.exports;
+    const React = require("react");
+
+    const inject = ["slots", "settingsScope"];
+
+    const CSS = ".av-root{display:flex;flex-direction:column;gap:14px;padding:16px 20px;font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif}.av-title{font-size:22px;font-weight:700;margin:0;background:linear-gradient(90deg,#ff7ab6,#7c5cff);-webkit-background-clip:text;background-clip:text;color:transparent}.av-sub{color:#9aa0b4;font-size:12px;margin:0}.av-set{border:1px solid #242838;border-radius:12px;padding:14px;display:flex;flex-direction:column;gap:12px}.av-row{display:flex;align-items:center;gap:10px;flex-wrap:wrap}.av-tag{font-size:11px;color:#ff8fc0;font-weight:700}.av-input{border:1px solid #2a2e3f;background:#151827;color:inherit;border-radius:9px;padding:7px 11px;font:inherit}.av-btn{font:inherit;font-size:12px;font-weight:600;border:1px solid #2a2e3f;background:#1b1f30;color:inherit;border-radius:9px;padding:7px 12px;cursor:pointer}.av-btn:hover{border-color:#ff7ab6}.av-primary{background:linear-gradient(135deg,#ff6aa8,#7c5cff);border:none;color:#fff}.av-switch{position:relative;width:40px;height:22px;background:#2a2e3f;border-radius:22px;cursor:pointer;border:1px solid #3a3f55;transition:.2s}.av-switch.on{background:linear-gradient(135deg,#ff6aa8,#7c5cff)}.av-knob{position:absolute;top:1px;left:1px;width:18px;height:18px;background:#fff;border-radius:50%;transition:.2s}.av-switch.on .av-knob{left:19px}.av-badge{font-size:11px;padding:2px 8px;border-radius:20px;background:#1b1f30;border:1px solid #2a2e3f;color:#9aa0b4}";
+
+    function useAction(scope) {
+      return async function call(args) {
+        const id = String(Date.now()) + "-" + Math.random().toString(36).slice(2);
+        await scope.set("request", JSON.stringify(args));
+        await scope.set("requestId", id);
+        for (let i = 0; i < 200; i++) {
+          const v = scope.getSnapshot().value;
+          if (v && v.responseId === id) {
+            try { return JSON.parse(v.response); } catch { return { ok: false, error: "bad response" }; }
+          }
+          await new Promise((r) => setTimeout(r, 400));
+        }
+        return { ok: false, error: "timeout" };
+      };
+    }
+    function useSnapshot(scope) {
+      return React.useSyncExternalStore((cb) => scope.subscribe(cb), () => scope.getSnapshot());
+    }
+
+    const FALLBACK_VOICES = [
+      { id: "jirka", name: "Jirka (česky, muž)", language: "cs", available: true },
+      { id: "kasandra", name: "Kasandra (česky, žena)", language: "cs", available: true },
+      { id: "lessac", name: "Lessac (anglicky, žena)", language: "en", available: true },
+      { id: "ryan", name: "Ryan (anglicky, muž)", language: "en", available: true },
+      { id: "xtts", name: "XTTS v2 (multilingual)", language: "cs,en", available: true },
+    ];
+
+    function AgentVoice(props) {
+      const [voices, setVoices] = React.useState(FALLBACK_VOICES);
+      const [status, setStatus] = React.useState("");
+      const [lastPlayed, setLastPlayed] = React.useState(null);
+
+      const action = React.useMemo(() => useAction(props.action), [props.action]);
+      const cfgSnap = useSnapshot(props.config);
+      const cfg = (cfgSnap && cfgSnap.value) || {};
+      const enabled = cfg.enabled !== false;
+      const voice = cfg.voice || "jirka";
+      const language = cfg.language || "cs";
+      const announceTasks = cfg.announceTasks !== false;
+      const announceAttention = cfg.announceAttention !== false;
+      const volume = cfg.volume ?? 1.0;
+
+      // Live audio playback: watch the status namespace for a new announcement.
+      const statusSnap = useSnapshot(props.status);
+      const statusJson = (statusSnap && statusSnap.value && statusSnap.value.json) || null;
+      React.useEffect(() => {
+        if (!statusJson) return;
+        let p = null;
+        try { p = JSON.parse(statusJson); } catch { return; }
+        if (!p || !p.dataUrl || !p.id) return;
+        if (p.id === lastPlayed) return;
+        setLastPlayed(p.id);
+        const audio = new Audio(p.dataUrl);
+        audio.volume = Math.max(0, Math.min(1, Number(p.volume ?? 1)));
+        audio.play().catch(() => {});
+      }, [statusJson, lastPlayed]);
+
+      React.useEffect(() => {
+        action({ action: "voices" }).then((r) => {
+          if (r && r.ok && r.result && r.result.voices && r.result.voices.length) setVoices(r.result.voices);
+        }).catch(() => {});
+      }, []);
+
+      function set(field, value) { props.config.set(field, value); }
+      async function test() {
+        setStatus("Generuji hlas…");
+        const r = await action({ action: "test", text: "Ahoj, tady agent. Tohle je můj hlas." });
+        setStatus(r && r.ok ? "Přehrávám ukázku 🔊" : ((r && r.error) || "Chyba"));
+      }
+      async function attention() {
+        const r = await action({ action: "attention" });
+        setStatus(r && r.ok ? "Přehrávám výzvu k pozornosti 🔔" : ((r && r.error) || "Chyba"));
+      }
+
+      return React.createElement("div", { className: "av-root" },
+        React.createElement("div", null,
+          React.createElement("h1", { className: "av-title" }, "Agent Voice"),
+          React.createElement("p", { className: "av-sub" }, "Agent čte nahlas dokončené úkoly a žádosti o pozornost · nikdy nečte úvahy ani průběžné zprávy")),
+
+        React.createElement("div", { className: "av-set" },
+          React.createElement("div", { className: "av-row" },
+            React.createElement("span", { className: "av-tag" }, "Hlas agenta:"),
+            React.createElement("div", { className: "av-switch" + (enabled ? " on" : ""), onClick: () => set("enabled", !enabled) },
+              React.createElement("div", { className: "av-knob" })),
+            React.createElement("span", { className: "av-sub" }, enabled ? "zapnuto" : "vypnuto")),
+
+          React.createElement("div", { className: "av-row" },
+            React.createElement("span", { className: "av-tag" }, "Hlas:"),
+            React.createElement("select", { className: "av-input", value: voice, onChange: (e) => set("voice", e.target.value) },
+              voices.map((v) => React.createElement("option", { key: v.id, value: v.id, disabled: v.available === false },
+                v.name + (v.available === false ? " (nedostupný)" : ""))))),
+
+          React.createElement("div", { className: "av-row" },
+            React.createElement("span", { className: "av-tag" }, "Jazyk:"),
+            React.createElement("select", { className: "av-input", value: language, onChange: (e) => set("language", e.target.value) },
+              React.createElement("option", { value: "cs" }, "čeština"),
+              React.createElement("option", { value: "en" }, "english"))),
+
+          React.createElement("div", { className: "av-row" },
+            React.createElement("span", { className: "av-tag" }, "Hlasitost:"),
+            React.createElement("input", { type: "range", min: 0, max: 1, step: 0.1, value: volume, onChange: (e) => set("volume", Number(e.target.value)) }),
+            React.createElement("span", { className: "av-badge" }, Math.round(volume * 100) + " %")),
+
+          React.createElement("div", { className: "av-row" },
+            React.createElement("label", { className: "av-sub" },
+              React.createElement("input", { type: "checkbox", checked: announceTasks, onChange: (e) => set("announceTasks", e.target.checked) }),
+              " oznamovat dokončené úkoly"),
+            React.createElement("label", { className: "av-sub" },
+              React.createElement("input", { type: "checkbox", checked: announceAttention, onChange: (e) => set("announceAttention", e.target.checked) }),
+              " oznamovat žádost o pozornost")),
+
+          React.createElement("div", { className: "av-row" },
+            React.createElement("button", { className: "av-btn av-primary", onClick: test }, "▶ Vyzkoušet hlas"),
+            React.createElement("button", { className: "av-btn", onClick: attention }, "🔔 Výzva k pozornosti"),
+            status ? React.createElement("span", { className: "av-badge" }, status) : null)),
+
+        React.createElement("p", { className: "av-sub" },
+          "Doporučené použití: agent zavolá dsh_agent_voice action='speak' po dokončení úkolu a action='attention', " +
+          "když tě potřebuje u počítače. Úvahy ani průběžné zprávy se nikdy nečtou nahlas."));
+    }
+
+    function apply(ctx) {
+      const style = document.createElement("style");
+      style.textContent = CSS;
+      document.head.appendChild(style);
+      ctx.effect(() => () => style.remove());
+
+      const action = ctx.settingsScope.bind({ namespace: "agent-voice-action" });
+      const config = ctx.settingsScope.bind({ namespace: "agent-voice" });
+      const status = ctx.settingsScope.bind({ namespace: "agent-voice-status" });
+      ctx.slots.inject("conversation.view", () => ctx.slots.register({
+        name: "conversation.view",
+        id: "studio-agent-voice",
+        order: 10,
+        label: () => "🔊 Agent Voice",
+        inject: () => ({ action, config, status }),
+        children: {},
+      }, AgentVoice));
+    }
+
+    exports.apply = apply;
+    exports.inject = inject;
+    return module.exports;
+  },
+});

package/lib/index.js

@@ -0,0 +1,251 @@
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import { settingsNamespace, installSettingsSection } from "@deepseek-ai/dsh-settings";
+import z from "@deepseek-ai/schemastery";
+import { execFile, spawn } from "node:child_process";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+import { promisify } from "node:util";
+import { fileURLToPath } from "node:url";
+
+const execFileAsync = promisify(execFile);
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const WORKER_PY = join(__dirname, "..", "worker", "agent_voice_worker.py");
+
+const name = "agent-voice";
+const inject = ["tools", "settings"];
+
+const NS = settingsNamespace("agent-voice");
+const ACTION_NS = settingsNamespace("agent-voice-action");
+const STATUS_NS = settingsNamespace("agent-voice-status");
+
+const DSH_HOME = process.env.DSH_HOME ?? join(homedir(), ".dsh");
+const SHARED_VENV = join(DSH_HOME, "voice-studio-venv"); // reuse the installed XTTS/Piper venv
+const VENV_DIR = join(DSH_HOME, "agent-voice-venv");
+const WORKER_URL = "http://127.0.0.1:7863";
+const PYTHON = process.env.PYTHON ?? "/opt/homebrew/opt/python@3.11/bin/python3.11";
+
+const SCHEMA = z.object({
+  enabled: z.boolean(),
+  voice: z.string(),
+  language: z.string(),
+  announceTasks: z.boolean(),
+  announceAttention: z.boolean(),
+  volume: z.number(),
+});
+
+const DEFAULTS = {
+  enabled: true,
+  voice: "jirka",
+  language: "cs",
+  announceTasks: true,
+  announceAttention: true,
+  volume: 1.0,
+};
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+let workerProcess = null;
+
+async function ensureWorker() {
+  let venvPython = join(SHARED_VENV, "bin", "python3");
+  if (!existsSync(venvPython)) {
+    // Fallback: build a lightweight venv with Piper only (XTTS stays optional).
+    if (!existsSync(join(VENV_DIR, "bin", "python3"))) {
+      await execFileAsync(PYTHON, ["-m", "venv", VENV_DIR], { timeout: 300000 });
+    }
+    venvPython = join(VENV_DIR, "bin", "python3");
+    const marker = join(VENV_DIR, ".deps-installed");
+    if (!existsSync(marker)) {
+      await execFileAsync(join(VENV_DIR, "bin", "pip"), ["install", "piper-tts"], {
+        timeout: 900000,
+        maxBuffer: 20 * 1024 * 1024,
+      });
+      await writeFile(marker, String(Date.now()));
+    }
+  }
+  if (!workerProcess || workerProcess.exitCode !== null) {
+    workerProcess = spawn(venvPython, [WORKER_PY], { detached: false, stdio: "ignore" });
+    workerProcess.unref?.();
+  }
+  for (let i = 0; i < 120; i++) {
+    try {
+      const r = await fetch(`${WORKER_URL}/health`, { signal: AbortSignal.timeout(3000) });
+      if (r.ok) return;
+    } catch {
+      /* not up yet */
+    }
+    await sleep(1000);
+  }
+  throw new Error("agent-voice worker did not become healthy on " + WORKER_URL);
+}
+
+async function postWorker(path, body) {
+  const r = await fetch(`${WORKER_URL}${path}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  const data = await r.json().catch(() => ({}));
+  if (!r.ok || data.ok !== true) {
+    throw new Error(`agent-voice worker ${path}: ${data.error ?? ("HTTP " + r.status)}`);
+  }
+  return data;
+}
+
+function apply(ctx) {
+  let source = () => ({ ...DEFAULTS });
+  installSettingsSection(ctx, NS, SCHEMA, DEFAULTS, {
+    setSource: (current) => { source = () => ({ ...DEFAULTS, ...(current ?? {}) }); },
+    onChange: () => {},
+  });
+
+  ctx.settings.register(STATUS_NS, z.object({ json: z.string() }), { base: {} });
+  const actionScope = ctx.settings.register(ACTION_NS, z.object({
+    requestId: z.string(),
+    request: z.string(),
+    responseId: z.string(),
+    response: z.string(),
+  }), { base: {} });
+
+  async function synthesize(text, voice, language) {
+    const res = await postWorker("/tts", { text, voice, language });
+    const bytes = await readFile(res.audio);
+    return "data:audio/wav;base64," + Buffer.from(bytes).toString("base64");
+  }
+
+  async function announce(kind, text) {
+    const cfg = source();
+    if (!cfg.enabled) return { ok: false, skipped: "disabled" };
+    const dataUrl = await synthesize(text, cfg.voice, cfg.language);
+    const payload = {
+      id: String(Date.now()) + "-" + Math.random().toString(36).slice(2),
+      kind,
+      text,
+      voice: cfg.voice,
+      volume: cfg.volume,
+      dataUrl,
+      at: Date.now(),
+    };
+    await ctx.settings.replace(STATUS_NS, { json: JSON.stringify(payload) });
+    return { ok: true, kind, text };
+  }
+
+  async function runAction(req) {
+    const cfg = source();
+    const a = req.action;
+
+    if (a === "status") {
+      return {
+        enabled: cfg.enabled,
+        voice: cfg.voice,
+        language: cfg.language,
+        announceTasks: cfg.announceTasks,
+        announceAttention: cfg.announceAttention,
+        volume: cfg.volume,
+      };
+    }
+
+    if (a === "voices") {
+      await ensureWorker();
+      return postWorker("/voices", {});
+    }
+
+    if (!cfg.enabled && a !== "status") {
+      return { ok: false, skipped: "agent voice je vypnutý" };
+    }
+
+    if (a === "speak") {
+      if (!req.text) throw new Error("speak requires text");
+      return announce("speak", req.text);
+    }
+    if (a === "attention") {
+      const text = req.text || "Potřebuji tě u počítače.";
+      return announce("attention", text);
+    }
+    if (a === "test") {
+      const text = req.text || "Ahoj, tady agent. Test hlasu proběhl úspěšně.";
+      return announce("test", text);
+    }
+    throw new Error("unknown action: " + a);
+  }
+
+  let lastRequestId = null;
+  actionScope.watch(() => {
+    const v = actionScope.get();
+    if (!v || !v.requestId || v.requestId === lastRequestId) return;
+    lastRequestId = v.requestId;
+    let req;
+    try { req = JSON.parse(v.request); } catch { return; }
+    runAction(req).then(
+      (result) => ctx.settings.replace(ACTION_NS, { ...v, responseId: v.requestId, response: JSON.stringify({ ok: true, result }) }),
+      (error) => ctx.settings.replace(ACTION_NS, { ...v, responseId: v.requestId, response: JSON.stringify({ ok: false, error: String(error?.message ?? error) }) }),
+    );
+  });
+
+  // Automatic announcements (fire-and-forget, guarded by settings).
+  ctx.on("subagent/end", () => {
+    const cfg = source();
+    if (!cfg.enabled || !cfg.announceTasks) return;
+    announce("task", "Dílčí úkol dokončen.").catch(() => {});
+  });
+  ctx.on("workflow/end", () => {
+    const cfg = source();
+    if (!cfg.enabled || !cfg.announceTasks) return;
+    announce("task", "Práce dokončena.").catch(() => {});
+  });
+  // Attention: when the agent must ask the user for a decision. We observe the
+  // approval waterfall without blocking it — we always pass control through.
+  ctx.on("approval/request", (req, next) => {
+    try {
+      const cfg = source();
+      if (cfg.enabled && cfg.announceAttention) {
+        announce("attention", "Potřebuji tě u počítače.").catch(() => {});
+      }
+    } catch {}
+    return next();
+  });
+
+  // Keep spoken output short and silent about reasoning.
+  const sp = ctx.get("systemPrompt");
+  if (sp) {
+    sp.section({
+      name: "agent-voice",
+      order: 400,
+      text:
+        "Mluvíš nahlas přes nástroj dsh_agent_voice. Použij ho POUZE k oznámení " +
+        "dokončeného úkolu (action='speak') nebo k žádosti o pozornost uživatele " +
+        "(action='attention'). NIKDY nečti nahlas své úvahy, průběžné kroky ani " +
+        "dílčí mezivýsledky. Hlasové zprávy udržuj krátké (jedna věta).",
+    });
+  }
+
+  ctx.tools.register(defineTool({
+    name: "dsh_agent_voice",
+    description:
+      "Speak aloud to the user (local TTS, Czech/English). Use it ONLY to announce a " +
+      "completed task ('speak') or to request the user's attention ('attention'). " +
+      "NEVER narrate reasoning, progress, or interim results. Keep spoken messages short. " +
+      "Also 'status' (config) and 'voices' (available voices) and 'test'.",
+    parameters: {
+      action: { type: "string", required: true, description: "speak | attention | test | status | voices." },
+      text: { type: "string", description: "Text to speak (speak/attention/test)." },
+    },
+    output: { schema: { type: "string" }, render: (_a, v) => [{ type: "text", text: v }] },
+    async execute(args) {
+      try {
+        return JSON.stringify(await runAction(args));
+      } catch (error) {
+        return `dsh_agent_voice failed: ${error.message}`;
+      }
+    },
+  }));
+
+  ctx.effect(() => () => {
+    if (workerProcess && workerProcess.exitCode === null) workerProcess.kill();
+  });
+}
+
+export { apply, inject, name };

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "dsh-agent-voice",
+  "version": "0.1.0",
+  "description": "DeepSeek Harness plugin: gives the agent a voice — it reads completed tasks and attention requests aloud (never reasoning or interim reports) via local Piper / XTTS v2, with a settings panel and a curated set of voices.",
+  "type": "module",
+  "main": "lib/index.js",
+  "files": [
+    "lib",
+    "worker",
+    "cordis.patch.yml",
+    "README.md",
+    "README.cs.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "license": "MIT",
+  "author": "Michal Ožuch",
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "plugin",
+    "agent",
+    "voice",
+    "tts",
+    "speech",
+    "piper",
+    "xtts"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/meliodascz89/dsh-agent-voice.git"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-connection",
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-ui-settings"
+      ]
+    }
+  },
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./package.json": "./package.json"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/dsh-tools": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-settings": "^0.1.1-rc.2"
+  },
+  "dependencies": {}
+}

package/worker/agent_voice_worker.log

@@ -0,0 +1,3 @@
+[2026-08-31 22:08:19] agent-voice worker listening on http://127.0.0.1:7863
+[2026-08-31 22:08:23] error: 'PiperVoice' object has no attribute 'synthesize_stream_raw'
+[2026-08-31 22:08:46] agent-voice worker listening on http://127.0.0.1:7863

package/worker/agent_voice_worker.py

@@ -0,0 +1,173 @@
+#!/usr/bin/env python3
+"""Local TTS worker for dsh-agent-voice.
+
+A small stdlib-only HTTP server for fast, low-memory agent announcements.
+Piper is the default engine (distinct, offline, internet-curated voices);
+XTTS v2 is available as a multilingual fallback.
+
+Endpoints:
+  GET  /health   -> {"ok": true}
+  POST /tts      {text, voice, language}  -> {"ok": true, "audio": path}
+  POST /voices   {}                       -> {"ok": true, "voices": [...]}
+
+Piper voice models live in ~/.local/share/piper/<model>.onnx(.json).
+"""
+import json
+import os
+import time
+import wave
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+# XTTS v2 model is licensed under Coqui's non-commercial CPML. Using this
+# plugin constitutes agreement; set COQUI_TOS_AGREED=1 explicitly if preferred.
+os.environ.setdefault("COQUI_TOS_AGREED", "1")
+
+HOST = "127.0.0.1"
+PORT = 7863
+BASE = os.path.dirname(os.path.abspath(__file__))
+LOG_PATH = os.path.join(BASE, "agent_voice_worker.log")
+OUT_DIR = os.environ.get("VOICE_OUTPUT_DIR") or "/Volumes/KvaDisk/Projekty/HarnessPlugs/dabing"
+PIPER_DIR = os.path.join(os.path.expanduser("~"), ".local", "share", "piper")
+
+# Curated voices (downloaded from https://huggingface.co/rhasspy/piper-voices).
+PIPER_VOICES = {
+    "jirka": ("cs_CZ-jirka-medium", "cs"),
+    "kasandra": ("cs_CZ-kasandra-medium", "cs"),
+    "lessac": ("en_US-lessac-medium", "en"),
+    "ryan": ("en_US-ryan-high", "en"),
+}
+
+
+def log(msg):
+    line = "[%s] %s\n" % (time.strftime("%Y-%m-%d %H:%M:%S"), msg)
+    try:
+        with open(LOG_PATH, "a") as fh:
+            fh.write(line)
+    except Exception:
+        pass
+    try:
+        print(line, end="")
+    except Exception:
+        pass
+
+
+_xtts = None
+
+
+def get_xtts():
+    global _xtts
+    if _xtts is None:
+        import torch
+        _orig_load = torch.load
+
+        def _load(*a, **kw):
+            kw.setdefault("weights_only", False)
+            return _orig_load(*a, **kw)
+
+        torch.load = _load
+        from TTS.api import TTS
+        log("loading XTTS v2 ...")
+        _xtts = TTS("tts_models/multilingual/multi-dataset/xtts_v2")
+        log("XTTS v2 ready")
+    return _xtts
+
+
+def _piper_paths(model_name):
+    onnx = os.path.join(PIPER_DIR, model_name + ".onnx")
+    config = os.path.join(PIPER_DIR, model_name + ".onnx.json")
+    if not (os.path.isfile(onnx) and os.path.isfile(config)):
+        return None, None
+    return onnx, config
+
+
+def tts_piper(text, model_name, output):
+    from piper import PiperVoice
+    onnx, config = _piper_paths(model_name)
+    if not (onnx and config):
+        raise RuntimeError(
+            "piper voice %s nenalezen v %s — stáhni jej z rhasspy/piper-voices" % (model_name, PIPER_DIR)
+        )
+    voice = PiperVoice.load(onnx, config)
+    with wave.open(output, "wb") as w:
+        voice.synthesize_wav(text, w)
+    return output
+
+
+def tts_xtts(text, language, output):
+    tts = get_xtts()
+    tts.tts_to_file(text=text, file_path=output, language=language)
+    return output
+
+
+def synthesize(text, voice, language, output):
+    if voice == "xtts":
+        return tts_xtts(text, language or "cs", output)
+    model_name, default_lang = PIPER_VOICES.get(voice, ("cs_CZ-jirka-medium", "cs"))
+    return tts_piper(text, model_name, output)
+
+
+def list_voices():
+    voices = []
+    for name, (model_name, lang) in PIPER_VOICES.items():
+        onnx, _ = _piper_paths(model_name)
+        voices.append({"id": name, "name": model_name, "language": lang, "available": bool(onnx)})
+    try:
+        get_xtts  # noqa: B018
+        voices.append({"id": "xtts", "name": "XTTS v2 (multilingual)", "language": "cs,en", "available": True})
+    except Exception:
+        voices.append({"id": "xtts", "name": "XTTS v2 (multilingual)", "language": "cs,en", "available": False})
+    return voices
+
+
+class Handler(BaseHTTPRequestHandler):
+    def _send_json(self, obj, status=200):
+        data = json.dumps(obj).encode("utf-8")
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(data)))
+        self.end_headers()
+        self.wfile.write(data)
+
+    def _read_json(self):
+        length = int(self.headers.get("Content-Length", 0) or 0)
+        if length <= 0:
+            return {}
+        return json.loads(self.rfile.read(length).decode("utf-8"))
+
+    def log_message(self, *args):
+        pass
+
+    def do_GET(self):
+        if self.path == "/health":
+            return self._send_json({"ok": True})
+        return self._send_json({"ok": False, "error": "not found"}, 404)
+
+    def do_POST(self):
+        try:
+            body = self._read_json()
+            if self.path == "/tts":
+                return self._tts(body)
+            if self.path == "/voices":
+                return self._send_json({"ok": True, "voices": list_voices()})
+            return self._send_json({"ok": False, "error": "not found"}, 404)
+        except Exception as exc:
+            log("error: %s" % exc)
+            return self._send_json({"ok": False, "error": str(exc)}, 500)
+
+    def _tts(self, body):
+        text = (body.get("text") or "").strip()
+        if not text:
+            return self._send_json({"ok": False, "error": "missing text"}, 400)
+        voice = body.get("voice") or "jirka"
+        language = body.get("language") or "cs"
+        os.makedirs(OUT_DIR, exist_ok=True)
+        output = body.get("output") or os.path.join(OUT_DIR, "agent-voice-%d.wav" % int(time.time() * 1000))
+        synthesize(text, voice, language, output)
+        return self._send_json({"ok": True, "audio": output})
+
+
+if __name__ == "__main__":
+    os.makedirs(OUT_DIR, exist_ok=True)
+    server = ThreadingHTTPServer((HOST, PORT), Handler)
+    log("agent-voice worker listening on http://%s:%d" % (HOST, PORT))
+    server.serve_forever()