@bli-cockpit/cli 0.2.275 → 0.2.277

package/dist/commands/local-help-notes.js

@@ -6,7 +6,7 @@ export const NOTES_HELP = [
             "Usage: cockpit notes [list|show <id>|shelf|shelves|folders|mkdir <path>|rmdir <path>|rename <path>|upload <paths...> [--wait]|paste|share <id>|unshare <id>|summarize <id>|move <id>|accounts|connect|detach <id>|sync <id>|sync-status [<id>]|recordings <note-id>|recording <id>|record start|stop|status|cancel|app install|uninstall|status] [flags]",
             "Audio uploads: MP3, M4A, WAV, WebM and OGG, up to 1 GB. Over 4 MB (a whole meeting) the file goes straight to storage and is transcribed in the background; --wait then polls for up to 4 hours and prints progress, otherwise for at most 330 seconds.",
             "",
-            "record start|stop [<session-id>]|status|cancel — record a meeting in a room from this machine's microphone (Apple Silicon macOS and Windows; Linux says it is not supported). On Windows the microphone needs Settings > Privacy & security > Microphone on, including Let desktop apps access your microphone. Nothing leaves the machine while recording and there is no auto-stop. `stop` trims the silence away locally, uploads only the speech, and Tower writes a note with Speaker 1, Speaker 2... lines (add --wait to watch the transcription). `cancel` stops and KEEPS the file; `status` lists what is recording or waiting; `stop <session-id>` finishes a cancelled or crashed session. The original recording stays on this machine.",
+            "record start|stop [<session-id>]|status|cancel — record a meeting in a room from this machine's microphone (Apple Silicon macOS and Windows; Linux says it is not supported). On Windows the microphone needs Settings > Privacy & security > Microphone on, including Let desktop apps access your microphone. Nothing leaves the machine while recording; the recorder stops by itself after 8 hours (under the 1 GB upload limit). `stop` uploads the whole original recording, silence included, and Tower writes a note with Speaker 1, Speaker 2... lines, or says no speech was detected (add --wait to watch the transcription). `cancel` stops and KEEPS the file; `status` lists what is recording and every session waiting for upload (`needs_upload`); `stop <session-id>` uploads a cancelled, crashed or auto-stopped session. The BLI Notetaker app uploads waiting sessions by itself. The recording also stays on this machine.",
             "app install|uninstall|status [--json] — the BLI Notetaker app (Apple Silicon macOS menu bar, or 64-bit Windows 10/11 taskbar notification area; Linux and Windows on Arm say they are not supported yet). `install` asks Tower for the newest release for this machine, downloads it, refuses it if its sha256 differs, and starts it at login: on the Mac it goes in ~/Applications/BLI Notetaker.app (replacing an older one, download quarantine cleared) with a LaunchAgent; on Windows it goes in %LOCALAPPDATA%\\Programs\\BLI Notetaker\\bli-notetaker.exe with a Startup entry (HKCU Run value, no admin; Windows does not block it because the CLI downloaded it). The menu runs the `record` verbs above: Record, Stop, Open last note, Finish last recording. Log: ~/Library/Logs/BLI Notetaker.log on the Mac, %LOCALAPPDATA%\\BLI Notetaker\\notetaker.log on Windows. `uninstall` removes the app and its startup entry and keeps your recordings and the log; `status` says what is installed, whether it runs, whether it starts at login, and whether a newer release exists.",
             "folders [--tree] [--json]: list folders and visible note counts.",
             "mkdir <path> [--json]: create a folder and any missing ancestors.",

package/dist/commands/notes-audio-direct.js

@@ -12,10 +12,19 @@
  * Step 2 goes to the storage host with the signed URL ONLY: the device token is
  * sent to Tower's own routes in steps 1 and 3 and never to anyone else.
  *
+ * A laptop recording (`recording`, from `cockpit notes record stop`, BLI-23470)
+ * also names its session to step 3, so Tower answers a repeat with the note it
+ * already made, and keeps the object key Tower issued in the session's
+ * `upload.json` before the PUT. The next try after a failed step 3 (a timeout
+ * after the server saved, a 5xx) asks step 3 again with that key and sends no
+ * byte; only when Tower says the object is not there (`upload_not_found`) does
+ * it upload again.
+ *
  * Nothing here throws; every failure comes back as a closed reason label and
  * the sentence Tower (or this file) wrote for it.
  */
 import { createReadStream } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
 import { Readable } from "node:stream";
 import { writeLine } from "./cli-io.js";
 import { ask, TAG } from "./notes-door.js";
@@ -23,8 +32,61 @@ import { noteAudioMime } from "./notes-file.js";
 /** A signed upload URL lives two hours; the PUT must finish inside that. */
 const PUT_DEADLINE_MS = 2 * 60 * 60 * 1000;
 const SMALL_DEADLINE_MS = 60_000;
+/** The object key a previous try of this session was issued, or null (no file, unreadable, another session's). */
+async function keptObjectKey(recording) {
+    try {
+        const kept = JSON.parse(await readFile(recording.stateFile, "utf8"));
+        return kept.session === recording.session && typeof kept.objectKey === "string" && kept.objectKey ? kept.objectKey : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function keepObjectKey(door, recording, objectKey, size) {
+    try {
+        await writeFile(recording.stateFile, `${JSON.stringify({ session: recording.session, objectKey, bytes: size, issuedAt: new Date().toISOString() })}\n`, { mode: 0o600 });
+    }
+    catch (error) {
+        // Not fatal: without it a retry sends the file again, and Tower's session check still makes one note.
+        writeLine(door.io.stderr, `${TAG} upload key not kept ${JSON.stringify({ session: recording.session, reason: error.code ?? "write_failed" })}`);
+    }
+}
+async function confirmSaved(door, input, objectKey) {
+    const saved = await ask(door, {
+        path: "/api/notes/audio/saved", method: "POST", label: "notes audio saved", timeoutMs: SMALL_DEADLINE_MS,
+        body: {
+            object_key: objectKey, file_name: input.fileName,
+            ...(input.exclude ? { exclusions: input.exclude } : {}),
+            ...(input.folder ? { folder_path: input.folder } : {}),
+            ...(input.recording ? { recording_session: input.recording.session } : {}),
+        },
+    });
+    if (!saved.ok)
+        return { ok: false, reason: saved.reason, detail: saved.detail };
+    return { ok: true, body: saved.body };
+}
+/**
+ * A recording whose file already reached storage on an earlier try: ask `/saved` again with the kept key. Null means
+ * "upload it" (nothing kept, or Tower says the object is not there); any other answer is final for this try.
+ */
+async function resumeKept(door, input, recording) {
+    const kept = await keptObjectKey(recording);
+    if (!kept)
+        return null;
+    writeLine(door.io.stderr, `${TAG} upload resumed ${JSON.stringify({ session: recording.session, bytes: input.size, reason: "object_key_kept" })}`);
+    const saved = await confirmSaved(door, input, kept);
+    if (saved.ok || saved.reason !== "upload_not_found")
+        return saved;
+    writeLine(door.io.stderr, `${TAG} upload resumed ${JSON.stringify({ session: recording.session, reason: "kept_object_not_in_storage" })}`);
+    return null;
+}
 export async function uploadAudioDirect(door, input) {
     const started = Date.now();
+    if (input.recording) {
+        const resumed = await resumeKept(door, input, input.recording);
+        if (resumed)
+            return resumed;
+    }
     const mediaType = noteAudioMime(input.fileName) ?? "";
     const target = await ask(door, {
         path: "/api/notes/audio/target", method: "POST", label: "notes audio target", timeoutMs: SMALL_DEADLINE_MS,
@@ -37,6 +99,9 @@ export async function uploadAudioDirect(door, input) {
     if (!issued.objectKey || !url) {
         return { ok: false, reason: "target_unreadable", detail: "Tower answered without an upload link." };
     }
+    // Kept BEFORE the PUT: a crash after the bytes landed still lets the next try ask `/saved` instead of re-sending.
+    if (input.recording)
+        await keepObjectKey(door, input.recording, issued.objectKey, input.size);
     writeLine(door.io.stderr, `Uploading ${input.fileName} (${(input.size / 1_000_000).toFixed(1)} MB) straight to storage...`);
     let put;
     try {
@@ -63,15 +128,5 @@ export async function uploadAudioDirect(door, input) {
                 : `Storage refused the upload (HTTP ${put.status}). Nothing was saved; try again.` };
     }
     writeLine(door.io.stderr, `${TAG} storage put ok ${JSON.stringify({ bytes: input.size, elapsed_ms: Date.now() - started })}`);
-    const saved = await ask(door, {
-        path: "/api/notes/audio/saved", method: "POST", label: "notes audio saved", timeoutMs: SMALL_DEADLINE_MS,
-        body: {
-            object_key: issued.objectKey, file_name: input.fileName,
-            ...(input.exclude ? { exclusions: input.exclude } : {}),
-            ...(input.folder ? { folder_path: input.folder } : {}),
-        },
-    });
-    if (!saved.ok)
-        return { ok: false, reason: saved.reason, detail: saved.detail };
-    return { ok: true, body: saved.body };
+    return await confirmSaved(door, input, issued.objectKey);
 }

package/dist/commands/notes-record-capture.js

@@ -18,6 +18,14 @@
  * always closes the file itself. It writes `ready` once the microphone is
  * really open and `failed.txt` (a closed reason label) if it cannot be.
  *
+ * BLI-23382: it also stops by itself once the file holds
+ * `MAX_RECORDING_SECONDS` of audio (8 hours, about 922 MB of 16 kHz mono
+ * 16-bit, under the 1,000,000,000-byte storage limit), writing `ended.txt`
+ * (`max_duration_reached`) and `done`. `status` then shows the session as
+ * stopped and waiting for upload. BLI-23470: the same stop fires after 8 hours
+ * on the wall clock, or once the file nears the storage limit
+ * (`max_size_reached`), whichever comes first (`RECORDER_STOP_RULE`).
+ *
  * Everything in a session lives in one directory under the collector's state
  * dir. Nothing here touches the network.
  */
@@ -28,6 +36,41 @@ import { randomBytes } from "node:crypto";
 import { getCollectorRuntimePaths } from "../local-state-paths.js";
 import { launchRecorderWin32, RECORDER_SCRIPT_WIN32 } from "./notes-record-capture-win32.js";
 export const RECORDING_SAMPLE_RATE = 16_000;
+/** The recorder stops by itself after this much audio (BLI-23382): 8 hours. */
+export const MAX_RECORDING_SECONDS = 28_800;
+/** What `MAX_RECORDING_SECONDS` of 16 kHz mono 16-bit audio weighs: 921,600,000 bytes, under the bucket's 1,000,000,000. */
+export const MAX_RECORDING_BYTES = MAX_RECORDING_SECONDS * RECORDING_SAMPLE_RATE * 2;
+/** The marker a recorder writes when it ended by itself, holding one closed reason label. */
+export const ENDED_MARKER = "ended.txt";
+/** Why a recorder ends by itself: the 8-hour cap (by audio or by the clock). */
+export const MAX_DURATION_REASON = "max_duration_reached";
+/** BLI-23470: or its file came near the storage limit first (only if the audio is not the format asked for). */
+export const MAX_SIZE_REASON = "max_size_reached";
+/** The storage bucket's per-object limit (`AUDIO_DIRECT_MAX_BYTES` on the server). */
+export const AUDIO_UPLOAD_LIMIT_BYTES = 1_000_000_000;
+/**
+ * BLI-23470: the macOS recorder stops once `audio.wav` reaches this, 1 MB under the limit: room for the WAV header
+ * and the chunks AVAudioRecorder adds, and for what it writes in one 0.2 s poll even at a far higher rate.
+ */
+export const RECORDER_STOP_BYTES = AUDIO_UPLOAD_LIMIT_BYTES - 1_000_000;
+/** BLI-23470: a recorder whose `audio.wav` has not changed for this long is not recording (both platforms write it continuously). */
+export const RECORDER_SILENT_AFTER_MS = 60_000;
+/** Asked again after this pause before calling it silent: a laptop just back from sleep writes again within a second. */
+export const RECORDER_SILENT_RECHECK_MS = 3_000;
+/** A session older than the 8-hour cap plus this has no recorder of ours behind it, whatever its pid says. */
+export const RECORDER_PAST_CAP_MARGIN_SECONDS = 15 * 60;
+/** BLI-23470: the session file keeping the object key Tower issued for its upload (see `notes-audio-direct.ts`). */
+export const UPLOAD_STATE_FILE = "upload.json";
+/**
+ * BLI-23470: when the macOS recorder stops by itself, as JavaScript it runs (and the tests run, with a fake clock).
+ * Whichever comes first: 8 hours of audio in the file, 8 hours on the wall clock since it started (the old tick
+ * count drifted), or the file nearing the storage limit. Returns the closed reason label, or null to keep recording.
+ */
+export const RECORDER_STOP_RULE = `function capReached(startedMs, nowMs, audioSeconds, fileBytes) {
+  if (audioSeconds >= ${MAX_RECORDING_SECONDS} || nowMs - startedMs >= ${MAX_RECORDING_SECONDS * 1000}) return '${MAX_DURATION_REASON}';
+  if (fileBytes >= ${RECORDER_STOP_BYTES}) return '${MAX_SIZE_REASON}';
+  return null;
+}`;
 /** The JXA recorder. `argv[0]` is the session directory. Reasons it writes to `failed.txt`: mic_denied, recorder_failed. */
 export const RECORDER_SCRIPT = `ObjC.import('AVFoundation');
 ObjC.import('Foundation');
@@ -37,8 +80,19 @@ function writeText(file, text) {
 }
 function exists(file) { return $.NSFileManager.defaultManager.fileExistsAtPath(file); }
 function tick(seconds) { $.NSRunLoop.currentRunLoop.runUntilDate($.NSDate.dateWithTimeIntervalSinceNow(seconds)); }
+function fileBytes(file) {
+  // Never throws: a size it cannot read is 0, and the audio and clock checks still stop the recorder.
+  try {
+    var attrs = $.NSFileManager.defaultManager.attributesOfItemAtPathError(file, null);
+    if (!attrs || attrs.isNil()) return 0;
+    var size = ObjC.unwrap(attrs.objectForKey('NSFileSize'));
+    return typeof size === 'number' ? size : 0;
+  } catch (e) { return 0; }
+}
+${RECORDER_STOP_RULE}
 function run(argv) {
   var dir = argv[0];
+  var startedMs = Date.now();
   var auth = $.AVCaptureDevice.authorizationStatusForMediaType('soun');
   if (auth === 1 || auth === 2) { writeText(dir + '/failed.txt', 'mic_denied'); $.exit(3); }
   var settings = $.NSDictionary.dictionaryWithObjectsForKeys(
@@ -55,6 +109,14 @@ function run(argv) {
     if (now === 1 || now === 2) { recorder.stop; writeText(dir + '/failed.txt', 'mic_denied'); $.exit(3); }
     if (!announced && now === 3) { announced = true; writeText(dir + '/ready', 'ok'); }
     if (!announced && waited > 120) { recorder.stop; writeText(dir + '/failed.txt', 'mic_permission_unanswered'); $.exit(5); }
+    // currentTime is the audio in the file; the wall clock and the file size are the backstops (BLI-23470).
+    var capped = capReached(startedMs, Date.now(), recorder.currentTime, fileBytes(dir + '/audio.wav'));
+    if (capped) {
+      recorder.stop;
+      writeText(dir + '/${ENDED_MARKER}', capped);
+      writeText(dir + '/done', 'ok');
+      $.exit(0);
+    }
   }
   recorder.stop;
   writeText(dir + '/done', 'ok');
@@ -66,7 +128,8 @@ export function recordingsRoot(homeDir) {
 }
 export const sessionDir = (root, id) => path.join(root, id);
 export const audioPath = (root, id) => path.join(root, id, "audio.wav");
-export const trimmedPath = (root, id) => path.join(root, id, `meeting-${id.slice(0, 13)}.wav`);
+/** The name Tower sees: a hard link to `audio.wav` (the same bytes), so the note is named after the meeting's time. */
+export const uploadPath = (root, id) => path.join(root, id, `meeting-${id.slice(0, 13)}.wav`);
 export function newSessionId(now) {
     const stamp = now.toISOString().replace(/[-:]/g, "").replace(/\..*$/, "").replace("T", "-");
     return `${stamp}-${randomBytes(2).toString("hex")}`;
@@ -108,6 +171,15 @@ export async function fileSize(file) {
         return null;
     }
 }
+/** How long ago `file` last changed, by the real clock, or null when it does not exist (BLI-23470). */
+export async function fileQuietMs(file) {
+    try {
+        return Math.max(0, Date.now() - (await stat(file)).mtimeMs);
+    }
+    catch {
+        return null;
+    }
+}
 export async function fileExists(file) {
     return (await fileSize(file)) !== null;
 }
@@ -119,6 +191,15 @@ export async function readReason(root, id) {
         return null;
     }
 }
+/** The closed reason a recorder wrote when it ended by itself (`ended.txt`), or null. */
+export async function readEndedReason(root, id) {
+    try {
+        return (await readFile(path.join(root, id, ENDED_MARKER), "utf8")).trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
 export async function requestStop(root, id) {
     await writeFile(path.join(root, id, "stop"), "stop\n", { mode: 0o600 });
 }

package/dist/commands/notes-record-wav.js

@@ -1,37 +1,14 @@
 /**
- * BLI-22979: the WAV file `cockpit notes record` writes, and the speech trim
- * that runs on it when a recording stops.
+ * BLI-22979: the WAV file `cockpit notes record` writes.
  *
- * The recorder (see `notes-record-capture.ts`) writes 16 kHz mono 16-bit PCM,
- * so a trim is plain arithmetic on samples: no codec, no native module, and it
- * runs the same on every machine. A recording that was killed leaves a header
- * that still says "0 bytes of audio"; `repairWavHeader` rewrites the two size
- * fields from the real file length so the file plays and trims again (R37: a
- * crashed session is recoverable, never lost).
- *
- * The trim is a voice-activity detector with a floor learned from the file
- * itself, so a quiet speaker in a quiet room is kept and a loud room is not
- * mistaken for speech. Every kept span is padded on both sides so a soft word
- * start or a trailing consonant is not clipped. The original file is never
- * modified by the trim; the caller keeps it.
+ * The recorder (see `notes-record-capture.ts`) writes 16 kHz mono 16-bit PCM.
+ * A recording that was killed leaves a header that still says "0 bytes of
+ * audio"; `repairWavHeader` rewrites the two size fields from the real file
+ * length so the file plays (R37: a crashed session is recoverable, never lost).
+ * That is the only change ever made to the file: BLI-23382 removed the local
+ * speech trim, so Tower receives the original recording, silence included.
  */
 import { open, stat } from "node:fs/promises";
-/** Frame length the detector measures, in seconds. */
-export const VAD_FRAME_SECONDS = 0.03;
-/** Padding kept on both sides of every speech span, in seconds. */
-export const VAD_PAD_SECONDS = 0.6;
-/** Silence shorter than this between two bursts of speech does not split them. */
-export const VAD_JOIN_GAP_SECONDS = 0.8;
-/** A burst shorter than this is a click or a cough, not speech. */
-export const VAD_MIN_SPEECH_SECONDS = 0.3;
-/** A frame must sit this far above the learned noise floor to count as speech. */
-export const VAD_MARGIN_DB = 12;
-/** Nothing quieter than this is ever speech, whatever the floor says. */
-export const VAD_ABSOLUTE_MIN_DB = -55;
-/** The bar never rises above this, so a file that is nearly all speech (a high floor) is still kept. */
-export const VAD_MAX_THRESHOLD_DB = -35;
-/** Less speech than this in total is "no speech": nothing is submitted. */
-export const VAD_MIN_TOTAL_SPEECH_SECONDS = 0.6;
 const HEADER_SCAN_BYTES = 4096;
 export async function readWavInfo(filePath) {
     const handle = await open(filePath, "r");
@@ -99,146 +76,4 @@ export async function repairWavHeader(filePath) {
         await handle.close();
     }
     return { ok: true, info: { ...read.info, dataBytes: read.info.dataBytes } };
-}
-/**
- * Speech spans (padded, merged) from per-frame loudness in dBFS. Pure, so the
- * trimming rules are tested without a file.
- */
-export function detectSpeechSpans(frameDb, frameSeconds = VAD_FRAME_SECONDS) {
-    const count = frameDb.length;
-    if (count === 0)
-        return { spans: [], speechSeconds: 0, noiseFloorDb: VAD_ABSOLUTE_MIN_DB, thresholdDb: VAD_ABSOLUTE_MIN_DB };
-    const sorted = Array.from({ length: count }, (_, i) => frameDb[i]).sort((a, b) => a - b);
-    const noiseFloorDb = sorted[Math.floor(count * 0.1)];
-    const thresholdDb = Math.min(Math.max(noiseFloorDb + VAD_MARGIN_DB, VAD_ABSOLUTE_MIN_DB), VAD_MAX_THRESHOLD_DB);
-    const total = count * frameSeconds;
-    // 1. Raw runs of loud frames.
-    let runs = [];
-    let runStart = -1;
-    for (let i = 0; i <= count; i += 1) {
-        const loud = i < count && frameDb[i] > thresholdDb;
-        if (loud && runStart < 0)
-            runStart = i;
-        if (!loud && runStart >= 0) {
-            runs.push({ startSeconds: runStart * frameSeconds, endSeconds: i * frameSeconds });
-            runStart = -1;
-        }
-    }
-    // 2. Join runs separated by a short gap, so a pause between words is not a cut.
-    const joined = [];
-    for (const run of runs) {
-        const last = joined.at(-1);
-        if (last && run.startSeconds - last.endSeconds <= VAD_JOIN_GAP_SECONDS)
-            last.endSeconds = run.endSeconds;
-        else
-            joined.push({ ...run });
-    }
-    // 3. Drop bursts too short to be speech.
-    runs = joined.filter((run) => run.endSeconds - run.startSeconds >= VAD_MIN_SPEECH_SECONDS);
-    const speechSeconds = runs.reduce((sum, run) => sum + (run.endSeconds - run.startSeconds), 0);
-    if (speechSeconds < VAD_MIN_TOTAL_SPEECH_SECONDS)
-        return { spans: [], speechSeconds, noiseFloorDb, thresholdDb };
-    // 4. Pad every span, clamp to the file, merge spans the padding made overlap.
-    const padded = [];
-    for (const run of runs) {
-        const span = { startSeconds: Math.max(0, run.startSeconds - VAD_PAD_SECONDS), endSeconds: Math.min(total, run.endSeconds + VAD_PAD_SECONDS) };
-        const last = padded.at(-1);
-        if (last && span.startSeconds <= last.endSeconds)
-            last.endSeconds = Math.max(last.endSeconds, span.endSeconds);
-        else
-            padded.push(span);
-    }
-    return { spans: padded, speechSeconds, noiseFloorDb, thresholdDb };
-}
-const CHUNK_BYTES = 1 << 20;
-/** Loudness of every frame, read in chunks so a long meeting is never held in memory. */
-export async function measureFrames(filePath, info) {
-    const frameSamples = Math.max(1, Math.round(info.sampleRate * VAD_FRAME_SECONDS));
-    const bytesPerFrame = frameSamples * info.channels * 2;
-    const frames = Math.floor(info.dataBytes / bytesPerFrame);
-    const out = new Float32Array(frames);
-    const handle = await open(filePath, "r");
-    try {
-        const framesPerChunk = Math.max(1, Math.floor(CHUNK_BYTES / bytesPerFrame));
-        const buffer = Buffer.alloc(framesPerChunk * bytesPerFrame);
-        for (let first = 0; first < frames; first += framesPerChunk) {
-            const want = Math.min(framesPerChunk, frames - first);
-            const { bytesRead } = await handle.read(buffer, 0, want * bytesPerFrame, info.dataOffset + first * bytesPerFrame);
-            const got = Math.floor(bytesRead / bytesPerFrame);
-            for (let f = 0; f < got; f += 1) {
-                let sum = 0;
-                const base = f * bytesPerFrame;
-                // First channel only: the recorder writes mono; a stereo file is judged on its left side.
-                for (let s = 0; s < frameSamples; s += 1) {
-                    const v = buffer.readInt16LE(base + s * info.channels * 2) / 32768;
-                    sum += v * v;
-                }
-                out[first + f] = 10 * Math.log10(Math.max(sum / frameSamples, 1e-10));
-            }
-        }
-    }
-    finally {
-        await handle.close();
-    }
-    return out;
-}
-/** Write only the padded speech spans of `inputPath` to `outputPath`. Writes nothing when no speech remains. */
-export async function trimToSpeech(inputPath, outputPath) {
-    const read = await readWavInfo(inputPath);
-    if (!read.ok)
-        return read;
-    const { info } = read;
-    const db = await measureFrames(inputPath, info);
-    const frameSeconds = Math.max(1, Math.round(info.sampleRate * VAD_FRAME_SECONDS)) / info.sampleRate;
-    const totalSeconds = info.dataBytes / (info.sampleRate * info.channels * 2);
-    const found = detectSpeechSpans(db, frameSeconds);
-    if (found.spans.length === 0) {
-        return { ok: true, speech: false, totalSeconds, speechSeconds: found.speechSeconds, noiseFloorDb: found.noiseFloorDb };
-    }
-    const frameBytes = info.channels * 2;
-    const ranges = found.spans.map((span) => {
-        const start = Math.floor(span.startSeconds * info.sampleRate) * frameBytes;
-        const end = Math.min(info.dataBytes - (info.dataBytes % frameBytes), Math.floor(span.endSeconds * info.sampleRate) * frameBytes);
-        return { start, end };
-    });
-    const dataBytes = ranges.reduce((sum, range) => sum + (range.end - range.start), 0);
-    const header = Buffer.alloc(44);
-    header.write("RIFF", 0, "ascii");
-    header.writeUInt32LE(36 + dataBytes, 4);
-    header.write("WAVEfmt ", 8, "ascii");
-    header.writeUInt32LE(16, 16);
-    header.writeUInt16LE(1, 20);
-    header.writeUInt16LE(info.channels, 22);
-    header.writeUInt32LE(info.sampleRate, 24);
-    header.writeUInt32LE(info.sampleRate * info.channels * 2, 28);
-    header.writeUInt16LE(info.channels * 2, 32);
-    header.writeUInt16LE(16, 34);
-    header.write("data", 36, "ascii");
-    header.writeUInt32LE(dataBytes, 40);
-    const source = await open(inputPath, "r");
-    const target = await open(outputPath, "w", 0o600);
-    try {
-        await target.write(header, 0, header.length, 0);
-        let position = header.length;
-        const buffer = Buffer.alloc(CHUNK_BYTES);
-        for (const range of ranges) {
-            for (let at = range.start; at < range.end;) {
-                const want = Math.min(buffer.length, range.end - at);
-                const { bytesRead } = await source.read(buffer, 0, want, info.dataOffset + at);
-                if (bytesRead === 0)
-                    break;
-                await target.write(buffer, 0, bytesRead, position);
-                position += bytesRead;
-                at += bytesRead;
-            }
-        }
-    }
-    finally {
-        await source.close();
-        await target.close();
-    }
-    return {
-        ok: true, speech: true, totalSeconds, speechSeconds: found.speechSeconds,
-        keptSeconds: dataBytes / (info.sampleRate * info.channels * 2), spans: found.spans.length, bytes: header.length + dataBytes,
-    };
 }

package/dist/commands/notes-record-win32-script.js

@@ -3,11 +3,17 @@
  * `notes-record-capture-win32.ts` (which launches it) so each file stays readable; the design notes live there.
  * Pure text: nothing here runs on import.
  */
+/**
+ * BLI-23382: the recorder stops by itself once it has written this many audio bytes: 8 hours of 16 kHz mono
+ * 16-bit (`MAX_RECORDING_BYTES` in `notes-record-capture.ts`, which imports this file, so the number is
+ * repeated here and a test pins the two together).
+ */
+export const WIN32_MAX_RECORDING_BYTES = 921_600_000;
 /**
  * The C# recorder. C# 5 and APIs of .NET Framework 4.x AND .NET 6+ only, so it
  * compiles under Windows PowerShell 5.1 (CodeDom) and PowerShell 7 (Roslyn).
  * Unmanaged WAVEHDRs and buffers, polled for WHDR_DONE: no delegate callback
- * that the GC could collect. Exit codes: 0 stopped, 2 no microphone, 3 mic
+ * that the GC could collect. Exit codes: 0 stopped (by `stop` or at the 8-hour cap, BLI-23382), 2 no microphone, 3 mic
  * denied, 4 recorder failed.
  */
 const RECORDER_CSHARP = String.raw `using System;
@@ -58,7 +64,8 @@ public sealed class BliRecorder
     const uint WhdrDone = 1;
     const int BufferCount = 8;
     const int BufferBytes = 3200;
-    const string Consent = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\CapabilityAccessManager\\ConsentStore\\microphone";
+    const long MaxBytes = ${WIN32_MAX_RECORDING_BYTES}L;
+    const string Consent ="SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\CapabilityAccessManager\\ConsentStore\\microphone";
 
     readonly string dir;
     bool ready;
@@ -242,6 +249,7 @@ public sealed class BliRecorder
             while (true)
             {
                 if (File.Exists(stopPath)) break;
+                if (total >= MaxBytes) { endedBy = "max_duration_reached"; break; }
                 if (clock.ElapsedMilliseconds - lastPrivacy >= 1000)
                 {
                     lastPrivacy = clock.ElapsedMilliseconds;
@@ -292,6 +300,7 @@ public sealed class BliRecorder
 
         Log("closed ended_by=" + endedBy + " buffers=" + buffers + " bytes=" + total);
         if (endedBy == "mic_denied") { Fail("mic_denied"); return 3; }
+        if (endedBy == "max_duration_reached") File.WriteAllText(Path.Combine(dir, "ended.txt"), endedBy);
         File.WriteAllText(Path.Combine(dir, "done"), "ok");
         return 0;
     }

package/dist/commands/notes-record.js

@@ -4,28 +4,41 @@
  * note with "Speaker N" lines.
  *
  *   start   opens the microphone and returns; the recorder keeps running.
- *   stop    closes it, trims the silence away on this machine, and uploads the
- *           trimmed audio through `cockpit notes upload` (the direct uploader),
- *           so Tower transcribes and labels the speakers exactly as it does
- *           for any other audio. `stop <session-id>` finishes a cancelled or
- *           crashed session the same way.
- *   cancel  closes the microphone and KEEPS the file (R37); nothing is uploaded.
- *   status  shows what is recording and what is recoverable, with time and size.
+ *   stop    closes it and uploads the ORIGINAL recording, untouched (only a
+ *           killed recorder's WAV header is repaired), through `cockpit notes
+ *           upload` (the direct uploader), so Tower transcribes and labels the
+ *           speakers exactly as it does for any other audio. Silence is
+ *           uploaded too; Tower names a recording with no speech. `stop
+ *           <session-id>` finishes a cancelled, crashed, auto-stopped or
+ *           failed-upload session the same way.
+ *   cancel  closes the microphone and KEEPS the file (R37); nothing is uploaded
+ *           yet. The BLI Notetaker app uploads it by itself (BLI-23382).
+ *   status  shows what is recording and every session waiting for upload
+ *           (`needs_upload: true`), with time and size.
  *
- * Nothing leaves the machine while recording, and there is no auto-stop. The
- * original file is never deleted or changed by the trim. Apple Silicon macOS
- * and Windows (BLI-23208) record; any other platform refuses by name. Both
- * platforms share one session directory, marker files, JSON answers and WAV
- * format, so the trim, upload and recovery below are the same code.
+ * Nothing leaves the machine while recording. The recorder stops by itself at
+ * `MAX_RECORDING_SECONDS` (8 hours) so the file stays under the 1 GB upload
+ * limit. Apple Silicon macOS and Windows (BLI-23208) record; any other platform
+ * refuses by name. Both platforms share one session directory, marker files,
+ * JSON answers and WAV format, so the upload and recovery below are one code path.
+ *
+ * BLI-23470: a session whose pid answers but whose recorder is plainly gone
+ * (silent file, past the cap, never opened the microphone) is crashed, so it
+ * uploads and `start` works again; an upload names its session and keeps the
+ * object key Tower issued (`upload.json`), so a retry makes no second note and
+ * sends no byte twice; failed uploads are counted on the session and `status`
+ * reports them (`upload_failures`, `last_attempt_age_seconds`) for the app's
+ * backoff.
  *
  * Capture is `notes-record-capture.ts` (macOS) and
- * `notes-record-capture-win32.ts` (Windows); the speech trim is `notes-record-wav.ts`.
+ * `notes-record-capture-win32.ts` (Windows); the header repair is `notes-record-wav.ts`.
  */
+import { link, rm } from "node:fs/promises";
 import path from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 import { writeLine } from "./cli-io.js";
-import { audioPath, fileExists, fileSize, launchRecorder, listSessions, newSessionId, prepareSessionDir, processAlive, readReason, recordingsRoot, requestStop, sessionDir, trimmedPath, writeSession, RECORDING_SAMPLE_RATE, } from "./notes-record-capture.js";
-import { repairWavHeader, trimToSpeech } from "./notes-record-wav.js";
+import { audioPath, fileExists, fileQuietMs, fileSize, launchRecorder, listSessions, newSessionId, prepareSessionDir, processAlive, readEndedReason, readReason, recordingsRoot, requestStop, sessionDir, uploadPath, writeSession, MAX_RECORDING_SECONDS, RECORDER_PAST_CAP_MARGIN_SECONDS, RECORDER_SILENT_AFTER_MS, RECORDER_SILENT_RECHECK_MS, RECORDING_SAMPLE_RATE, UPLOAD_STATE_FILE, } from "./notes-record-capture.js";
+import { repairWavHeader } from "./notes-record-wav.js";
 const TAG = "[notes record]";
 const READY_DEADLINE_MS = 150_000;
 const STOP_DEADLINE_MS = 10_000;
@@ -42,13 +55,72 @@ export function defaultRecordDeps(io, upload) {
         }
         catch { /* already gone */ } },
         upload,
+        audioQuietMs: fileQuietMs,
     };
 }
-const stateOf = (session, deps) => {
-    if (!session.endedAt)
-        return deps.alive(session.pid) ? "recording" : "crashed";
-    return session.endedBy === "cancel" ? "cancelled" : "stopped";
-};
+/**
+ * Where a session stands. Order matters: an end the CLI wrote, then an end the recorder wrote (`ended.txt`
+ * at the 8-hour cap, or `done`), then a live process. A marker outranks the pid, so a pid the system reused
+ * never pins a finished recorder as "recording". `endedReason` is the recorder's closed label, if it wrote one.
+ *
+ * BLI-23470: a live pid is not proof either. With no marker, a pid the system reused (or one owned by another
+ * user, EPERM) would pin a crashed session as "recording" forever: never uploaded, and `start` refused. So a
+ * process that looks alive still counts as crashed when its recorder is plainly not recording (`recorderGone`).
+ */
+async function viewOf(root, session, deps, io) {
+    if (session.endedAt)
+        return { state: session.endedBy === "cancel" ? "cancelled" : "stopped", endedReason: null };
+    const ended = await readEndedReason(root, session.id);
+    if (ended)
+        return { state: "stopped", endedReason: ended };
+    if (await fileExists(path.join(sessionDir(root, session.id), "done")))
+        return { state: "stopped", endedReason: null };
+    if (!deps.alive(session.pid))
+        return { state: "crashed", endedReason: null };
+    const gone = await recorderGone(root, session, deps, io);
+    return gone ? { state: "crashed", endedReason: gone } : { state: "recording", endedReason: null };
+}
+/**
+ * Why a session whose pid answers is not really recording, or null when it is. Judged on the session's own files:
+ *   - `recorder_past_cap`: started longer ago than the 8-hour cap plus a margin; no recorder of ours runs that long.
+ *   - `recorder_never_ready`: the microphone never opened (no `ready`) and `start` gave up waiting long ago.
+ *   - `recorder_silent`: the microphone opened, but `audio.wav` has not changed for `RECORDER_SILENT_AFTER_MS`.
+ *     Asked twice, `RECORDER_SILENT_RECHECK_MS` apart: right after a laptop wakes from sleep the file is old
+ *     but the recorder writes again within a second, and that recording must not be cut off.
+ */
+async function recorderGone(root, session, deps, io) {
+    const ageMs = deps.now().getTime() - Date.parse(session.startedAt);
+    let reason = null;
+    if (ageMs > (MAX_RECORDING_SECONDS + RECORDER_PAST_CAP_MARGIN_SECONDS) * 1000)
+        reason = "recorder_past_cap";
+    else if (!(await fileExists(path.join(sessionDir(root, session.id), "ready")))) {
+        if (ageMs > READY_DEADLINE_MS + RECORDER_SILENT_AFTER_MS)
+            reason = "recorder_never_ready";
+    }
+    else {
+        const audio = audioPath(root, session.id);
+        const quiet = await deps.audioQuietMs(audio);
+        if (quiet !== null && quiet > RECORDER_SILENT_AFTER_MS) {
+            const before = await fileSize(audio);
+            await deps.sleep(RECORDER_SILENT_RECHECK_MS);
+            const again = await deps.audioQuietMs(audio);
+            // The size too: a file system that is slow to move the modified time still shows the bytes growing.
+            if (again !== null && again > RECORDER_SILENT_AFTER_MS && (await fileSize(audio)) === before)
+                reason = "recorder_silent";
+        }
+    }
+    if (reason) {
+        writeLine(io.stderr, `${TAG} recorder gone ${JSON.stringify({ session: session.id, pid: session.pid, reason, age_s: Math.round(ageMs / 1000) })}`);
+    }
+    return reason;
+}
+async function findRecording(root, sessions, deps, io) {
+    for (const session of sessions) {
+        if ((await viewOf(root, session, deps, io)).state === "recording")
+            return session;
+    }
+    return undefined;
+}
 const MIC_DENIED_DARWIN = "The microphone is blocked for this terminal. Open System Settings > Privacy & Security > Microphone, switch your terminal app on, then run `cockpit notes record start` again.";
 const MIC_DENIED_WIN32 = "The microphone is blocked. Open Settings > Privacy & security > Microphone, turn on Microphone access and Let desktop apps access your microphone, then run `cockpit notes record start` again.";
 /** The sentence for a recorder reason, per platform: the macOS and Windows microphone switches live in different places. */
@@ -98,7 +170,7 @@ export async function runNotesRecord(command, io, deps) {
 }
 async function startRecording(command, io, deps, root) {
     const sessions = await listSessions(root);
-    const running = sessions.find((s) => stateOf(s, deps) === "recording");
+    const running = await findRecording(root, sessions, deps, io);
     if (running) {
         return refuse(io, command, "already_recording", `A recording is already running (started ${running.startedAt}). Run \`cockpit notes record stop\` to finish it or \`cockpit notes record cancel\` to keep the file and stop.`);
     }
@@ -120,7 +192,7 @@ async function startRecording(command, io, deps, root) {
         }
         if (await fileExists(`${sessionDir(root, id)}/ready`)) {
             writeLine(io.stderr, `${TAG} recording ${JSON.stringify({ session: id, reason: "mic_open" })}`);
-            return say(io, command, `Recording. Nothing leaves this machine until you run \`cockpit notes record stop\`.\nFile: ${audioPath(root, id)}`, { session: id, state: "recording", file: audioPath(root, id) });
+            return say(io, command, `Recording. Nothing leaves this machine until you run \`cockpit notes record stop\`. It stops by itself after ${MAX_RECORDING_SECONDS / 3600} hours.\nFile: ${audioPath(root, id)}`, { session: id, state: "recording", file: audioPath(root, id) });
         }
         if (!deps.alive(pid)) {
             await writeSession(root, { ...session, endedAt: deps.now().toISOString(), endedBy: "cancel" });
@@ -140,85 +212,143 @@ async function closeRecorder(root, session, deps) {
         deps.kill(session.pid);
 }
 async function cancelRecording(command, io, deps, root) {
-    const running = (await listSessions(root)).find((s) => stateOf(s, deps) === "recording");
+    const running = await findRecording(root, await listSessions(root), deps, io);
     if (!running)
         return refuse(io, command, "not_recording", "No recording is running.");
     await closeRecorder(root, running, deps);
-    await repairWavHeader(audioPath(root, running.id));
+    if (await fileExists(audioPath(root, running.id)))
+        await repairWavHeader(audioPath(root, running.id));
     await writeSession(root, { ...running, endedAt: deps.now().toISOString(), endedBy: "cancel" });
     const bytes = await fileSize(audioPath(root, running.id));
     writeLine(io.stderr, `${TAG} cancelled ${JSON.stringify({ session: running.id, bytes })}`);
-    return say(io, command, `Stopped. Nothing was uploaded and the file is kept (${megabytes(bytes)}): ${audioPath(root, running.id)}\nFinish it later with \`cockpit notes record stop ${running.id}\`.`, { session: running.id, state: "cancelled", file: audioPath(root, running.id), bytes });
+    return say(io, command, `Stopped. Nothing was uploaded yet and the file is kept (${megabytes(bytes)}): ${audioPath(root, running.id)}\nThe BLI Notetaker app uploads it by itself; or run \`cockpit notes record stop ${running.id}\`.`, { session: running.id, state: "cancelled", file: audioPath(root, running.id), bytes });
+}
+/**
+ * Why a session's audio cannot be sent, or null when it can. Records the reason on the session, so `status`
+ * stops listing it and nothing (the app's timer included) retries it forever. The file is never deleted.
+ */
+async function unsendable(root, session, deps) {
+    const audio = audioPath(root, session.id);
+    let reason = null;
+    if (!(await fileExists(audio)))
+        reason = "no_file";
+    else {
+        const repaired = await repairWavHeader(audio);
+        if (!repaired.ok)
+            reason = repaired.reason;
+    }
+    if (reason)
+        await writeSession(root, { ...session, nothingToUpload: { at: deps.now().toISOString(), reason } });
+    return reason;
+}
+/**
+ * The file handed to the uploader: `meeting-<stamp>.wav`, a hard link to `audio.wav` (the same bytes, so the
+ * note is named after the meeting's time rather than "audio"). Whatever sat at that name is removed first
+ * (CLIs before BLI-23382 wrote a trimmed copy there). If this disk cannot link, `audio.wav` itself is sent.
+ */
+async function fileToSend(root, id, io) {
+    const audio = audioPath(root, id);
+    const named = uploadPath(root, id);
+    try {
+        await rm(named, { force: true });
+        await link(audio, named);
+        return named;
+    }
+    catch (error) {
+        writeLine(io.stderr, `${TAG} upload name not linked ${JSON.stringify({ session: id, reason: error.code ?? "link_failed" })}`);
+        return audio;
+    }
 }
 async function stopRecording(command, io, deps, root) {
     const sessions = await listSessions(root);
     const target = command.sessionId
         ? sessions.find((s) => s.id === command.sessionId)
-        : sessions.find((s) => stateOf(s, deps) === "recording");
+        : await findRecording(root, sessions, deps, io);
     if (!target) {
-        const waiting = sessions.filter((s) => !s.submittedAt);
-        const hint = waiting.length ? ` Recoverable: ${waiting.map((s) => s.id).join(", ")} (\`cockpit notes record stop <id>\`).` : "";
+        const waiting = sessions.filter((s) => !s.submittedAt && !s.nothingToUpload);
+        const hint = waiting.length ? ` Waiting for upload: ${waiting.map((s) => s.id).join(", ")} (\`cockpit notes record stop <id>\`).` : "";
         return refuse(io, command, command.sessionId ? "unknown_session" : "not_recording", command.sessionId ? `No recording called ${command.sessionId}.${hint}` : `No recording is running.${hint}`);
     }
     if (target.submittedAt) {
         return refuse(io, command, "already_submitted", `Recording ${target.id} was already submitted at ${target.submittedAt}.`);
     }
     let session = target;
-    if (stateOf(target, deps) === "recording") {
+    const view = await viewOf(root, target, deps, io);
+    if (view.state === "recording") {
         await closeRecorder(root, target, deps);
         session = { ...target, endedAt: deps.now().toISOString(), endedBy: "stop" };
         await writeSession(root, session);
     }
-    const audio = audioPath(root, session.id);
-    const repaired = await repairWavHeader(audio);
-    if (!repaired.ok) {
-        return refuse(io, command, `audio_${repaired.reason}`, `The recording could not be read (${repaired.reason}). The file is kept at ${audio}; nothing was uploaded.`);
-    }
-    const trimmed = trimmedPath(root, session.id);
-    const result = await trimToSpeech(audio, trimmed);
-    if (!result.ok) {
-        return refuse(io, command, `audio_${result.reason}`, `The recording could not be trimmed (${result.reason}). The file is kept at ${audio}; nothing was uploaded.`);
-    }
-    if (!result.speech) {
-        writeLine(io.stderr, `${TAG} no speech ${JSON.stringify({ session: session.id, total_s: Math.round(result.totalSeconds), speech_s: Number(result.speechSeconds.toFixed(2)) })}`);
-        return say(io, command, `No speech was found in ${clock(result.totalSeconds)} of audio, so nothing was submitted. The recording is kept: ${audio}`, { session: session.id, state: "no_speech", submitted: false, total_seconds: Math.round(result.totalSeconds), file: audio });
+    else if (view.endedReason?.startsWith("recorder_")) {
+        // BLI-23470: its pid answers but the recorder is gone (`recorderGone`). Ask a recorder that may still be there to
+        // close its file, but never kill: that pid may belong to somebody else's process now. Pinned as stopped.
+        await requestStop(root, target.id);
+        for (let waited = 0; waited < STOP_DEADLINE_MS && deps.alive(target.pid); waited += POLL_MS)
+            await deps.sleep(POLL_MS);
+        session = { ...target, endedAt: deps.now().toISOString(), endedBy: "stop" };
+        await writeSession(root, session);
     }
-    writeLine(io.stderr, `${TAG} trimmed ${JSON.stringify({ session: session.id, total_s: Math.round(result.totalSeconds), kept_s: Math.round(result.keptSeconds), spans: result.spans, bytes: result.bytes })}`);
-    if (!command.json) {
-        writeLine(io.stderr, `Kept ${clock(result.keptSeconds)} of speech from ${clock(result.totalSeconds)}. Uploading...`);
+    const audio = audioPath(root, session.id);
+    const reason = await unsendable(root, session, deps);
+    if (reason) {
+        writeLine(io.stderr, `${TAG} nothing to upload ${JSON.stringify({ session: session.id, reason })}`);
+        return refuse(io, command, `audio_${reason}`, `The recording has no audio that can be sent (${reason}). Nothing was uploaded; it will not be tried again. Any file is kept in ${sessionDir(root, session.id)}.`);
     }
-    const code = await deps.upload({ ...command, action: "upload", paths: [trimmed] }, trimmed);
+    const bytes = await fileSize(audio);
+    const sent = await fileToSend(root, session.id, io);
+    writeLine(io.stderr, `${TAG} uploading original ${JSON.stringify({ session: session.id, bytes, seconds: Math.round(audioSeconds(bytes)), ended_reason: view.endedReason })}`);
+    if (!command.json)
+        writeLine(io.stderr, `Uploading the whole recording (${clock(audioSeconds(bytes))}, ${megabytes(bytes)})...`);
+    // BLI-23470: the upload names this session, and keeps the object key Tower issued beside the audio, so a retry after
+    // `/saved` failed asks Tower again instead of sending the whole file twice (and Tower answers with the same note).
+    const recordingUpload = { session: session.id, stateFile: path.join(sessionDir(root, session.id), UPLOAD_STATE_FILE) };
+    const code = await deps.upload({ ...command, action: "upload", paths: [sent], recordingUpload }, sent);
     if (code !== 0) {
-        writeLine(io.stderr, `${TAG} upload failed ${JSON.stringify({ session: session.id, exit: code })}`);
-        writeLine(io.stderr, `The upload did not finish. Both files are kept; run \`cockpit notes record stop ${session.id}\` to try again.`);
+        // Counted on the session, so the app's retries back off across restarts (5 min doubling to 1 h, `backoff.rs`).
+        const failures = (session.uploadFailures ?? 0) + 1;
+        await writeSession(root, { ...session, uploadFailures: failures, lastUploadAttemptAt: deps.now().toISOString() });
+        writeLine(io.stderr, `${TAG} upload failed ${JSON.stringify({ session: session.id, exit: code, upload_failures: failures })}`);
+        writeLine(io.stderr, `The upload did not finish. The recording is kept; the BLI Notetaker app tries again by itself, or run \`cockpit notes record stop ${session.id}\`.`);
         return code;
     }
     await writeSession(root, { ...session, submittedAt: deps.now().toISOString() });
-    writeLine(io.stderr, `${TAG} submitted ${JSON.stringify({ session: session.id, kept_s: Math.round(result.keptSeconds) })}`);
-    writeLine(io.stderr, `The original recording stays on this machine: ${audio}`);
+    writeLine(io.stderr, `${TAG} submitted ${JSON.stringify({ session: session.id, bytes })}`);
+    writeLine(io.stderr, `The recording also stays on this machine: ${audio}`);
     return 0;
 }
+const NOTE = {
+    recording: "recording now",
+    crashed: "the recorder died; the audio so far is kept",
+    cancelled: "cancelled; file kept",
+    stopped: "stopped, not yet uploaded",
+};
 async function recordingStatus(command, io, deps, root) {
-    const sessions = (await listSessions(root)).filter((s) => !s.submittedAt);
+    const sessions = (await listSessions(root)).filter((s) => !s.submittedAt && !s.nothingToUpload);
     const rows = [];
     for (const session of sessions) {
-        const state = stateOf(session, deps);
+        const { state, endedReason } = await viewOf(root, session, deps, io);
         const bytes = await fileSize(audioPath(root, session.id));
         if (state !== "recording" && bytes === null)
             continue;
-        const elapsed = state === "recording" ? (deps.now().getTime() - Date.parse(session.startedAt)) / 1000 : audioSeconds(bytes);
-        rows.push({ session: session.id, state, started_at: session.startedAt, elapsed_seconds: Math.round(elapsed), bytes, file: audioPath(root, session.id) });
+        const now = deps.now().getTime();
+        const elapsed = state === "recording" ? (now - Date.parse(session.startedAt)) / 1000 : audioSeconds(bytes);
+        const lastAttempt = session.lastUploadAttemptAt ? Date.parse(session.lastUploadAttemptAt) : Number.NaN;
+        rows.push({
+            session: session.id, state, needs_upload: state !== "recording", ended_reason: endedReason,
+            started_at: session.startedAt, elapsed_seconds: Math.round(elapsed), bytes, file: audioPath(root, session.id),
+            // BLI-23470: what the app's backoff reads. Seconds since the last failed upload, so no clock is compared across processes.
+            upload_failures: session.uploadFailures ?? 0,
+            last_attempt_age_seconds: Number.isFinite(lastAttempt) ? Math.max(0, Math.round((now - lastAttempt) / 1000)) : null,
+        });
     }
-    writeLine(io.stderr, `${TAG} status ${JSON.stringify({ sessions: rows.length })}`);
+    writeLine(io.stderr, `${TAG} status ${JSON.stringify({ sessions: rows.length, needs_upload: rows.filter((row) => row.needs_upload).length })}`);
     if (command.json)
         return say(io, command, "", { sessions: rows });
     if (rows.length === 0)
-        return say(io, command, "No recording is running and none is waiting to be finished.", {});
+        return say(io, command, "No recording is running and none is waiting for upload.", {});
     const lines = rows.map((row) => {
-        const note = row.state === "recording" ? "recording now"
-            : row.state === "crashed" ? "the recorder died; the audio so far is kept"
-                : row.state === "cancelled" ? "cancelled; file kept" : "stopped, not yet uploaded";
-        const next = row.state === "recording" ? "" : `  finish with: cockpit notes record stop ${row.session}`;
+        const note = row.ended_reason === "max_duration_reached" ? `stopped by itself at ${MAX_RECORDING_SECONDS / 3600} hours, not yet uploaded` : NOTE[row.state];
+        const next = row.needs_upload ? `  waiting for upload (the BLI Notetaker app sends it by itself), or: cockpit notes record stop ${row.session}` : "";
         return `${row.session}  ${row.state}  ${clock(row.elapsed_seconds)}  ${megabytes(row.bytes)}  (${note})${next ? `\n${next}` : ""}`;
     });
     return say(io, command, lines.join("\n"), {});

package/dist/commands/notes-writes.js

@@ -80,9 +80,12 @@ async function uploadOneNote(command, door, filePath) {
  * upload route.
  */
 async function sendNoteFile(command, door, filePath, read) {
-    if (read.direct) {
+    // BLI-23470: a laptop recording always goes direct, whatever its size, so it names its session to `/saved` and a
+    // retry never makes a second note (the small-file route has no session check).
+    if (read.direct || (command.recordingUpload && noteAudioMime(read.fileName))) {
         const direct = await uploadAudioDirect(door, {
             filePath, fileName: read.fileName, size: read.size, exclude: command.exclude, folder: command.folder,
+            ...(command.recordingUpload ? { recording: command.recordingUpload } : {}),
         });
         return direct.ok ? { ok: true, body: direct.body } : { ok: false, reason: direct.reason, detail: direct.detail };
     }

package/dist/commands/public-root.js

@@ -21,7 +21,7 @@ export async function runCockpitCli(argv, io) {
   }
 
   if (command === "--version" || command === "-V" || command === "version") {
-    writeLine(io?.stdout ?? process.stdout, "0.2.275");
+    writeLine(io?.stdout ?? process.stdout, "0.2.277");
     return 0;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.275",
+  "version": "0.2.277",
   "private": false,
   "type": "module",
   "bin": {