verbalcoding 0.2.11 → 0.2.12

package/app-node/agent_adapters.test.mjs

@@ -288,6 +288,8 @@ test('Claude, Codex, and Gemini adapters use backend-specific default commands w
     { backend: 'gemini', command: ['gemini', '-p'], label: 'Gemini' },
     { backend: 'opencode', command: ['opencode', 'run'], label: 'OpenCode' },
     { backend: 'openclaw', command: ['openclaw', 'run'], label: 'OpenClaw' },
+    { backend: 'aider', command: ['aider', '--no-pretty', '--yes-always', '--message'], label: 'Aider' },
+    { backend: 'cursor', command: ['cursor-agent', '--print', '--prompt'], label: 'Cursor CLI' },
   ];
 
   for (const item of cases) {
@@ -352,10 +354,20 @@ test('voiceBridgePrompt keeps voice-specific operating instructions with user te
   const prompt = voiceBridgePrompt('파일 수정해줘');
 
   assert.match(prompt, /Discord 음성 대화/);
-  assert.match(prompt, /파일 수정, 실행, 로그 확인/);
   assert.match(prompt, /파일 수정해줘/);
 });
 
+test('voiceBridgePrompt includes recent Discord text context when provided', () => {
+  const prompt = voiceBridgePrompt('왜 죽었어?', {
+    recentDiscordContext: '최근 텍스트 채널 메시지:\n- user: 음성채널에서만 나가줘',
+  });
+
+  assert.match(prompt, /음성 채널 발화와 텍스트 채널 메시지를 같은 대화 맥락으로 함께 고려/);
+  assert.match(prompt, /최근 텍스트 채널 메시지/);
+  assert.match(prompt, /음성채널에서만 나가줘/);
+  assert.match(prompt, /왜 죽었어\?/);
+});
+
 test('voiceBridgePrompt adds optional verbose progress instructions only when enabled', () => {
   const normal = voiceBridgePrompt('파일 수정해줘');
   const verbose = voiceBridgePrompt('파일 수정해줘', { verboseProgress: true });

package/app-node/agent_detect.mjs

@@ -0,0 +1,73 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+const PROBES = [
+  { backend: 'hermes', bin: 'hermes', defaultCommand: 'hermes chat -Q -q', envCommand: 'HERMES_COMMAND', label: 'Hermes Agent' },
+  { backend: 'claude', bin: 'claude', defaultCommand: 'claude -p', envCommand: 'CLAUDE_COMMAND', label: 'Claude Code' },
+  { backend: 'codex', bin: 'codex', defaultCommand: 'codex exec', envCommand: 'CODEX_COMMAND', label: 'Codex' },
+  { backend: 'gemini', bin: 'gemini', defaultCommand: 'gemini -p', envCommand: 'GEMINI_COMMAND', label: 'Gemini' },
+  { backend: 'opencode', bin: 'opencode', defaultCommand: 'opencode run', envCommand: 'OPENCODE_COMMAND', label: 'OpenCode' },
+  { backend: 'openclaw', bin: 'openclaw', defaultCommand: 'openclaw run', envCommand: 'OPENCLAW_COMMAND', label: 'OpenClaw' },
+  { backend: 'aider', bin: 'aider', defaultCommand: 'aider --no-pretty --yes-always --message', envCommand: 'AIDER_COMMAND', label: 'Aider' },
+  { backend: 'cursor', bin: 'cursor-agent', defaultCommand: 'cursor-agent --print --prompt', envCommand: 'CURSOR_COMMAND', label: 'Cursor CLI' },
+];
+
+function defaultWhich(bin, { env = process.env, accessSync = fs.accessSync } = {}) {
+  const pathVar = env.PATH || '';
+  const sep = process.platform === 'win32' ? ';' : ':';
+  const exts = process.platform === 'win32' ? (env.PATHEXT || '.EXE;.CMD;.BAT').split(';') : [''];
+  for (const dir of pathVar.split(sep)) {
+    if (!dir) continue;
+    for (const ext of exts) {
+      const candidate = path.join(dir, bin + ext);
+      try {
+        accessSync(candidate, fs.constants.X_OK);
+        return candidate;
+      } catch { /* not here */ }
+    }
+  }
+  return null;
+}
+
+export async function detectInstalledAgents(env = process.env, { which } = {}) {
+  const probe = which || ((bin) => defaultWhich(bin, { env }));
+  return Promise.all(PROBES.map(async (p) => {
+    const located = await probe(p.bin);
+    return {
+      backend: p.backend,
+      label: p.label,
+      bin: p.bin,
+      path: located || null,
+      present: Boolean(located),
+      command: env[p.envCommand] || p.defaultCommand,
+    };
+  }));
+}
+
+export function listKnownBackends() {
+  return PROBES.map(p => ({ backend: p.backend, label: p.label, bin: p.bin }));
+}
+
+export function pickDefaultBackend(detection, preferred = '') {
+  const list = Array.isArray(detection) ? detection : [];
+  const pref = String(preferred || '').toLowerCase();
+  if (pref) {
+    const match = list.find(r => r.backend === pref && r.present);
+    if (match) return match.backend;
+  }
+  const firstPresent = list.find(r => r.present);
+  if (firstPresent) return firstPresent.backend;
+  return 'hermes';
+}
+
+export function formatAgentDetectionReport(detection) {
+  const list = Array.isArray(detection) ? detection : [];
+  if (!list.length) return 'No agent backends probed.';
+  const rows = list.map(r => {
+    const marker = r.present ? '✓' : '·';
+    const pathPart = r.present ? r.path : 'not found';
+    return `  ${marker} ${r.label.padEnd(14)} ${r.bin.padEnd(14)} ${pathPart}`;
+  });
+  const presentCount = list.filter(r => r.present).length;
+  return `Agent backends (${presentCount}/${list.length} present):\n${rows.join('\n')}`;
+}

package/app-node/agent_detect.test.mjs

@@ -0,0 +1,77 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { detectInstalledAgents, listKnownBackends, pickDefaultBackend, formatAgentDetectionReport } from './agent_detect.mjs';
+
+test('detectInstalledAgents marks present when which resolves', async () => {
+  const fakeWhich = async (bin) => (bin === 'hermes' ? '/usr/local/bin/hermes' : null);
+  const result = await detectInstalledAgents({}, { which: fakeWhich });
+  const hermes = result.find(r => r.backend === 'hermes');
+  assert.equal(hermes.present, true);
+  assert.equal(hermes.path, '/usr/local/bin/hermes');
+  const claude = result.find(r => r.backend === 'claude');
+  assert.equal(claude.present, false);
+});
+
+test('detectInstalledAgents includes aider and cursor', async () => {
+  const fakeWhich = async () => null;
+  const result = await detectInstalledAgents({}, { which: fakeWhich });
+  const backends = result.map(r => r.backend);
+  assert.ok(backends.includes('aider'));
+  assert.ok(backends.includes('cursor'));
+});
+
+test('detectInstalledAgents honors env overrides for command', async () => {
+  const fakeWhich = async (bin) => (bin === 'aider' ? '/opt/aider' : null);
+  const result = await detectInstalledAgents({ AIDER_COMMAND: 'aider --foo' }, { which: fakeWhich });
+  const aider = result.find(r => r.backend === 'aider');
+  assert.equal(aider.command, 'aider --foo');
+  assert.equal(aider.present, true);
+});
+
+test('listKnownBackends returns 8 entries', () => {
+  const list = listKnownBackends();
+  assert.equal(list.length, 8);
+  assert.ok(list.some(b => b.backend === 'hermes'));
+  assert.ok(list.some(b => b.backend === 'cursor'));
+});
+
+test('detectInstalledAgents default which uses PATH iteration', async () => {
+  const result = await detectInstalledAgents({ PATH: '/nonexistent/dir' }, {});
+  assert.ok(Array.isArray(result));
+  for (const r of result) assert.equal(r.present, false);
+});
+
+test('pickDefaultBackend respects preferred when present', () => {
+  const detection = [
+    { backend: 'hermes', present: false },
+    { backend: 'claude', present: true },
+    { backend: 'aider', present: true },
+  ];
+  assert.equal(pickDefaultBackend(detection, 'aider'), 'aider');
+});
+
+test('pickDefaultBackend falls back to first present when preferred missing', () => {
+  const detection = [
+    { backend: 'hermes', present: false },
+    { backend: 'claude', present: true },
+    { backend: 'aider', present: true },
+  ];
+  assert.equal(pickDefaultBackend(detection, 'codex'), 'claude');
+});
+
+test('pickDefaultBackend returns hermes when nothing detected', () => {
+  const detection = [{ backend: 'hermes', present: false }, { backend: 'claude', present: false }];
+  assert.equal(pickDefaultBackend(detection, ''), 'hermes');
+});
+
+test('formatAgentDetectionReport marks present and missing', () => {
+  const detection = [
+    { backend: 'hermes', label: 'Hermes Agent', bin: 'hermes', present: true, path: '/usr/local/bin/hermes' },
+    { backend: 'claude', label: 'Claude Code', bin: 'claude', present: false, path: null },
+  ];
+  const out = formatAgentDetectionReport(detection);
+  assert.match(out, /1\/2 present/);
+  assert.match(out, /✓ Hermes Agent/);
+  assert.match(out, /· Claude Code/);
+  assert.match(out, /not found/);
+});

package/app-node/install_config.mjs

@@ -8,6 +8,9 @@ export const SUPPORTED_HARNESSES = [
   'gemini',
   'opencode',
   'openclaw',
+  'aider',
+  'cursor',
+  'cursor-cli',
   'custom',
 ];
 

package/app-node/main.mjs

@@ -28,6 +28,22 @@ import {
 } from './latency_metrics.mjs';
 import { splitForTTS } from './tts_chunks.mjs';
 import { playChunkedTTSWithPrefetch } from './tts_prefetch.mjs';
+import { createSentencer } from './stream_sentencer.mjs';
+import { createStreamingTTSQueue } from './streaming_tts_queue.mjs';
+import { createSmartProgressSummarizer } from './smart_progress.mjs';
+import {
+  isPlanEntryUtterance,
+  parsePlanOutput,
+  parseVoiceCommand as parsePlanVoiceCommand,
+  applyCommand as applyPlanCommand,
+  renderFinalPlan,
+  planModePreamble,
+  planExecutionPreamble,
+  parseDecisionAnswer,
+  renderDecisionPrompt,
+  renderResolvedDecisions,
+} from './plan_mode.mjs';
+import { createNotifier, buildDiscordDeepLink } from './notify.mjs';
 import { progressCategory, summarizeProgressEvents, formatProgressMessage } from './progress_speech.mjs';
 import { buildTtsSettings } from './tts_settings.mjs';
 import { createTtsBackend } from './tts_backends.mjs';
@@ -47,7 +63,11 @@ import { sendDiscordText, splitDiscordMessage } from './discord_text.mjs';
 import { progressTtsCacheFileName } from './progress_cache.mjs';
 import { shouldPassWhisperLanguage, voiceLanguageCommandFromTranscript, languagePreset } from './language_config.mjs';
 import { formatRestartCompleteNotice, formatRestartShutdownNotice } from './restart_notice.mjs';
-import { shouldRouteDiscordTextToAgent } from './text_routing.mjs';
+import {
+  appendRecentDiscordText,
+  formatRecentDiscordContext,
+  shouldRouteDiscordTextToAgent,
+} from './text_routing.mjs';
 import {
   bindProjectSessionToChannel,
   createProjectSession,
@@ -193,6 +213,7 @@ const voiceCloneCapture = createVoiceCloneCaptureState({ defaultTargetPath: sett
 let connection = null;
 let activeVoiceChannelId = '';
 let activeTranscriptChannelId = '';
+const recentDiscordTextByChannel = new Map();
 let player = createAudioPlayer();
 let speaking = false;
 let processing = false;
@@ -263,6 +284,220 @@ let progressSpeechBatch = [];
 let progressSpeechBatchTimer = null;
 let progressSpeechBatchSignal = null;
 let progressSpeechBatchStartedAt = 0;
+
+const STREAMING_TTS_ENABLED = ['1', 'true', 'yes', 'on'].includes(String(process.env.STREAMING_TTS || '0').toLowerCase());
+let activeSentencer = null;
+let activeStreamingQueue = null;
+let streamingSpeechDelivered = false;
+
+let notifyUserOptIn = false;
+let notifierInstance = null;
+function ensureNotifier() {
+  if (notifierInstance) return notifierInstance;
+  notifierInstance = createNotifier({
+    provider: (process.env.NOTIFY_PROVIDER || 'ntfy').toLowerCase(),
+    topic: process.env.NTFY_TOPIC || '',
+    pushoverUser: process.env.PUSHOVER_USER || '',
+    pushoverToken: process.env.PUSHOVER_TOKEN || '',
+  });
+  return notifierInstance;
+}
+function notifyStatusText() {
+  const provider = (process.env.NOTIFY_PROVIDER || 'ntfy').toLowerCase();
+  const hasTopic = provider === 'ntfy' ? Boolean(process.env.NTFY_TOPIC) : (provider === 'pushover' ? Boolean(process.env.PUSHOVER_USER && process.env.PUSHOVER_TOKEN) : true);
+  const mode = notifyUserOptIn ? 'always' : 'empty-channel only';
+  const config = hasTopic ? 'configured' : 'NOT configured';
+  return `notify: ${mode} via ${provider} (${config}). Threshold: ${process.env.NOTIFY_MIN_TASK_MS || '60000'}ms.`;
+}
+async function getVoiceChannelHumanCount() {
+  if (!activeVoiceChannelId) return 0;
+  try {
+    const ch = await client.channels.fetch(activeVoiceChannelId).catch(() => null);
+    if (!ch || !ch.members) return 0;
+    let count = 0;
+    for (const [, m] of ch.members) if (!m.user?.bot) count += 1;
+    return count;
+  } catch (e) {
+    warn('humanCount failed', e?.message || e);
+    return 0;
+  }
+}
+async function maybeNotifyTaskComplete({ answer, label, elapsedMs, guildId }) {
+  const provider = (process.env.NOTIFY_PROVIDER || '').toLowerCase();
+  if (!provider || provider === 'noop') return;
+  const minTaskMs = Number(process.env.NOTIFY_MIN_TASK_MS || '60000');
+  const humanCount = await getVoiceChannelHumanCount();
+  const notifier = ensureNotifier();
+  if (!notifier.shouldNotify({ humanCount, taskMs: elapsedMs, minTaskMs, userOptIn: notifyUserOptIn })) return;
+  const text = String(answer || '').trim();
+  const lastSentence = text.split(/(?<=[.!?。！？])\s+/).filter(Boolean).pop() || text;
+  const body = lastSentence.slice(0, 200);
+  const title = label ? `${label} finished` : 'VerbalCoding finished';
+  const deepLink = buildDiscordDeepLink({ guildId, channelId: activeVoiceChannelId });
+  try {
+    const result = await notifier.send({ title, body, deepLink });
+    log('notify sent', 'provider', provider, 'status', result?.status || result?.ok, 'skipped', result?.skipped || false);
+  } catch (e) {
+    warn('notify send failed', e?.message || e);
+  }
+}
+
+const planStates = new Map(); // channelId -> { steps, language }
+
+function planChannelKey() {
+  return activeVoiceChannelId || settings.transcriptChannelId || 'default';
+}
+
+async function askNextDecision(state, signal) {
+  const decision = state.decisions[state.pendingDecisionIndex];
+  if (!decision) return;
+  const text = renderDecisionPrompt(decision, state.language);
+  await sendText(`❓ ${text}`);
+  await speakText(text, signal, null);
+}
+
+async function finalizePlanReady(state, signal) {
+  const language = state.language;
+  const resolvedLine = renderResolvedDecisions(state.resolvedDecisions, language);
+  const plan = planNarrationLines(state.steps, language);
+  const tail = /^en/i.test(String(language || ''))
+    ? `${plan}\n${resolvedLine}\nSay "approve" to run, or edit with skip/insert.`
+    : `${plan}\n${resolvedLine}\n"실행"이라고 하면 시작할게. skip/insert로 수정도 돼.`;
+  await sendText(`📝 ${tail}`);
+  await speakText(tail, signal, null);
+}
+
+async function dispatchPlanModeUtterance(prompt, signal) {
+  const language = settings.voiceLanguage;
+  const key = planChannelKey();
+  const existing = planStates.get(key);
+
+  if (existing && existing.pendingDecisionIndex < existing.decisions.length) {
+    const decision = existing.decisions[existing.pendingDecisionIndex];
+    const answer = parseDecisionAnswer(prompt, decision, language);
+    if (answer.type === 'unknown') {
+      await sendText(/^en/i.test(String(language || ''))
+        ? '⚠️ I did not catch that. Please pick an option.'
+        : '⚠️ 못 알아들었어. 옵션 중에 하나 골라줘.');
+      await askNextDecision(existing, signal);
+      return { handled: true };
+    }
+    const next = {
+      ...existing,
+      resolvedDecisions: { ...existing.resolvedDecisions, [decision.slot]: answer.choice },
+      pendingDecisionIndex: existing.pendingDecisionIndex + 1,
+    };
+    planStates.set(key, next);
+    if (next.pendingDecisionIndex < next.decisions.length) {
+      await askNextDecision(next, signal);
+    } else {
+      await finalizePlanReady(next, signal);
+    }
+    return { handled: true };
+  }
+
+  if (existing) {
+    const cmd = parsePlanVoiceCommand(prompt, language);
+    if (cmd.type === 'skip' || cmd.type === 'insert') {
+      const nextSteps = applyPlanCommand(existing.steps, cmd);
+      planStates.set(key, { ...existing, steps: nextSteps });
+      await finalizePlanReady({ ...existing, steps: nextSteps }, signal);
+      return { handled: true };
+    }
+    if (cmd.type === 'cancel') {
+      planStates.delete(key);
+      const msg = /^en/i.test(String(language || '')) ? 'Plan cancelled.' : '계획을 취소했어.';
+      await sendText(`❎ ${msg}`);
+      await speakText(msg, signal, null);
+      return { handled: true };
+    }
+    if (cmd.type === 'approve') {
+      const finalPlan = renderFinalPlan(existing.steps);
+      const resolvedLine = renderResolvedDecisions(existing.resolvedDecisions, language);
+      const promptToRun = [
+        planExecutionPreamble(language),
+        '',
+        finalPlan,
+        resolvedLine,
+        '',
+        `Original user request: ${existing.originalPrompt}`,
+      ].filter(Boolean).join('\n');
+      planStates.delete(key);
+      const note = /^en/i.test(String(language || '')) ? 'Running the plan now.' : '계획대로 실행할게.';
+      await sendText(`▶ ${note}`);
+      await speakText(note, signal, null);
+      return { handled: false, prompt: promptToRun };
+    }
+    planStates.delete(key);
+    return { handled: false, prompt };
+  }
+
+  if (isPlanEntryUtterance(prompt, language)) {
+    const planPrompt = `${planModePreamble(language)}\n\nUser request: ${prompt}`;
+    const adapter = adapterForProjectSession(resolveProjectSessionForChannel(planChannelKey()));
+    const plan = { task: false, label: adapter.label, verboseProgress: false, language, projectContext: '' };
+    const result = await adapter.run(planPrompt, signal, plan).catch(e => ({ answer: '', error: e }));
+    const { steps, decisions } = parsePlanOutput(result.answer || '');
+    if (!steps.length) {
+      const failMsg = /^en/i.test(String(language || ''))
+        ? 'I could not produce a plan. Continuing as a regular turn.'
+        : '계획을 만들지 못했어. 일반 작업으로 진행할게.';
+      await sendText(`⚠️ ${failMsg}`);
+      return { handled: false, prompt };
+    }
+    const state = {
+      steps,
+      decisions,
+      resolvedDecisions: {},
+      pendingDecisionIndex: 0,
+      originalPrompt: prompt,
+      language,
+    };
+    planStates.set(planChannelKey(), state);
+    const narration = planNarrationLines(steps, language);
+    await sendText(`📝 ${narration}`);
+    await speakText(narration, signal, null);
+    if (decisions.length) {
+      await askNextDecision(state, signal);
+    } else {
+      await finalizePlanReady(state, signal);
+    }
+    return { handled: true };
+  }
+  return { handled: false, prompt };
+}
+
+function planNarrationLines(steps, language) {
+  const visible = steps.filter(s => s.status !== 'skipped');
+  const header = /^en/i.test(String(language || ''))
+    ? `Plan with ${visible.length} steps. Say "skip step N", "add X after step N", or "approve" to run.`
+    : `${visible.length}단계 계획. "step N 건너뛰어", "step N 다음에 X 추가", "실행"이라고 말해줘.`;
+  const body = visible.map((s, i) => `${i + 1}. ${s.text}`).join('\n');
+  return `${header}\n${body}`;
+}
+
+let smartProgressEnabled = Boolean(process.env.SMART_PROGRESS_API_KEY);
+let smartProgressSummarizer = null;
+function ensureSmartProgressSummarizer() {
+  if (smartProgressSummarizer) return smartProgressSummarizer;
+  smartProgressSummarizer = createSmartProgressSummarizer({
+    apiKey: process.env.SMART_PROGRESS_API_KEY || '',
+    baseUrl: process.env.SMART_PROGRESS_BASE_URL || 'https://api.groq.com/openai/v1',
+    model: process.env.SMART_PROGRESS_MODEL || 'llama-3.1-8b-instant',
+    language: settings.voiceLanguage,
+  });
+  smartProgressSummarizer.on('summary', summary => {
+    if (!summary || !activeProgressSignal) return;
+    queueVerboseProgressSpeech(summary, activeProgressSignal);
+  });
+  return smartProgressSummarizer;
+}
+function smartProgressStatusText() {
+  const hasKey = Boolean(process.env.SMART_PROGRESS_API_KEY);
+  const mode = smartProgressEnabled && hasKey ? 'on' : 'off';
+  const reason = !hasKey ? ' (no SMART_PROGRESS_API_KEY set)' : '';
+  return `smart-progress: ${mode}${reason}`;
+}
 let activeProgressLastEventAt = 0;
 let lastVerboseProgressText = '';
 let lastVerboseProgressTextAt = 0;
@@ -283,7 +518,17 @@ function createBridgeAgentAdapter(agentSettings) {
       if (!verboseProgress) return;
       activeProgressLastEventAt = Date.now();
       sendVerboseProgressText(event, activeProgressSignal);
-      queueVerboseProgressSpeech(event, activeProgressSignal);
+      if (smartProgressEnabled && process.env.SMART_PROGRESS_API_KEY) {
+        try { ensureSmartProgressSummarizer().ingest(event); }
+        catch (e) { warn('smart progress ingest failed', e?.stack || e); queueVerboseProgressSpeech(event, activeProgressSignal); }
+      } else {
+        queueVerboseProgressSpeech(event, activeProgressSignal);
+      }
+    },
+    onStdoutChunk: chunk => {
+      if (activeSentencer) {
+        try { activeSentencer.push(chunk); } catch (e) { warn('streaming sentencer push failed', e?.stack || e); }
+      }
     },
   });
 }
@@ -764,6 +1009,39 @@ async function speakText(text, signal, metricsTurn = null, options = {}) {
   metricsTurn?.stage('tts_total', Date.now() - ttsStart);
 }
 
+function beginStreamingTurn(signal) {
+  if (!STREAMING_TTS_ENABLED || !connection) return false;
+  streamingSpeechDelivered = false;
+  const sentencer = createSentencer({ minChars: 40, maxLatencyMs: 800 });
+  const queue = createStreamingTTSQueue({
+    synth: async text => synthTTS(text, signal),
+    play: async file => playAudio(file, { deleteAfter: false }),
+    cleanup: async file => { try { await fs.promises.rm(file, { force: true }); } catch {} },
+    signal,
+    log,
+  });
+  sentencer.on('sentence', text => {
+    if (signal?.aborted) return;
+    queue.enqueue(text);
+  });
+  activeSentencer = sentencer;
+  activeStreamingQueue = queue;
+  log('streaming turn begin');
+  return true;
+}
+
+async function endStreamingTurn() {
+  const sentencer = activeSentencer;
+  const queue = activeStreamingQueue;
+  activeSentencer = null;
+  activeStreamingQueue = null;
+  if (!sentencer || !queue) return;
+  try { sentencer.flush(); } catch (e) { warn('streaming sentencer flush failed', e?.stack || e); }
+  try { await queue.drain(); } catch (e) { warn('streaming queue drain failed', e?.stack || e); }
+  streamingSpeechDelivered = queue.size === 0;
+  log('streaming turn end');
+}
+
 async function speakProgress(text, signal) {
   if (signal?.aborted) return;
   try {
@@ -883,6 +1161,9 @@ async function handleTextAgentMessage(msg, text, { speakResponse = false } = {})
   activeTranscriptChannelId = session?.transcriptChannelId || msg.channelId;
   const selectedAgentAdapter = adapterForProjectSession(session);
   const projectContext = projectSessionContextText(session);
+  const recentDiscordContext = formatRecentDiscordContext(recentDiscordTextByChannel, {
+    channelId: activeTranscriptChannelId,
+  });
   const plan = {
     task: true,
     label: selectedAgentAdapter.label,
@@ -890,6 +1171,7 @@ async function handleTextAgentMessage(msg, text, { speakResponse = false } = {})
     language: settings.voiceLanguage,
     cwd: session?.workdir,
     projectContext,
+    recentDiscordContext,
   };
   const sessionBefore = selectedAgentAdapter.readSessionId?.();
   log('text agent request start', selectedAgentAdapter.label, sessionBefore ? 'resume-existing-session' : 'new-session', 'verbose', verboseProgress, session ? `project=${session.slug}` : 'project=default');
@@ -1232,8 +1514,22 @@ async function handleRecording(userId, wavPath, pcmBytes, segments = 1, metricsT
         return;
       }
     }
+    let promptForAgent = prompt;
+    try {
+      const planOutcome = await dispatchPlanModeUtterance(prompt, signal);
+      if (planOutcome.handled) {
+        metricsTurn?.finish({ status: 'plan_mode' });
+        return;
+      }
+      if (planOutcome.prompt) promptForAgent = planOutcome.prompt;
+    } catch (e) {
+      warn('plan mode dispatch failed', e?.stack || e);
+    }
     const selectedAgentAdapter = adapterForProjectSession(session);
     const projectContext = projectSessionContextText(session);
+    const recentDiscordContext = formatRecentDiscordContext(recentDiscordTextByChannel, {
+      channelId: activeTranscriptChannelId,
+    });
     const plan = {
       task: true,
       label: selectedAgentAdapter.label,
@@ -1241,6 +1537,7 @@ async function handleRecording(userId, wavPath, pcmBytes, segments = 1, metricsT
       language: settings.voiceLanguage,
       cwd: session?.workdir,
       projectContext,
+      recentDiscordContext,
     };
     log('Agent plan', plan.label, 'backend', selectedAgentAdapter.backend, 'task', plan.task, 'language', plan.language, session ? `project=${session.slug}` : 'project=default');
     const agentStart = Date.now();
@@ -1248,7 +1545,8 @@ async function handleRecording(userId, wavPath, pcmBytes, segments = 1, metricsT
     activeProgressAbortController = progressController;
     activeProgressSignal = progressController.signal;
     activeProgressLastEventAt = Date.now();
-    const agentPromise = selectedAgentAdapter.ask(prompt, signal, plan);
+    const streamingTurnActive = beginStreamingTurn(signal);
+    const agentPromise = selectedAgentAdapter.ask(promptForAgent, signal, plan);
     let done = false;
     // Status announcements share one queue with verbose progress so they never
     // talk over each other. In verbose mode, skip the generic initial prompt;
@@ -1292,6 +1590,7 @@ async function handleRecording(userId, wavPath, pcmBytes, segments = 1, metricsT
       if (!isAbortError(e)) warn('progress loop failed', e?.stack || e);
     });
     const answer = await agentPromise.finally(() => { done = true; });
+    if (streamingTurnActive) await endStreamingTurn();
     metricsTurn?.stage('agent', Date.now() - agentStart, { answerChars: String(answer || '').length, backend: selectedAgentAdapter.backend });
     void progressLoop;
     if (interruptedTurns.has(turnId) || signal.aborted) { metricsTurn?.finish({ status: 'aborted_after_agent' }); return; }
@@ -1306,7 +1605,20 @@ async function handleRecording(userId, wavPath, pcmBytes, segments = 1, metricsT
     }
     log('spoken answer', spokenAnswer.slice(0, 200));
     stopProgressSpeech(progressController.signal, 'agent-answer-ready');
-    await speakText(spokenAnswer, signal, metricsTurn, { mirrorText: !answerTextDelivered });
+    if (streamingTurnActive && streamingSpeechDelivered) {
+      log('skipping post-run speakText; streaming already delivered audio');
+    } else {
+      await speakText(spokenAnswer, signal, metricsTurn, { mirrorText: !answerTextDelivered });
+    }
+    try {
+      const guildId = client.channels.cache.get(activeVoiceChannelId)?.guild?.id || '';
+      await maybeNotifyTaskComplete({
+        answer: spokenAnswer || answer,
+        label: selectedAgentAdapter.label,
+        elapsedMs: Date.now() - agentStart,
+        guildId,
+      });
+    } catch (e) { warn('maybeNotifyTaskComplete failed', e?.message || e); }
     metricsTurn?.finish({ status: 'ok' });
   } catch (e) {
     if (isAbortError(e) || interruptedTurns.has(turnId)) {
@@ -1617,6 +1929,11 @@ client.on('messageCreate', async msg => {
   if (msg.author.bot) return;
   if (!isAllowed(msg.author.id)) return;
   const content = msg.content.trim();
+  appendRecentDiscordText(recentDiscordTextByChannel, {
+    channelId: msg.channelId,
+    authorLabel: msg.member?.displayName || msg.author?.username || 'user',
+    content,
+  });
   const projectSessionCommand = parseProjectSessionCommand(content);
   if (projectSessionCommand) {
     try {
@@ -1637,6 +1954,24 @@ client.on('messageCreate', async msg => {
     setVerboseProgress(false, 'discord-command');
     return void msg.reply(verboseStatusText());
   }
+  if (content === '!notify') return void msg.reply(notifyStatusText());
+  if (['!notify on', '!notify always', '!notify 1'].includes(content.toLowerCase())) {
+    notifyUserOptIn = true;
+    return void msg.reply(notifyStatusText());
+  }
+  if (['!notify off', '!notify auto', '!notify 0'].includes(content.toLowerCase())) {
+    notifyUserOptIn = false;
+    return void msg.reply(notifyStatusText());
+  }
+  if (content === '!smart-progress' || content === '!smart_progress') return void msg.reply(smartProgressStatusText());
+  if (['!smart-progress on', '!smart-progress true', '!smart-progress 1', '!smart_progress on'].includes(content.toLowerCase())) {
+    smartProgressEnabled = true;
+    return void msg.reply(smartProgressStatusText());
+  }
+  if (['!smart-progress off', '!smart-progress false', '!smart-progress 0', '!smart_progress off'].includes(content.toLowerCase())) {
+    smartProgressEnabled = false;
+    return void msg.reply(smartProgressStatusText());
+  }
   if (content === '!sensitivity') return void msg.reply(sensitivityStatusText());
   if (content === '!latency' || content === '!metrics') {
     const summary = summarizeLatencyRecords(readJsonlRecords(settings.latencyLogPath, { limit: 200 }));