Phase 5 refinement + Phase 6 controller for let-there-be-voice. The system is
LIVE: daemon.py
(Pocket TTS, localhost:7333), hook.py wired into Claude Code + Codex via Stop +
UserPromptSubmit hooks. Do not rebuild anything, do not touch the architecture,
no PTY wrapper, no logic back into hook.py beyond what a task below says.
Narrow, surgical changes only.

FIRST: there is good uncommitted work already in the tree (cwd-scoped /stop,
working_cwd tracking, speak_stale guard). Keep it and commit it as its own
commit before starting the tasks.

Field data behind these changes (.voice.log, first real week): 29 speaks,
median 207 chars, 10 speaks over 400 chars spoken raw (max 913, roughly a
minute of narration), condense fired only 3 times with zero failures.

TASKS, in order:

1. Condense threshold: MAX_DIRECT_CHARS 1000 -> 400 in daemon.py.

2. Token-level stripping: in strip_markdown, stop deleting whole lines that
   contain file paths, URLs, or filename.ext tokens. Remove the offending
   token from the sentence, keep the rest of the sentence. Keep dropping
   diff/traceback/code-fence lines whole as today.

3. Scoped stop, fully: in stop_speech, when a stop matches, only clear
   pending work whose cwd matches the stopping cwd. A stop from project A
   must never wipe project B's queued reply. cwd=None still means stop all.

4. Per-project pending: replace the single pending slot with a small dict
   keyed by cwd (None key allowed). Newest wins PER PROJECT; the worker
   drains all pending entries. Generation logic must stay airtight: a stale
   speak never plays after a newer stop for that cwd. Keep it simple, this
   is two concurrent projects in practice, not a job queue.

5. Condense fallback: when the summarizer fails, speak first_sentence(text)
   prefixed with a short note ("Summary failed, first line:") instead of
   the old failure constant which loses the content. first_sentence already
   exists in daemon.py, currently unused.

6. Cold-boot retry: in hook.py, if the /speak POST fails, retry once after
   ~300ms so the first reply after a full shutdown is not lost. Total worst
   case stays well under half a second; the Stop hook can afford it. Do NOT
   add retries to /stop.

7. Notification hook: handle hook_event_name == "Notification" in hook.py:
   POST /speak with a short fixed line like "<project> needs your input"
   (project = basename of cwd). Register the Notification hook for Claude
   Code in ~/.claude/settings.json alongside Stop, same command. Skip Codex
   if it has no equivalent event.

8. Wav leak: in play(), unlink the temp wav before returning when the
   generation check bails early.

9. Dead code: remove kill_player and prepare_text from daemon.py, and the
   unused urllib.error imports in both files. KEEP first_sentence (task 5
   uses it).

10. Log cap: when .voice.log exceeds ~500 lines, truncate it to the most
    recent 250 before appending.

11. /health: include model_loaded (bool), uptime_s, last_spoken_ts in the
    JSON response.

PHASE 6 - CONTROLLER (only after all Phase 5 tasks are committed + verified):
controller.html, one self-contained file in the repo, served by the daemon at
GET / on 7333 (same origin, no CORS). House skin: dark grey, border-radius 0,
Inter for text, Share Tech Mono for numbers, compact and tight. No framework,
no build step, no external assets. Plain fetch, no SSE, no websockets.

Daemon side, stdlib only:
- GET / returns controller.html from disk.
- GET /config and POST /config: MAX_DIRECT_CHARS, IDLE_EXIT_S,
  PROJECT_WINDOW_S, CONDENSE_TIMEOUT_S, afplay rate + volume, and per-agent
  voice assignments become defaults overridden by config.json in the repo
  root, hot-applied on POST, no restart. afplay rate/volume apply via
  afplay -r / -v at play time.
- GET /voices: the predefined Pocket catalog names
  (pocket_tts _ORIGINS_OF_PREDEFINED_VOICES keys).
- POST /audition {voice}: speak one fixed sentence in that voice. Cache
  voice states per name so switching stays cheap.
- GET /log/tail: recent .voice.log entries for the histogram, plus the last
  raw reply and its cleaned version (keep both in memory after each speak).

Three panels, nothing more:
1. Mixing Desk: the condense threshold as a draggable line over a histogram
   of spoken_chars from the log, live "would have condensed: N%" readout,
   plus sliders for idle exit, prefix window, summary timeout, playback
   rate, volume.
