Document one shared runner per host [skip ci]

fix: isolate CI Keychain access from the production app
fix: launch CI smoke app through macOS Launch Services
2026-09-10 09:05:04 +02:00 · 2026-09-10 00:33:30 +02:00 · 2026-09-10 00:25:09 +02:00 · 2026-09-10 00:08:31 +02:00 · 2026-09-09 23:56:02 +02:00 · 2026-09-09 23:51:29 +02:00
24 changed files with 836 additions and 488 deletions
@@ -9,7 +9,7 @@ on:

 jobs:
  macos:
-    runs-on: macos-15
+    runs-on: macos-arm64
    steps:
      - uses: actions/checkout@v4
      - name: Build Meetingnotes
@@ -22,6 +22,7 @@ jobs:
          -derivedDataPath "$RUNNER_TEMP/DerivedData"
          ARCHS="arm64 x86_64"
          ONLY_ACTIVE_ARCH=NO
+          PRODUCT_BUNDLE_IDENTIFIER=net.jamesbone.meetingnotes.ci
          CODE_SIGNING_ALLOWED=NO
          build
      - name: Sign test build
@@ -34,28 +35,15 @@ jobs:
          codesign -d --entitlements :- "$app_path" 2>&1 \
            | grep -q 'com.apple.security.network.server'
      - name: Smoke test local API
-        run: |
-          defaults write net.jamesbone.meetingnotes muteDeckAPIEnabled -bool true
-          defaults write net.jamesbone.meetingnotes muteDeckAPIPort -int 19880
-          "$RUNNER_TEMP/DerivedData/Build/Products/Release/Meetingnotes.app/Contents/MacOS/Meetingnotes" >"$RUNNER_TEMP/meetingnotes.log" 2>&1 &
-          app_pid=$!
-          trap 'kill "$app_pid" 2>/dev/null || true' EXIT
-
-          for _ in {1..20}; do
-            if curl -fsS http://127.0.0.1:19880/api/info >"$RUNNER_TEMP/api-info.json"; then
-              break
-            fi
-            sleep 1
-          done
-
-          grep -q '"name":"MeetingDebrief"' "$RUNNER_TEMP/api-info.json"
-          test "$(curl -sS -o /dev/null -w '%{http_code}' http://127.0.0.1:19880/api/recording/status)" = "401"
+        run: python3 scripts/smoke_test_api.py "$RUNNER_TEMP/DerivedData/Build/Products/Release/Meetingnotes.app"
      - name: Package test build
+        if: always()
        run: |
          app_path="$RUNNER_TEMP/DerivedData/Build/Products/Release/Meetingnotes.app"
          ditto -c -k --sequesterRsrc --keepParent \
            "$app_path" "$RUNNER_TEMP/Meetingnotes-macOS.zip"
      - name: Upload test build
+        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: Meetingnotes-macOS-${{ github.sha }}
@@ -0,0 +1,47 @@
+name: Release
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: Version from MARKETING_VERSION, without the v prefix
+        required: true
+        type: string
+permissions:
+  contents: write
+concurrency:
+  group: meetingnotes-release
+  cancel-in-progress: false
+jobs:
+  release:
+    runs-on: macos-arm64
+    env:
+      VERSION: ${{ inputs.version }}
+      RELEASE_BASE_URL: https://git.jamesbone.net/coder/meetingnotes
+      APPLE_ID: ${{ secrets.APPLE_ID }}
+      APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
+      APPLE_APP_PASSWORD: ${{ secrets.APPLE_APP_PASSWORD }}
+      SPARKLE_PRIVATE_KEY: ${{ secrets.SPARKLE_PRIVATE_KEY }}
+    steps:
+      - name: Require main
+        run: test "$GITHUB_REF" = refs/heads/main
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Build, sign, and notarize release
+        timeout-minutes: 45
+        env:
+          APPLE_CERTIFICATE_P12: ${{ secrets.APPLE_CERTIFICATE_P12 }}
+          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
+        run: python3 scripts/with_signing_identity.py scripts/package_release.sh
+      - name: Preserve signed release artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: meetingnotes-signed-release-${{ github.run_id }}
+          path: ${{ runner.temp }}/meetingnotes-release/release
+          if-no-files-found: error
+          retention-days: 30
+      - name: Publish Gitea release
+        env:
+          GITEA_SERVER_URL: ${{ github.server_url }}
+          GITEA_TOKEN: ${{ github.token }}
+        run: python3 scripts/publish_gitea_release.py
@@ -1,92 +0,0 @@
-name: Finalize Notarization (manual)
-
-on:
-  workflow_dispatch:
-    inputs:
-      release_run_id:
-        description: Release workflow run ID; leave blank to use the latest pending run
-        required: false
-        type: string
-
-permissions:
-  actions: read
-  contents: write
-
-concurrency:
-  group: meetingnotes-finalize-release
-  cancel-in-progress: false
-
-jobs:
-  finalize:
-    if: github.event_name != 'workflow_run' || github.event.workflow_run.conclusion == 'success'
-    runs-on: macos-15
-    env:
-      APPLE_ID: ${{ secrets.APPLE_ID }}
-      APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
-      APPLE_APP_PASSWORD: ${{ secrets.APPLE_APP_PASSWORD }}
-      SPARKLE_PRIVATE_KEY: ${{ secrets.SPARKLE_PRIVATE_KEY }}
-      GH_TOKEN: ${{ github.token }}
-    steps:
-      - uses: actions/checkout@v7
-
-      - name: Validate release secrets
-        run: |
-          for variable in APPLE_ID APPLE_TEAM_ID APPLE_APP_PASSWORD SPARKLE_PRIVATE_KEY; do
-            if [[ -z "${!variable:-}" ]]; then
-              echo "Missing GitHub Actions secret: $variable" >&2
-              exit 1
-            fi
-          done
-
-      - name: Download pending signed build
-        id: submission
-        env:
-          MANUAL_RUN_ID: ${{ inputs.release_run_id }}
-          COMPLETED_RUN_ID: ${{ github.event.workflow_run.id }}
-        run: |
-          PENDING_DIR="$RUNNER_TEMP/meetingnotes-pending"
-          candidate_ids=()
-          if [[ -n "${MANUAL_RUN_ID:-}" ]]; then
-            candidate_ids+=("$MANUAL_RUN_ID")
-          elif [[ -n "${COMPLETED_RUN_ID:-}" ]]; then
-            candidate_ids+=("$COMPLETED_RUN_ID")
-          else
-            while IFS= read -r run_id; do
-              candidate_ids+=("$run_id")
-            done < <(gh run list --repo "$GITHUB_REPOSITORY" --workflow Release --status success --limit 20 --json databaseId --jq '.[].databaseId')
-          fi
-
-          for run_id in "${candidate_ids[@]}"; do
-            if [[ ! "$run_id" =~ ^[0-9]+$ ]]; then
-              echo "Invalid release run ID: $run_id" >&2
-              exit 1
-            fi
-
-            artifact_name="meetingnotes-notarization-$run_id"
-            artifact_count=$(gh api "repos/$GITHUB_REPOSITORY/actions/runs/$run_id/artifacts" \
-              --jq "[.artifacts[] | select(.name == \"$artifact_name\" and .expired == false)] | length")
-            if [[ "$artifact_count" == 0 ]]; then
-              continue
-            fi
-
-            rm -rf "$PENDING_DIR"
-            mkdir -p "$PENDING_DIR"
-            gh run download "$run_id" --repo "$GITHUB_REPOSITORY" --name "$artifact_name" --dir "$PENDING_DIR"
-
-            version=$(<"$PENDING_DIR/version")
-            if gh release view "v$version" --repo "$GITHUB_REPOSITORY" >/dev/null 2>&1; then
-              continue
-            fi
-
-            echo "found=true" >> "$GITHUB_OUTPUT"
-            echo "run_id=$run_id" >> "$GITHUB_OUTPUT"
-            echo "Using release submission from workflow run $run_id"
-            exit 0
-          done
-
-          echo "found=false" >> "$GITHUB_OUTPUT"
-          echo "No pending release submission was found"
-
-      - name: Check notarization and publish when accepted
-        if: steps.submission.outputs.found == 'true'
-        run: scripts/finalize_release.sh
@@ -1,88 +0,0 @@
-name: Release
-
-on:
-  workflow_dispatch:
-    inputs:
-      version:
-        description: Version from MARKETING_VERSION, without the v prefix
-        required: true
-        type: string
-
-permissions:
-  contents: write
-
-concurrency:
-  group: meetingnotes-release
-  cancel-in-progress: false
-
-jobs:
-  release:
-    runs-on: macos-15
-    env:
-      VERSION: ${{ inputs.version }}
-      APPLE_ID: ${{ secrets.APPLE_ID }}
-      APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
-      APPLE_APP_PASSWORD: ${{ secrets.APPLE_APP_PASSWORD }}
-      SPARKLE_PRIVATE_KEY: ${{ secrets.SPARKLE_PRIVATE_KEY }}
-    steps:
-      - uses: actions/checkout@v7
-        with:
-          fetch-depth: 0
-
-      - name: Validate release secrets
-        env:
-          APPLE_CERTIFICATE_P12: ${{ secrets.APPLE_CERTIFICATE_P12 }}
-          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
-        run: |
-          for variable in APPLE_CERTIFICATE_P12 APPLE_CERTIFICATE_PASSWORD APPLE_ID APPLE_TEAM_ID APPLE_APP_PASSWORD SPARKLE_PRIVATE_KEY; do
-            if [[ -z "${!variable:-}" ]]; then
-              echo "Missing GitHub Actions secret: $variable" >&2
-              exit 1
-            fi
-          done
-
-      - name: Import Developer ID certificate
-        uses: apple-actions/import-codesign-certs@v7
-        with:
-          p12-file-base64: ${{ secrets.APPLE_CERTIFICATE_P12 }}
-          p12-password: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
-
-      - name: Locate Developer ID identity
-        run: |
-          signing_identity=$(security find-identity -v -p codesigning | awk -F '"' '/Developer ID Application/{print $2; exit}')
-          if [[ -z "$signing_identity" ]]; then
-            echo "The .p12 does not contain a Developer ID Application identity" >&2
-            exit 1
-          fi
-          echo "SIGNING_IDENTITY=$signing_identity" >> "$GITHUB_ENV"
-
-      - name: Build, sign, and notarize release
-        timeout-minutes: 30
-        run: scripts/package_release.sh
-
-      - name: Preserve signed release artifacts
-        uses: actions/upload-artifact@v4
-        with:
-          name: meetingnotes-signed-release-${{ github.run_id }}
-          path: ${{ runner.temp }}/meetingnotes-release/release
-          if-no-files-found: error
-          retention-days: 30
-
-      - name: Publish signed GitHub release
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          tag="v$VERSION"
-          if gh release view "$tag" >/dev/null 2>&1; then
-            gh release upload "$tag" \
-              "$RUNNER_TEMP/meetingnotes-release/release/Meetingnotes-$VERSION.zip" \
-              "$RUNNER_TEMP/meetingnotes-release/release/appcast.xml" \
-              --clobber
-          else
-            gh release create "$tag" \
-              "$RUNNER_TEMP/meetingnotes-release/release/Meetingnotes-$VERSION.zip" \
-              "$RUNNER_TEMP/meetingnotes-release/release/appcast.xml" \
-              --target "$GITHUB_SHA" \
-              --title "Meetingnotes $VERSION" \
-              --generate-notes
-          fi
@@ -276,7 +276,7 @@
 				CODE_SIGN_IDENTITY = "Apple Development";
 				CODE_SIGN_STYLE = Automatic;
 				COMBINE_HIDPI_IMAGES = YES;
