ucode-agent 1.62.7 → 1.63.0

package/LICENSE-APACHE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -368,6 +368,7 @@ Everything after the frontmatter is the instruction.
 | `/undo` | put back every file the last turn changed |
 | `/look [url]` | open the running app and report what is on the page |
 | `/deploy [folder]` | put the app online and get its link |
+| `/mic` | say what you want instead of typing it — same as `ctrl+t` |
 | `/stats` | time, steps and tokens this session |
 | `/doctor` | check that everything ucode needs is working |
 | `/skills` | what it knows how to do, and what is loaded |
@@ -380,6 +381,18 @@ Everything after the frontmatter is the instruction.
 `↑ ↓` scroll the conversation, or walk history once you are typing ·
 `tab` completes a command
 
+### Speak instead of typing
+
+Press `ctrl+t` (or click `mic`, or type `/mic`) and say what you want —
+"make me a quiz app about planets". The chip turns red while it listens.
+`enter` stops and sends it; `ctrl+t` stops and puts the words in the box to
+check first; `esc` throws it away. It stops by itself after two minutes.
+
+Gemini writes down what you said, so nothing extra is needed beyond your key.
+Recording uses what the computer already has: Windows' built-in recorder, `sox`
+or `ffmpeg` on macOS (`brew install sox`), `arecord` or `sox` on Linux. If a
+quiet mic is taken for silence, set `UCODE_MIC_QUIET` lower than 800.
+
 ## Options
 
 ```
@@ -456,7 +469,12 @@ The tests need no network and no framework — `node test/run.js` runs them all.
 
 ## Licence
 
-MIT — see [LICENSE](LICENSE). Made with ❤️ by om dixit.
+Dual-licensed under either of, at your option:
+
+- MIT — see [LICENSE](LICENSE)
+- Apache License 2.0 — see [LICENSE-APACHE](LICENSE-APACHE)
+
+Made with ❤️ by om dixit.
 
 The edit matchers, the summary template, the context-overflow and transient-error
 patterns and tool-name repair are adapted from

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucode-agent",
-  "version": "1.62.7",
+  "version": "1.63.0",
   "description": "ucode - a terminal coding agent that reads, edits and runs your code, on Google Gemini models.",
   "type": "module",
   "main": "ucode.js",
@@ -12,7 +12,8 @@
     "src/",
     "skills/",
     "templates/",
-    "THIRD_PARTY_NOTICES.md"
+    "THIRD_PARTY_NOTICES.md",
+    "LICENSE-APACHE"
   ],
   "scripts": {
     "start": "node ucode.js",
@@ -42,7 +43,7 @@
     "ai"
   ],
   "author": "om dixit",
-  "license": "MIT",
+  "license": "(MIT OR Apache-2.0)",
   "dependencies": {
     "@babel/parser": "^7.29.9",
     "chalk": "^6.0.0",

package/src/core/loop.js

@@ -28,7 +28,7 @@ import { spawn } from 'node:child_process';
 
 import {
   ask, model, setModel, modelName, modelList, contextLimit, rateLimits,
-  estimateConversation, MODELS, DEFAULT_MODEL, PROVIDER, fallbackFor, backupFor,
+  estimateConversation, MODELS, DEFAULT_MODEL, PROVIDER, fallbackFor, backupFor, transcribe,
 } from './provider.js';
 import {
   tools, runTool, describe, setRoot, setConfirm, setRequest,
@@ -54,6 +54,7 @@ import { MAX_FILE_OUTPUT } from '../tools/shared.js';
 import { openInBrowser } from './opener.js';
 import { withScope, isNoise } from './scope.js';
 import { chooseFile, projectFiles, loadAttachments } from './attach.js';
+import { startRecording, isSilent, cleanTranscript, MAX_RECORD_MS } from './voice.js';
 import { runDoctor } from './doctor.js';
 import { JS_LOGIC } from './jslogic.js';
 import { deploy } from '../tools/deploy.js';
@@ -1028,6 +1029,7 @@ export class Agent {
       };
       this.ui.onModeChange = () => this.showHeader({ clear: false });
       this.ui.onAttach = () => { this.attachFile().catch(() => {}); };
+      this.ui.onMic = (action) => { this.mic(action).catch((err) => this.ui.error(err, { debug: this.debug })); };
     }
 
     for (const problem of this.skills.problems ?? []) {
@@ -1827,6 +1829,59 @@ export class Agent {
     }
   }
 
+  /**
+   * The mic button (ctrl+t, a click, or /mic). 'toggle' starts listening, or
+   * stops and puts the words in the box; 'send' stops and sends them; 'cancel'
+   * throws the recording away.
+   */
+  async mic(action = 'toggle') {
+    const state = this.ui.listening;
+    if (state === 'starting' || state === 'writing') return;
+
+    if (state !== 'listening') {
+      if (action !== 'toggle') return;
+      this.ui.setListening('starting');
+      try {
+        this.recording = await startRecording();
+      } catch (err) {
+        this.ui.setListening(null);
+        this.ui.note(`mic: ${err.message}`);
+        return;
+      }
+      this.ui.setListening('listening');
+      this.micTimer = setTimeout(() => this.ui.onMic?.('toggle'), MAX_RECORD_MS);
+      return;
+    }
+
+    clearTimeout(this.micTimer);
+    // Taken and the state moved on before any await, so a second press
+    // while this one finishes finds nothing to stop.
+    const recording = this.recording;
+    this.recording = null;
+    if (!recording) return;
+    if (action === 'cancel') {
+      this.ui.setListening(null);
+      this.ui.flash('stopped listening');
+      await recording.cancel();
+      return;
+    }
+
+    this.ui.setListening('writing');
+    let text = '';
+    try {
+      const wav = await recording.stop();
+      if (!wav || isSilent(wav)) {
+        this.ui.note('mic: heard nothing — check the microphone is on, then speak a little louder');
+        return;
+      }
+      text = cleanTranscript(await transcribe(wav));
+      if (!text) this.ui.note('mic: could not make out any words — try again, closer to the microphone');
+    } finally {
+      this.ui.setListening(null);
+    }
+    if (text) this.ui.insertText(text, { send: action === 'send' });
+  }
+
   /** Show a URL or a page in the project in the desktop browser (see opener.js). UCODE_OPEN=0 turns it off. */
   openInBrowser(target) {
     if (!this.full || process.env.UCODE_OPEN === '0') return false;
@@ -2961,6 +3016,9 @@ export class Agent {
       case '/doctor':   return this.cmdDoctor();
       case '/look':     return this.cmdLook(arg);
       case '/deploy':   return this.cmdDeploy(arg);
+      case '/mic':
+        if (this.ui.onMic) return this.mic('toggle');
+        return this.ui.note('the mic works in the full-screen view — start ucode in a terminal window');
       case '/exit':
       case '/quit':     return 'exit';
 
@@ -3031,6 +3089,7 @@ ${out.content}` });
       ['/doctor', 'check that everything ucode needs is working'],
       ['/look [url]', 'open the running app and report what is on the page'],
       ['/deploy [folder]', 'put the app online and get its link'],
