clavarium 0.2.365-next.1 → 0.2.366-next.1

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "clavarium",
-  "version": "0.2.365-next.1",
+  "version": "0.2.366-next.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "clavarium",
-      "version": "0.2.365-next.1",
+      "version": "0.2.366-next.1",
       "license": "MIT",
       "dependencies": {
         "@xterm/addon-fit": "^0.11.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clavarium",
-  "version": "0.2.365-next.1",
+  "version": "0.2.366-next.1",
   "license": "MIT",
   "type": "module",
   "description": "A conversation is a VM with a terminal in it. Everything else is a folder.",

package/server/boxcollect.mjs

@@ -0,0 +1,276 @@
+/* A COLLECT SESSION (07-11): a box's false wakes gathered on purpose, to train its next wake-word model (v3).
+ *
+ * For a set time (an empty home: the owner's go), each time the box listens nothing goes to its conversation and
+ * nothing is answered: the wake clip (wake.clip: the exact 1.6 s the box sends, 16 kHz 16-bit mono) and the first
+ * seconds after it are kept here, with one line of what is known -- no one labels them, no one listens:
+ *
+ *   <dir>/<YYYY-MM-DD>/<n>.wav          the wake clip, as sent (UTC day)
+ *   <dir>/<YYYY-MM-DD>/<n>-suite.wav    the next AFTER_MAX seconds at most (a radio: more of the same)
+ *   <dir>/<YYYY-MM-DD>/index.jsonl      { n, at, box, tag, reason, score, heard, word, voice, end, station, clip, after }
+ *   <dir>/state.json                    { <boxId>: { from, until, tag, after, radio, volume, station, ... } }
+ *   <dir>/ended.json                    { <boxId>: the last session, ended (shown on the box's card: « Exporter ») }
+ *
+ * RADIO (optional): the box asks the Google Home beside it, aloud, for one French station after another
+ * (« Ok Google, mets France Inter »), every `every` minutes, and « Ok Google, stop » at the end. No wake for
+ * QUIET_WARN_MS after a station was asked: said in the log (the speaker may not have obeyed).
+ *
+ * Off by itself at its end time, at COUNT_MAX entries or BYTES_MAX bytes on disk. Started and stopped by the
+ * operator only (/api/boxes/<id>/collect, behind the sign-on), never by a tool. exportZip(): the clips, laid out
+ * as the training notebook (v2, cell 7 bis) takes its negative examples: folders of 16 kHz WAV.
+ */
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync, renameSync } from 'node:fs';
+import { join } from 'node:path';
+import { Refusal } from './conversations.mjs';
+import { wavOf } from './boxes.mjs';
+
+export const COUNT_MAX = 1500;
+export const BYTES_MAX = 300 * 1024 * 1024;
+export const AFTER_DEFAULT = 8;
+export const AFTER_MAX = 30;
+export const HOURS_MAX = 12;
+export const EVERY_DEFAULT = 60;
+export const QUIET_WARN_MS = 20 * 60_000;
+export const GRACE_MS = 5 * 60_000;
+export const VOLUME_DEFAULT = 4;    /* the Google Home's own scale, 0-10: a radio heard across the room, not loud */
+/* French talk and music stations, as a Google Home knows them by name. */
+export const STATIONS = ['France Inter', 'France Info', 'RTL', 'Europe 1', 'France Culture', 'Nostalgie', 'FIP', 'RMC'];
+export const TAG = /^[a-z0-9-]{1,20}$/;
+const BOX_ID = /^[0-9a-f-]{36}$/;
+const DAY = /^\d{4}-\d{2}-\d{2}$/;
+const dayOf = (t) => new Date(t).toISOString().slice(0, 10);
+const timeOf = (v) => { const t = typeof v === 'number' ? v : Date.parse(String(v ?? '')); return Number.isFinite(t) ? t : NaN; };
+
+export const stationPhrase = (name) => `Ok Google, mets ${name}`;
+export const volumePhrase = (level) => `Ok Google, mets le volume à ${level}`;
+export const STOP_PHRASE = 'Ok Google, stop';
+
+export class BoxCollect {
+    #dir; #now; #log; #state; #countMax; #bytesMax; #usage = null; #next = new Map(); #ended = {};
+
+    constructor({ dir, now = () => Date.now(), log = () => {}, countMax = COUNT_MAX, bytesMax = BYTES_MAX }) {
+        this.#dir = dir; this.#now = now; this.#log = log; this.#countMax = countMax; this.#bytesMax = bytesMax;
+        try { this.#state = JSON.parse(readFileSync(join(dir, 'state.json'), 'utf8')); } catch { this.#state = {}; }
+        if (!this.#state || typeof this.#state !== 'object') this.#state = {};
+        try { this.#ended = JSON.parse(readFileSync(join(dir, 'ended.json'), 'utf8')) ?? {}; } catch { this.#ended = {}; }
+    }
+
+    #save() {
+        mkdirSync(this.#dir, { recursive: true });
+        const file = join(this.#dir, 'state.json');
+        writeFileSync(`${file}.tmp`, JSON.stringify(this.#state, null, 1)); renameSync(`${file}.tmp`, file);
+    }
+
+    /* What is on disk, counted once, then kept up to date. */
+    #used() {
+        if (this.#usage) return this.#usage;
+        let count = 0; let bytes = 0;
+        for (const day of existsSync(this.#dir) ? readdirSync(this.#dir).filter((d) => DAY.test(d)) : []) {
+            for (const f of readdirSync(join(this.#dir, day))) {
+                try { bytes += statSync(join(this.#dir, day, f)).size; } catch { /* gone meanwhile */ }
+                if (/^\d+\.wav$/.test(f)) count++;
+            }
+        }
+        this.#usage = { count, bytes };
+        return this.#usage;
+    }
+
+    /* {from?, until, tag?, after?, radio?, every?, volume?, stations?} -> the state. */
+    start(boxId, body = {}) {
+        if (!BOX_ID.test(String(boxId))) throw new Refusal(400, 'Not a box id.');
+        const now = this.#now();
+        const from = body.from == null ? now : timeOf(body.from);
+        const until = timeOf(body.until);
+        if (!Number.isFinite(from) || !Number.isFinite(until)) throw new Refusal(400, 'An end time, please (until: ISO date).');
+        if (until <= Math.max(now, from)) throw new Refusal(400, 'The end time is already past.');
+        if (until - Math.max(now, from) > HOURS_MAX * 3_600_000) throw new Refusal(400, `${HOURS_MAX} hours at most.`);
+        const tag = String(body.tag ?? 'radio');
+        if (!TAG.test(tag)) throw new Refusal(400, 'A tag of a-z, 0-9 and -, 20 characters at most.');
+        const after = Math.round(Number(body.after ?? AFTER_DEFAULT));
+        if (!Number.isFinite(after) || after < 0 || after > AFTER_MAX) throw new Refusal(400, `after: 0 to ${AFTER_MAX} seconds.`);
+        const every = Math.round(Number(body.every ?? EVERY_DEFAULT));
+        if (!Number.isFinite(every) || every < 10 || every > 240) throw new Refusal(400, 'every: 10 to 240 minutes.');
+        const volume = Math.round(Number(body.volume ?? VOLUME_DEFAULT));
+        if (!Number.isFinite(volume) || volume < 1 || volume > 10) throw new Refusal(400, 'volume: 1 to 10 (the speaker\'s scale).');
+        const stations = Array.isArray(body.stations) && body.stations.length
+            ? body.stations.map((s) => String(s).replace(/[^\p{L}\p{N} '-]/gu, '').trim().slice(0, 40)).filter(Boolean).slice(0, 12)
+            : STATIONS;
+        if (!stations.length) throw new Refusal(400, 'No station.');
+        this.#state[boxId] = {
+            from: new Date(from).toISOString(), until: new Date(until).toISOString(), tag, after, radio: body.radio === true,
+            every, volume, stations, startedAt: new Date(now).toISOString(),
+            station: null, stationAt: null, stationIndex: -1, volumeSaid: false, lastWakeAt: null, warnedAt: null,
+            kept: 0, wakes: 0, answers: [], warnings: [],
+        };
+        this.#save();
+        this.#log(`voice box ${boxId.slice(0, 8)}: collect on (${tag}) until ${new Date(until).toISOString()}${body.radio === true ? ', radio' : ''}`);
+        return this.state(boxId);
+    }
+
+    /* Off: by the operator, at its end, or full. Returns what was on (to say « stop » to the speaker), or null. */
+    stop(boxId, why = 'asked') {
+        const s = this.#state[boxId];
+        if (!s) return null;
+        delete this.#state[boxId]; this.#save();
+        this.#log(`voice box ${String(boxId).slice(0, 8)}: collect off (${why}), ${s.kept} kept`);
+        this.#ended = { ...this.#ended, [boxId]: { ...s, endedAt: new Date(this.#now()).toISOString(), why } };
+        try { writeFileSync(join(this.#dir, 'ended.json'), JSON.stringify(this.#ended)); } catch { /* shown until a restart only */ }
+        return s;
+    }
+
+    /* On now: begun, not yet ended. With the radio, GRACE_MS more: the radio plays until the box has told the
+       speaker to stop (the clock waits for a box busy listening), and its wakes must not reach the AI meanwhile. */
+    on(boxId) {
+        const s = this.#state[boxId];
+        if (!s) return false;
+        const now = this.#now();
+        return now >= Date.parse(s.from) && now < Date.parse(s.until) + (s.radio ? GRACE_MS : 0);
+    }
+
+    state(boxId) {
+        const s = this.#state[boxId]; const u = this.#used();
+        if (!s) return { on: false, last: this.#ended[boxId] ?? null, count: u.count, bytes: u.bytes };
+        return { on: this.on(boxId), ...s, count: u.count, bytes: u.bytes, countMax: this.#countMax, bytesMax: this.#bytesMax };
+    }
+
+    /* One listen of the box, during a session: kept (wake, button, knock), or null when full or off. */
+    keep(boxId, { clip = null, after = Buffer.alloc(0), reason = '', score = null, heard = null, word = null, voice = null, end = '' } = {}) {
+        const s = this.#state[boxId];
+        if (!s || !this.on(boxId)) return null;
+        const now = this.#now();
+        if (reason === 'wake') { s.wakes++; s.lastWakeAt = new Date(now).toISOString(); }
+        const u = this.#used();
+        const tail = after.subarray(0, (s.after * 32_000) & ~1);
+        const size = (clip?.length ? clip.length + 44 : 0) + (tail.length ? tail.length + 44 : 0);
+        if (u.count >= this.#countMax || u.bytes + size > this.#bytesMax) { this.#save(); return null; }
+        const day = dayOf(now); const dir = join(this.#dir, day);
+        mkdirSync(dir, { recursive: true });
+        const n = this.#nextOf(day);
+        const line = {
+            n, at: new Date(now).toISOString(), box: boxId, tag: s.tag, reason: String(reason).slice(0, 12),
+            score: Number.isFinite(score) ? score : null, heard: heard == null ? null : String(heard).slice(0, 200),
+            word: typeof word === 'boolean' ? word : null, voice: Number.isFinite(voice) && voice > 0 ? Math.round(voice) : null,
+            end: String(end).slice(0, 12), station: s.radio ? s.station : null, clip: null, after: null,
+        };
+        if (clip?.length) { writeFileSync(join(dir, `${n}.wav`), wavOf(clip)); line.clip = `${n}.wav`; }
+        if (tail.length) { writeFileSync(join(dir, `${n}-suite.wav`), wavOf(tail)); line.after = `${n}-suite.wav`; }
+        appendFileSync(join(dir, 'index.jsonl'), `${JSON.stringify(line)}\n`);
+        u.count++; u.bytes += size; s.kept++;
+        this.#save();
+        return line;
+    }
+    #nextOf(day) {
+        if (!this.#next.has(day)) {
+            let n = 0;
+            try { for (const l of readFileSync(join(this.#dir, day, 'index.jsonl'), 'utf8').split('\n')) { try { n = Math.max(n, JSON.parse(l).n); } catch { /* a torn line */ } } } catch { /* a new day */ }
+            this.#next.set(day, n);
+        }
+        const n = this.#next.get(day) + 1; this.#next.set(day, n);
+        return n;
+    }
+    full() { const u = this.#used(); return u.count >= this.#countMax || u.bytes >= this.#bytesMax - 400_000; }   /* no room for one more (a clip and AFTER_DEFAULT s) */
+
+    /* What the speaker answered when asked for a station (the box listened after it spoke). */
+    answered(boxId, text) {
+        const s = this.#state[boxId]; if (!s) return;
+        s.answers = [...s.answers, { at: new Date(this.#now()).toISOString(), station: s.station, text: String(text).slice(0, 120) }].slice(-20);
+        this.#save();
+    }
+
+    /* THE CLOCK (every half minute): what is due now, for one box -- { end } | { say, station? } | { warn } | null.
+       online: the box is connected; busy: it is listening now (a phrase then waits for the next tick). */
+    due(boxId, { online = true, busy = false } = {}) {
+        const s = this.#state[boxId];
+        if (!s) return null;
+        const now = this.#now();
+        if (this.full()) return { end: 'full', radio: s.radio };
+        if (now >= Date.parse(s.until) && (!busy || !online || now >= Date.parse(s.until) + GRACE_MS - 60_000)) return { end: 'time', radio: s.radio };
+        if (now >= Date.parse(s.until)) return null;
+        if (!s.radio || !online || busy || now < Date.parse(s.from)) return null;
+        if (!s.volumeSaid) { s.volumeSaid = true; this.#save(); return { say: volumePhrase(s.volume) }; }
+        if (s.stationIndex < 0 || now - Date.parse(s.stationAt) >= s.every * 60_000) {
+            s.stationIndex = (s.stationIndex + 1) % s.stations.length;
+            s.station = s.stations[s.stationIndex]; s.stationAt = new Date(now).toISOString(); s.warnedAt = null;
+            this.#save();
+            return { say: stationPhrase(s.station), station: s.station };
+        }
+        const quietSince = Math.max(Date.parse(s.stationAt), Date.parse(s.lastWakeAt ?? '') || 0);
+        if (!s.warnedAt && now - quietSince >= QUIET_WARN_MS) {
+            s.warnedAt = new Date(now).toISOString();
+            const text = `no wake for ${Math.round((now - quietSince) / 60_000)} min since ${s.station} was asked: the Google Home may not have obeyed`;
+            s.warnings = [...s.warnings, { at: s.warnedAt, station: s.station, text }].slice(-20);
+            this.#save();
+            return { warn: text };
+        }
+        return null;
+    }
+    boxes() { return Object.keys(this.#state); }
+
+    /* THE EXPORT: one zip, laid out for the training notebook (v2, cell 7 bis: a folder of 16 kHz WAV per source):
+         <tag>/<day>-<n>.wav          the wake clips (1.6 s): the hard negatives
+         <tag>_suite/<day>-<n>.wav    what came after them: more negative speech and music
+         index.csv                    file, at, reason, score, heard, word, voice, end, station
+         LISEZMOI.txt                 how the notebook takes them
+       Only the box's wakes (not a button or a knock) of that tag; days: all, or those given. */
+    exportZip({ tag = 'radio', days = null } = {}) {
+        if (!TAG.test(String(tag))) throw new Refusal(400, 'Not a tag.');
+        const files = []; const rows = [['file', 'suite', 'at', 'reason', 'score', 'heard', 'word', 'voice', 'end', 'station'].join(',')];
+        const wanted = Array.isArray(days) && days.length ? new Set(days.filter((d) => DAY.test(String(d)))) : null;
+        const csv = (v) => (v == null ? '' : /[",\n]/.test(String(v)) ? `"${String(v).replace(/"/g, '""')}"` : String(v));
+        for (const day of existsSync(this.#dir) ? readdirSync(this.#dir).filter((d) => DAY.test(d) && (!wanted || wanted.has(d))).sort() : []) {
+            let lines = [];
+            try { lines = readFileSync(join(this.#dir, day, 'index.jsonl'), 'utf8').split('\n').filter(Boolean).map((l) => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean); } catch { continue; }
+            for (const l of lines) {
+                if (l.tag !== tag || l.reason !== 'wake' || !l.clip) continue;
+                const name = `${day}-${l.n}.wav`;
+                try { files.push({ name: `${tag}/${name}`, data: readFileSync(join(this.#dir, day, l.clip)) }); } catch { continue; }
+                let suite = '';
+                if (l.after) { try { files.push({ name: `${tag}_suite/${name}`, data: readFileSync(join(this.#dir, day, l.after)) }); suite = `${tag}_suite/${name}`; } catch { /* the clip alone */ } }
+                rows.push([`${tag}/${name}`, suite, l.at, l.reason, l.score, l.heard, l.word, l.voice, l.end, l.station].map(csv).join(','));
+            }
+        }
+        files.push({ name: 'index.csv', data: Buffer.from(`${rows.join('\n')}\n`) });
+        files.push({ name: 'LISEZMOI.txt', data: Buffer.from(readme(tag, rows.length - 1)) });
+        return { zip: zipOf(files, this.#now()), clips: rows.length - 1 };
+    }
+}
+
+const readme = (tag, n) => `${n} faux réveils du boîtier (session « ${tag} »), sans étiquetage : personne à la maison, tout réveil est un faux.
+
+${tag}/        les 1,6 s qui ont réveillé le boîtier (wav 16 kHz, 16 bits, mono) : les contre-exemples durs
+${tag}_suite/  les secondes d'après (même format) : de la radio française en plus
+index.csv     score d'éveil, réécoute du serveur (word = le mot entendu), niveau de voix, station
+
+Dans le carnet v2 (cellule 7 bis) :
+1. décompresser ce zip dans /content ;
+2. ajouter à la boucle c) : ('${tag}', 'negative_datasets/${tag}'), ('${tag}_suite', 'negative_datasets/${tag}_suite') ;
+3. ajouter à config["features"] (cellule 8) deux entrées « truth: False, truncation_strategy: random »,
+   ${tag} avec penalty_weight 2.0 (comme near_words), ${tag}_suite avec sampling_weight 6.0.
+`;
+
+/* A ZIP, stored (WAV does not compress): enough for a few hundred megabytes, no dependency. */
+const CRC = (() => { const t = new Uint32Array(256); for (let n = 0; n < 256; n++) { let c = n; for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1; t[n] = c >>> 0; } return t; })();
+export function crc32(buf) { let c = 0xffffffff; for (let i = 0; i < buf.length; i++) c = CRC[(c ^ buf[i]) & 0xff] ^ (c >>> 8); return (c ^ 0xffffffff) >>> 0; }
+export function zipOf(files, at = Date.now()) {
+    const d = new Date(at);
+    const time = (d.getUTCHours() << 11) | (d.getUTCMinutes() << 5) | (d.getUTCSeconds() >> 1);
+    const date = ((d.getUTCFullYear() - 1980) << 9) | ((d.getUTCMonth() + 1) << 5) | d.getUTCDate();
+    const parts = []; const central = []; let offset = 0;
+    for (const f of files) {
+        const name = Buffer.from(f.name, 'utf8'); const crc = crc32(f.data);
+        const local = Buffer.alloc(30);
+        local.writeUInt32LE(0x04034b50, 0); local.writeUInt16LE(20, 4); local.writeUInt16LE(0x0800, 6); local.writeUInt16LE(0, 8);
+        local.writeUInt16LE(time, 10); local.writeUInt16LE(date, 12); local.writeUInt32LE(crc, 14);
+        local.writeUInt32LE(f.data.length, 18); local.writeUInt32LE(f.data.length, 22); local.writeUInt16LE(name.length, 26); local.writeUInt16LE(0, 28);
+        const c = Buffer.alloc(46);
+        c.writeUInt32LE(0x02014b50, 0); c.writeUInt16LE(20, 4); c.writeUInt16LE(20, 6); c.writeUInt16LE(0x0800, 8); c.writeUInt16LE(0, 10);
+        c.writeUInt16LE(time, 12); c.writeUInt16LE(date, 14); c.writeUInt32LE(crc, 16); c.writeUInt32LE(f.data.length, 20); c.writeUInt32LE(f.data.length, 24);
+        c.writeUInt16LE(name.length, 28); c.writeUInt32LE(offset, 42);
+        parts.push(local, name, f.data); central.push(c, name);
+        offset += 30 + name.length + f.data.length;
+    }
+    const size = central.reduce((s, b) => s + b.length, 0);
+    const end = Buffer.alloc(22);
+    end.writeUInt32LE(0x06054b50, 0); end.writeUInt16LE(files.length, 8); end.writeUInt16LE(files.length, 10);
+    end.writeUInt32LE(size, 12); end.writeUInt32LE(offset, 16);
+    return Buffer.concat([...parts, ...central, end]);
+}

package/server/boxes.mjs

@@ -15,13 +15,14 @@
  *
  * Both are under /c/: the edge lets them through without sign-on, as the
  * device door. Nothing is kept of the audio, here or on the box -- but the wake word's own
- * 1.6 s of a box set to learn it (wakelearn.mjs).
+ * 1.6 s of a box set to learn it (wakelearn.mjs), and what a box hears in a COLLECT session (boxcollect.mjs).
  */
 import { spawn as spawnProcess } from 'node:child_process';
 import { createWriteStream, mkdirSync, readFileSync, rmSync, statSync } from 'node:fs';
 import { randomBytes, randomUUID, createHash, timingSafeEqual } from 'node:crypto';
 import { Refusal } from './conversations.mjs';
 import { WIRE, cutoffOf, scoreOf } from './wakelearn.mjs';
+import { STOP_PHRASE } from './boxcollect.mjs';
 
 export const CODE_MINUTES = 10;
 export const PAIR_PATH = '/c/api/box/pair';
@@ -283,12 +284,12 @@ export function piecesOf(pcm, { least = 8, most = 14 } = {}) {
 
 export class Boxes {
     #file; #codes = new Map(); #links = new Map(); #tries = []; #now;
-    #exists; #hear; #say; #note; #speak; #log; #changed; #images = new Map(); #origin; #spawn; #fetch; #streams = new Map(); #recordDir; #parts; #keep; #react; #learn;
+    #exists; #hear; #say; #note; #speak; #log; #changed; #images = new Map(); #origin; #spawn; #fetch; #streams = new Map(); #recordDir; #parts; #keep; #react; #learn; #collect; #stopSay = new Map();
 
     /* file: a JsonFile holding [{ id, name, conversation, keyHash, firmware, createdAt, seenAt }].
        exists(conversation), hear(wav) -> text, say(conversation, text, room), speak(text) -> PCM 16 kHz. */
-    constructor({ file, exists = () => true, hear, say, note = null, speak, changed = () => {}, origin = () => null, now = () => Date.now(), log = () => {}, spawn = spawnProcess, fetcher = fetch, recordDir = null, parts = null, keep = null, react = async () => null, learn = null }) {
-        this.#react = react; this.#learn = learn;
+    constructor({ file, exists = () => true, hear, say, note = null, speak, changed = () => {}, origin = () => null, now = () => Date.now(), log = () => {}, spawn = spawnProcess, fetcher = fetch, recordDir = null, parts = null, keep = null, react = async () => null, learn = null, collect = null }) {
+        this.#react = react; this.#learn = learn; this.#collect = collect;
         this.#spawn = spawn; this.#fetch = fetcher; this.#recordDir = recordDir; this.#parts = parts; this.#keep = keep;
         this.#file = file; this.#changed = changed; this.#origin = origin; this.#exists = exists; this.#hear = hear; this.#say = say; this.#note = note; this.#speak = speak; this.#now = now; this.#log = log;
     }
@@ -424,13 +425,13 @@ export class Boxes {
     /* SPEAKING TO ANOTHER DEVICE in the room (a Google Home: « OK Google, baisse la clim »): said as given, its
        call included, then the box listens; what it hears within twenty seconds comes back to the conversation as
        that device's answer, not as the person's words (31-10: the box set the heating that way). */
-    async speakTo(id, text) {
+    async speakTo(id, text, { listen = true } = {}) {
         const link = this.#links.get(id);
         if (!link) throw new Refusal(409, 'This voice box is not connected.');
         const words = forSpeech(text, { callOthers: true });
         if (!words) throw new Refusal(400, 'Nothing to say.');
-        link.play(await this.#speak(words), 'listen');
-        link.relay = this.#now();
+        link.play(await this.#speak(words), listen ? 'listen' : null);
+        if (listen) link.relay = this.#now();
         this.#log(`voice box ${link.box().name}: spoke to a device in the room`);
         return { ok: true };
     }
@@ -778,7 +779,7 @@ export class Boxes {
                 return;
             }
             if (m.t === WIRE.clip && m.edge === 'start') { link.clip = { parts: [], bytes: 0, score: scoreOf(m.score) };   /* none (before 0.1.49): unknown, left out of tuning */ return; }
-            if (m.t === WIRE.clip && m.edge === 'end' && link.clip) { const { parts, score } = link.clip; link.clip = null; link.wakeCheck = this.#checkWake(link, Buffer.concat(parts), { score }); return; }
+            if (m.t === WIRE.clip && m.edge === 'end' && link.clip) { const { parts, score } = link.clip; link.clip = null; link.clipPcm = Buffer.concat(parts); link.clipScore = score; link.wakeCheck = this.#checkWake(link, link.clipPcm, { score }); return; }
             if (m.t === WIRE.near && m.edge === 'start') { link.near = { parts: [], bytes: 0, score: scoreOf(m.score) }; return; }
             if (m.t === WIRE.near && m.edge === 'end' && link.near) { const { parts, score } = link.near; link.near = null; void this.#checkNear(link, Buffer.concat(parts), score); return; }
             if (m.t === 'event' && m.name === 'wake.own') { this.#log(`voice box ${box.name}: heard its own voice say the wake word, ignored`); return; }
@@ -790,8 +791,17 @@ export class Boxes {
                 this.#log(`voice box ${box.name}: a sentence while recording here, the recording closed`);
                 r.out.end(() => { void this.#recorded(link, r); });
             }
+            if (m.t === 'listen.start') { link.listening = true; link.startScore = scoreOf(m.score); link.clipPcm = null; link.clipScore = null; }
             if (m.t === 'listen.start') { link.why = whyOf(m); link.wakeCheck = null; link.voice = NaN; link.endReason = ''; link.startReason = String(m.reason ?? ''); link.clipSeen = false; }   /* its clip, if any, comes after listen.start: an older check never carries over */
             if (m.t === 'listen.start') { if (this.stop(box.id)) this.#log(`voice box ${box.name}: stopped playing, someone speaks`); sentence = []; size = 0; return; }
+            if (m.t === 'listen.end') link.listening = false;
+            /* A COLLECT SESSION (boxcollect.mjs): nothing goes to the conversation, nothing is answered; kept. */
+            if (m.t === 'listen.end' && sentence && this.#collect?.on(box.id)) {
+                const pcm = Buffer.concat(sentence); sentence = null;
+                link.endReason = String(m.reason ?? ''); link.voice = Number(m.ep?.voice);
+                void this.#collected(link, pcm);
+                return;
+            }
             if (m.t === 'listen.end' && sentence && m.reason === 'nobody') {
                 /* Listened again, nobody spoke: a conversation ends there, in silence. */
                 sentence = null;
@@ -873,7 +883,8 @@ export class Boxes {
         const ok = wakeHeard(heard);
         /* Counted, and kept when the box learns (the clip only: never the sentence), with the box's score. */
         const box = link.box();
-        try { this.#learn?.checked(box.id, pcm, ok, { keep: box.wake === 'learn', heard, score, near }); } catch (error) { this.#log(`voice box ${box.name}: wake clip not kept (${error.message})`); }
+        /* Not during a collect session: a radio asked for on purpose would count as the room's false wakes (tuning). */
+        if (!this.#collect?.on(box.id)) try { this.#learn?.checked(box.id, pcm, ok, { keep: box.wake === 'learn', heard, score, near }); } catch (error) { this.#log(`voice box ${box.name}: wake clip not kept (${error.message})`); }
         return { heard, ok };
     }
     /* A NEAR MISS (wake.near): checked the same way, only when the box learns; one at a time; nothing said. */
@@ -973,6 +984,58 @@ export class Boxes {
         link.doingSaid = false;
     }
 
+    /* COLLECT (boxcollect.mjs): a listen of the box, kept, never sent on. The box is told « done » at once. After
+       it asked the speaker for a station (reason follow), what it heard is the speaker's answer: dictated, logged. */
+    async #collected(link, pcm) {
+        const box = link.box();
+        link.send({ t: 'cue', name: 'done' });
+        const reason = link.startReason;
+        const clip = link.clipPcm; const score = link.clipScore ?? link.startScore; link.clipPcm = null;
+        if (reason === 'follow') {
+            link.wakeCheck = null;
+            if (pcm.length < 16_000) return;
+            try {
+                const text = String(await this.#hear(wavOf(pcm.subarray(0, 20 * 32_000)), box.lang) ?? '').trim();
+                this.#log(`voice box ${box.name}: collect, the speaker answered « ${text.slice(0, 60)} »`);
+                this.#collect.answered(box.id, text);
+            } catch (error) { this.#log(`voice box ${box.name}: collect, the speaker's answer not dictated (${error.message})`); }
+            return;
+        }
+        const check = link.wakeCheck ? await link.wakeCheck.catch(() => null) : null; link.wakeCheck = null;
+        let line = null;
+        try { line = this.#collect.keep(box.id, { clip, after: pcm, reason, score, heard: check?.heard ?? null, word: check?.ok ?? null, voice: link.voice, end: link.endReason }); } catch (error) { this.#log(`voice box ${box.name}: collect, not kept (${error.message})`); return; }
+        this.#log(line ? `voice box ${box.name}: collect, ${reason} #${line.n} kept (mot ${check ? (check.ok ? '\u2713' : '\u2717') : '?'}, ${link.endReason})` : `voice box ${box.name}: collect, ${reason} not kept (full, or the session ended)`);
+    }
+    collectStart(id, body) { this.#box(id); return this.#collecting().start(id, body); }
+    collectStop(id) {
+        this.#box(id);
+        const was = this.#collecting().stop(id, 'asked');
+        if (was?.radio) this.#stopSay.set(id, this.#now());
+        void this.collectTick();
+        return this.#collect.state(id);
+    }
+    collectState(id) { this.#box(id); return this.#collecting().state(id); }
+    collectExport(tag, days) { return this.#collecting().exportZip({ tag, days }); }
+    #collecting() { if (!this.#collect) throw new Refusal(501, 'This server collects no wake clips.'); return this.#collect; }
+    /* Its clock (every half minute, main.mjs): stations asked, the end, « Ok Google, stop » once the box is free. */
+    async collectTick() {
+        if (!this.#collect) return;
+        const tell = async (id, text, listen) => { await this.speakTo(id, text, { listen }); this.#log(`voice box ${id.slice(0, 8)}: collect, said « ${text} »`); };
+        for (const id of this.#collect.boxes()) {
+            const link = this.#links.get(id);
+            const d = this.#collect.due(id, { online: Boolean(link), busy: Boolean(link?.listening) });
+            if (!d) continue;
+            if (d.end) { const was = this.#collect.stop(id, d.end); if (was?.radio) this.#stopSay.set(id, this.#now()); continue; }
+            if (d.warn) { this.#log(`voice box ${id.slice(0, 8)}: collect, ${d.warn}`); continue; }
+            try { await tell(id, d.say, true); } catch (error) { this.#log(`voice box ${id.slice(0, 8)}: collect, « ${d.say} » not said (${error.message})`); }
+        }
+        for (const [id, at] of this.#stopSay) {
+            const link = this.#links.get(id);
+            if (link && !link.listening) { this.#stopSay.delete(id); try { await tell(id, STOP_PHRASE, false); } catch (error) { this.#log(`voice box ${id.slice(0, 8)}: collect, the speaker not stopped (${error.message})`); } }
+            else if (this.#now() - at > 10 * 60_000) { this.#stopSay.delete(id); this.#log(`voice box ${id.slice(0, 8)}: collect, the speaker could not be told to stop (box ${link ? 'busy' : 'offline'})`); }
+        }
+    }
+
     /* Wires the box link on an HTTP server: the key in Authorization, else 401. */
     attach(server, WebSocketServer) {
         const wss = new WebSocketServer({ noServer: true, maxPayload: 64 * 1024 });
@@ -1015,6 +1078,10 @@ export class Boxes {
  *   POST /api/boxes/<id>/wake-erase      every clip of the box deleted -> the same
  *   POST /api/boxes/<id>/wake-improve    -> 202 {queued, at, tuning}: the threshold tuned now; nothing better, the
  *                                          trainer asked (queued)
+ *   GET  /api/boxes/<id>/collect         -> the COLLECT session (boxcollect.mjs): {on, from, until, tag, kept, ...}
+ *   POST /api/boxes/<id>/collect         {until, from?, tag?, after?, radio?, every?, volume?, stations?} -> the same;
+ *                                          {on: false}: stopped now
+ *   GET  /api/boxes/collect-export?tag=radio&day=YYYY-MM-DD   -> a zip of the wake clips kept (any day: all)
  */
 export async function handleBoxes(request, response, boxes, originOk, headers = {}, qr = null) {
     const { pathname } = new URL(request.url ?? '/', 'http://local');
@@ -1023,6 +1090,14 @@ export async function handleBoxes(request, response, boxes, originOk, headers =
         if (request.method === 'GET' && pathname === '/api/boxes') return send(200, boxes.all());
         const asked = request.method === 'GET' && /^\/api\/boxes\/([0-9a-f-]{36})\/wake$/.exec(pathname);
         if (asked) return send(200, boxes.wakeStats(asked[1]));
+        const collecting = request.method === 'GET' && /^\/api\/boxes\/([0-9a-f-]{36})\/collect$/.exec(pathname);
+        if (collecting) return send(200, boxes.collectState(collecting[1]));
+        if (request.method === 'GET' && pathname === '/api/boxes/collect-export') {
+            const q = new URL(request.url ?? '/', 'http://local').searchParams;
+            const { zip, clips } = boxes.collectExport(q.get('tag') ?? 'radio', q.getAll('day'));
+            response.writeHead(200, { ...headers, 'content-type': 'application/zip', 'content-length': zip.length, 'content-disposition': `attachment; filename="faux-reveils-${q.get('tag') ?? 'radio'}.zip"`, 'x-clips': String(clips) }).end(zip);
+            return true;
+        }
         if (request.method !== 'POST') return false;
         if (!originOk(request.headers)) return send(403, { error: 'This request does not come from this site.' });
         let text = '';
@@ -1060,6 +1135,7 @@ export async function handleBoxes(request, response, boxes, originOk, headers =
         case 'wake-mode': return send(200, boxes.wakeMode(id, String(body.mode ?? '')));
         case 'wake-erase': return send(200, boxes.wakeErase(id));
         case 'wake-improve': return send(202, boxes.wakeImprove(id));
+        case 'collect': return send(200, body.on === false ? boxes.collectStop(id) : boxes.collectStart(id, body));
         default: return false;
         }
     } catch (error) {

package/server/main.mjs

@@ -80,6 +80,7 @@ import { Bundles } from './bundle.mjs';
 import { migrateData } from './dataformat.mjs';
 import { VmWatch } from './vmwatch.mjs';
 import { WakeLearn } from './wakelearn.mjs';
+import { BoxCollect } from './boxcollect.mjs';
 import { Boxes, handleBoxes, voiceboxConnector, syncTargets, PAIR_PATH as BOX_PAIR_PATH, FIRMWARE_PATH as BOX_FIRMWARE_PATH } from './boxes.mjs';
 import { Pocket } from './pocket.mjs';
 import { Speech } from './speech.mjs';
@@ -667,6 +668,8 @@ export async function startHome({ port, host, dataDir, mntDir = dataDir, gitRese
         react: (said) => voice.reaction(said),
         /* The wake word that learns: each box's wake clips, when it is set so (wakelearn.mjs). */
         learn: new WakeLearn({ dir: `${dataDir}/wake-learn` }),
+        /* A collect session: a box's false wakes kept on purpose, nothing answered (boxcollect.mjs; started by the owner). */
+        collect: new BoxCollect({ dir: `${dataDir}/box-collect`, log: (line) => events.add({ kind: 'server', text: line }) }),
         recordDir: `${dataDir}/recordings`, parts: (wav) => voice.transcribeParts(wav), keep: (name, file, text) => talk.keepText(name, file, text),
         hear: (wav, lang) => hearBox(voice, wav, lang),   /* any language heard; one neither the box's (its page's) nor English heard again in the box's (voice.mjs) */
         /* Said as the person's own message, the room named (one speaker for now). */
@@ -733,6 +736,8 @@ export async function startHome({ port, host, dataDir, mntDir = dataDir, gitRese
     boxes.attach(server, WebSocketServer);
     /* The wake word's weekly threshold tuning (Sunday from 03:00, each box's own time): looked at every 10 minutes. */
     const wakeWeekly = setInterval(() => { try { boxes.wakeWeekly(); } catch (error) { console.error(`wake tuning: ${error.message}`); } }, 10 * 60_000); wakeWeekly.unref?.(); server.on('close', () => clearInterval(wakeWeekly));
+    /* A collect session's clock: the stations asked, its end, the speaker told to stop (boxcollect.mjs). */
+    const collectTick = setInterval(() => { boxes.collectTick().catch((error) => console.error(`box collect: ${error.message}`)); }, 30_000); collectTick.unref?.(); server.on('close', () => clearInterval(collectTick));
     for (const c of all.list()) talk.speakers(c.name, boxes.speakersOf(c.name));
     try { syncTargets(tethers.store(), boxes.all()); } catch (error) { console.error(`voice boxes in Tether: ${error.message}`); }
     bridge = attachBridge(server, {

package/server/settingswords.mjs

@@ -17,6 +17,10 @@ export const SETTINGS_WORDS_FR = {
     'set-free-of': '{free} libres sur {total}', 'set-left-of': '{free} restants sur {total}', 'set-highest': 'au plus {n} % en 1 h',
     'set-core': '1 cœur', 'set-cores': '{n} cœurs',
     'set-update-out': '{v} est sortie', 'set-up-to-date': 'À jour · {v}', 'set-wifi-on': 'Wi-Fi · {name}', 'set-wifi-off': 'Wi-Fi non utilisé', 'set-cable': 'Câble',
+    /* A box's learning session (boxcollect.mjs): the radio, its false wakes kept. */
+    'set-collect': 'Séance d\'apprentissage (radio)', 'set-collect-from': 'de', 'set-collect-to': 'à',
+    'set-collect-go': 'Programmer', 'set-collect-stop': 'Arrêter', 'set-collect-scheduled': 'Programmée de {from} à {to}',
+    'set-collect-running': 'En cours : {n} réveils gardés', 'set-collect-ended': 'Terminée : {n} réveils', 'set-collect-export': 'Exporter',
     'set-not-well': 'ne va pas bien', 'set-box-away': '{name} hors ligne',
     'set-just-now': 'à l\'instant', 'set-min-ago': 'il y a {n} min', 'set-h-ago': 'il y a {n} h', 'set-days-ago': 'il y a {n} jours',
     'set-on': 'Activé', 'set-off': 'Désactivé', 'set-none': 'Aucun', 'set-changed': '{n} modifiés', 'set-as-given': 'Comme livrés',

package/web/app.js

@@ -10660,6 +10660,48 @@
         void getJson(`/boxes/${b.id}/wake`, null).then((w) => { if (w) paint(w); });
         return part;
     }
+    /* A LEARNING SESSION (boxcollect.mjs): the box's false wakes kept, nothing answered, the Google Home playing
+       the radio -- programmed here in one tap (today, local hours); its one line says where it stands. */
+    function boxCollect(b) {
+        const part = el('div', 'box-wake box-collect');
+        const at = (hhmm, after = 0) => { const d = new Date(); const [h, m] = String(hhmm).split(':').map(Number); d.setHours(h, m || 0, 0, 0); if (d.getTime() <= after) d.setDate(d.getDate() + 1); return d; };
+        const from = el('input'); from.type = 'time'; from.value = '09:00'; from.setAttribute('aria-label', uiSaid('set-collect-from', 'from'));
+        const to = el('input'); to.type = 'time'; to.value = '17:00'; to.setAttribute('aria-label', uiSaid('set-collect-to', 'to'));
+        const go = el('button', 'primary'); go.type = 'button';
+        const line = el('div', 'box-wake-lines');
+        const row = el('div', 'action-row box-wake-row');
+        row.append(el('span', '', uiSaid('set-collect', 'Learning session (radio)')), el('span', '', uiSaid('set-collect-from', 'from')), from, el('span', '', uiSaid('set-collect-to', 'to')), to, go);
+        part.append(row, line);
+        const hour = (iso) => new Date(iso).toLocaleTimeString([], { hour: 'numeric', minute: '2-digit' });
+        let busy = false;
+        const paint = (c) => {
+            const m = KIT.collectModel(c);
+            busy = m.state === 'scheduled' || m.state === 'running';
+            go.textContent = busy ? uiSaid('set-collect-stop', 'Stop') : uiSaid('set-collect-go', 'Schedule');
+            const hhmm = (iso) => { const d = new Date(iso); return `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`; };
+            if (busy) { from.value = hhmm(m.from); to.value = hhmm(m.until); }
+            from.disabled = busy; to.disabled = busy; go.disabled = false;
+            line.replaceChildren();
+            if (m.state === 'scheduled') line.append(el('small', 'hint', uiSaid('set-collect-scheduled', 'Scheduled from {from} to {to}', { from: hour(m.from), to: hour(m.until) })));
+            if (m.state === 'running') line.append(el('small', 'hint', uiSaid('set-collect-running', 'Running: {n} wakes kept', { n: m.kept })));
+            if (m.state === 'ended') {
+                const out = el('a', '', uiSaid('set-collect-export', 'Export')); out.href = `${API}/boxes/collect-export?tag=radio`; out.setAttribute('download', '');
+                const said = el('small', 'hint', `${uiSaid('set-collect-ended', 'Ended: {n} wakes', { n: m.kept })} \u2014 `); said.append(out);
+                line.append(said);
+            }
+        };
+        go.addEventListener('click', async () => {
+            go.disabled = true;
+            try {
+                if (busy) { paint(await post(`${API}/boxes/${b.id}/collect`, { on: false })); return; }
+                const start = at(from.value); const end = at(to.value, start.getTime());
+                paint(await post(`${API}/boxes/${b.id}/collect`, { from: start.toISOString(), until: end.toISOString(), tag: 'radio', radio: true }));
+            } catch (error) { go.disabled = false; line.replaceChildren(el('small', 'warn', error.message)); }
+        });
+        paint({});
+        void getJson(`/boxes/${b.id}/collect`, null).then((c) => { if (c) paint(c); });
+        return part;
+    }
     async function paintBoxes() {
         const list = await getJson('/boxes', []); await loadRooms();
         const rows = $('box-list'); rows.replaceChildren();
@@ -10704,7 +10746,7 @@
             const volRow = el('label', 'box-volume'); volRow.append('Volume ', vol, volSaid);
             const acts = el('div', 'action-row'); acts.append(whereRow, place, volRow, rename, remove);
             card.append(head, acts);
-            card.append(boxWake(b));
+            card.append(boxWake(b), boxCollect(b));
             /* TESTED FROM HERE (01-11): its sound -- it says a test sentence -- and its microphone -- it listens
                once, and what it heard shows here, not in the conversation. */
             if (b.online) {

package/web/kit.js

@@ -789,7 +789,20 @@
         return box;
     }
 
+    /* A BOX'S COLLECT SESSION (boxcollect.mjs), from GET /api/boxes/<id>/collect, in one state for its one line:
+       none · scheduled (from, until) · running (kept) · ended (kept). */
+    function collectModel(c, now = Date.now()) {
+        if (c?.until) {
+            const from = Date.parse(c.from); const until = Date.parse(c.until);
+            if (!c.on && from > now) return { state: 'scheduled', from: c.from, until: c.until };
+            return { state: c.on || now < until ? 'running' : 'ended', kept: c.kept ?? 0, from: c.from, until: c.until };
+        }
+        if (c?.last) return { state: 'ended', kept: c.last.kept ?? 0, from: c.last.from, until: c.last.until };
+        return { state: 'none' };
+    }
+
     window.clavariumKit = {
+        collectModel,
         AssetIcon, AssetCard, Holders, RightsBadge, RightsPicker, AssetList, assetListModel, AccessList, accessModel, AssetPanel, AssetDelete, RIGHT_SAME,
         ASSET_ICONS, ASSET_KINDS, RIGHTS, RIGHT_LEVELS, rightsKey, rightsFor, rightOf, storedOf, lightest, rightWord,
         shareSlices, ShareDonut, ShareKey,

package/web/style.css

@@ -2191,6 +2191,7 @@ body.as-dragging #assets-rows .as-row { touch-action: none; }
 .box-wake { margin-top: 8px; }
 .box-wake-row { align-items: center; }
 .box-wake-lines { display: flex; flex-direction: column; gap: 2px; margin-top: 4px; }
+.box-collect a { color: var(--brass-ink); }
 .box-wake-sure { display: inline-flex; align-items: center; gap: 6px; }
 .box-wake-sure[hidden] { display: none; }