an open-source alternative to the dots, bots and muses of the world, run an office of claude code/codex like agents on your laptop, sandboxes or anywhere, uses your existing subscriptions
HTML agent-harnessagent-orchestrationagentsai-agentsautonomous-agentsclaude-codecodexcoding-agentsdesktop-appdeveloper-toolselectrongemini-cliharnessharness-engineeringlocal-firstmemorymulti-agentopencodeorchestrationtypescript
docs(release): v0.3.2 — Talk to Michael (Realtime voice orchestrator)
Chaitanya Giri0e65795c2ea4
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex a54ceac1..600c1a81 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -4,6 +4,112 @@ All notable changes to this project are documented here. The format is based on[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to[Semantic Versioning](https://semver.org/spec/v2.0.0.html).+## [0.3.2] — 2026-06-27++**Talk to Michael.** The headline is **Realtime Michael** — a low-latency **voice channel to the+GOD orchestrator**, running alongside the async terminal floor. Press **Talk**, and Michael listens,+answers, and *acts* in real time: he reads the hive (tasks, board, memory, agents, activity) and —+behind spoken **echo-back confirmation** for anything destructive — creates and assigns work,+dispatches agents, spawns and kills workers, and steers the floor, all attributed to a distinct+**michael-voice** actor that pings the GOD terminal. He greets you on connect, **speaks task+completions the moment they land** ("respond when done"), and runs under a live cost meter with a+hard spend cap and an idle auto-disconnect. It's **bring-your-own OpenAI key**: the key is decrypted+**main-only**, minted into short-lived ephemeral session tokens, and never reaches the renderer. Plus+**Slack hardening** (proactive posting off by default; no sends without an explicit thread), a+dedicated **auto-compact** maintenance schedule decoupled from missions, and **per-agent environment+metadata**.++> **Live verification note.** The realtime voice loop is **human-verified end-to-end** on a real+> OpenAI key — connect → mic → Michael answers via the read tools, and the full destructive action+> path (spoken echo-back confirm → spawn / kill / dispatch → the worker appears on the floor →+> completion spoken back) was exercised live. It requires **your own OpenAI key with Realtime API+> access**; without one the **Talk** button stays visibly disabled with a "needs OpenAI key" cue.++### Added+- **Realtime Michael — talk to the GOD orchestrator by voice.** A new low-latency realtime channel+ (OpenAI Realtime API over WebRTC) sits next to the async terminal. A **Talk** toggle (on Michael's+ card and in any fullscreen terminal) opens a mic session with EC/NS/AGC, semantic-VAD turn-taking ++ barge-in, and a device picker for both microphone and speaker. Michael runs his own persona and+ answers in a natural voice, with an `Off → Connecting → Listening → Responding → Working` state+ machine surfaced live on his card (`src/renderer/src/realtime/*`, `src/main/realtime.ts`,+ `RealtimeMichaelToggle.tsx`).+- **BYOK ephemeral-token mint.** The voice session authenticates with a **short-lived ephemeral+ client secret** minted main-side from your stored OpenAI key — the real key is decrypted main-only+ and never crosses IPC. The renderer's CSP allows the WebRTC SDP exchange to reach `api.openai.com`+ while keeping everything else locked down (`src/main/realtime.ts`, renderer `index.html` CSP).+- **Voice action set with tiered echo-back confirmation.** Michael can *do* things by voice — read+ tools (tasks / board / memory / agents / activity / cost) plus the full action set: create and+ assign tasks, dispatch agents, pause / steer / halt, spawn / hire, kill, and edit schedules. Every+ **destructive** verb is gated behind a spoken **echo-back confirmation** (a distinct confirm token,+ never a bare "yes"), with hard refusals for killing the GOD agent or targeting all agents at once+ (`src/renderer/src/realtime/actions.ts`, `src/main/realtimeActions.ts`).+- **"Respond when done" completion loop.** Voice-dispatched work reports back on its own: a+ main-process completion watcher detects when a dispatched task finishes (card → done or a done+ reply in the inbox) and **proactively pushes the event into the live session so Michael speaks it+ unprompted**, while a `CompletionToast` shows it on screen. If the session is closed, completions+ queue to a desktop notification and a "completions since last session" warm-start; a `wait_for`+ tool covers the block-until-done case (`src/main/realtimeCompletionWatcher.ts`,+ `CompletionToast.tsx`).+- **michael-voice as a distinct actor.** Actions taken by voice are attributed to a separate+ **michael-voice** identity in messages, the board, and the activity log, and notify the GOD PTY —+ so a voice-driven dispatch is auditable and never silently impersonates a worker.+- **Cost guard + idle auto-disconnect for voice sessions.** A live session cost HUD by the Talk+ toggle, a configurable **spend cap** that auto-disconnects when hit, and a configurable **idle+ auto-disconnect** (default 3 min, 30 s–10 min or Off) so a forgotten-open mic can't run up a bill+ (`src/renderer/src/realtime/cost*`, **Settings → AI Engines**).+- **Greeting on connect.** When a session goes live, Michael opens with a warm, rotating greeting+ ("Hi, what's up?", "Hey, how's it going?", …) instead of waiting in silence — best-effort and+ guarded so a not-yet-ready data channel never blocks a successful connect.+- **Conversational read-layer.** The voice read tools were reworked to actually answer hive+ questions: `get_memory` no longer dead-ends, and new agent/board tools plus an expanded persona let+ Michael talk through roster, tasks, and floor state naturally.+- **Talk reachable from any fullscreen terminal.** The Talk toggle is no longer Michael-only chrome —+ it's reachable in any fullscreen terminal view (the toggle is global/session state, so it's correct+ everywhere), while the per-session cost HUD stays Michael-only (`FullscreenTerminal.tsx`).+- **OpenAI Realtime key — documented and gated.** **Settings → AI Engines** now documents the+ **OpenAI Realtime key** as its own requirement (the same OpenAI provider key, distinct from your+ Anthropic key; main mints a short-lived token from it per session). The Talk button shows a live+ enabled/disabled status and an inline **"needs OpenAI key"** cue when none is set, so connecting+ never lands on a silently-dead button (`RealtimeMichaelToggle.tsx`, `SettingsModal.tsx`,+ `AiEnginesSettings.tsx`).+- **Dedicated auto-compact maintenance schedule.** Auto-compaction is now a **persistent,+ configurable maintenance mission** of its own, decoupled from the standup mission it used to ride+ on (so editing standups can't silently drop it). It reappears disabled rather than vanishing, with+ a mandatory warning and a configurable interval in the **Schedules** tab, plus a migration+ (`src/main/schedules*`, `SchedulesTab`).+- **Per-agent environment metadata + cwd guard.** Each agent now carries queryable environment+ metadata with a working-directory validity guard, and a new agent-env query tool (`src/main/hive.ts`).++### Changed+- **"Voice" is now "Talk".** The voice feature is renamed **Talk** throughout, with a redesigned+ navigation: the GOD card pops with a dedicated **Talk** line, and the worker nav cards are+ compacted to make room (`src/renderer/src/components/*`).+- **Robust voice task-matching (findCard).** Resolving a task by voice is now tolerant of+ hyphens/punctuation, phrasing, and truncation: both the spoken phrase and the stored title are+ normalized, candidates are **scored** (exact / prefix / token-coverage / substring), and close+ matches trigger a spoken **"which one?"** disambiguation instead of silently mutating the wrong card+ (`src/main/realtimeActions.ts`, `test/realtime-findcard.test.cjs`).++### Fixed+- **Fullscreen agent modal now opens above the fullscreen view.** The Add-Agent modal launched from+ the in-fullscreen "+ agent" button rendered *behind* the fullscreen terminal (z-index 100 vs 250)+ and was non-interactive. It's lifted to the dialog tier (300) so it's on top and clickable, and the+ fullscreen Esc handler now closes the modal first instead of exiting fullscreen underneath it+ (`AddAgentModal.tsx`, `FullscreenTerminal.tsx`).+- **Voice `get_memory` no longer dead-ends.** The conversational read tools were fixed so memory+ lookups return usable answers instead of stalling the turn.++### Security+- **BYOK voice secret invariant.** The real OpenAI key is encrypted at rest and decrypted+ **main-only**; the renderer only ever sees a **short-lived ephemeral client secret** minted per+ session. The key never crosses IPC and is never logged. The voice read-layer reports **tokens, not+ dollars** (de-monetized chrome), and every destructive voice action is held behind spoken echo-back+ confirmation with hard refusals for killing the GOD agent or targeting all agents at once.+- **Slack: proactive posting off by default + explicit-thread guard.** App/voice Slack sends are now+ **off by default** behind a config flag + Settings toggle, and a request with no explicit+ channel+thread is **refused** rather than guessed — closing an unattended-broadcast path+ (`src/main/slack.ts`, Settings).+## [0.3.1] — 2026-06-22Three more coding CLIs join the floor — **OpenCode**, **Crush**, and **pi.dev** — each usable as adiff --git a/README.md b/README.mdindex 24ac2078..0dea809d 100644--- a/README.md+++ b/README.md@@ -16,7 +16,7 @@ you talk to, and visualized as avatars at work on a shared office floor.<p><a href="./LICENSE"><img alt="License: MIT" src="https://img.shields.io/badge/license-MIT-F4D35E.svg?style=flat-square&labelColor=6E1423"></a>- <a href="./CHANGELOG.md"><img alt="Version: 0.3.1" src="https://img.shields.io/badge/version-0.3.1-F4D35E.svg?style=flat-square&labelColor=6E1423"></a>+ <a href="./CHANGELOG.md"><img alt="Version: 0.3.2" src="https://img.shields.io/badge/version-0.3.2-F4D35E.svg?style=flat-square&labelColor=6E1423"></a><img alt="Status: prototype" src="https://img.shields.io/badge/status-working%20prototype-F4F1EA.svg?style=flat-square&labelColor=6E1423"><img alt="Platform: macOS | Windows | Linux" src="https://img.shields.io/badge/platform-macOS%20%7C%20Windows%20%7C%20Linux-F4F1EA.svg?style=flat-square&labelColor=6E1423"><a href="./CONTRIBUTING.md"><img alt="PRs welcome" src="https://img.shields.io/badge/PRs-welcome-F4D35E.svg?style=flat-square&labelColor=6E1423"></a>@@ -123,6 +123,7 @@ terminal/event plane, and [`DESIGN.md`](./DESIGN.md) for the visual system.| **Onboarding wizard** | First-run setup: harness home, registered repos, default command, auto-mode. || **Design system** | Fully tokenized SNES / Animal-Crossing aesthetic — pixel panels, buttons, badges, hand-drawn icons. See [`DESIGN.md`](./DESIGN.md). || **Command Center** | Michael's control surface: Terminal, Floor (roster + dispatch + per-agent model selector + live fleet monitoring), Memory (MemPalace + text search + memory graph), Activity (log + board + real token telemetry + observability + CI watcher), Tasks (kanban board with dependencies + status tracking), and a dedicated Schedules tab (recurring missions + adaptive heartbeat). |+| **Talk to Michael (Realtime Michael)** | A low-latency **voice channel to the GOD orchestrator** (OpenAI Realtime API over WebRTC), alongside the async terminal. Press **Talk** and Michael listens, answers, and *acts* in real time — reads the hive and, behind spoken **echo-back confirmation** for destructive verbs, creates/assigns tasks, dispatches, spawns/kills workers, and steers the floor (attributed to a distinct **michael-voice** actor). He greets you on connect, **speaks task completions the moment they land** ("respond when done"), and runs under a live cost meter with a hard spend cap + idle auto-disconnect. **BYOK OpenAI key** — decrypted main-only, minted into short-lived ephemeral session tokens, never read back to the renderer. || **Per-agent git worktrees** | 'Git isolation' toggle in Add Agent auto-provisions a dedicated worktree per agent on spawn and tears it down on kill — agents never collide on branches. || **Token & cost telemetry** | Activity tab reads `~/.claude/projects/` JSONL transcripts and surfaces real token counts + estimated USD cost per agent per session, backed by a durable cost ledger that survives restarts. || **Per-agent token budgets** | Set a token budget per agent and watch live fleet monitoring track consumption across the whole roster — paired with the cost/runaway circuit breaker to keep spend in check. |@@ -156,7 +157,7 @@ terminal/event plane, and [`DESIGN.md`](./DESIGN.md) for the visual system.| **Avatar states** | Avatars reflect real work — including new v0.2.0 states for *compacting* (context compaction) and *looping* (circuit-breaker intervention), on top of crisper HiDPI floor text and high-contrast speech bubbles. |> [!NOTE]-> **Status: v0.3.1 — three more engines: OpenCode · Crush · pi.dev.** The floor gains three new coding CLIs, each usable as a **worker *and* as Michael**, with **bring-your-own keys + local LLMs**. **OpenCode** wires in via a **native plugin** bridge (`session.idle`), **Crush** through a **proxy** bridge (it has no base-URL env), and **pi.dev** via a **hooks** bridge (a bundled extension maps `pi.on(event)` onto the hive, auto-approving tools only in auto mode). A new **Settings → AI Engines** panel collects per-provider **API keys** — stored **write-only** in the encrypted secret broker, materialized main-only at spawn, never read back to the renderer — plus per-engine **local base-URLs** (Ollama / LM Studio / vLLM), and Add-Agent surfaces **OSS-model quick-picks** with two local-setup guides ([open models](https://munderdiffl.in/blog/run-munder-difflin-on-open-models/) · [Mac Mini](https://munderdiffl.in/blog/run-munder-difflin-on-a-mac-mini/)). These three engines are wired end-to-end and selectable as god, but **live runtime verification with real model calls is an on-device check pending your BYOK keys / a local LLM** — mail delivery doesn't wait on it, because a new **provider-agnostic PTY-quiescence idle backstop** drains a god even if a bridge's turn-end signal never fires. Plus two reliability fixes: the **message router now survives system sleep** (re-arms and drains the backlog on wake), and **Codex workers get full filesystem + auto-approval from spawn** (parity with Claude). Built on **v0.3.0**'s platform release — **selectable agent engines** (every hire and Michael a pluggable engine with its own consented **skills + MCP catalog** behind a **consent UI**), an **integrations registry + loopback secret broker** (write-only secrets), **Slack-spawned ephemeral workers** (reply in-thread, then torn down with **worktree GC** + **per-worker token caps**, surfaced in a **Workers tab**), **temporal date-range skills**, the **Agent Gallery** with **six off-the-shelf hires**, and **wake-reliability hardening**. Everything from **v0.2.0–v0.2.8** — shareable hires, Free Flow voice dictation, the enterprise Knowledge Graph, multi-window "floors", the rich composer, agent session resume, observability, the circuit breaker, durable persistence, Command Center, task kanban, GitHub/CI integration, and the Schedules tab — remains functional and shipping. macOS (signed), Windows, and Linux builds are available on the releases page.+> **Status: v0.3.2 — Talk to Michael (Realtime Michael).** The headline is a **low-latency voice channel to the GOD orchestrator** that runs alongside the async terminal floor. Press **Talk** and Michael listens, answers, and *acts* in real time over the **OpenAI Realtime API (WebRTC)**: he reads the hive (tasks, board, memory, agents, activity) and — behind spoken **echo-back confirmation** for anything destructive — creates and assigns work, dispatches agents, spawns and kills workers, and steers the floor, all attributed to a distinct **michael-voice** actor that pings the GOD terminal. He **greets you on connect**, **speaks task completions the moment they land** ("respond when done", with an on-screen toast + closed-session warm-start), and runs under a **live cost meter with a hard spend cap and idle auto-disconnect**. It's **bring-your-own OpenAI key**: the key is decrypted **main-only**, minted into **short-lived ephemeral session tokens**, and never reaches the renderer — and **Settings → AI Engines** documents the Realtime key as its own requirement, with the **Talk** button showing a live enabled/disabled cue. The realtime loop is **human-verified end-to-end** (connect → mic → answer, plus the full spawn/kill/dispatch action path) on a real OpenAI key; it requires **your own OpenAI key with Realtime API access**. Plus **Slack hardening** (proactive app/voice posting **off by default**; no sends without an explicit channel+thread), a dedicated **auto-compact maintenance schedule** decoupled from missions, and **per-agent environment metadata**. Built on **v0.3.1** (three more engines — **OpenCode · Crush · pi.dev** — each a worker *and* Michael, with **BYOK keys + local LLMs**) and **v0.3.0**'s platform release — **selectable agent engines** (every hire and Michael a pluggable engine with its own consented **skills + MCP catalog** behind a **consent UI**), an **integrations registry + loopback secret broker** (write-only secrets), **Slack-spawned ephemeral workers**, **temporal date-range skills**, and the **Agent Gallery** with **six off-the-shelf hires**. Everything from **v0.2.0–v0.3.1** — shareable hires, Free Flow voice dictation, the enterprise Knowledge Graph, multi-window "floors", the rich composer, agent session resume, observability, the circuit breaker, durable persistence, Command Center, task kanban, GitHub/CI integration, and the Schedules tab — remains functional and shipping. macOS (signed), Windows, and Linux builds are available on the releases page.<div align="right">(<a href="#munder-difflin">↑ back to top</a>)</div>@@ -292,8 +293,9 @@ chrome. The 15 avatars are the cast of *The Office*, differentiated by hair/skin## Roadmap-Shipped in **v0.2.0–v0.3.1**:+Shipped in **v0.2.0–v0.3.2**:+- [x] **Talk to Michael — Realtime Michael (v0.3.2)** — a low-latency **voice channel to the GOD orchestrator** (OpenAI Realtime API over WebRTC) next to the async terminal. Michael listens, answers, and *acts* in real time — reading the hive and, behind spoken **echo-back confirmation** for destructive verbs, creating/assigning tasks, dispatching, spawning/killing workers, and steering the floor as a distinct **michael-voice** actor. Greets you on connect, **speaks completions** the moment they land ("respond when done"), and runs under a **live cost meter + spend cap + idle auto-disconnect**. **BYOK OpenAI key** — decrypted main-only, minted into short-lived ephemeral tokens, never read back to the renderer (requires Realtime API access; human-verified end-to-end). Plus **Slack hardening** (proactive posting off by default, no sends without an explicit thread), a dedicated **auto-compact maintenance schedule**, and **per-agent environment metadata**.- [x] **Three more engines — OpenCode · Crush · pi.dev (v0.3.1)** — each selectable as a worker *and* as Michael, via a native-plugin / proxy / hooks bridge, with **BYOK keys + local LLMs** in **Settings → AI Engines**, **OSS-model quick-picks** in Add-Agent, a **self-healing engine installer**, and a **provider-agnostic idle backstop**. Two local-setup guides: [run on open models](https://munderdiffl.in/blog/run-munder-difflin-on-open-models/) · [run on a Mac Mini](https://munderdiffl.in/blog/run-munder-difflin-on-a-mac-mini/). *(Live runtime verification with real model calls is an on-device check pending BYOK keys / a local LLM.)*- [x] **Selectable agent engines + per-hire capabilities** — a pluggable engine per hire (Claude Code / Antigravity / Codex / local provider) and a swappable Michael engine, each with its own consented skills + MCP catalog.- [x] **Integrations registry + loopback secret broker** — write-only secrets, a registry-driven Settings UI, and a first wave of declarative templates.@@ -322,7 +324,6 @@ Next up:- [ ] **More chat integrations** — Telegram and richer chat bridges that pipe a channel straight into Michael's queue (and route his replies back out), so you can run the floor from your phone.- [x] **More engines & providers** — the engine abstraction is in (Claude Code, Antigravity, Codex, local providers), and **v0.3.1 shipped OpenCode, Crush, and pi.dev** as worker+god engines with BYOK keys + local LLMs (live runtime verification pending on-device keys). Keep adding engines and broadening the per-hire capability catalog on top of it.- [ ] **More integration templates** — grow the integrations registry beyond the first-wave templates.-- [ ] **Realtime Michael** — a low-latency realtime LLM channel for quick, snappy back-and-forth with the orchestrator, alongside the async terminal.- [ ] **Fuller avatar coverage** — push the remaining station visits and tool-bubbles to be driven 100% by real Claude Code hook events.- [ ] **Durable layout & command history** — extend persistence to agent layout and per-session command history.diff --git a/blog/src/posts/launching-munder-difflin-v0-3-2.md b/blog/src/posts/launching-munder-difflin-v0-3-2.mdnew file mode 100644index 00000000..fbe5ec3a--- /dev/null+++ b/blog/src/posts/launching-munder-difflin-v0-3-2.md@@ -0,0 +1,124 @@+---+title: "Launching Munder Difflin v0.3.2: Talk to Michael, a Realtime Voice Orchestrator"+description: "Munder Difflin v0.3.2 adds Realtime Michael — a low-latency voice channel to the GOD orchestrator. Talk to Michael and he listens, answers, and acts: reading the hive and, behind spoken echo-back confirmation, dispatching, spawning, and steering the floor in real time."+date: 2026-06-27+category: story+categoryLabel: Story+type: Non-technical+primaryKeyword: "munder difflin v0.3.2"+secondaryKeywords: ["realtime voice ai orchestrator", "talk to ai agents by voice", "openai realtime api electron", "voice controlled multi-agent", "byok openai key voice agent", "voice action confirmation"]+tags: ["Story", "Release", "Multi-Agent", "Voice", "Realtime", "Open Source"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "What's new in Munder Difflin v0.3.2?"+ a: "The headline is Realtime Michael — a low-latency voice channel to the GOD orchestrator that runs alongside the async terminal floor. Press Talk and Michael listens, answers, and acts in real time over the OpenAI Realtime API (WebRTC): he reads the hive (tasks, board, memory, agents, activity) and — behind spoken echo-back confirmation for anything destructive — creates and assigns work, dispatches agents, spawns and kills workers, and steers the floor, attributed to a distinct michael-voice actor. He greets you on connect, speaks task completions the moment they land ('respond when done'), and runs under a live cost meter with a hard spend cap and idle auto-disconnect. It's bring-your-own OpenAI key, decrypted main-only and minted into short-lived ephemeral session tokens. Plus Slack hardening, a dedicated auto-compact schedule, and per-agent environment metadata."+ - q: "How does talking to Michael actually work?"+ a: "Press the Talk button (on Michael's card, or in any fullscreen terminal). Main mints a short-lived ephemeral token from your OpenAI key and the renderer opens a WebRTC voice session against the OpenAI Realtime API, with echo/noise/gain processing, semantic-VAD turn-taking and barge-in, and a device picker for your mic and speaker. Michael's card shows a live Off → Connecting → Listening → Responding → Working state. He greets you on connect, and from there it's a normal back-and-forth — except he can also act on what you ask."+ - q: "Michael can spawn and kill agents by voice — is that safe?"+ a: "Yes — safety is built into the action path. Read tools (tasks, board, memory, agents, activity, cost) run freely. Every destructive verb — create/assign, dispatch, pause/steer/halt, spawn/hire, kill, edit schedules — is gated behind spoken echo-back confirmation: Michael repeats back what he's about to do and waits for a distinct confirm token, never a bare 'yes'. Killing the GOD agent or targeting all agents at once is refused outright. And every voice action is attributed to a distinct michael-voice actor that pings the GOD terminal, so nothing happens invisibly."+ - q: "Does Michael tell me when a task finishes?"+ a: "Yes — that's the 'respond when done' loop. When you dispatch work by voice, a completion watcher detects when the task finishes (the card flips to done, or a done reply lands in the inbox) and pushes the event straight into the live session so Michael speaks it unprompted, with an on-screen toast alongside. If you've closed the session, completions queue to a desktop notification and a 'completions since last session' warm-start the next time you connect. There's also a wait_for tool for the block-until-done case."+ - q: "What do I need to use Realtime Michael?"+ a: "Your own OpenAI API key with Realtime API access. It's the same OpenAI provider key you set under Settings → AI Engines (separate from your Anthropic key). The key is encrypted at rest, decrypted only in the main process, and minted into a short-lived ephemeral token per session — it never reaches the renderer and is never logged. Without an OpenAI key the Talk button stays visibly disabled with a 'needs OpenAI key' cue. The realtime loop is human-verified end-to-end, including the full spawn/kill/dispatch action path."+ - q: "Do I still get everything from v0.3.1 and earlier?"+ a: "Yes. v0.3.2 is additive. The three v0.3.1 engines (OpenCode, Crush, pi.dev) with BYOK keys + local LLMs, selectable agent engines, the integrations registry + secret broker, Slack-spawned ephemeral workers, the Agent Gallery, Free Flow voice dictation, the enterprise Knowledge Graph, multi-window floors, observability, the circuit breaker, durable persistence, the Command Center, task kanban, GitHub/CI integration, and the Schedules tab all remain functional and shipping."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p><strong>Munder Difflin v0.3.2</strong> lets you <strong>talk to Michael</strong>. <strong>Realtime Michael</strong> is a low-latency <strong>voice channel to the GOD orchestrator</strong> (OpenAI Realtime API over WebRTC) that runs next to the async terminal floor. Press <strong>Talk</strong> and Michael listens, answers, and <em>acts</em> — reading the hive and, behind spoken <strong>echo-back confirmation</strong> for anything destructive, creating and assigning work, dispatching, spawning and killing workers, and steering the floor as a distinct <strong>michael-voice</strong> actor. He <strong>greets you on connect</strong>, <strong>speaks completions</strong> the moment they land, and runs under a <strong>live cost meter + spend cap + idle auto-disconnect</strong>. <strong>Bring your own OpenAI key</strong> — decrypted main-only, minted into short-lived ephemeral tokens, never read back to the renderer. Free, open source, local-first.</p></div>++for a while now you could *watch* the floor. you could read the board, watch envelopes fly desk-to-desk, type into a terminal, and tell Michael — the GOD orchestrator who runs the office like a regional manager who's read one management book — what to do by typing it. but you couldn't *talk* to him. the office was a thing you operated; not a thing you had a conversation with.++**v0.3.2 changes that.** press **Talk**, and Michael is on the line.++## talk to Michael: the orchestrator, out loud++the headline is **Realtime Michael** — a **low-latency voice channel to the GOD orchestrator**, running alongside the async terminal you already have. under the hood it's the **OpenAI Realtime API over WebRTC**: a real-time audio session, not a record-then-transcribe round-trip.++there's a **Talk** toggle on Michael's card (and, new this release, in *any* fullscreen terminal — more on that below). hit it and a mic session opens with the boring-but-essential audio plumbing handled for you: echo cancellation, noise suppression, gain control, **semantic-VAD turn-taking with barge-in** (you can cut him off mid-sentence, like a real conversation), and a device picker for both your microphone and your speaker. Michael's card shows a live state the whole time — `Off → Connecting → Listening → Responding → Working` — so you always know whether he's hearing you, thinking, or doing.++and he doesn't make you go first. **he greets you on connect** — a warm, rotating opener ("hi, what's up?", "hey, how's it going?") instead of an awkward silent line. small thing; makes the whole feature feel alive.++### he doesn't just answer — he acts++this is the part that feels like the future the first time. Michael isn't a read-only voice assistant bolted onto the side. he's the **orchestrator** — so when you talk to him, he can *run the floor*.++he has the full toolbox:++- 👀 **read tools** — tasks, board, memory, agents, activity, cost. "what's Pam working on?" "what's blocked?" "read me the board." these run freely.+- 🛠️ **action tools** — create and assign tasks, dispatch agents, pause / steer / halt, spawn or hire a new worker, kill one, edit schedules. the things that actually *change* the office.++obviously, "spawn a worker" and "kill that agent" are not commands you want fired off a misheard word. so every **destructive** verb is gated behind **spoken echo-back confirmation**:++> Michael repeats back exactly what he's about to do, and waits for a **distinct confirm token** — never a bare "yes". and some things he just won't do: **killing the GOD agent**, or **targeting every agent at once**, are refused outright.++and crucially, nothing happens in the shadows. every voice-driven action is attributed to a distinct **michael-voice** actor — it shows up in messages, on the board, and in the activity log, and it pings the GOD terminal. a dispatch you made by voice is as auditable as one you typed. (if you care about *why* a trust boundary like this matters for agents that can act, we wrote about [the lethal trifecta for coding agents](/blog/the-lethal-trifecta-for-coding-agents/) separately.)++## "respond when done"++here's the bit that makes voice feel like delegation instead of micromanagement. you ask Michael to dispatch some work — and then you go do something else. you don't have to sit there asking "is it done yet?"++a main-process **completion watcher** notices when the dispatched task actually finishes — the card flips to *done*, or a done reply lands in the inbox — and **pushes that straight into the live session so Michael speaks it, unprompted**. "Pam finished the changelog." an on-screen **toast** shows it too, so it's there whether or not you caught the audio.++and if you've already closed the session? the completion isn't lost. it **queues to a desktop notification**, and the next time you connect, Michael **warm-starts with the completions since you last talked**. there's also a `wait_for` tool for when you explicitly want him to block until a specific task lands.++fire-and-forget by default; tell-me-the-second-it's-done without you asking. that's the loop.++## it stays on a budget++a live voice session is a meter running. so v0.3.2 keeps it honest:++- 💸 **a live cost HUD** sits right by the Talk toggle, so the session's spend is never a mystery.+- 🧱 **a hard spend cap** auto-disconnects the session when it's hit.+- ⏳ **a configurable idle auto-disconnect** (default 3 minutes; 30s–10min, or Off) means a mic you forgot to close doesn't quietly burn money in the background.++talk freely; it won't surprise you on the bill.++## bring your own OpenAI key — and it never leaves++Realtime Michael runs on **your own OpenAI key** (with Realtime API access). it's the same OpenAI provider key you set under **Settings → AI Engines** — separate from your Anthropic key — and v0.3.2 documents it there as its own clearly-labeled requirement, with a live **enabled/disabled** status. no key set? the **Talk** button stays visibly disabled with a **"needs OpenAI key"** cue, so you never click a silently-dead button and wonder why nothing happened.++and the key handling is the careful part:++> your OpenAI key is **encrypted at rest**, decrypted **only in the main process**, and minted into a **short-lived ephemeral session token** for each connection. the real key **never crosses into the renderer** and is **never logged**. the renderer only ever holds a throwaway token good for one session.++the renderer's content-security policy is opened *just* enough to let the WebRTC handshake reach `api.openai.com`, and nothing more. it's the same write-only-secrets posture the [integrations broker](/blog/launching-munder-difflin-v0-3-0/) uses, applied to voice. (local-first people: the audio goes to OpenAI's Realtime API because that's what's doing the speech — everything else stays on your machine. that's [why local-first still matters](/blog/why-local-first-matters-for-ai-agents/) for the rest of the floor.)++the whole loop is **human-verified end-to-end** — connect, mic, answer, *and* the full spawn / kill / dispatch action path, exercised live on a real key.++## the smaller things that add up++a release with a headline this big still has a tail of quality-of-life wins:++- 🔤 **"Voice" is now "Talk".** the feature is renamed throughout, with a redesigned nav — the GOD card pops with a dedicated **Talk** line, and the worker nav cards are compacted to make room.+- 🔎 **robust voice task-matching.** ask Michael to act on a task by name and he's now tolerant of hyphens, punctuation, phrasing, and truncation — candidates are scored, and close matches trigger a spoken **"which one?"** instead of silently mutating the wrong card.+- 🖥️ **Talk from any fullscreen.** the Talk toggle is no longer Michael-only chrome; it's reachable in any fullscreen terminal view.+- 🧠 **a conversational read-layer.** the voice read tools were reworked so `get_memory` actually answers instead of dead-ending, with new agent/board tools and an expanded persona so Michael talks through roster and floor state naturally.+- 🪟 **fullscreen agent-modal stacking fix.** the Add-Agent modal opened from the in-fullscreen "+ agent" button used to render *behind* the fullscreen view and sit there un-clickable. it now opens on top and interactive, and Esc closes the modal instead of dumping you out of fullscreen.+- 🔕 **Slack hardening.** app/voice proactive Slack posting is **off by default** now (behind a config flag + Settings toggle), and a send with no explicit channel+thread is **refused** rather than guessed.+- 🗜️ **a dedicated auto-compact schedule.** context auto-compaction is its own **persistent, configurable maintenance mission** now — decoupled from the standup mission it used to ride on, so editing standups can't silently drop it.+- 🏷️ **per-agent environment metadata** — each agent carries queryable env metadata with a working-directory validity guard.++## everything from 0.3.1 is still in the box++v0.3.2 is purely **additive**. the three engines from [v0.3.1](/blog/run-munder-difflin-on-open-models/) — **OpenCode, Crush, and pi.dev**, each usable as a worker *and* as Michael, with **BYOK keys + local LLMs** — are all still here, as is everything from [v0.3.0](/blog/launching-munder-difflin-v0-3-0/) and earlier:++- 🧩 **selectable agent engines** — Claude Code, Antigravity, Codex, OpenCode, Crush, pi.dev, or a local provider, per hire and for Michael himself+- 🔐 **the integrations registry + write-only secret broker**, and **Slack-spawned ephemeral workers**+- 🎙️ **Free Flow voice dictation** (hold Option to dictate into the composer — distinct from talking *to* Michael)+- 🕸️ **the enterprise Knowledge Graph**, 🪟 **multi-window floors**, ⏯️ **session resume**, plus observability, the circuit breaker, durable persistence, the Command Center, task kanban, GitHub/CI integration, and the Schedules tab++the floor you already run — now with a regional manager you can actually call.++## get v0.3.2++Munder Difflin is **free, open source, and local-first** on macOS, Windows, and Linux. no account, no cloud for the floor itself — your machine, your subscriptions, your office.++[**Download v0.3.2**](https://github.com/chaitanyagiri/munder-difflin/releases/latest), set your OpenAI key under **Settings → AI Engines**, hit **Talk**, and ask Michael what everyone's working on. then — if you're feeling brave — tell him to spawn someone, listen to him read the plan back, and say the magic word.++curious how the orchestrator decides any of this under the hood? read [how the GOD orchestrator works](/blog/how-the-god-orchestrator-works/). want the last launch? [v0.3.0's platform release is right here](/blog/launching-munder-difflin-v0-3-0/).++full release notes live in the [CHANGELOG](https://github.com/chaitanyagiri/munder-difflin/blob/main/CHANGELOG.md).++that's it. go pick up the phone. (Michael's been waiting for someone to call.)diff --git a/package.json b/package.jsonindex e8780ebf..8f66617d 100644--- a/package.json+++ b/package.json@@ -1,6 +1,6 @@{"name": "munder-difflin",- "version": "0.3.1",+ "version": "0.3.2","private": true,"description": "Local multi-agent harness for Claude Code: autonomous agents that message, route, and remember — coordinated by a GOD orchestrator and visualized as avatars at work.","main": "out/main/index.js",