+      ['/mic', 'say what you want instead of typing it (or ctrl+t)'],
       ['/model', 'show the models and switch between them'],
       ['/resume', 'pick up an earlier conversation'],
       ['/new', 'save this one and start fresh'],
@@ -3049,6 +3108,7 @@ ${out.content}` });
     this.ui.blank();
     this.ui.write(dim('  /models, /session and /sessions do the same as /model and /resume.'));
     this.ui.write(dim('  ctrl+b swaps plan and build · + file (or ctrl+o) adds a picture or file · esc stops a running turn · ctrl+d quits'));
+    this.ui.write(dim('  ctrl+t (or the mic button) listens: speak, then enter to send, ctrl+t to check it first, esc to cancel'));
     this.ui.blank();
   }
 

package/src/core/provider.js

@@ -276,6 +276,37 @@ export function resetConnection() {
   client = null;
 }
 
+const TRANSCRIBE_PROMPT =
+  'Transcribe the speech in this recording word for word, in the language spoken. ' +
+  'Reply with only the words spoken - no quotes, no notes. If nothing is said, reply with nothing.';
+
+/**
+ * Write down what was said in a WAV recording (the mic button). Uses the
+ * session's model, and the backup model when that one is overloaded.
+ */
+export async function transcribe(wav, { timeout = 45_000 } = {}) {
+  const request = (id) => connection().chat.completions.create({
+    model: id,
+    messages: [{
+      role: 'user',
+      content: [
+        { type: 'text', text: TRANSCRIBE_PROMPT },
+        { type: 'input_audio', input_audio: { data: wav.toString('base64'), format: 'wav' } },
+      ],
+    }],
+  }, { timeout });
+
+  let res;
+  try {
+    res = await request(current);
+  } catch (err) {
+    const backup = backupFor(current);
+    if (!backup) throw explain(err, current);
+    res = await request(backup).catch((again) => { throw explain(again, backup); });
+  }
+  return res.choices?.[0]?.message?.content ?? '';
+}
+
 // ---------------------------------------------------------------------------
 // Live quota, taken from whatever rate-limit headers come back
 // ---------------------------------------------------------------------------

package/src/core/voice.js

@@ -0,0 +1,172 @@
+/**
+ * voice.js — the mic button: say what you want instead of typing it.
+ *
+ * Recording uses what the computer already has, so there is nothing to
+ * install on Windows: its own sound recorder API (winmm, driven through
+ * PowerShell). macOS uses sox or ffmpeg, Linux arecord or sox, whichever is
+ * there. The recording is sent to the same Gemini model as everything else,
+ * which writes down what was said (see transcribe in provider.js).
+ */
+
+import { spawn } from 'node:child_process';
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+/** Longest a recording runs before it stops by itself. */
+export const MAX_RECORD_MS = 2 * 60_000;
+
+/**
+ * Loudest sample (of 32767) below which a recording counts as silence. A quiet
+ * room measured ~400 on a laptop mic, speech ~3,000 and up. UCODE_MIC_QUIET
+ * tunes it for a mic that reads differently.
+ */
+export const quietBelow = () => Number(process.env.UCODE_MIC_QUIET) || 800;
+
+// winmm's MCI strings refuse long paths (error 304), so the file sits directly
+// in the temp folder with a short name. The script says "ready" once it is
+// recording, and saves when a line arrives on stdin.
+const WINDOWS_SCRIPT = [
+  '$sig = \'[DllImport("winmm.dll", CharSet = CharSet.Unicode)] public static extern int mciSendString(string c, System.Text.StringBuilder r, int l, System.IntPtr h);\'',
+  '$w = Add-Type -MemberDefinition $sig -Name Mci -Namespace UcodeMic -PassThru',
+  'function mci($c) { $r = $w::mciSendString($c, $null, 0, [IntPtr]::Zero); if ($r -ne 0) { [Console]::Out.WriteLine("mci-error $r"); exit 1 } }',
+  'mci "open new type waveaudio alias ucodemic"',
+  'mci "set ucodemic bitspersample 16 channels 1 samplespersec 16000 bytespersec 32000 alignment 2"',
+  'mci "record ucodemic"',
+  '[Console]::Out.WriteLine("ready")',
+  '[void][Console]::In.ReadLine()',
+  'mci "stop ucodemic"',
+  'mci (\'save ucodemic "\' + $env:UCODE_MIC_FILE + \'"\')',
+  'mci "close ucodemic"',
+].join('\n');
+
+/**
+ * The recorders to try on this platform, in order. `stop` is how each is told
+ * to finish and write its file: a line on stdin, "q" on stdin, or SIGINT.
+ */
+export function recordersFor(platform, file) {
+  if (platform === 'win32') {
+    const encoded = Buffer.from(WINDOWS_SCRIPT, 'utf16le').toString('base64');
+    return [{
+      cmd: 'powershell.exe',
+      args: ['-NoProfile', '-NonInteractive', '-EncodedCommand', encoded],
+      stop: 'line',
+      saysReady: true,
+    }];
+  }
+  const sox = { cmd: 'rec', args: ['-q', '-c', '1', '-r', '16000', '-b', '16', file], stop: 'SIGINT' };
+  if (platform === 'darwin') {
+    return [sox, {
+      cmd: 'ffmpeg',
+      args: ['-loglevel', 'error', '-f', 'avfoundation', '-i', ':0', '-ac', '1', '-ar', '16000', '-y', file],
+      stop: 'q',
+    }];
+  }
+  return [{ cmd: 'arecord', args: ['-q', '-f', 'S16_LE', '-r', '16000', '-c', '1', file], stop: 'SIGINT' }, sox];
+}
+
+const NO_RECORDER = {
+  darwin: 'No recorder found. Install one with: brew install sox',
+  linux: 'No recorder found. Install one with: sudo apt install alsa-utils',
+};
+
+/** Start one recorder; resolves once it is listening, rejects with the reason it could not. */
+function launch(rec, file, run) {
+  return new Promise((resolve, reject) => {
+    const child = run(rec.cmd, rec.args, {
+      env: { ...process.env, UCODE_MIC_FILE: file },
+      windowsHide: true,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    let out = '';
+    let settled = false;
+    const done = (fn, value) => { if (!settled) { settled = true; fn(value); } };
+
+    child.on('error', (err) => done(reject, err));
+    child.stdout?.on('data', (d) => {
+      out += d;
+      if (rec.saysReady && out.includes('ready')) done(resolve, child);
+      const code = /mci-error (\d+)/.exec(out)?.[1];
+      if (code) done(reject, new Error(`Windows could not use the microphone (error ${code}). Check one is plugged in and allowed in Settings › Privacy › Microphone.`));
+    });
+    child.on('exit', (code) => done(reject, new Error(`The recorder stopped before listening (exit ${code}). Check a microphone is connected.`)));
+    if (!rec.saysReady) child.on('spawn', () => done(resolve, child));
+  });
+}
+
+/**
+ * Start recording from the default microphone.
+ * Resolves to { stop() → Promise<Buffer|null>, cancel() → Promise<void> } once listening.
+ */
+export async function startRecording({ platform = process.platform, run = spawn, dir = os.tmpdir() } = {}) {
+  // A private folder of its own, so no other user can guess or pre-place the file.
+  const folder = await fs.mkdtemp(path.join(dir, 'ucm-'));
+  const file = path.join(folder, 'mic.wav');
+  const remove = () => fs.rm(folder, { recursive: true, force: true }).catch(() => {});
+
+  let child = null;
+  let rec = null;
+  try {
+    for (const candidate of recordersFor(platform, file)) {
+      try {
+        child = await launch(candidate, file, run);
+        rec = candidate;
+        break;
+      } catch (err) {
+        if (err.code !== 'ENOENT') throw err;
+      }
+    }
+  } catch (err) {
+    await remove();
+    throw err;
+  }
+  if (!child) {
+    await remove();
+    throw new Error(NO_RECORDER[platform] ?? 'No sound recorder found on this computer.');
+  }
+
+  const closed = new Promise((resolve) => child.on('close', resolve));
+  // A recorder that will not finish is killed rather than waited on forever.
+  const finished = async () => {
+    const timer = setTimeout(() => child.kill('SIGKILL'), 10_000);
+    await closed;
+    clearTimeout(timer);
+  };
+
+  return {
+    async stop() {
+      if (rec.stop === 'line') child.stdin.write('\n');
+      else if (rec.stop === 'q') child.stdin.write('q');
+      else child.kill('SIGINT');
+      await finished();
+      const wav = await fs.readFile(file).catch(() => null);
+      await remove();
+      return wav;
+    },
+    async cancel() {
+      child.kill();
+      await finished();
+      await remove();
+    },
+  };
+}
+
+/** True when a 16-bit PCM WAV holds nothing louder than room noise, or under a third of a second. */
+export function isSilent(wav, threshold = quietBelow()) {
+  const at = wav.indexOf('data');
+  const start = at >= 0 ? at + 8 : 44;
+  if (wav.length - start < 16000 * 2 / 3) return true;
+  for (let i = start; i + 1 < wav.length; i += 2) {
+    if (Math.abs(wav.readInt16LE(i)) >= threshold) return false;
+  }
+  return true;
+}
+
+/** What the model heard, as one line for the input box: no quotes, no line breaks. */
+export function cleanTranscript(text) {
+  return String(text ?? '')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .replace(/^["'“”]+|["'“”]+$/g, '')
+    .trim();
+}

package/src/ui/screen.js

@@ -40,7 +40,7 @@ import {
   theme, blue, sky, deep, dim, edge, ADDED, REMOVED, BANNER, BANNER_WIDTH, SPINNER,
   boxTop, boxBottom, boxRow, visLen, padVis, clip, wrapAnsi,
   shortenPath, asLabel, ensureColour, planLine, bare, narration, narrationMark, groupKind, groupLabel, groupTarget, runLine, planRows, tidyReply, trimAnswer,
-  bannerPaint, RAIL, modeChip, ADD_CHIP, asNarrationLine } from './theme.js';
+  bannerPaint, RAIL, modeChip, ADD_CHIP, micChip, asNarrationLine } from './theme.js';
 import { FRAME_MS, spinnerGlyph, formatDuration, doneLine, workingLine, bannerSweep, SWEEP_MS } from './activity.js';
 import { gitBranch } from '../core/git.js';
 import { renderer, render } from './markdown.js';
@@ -60,7 +60,7 @@ export function isLabel(text) {
 export const COMMANDS = [
   '/help', '/model', '/models', '/session', '/sessions', '/resume',
   '/new', '/remember', '/skills', '/clear', '/search', '/copy', '/exit',
-  '/stats', '/doctor', '/deploy', '/look', '/undo',
+  '/stats', '/doctor', '/deploy', '/look', '/undo', '/mic',
 ];
 
 // ANSI ----------------------------------------------------------------------
@@ -215,6 +215,12 @@ export class Screen {
     this.plusTo = 0;
     this.attachments = [];
     this.onAttach = null;
+    // The mic button: null when idle, else 'starting' | 'listening' | 'writing'.
+    // Ctrl+T starts and stops it; while it listens, enter stops and sends.
+    this.micFrom = 0;
+    this.micTo = 0;
+    this.listening = null;
+    this.onMic = null;
     this.onInterrupt = null;
     this.onModeChange = null;
     this.spinTimer = null;
@@ -808,7 +814,7 @@ export class Screen {
       ['dir', value(shortenPath(this.facts.cwd ?? this.cwd, room - 10))],
       branch && ['branch', value(branch)],
       VERSION && ['version', value(this.facts.update ? `${VERSION} → ${this.facts.update} next start` : VERSION)],
-      ['keys', value('/help · esc interrupts · ctrl+b plan · ctrl+o file')],
+      ['keys', value('/help · ctrl+t mic · ctrl+o file · ctrl+b plan · esc stops')],
     ].filter(Boolean).slice(0, BANNER.length - 1);
 
     while (facts.length < BANNER.length - 1) facts.push(['', '']);
@@ -986,7 +992,8 @@ export class Screen {
   statusRow(width = this.width()) {
     const inner = width - 2;             // the space between the two borders
     const chip = this.modeChip();
-    const left = ` ${chip}  ${ADD_CHIP}  ${chalk.white(this.model || '—')}`;
+    const mic = micChip(this.listening);
+    const buttons = ` ${chip}  ${ADD_CHIP}  ${mic}`;
 
     // How long the turn has taken, back in the box beside the other two facts
     // about the session. It is not on the live line: that line says what is
@@ -996,16 +1003,24 @@ export class Screen {
     const since = this.activity?.start ?? this.status.since ?? 0;
     const running = this.busy() && since && now - since >= 1000;
     const right = `${running ? `${dim(formatDuration(now - since))}   ` : ''}${this.percentChip()} `;
+    // On a narrow terminal the model name goes before any button does.
+    const withModel = `${buttons}  ${chalk.white(this.model || '—')}`;
+    const left = visLen(withModel) + visLen(right) < inner ? withModel : buttons;
 
     // Where a click on the bottom row still counts as hitting the mode chip.
     this.chipTo = 2 + visLen(chip);
     this.plusFrom = this.chipTo + 3;                     // after the two spaces
     this.plusTo = this.plusFrom + visLen(ADD_CHIP) - 1;
+    this.micFrom = this.plusTo + 3;
+    this.micTo = this.micFrom + visLen(mic) - 1;
 
     const between = Math.max(1, inner - visLen(left) - visLen(right));
     const files = this.attachments.map((f) => path.basename(f)).join(', ');
-    const middle = this.flashText ? dim(clip(this.flashText, between - 2))
-      : files ? sky(clip(`+ ${files}`, between - 2)) : '';
+    // Room for the three spaces after it and at least one before.
+    const room = between - 4;
+    const middle = this.listening === 'listening' ? sky(clip('speak now · enter sends · ctrl+t stops · esc cancels', room))
+      : this.flashText ? dim(clip(this.flashText, room))
+        : files ? sky(clip(`+ ${files}`, room)) : '';
 
     const tail = middle ? `${middle}   ` : '';
     const pad = Math.max(1, inner - visLen(left) - visLen(tail) - visLen(right));
@@ -1430,12 +1445,30 @@ export class Screen {
       if (row !== statusRow) return;
       if (col > g.left + 1 && col <= g.left + this.chipTo) this.toggleMode();
       else if (col >= g.left + this.plusFrom && col <= g.left + this.plusTo) this.onAttach?.();
+      else if (col >= g.left + this.micFrom && col <= g.left + this.micTo) this.onMic?.('toggle');
       return;
     }
-    // The mode chip and the "+ file" button, at the left of the bottom row.
+    // The mode chip, "+ file" and mic buttons, at the left of the bottom row.
     if (row !== this.rows - 1) return;
     if (col >= 2 && col <= this.chipTo) this.toggleMode();
     else if (col >= this.plusFrom && col <= this.plusTo) this.onAttach?.();
+    else if (col >= this.micFrom && col <= this.micTo) this.onMic?.('toggle');
+  }
+
+  /** The mic's state, for the chip: null, 'starting', 'listening' or 'writing'. */
+  setListening(state) {
+    this.listening = state;
+    this.render();
+  }
+
+  /** Words from the mic, into the box at the cursor; `send` presses enter for them. */
+  insertText(text, { send = false } = {}) {
+    const before = this.buffer.slice(0, this.cursor);
+    const joined = before && !before.endsWith(' ') ? `${before} ${text}` : before + text;
+    this.buffer = joined + this.buffer.slice(this.cursor);
+    this.cursor = joined.length;
+    if (send) this.onKey('\r');
+    else this.render();
   }
 
   /** A file chosen with "+ file", to go with the next message. */
@@ -1470,6 +1503,12 @@ export class Screen {
       return;
     }
 
+    // While the mic listens, enter means "done, send it" and esc means "never mind".
+    if (this.listening === 'listening') {
+      if (key === '\r' || key === '\n') { this.onMic?.('send'); return; }
+      if (key === ESC || key === '\x03') { this.onMic?.('cancel'); return; }
+    }
+
     switch (key) {
       case '\r':
       case '\n': {
@@ -1516,6 +1555,10 @@ export class Screen {
         this.onAttach?.();
         return;
 
+      case '\x14':  // ctrl+t — the mic button: start listening, or stop and put the words in the box
+        this.onMic?.('toggle');
+        return;
+
       case '\x15':  // ctrl+u — clear the line; on an empty line, the attached files
         if (!this.buffer) this.attachments = [];
         this.buffer = this.buffer.slice(this.cursor);

package/src/ui/theme.js

@@ -130,6 +130,13 @@ export const modeChip = (mode) =>
 /** The "+ file" button beside the mode chip, in the quieter of the two chip styles. */
 export const ADD_CHIP = PLAN_CHIP(' + file ');
 
+/** The mic button beside it: quiet when idle, red while it is listening. */
+const LISTEN_CHIP = chalk.bgHex('#e5484d').hex('#ffffff').bold;
+export const micChip = (state) =>
+  state === 'listening' ? LISTEN_CHIP(' ● listening ')
+    : state ? PLAN_CHIP(` ${state === 'starting' ? 'starting' : 'writing'}… `)
+      : PLAN_CHIP(' mic ');
+
 /** The spinner. Braille dots, because they animate in place without jitter. */
 export const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];