-				CURRENT_PROJECT_VERSION = 38;
+				CURRENT_PROJECT_VERSION = 45;
 				DEVELOPMENT_ASSET_PATHS = "\"meetingnotes/Preview Content\"";
 				DEVELOPMENT_TEAM = G9LVHZAJNX;
 				ENABLE_HARDENED_RUNTIME = YES;
@@ -290,7 +290,7 @@
 					"@executable_path/../Frameworks",
 				);
 				MACOSX_DEPLOYMENT_TARGET = 15.0;
-				MARKETING_VERSION = 1.1.26;
+				MARKETING_VERSION = 1.1.33;
 				ONLY_ACTIVE_ARCH = NO;
 				OTHER_SWIFT_FLAGS = "$(inherited) -D ENABLE_TCC_SPI";
 				PRODUCT_BUNDLE_IDENTIFIER = net.jamesbone.meetingnotes;
@@ -312,7 +312,7 @@
 				CODE_SIGN_IDENTITY = "Apple Development";
 				CODE_SIGN_STYLE = Automatic;
 				COMBINE_HIDPI_IMAGES = YES;
-				CURRENT_PROJECT_VERSION = 38;
+				CURRENT_PROJECT_VERSION = 45;
 				DEVELOPMENT_ASSET_PATHS = "\"meetingnotes/Preview Content\"";
 				DEVELOPMENT_TEAM = G9LVHZAJNX;
 				ENABLE_HARDENED_RUNTIME = YES;
@@ -326,7 +326,7 @@
 					"@executable_path/../Frameworks",
 				);
 				MACOSX_DEPLOYMENT_TARGET = 15.0;
-				MARKETING_VERSION = 1.1.26;
+				MARKETING_VERSION = 1.1.33;
 				ONLY_ACTIVE_ARCH = YES;
 				OTHER_SWIFT_FLAGS = "$(inherited) -D ENABLE_TCC_SPI";
 				PRODUCT_BUNDLE_IDENTIFIER = net.jamesbone.meetingnotes;
@@ -46,7 +46,7 @@ Later:
 ## Releasing a New Version

 Production releases are Developer ID signed, notarized by Apple, published to
-GitHub Releases, and signed for Sparkle auto-updates.
+[Gitea Releases](https://git.jamesbone.net/coder/meetingnotes/releases), and signed for Sparkle auto-updates.

 ### Release Process

@@ -68,12 +68,12 @@ GitHub Releases, and signed for Sparkle auto-updates.

 2. Commit and push the version change to `main`.

-3. Run the `Release` workflow from GitHub Actions and enter the version without
+3. Run the `Release` workflow from Gitea Actions on `main` and enter the version without
   the `v` prefix. The workflow signs and notarizes the app, generates the
   signed appcast, creates the version tag, and publishes both release assets.

 The app checks
-`https://github.com/superdooper86/meetingnotes/releases/latest/download/appcast.xml`
+`https://git.jamesbone.net/coder/meetingnotes/releases/download/latest/appcast.xml`
 and installs later releases automatically through Sparkle.

 ### Recovering Meetings
@@ -82,3 +82,20 @@ The first Developer ID signed build may not automatically inherit data from an
 older ad-hoc signed build. In Settings, use **Import Meetings...** and select the
 old `Meetings` folder. After this one-time transition, the stable signing
 identity keeps the same sandbox container across updates.
+
+### Build runner and GitHub transition
+
+`.gitea/workflows/build.yml` builds universal macOS artifacts for pushes and pull
+requests to `main`. The shared account-scoped `mac-mini` runner uses the
+`macos-arm64` label. Smoke tests use a separate CI bundle identifier and temporary
+launch preferences and an internal-volume staging directory. Keychain services
+follow the bundle identifier, so CI never reads production credentials; the smoke
+test removes its isolated API token before and after each launch. Release jobs import the original Developer ID certificate
+into a temporary keychain and keep the original Sparkle signing key in Gitea
+Actions secrets. They never publish from a development branch.
+
+Version 1.1.33 moves the embedded update feed to Gitea. After its notarized archive
+is verified, replace the `appcast.xml` asset on the last GitHub release with the
+new appcast. Existing installations discover the Gitea download through that old
+GitHub feed; after installing it, they check Gitea directly. Keep the old GitHub
+repository and its release appcast available for installations that update later.
@@ -14,7 +14,7 @@
 	<key>NSMicrophoneUsageDescription</key>
 	<string>Meetingnotes needs access to your microphone for transcription.</string>
 	<key>SUFeedURL</key>
-	<string>https://github.com/superdooper86/meetingnotes/releases/latest/download/appcast.xml</string>
+	<string>https://git.jamesbone.net/coder/meetingnotes/releases/download/latest/appcast.xml</string>
 	<key>SUPublicEDKey</key>
 	<string>9ZuN9G9ERB3Qoyyd/4FsF+6LMUv5jzAGP26OXAHBiW0=</string>
 	<key>SUEnableAutomaticChecks</key>
@@ -20,6 +20,27 @@ private enum RecoveryTranscriptionError: LocalizedError {
    }
 }

+private struct SystemCaptureDiagnostics {
+    var tapAdvertisedFormat = "unavailable"
+    var aggregateInputFormat = "unavailable"
+    var selectedInputFormat = "unavailable"
+    var targetFormat = "unavailable"
+    var selectedInputSampleRate: Double?
+    var targetSampleRate: Double?
+    var inputRateInference = "unavailable"
+    var firstBufferLayout: String?
+    var callbackCount: UInt64 = 0
+    var inputFrameCount: UInt64 = 0
+    var outputFrameCount: UInt64 = 0
+    var discardedCallbackCount: UInt64 = 0
+    var firstSampleTime: Double?
+    var lastSampleTime: Double?
+    var firstHostTime: UInt64?
+    var lastHostTime: UInt64?
+    var firstCallbackAt: Date?
+    var lastCallbackAt: Date?
+}
+
 /// Captures microphone and system audio locally, then sends completed files to Coder.