2. Strip Inspector: last reply raw beside what survived cleanup, deletions
   highlighted. The tuning surface for strip_markdown.
3. Voice Lab: dropdown of catalog voices with an audition button, per-agent
   voice assignment (claude / codex / notification), and a drop-a-wav clone
   zone rendered but DORMANT (disabled, with a one-line note) until the
   gated HF weights are set up manually. Do NOT attempt hf auth yourself.

The controller is a remote, not a brain: all behavior stays in daemon.py.
Verify Phase 6: open the controller, drag the threshold, confirm config.json
updates and a following long reply respects it without a daemon restart;
audition two voices; confirm the inspector shows the raw/cleaned pair from
the last real turn.

NIGHT SHIFT (only after Phase 6 verifies; this is an unattended overnight
run, so self-check relentlessly and never leave the tree broken):

12. smoke.sh: one script in the repo running the whole verify ritual:
    daemon health, hook smoke test from CLAUDE.md, cwd-scoped /stop, two
    overlapping project turns, kill switch on then off. Run it after every
    commit from here on; if it fails, fix before moving to the next task.

13. Error journal: wrap the daemon worker and request handlers so any
    exception lands in .voice.log as {"event":"error","trace":...}. Never
    crash the daemon for one bad speak; log and continue.

14. Personality editor: move the summarizer condense system prompt into
    config.json (default = the current prompt text), expose it via /config,
    add a textarea panel in the controller with a "re-condense last long
    reply" button so a prompt change is instantly hearable.

15. Quiet hours: config.json gains quiet_hours {"start":"HH:MM",
    "end":"HH:MM"} (absent = disabled). Inside the window /speak is
    accepted, logged as {"event":"quiet_skip"}, and stays silent. The kill
    switch and /stop are unaffected. Expose the window in the Mixing Desk.

16. Ledger panel: a fourth read-only controller panel from .voice.log:
    talk-time today (estimate from spoken_chars at ~15 chars/sec), condense
    rate, table skips, per-project utterance lanes over time. No new
    endpoint beyond /log/tail growing a limit param.

17. Notification parity, both CLIs: first verify the Claude Code
    Notification hook from task 7 actually fires on a real permission
    prompt and speaks. Then investigate whether Codex CLI has an equivalent
    event (notify config, hooks); wire it identically if yes. Record what
    you found either way in the implementation notes.

18. Notification priority: a "needs your input" line queue-jumps. It never
    waits behind a long reply mid-playback in another project: it speaks
    next, ahead of any pending replies. Do not cut off an utterance that is
    already playing for the SAME project the notification belongs to;
    interrupt other-project playback only if implementation stays simple,
    otherwise just jump the queue.

19. Config armor: a malformed or hand-mangled config.json must never
    silence the system. Validate on load and on POST /config; on any bad
    field fall back to that field's default, log
    {"event":"config_error","field":...}, keep speaking. The failure mode
    of a bad write is defaults, never mystery silence.

20. Transcript fallback: on Stop, if last_assistant_message is empty but
    transcript_path is present, parse the transcript for the last
    assistant entry and speak that. This was the original risk-table
    fallback, never built. Log {"event":"transcript_fallback"} when used.

21. voicectl: a tiny ./voice shell script in the repo: status (pretty
    /health), chill (stop current speech), shutup (create .voice-disabled), unshutup (remove it),
    say "text" (POST /speak). Stdlib/curl-level simplicity, no deps.

22. Temperature knob: expose Pocket's TTS temperature (default 0.7) in
    config.json and as a Mixing Desk slider. It is passed at generation
    time; confirm pocket_tts generate_audio_stream accepts it and wire it
    through, else note the limitation in the implementation notes and skip.

23. Docs true-up, last task of the night: update CLAUDE.md to post-run
    reality (endpoints, config.json, controller, smoke.sh, voicectl, quiet
    hours), and stamp the running git rev into /health so "which daemon
    build is running" is never a guess.

End the pass by writing short implementation notes: what landed, what failed,
what you skipped and why, plus anything surprising in the logs. Plain prose,
short.

INVARIANTS, never break these ("no config UI" was amended 2026-07-06 to
permit exactly this controller, nothing more):
- Hook exits fast and never blocks the agent turn; silence over noise: any
  failure means no sound and exit 0, never leak errors into the session.
