agent-cli 0.95.7__tar.gz → 0.95.9__tar.gz

agent_cli-0.95.9/.github/scripts/update_cask.py

@@ -0,0 +1,87 @@
+"""Update the Agent CLI Homebrew cask version and checksum."""
+
+from __future__ import annotations
+
+import argparse
+import re
+from pathlib import Path
+
+VERSION_RE = re.compile(r'^(?P<indent>\s*)version "[^"]+"$')
+SHA256_RE = re.compile(r'^(?P<indent>\s*)sha256 "[0-9a-f]{64}"$')
+
+
+def _validate_sha256(value: str) -> str:
+    if not re.fullmatch(r"[0-9a-f]{64}", value):
+        msg = "sha256 must be 64 lowercase hexadecimal characters"
+        raise ValueError(msg)
+    return value
+
+
+def _validate_version(value: str) -> str:
+    value = value.removeprefix("v")
+    if not re.fullmatch(r"\d+(?:\.\d+)*(?:[-,._A-Za-z0-9]+)?", value):
+        msg = f"unsupported cask version: {value}"
+        raise ValueError(msg)
+    return value
+
+
+def update_cask_text(text: str, *, version: str, sha256: str) -> str:
+    """Replace the single version and sha256 stanzas in a cask."""
+    version = _validate_version(version)
+    sha256 = _validate_sha256(sha256)
+
+    version_count = 0
+    sha256_count = 0
+    lines: list[str] = []
+    for source_line in text.splitlines(keepends=True):
+        newline = "\n" if source_line.endswith("\n") else ""
+        content = source_line.removesuffix("\n")
+
+        if match := VERSION_RE.match(content):
+            output_line = f'{match.group("indent")}version "{version}"{newline}'
+            version_count += 1
+        elif match := SHA256_RE.match(content):
+            output_line = f'{match.group("indent")}sha256 "{sha256}"{newline}'
+            sha256_count += 1
+        else:
+            output_line = source_line
+        lines.append(output_line)
+
+    if version_count != 1:
+        msg = f"expected exactly one version stanza, found {version_count}"
+        raise ValueError(msg)
+    if sha256_count != 1:
+        msg = f"expected exactly one sha256 stanza, found {sha256_count}"
+        raise ValueError(msg)
+
+    return "".join(lines)
+
+
+def update_cask_file(path: Path, *, version: str, sha256: str) -> None:
+    """Update a cask file in place."""
+    path.write_text(
+        update_cask_text(path.read_text(), version=version, sha256=sha256),
+        encoding="utf-8",
+    )
+
+
+def main() -> None:
+    """Run the command-line cask updater."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--cask",
+        type=Path,
+        default=Path("Casks/agent-cli.rb"),
+        help="Path to the cask file to update.",
+    )
+    parser.add_argument(
+        "--version", required=True, help="Release version, with or without v prefix."
+    )
+    parser.add_argument("--sha256", required=True, help="SHA-256 checksum for the release DMG.")
+    args = parser.parse_args()
+
+    update_cask_file(args.cask, version=args.version, sha256=args.sha256)
+
+
+if __name__ == "__main__":
+    main()

{agent_cli-0.95.7 → agent_cli-0.95.9}/.github/workflows/release.yml

@@ -64,3 +64,28 @@ jobs:
           GH_TOKEN: ${{ github.token }}
           TAG_NAME: ${{ github.event.release.tag_name }}
         run: gh release upload "$TAG_NAME" dist/macos/AgentCLI.dmg --clobber
+      - name: Update Homebrew cask
+        env:
+          TAG_NAME: ${{ github.event.release.tag_name }}
+        run: |
+          VERSION="${TAG_NAME#v}"
+          SHA256=$(shasum -a 256 dist/macos/AgentCLI.dmg | awk '{ print $1 }')
+
+          git fetch origin main
+          git switch --force-create cask-update origin/main
+
+          python3 .github/scripts/update_cask.py \
+            --version "$VERSION" \
+            --sha256 "$SHA256"
+
+          if git diff --quiet -- Casks/agent-cli.rb; then
+            echo "Casks/agent-cli.rb is already up to date."
+            exit 0
+          fi
+
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add Casks/agent-cli.rb
+          git commit -m "Update AgentCLI cask to ${TAG_NAME}"
+          git pull --rebase origin main
+          git push origin HEAD:main

agent_cli-0.95.9/Casks/agent-cli.rb

@@ -0,0 +1,29 @@
+cask "agent-cli" do
+  version "0.95.8"
+  sha256 "60273504f3c4bea181db64033790e0290bf1b53b86a1386afa3d41216a172029"
+
+  url "https://github.com/basnijholt/agent-cli/releases/download/v#{version}/AgentCLI.dmg"
+  name "Agent CLI"
+  desc "Local-first AI voice and text tools with menu bar integration"
+  homepage "https://github.com/basnijholt/agent-cli"
+
+  livecheck do
+    url :url
+    strategy :github_latest
+  end
+
+  depends_on arch: :arm64
+  depends_on macos: :ventura
+
+  app "AgentCLI.app"
+
+  uninstall launchctl: "com.agent_cli.whisper",
+            quit:      "lt.nijho.agent-cli.menubar"
+
+  zap trash: [
+    "~/Library/Application Support/AgentCLI",
+    "~/Library/LaunchAgents/com.agent_cli.whisper.plist",
+    "~/Library/Logs/agent-cli-whisper",
+    "~/Library/Preferences/lt.nijho.agent-cli.menubar.plist",
+  ]
+end

{agent_cli-0.95.7 → agent_cli-0.95.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-cli
-Version: 0.95.7
+Version: 0.95.9
 Summary: A suite of AI-powered command-line tools for text correction, audio transcription, and voice assistance.
 Project-URL: Homepage, https://github.com/basnijholt/agent-cli
 Author-email: Bas Nijholt <bas@nijho.lt>

{agent_cli-0.95.7 → agent_cli-0.95.9}/macos/AgentCLI/Sources/AgentCLI/AgentCommand.swift

@@ -1,5 +1,15 @@
 import Foundation
 
+private extension String {
+    var isVisiblyBlank: Bool {
+        unicodeScalars.allSatisfy { scalar in
+            CharacterSet.whitespacesAndNewlines.contains(scalar)
+                || scalar.properties.generalCategory == .format
+                || scalar.properties.generalCategory == .control
+        }
+    }
+}
+
 struct AgentCommand {
     let identifier: String
     let title: String
@@ -40,7 +50,7 @@ struct AgentCommand {
         guard appliesTranscriptionExtraInstructions else { return arguments }
 
         let trimmedInstructions = extraInstructions?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
-        guard !trimmedInstructions.isEmpty else { return arguments }
+        guard !trimmedInstructions.isVisiblyBlank else { return arguments }
 
         return arguments + ["--extra-instructions", trimmedInstructions]
     }

{agent_cli-0.95.7 → agent_cli-0.95.9}/macos/AgentCLI/Sources/AgentCLI/AgentCommandRunner.swift

@@ -29,9 +29,13 @@ final class AgentCommandRunner: ObservableObject {
     @Published private(set) var isRecording = false
     @Published private(set) var bootstrapPhase: BootstrapPhase = .idle
     @Published private var activeCommandCount = 0
+    @Published private var bootstrapAnimationTick = 0
+    @Published private var bootstrapElapsedSeconds = 0
     private var recordingIndicator = RecordingIndicatorController()
     private let pasteController: TranscriptPasteController
     private let bootstrap: AgentBootstrap
+    private var bootstrapAnimationTimer: Timer?
+    private var bootstrapPhaseStartedAt: Date?
     private var pendingStopRecordingCommands: Set<String> = []
     private var holdTranscriptionState: HoldTranscriptionState = .idle
     private var holdToTranscribePasteTarget: FocusedTextTarget?
@@ -47,7 +51,10 @@ final class AgentCommandRunner: ObservableObject {
             return "Recording"
         }
         if bootstrapPhase.isPreparing {
-            return bootstrapPhase.statusMessage
+            return bootstrapPhase.statusMessage(
+                animationTick: bootstrapAnimationTick,
+                elapsedSeconds: bootstrapElapsedSeconds
+            )
         }
         if holdTranscriptionState.isFinishing {
             return "Transcribing..."
@@ -122,7 +129,19 @@ final class AgentCommandRunner: ObservableObject {
     }
 
     private func reportBootstrapPhase(_ phase: BootstrapPhase) {
+        let wasPreparing = bootstrapPhase.isPreparing
+        let phaseChanged = bootstrapPhase != phase
         bootstrapPhase = phase
+        if phase.isPreparing {
+            if !wasPreparing || phaseChanged {
+                bootstrapAnimationTick = 0
+                bootstrapElapsedSeconds = 0
+                bootstrapPhaseStartedAt = Date()
+            }
+            startBootstrapAnimationTimer()
+        } else {
+            stopBootstrapAnimationTimer()
+        }
     }
 
     private func makeBootstrapProgressReporter() -> AgentBootstrapProgress {
@@ -133,6 +152,33 @@ final class AgentCommandRunner: ObservableObject {
         }
     }
 
+    private func startBootstrapAnimationTimer() {
+        guard bootstrapAnimationTimer == nil else { return }
+        let timer = Timer(timeInterval: 0.8, repeats: true) { [weak self] _ in
+            Task { @MainActor in
+                guard let self else { return }
+                guard self.bootstrapPhase.isPreparing else {
+                    self.stopBootstrapAnimationTimer()
+                    return
+                }
+                self.bootstrapAnimationTick = (self.bootstrapAnimationTick + 1) % 4
+                if let startedAt = self.bootstrapPhaseStartedAt {
+                    self.bootstrapElapsedSeconds = max(0, Int(Date().timeIntervalSince(startedAt)))
+                }
+            }
+        }
+        RunLoop.main.add(timer, forMode: .common)
+        bootstrapAnimationTimer = timer
+    }
+
+    private func stopBootstrapAnimationTimer() {
+        bootstrapAnimationTimer?.invalidate()
+        bootstrapAnimationTimer = nil
+        bootstrapAnimationTick = 0
+        bootstrapElapsedSeconds = 0
+        bootstrapPhaseStartedAt = nil
+    }
+
     @discardableResult
     func beginHoldToTranscribe() -> Bool {
         guard holdTranscriptionState == .idle else {

{agent_cli-0.95.7 → agent_cli-0.95.9}/macos/AgentCLI/Sources/AgentCLI/BootstrapState.swift

@@ -42,6 +42,37 @@ enum BootstrapPhase: Equatable {
             return "Voice service warm-up failed"
         }
     }
+
+    func statusMessage(animationTick: Int, elapsedSeconds: Int) -> String {
+        switch self {
+        case .checkingRuntime, .installingRuntime, .installingVoiceService, .waitingForVoiceService, .warmingWhisperModel:
+            let spinnerFrames = ["◐", "◓", "◑", "◒"]
+            let spinner = spinnerFrames[animationTick % spinnerFrames.count]
+            let minutes = elapsedSeconds / 60
+            let seconds = elapsedSeconds % 60
+            let elapsedTime = String(format: "%02d:%02d", minutes, seconds)
+            return "\(animatedStatusMessage) \(spinner) (\(elapsedTime))"
+        case .idle, .failed:
+            return statusMessage
+        }
+    }
+
+    private var animatedStatusMessage: String {
+        switch self {
+        case .checkingRuntime:
+            return "Checking CLI runtime"
+        case .installingRuntime:
+            return "Installing CLI runtime"
+        case .installingVoiceService:
+            return "Installing voice service"
+        case .waitingForVoiceService:
+            return "Waiting for voice service"
+        case .warmingWhisperModel:
+            return "Warming Whisper model"
+        case .idle, .failed:
+            return statusMessage
+        }
+    }
 }
 
 typealias AgentBootstrapProgress = (BootstrapPhase) -> Void

{agent_cli-0.95.7 → agent_cli-0.95.9}/macos/AgentCLI/Sources/AgentCLI/RecordingIndicatorController.swift

@@ -3,6 +3,16 @@ import Foundation
 final class RecordingIndicatorController {
     private var recordingCommandCount = 0
     private var activeRecordingCommands: [String: Int] = [:]
+    private let defaults: UserDefaults
+    private let audioCuePlayer: RecordingCuePlaying
+
+    init(
+        defaults: UserDefaults = .standard,
+        audioCuePlayer: RecordingCuePlaying = NativeRecordingCuePlayer.shared
+    ) {
+        self.defaults = defaults
+        self.audioCuePlayer = audioCuePlayer
+    }
 
     var isRecording: Bool {
         recordingCommandCount > 0
@@ -13,12 +23,17 @@ final class RecordingIndicatorController {
     }
 
     func begin(for command: AgentCommand) {
+        let wasRecording = isRecording
         activeRecordingCommands[command.identifier, default: 0] += 1
         recordingCommandCount += 1
+        if !wasRecording {
+            play(.startedRecording)
+        }
         VoiceLevelOverlayController.shared.show()
     }
 
     func end(for command: AgentCommand) {
+        let wasRecording = isRecording
         let activeCommandCount = max(0, activeRecordingCommands[command.identifier, default: 0] - 1)
         if activeCommandCount > 0 {
             activeRecordingCommands[command.identifier] = activeCommandCount
@@ -26,8 +41,14 @@ final class RecordingIndicatorController {
             activeRecordingCommands.removeValue(forKey: command.identifier)
         }
         recordingCommandCount = max(0, recordingCommandCount - 1)
-        if !isRecording {
+        if wasRecording && !isRecording {
+            play(.finishedRecording)
             VoiceLevelOverlayController.shared.hide()
         }
     }
+
+    private func play(_ event: RecordingSoundEvent) {
+        guard RecordingSoundSettings.isEnabled(defaults: defaults) else { return }
+        audioCuePlayer.play(event)
+    }
 }

agent_cli-0.95.9/macos/AgentCLI/Sources/AgentCLI/RecordingSoundSettings.swift

@@ -0,0 +1,54 @@
+import AppKit
+import Foundation
+
+enum RecordingSoundSettings {
+    static let enabledKey = "recordingNotificationSoundsEnabled"
+
+    static func isEnabled(defaults: UserDefaults = .standard) -> Bool {
+        defaults.bool(forKey: enabledKey)
+    }
+}
+
+enum RecordingSoundEvent: Hashable {
+    case startedRecording
+    case finishedRecording
+
+    var cueName: NSSound.Name {
+        switch self {
+        case .startedRecording:
+            return NSSound.Name("Frog")
+        case .finishedRecording:
+            return NSSound.Name("Funk")
+        }
+    }
+}
+
+protocol RecordingCuePlaying: AnyObject {
+    func play(_ event: RecordingSoundEvent)
+}
+
+final class NativeRecordingCuePlayer: RecordingCuePlaying {
+    static let shared = NativeRecordingCuePlayer()
+
+    private var sounds: [RecordingSoundEvent: NSSound] = [:]
+
+    private init() {}
+
+    func play(_ event: RecordingSoundEvent) {
+        guard let sound = sound(for: event) else { return }
+        sound.stop()
+        sound.currentTime = 0
+        sound.play()
+    }
+
+    private func sound(for event: RecordingSoundEvent) -> NSSound? {
+        if let sound = sounds[event] {
+            return sound
+        }
+        guard let sound = NSSound(named: event.cueName) else {
+            return nil
+        }
+        sounds[event] = sound
+        return sound
+    }
+}

{agent_cli-0.95.7 → agent_cli-0.95.9}/macos/AgentCLI/Sources/AgentCLI/Shortcuts.swift

@@ -5,10 +5,7 @@ import KeyboardShortcuts
 import SwiftUI
 
 extension KeyboardShortcuts.Name {
-    static let toggleTranscription = Self(
-        "toggleTranscription",
-        default: KeyboardShortcuts.Shortcut(carbonKeyCode: kVK_Space, carbonModifiers: kEventKeyModifierFnMask)
-    )
+    static let toggleTranscription = Self("toggleTranscription")
     static let holdToTranscribe = Self(
         "holdToTranscribe",
         default: KeyboardShortcuts.Shortcut(.function)
@@ -23,6 +20,68 @@ extension KeyboardShortcuts.Name {
     )
 }
 
+enum ToggleTranscriptionDefault {
+    static let shortcut = FunctionShortcutPersistence.rawShortcut(
+        carbonKeyCode: kVK_Space,
+        carbonModifiers: kEventKeyModifierFnMask
+    )
+
+    static func set() {
+        FunctionShortcutPersistence.set(shortcut, for: .toggleTranscription)
+    }
+
+    static func seedIfNeeded() {
+        guard !userDefaultsContainsShortcut else {
+            return
+        }
+        set()
+    }
+
+    private static var userDefaultsContainsShortcut: Bool {
+        UserDefaults.standard.object(forKey: userDefaultsKey) != nil
+    }
+
+    private static var userDefaultsKey: String {
+        "KeyboardShortcuts_\(KeyboardShortcuts.Name.toggleTranscription.rawValue)"
+    }
+}
+
+enum FunctionShortcutPersistence {
+    static func rawShortcut(carbonKeyCode: Int, carbonModifiers: Int) -> KeyboardShortcuts.Shortcut {
+        // KeyboardShortcuts' public initializer normalizes away Fn, but Codable preserves raw Carbon modifiers.
+        let shortcutJSON = """
+        {"carbonKeyCode":\(carbonKeyCode),"carbonModifiers":\(carbonModifiers)}
+        """
+        guard let data = shortcutJSON.data(using: .utf8),
+              let shortcut = try? JSONDecoder().decode(KeyboardShortcuts.Shortcut.self, from: data) else {
+            return KeyboardShortcuts.Shortcut(
+                carbonKeyCode: carbonKeyCode,
+                carbonModifiers: carbonModifiers
+            )
+        }
+        return shortcut
+    }
+
+    static func set(_ shortcut: KeyboardShortcuts.Shortcut, for name: KeyboardShortcuts.Name) {
+        KeyboardShortcuts.setShortcut(nil, for: name)
+        guard let encoded = try? JSONEncoder().encode(shortcut),
+              let encodedString = String(data: encoded, encoding: .utf8) else {
+            return
+        }
+        UserDefaults.standard.set(encodedString, forKey: userDefaultsKey(for: name))
+    }
+
+    private static func userDefaultsKey(for name: KeyboardShortcuts.Name) -> String {
+        "KeyboardShortcuts_\(name.rawValue)"
+    }
+}
+
+private extension KeyboardShortcuts.Shortcut {
+    var usesFunctionModifier: Bool {
+        carbonModifiers & kEventKeyModifierFnMask != 0
+    }
+}
+
 final class ShortcutRecordingState {
     static let shared = ShortcutRecordingState()
 
@@ -64,8 +123,8 @@ final class ShortcutSummaryState: ObservableObject {
     }
 
     func resetDefaults() {
+        ToggleTranscriptionDefault.set()
         KeyboardShortcuts.reset(
-            .toggleTranscription,
             .holdToTranscribe,
             .autocorrect,
             .voiceEdit
@@ -115,15 +174,37 @@ private enum ShortcutDisplay {
         }
 
         var carbonModifiers = shortcut.carbonModifiers
-        if event.modifierFlags.contains(.function) {
+        if event.modifierFlags.contains(.function),
+           shouldTreatFunctionFlagAsModifier(for: shortcut.carbonKeyCode) {
             carbonModifiers |= kEventKeyModifierFnMask
         }
-        return KeyboardShortcuts.Shortcut(
+
+        guard carbonModifiers & kEventKeyModifierFnMask != 0 else {
+            return KeyboardShortcuts.Shortcut(
+                carbonKeyCode: shortcut.carbonKeyCode,
+                carbonModifiers: carbonModifiers
+            )
+        }
+
+        return FunctionShortcutPersistence.rawShortcut(
             carbonKeyCode: shortcut.carbonKeyCode,
             carbonModifiers: carbonModifiers
         )
     }
 
+    private static func shouldTreatFunctionFlagAsModifier(for carbonKeyCode: Int) -> Bool {
+        !isFunctionRowKey(carbonKeyCode)
+    }
+
+    private static func isFunctionRowKey(_ carbonKeyCode: Int) -> Bool {
+        switch carbonKeyCode {
+        case kVK_F1...kVK_F20:
+            return true
+        default:
+            return false
+        }
+    }
+
     private static func label(for shortcut: KeyboardShortcuts.Shortcut, fallback: String) -> String {
         if shortcut.carbonKeyCode == kVK_Function, shortcut.carbonModifiers == 0 {
             return "Fn"
@@ -154,13 +235,19 @@ enum ShortcutDefaultsMigrator {
         migrateDefault(
             name: .toggleTranscription,
             from: KeyboardShortcuts.Shortcut(.r, modifiers: [.command, .shift]),
-            to: KeyboardShortcuts.Shortcut(carbonKeyCode: kVK_Space, carbonModifiers: kEventKeyModifierFnMask)
+            to: ToggleTranscriptionDefault.shortcut
+        )
+        migrateDefault(
+            name: .toggleTranscription,
+            from: KeyboardShortcuts.Shortcut(.space),
+            to: ToggleTranscriptionDefault.shortcut
         )
         migrateDefault(
             name: .holdToTranscribe,
             from: KeyboardShortcuts.Shortcut(.space, modifiers: [.control, .option]),
             to: KeyboardShortcuts.Shortcut(.function)
         )
+        ToggleTranscriptionDefault.seedIfNeeded()
     }
 
     private static func migrateDefault(
@@ -171,7 +258,19 @@ enum ShortcutDefaultsMigrator {
         guard KeyboardShortcuts.getShortcut(for: name) == oldShortcut else {
             return
         }
-        KeyboardShortcuts.setShortcut(newShortcut, for: name)
+        setShortcut(newShortcut, for: name)
+    }
+
+    private static func setShortcut(
+        _ shortcut: KeyboardShortcuts.Shortcut,
+        for name: KeyboardShortcuts.Name
+    ) {
+        guard name == .toggleTranscription,
+              shortcut == ToggleTranscriptionDefault.shortcut else {
+            KeyboardShortcuts.setShortcut(shortcut, for: name)
+            return
+        }
+        ToggleTranscriptionDefault.set()
     }
 }
 
@@ -179,6 +278,8 @@ struct SettingsView: View {
     @ObservedObject private var loginItemController = LoginItemController.shared
     @AppStorage(RuntimeSettings.useUserInstalledAgentCLIKey)
     private var useUserInstalledAgentCLI = false
+    @AppStorage(RecordingSoundSettings.enabledKey)
+    private var recordingSoundsEnabled = false
     @AppStorage(TranscriptionSettings.transcriptionExtraInstructionsKey)
     private var transcriptionExtraInstructions = ""
     @State private var shortcutRevision = 0
@@ -202,10 +303,11 @@ struct SettingsView: View {
                 }
 
                 Toggle("Use User-Installed agent-cli", isOn: $useUserInstalledAgentCLI)
+                Toggle("Play Recording Sounds", isOn: $recordingSoundsEnabled)
             } header: {
                 Text("General")
             } footer: {
-                Text("Runs the agent-cli found on PATH with your normal config instead of the app's private bundled-uv runtime.")
+                Text("Runs the agent-cli found on PATH with your normal config instead of the app's private bundled-uv runtime. Recording sounds use Frog when recording starts and Funk when recording ends.")
             }
 
             Section {
@@ -368,7 +470,15 @@ final class ShortcutRecorderButton: NSButton {
                 NSSound.beep()
                 return
             }
-            KeyboardShortcuts.setShortcut(shortcut, for: shortcutName)
+            if shortcut.usesFunctionModifier {
+                guard supportsFunctionChord(shortcutName) else {
+                    NSSound.beep()
+                    return
+                }
+                FunctionShortcutPersistence.set(shortcut, for: shortcutName)
+            } else {
+                KeyboardShortcuts.setShortcut(shortcut, for: shortcutName)
+            }
             stopRecording()
         }
     }
@@ -394,6 +504,10 @@ final class ShortcutRecorderButton: NSButton {
         stopRecording()
     }
 
+    private func supportsFunctionChord(_ name: KeyboardShortcuts.Name) -> Bool {
+        name == .toggleTranscription || name == .holdToTranscribe
+    }
+
     private func stopRecording() {
         if let eventMonitor {
             NSEvent.removeMonitor(eventMonitor)

{agent_cli-0.95.7 → agent_cli-0.95.9}/macos/AgentCLI/Tests/AgentCLITests/AgentCommandTests.swift

@@ -41,6 +41,13 @@ final class AgentCommandTests: XCTestCase {
         )
     }
 
+    func testVisuallyBlankExtraInstructionsAreIgnored() {
+        XCTAssertEqual(
+            AgentCommand.toggleTranscription.resolvedArguments(extraInstructions: "\u{2060}\u{FEFF}"),
+            AgentCommand.toggleTranscription.arguments
+        )
+    }
+
     func testExtraInstructionsOnlyApplyToTranscription() {
         XCTAssertEqual(
             AgentCommand.autocorrect.resolvedArguments(extraInstructions: "Remember Bas."),
@@ -140,6 +147,37 @@ final class AgentCommandTests: XCTestCase {
 
         XCTAssertEqual(recorder.calls, [.init(requirement: .transcriptionModel, force: false)])
     }
+
+    func testPreparingStatusShowsFixedWidthSpinnerAndElapsedTime() {
+        XCTAssertEqual(
+            BootstrapPhase.checkingRuntime.statusMessage(animationTick: 0, elapsedSeconds: 0),
+            "Checking CLI runtime ◐ (00:00)"
+        )
+        XCTAssertEqual(
+            BootstrapPhase.installingRuntime.statusMessage(animationTick: 1, elapsedSeconds: 12),
+            "Installing CLI runtime ◓ (00:12)"
+        )
+        XCTAssertEqual(
+            BootstrapPhase.installingVoiceService.statusMessage(animationTick: 2, elapsedSeconds: 123),
+            "Installing voice service ◑ (02:03)"
+        )
+        XCTAssertEqual(
+            BootstrapPhase.waitingForVoiceService.statusMessage(animationTick: 0, elapsedSeconds: 0),
+            "Waiting for voice service ◐ (00:00)"
+        )
+        XCTAssertEqual(
+            BootstrapPhase.waitingForVoiceService.statusMessage(animationTick: 1, elapsedSeconds: 12),
+            "Waiting for voice service ◓ (00:12)"
+        )
+        XCTAssertEqual(
+            BootstrapPhase.waitingForVoiceService.statusMessage(animationTick: 2, elapsedSeconds: 123),
+            "Waiting for voice service ◑ (02:03)"
+        )
+        XCTAssertEqual(
+            BootstrapPhase.warmingWhisperModel.statusMessage(animationTick: 3, elapsedSeconds: 4),
+            "Warming Whisper model ◒ (00:04)"
+        )
+    }
 }
 
 private struct BootstrapCall: Equatable {