@MainActor
 final class AudioManager: NSObject, ObservableObject {
@@ -50,8 +71,9 @@ final class AudioManager: NSObject, ObservableObject {
    private var micAudioURL: URL?
    private var systemAudioURL: URL?
    private var recordingStartedAt = Date()
+    private var systemDiagnostics = SystemCaptureDiagnostics()

-    private override init() {
+    override init() {
        super.init()
        observeAudioEngine()
    }
@@ -67,6 +89,7 @@ final class AudioManager: NSObject, ObservableObject {
        sessionID = UUID()
        self.meetingID = meetingID
        recordingStartedAt = Date()
+        systemDiagnostics = SystemCaptureDiagnostics()
        do {
            try prepareAudioFiles()
            startMicrophoneTap()
@@ -79,6 +102,7 @@ final class AudioManager: NSObject, ObservableObject {

    func stopRecordingAndTranscribe() async -> [TranscriptChunk] {
        let completedMeetingID = meetingID
+        let completedSessionID = sessionID
        let captureStartedAt = recordingStartedAt
        let files = stopCaptureAndCloseFiles()
        isProcessing = true
@@ -86,11 +110,20 @@ final class AudioManager: NSObject, ObservableObject {
            isProcessing = false
        }

-        repairHalfDurationSystemWAVIfNeeded(in: files)
+        let preRepairFileSummaries = files.map(audioFileSummary)
+        let repairApplied = repairHalfDurationSystemWAVIfNeeded(in: files)
        let completedFiles = files.compactMap { $0 }
        let audioFolder = preserveAudioFiles(completedFiles, meetingID: completedMeetingID)
        let transcriptionFiles = preservedAudioFiles(files, in: audioFolder)
        lastRecoveryAudioFolderName = audioFolder?.lastPathComponent
+        writeCaptureDiagnostics(
+            sessionID: completedSessionID,
+            captureStartedAt: captureStartedAt,
+            preRepairFileSummaries: preRepairFileSummaries,
+            repairedFiles: transcriptionFiles,
+            repairApplied: repairApplied,
+            audioFolder: audioFolder
+        )
        if let mismatch = captureDurationMismatch(in: transcriptionFiles) {
            let recoveryMessage = audioFolder == nil
                ? " The audio remains in the app's temporary folder."
@@ -405,18 +438,76 @@ final class AudioManager: NSObject, ObservableObject {
              advertisedInputFormat.sampleRate > 0 else {
            throw NSError(domain: "AudioManager", code: -1, userInfo: [NSLocalizedDescriptionKey: "Unsupported system audio format"])
        }
+        systemDiagnostics.tapAdvertisedFormat = streamDescriptionSummary(tap.tapAdvertisedStreamDescription)
+        systemDiagnostics.aggregateInputFormat = streamDescriptionSummary(tap.aggregateInputStreamDescription)
+        systemDiagnostics.targetFormat = audioFormatSummary(targetFormat)
+        systemDiagnostics.targetSampleRate = targetFormat.sampleRate
        var inputFormat: AVAudioFormat?
        var converter: AVAudioConverter?
-        try tap.run(on: tapQueue) { [weak self] _, inputData, _, _, _ in
+        var pendingBuffer: AVAudioPCMBuffer?
+        var pendingInputTime: AudioTimeStamp?
+        var pendingNow: AudioTimeStamp?
+        try tap.run(on: tapQueue) { [weak self] inNow, inputData, inInputTime, _, _ in
            guard let self else { return }
            if inputFormat == nil {
+                guard let callbackFormat = self.inputFormat(
+                    for: inputData,
+                    sampleRate: advertisedInputFormat.sampleRate
+                ),
+                let currentBuffer = self.copyAudioBuffer(from: inputData, format: callbackFormat) else {
+                    self.systemDiagnostics.discardedCallbackCount += 1
+                    return
+                }
+
+                guard let previousBuffer = pendingBuffer,
+                      let previousInputTime = pendingInputTime,
+                      let previousNow = pendingNow else {
+                    pendingBuffer = currentBuffer
+                    pendingInputTime = inInputTime.pointee
+                    pendingNow = inNow.pointee
+                    return
+                }
+
+                let selectedSampleRate = self.effectiveInputSampleRate(
+                    advertisedSampleRate: advertisedInputFormat.sampleRate,
+                    previousFrameLength: previousBuffer.frameLength,
+                    previousTimestamp: previousInputTime,
+                    currentTimestamp: inInputTime.pointee,
+                    previousHostTimestamp: previousNow,
+                    currentHostTimestamp: inNow.pointee
+                )
                inputFormat = self.inputFormat(
                    for: inputData,
-                    advertisedFormat: advertisedInputFormat
+                    sampleRate: selectedSampleRate
                )
                if let inputFormat {
+                    self.systemDiagnostics.selectedInputFormat = self.audioFormatSummary(inputFormat)
+                    self.systemDiagnostics.selectedInputSampleRate = inputFormat.sampleRate
                    converter = AVAudioConverter(from: inputFormat, to: targetFormat)
                }
+
+                guard let inputFormat, let converter else { return }
+                self.processAudioBuffer(
+                    { self.copyAudioBuffer(from: previousBuffer.audioBufferList, format: inputFormat) },
+                    converter: converter,
+                    targetFormat: targetFormat,
+                    source: .system,
+                    callbackTimestamp: previousInputTime,
+                    ioTimestamp: pendingNow
+                )
+                pendingBuffer = nil
+                pendingInputTime = nil
+                pendingNow = nil
+
+                self.processAudioBuffer(
+                    { self.copyAudioBuffer(from: currentBuffer.audioBufferList, format: inputFormat) },
+                    converter: converter,
+                    targetFormat: targetFormat,
+                    source: .system,
+                    callbackTimestamp: inInputTime.pointee,
+                    ioTimestamp: inNow.pointee
+                )
+                return
            }
            guard let inputFormat, let converter else { return }
            // The tap queue is serial. Reusing the converter preserves its
@@ -425,7 +516,9 @@ final class AudioManager: NSObject, ObservableObject {
                { self.copyAudioBuffer(from: inputData, format: inputFormat) },
                converter: converter,
                targetFormat: targetFormat,
-                source: .system
+                source: .system,
+                callbackTimestamp: inInputTime.pointee,
+                ioTimestamp: inNow.pointee
            )
        } invalidationHandler: { [weak self] _ in
            guard let self, self.isRecording else { return }
@@ -435,7 +528,7 @@ final class AudioManager: NSObject, ObservableObject {

    private func inputFormat(
        for inputData: UnsafePointer<AudioBufferList>,
-        advertisedFormat: AVAudioFormat
+        sampleRate: Double
    ) -> AVAudioFormat? {
        let buffers = UnsafeMutableAudioBufferListPointer(
            UnsafeMutablePointer(mutating: inputData)
@@ -443,38 +536,106 @@ final class AudioManager: NSObject, ObservableObject {
        let channelCount = buffers.reduce(UInt32(0)) { $0 + $1.mNumberChannels }
        guard channelCount > 0 else { return nil }

-        // HAL tap metadata can advertise interleaved stereo while the callback
-        // supplies one mono buffer per channel (or the reverse). Constructing a
-        // PCM buffer with that mismatched layout halves its frame count and
-        // produces 2x-speed system audio. The callback's AudioBufferList is the
-        // authoritative layout for the memory we are copying.
+        // HAL I/O proc samples use the canonical Float32 representation. The
+        // tap's stream description can advertise a different common format;
+        // using that to interpret the callback bytes can halve the frame count
+        // (for example, treating four-byte Float32 samples as eight-byte
+        // Float64 samples). The callback's AudioBufferList is authoritative for
+        // its channel layout, while its sample rate comes from the input stream.
        let isInterleaved = buffers.count == 1 && channelCount > 1
        return AVAudioFormat(
-            commonFormat: advertisedFormat.commonFormat,
-            sampleRate: advertisedFormat.sampleRate,
+            commonFormat: .pcmFormatFloat32,
+            sampleRate: sampleRate,
            channels: AVAudioChannelCount(channelCount),
            interleaved: isInterleaved
        )
    }

+    private func effectiveInputSampleRate(
+        advertisedSampleRate: Double,
+        previousFrameLength: AVAudioFrameCount,
+        previousTimestamp: AudioTimeStamp,
+        currentTimestamp: AudioTimeStamp,
+        previousHostTimestamp: AudioTimeStamp,
+        currentHostTimestamp: AudioTimeStamp
+    ) -> Double {
+        let sampleTimeDelta = currentTimestamp.mSampleTime - previousTimestamp.mSampleTime
+        guard advertisedSampleRate > 0, previousFrameLength > 0 else {
+            systemDiagnostics.inputRateInference = "advertised (invalid advertised rate or frame count)"
+            return advertisedSampleRate
+        }
+
+        guard currentHostTimestamp.mHostTime > previousHostTimestamp.mHostTime else {
+            systemDiagnostics.inputRateInference = "advertised (host timestamps unavailable)"
+            return advertisedSampleRate
+        }
+        let hostTimeDelta = currentHostTimestamp.mHostTime - previousHostTimestamp.mHostTime
+        let hostNanoseconds = AudioConvertHostTimeToNanos(hostTimeDelta)
+        guard hostNanoseconds > 0 else {
+            systemDiagnostics.inputRateInference = "advertised (host-time conversion failed)"
+            return advertisedSampleRate
+        }
+
+        let inferredSampleRate = Double(previousFrameLength) * 1_000_000_000 / Double(hostNanoseconds)
+        let plausibleRange = (advertisedSampleRate * 0.25)...(advertisedSampleRate * 1.25)
+        guard inferredSampleRate.isFinite, plausibleRange.contains(inferredSampleRate) else {
+            systemDiagnostics.inputRateInference = String(
+                format: "advertised (invalid host inference %.3f from %u frames / %llu ns; sampleTimeDelta=%.3f)",
+                inferredSampleRate,
+                previousFrameLength,
+                hostNanoseconds,
+                sampleTimeDelta
+            )
+            return advertisedSampleRate
+        }
+
+        let commonSampleRates: [Double] = [8_000, 11_025, 12_000, 16_000, 22_050, 24_000, 32_000, 44_100, 48_000, 88_200, 96_000]
+        let selectedSampleRate = commonSampleRates
+            .min(by: { abs($0 - inferredSampleRate) < abs($1 - inferredSampleRate) })
+            .flatMap { abs($0 - inferredSampleRate) / $0 <= 0.01 ? $0 : nil }
+            ?? inferredSampleRate
+        systemDiagnostics.inputRateInference = String(
+            format: "source=hostTime,advertised=%.3f,inferred=%.3f,selected=%.3f,previousFrames=%u,hostNanoseconds=%llu,sampleTimeDelta=%.3f",
+            advertisedSampleRate,
+            inferredSampleRate,
+            selectedSampleRate,
+            previousFrameLength,
+            hostNanoseconds,
+            sampleTimeDelta
+        )
+        return selectedSampleRate
+    }
+
    private func copyAudioBuffer(
        from inputData: UnsafePointer<AudioBufferList>,
        format: AVAudioFormat
    ) -> AVAudioPCMBuffer? {
-        guard let borrowedBuffer = AVAudioPCMBuffer(
-            pcmFormat: format,
-            bufferListNoCopy: inputData,
-            deallocator: nil
-        ), borrowedBuffer.frameLength > 0,
-        let ownedBuffer = AVAudioPCMBuffer(
-            pcmFormat: format,
-            frameCapacity: borrowedBuffer.frameLength
-        ) else { return nil }
-
-        ownedBuffer.frameLength = borrowedBuffer.frameLength
        let sourceBuffers = UnsafeMutableAudioBufferListPointer(
            UnsafeMutablePointer(mutating: inputData)
        )
+        if systemDiagnostics.firstBufferLayout == nil {
+            systemDiagnostics.firstBufferLayout = sourceBuffers.enumerated().map { index, buffer in
+                "buffer\(index):channels=\(buffer.mNumberChannels),bytes=\(buffer.mDataByteSize)"
+            }.joined(separator: "; ")
+        }
+        let frameLengths = sourceBuffers.compactMap { source -> AVAudioFrameCount? in
+            let bytesPerFrame = Int(source.mNumberChannels) * MemoryLayout<Float32>.size
+            guard bytesPerFrame > 0,
+                  Int(source.mDataByteSize).isMultiple(of: bytesPerFrame) else { return nil }
+            return AVAudioFrameCount(Int(source.mDataByteSize) / bytesPerFrame)
+        }
+        guard frameLengths.count == sourceBuffers.count,
+              let frameLength = frameLengths.first,
+              frameLength > 0,
+              frameLengths.allSatisfy({ $0 == frameLength }),
+              let ownedBuffer = AVAudioPCMBuffer(
+                pcmFormat: format,
+                frameCapacity: frameLength
+              ) else { return nil }
+
+        // Set the frame count explicitly instead of asking AVAudioPCMBuffer to
+        // infer it from potentially inconsistent tap metadata.
+        ownedBuffer.frameLength = frameLength
        let destinationBuffers = UnsafeMutableAudioBufferListPointer(
            ownedBuffer.mutableAudioBufferList
        )
@@ -497,20 +658,44 @@ final class AudioManager: NSObject, ObservableObject {
        _ inputBufferProvider: () -> AVAudioPCMBuffer?,
        converter: AVAudioConverter,
        targetFormat: AVAudioFormat,
-        source: AudioSource
+        source: AudioSource,
+        callbackTimestamp: AudioTimeStamp? = nil,
+        ioTimestamp: AudioTimeStamp? = nil
    ) {
        // The system callback copies its borrowed Core Audio memory while this
        // lock prevents teardown, then conversion operates on the owned copy.
        audioFileLock.lock()
        defer { audioFileLock.unlock() }
-        guard isAcceptingAudio,
-              let inputBuffer = inputBufferProvider(),
-              inputBuffer.frameLength > 0 else { return }
+        guard isAcceptingAudio else { return }
+        if source == .system {
+            systemDiagnostics.callbackCount += 1
+            let callbackAt = Date()
+            if systemDiagnostics.firstCallbackAt == nil { systemDiagnostics.firstCallbackAt = callbackAt }
+            systemDiagnostics.lastCallbackAt = callbackAt
+            if let callbackTimestamp {
+                if systemDiagnostics.firstSampleTime == nil { systemDiagnostics.firstSampleTime = callbackTimestamp.mSampleTime }
+                systemDiagnostics.lastSampleTime = callbackTimestamp.mSampleTime
+            }
+            if let ioTimestamp {
+                if systemDiagnostics.firstHostTime == nil { systemDiagnostics.firstHostTime = ioTimestamp.mHostTime }
+                systemDiagnostics.lastHostTime = ioTimestamp.mHostTime
+            }
+        }
+        guard let inputBuffer = inputBufferProvider(), inputBuffer.frameLength > 0 else {
+            if source == .system { systemDiagnostics.discardedCallbackCount += 1 }
+            return
+        }
+        if source == .system {
+            systemDiagnostics.inputFrameCount += UInt64(inputBuffer.frameLength)
+        }

        updateAudioLevel(inputBuffer, source: source)
        let ratio = targetFormat.sampleRate / inputBuffer.format.sampleRate
        let capacity = max(1, AVAudioFrameCount(ceil(Double(inputBuffer.frameLength) * ratio)))
-        guard let outputBuffer = AVAudioPCMBuffer(pcmFormat: targetFormat, frameCapacity: capacity) else { return }
+        guard let outputBuffer = AVAudioPCMBuffer(pcmFormat: targetFormat, frameCapacity: capacity) else {
+            if source == .system { systemDiagnostics.discardedCallbackCount += 1 }
+            return
+        }
        var suppliedInput = false
        var conversionError: NSError?
        let status = converter.convert(to: outputBuffer, error: &conversionError) { _, outputStatus in
@@ -522,7 +707,10 @@ final class AudioManager: NSObject, ObservableObject {
            outputStatus.pointee = .haveData
            return inputBuffer
        }
-        guard status != .error, conversionError == nil, outputBuffer.frameLength > 0 else { return }
+        guard status != .error, conversionError == nil, outputBuffer.frameLength > 0 else {
+            if source == .system { systemDiagnostics.discardedCallbackCount += 1 }
+            return
+        }

        do {
            switch source {
@@ -530,6 +718,7 @@ final class AudioManager: NSObject, ObservableObject {
                try micAudioFile?.write(from: outputBuffer)
            case .system:
                try systemAudioFile?.write(from: outputBuffer)
+                systemDiagnostics.outputFrameCount += UInt64(outputBuffer.frameLength)
            }
        } catch {
            DispatchQueue.main.async { [weak self] in
@@ -623,15 +812,20 @@ final class AudioManager: NSObject, ObservableObject {
        return String(format: "mic %.1fs, system %.1fs", micDuration, systemDuration)
    }

-    private func repairHalfDurationSystemWAVIfNeeded(in files: [URL?]) {
+    private func repairHalfDurationSystemWAVIfNeeded(in files: [URL?]) -> Bool {
        guard files.count >= 2,
              let micDuration = audioDuration(at: files[0]),
              let systemURL = files[1],
              let systemDuration = audioDuration(at: systemURL),
              micDuration >= 60,
              systemURL.pathExtension.caseInsensitiveCompare("wav") == .orderedSame,
-              (0.48...0.52).contains(systemDuration / micDuration) else { return }
-        try? halveWAVSampleRate(at: systemURL)
+              (0.48...0.52).contains(systemDuration / micDuration) else { return false }
+        do {
+            try halveWAVSampleRate(at: systemURL)
+            return true
+        } catch {
+            return false
+        }
    }

    private func halveWAVSampleRate(at url: URL) throws {
@@ -696,6 +890,113 @@ final class AudioManager: NSObject, ObservableObject {
              file.processingFormat.sampleRate > 0 else { return nil }
        return Double(file.length) / file.processingFormat.sampleRate
    }
+
+    private func streamDescriptionSummary(_ description: AudioStreamBasicDescription?) -> String {
+        guard let description else { return "unavailable" }
+        return String(
+            format: "sampleRate=%.3f,formatID=%u,flags=%u,bytesPerPacket=%u,framesPerPacket=%u,bytesPerFrame=%u,channels=%u,bitsPerChannel=%u",
+            description.mSampleRate,
+            description.mFormatID,
+            description.mFormatFlags,
+            description.mBytesPerPacket,
+            description.mFramesPerPacket,
+            description.mBytesPerFrame,
+            description.mChannelsPerFrame,
+            description.mBitsPerChannel
+        )
+    }
+
+    private func audioFormatSummary(_ format: AVAudioFormat) -> String {
+        "sampleRate=\(format.sampleRate),channels=\(format.channelCount),commonFormat=\(format.commonFormat.rawValue),interleaved=\(format.isInterleaved)"
+    }
+
+    private func audioFileSummary(_ url: URL?) -> String {
+        guard let url else { return "missing" }
+        guard let file = try? AVAudioFile(forReading: url), file.processingFormat.sampleRate > 0 else {
+            return "\(url.lastPathComponent):unreadable"
+        }
+        let duration = Double(file.length) / file.processingFormat.sampleRate
+        return String(
+            format: "%@:sampleRate=%.3f,channels=%u,frames=%lld,duration=%.6f",
+            url.lastPathComponent,
+            file.processingFormat.sampleRate,
+            file.processingFormat.channelCount,
+            file.length,
+            duration
+        )
+    }
+
+    private func writeCaptureDiagnostics(
+        sessionID: UUID,
+        captureStartedAt: Date,
+        preRepairFileSummaries: [String],
+        repairedFiles: [URL?],
+        repairApplied: Bool,
+        audioFolder: URL?
+    ) {
+        guard let audioFolder else { return }
+        let callbackDuration = systemDiagnostics.firstCallbackAt.flatMap { first in
+            systemDiagnostics.lastCallbackAt.map { $0.timeIntervalSince(first) }
+        }
+        let sampleTimeDelta = systemDiagnostics.firstSampleTime.flatMap { first in
+            systemDiagnostics.lastSampleTime.map { $0 - first }
+        }
+        let hostTimeDelta = systemDiagnostics.firstHostTime.flatMap { first in
+            systemDiagnostics.lastHostTime.map { $0 >= first ? $0 - first : 0 }
+        }
+        let inputFrameDuration = systemDiagnostics.selectedInputSampleRate.flatMap { sampleRate in
+            sampleRate > 0 ? Double(systemDiagnostics.inputFrameCount) / sampleRate : nil
+        }
+        let outputFrameDuration = systemDiagnostics.targetSampleRate.flatMap { sampleRate in
+            sampleRate > 0 ? Double(systemDiagnostics.outputFrameCount) / sampleRate : nil
+        }
+        let observedInputRate = callbackDuration.flatMap { duration in
+            duration > 0 ? Double(systemDiagnostics.inputFrameCount) / duration : nil
+        }
+        let preRepairMic = preRepairFileSummaries.indices.contains(0) ? preRepairFileSummaries[0] : "missing"
+        let preRepairSystem = preRepairFileSummaries.indices.contains(1) ? preRepairFileSummaries[1] : "missing"
+        let postRepairMic = repairedFiles.indices.contains(0) ? audioFileSummary(repairedFiles[0]) : "missing"
+        let postRepairSystem = repairedFiles.indices.contains(1) ? audioFileSummary(repairedFiles[1]) : "missing"
+        let callbackDurationLine = callbackDuration.map { String(format: "callbackWallDuration=%.6f", $0) } ?? "callbackWallDuration=unavailable"
+        let inputFrameDurationLine = inputFrameDuration.map { String(format: "inputFrameDurationAtSelectedRate=%.6f", $0) } ?? "inputFrameDurationAtSelectedRate=unavailable"
+        let outputFrameDurationLine = outputFrameDuration.map { String(format: "outputFrameDurationAtTargetRate=%.6f", $0) } ?? "outputFrameDurationAtTargetRate=unavailable"
+        let observedInputRateLine = observedInputRate.map { String(format: "observedInputFramesPerSecond=%.3f", $0) } ?? "observedInputFramesPerSecond=unavailable"
+        let sampleTimeDeltaLine = sampleTimeDelta.map { String(format: "sampleTimeDelta=%.6f", $0) } ?? "sampleTimeDelta=unavailable"
+        let hostTimeDeltaLine = hostTimeDelta.map { "hostTimeDelta=\($0)" } ?? "hostTimeDelta=unavailable"
+        let lines: [String] = [
+            "Meetingnotes system capture diagnostics",
+            "sessionID=\(sessionID.uuidString)",
+            "createdAt=\(ISO8601DateFormatter().string(from: Date()))",
+            String(format: "captureWallDuration=%.6f", Date().timeIntervalSince(captureStartedAt)),
+            "tapAdvertisedFormat=\(systemDiagnostics.tapAdvertisedFormat)",
+            "aggregateInputFormat=\(systemDiagnostics.aggregateInputFormat)",
+            "selectedInputFormat=\(systemDiagnostics.selectedInputFormat)",
+            "inputRateInference=\(systemDiagnostics.inputRateInference)",
+            "targetFormat=\(systemDiagnostics.targetFormat)",
+            "firstBufferLayout=\(systemDiagnostics.firstBufferLayout ?? "unavailable")",
+            "callbackCount=\(systemDiagnostics.callbackCount)",
+            "inputFrameCount=\(systemDiagnostics.inputFrameCount)",
+            "outputFrameCount=\(systemDiagnostics.outputFrameCount)",
+            "discardedCallbackCount=\(systemDiagnostics.discardedCallbackCount)",
+            callbackDurationLine,
+            inputFrameDurationLine,
+            outputFrameDurationLine,
+            observedInputRateLine,
+            sampleTimeDeltaLine,
+            hostTimeDeltaLine,
+            "repairApplied=\(repairApplied)",
+            "preRepairMic=\(preRepairMic)",
+            "preRepairSystem=\(preRepairSystem)",
+            "postRepairMic=\(postRepairMic)",
+            "postRepairSystem=\(postRepairSystem)"
+        ]
+        let diagnosticsURL = audioFolder.appendingPathComponent("audio-diagnostics-\(sessionID.uuidString).txt")
+        try? lines.joined(separator: "\n").appending("\n").write(
+            to: diagnosticsURL,
+            atomically: true,
+            encoding: .utf8
+        )
+    }
        
    private func resetAudioLevels() {
        micAudioLevel = 0
@@ -8,7 +8,7 @@ import Security
 class KeychainHelper {
    static let shared = KeychainHelper()
    
-    private let serviceName = "net.jamesbone.meetingnotes"
+    private let serviceName = Bundle.main.bundleIdentifier ?? "net.jamesbone.meetingnotes"
    
    private init() {}
    
@@ -170,11 +170,13 @@ class LocalStorageManager {
                }
            }

-            for audioFile in recoveryAudioFiles(in: continuationFolder) {
-                let destination = previousFolder.appendingPathComponent(audioFile.url.lastPathComponent)
+            let recoveryFiles = recoveryAudioFiles(in: continuationFolder).map(\.url)
+                + recoveryDiagnosticFiles(in: continuationFolder)
+            for recoveryFile in recoveryFiles {
+                let destination = previousFolder.appendingPathComponent(recoveryFile.lastPathComponent)
                if FileManager.default.fileExists(atPath: destination.path) {
                    guard FileManager.default.contentsEqual(
-                        atPath: audioFile.url.path,
+                        atPath: recoveryFile.path,
                        andPath: destination.path
                    ) else {
                        rollbackMergedAudio(copiedAudioURLs, removeFolder: createdPreviousFolder ? previousFolder : nil)
@@ -184,7 +186,7 @@ class LocalStorageManager {
                }

                do {
-                    try FileManager.default.copyItem(at: audioFile.url, to: destination)
+                    try FileManager.default.copyItem(at: recoveryFile, to: destination)
                    copiedAudioURLs.append(destination)
                } catch {
                    rollbackMergedAudio(copiedAudioURLs, removeFolder: createdPreviousFolder ? previousFolder : nil)
@@ -206,6 +208,7 @@ class LocalStorageManager {
        merged.userNotes = mergedText(previous.userNotes, continuation.userNotes)
        merged.generatedNotes = mergedText(previous.generatedNotes, continuation.generatedNotes)
        merged.templateId = previous.templateId ?? continuation.templateId
+        merged.transcriptionError = previous.transcriptionError ?? continuation.transcriptionError
        if !recoveryAudioFiles(in: previousFolder).isEmpty {
            merged.recoveryAudioFolderName = previous.id.uuidString
        }
@@ -347,6 +350,23 @@ class LocalStorageManager {
        }
    }

+    private func recoveryDiagnosticFiles(in folder: URL) -> [URL] {
+        guard let files = try? FileManager.default.contentsOfDirectory(
+            at: folder,
+            includingPropertiesForKeys: [.isRegularFileKey],
+            options: [.skipsHiddenFiles]
+        ) else {
+            return []
+        }
+
+        return files.filter { url in
+            let values = try? url.resourceValues(forKeys: [.isRegularFileKey])
+            return values?.isRegularFile == true
+                && url.pathExtension.caseInsensitiveCompare("txt") == .orderedSame
+                && url.lastPathComponent.lowercased().hasPrefix("audio-diagnostics-")
+        }
+    }
+
    func findRecoveryAudioFolder(for meeting: Meeting) -> URL? {
        let canonicalName = meeting.id.uuidString
        guard meeting.recoveryAudioFolderName == nil
@@ -2,6 +2,12 @@ import Foundation
 import SwiftUI
 import Combine

+struct RecordingCompletion {
+    let chunks: [TranscriptChunk]
+    let recoveryAudioFolderName: String?
+    let transcriptionError: String?
+}
+
 /// Manages recording sessions at the app level to persist across navigation
@MainActor
 class RecordingSessionManager: ObservableObject {
@@ -14,9 +20,11 @@ class RecordingSessionManager: ObservableObject {
    @Published var errorMessage: String?
    @Published var activeRecordingTranscriptChunksUpdated: [TranscriptChunk] = []
    
-    private let audioManager = AudioManager.shared
+    private var audioManager = AudioManager.shared
    private var cancellables = Set<AnyCancellable>()
+    private var audioManagerCancellables = Set<AnyCancellable>()
    private let transcriptUpdateSubject = PassthroughSubject<[TranscriptChunk], Never>()
+    private var processingMeetingIds = Set<UUID>()
    
    // Store transcript chunks for the active recording session
    private var activeRecordingTranscriptChunks: [TranscriptChunk] = []
@@ -27,24 +35,19 @@ class RecordingSessionManager: ObservableObject {
    }
    
    private func setupAudioManagerBindings() {
+        audioManagerCancellables.removeAll()
        // Bind to audio manager state
        audioManager.$isRecording
            .sink { [weak self] isRecording in
                self?.isRecording = isRecording
            }
-            .store(in: &cancellables)
-        
-        audioManager.$isProcessing
-            .sink { [weak self] isProcessing in
-                self?.isProcessing = isProcessing
-            }
-            .store(in: &cancellables)
+            .store(in: &audioManagerCancellables)

        audioManager.$errorMessage
            .sink { [weak self] errorMessage in
                self?.errorMessage = errorMessage
            }
-            .store(in: &cancellables)
+            .store(in: &audioManagerCancellables)
        
        // When transcript chunks change, store them for the active recording and send to debouncer
        audioManager.$transcriptChunks
@@ -55,7 +58,7 @@ class RecordingSessionManager: ObservableObject {
                
                self.transcriptUpdateSubject.send(newChunks)
            }
-            .store(in: &cancellables)
+            .store(in: &audioManagerCancellables)
    }
    
    private func setupDebouncedSaving() {
@@ -84,22 +87,40 @@ class RecordingSessionManager: ObservableObject {
        audioManager.startRecording(for: meetingId)
    }
    
-    func stopRecording() async -> [TranscriptChunk] {
+    func stopRecording() async -> RecordingCompletion {
        print("🛑 Stopping recording for meeting: \(activeMeetingId?.uuidString ?? "unknown")")
        
        guard let meetingId = activeMeetingId else {
            audioManager.cancelRecording()
            recordingStartedAt = nil
-            return []
+            return RecordingCompletion(chunks: [], recoveryAudioFolderName: nil, transcriptionError: nil)
        }
-        recordingStartedAt = nil
-        let chunks = await audioManager.stopRecordingAndTranscribe()
-        activeRecordingTranscriptChunks = chunks
-        activeRecordingTranscriptChunksUpdated = chunks
-        updateActiveMeetingTranscript(meetingId: meetingId, chunks: chunks)
+
+        let completedAudioManager = audioManager
+        audioManager = AudioManager()
+        setupAudioManagerBindings()
        activeMeetingId = nil
-        activeRecordingTranscriptChunks = []
-        return chunks
+        recordingStartedAt = nil
+        processingMeetingIds.insert(meetingId)
+        isProcessing = true
+        defer {
+            processingMeetingIds.remove(meetingId)
+            isProcessing = !processingMeetingIds.isEmpty
+        }
+
+        let chunks = await completedAudioManager.stopRecordingAndTranscribe()
+        let completion = RecordingCompletion(
+            chunks: chunks,
+            recoveryAudioFolderName: completedAudioManager.lastRecoveryAudioFolderName,
+            transcriptionError: completedAudioManager.errorMessage
+        )
+        updateActiveMeetingTranscript(
+            meetingId: meetingId,
+            chunks: chunks,
+            recoveryAudioFolderName: completion.recoveryAudioFolderName,
+            transcriptionError: completion.transcriptionError
+        )
+        return completion
    }
        
    func cancelRecording() {
@@ -113,20 +134,26 @@ class RecordingSessionManager: ObservableObject {
        return isRecording && activeMeetingId == meetingId
    }

-    var lastRecoveryAudioFolderName: String? {
-        audioManager.lastRecoveryAudioFolderName
+    func isProcessingMeeting(_ meetingId: UUID) -> Bool {
+        processingMeetingIds.contains(meetingId)
    }
-    
-    private func updateActiveMeetingTranscript(meetingId: UUID, chunks: [TranscriptChunk]) {
+
+    private func updateActiveMeetingTranscript(
+        meetingId: UUID,
+        chunks: [TranscriptChunk],
+        recoveryAudioFolderName: String? = nil,
+        transcriptionError: String? = nil
+    ) {
        // Load all meetings
        var meetings = LocalStorageManager.shared.loadMeetings()
        
        // Find and update the active meeting
        if let index = meetings.firstIndex(where: { $0.id == meetingId }) {
            meetings[index].transcriptChunks = chunks
-            if let recoveryAudioFolderName = lastRecoveryAudioFolderName {
+            if let recoveryAudioFolderName {
                meetings[index].recoveryAudioFolderName = recoveryAudioFolderName
            }
+            meetings[index].transcriptionError = transcriptionError
            
            // Save the updated meeting
            let success = LocalStorageManager.shared.saveMeeting(meetings[index])
@@ -99,6 +99,7 @@ struct Meeting: Codable, Identifiable, Hashable {
    var generatedNotes: String
    var templateId: UUID?  // Add property to track per-meeting template
    var recoveryAudioFolderName: String?
+    var transcriptionError: String?
    // MARK: - Data versioning
    /// Version of this Meeting record on disk. Useful for migration.
    var dataVersion: Int
@@ -113,6 +114,7 @@ struct Meeting: Codable, Identifiable, Hashable {
         generatedNotes: String = "",
         templateId: UUID? = nil,
         recoveryAudioFolderName: String? = nil,
+         transcriptionError: String? = nil,
         dataVersion: Int = Meeting.currentDataVersion) {
        self.id = id
        self.date = date
@@ -122,6 +124,7 @@ struct Meeting: Codable, Identifiable, Hashable {
        self.generatedNotes = generatedNotes
        self.templateId = templateId
        self.recoveryAudioFolderName = recoveryAudioFolderName
+        self.transcriptionError = transcriptionError
        self.dataVersion = dataVersion
    }
    
@@ -63,6 +63,10 @@ final class ProcessTap {
    @ObservationIgnored
    private(set) var tapStreamDescription: AudioStreamBasicDescription?
    @ObservationIgnored
+    private(set) var tapAdvertisedStreamDescription: AudioStreamBasicDescription?
+    @ObservationIgnored
+    private(set) var aggregateInputStreamDescription: AudioStreamBasicDescription?
+    @ObservationIgnored
    private var invalidationHandler: InvalidationHandler?

    @ObservationIgnored
@@ -138,11 +142,11 @@ final class ProcessTap {
            tapDescription = CATapDescription(stereoMixdownOfProcesses: [process.objectID])
            logger.debug("Configuring tap for single process objectID: \(process.objectID)")
        case .systemAudio:
-            // Keep the HAL tap's buffer layout consistent with the default
-            // output stream. AudioManager performs the stereo-to-mono mix when
-            // it converts the captured audio to the 16 kHz transcription file.
-            tapDescription = CATapDescription(stereoGlobalTapButExcludeProcesses: [])
-            logger.debug("Configuring a stereo global system audio tap.")
+            // The transcription file is mono, so ask Core Audio for a mono
+            // mixdown at the source. This avoids interpreting a stereo HAL
+            // buffer as half as many frames before the 16 kHz conversion.
+            tapDescription = CATapDescription(monoGlobalTapButExcludeProcesses: [])
+            logger.info("Configuring a mono global system audio tap.")
        }
        
        tapDescription.uuid = UUID()
@@ -249,6 +253,7 @@ final class ProcessTap {
        do {
            logger.debug("Attempting to read audio tap stream basic description for tapID #\(tapID)...")
            let advertisedDescription = try tapID.readAudioTapStreamBasicDescription()
+            self.tapAdvertisedStreamDescription = advertisedDescription

            // The aggregate device may adapt the tap to the active hardware's
            // sample rate. Its input stream is the format actually delivered
@@ -256,7 +261,9 @@ final class ProcessTap {
            // advertisement. Using the latter can halve the written duration
            // when, for example, a 48 kHz tap is delivered at 24 kHz.
            do {
-                self.tapStreamDescription = try aggregateDeviceID.readInputStreamBasicDescription()
+                let aggregateDescription = try aggregateDeviceID.readInputStreamBasicDescription()
+                self.aggregateInputStreamDescription = aggregateDescription
+                self.tapStreamDescription = aggregateDescription
                logger.info("Using aggregate input stream description: \(String(describing: self.tapStreamDescription), privacy: .public); tap advertised: \(String(describing: advertisedDescription), privacy: .public)")
            } catch {
                self.tapStreamDescription = advertisedDescription
@@ -30,6 +30,7 @@ enum CoderAPIError: LocalizedError {
    case missingModel(String)
    case invalidResponse
    case serviceError(Int, String)
+    case audioPreparationFailed(String, String)

    var errorDescription: String? {
        switch self {
@@ -43,6 +44,8 @@ enum CoderAPIError: LocalizedError {
            return "Coder returned an invalid response."
        case .serviceError(let status, let message):
            return "Coder request failed (\(status)): \(message)"
+        case .audioPreparationFailed(let filename, let message):
+            return "Could not prepare \(filename) for transcription: \(message)"
        }
    }
 }
@@ -179,7 +182,12 @@ final class CoderAPIClient {
        let selectedModel = model.trimmingCharacters(in: .whitespacesAndNewlines)
        guard !selectedModel.isEmpty else { throw CoderAPIError.missingModel("transcription") }
        let apiKey = try requiredAPIKey(KeychainHelper.shared.getCoderAPIKey() ?? "")
-        let chunks = try makeAudioChunks(from: fileURL, preserveSpeakerIdentity: diarization)
+        let chunks: [AudioChunk]
+        do {
+            chunks = try makeAudioChunks(from: fileURL, preserveSpeakerIdentity: diarization)
+        } catch {
+            throw CoderAPIError.audioPreparationFailed(fileURL.lastPathComponent, error.localizedDescription)
+        }
        defer {
            for chunk in chunks where chunk.isTemporary {
                try? FileManager.default.removeItem(at: chunk.url)
@@ -260,13 +268,38 @@ final class CoderAPIClient {
           let size = attributes[.size] as? NSNumber {
            request.setValue(size.stringValue, forHTTPHeaderField: "Content-Length")
        }
-        let (data, response) = try await transcriptionSession.upload(for: request, fromFile: bodyURL)
+        let (data, response) = try await uploadTranscription(request: request, bodyURL: bodyURL)
        try validate(response: response, data: data)
        let decoded = try JSONDecoder().decode(TranscriptionResponse.self, from: data)
        let segments = decoded.segments ?? segments(from: decoded.words ?? [])
        return Transcription(text: decoded.text, segments: segments)
    }

+    private func uploadTranscription(request: URLRequest, bodyURL: URL) async throws -> (Data, URLResponse) {
+        let retryDelays: [UInt64] = [3, 10]
+        for attempt in 0...retryDelays.count {
+            do {
+                return try await transcriptionSession.upload(for: request, fromFile: bodyURL)
+            } catch {
+                guard attempt < retryDelays.count, isRetryableTranscriptionError(error) else {
+                    throw error
+                }
+                try await Task.sleep(nanoseconds: retryDelays[attempt] * 1_000_000_000)
+            }
+        }
+        throw CoderAPIError.invalidResponse
+    }
+
+    private func isRetryableTranscriptionError(_ error: Error) -> Bool {
+        guard let urlError = error as? URLError else { return false }
+        switch urlError.code {
+        case .networkConnectionLost, .cannotConnectToHost, .timedOut:
+            return true
+        default:
+            return false
+        }
+    }
+
    private func makeAudioChunks(from fileURL: URL, preserveSpeakerIdentity: Bool) throws -> [AudioChunk] {
        let input = try AVAudioFile(forReading: fileURL)
        let format = input.processingFormat
@@ -182,13 +182,13 @@ private enum LocalAPIRouter {
 }

 private enum LocalRecordingError: LocalizedError {
-    case processing
+    case stopping
    case saveFailed

    var errorDescription: String? {
        switch self {
-        case .processing:
-            return "The previous meeting is still processing."
+        case .stopping:
+            return "The current recording is still stopping."
        case .saveFailed:
            return "Could not create a meeting for this recording."
        }
@@ -208,12 +208,12 @@ private final class LocalRecordingController {

    func statusPayload() -> [String: Any] {
        let state: String
-        if isStopping || recordingManager.isProcessing {
-            state = "processing"
-        } else if recordingManager.isRecording {
+        if recordingManager.isRecording {
            state = "recording"
        } else if recordingManager.activeMeetingId != nil {
            state = "starting"
+        } else if isStopping || recordingManager.isProcessing {
+            state = "processing"
        } else {
            state = "idle"
        }
@@ -245,8 +245,8 @@ private final class LocalRecordingController {
            isStopping = false
            return statusPayload()
        }
-        if isStopping || recordingManager.isProcessing {
-            throw LocalRecordingError.processing
+        if isStopping {
+            throw LocalRecordingError.stopping
        }
        if recordingManager.activeMeetingId != nil {
            return statusPayload()
@@ -295,15 +295,16 @@ private final class LocalRecordingController {
    private func finishRecording() async {
        pendingStopTask = nil
        let meetingID = recordingManager.activeMeetingId
-        let chunks = await recordingManager.stopRecording()
+        isStopping = false
+        let completion = await recordingManager.stopRecording()
        guard let meetingID,
              var meeting = LocalStorageManager.shared.loadMeetings().first(where: { $0.id == meetingID }) else {
-            isStopping = false
            return
        }

-        meeting.transcriptChunks = chunks
-        meeting.recoveryAudioFolderName = recordingManager.lastRecoveryAudioFolderName
+        meeting.transcriptChunks = completion.chunks
+        meeting.recoveryAudioFolderName = completion.recoveryAudioFolderName
+        meeting.transcriptionError = completion.transcriptionError
        let templates = LocalStorageManager.shared.loadTemplates()
        if meeting.templateId == nil {
            meeting.templateId = LocalStorageManager.shared.preferredTemplateID(in: templates)
@@ -352,7 +353,6 @@ private final class LocalRecordingController {
                NotificationCenter.default.post(name: .meetingSaved, object: meeting)
            }
        }
-        isStopping = false
    }
 }

@@ -47,7 +47,7 @@ class MeetingViewModel: ObservableObject {

    var isProcessing: Bool {
        return isRetryingTranscription ||
-            (recordingSessionManager.isProcessing && recordingSessionManager.activeMeetingId == meeting.id)
+            recordingSessionManager.isProcessingMeeting(meeting.id)
    }

    var canRetryTranscription: Bool {
@@ -137,17 +137,26 @@ class MeetingViewModel: ObservableObject {
            self.meeting.transcriptChunks = recordingSessionManager.getTranscriptChunks(for: meeting.id)
        }

-        // Listen for final transcript updates for this meeting.
+        // Listen for transcript updates emitted while this meeting is recording.
        recordingSessionManager.$activeRecordingTranscriptChunksUpdated
            .dropFirst()
            .sink { [weak self] updatedChunks in
                guard let self = self else { return }
-                // Only update if this meeting is the active recording
-                if recordingSessionManager.isRecordingMeeting(self.meeting.id) {
+                if recordingSessionManager.activeMeetingId == self.meeting.id {
                    self.meeting.transcriptChunks = updatedChunks
                }
            }
            .store(in: &cancellables)
+
+        NotificationCenter.default.publisher(for: .meetingSaved)
+            .compactMap { $0.object as? Meeting }
+            .filter { [weak self] in $0.id == self?.meeting.id }
+            .sink { [weak self] savedMeeting in
+                guard let self, !self.isDeleted, self.meeting != savedMeeting else { return }
+                self.meeting = savedMeeting
+                self.refreshRecoveryAudioFolder()
+            }
+            .store(in: &cancellables)
        

        
@@ -212,9 +221,11 @@ class MeetingViewModel: ObservableObject {
    func stopRecording() {
        isStartingRecording = true
        Task {
-            let chunks = await recordingSessionManager.stopRecording()
-            meeting.transcriptChunks = chunks
-            meeting.recoveryAudioFolderName = recordingSessionManager.lastRecoveryAudioFolderName
+            let completion = await recordingSessionManager.stopRecording()
+            meeting.transcriptChunks = completion.chunks
+            meeting.recoveryAudioFolderName = completion.recoveryAudioFolderName
+            meeting.transcriptionError = completion.transcriptionError
+            errorMessage = completion.transcriptionError
            refreshRecoveryAudioFolder()
            saveMeeting()
            if !meeting.formattedTranscript.isEmpty {
@@ -238,6 +249,7 @@ class MeetingViewModel: ObservableObject {
                )
                meeting.transcriptChunks = chunks
                meeting.recoveryAudioFolderName = recoveryAudioFolderURL.lastPathComponent
+                meeting.transcriptionError = nil
                selectedTab = .transcript

                guard saveMeeting() else {
@@ -247,6 +259,8 @@ class MeetingViewModel: ObservableObject {
                await generateNotes()
            } catch {
                errorMessage = error.localizedDescription
+                meeting.transcriptionError = error.localizedDescription
+                _ = saveMeeting()
                print("Retry transcription failed: \(error)")
            }
        }
@@ -6,6 +6,8 @@ struct MeetingListView: View {
    @StateObject private var recordingSessionManager = RecordingSessionManager.shared
    @State private var selectedMeeting: Meeting?
    @State private var navigationPath = NavigationPath()
+    @State private var recordingFailureMessage: String?
+    @State private var failedMeetingID: UUID?
    
    var body: some View {
        NavigationSplitView {
@@ -23,6 +25,38 @@ struct MeetingListView: View {
                    .background(Color.clear)
            }
        }
+        .onReceive(recordingSessionManager.$activeMeetingId.compactMap { $0 }) { meetingID in
+            if let meeting = LocalStorageManager.shared.loadMeetings().first(where: { $0.id == meetingID }) {
+                selectedMeeting = meeting
+            }
+        }
+        .onReceive(NotificationCenter.default.publisher(for: .meetingSaved)) { notification in
+            guard let savedMeeting = notification.object as? Meeting,
+                  selectedMeeting?.id == savedMeeting.id else { return }
+            selectedMeeting = savedMeeting
+        }
+        .onReceive(recordingSessionManager.$errorMessage.compactMap { $0 }) { message in
+            failedMeetingID = recordingSessionManager.activeMeetingId
+            recordingFailureMessage = message
+        }
+        .alert("Transcription Failed", isPresented: Binding(
+            get: { recordingFailureMessage != nil },
+            set: { if !$0 { recordingFailureMessage = nil } }
+        )) {
+            if failedMeetingID != nil {
+                Button("View Meeting") {
+                    selectFailedMeeting()
+                    recordingFailureMessage = nil
+                    recordingSessionManager.errorMessage = nil
+                }
+            }
+            Button("OK") {
+                recordingFailureMessage = nil
+                recordingSessionManager.errorMessage = nil
+            }
+        } message: {
+            Text(recordingFailureMessage ?? "")
+        }
    }
    
    private var sidebarContent: some View {
@@ -161,6 +195,14 @@ struct MeetingListView: View {
            return DayGroup(day: dayString, date: date, meetings: meetings.sorted { $0.date > $1.date })
        }.sorted { $0.date > $1.date }
    }
+
+    private func selectFailedMeeting() {
+        guard let failedMeetingID,
+              let meeting = LocalStorageManager.shared.loadMeetings().first(where: { $0.id == failedMeetingID }) else {
+            return
+        }
+        selectedMeeting = meeting
+    }
 }

 struct DayGroup {
@@ -182,7 +224,14 @@ struct MeetingRowView: View {
                        .foregroundColor(.red)
                        .font(.headline)
                }
-                Text(meeting.title.isEmpty ? "Untitled meeting" : meeting.title)
+                if meeting.transcriptionError != nil {
+                    Image(systemName: "exclamationmark.triangle.fill")
+                        .foregroundColor(.orange)
+                        .accessibilityLabel("Transcription failed")
+                }
+                Text(meeting.title.isEmpty
+                     ? (meeting.transcriptionError == nil ? "Untitled meeting" : "Transcription failed")
+                     : meeting.title)
                    .font(.headline)
                    .lineLimit(1)
            }
@@ -542,24 +591,52 @@ struct MeetingDetailContentView: View {
    }
    
    private var transcriptView: some View {
-        ScrollView {
-            if viewModel.meeting.collapsedTranscriptChunks.isEmpty {
-                Text("Transcript will appear here...")
-                    .frame(maxWidth: .infinity, alignment: .leading)
-                    .padding()
-                    .foregroundColor(.secondary)
-            } else {
-                LazyVStack(alignment: .leading, spacing: 4) {
-                    ForEach(viewModel.meeting.collapsedTranscriptChunks) { chunk in
-                        CollapsedTranscriptChunkView(chunk: chunk)
+        VStack(alignment: .leading, spacing: 10) {
+            if let transcriptionError = viewModel.meeting.transcriptionError {
+                HStack(alignment: .top, spacing: 10) {
+                    Image(systemName: "exclamationmark.triangle.fill")
+                        .foregroundColor(.orange)
+                    VStack(alignment: .leading, spacing: 4) {
+                        Text("Transcription failed")
+                            .font(.headline)
+                        Text(transcriptionError)
+                            .font(.caption)
+                            .foregroundColor(.secondary)
+                    }
+                    Spacer()
+                    if viewModel.recoveryAudioFolderURL != nil {
+                        Button("Retry") {
+                            viewModel.retryTranscription()
+                        }
+                        .disabled(!viewModel.canRetryTranscription)
                    }
                }
                .padding()
+                .background(Color.orange.opacity(0.08))
+                .cornerRadius(8)
            }
+
+            ScrollView {
+                if viewModel.meeting.collapsedTranscriptChunks.isEmpty {
+                    Text(viewModel.meeting.transcriptionError == nil
+                         ? "Transcript will appear here..."
+                         : "No transcript was produced. The recording was kept and can be retried.")
+                        .frame(maxWidth: .infinity, alignment: .leading)
+                        .padding()
+                        .foregroundColor(.secondary)
+                } else {
+                    LazyVStack(alignment: .leading, spacing: 4) {
+                        ForEach(viewModel.meeting.collapsedTranscriptChunks) { chunk in
+                            CollapsedTranscriptChunkView(chunk: chunk)
+                        }
+                    }
+                    .padding()
+                }
+            }
+            .frame(maxHeight: .infinity)
+            .background(Color.gray.opacity(0.05))
+            .cornerRadius(8)
        }
-        .frame(maxHeight: .infinity)
-        .background(Color.gray.opacity(0.05))
-        .cornerRadius(8)
    }
    
    private var enhancedNotesView: some View {
@@ -255,7 +255,7 @@ struct SettingsView: View {
                    
                    // Link to GitHub repository
                    Link("GitHub",
-                         destination: URL(string: "https://github.com/superdooper86/meetingnotes")!)
+                         destination: URL(string: "https://git.jamesbone.net/coder/meetingnotes")!)
                        .foregroundColor(.blue)

                    // Link to landing page
@@ -1,34 +0,0 @@
-#!/usr/bin/env bash
-
-set -euo pipefail
-
-REPOSITORY="${REPOSITORY:-superdooper86/meetingnotes}"
-
-if ! command -v gh >/dev/null 2>&1; then
-  echo "Install GitHub CLI first: brew install gh" >&2
-  exit 1
-fi
-
-gh auth status >/dev/null
-
-read -r -p "Developer ID certificate (.p12) path: " certificate_path
-if [[ ! -f "$certificate_path" ]]; then
-  echo "Certificate not found: $certificate_path" >&2
-  exit 1
-fi
-
-read -r -s -p "Certificate export password: " certificate_password
-printf '\n'
-read -r -p "Apple ID email: " apple_id
-read -r -p "Apple Developer Team ID: " team_id
-read -r -s -p "Apple app-specific password: " app_password
-printf '\n'
-
-base64 < "$certificate_path" | gh secret set APPLE_CERTIFICATE_P12 -R "$REPOSITORY"
-printf '%s' "$certificate_password" | gh secret set APPLE_CERTIFICATE_PASSWORD -R "$REPOSITORY"
-printf '%s' "$apple_id" | gh secret set APPLE_ID -R "$REPOSITORY"
-printf '%s' "$team_id" | gh secret set APPLE_TEAM_ID -R "$REPOSITORY"
-printf '%s' "$app_password" | gh secret set APPLE_APP_PASSWORD -R "$REPOSITORY"
-
-unset certificate_password app_password
-echo "Apple release secrets configured for $REPOSITORY."
@@ -1,139 +0,0 @@
-#!/usr/bin/env bash
-
-set -euo pipefail
-
-APP_NAME="Meetingnotes"
-RUNNER_TEMP="${RUNNER_TEMP:-/tmp}"
-PENDING_DIR="${PENDING_DIR:-$RUNNER_TEMP/meetingnotes-pending}"
-WORK_ROOT="${WORK_ROOT:-$RUNNER_TEMP/meetingnotes-finalize}"
-APP_PATH="$WORK_ROOT/$APP_NAME.app"
-RELEASE_DIR="$WORK_ROOT/release"
-VERSION_PATH="$PENDING_DIR/version"
-COMMIT_SHA_PATH="$PENDING_DIR/commit-sha"
-SUBMISSION_PATH="$PENDING_DIR/notary-submission.json"
-PRE_NOTARY_ZIP="$PENDING_DIR/$APP_NAME-pre-notary.zip"
-
-required_variables=(
-  APPLE_ID
-  APPLE_TEAM_ID
-  APPLE_APP_PASSWORD
-  SPARKLE_PRIVATE_KEY
-  GH_TOKEN
-  GITHUB_REPOSITORY
-)
-
-for variable in "${required_variables[@]}"; do
-  if [[ -z "${!variable:-}" ]]; then
-    echo "Missing required environment variable: $variable" >&2
-    exit 1
-  fi
-done
-
-for path in "$VERSION_PATH" "$COMMIT_SHA_PATH" "$SUBMISSION_PATH" "$PRE_NOTARY_ZIP" "$PENDING_DIR/generate_appcast"; do
-  if [[ ! -e "$path" ]]; then
-    echo "Missing release submission artifact: $path" >&2
-    exit 1
-  fi
-done
-
-VERSION=$(<"$VERSION_PATH")
-COMMIT_SHA=$(<"$COMMIT_SHA_PATH")
-SUBMISSION_ID=$(plutil -extract id raw -o - "$SUBMISSION_PATH")
-TAG="v$VERSION"
-
-if gh release view "$TAG" --repo "$GITHUB_REPOSITORY" >/dev/null 2>&1; then
-  echo "Release already exists: $TAG"
-  exit 0
-fi
-
-STATUS_PATH="$WORK_ROOT/notary-status.json"
-rm -rf "$WORK_ROOT"
-mkdir -p "$RELEASE_DIR"
-
-notary_info_succeeded=false
-for attempt in 1 2 3; do
-  if xcrun notarytool info "$SUBMISSION_ID" \
-    --apple-id "$APPLE_ID" \
-    --team-id "$APPLE_TEAM_ID" \
-    --password "$APPLE_APP_PASSWORD" \
-    --output-format json > "$STATUS_PATH"; then
-    notary_info_succeeded=true
-    break
-  fi
-  echo "Notary status check failed ($attempt/3); retrying"
-  sleep 15
-done
-
-if [[ "$notary_info_succeeded" != true ]]; then
-  echo "Unable to query Apple notarization status after three attempts" >&2
-  exit 1
-fi
-
-NOTARY_STATUS=$(plutil -extract status raw -o - "$STATUS_PATH")
-echo "Notarization status for $SUBMISSION_ID: $NOTARY_STATUS"
-
-case "$NOTARY_STATUS" in
-  "In Progress")
-    if [[ -n "${GITHUB_STEP_SUMMARY:-}" ]]; then
-      printf 'Apple is still processing Meetingnotes %s. Submission: `%s`. The scheduled workflow will check again.\n' \
-        "$VERSION" "$SUBMISSION_ID" >> "$GITHUB_STEP_SUMMARY"
-    fi
-    exit 0
-    ;;
-  Accepted)
-    ;;
-  Invalid|Rejected)
-    xcrun notarytool log "$SUBMISSION_ID" \
-      --apple-id "$APPLE_ID" \
-      --team-id "$APPLE_TEAM_ID" \
-      --password "$APPLE_APP_PASSWORD" || true
-    exit 1
-    ;;
-  *)
-    echo "Unexpected notarization status: $NOTARY_STATUS" >&2
-    exit 1
-    ;;
-esac
-
-ditto -x -k "$PRE_NOTARY_ZIP" "$WORK_ROOT"
-if [[ ! -d "$APP_PATH" ]]; then
-  echo "Signed app was not found after extracting $PRE_NOTARY_ZIP" >&2
-  exit 1
-fi
-
-APP_VERSION=$(plutil -extract CFBundleShortVersionString raw -o - "$APP_PATH/Contents/Info.plist")
-if [[ "$APP_VERSION" != "$VERSION" ]]; then
-  echo "Signed app version $APP_VERSION does not match release version $VERSION" >&2
-  exit 1
-fi
-
-xcrun stapler staple "$APP_PATH"
-xcrun stapler validate "$APP_PATH"
-spctl --assess --type execute --verbose=2 "$APP_PATH"
-
-ARCHIVE_NAME="$APP_NAME-$VERSION.zip"
-ARCHIVE_PATH="$RELEASE_DIR/$ARCHIVE_NAME"
-ditto -c -k --sequesterRsrc --keepParent "$APP_PATH" "$ARCHIVE_PATH"
-
-GENERATE_APPCAST="$PENDING_DIR/generate_appcast"
-chmod +x "$GENERATE_APPCAST"
-DOWNLOAD_URL="https://github.com/$GITHUB_REPOSITORY/releases/download/$TAG/"
-printf '%s' "$SPARKLE_PRIVATE_KEY" | "$GENERATE_APPCAST" "$RELEASE_DIR" \
-  --ed-key-file - \
-  --download-url-prefix "$DOWNLOAD_URL" \
-  --maximum-deltas 0 \
-  -o "$RELEASE_DIR/appcast.xml"
-
-grep -q "$DOWNLOAD_URL$ARCHIVE_NAME" "$RELEASE_DIR/appcast.xml"
-grep -q 'sparkle:edSignature=' "$RELEASE_DIR/appcast.xml"
-
-gh release \
-  create "$TAG" \
-  "$ARCHIVE_PATH" \
-  "$RELEASE_DIR/appcast.xml" \
-  --repo "$GITHUB_REPOSITORY" \
-  --target "$COMMIT_SHA" \
-  --title "Meetingnotes $VERSION" \
-  --generate-notes
-
-echo "Published Meetingnotes $VERSION"
@@ -14,11 +14,13 @@ APP_PATH="$DERIVED_DATA/Build/Products/Release/$APP_NAME.app"
 required_variables=(
  VERSION
  SIGNING_IDENTITY
+  SIGNING_KEYCHAIN
  APPLE_ID
  APPLE_TEAM_ID
  APPLE_APP_PASSWORD
  SPARKLE_PRIVATE_KEY
  GITHUB_REPOSITORY
+  RELEASE_BASE_URL
 )

 for variable in "${required_variables[@]}"; do
@@ -57,12 +59,12 @@ SPARKLE_FRAMEWORK="$APP_PATH/Contents/Frameworks/Sparkle.framework"
 SPARKLE_CONTENTS="$SPARKLE_FRAMEWORK/Versions/B"

 sign_component() {
-  codesign --force --timestamp --options runtime --sign "$SIGNING_IDENTITY" "$1"
+  codesign --force --timestamp --options runtime --keychain "$SIGNING_KEYCHAIN" --sign "$SIGNING_IDENTITY" "$1"
 }

 sign_component "$SPARKLE_CONTENTS/XPCServices/Installer.xpc"
 if [[ -d "$SPARKLE_CONTENTS/XPCServices/Downloader.xpc" ]]; then
-  codesign --force --timestamp --options runtime \
+  codesign --force --timestamp --options runtime --keychain "$SIGNING_KEYCHAIN" \
    --preserve-metadata=entitlements \
    --sign "$SIGNING_IDENTITY" \
    "$SPARKLE_CONTENTS/XPCServices/Downloader.xpc"
@@ -71,7 +73,7 @@ sign_component "$SPARKLE_CONTENTS/Autoupdate"
 sign_component "$SPARKLE_CONTENTS/Updater.app"
 sign_component "$SPARKLE_FRAMEWORK"

-codesign --force --timestamp --options runtime \
+codesign --force --timestamp --options runtime --keychain "$SIGNING_KEYCHAIN" \
  --entitlements meetingnotes/meetingnotes.entitlements \
  --sign "$SIGNING_IDENTITY" \
  "$APP_PATH"
@@ -116,7 +118,7 @@ if [[ -z "$GENERATE_APPCAST" ]]; then
  exit 1
 fi

-DOWNLOAD_URL="https://github.com/$GITHUB_REPOSITORY/releases/download/v$VERSION/"
+DOWNLOAD_URL="$RELEASE_BASE_URL/releases/download/v$VERSION/"
 printf '%s' "$SPARKLE_PRIVATE_KEY" | "$GENERATE_APPCAST" "$RELEASE_DIR" \
  --ed-key-file - \
  --download-url-prefix "$DOWNLOAD_URL" \
@@ -127,7 +129,7 @@ grep -q "$DOWNLOAD_URL$ARCHIVE_NAME" "$RELEASE_DIR/appcast.xml"
 grep -q 'sparkle:edSignature=' "$RELEASE_DIR/appcast.xml"

 if [[ -n "${GITHUB_STEP_SUMMARY:-}" ]]; then
-  printf 'Built, Developer ID-signed, notarized, and stapled Meetingnotes %s. The GitHub release is ready to publish.\n' \
+  printf 'Built, Developer ID-signed, notarized, and stapled Meetingnotes %s. The Gitea release is ready to publish.\n' \
    "$VERSION" >> "$GITHUB_STEP_SUMMARY"
 fi

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+"""Publish both signed assets together, keeping incomplete uploads as a draft."""
+import json
+import os
+import urllib.error
+import urllib.parse
+import urllib.request
+from pathlib import Path
+
+base = os.environ["GITEA_SERVER_URL"].rstrip("/") + "/api/v1/repos/" + os.environ["GITHUB_REPOSITORY"]
+token = os.environ["GITEA_TOKEN"]
+version = os.environ["VERSION"]
+
+
+class NoRedirect(urllib.request.HTTPRedirectHandler):
+    def redirect_request(self, *args, **kwargs):
+        return None
+
+
+def request(path, method="GET", data=None, binary=False):
+    body = data if binary else None if data is None else json.dumps(data).encode()
+    req = urllib.request.Request(base + path, method=method, data=body, headers={
+        "Authorization": "token " + token,
+        "Content-Type": "application/octet-stream" if binary else "application/json",
+        "User-Agent": "Meetingnotes-release",
+    })
+    with urllib.request.build_opener(NoRedirect()).open(req, timeout=120) as response:
+        raw = response.read()
+        return json.loads(raw) if raw else None
+
+
+release_dir = Path(os.environ["RUNNER_TEMP"]) / "meetingnotes-release/release"
+assets = [release_dir / f"Meetingnotes-{version}.zip", release_dir / "appcast.xml"]
+for asset in assets:
+    if not asset.is_file() or not asset.stat().st_size:
+        raise RuntimeError(f"Missing release artifact: {asset.name}")
+release = request("/releases", "POST", {
+    "tag_name": "v" + version, "target_commitish": os.environ["GITHUB_SHA"],
+    "name": "Meetingnotes " + version, "draft": True, "prerelease": False,
+    "body": "Developer ID signed, Apple notarized, and signed for Sparkle updates.\n\nBuilt from main at `" + os.environ["GITHUB_SHA"] + "`.",
+})
+for asset in assets:
+    request(f"/releases/{release['id']}/assets?name=" + urllib.parse.quote(asset.name), "POST", asset.read_bytes(), binary=True)
+request(f"/releases/{release['id']}", "PATCH", {"draft": False})
+print("Published Meetingnotes " + version)
@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+"""Check the CI app's unauthenticated API without changing saved preferences."""
+import json
+import plistlib
+import socket
+import subprocess
+import sys
+import tempfile
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+# Launch from the Mac's internal volume; the runner checkout is on removable storage.
+cache = Path.home() / "Library/Caches/meetingnotes-ci"
+cache.mkdir(parents=True, exist_ok=True)
+with tempfile.TemporaryDirectory(prefix="smoke-", dir=cache) as directory:
+    staged = Path(directory) / "Meetingnotes.app"
+    subprocess.run(["ditto", sys.argv[1], str(staged)], check=True)
+    app = staged / "Contents/MacOS/Meetingnotes"
+    with (staged / "Contents/Info.plist").open("rb") as info_file:
+        bundle_id = plistlib.load(info_file)["CFBundleIdentifier"]
+    assert bundle_id == "net.jamesbone.meetingnotes.ci", "Smoke tests require the isolated CI app"
+
+    def clear_test_token():
+        result = subprocess.run(
+            ["security", "delete-generic-password", "-s", bundle_id, "-a", "muteDeckAPIToken"],
+            capture_output=True, timeout=10,
+        )
+        if result.returncode not in (0, 44):  # 44: item does not exist
+            raise RuntimeError("Could not clear the CI Keychain token")
+
+    clear_test_token()
+    with socket.socket() as listener:
+        listener.bind(("127.0.0.1", 0))
+        port = listener.getsockname()[1]
+    with tempfile.TemporaryFile() as log:
+        process = subprocess.Popen(
+            [str(app), "-muteDeckAPIEnabled", "YES", "-muteDeckAPIPort", str(port), "-hasCompletedOnboarding", "YES", "-hasAcceptedTerms", "YES", "-SUEnableAutomaticChecks", "NO"],
+            stdout=log, stderr=subprocess.STDOUT,
+        )
+        try:
+            for attempt in range(30):
+                if process.poll() is not None:
+                    raise RuntimeError("CI app exited before the API became ready")
+                try:
+                    with urllib.request.urlopen(f"http://127.0.0.1:{port}/api/info", timeout=2) as response:
+                        info = json.load(response)
+                    break
+                except (urllib.error.URLError, TimeoutError):
+                    time.sleep(1)
+            else:
+                raise RuntimeError("CI API did not become ready")
+            assert info["name"] == "MeetingDebrief", "Unexpected API identity"
+            try:
+                urllib.request.urlopen(f"http://127.0.0.1:{port}/api/recording/status", timeout=2)
+            except urllib.error.HTTPError as error:
+                assert error.code == 401, f"Unexpected status: {error.code}"
+            else:
+                raise RuntimeError("Recording status allowed an unauthenticated request")
+            print("Local API readiness and authentication checks passed")
+        except Exception:
+            if process.poll() is None:
+                sample = subprocess.run(["sample", str(process.pid), "1", "1"], capture_output=True, text=True, timeout=10)
+                print(sample.stdout.split("Binary Images:")[0], file=sys.stderr)
+            log.seek(0)
+            print(log.read().decode(errors="replace")[-8000:], file=sys.stderr)
+            raise
+        finally:
+            if process.poll() is None:
+                process.terminate()
+                try:
+                    process.wait(timeout=10)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                    process.wait()
+            clear_test_token()
@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+"""Import the CI certificate into an isolated keychain for one release command."""
+import base64
+import os
+import re
+import secrets
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+
+def security(*args):
+    result = subprocess.run(["security", *args], capture_output=True, text=True)
+    if result.returncode:
+        raise RuntimeError(f"security {args[0]} failed (output withheld to protect credentials)")
+    return result.stdout
+
+
+with tempfile.TemporaryDirectory(prefix="meetingnotes-signing-", dir=os.environ["RUNNER_TEMP"]) as directory:
+    keychain = str(Path(directory) / "release.keychain-db")
+    certificate = Path(directory) / "certificate.p12"
+    certificate.write_bytes(base64.b64decode(os.environ["APPLE_CERTIFICATE_P12"]))
+    certificate.chmod(0o600)
+    password = secrets.token_urlsafe(32)
+    created = False
+    try:
+        security("create-keychain", "-p", password, keychain)
+        created = True
+        security("set-keychain-settings", "-lut", "21600", keychain)
+        security("unlock-keychain", "-p", password, keychain)
+        security("import", str(certificate), "-k", keychain, "-P", os.environ["APPLE_CERTIFICATE_PASSWORD"], "-T", "/usr/bin/codesign", "-T", "/usr/bin/security")
+        security("set-key-partition-list", "-S", "apple-tool:,apple:", "-s", "-k", password, keychain)
+        identities = security("find-identity", "-v", "-p", "codesigning", keychain)
+        match = re.search(r'([0-9A-F]{40}) "Developer ID Application:', identities)
+        if not match:
+            raise RuntimeError("The certificate contains no valid Developer ID Application identity")
+        environment = dict(os.environ, SIGNING_IDENTITY=match[1], SIGNING_KEYCHAIN=keychain)
+        status = subprocess.run(sys.argv[1:], env=environment).returncode
+    finally:
+        if created:
+            security("delete-keychain", keychain)
+    sys.exit(status)
Author	SHA1	Message	Date
coder	83710bc1fe	Document one shared runner per host [skip ci]	2026-09-10 09:05:04 +02:00
coder	7584863392	fix: isolate CI Keychain access from the production app Build / macos (push) Successful in 27s Details	2026-09-10 00:33:30 +02:00
coder	31584792e6	fix: launch CI smoke app through macOS Launch Services Build / macos (push) Failing after 1m3s Details	2026-09-10 00:25:09 +02:00
coder	58fbe56298	ci: retire the superseded GitHub release workflows Build / macos (push) Failing after 1m22s Details	2026-09-10 00:08:31 +02:00
coder	4d87288f2f	ci: stage the Mac launch check on the internal volume Build / macos (push) Successful in 26s Details	2026-09-09 23:56:02 +02:00
coder	cda28cc6be	ci: preserve evidence when the Mac smoke launch stalls Build / macos (push) Failing after 1m1s Details	2026-09-09 23:51:29 +02:00
coder	df23c84474	ci: release notarized Meetingnotes updates through Gitea Build / macos (push) Failing after 57s Details	2026-09-09 23:49:37 +02:00
coder	2508c77f17	ci: build and smoke test main on the Gitea Mac runner Build / macos (push) Failing after 1m11s Details	2026-09-09 23:45:46 +02:00
coder	607e1236f7	fix: allow recording while meetings process	2026-08-27 16:05:23 +02:00
coder	204857cdd9	fix: infer actual system audio clock rate	2026-08-27 13:02:00 +02:00
coder	3a9ad8fe0c	fix: preserve diagnostics when merging meetings	2026-08-26 17:04:15 +02:00
coder	299986ab00	fix: preserve transcription failures and audio diagnostics	2026-08-26 16:43:43 +02:00
coder	66447b2510	fix: count Core Audio callback frames explicitly	2026-08-26 14:36:32 +02:00
coder	9f3805733b	fix: capture system audio as mono	2026-08-26 11:56:27 +02:00