- Never speak code, diffs, stack traces, or raw file paths.
- New input in a project kills that project's speech instantly; stale speech
  never resurrects after an interrupt.
- SHUT UP: .voice-disabled in the repo root blocks everything.
- Everything local except the optional summarizer condense call; only the daemon
  touches the network or the token.
- Keep it small: no framework, no native app packaging, no tests beyond the bench
  script. The controller is the only UI, and it stays one file. Personal
  tool, not a product.

VERIFY when done: run the hook smoke test from CLAUDE.md, then one real
Claude Code turn and one real Codex turn, then two overlapping turns from two
different project directories to prove per-project pending and scoped stop
actually behave.

Commits: the pre-existing scoped-stop work first, then one commit per task or
sensible small groups, plain messages. Phase 6 lands as its own commit(s)
only after Phase 5 is verified end to end, and the Night Shift only after
Phase 6 does. Run smoke.sh before every commit once it exists.

Phase 9 for let-there-be-voice: turn the controller into a TTS shootout bench
so I can compare three engines, learn, pick the best, and remove the losers.
The system is LIVE and must keep working throughout. Read build-packet.html
section 14 for the full spec. Do not break the live voice path: Pocket stays
the default engine until I pick a winner in the UI.

FOUNDATION FIRST (task 0, its own commit):
Refactor synthesis behind an engine abstraction. Today ENGINE = "pocket" and
speak() calls Pocket directly. Introduce a small registry where each engine
exposes the same interface: load() (lazy), voices() -> list of names,
synth(text, voice) -> yields int16 PCM chunks at the engine's sample_rate.
Move today's Pocket code behind it UNCHANGED in behavior; the live path,
smoke.sh, cloning, and the controller must all still pass exactly as now.
config gains "engine" (default "pocket") validated against installed engines.

KOKORO SECOND (prove it before touching Supertonic):
Add Kokoro-82M as an engine (kokoro pip package, Apache-2.0, PyTorch, happy on
MPS). Expose its ~54 voices via voices(). Synth to int16 PCM chunks. If the
package is not installed, the engine reports "not installed" with the pip/uv
command, never crashes. Once Kokoro synthesizes and plays through the existing
pipeline, wire the controller bench (below) and stop. Do NOT add Supertonic in
the same run.

CONTROLLER BENCH (features 2,3,5,6,8,9 from section 14):
- GET /engines: [{name, installed, loaded, rss_mb}]. POST /engine {name}: set
  active, hot-applied, saved to config. POST /bench {text, voice?}: synthesize
  the text on every installed engine, return per-engine {clip_id, rtf,
  ttfa_s, synth_s, duration_s, rss_mb}. Audition/speak take an optional engine.
- Readiness cards (9): per-engine installed / loaded / RAM, install command
  when missing.
- Shootout (2): a text box, a "compare" button, plays each engine's clip on
  demand, reuse the replay ring for the clips.
- Metrics scoreboard (3): the /bench numbers in a live per-engine table. RTF =
  synth_s / duration_s, measured in the daemon (resource.getrusage for RAM,
  perf_counter for timing). RTF below 1.0 = faster than realtime.
- Blind A/B/C (5): play the three clips unlabeled in random order, let me
  score each, then reveal which engine was which.
- Per-engine voices (6): the Voice Lab dropdowns and catalog reflect the
  ACTIVE engine's voices, not a shared list.
- Winner + cleanup (8): a "keep this engine" control that sets the default and
  prints the uninstall / file-removal steps for the other engines. Do NOT run
  the removal yourself; just show the commands.

SUPERTONIC LAST (only after the Kokoro shootout works end to end):
Add Supertonic-3 via sherpa-onnx as a third engine behind the same interface,
then it joins the shootout automatically.

INVARIANTS: the live voice path never regresses; Pocket default until I pick;
engines lazy-load and idle-exit as today; stdlib daemon plus the engine
packages, no web framework; controller stays one self-contained file and a
remote, not a brain; run smoke.sh before every commit and keep it green.

VERIFY: smoke.sh green, one real Claude turn still speaks via Pocket, then a
bench run comparing Pocket vs Kokoro on the same sentence with real RTF
numbers. One commit per meaningful step, plain messages. When done, update
CLAUDE.md and this packet per the docs-sweep note.