@ciphore/radiocli 0.2.4 → 0.2.5

package/dist/agent/tui-session.js

@@ -0,0 +1,213 @@
+import { randomUUID } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import { createServer } from 'node:net';
+import { join } from 'node:path';
+import { PlayerController } from '../player/player-controller.js';
+import { launchHeadlessHost } from './launcher.js';
+import { platformPaths } from '../platform/paths.js';
+import { storageReadiness } from '../platform/storage.js';
+import { listenLoopback } from '../platform/loopback.js';
+import { ensureRadioSession, radioSessionMayBeActive } from './session.js';
+export async function openTuiSession() {
+    if (!radioSessionMayBeActive()) {
+        if (process.env.RADIOCLI_TUI_PLAYBACK === 'inline')
+            return { warning: 'Playback runs in this terminal. Crash recovery is disabled by RADIOCLI_TUI_PLAYBACK=inline.' };
+        if (storageReadiness(join(platformPaths().runtime, 'agent-session.json')).status === 'unavailable') {
+            return { warning: 'Playback recovery is unavailable: the runtime directory is not writable. Set RADIOCLI_HOME to a private writable directory.' };
+        }
+        const probe = createServer();
+        try {
+            await listenLoopback(probe);
+        }
+        catch {
+            return { warning: 'Playback recovery is unavailable: this environment blocks local loopback control. Playback runs in this terminal.' };
+        }
+        finally {
+            await new Promise(resolve => probe.close(() => resolve()));
+        }
+    }
+    return { session: await TuiSession.connect() };
+}
+/** A terminal is a view of the existing playback owner. Its death must never
+ * destroy the owner's IPC connection, queue, timers, or listening history. */
+export class TuiSession {
+    client;
+    clientId;
+    status;
+    listeners = new Set();
+    timer;
+    revision = 0;
+    closing;
+    closed = false;
+    constructor(client, clientId, status) {
+        this.client = client;
+        this.clientId = clientId;
+        this.status = status;
+    }
+    static async connect() {
+        const cli = fileURLToPath(new URL(import.meta.url.endsWith('.ts') ? '../cli.tsx' : '../cli.js', import.meta.url));
+        const client = await ensureRadioSession(() => launchHeadlessHost(process.execPath, cli), 15_000, { source: 'cli' });
+        const clientId = randomUUID();
+        let result;
+        try {
+            result = await client.call({ type: 'tui-attach', pid: process.pid, clientId });
+        }
+        catch (error) {
+            if (error instanceof Error && /Invalid radio command|Unsupported radio command/i.test(error.message)) {
+                throw new Error('The running player predates TUI recovery. Run radiocli stop, then reopen radiocli to use the updated player.');
+            }
+            throw error;
+        }
+        if (!result.ok)
+            throw new Error(result.message);
+        if (!result.status.tui)
+            throw new Error('The playback host does not support terminal recovery. Stop the older session and reopen RadioCLI.');
+        const session = new TuiSession(client, clientId, result.status);
+        session.poll();
+        return session;
+    }
+    subscribe(listener) { this.listeners.add(listener); return () => this.listeners.delete(listener); }
+    async call(command) {
+        if (this.closed)
+            throw new Error('RadioCLI terminal session is closed.');
+        const result = await this.client.call(command);
+        this.revision++;
+        this.status = result.status;
+        this.emit();
+        return result;
+    }
+    report(error) {
+        this.status = { ...this.status, persistenceWarning: error instanceof Error ? error.message : String(error) };
+        this.emit();
+    }
+    disconnect() {
+        clearTimeout(this.timer);
+        this.closed = true;
+        this.listeners.clear();
+    }
+    close() {
+        return this.closing ??= (async () => {
+            clearTimeout(this.timer);
+            try {
+                const result = await this.call({ type: 'tui-detach', clientId: this.clientId });
+                if (!result.ok)
+                    throw new Error(result.message);
+            }
+            finally {
+                this.disconnect();
+            }
+        })();
+    }
+    poll() {
+        this.timer = setTimeout(() => {
+            const revision = this.revision;
+            void this.client.status().then(status => {
+                if (!this.closed && revision === this.revision && JSON.stringify(status) !== JSON.stringify(this.status)) {
+                    this.status = status;
+                    this.emit();
+                }
+            }).catch(() => {
+                if (!this.closed && revision === this.revision) {
+                    this.status = { ...this.status, playback: { ...this.status.playback, state: 'error', ready: false,
+                            message: 'Playback host disconnected. Reopen RadioCLI to reconnect.' } };
+                    this.emit();
+                }
+            }).finally(() => { if (!this.closed && !this.closing)
+                this.poll(); });
+        }, 250);
+        this.timer.unref();
+    }
+    emit() { for (const listener of this.listeners)
+        listener(); }
+}
+/** Keep synchronous presentation queries local, while every audio mutation
+ * reaches the same owner used by CLI, agent, alarm, and desktop controls. */
+export class TuiPlayer extends PlayerController {
+    session;
+    constructor(session, settings) {
+        super(settings);
+        this.session = session;
+    }
+    getState() { return { ...this.session.status.playback }; }
+    onChange(listener) {
+        listener(this.getState());
+        return this.session.subscribe(() => listener(this.getState()));
+    }
+    onMetadata(listener) {
+        let previous;
+        return this.session.subscribe(() => {
+            const metadata = this.session.status.nowPlaying;
+            const key = JSON.stringify(metadata);
+            if (metadata && key !== previous) {
+                previous = key;
+                listener(metadata);
+            }
+        });
+    }
+    diagnostics() { return { ...this.session.status.tui.diagnostics }; }
+    desktopMediaCompatible() { return this.session.status.tui.desktopMediaCompatible; }
+    detectedBackends() { return [...this.session.status.tui.diagnostics.availableBackends]; }
+    refreshDetectedBackends() {
+        void this.session.call({ type: 'tui-refresh' }).catch(error => this.session.report(error));
+        return this.detectedBackends();
+    }
+    detectedAirPlayDevices() { return [...this.session.status.tui.devices]; }
+    airPlaySelectionRequired() { return this.session.status.tui.selectionRequired; }
+    async refreshAirPlayDevices() {
+        const result = await this.session.call({ type: 'airplay-list' });
+        if (!result.ok)
+            throw new Error(result.message);
+        return result.data ?? [];
+    }
+    async selectAirPlayDevice(deviceId) { return (await this.session.call({ type: 'tui-output', deviceId })).ok; }
+    async submitAirPlayPasscode(code) { return this.control({ type: 'airplay-passcode', code }); }
+    async pause() { return this.control({ type: 'pause' }); }
+    async resume() { return this.control({ type: 'resume' }); }
+    async togglePause() { return this.control({ type: 'tui-toggle-pause' }); }
+    async setVolume(volume, options = {}) {
+        return this.control({ type: 'set-volume', volume: Math.max(0, Math.min(100, Math.round(volume))), allowStopped: options.allowStopped });
+    }
+    async adjustVolume(delta) { return this.control({ type: 'tui-adjust-volume', delta }); }
+    async setMuted(muted, options = {}) { return this.control({ type: 'set-muted', muted, allowStopped: options.allowStopped }); }
+    async toggleMute() { return this.control({ type: 'tui-toggle-muted' }); }
+    async stop() { await this.session.call({ type: 'stop', retainSelection: true }); }
+    async play() { throw new Error('Terminal playback must use the shared radio engine.'); }
+    async control(command) {
+        const result = await this.session.call(command);
+        return { ok: result.ok, message: result.message };
+    }
+}
+export class TuiRadioEngine {
+    session;
+    constructor(session) {
+        this.session = session;
+    }
+    snapshot() {
+        const status = this.session.status;
+        return { station: status.station, tuningStation: status.tui?.tuningStation ?? null, queue: [...status.queue],
+            playback: { ...status.playback }, nowPlaying: status.nowPlaying ?? null, warning: status.persistenceWarning, message: status.tui?.message };
+    }
+    onChange(listener) { listener(this.snapshot()); return this.session.subscribe(() => listener(this.snapshot())); }
+    clearWarning() { this.session.status.persistenceWarning = undefined; }
+    cancel() { void this.session.call({ type: 'tui-cancel' }).catch(error => this.session.report(error)); }
+    async tune(station, options = {}) {
+        options.signal?.throwIfAborted();
+        const abort = () => this.cancel();
+        options.signal?.addEventListener('abort', abort, { once: true });
+        try {
+            const result = await this.session.call({ type: 'play', station, queue: options.queue, startPaused: options.startPaused });
+            options.signal?.throwIfAborted();
+            if (!result.ok || !result.status.station)
+                throw new Error(result.message);
+            return result.status.station;
+        }
+        finally {
+            options.signal?.removeEventListener('abort', abort);
+        }
+    }
+    async stop(options = {}) { await this.session.call({ type: 'stop', ...options }); }
+    async pause() { const result = await this.session.call({ type: 'pause' }); return { ok: result.ok, message: result.message }; }
+    async resume() { const result = await this.session.call({ type: 'resume' }); return { ok: result.ok, message: result.message }; }
+    select(station, queue) { void this.session.call({ type: 'tui-select', station, queue }).catch(error => this.session.report(error)); }
+    close() { return this.session.close(); }
+}

package/dist/alarms/cli.js

@@ -1,5 +1,7 @@
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { LibraryRepository } from '../storage/repository.js';
+import { matchesStationId } from '../storage/station-identity.js';
 import { JsonLibraryStore, stationKey } from '../storage/store.js';
 import { ProviderManager } from '../providers/provider-manager.js';
 import { PlayerController } from '../player/player-controller.js';
@@ -74,6 +76,7 @@ export async function runAlarmCommand(args, dependencies = {}) {
     if (sub === 'remove') {
         const id = requiredPos(rest, 0);
         requireAlarm(store, id);
+        store.toggleAlarm(id, false);
         await scheduler.remove(id);
         if (!store.removeAlarm(id))
             throw new Error(`Alarm not found: ${id}`);
@@ -157,7 +160,13 @@ export async function runAlarmCommand(args, dependencies = {}) {
     if (sub === 'internal-run') {
         const id = requiredPos(rest, 0);
         const at = requiredPos(rest, 1);
-        await runAlarm(id, at, createRuntimeDeps(store, scheduler, id));
+        const repository = new LibraryRepository(store, { worker: !dependencies.store });
+        try {
+            await runAlarm(id, at, createRuntimeDeps(repository, scheduler, id));
+        }
+        finally {
+            await repository.close();
+        }
         return;
     }
     if (sub === 'internal-launchd') {
@@ -165,7 +174,13 @@ export async function runAlarmCommand(args, dependencies = {}) {
         const at = requiredPos(rest, 1);
         if (!shouldRunLaunchdOccurrence(at, new Date()))
             return;
-        await runAlarm(id, at, createRuntimeDeps(store, scheduler, id));
+        const repository = new LibraryRepository(store, { worker: !dependencies.store });
+        try {
+            await runAlarm(id, at, createRuntimeDeps(repository, scheduler, id));
+        }
+        finally {
+            await repository.close();
+        }
         return;
     }
     if (sub === 'internal-guard-run') {
@@ -238,7 +253,8 @@ function parseDays(value) { if (value === 'daily')
     return [1, 2, 3, 4, 5, 6, 7]; if (value === 'weekdays')
     return [1, 2, 3, 4, 5]; if (value === 'weekends')
     return [6, 7]; return canonicalizeIsoWeekdays(value.split(',').map(Number)); }
-function resolveStation(store, key) { const state = store.snapshot(); const stations = [...state.favorites, ...state.imported, ...state.recent.map(item => item.station), ...state.alarms.flatMap(alarm => [alarm.station, ...(alarm.playback.fallbackStation ? [alarm.playback.fallbackStation] : [])])]; const station = stations.find(item => stationKey(item) === key); if (!station)
+function resolveStation(store, key) { const state = store.snapshot(); const stations = [...state.favorites, ...state.imported, ...state.recent.map(item => item.station), ...state.alarms.flatMap(alarm => [alarm.station, ...(alarm.playback.fallbackStation ? [alarm.playback.fallbackStation] : [])])]; const matches = new Map(stations.filter(item => matchesStationId(item, key)).map(item => [stationKey(item), item])); if (matches.size > 1)
+    throw new Error('This legacy station ID is ambiguous. List stations and use the current ID.'); const station = [...matches.values()][0]; if (!station)
     throw new Error(`Station not found: ${key}. Add it to favorites/imports/recents first.`); return station; }
 function parseOptions(args) { const allowed = new Set(['station', 'once', 'time', 'days', 'timezone', 'label', 'volume', 'fade', 'stop-after', 'fallback', 'grace', 'disabled', 'wake', 'no-wake', 'guard', 'no-guard', 'clear-fallback']); const values = new Map(); const positionals = []; for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];

package/dist/alarms/occurrence-cache.js

@@ -0,0 +1,25 @@
+import { nextOccurrenceForAlarm } from './schedule.js';
+/** Reuse civil-time work until its result expires; clock reversals invalidate it. */
+export class AlarmOccurrenceCache {
+    limit;
+    entries = new Map();
+    constructor(limit = 512) {
+        this.limit = limit;
+    }
+    next(alarm, now) {
+        const time = now.getTime();
+        const fingerprint = JSON.stringify([alarm.enabled, alarm.schedule, alarm.nextOverride?.at]);
+        const cached = this.entries.get(alarm.id);
+        if (cached && cached.fingerprint === fingerprint && time >= cached.computedAt && (cached.at === null || cached.at > time)) {
+            this.entries.delete(alarm.id);
+            this.entries.set(alarm.id, cached);
+            return cached.at === null ? null : new Date(cached.at);
+        }
+        const occurrence = nextOccurrenceForAlarm(alarm, now);
+        this.entries.delete(alarm.id);
+        this.entries.set(alarm.id, { fingerprint, computedAt: time, at: occurrence?.getTime() ?? null });
+        while (this.entries.size > this.limit)
+            this.entries.delete(this.entries.keys().next().value);
+        return occurrence;
+    }
+}

package/dist/alarms/runner.js

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { platformPaths } from '../platform/paths.js';
 import { dirname, join } from 'node:path';
+import { createHash } from 'node:crypto';
 import { assessScheduledOccurrence, NATIVE_DISPATCH_TOLERANCE_MS, nextOccurrenceForAlarm } from './schedule.js';
 import { startActiveAlarmSession } from './active-session.js';
 export async function runAlarm(alarmId, scheduledAtText, deps) {
@@ -37,16 +38,29 @@ export async function runAlarm(alarmId, scheduledAtText, deps) {
     let handoffOutput;
     let validTerminalOccurrence = false;
     let completeLock = true;
+    const tuneAbort = new AbortController();
     let signalReceived = false;
     let resolveEarlySignal = () => { };
     let onPlaybackSignal = () => { };
     const earlySignal = new Promise(resolve => { resolveEarlySignal = resolve; });
-    const unsubscribeSignals = deps.subscribeSignals?.(() => { signalReceived = true; resolveEarlySignal(); onPlaybackSignal(); void deps.player.stop().catch(() => undefined); });
+    const unsubscribeSignals = deps.subscribeSignals?.(() => { signalReceived = true; tuneAbort.abort(); resolveEarlySignal(); onPlaybackSignal(); void deps.player.stop().catch(() => undefined); });
     const finish = (status, message) => ({ status, scheduledAt: scheduledAt.toISOString(), ...(firedAt ? { firedAt: firedAt.toISOString() } : {}), finishedAt: deps.now().toISOString(), ...(message ? { message } : {}) });
     let action;
     let keepPlaying = false;
     let resolveAction = () => { };
     const actionPromise = new Promise(resolve => { resolveAction = resolve; });
+    let backendMessage;
+    let playbackStarted = false;
+    let backendEndedAt;
+    const unsubscribePlayer = deps.player.onChange?.(state => {
+        if ((!listening && !playbackStarted) || action || !['error', 'stopped', 'idle'].includes(state.state))
+            return;
+        backendMessage = state.message ?? 'Alarm stream ended before its scheduled stop.';
+        backendEndedAt = deps.now();
+        action = 'backend-ended';
+        resolveAction('backend-ended');
+        resolveEarlySignal();
+    });
     try {
         if (!alarm || !alarm.enabled)
             return { message: 'Alarm is missing or disabled.' };
@@ -68,13 +82,13 @@ export async function runAlarm(alarmId, scheduledAtText, deps) {
         }
         const claimingStatus = { alarmId, scheduledAt: scheduledAt.toISOString(), stationName: alarm.station.name, station: alarm.station, startedAt: deps.now().toISOString(), state: 'starting' };
         const creatingSession = deps.createSession(claimingStatus, {
-            onDismiss: () => { action = 'dismissed'; resolveAction('dismissed'); resolveEarlySignal(); },
-            onSnooze: minutes => { deps.store.snoozeAlarm(alarmId, new Date(deps.now().getTime() + minutes * 60_000)); preserveNextOverride = true; action = 'snoozed'; resolveAction('snoozed'); resolveEarlySignal(); },
+            onDismiss: () => { tuneAbort.abort(); action = 'dismissed'; resolveAction('dismissed'); resolveEarlySignal(); },
+            onSnooze: async (minutes) => { await deps.store.snoozeAlarm(alarmId, new Date(deps.now().getTime() + minutes * 60_000)); preserveNextOverride = true; tuneAbort.abort(); action = 'snoozed'; resolveAction('snoozed'); resolveEarlySignal(); },
             onKeepPlaying: () => { keepPlaying = true; session?.update({ keepPlaying: true }); },
             onHandoff: async () => { if (!listening)
                 throw new Error('Alarm playback is still starting.'); handoffOutput = (systemVolumeLease?.release({ preserve: true }) ?? Promise.resolve()).then(() => { preserveSystemVolume = true; }); await handoffOutput; action = 'handoff'; resolveAction('handoff'); }
         });
-        void creatingSession.then(created => { if (signalReceived)
+        void creatingSession.then(created => { if (signalReceived || action)
             void created.close().catch(() => undefined); }).catch(() => { });
         const created = await Promise.race([creatingSession.then(value => ({ value })), earlySignal.then(() => ({ signal: true }))]);
         if ('signal' in created) {
@@ -96,7 +110,7 @@ export async function runAlarm(alarmId, scheduledAtText, deps) {
         const candidates = [alarm.station, alarm.station, alarm.playback.fallbackStation].filter((item) => Boolean(item));
         for (const [candidateIndex, candidate] of candidates.entries()) {
             try {
-                const resolved = await Promise.race([deps.providers.resolve(candidate).then(stream => ({ stream })), earlySignal.then(() => ({ signal: true }))]);
+                const resolved = await Promise.race([deps.providers.resolve(candidate, { signal: tuneAbort.signal }).then(stream => ({ stream })), earlySignal.then(() => ({ signal: true }))]);
                 if ('signal' in resolved) {
                     outcome = finish('dismissed', 'Alarm interrupted before playback started.');
                     return { status: 'dismissed', message: outcome.message };
@@ -110,6 +124,7 @@ export async function runAlarm(alarmId, scheduledAtText, deps) {
                         deps.health?.record({ alarmId, occurrenceAt: scheduledAt.toISOString(), component: 'runner', healthy: false, active: true, message: `Alarm continued after interactive playback could not be stopped cleanly: ${errorMessage(error)}` });
                     }
                 }
+                tuneAbort.signal.throwIfAborted();
                 if (!outputPrepared) {
                     outputPrepared = true;
                     if (deps.systemVolume)
@@ -121,7 +136,8 @@ export async function runAlarm(alarmId, scheduledAtText, deps) {
                             deps.health?.record({ alarmId, occurrenceAt: scheduledAt.toISOString(), component: 'runner', healthy: false, active: false, message: `Alarm will use player volume, but system output could not be raised: ${errorMessage(error)}` });
                         }
                 }
-                const playPromise = deps.player.play(candidate, resolved.stream.url);
+                tuneAbort.signal.throwIfAborted();
+                const playPromise = deps.player.play(candidate, resolved.stream.url, { signal: tuneAbort.signal });
                 const tuned = await Promise.race([playPromise.then(() => ({ played: true })), earlySignal.then(() => ({ signal: true }))]);
                 if ('signal' in tuned || signalReceived) {
                     void playPromise.then(() => deps.player.stop()).catch(() => undefined);
@@ -148,15 +164,19 @@ export async function runAlarm(alarmId, scheduledAtText, deps) {
         }
         if (lastError)
             throw lastError;
+        playbackStarted = true;
+        const initialPlayback = deps.player.getState();
+        if (initialPlayback.state && ['error', 'stopped', 'idle'].includes(initialPlayback.state))
+            throw new Error(initialPlayback.message ?? 'Alarm stream ended before playback could be published.');
         firedAt = deps.now();
         try {
             const acquiring = deps.inhibitor.acquire('RadioCLI alarm playback');
-            void acquiring.then(acquired => { if (signalReceived)
+            void acquiring.then(acquired => { if (signalReceived || action)
                 void acquired.release().catch(() => undefined); }).catch(() => { });
             const acquired = await Promise.race([acquiring.then(value => ({ value })), earlySignal.then(() => ({ signal: true }))]);
             if ('signal' in acquired) {
-                outcome = finish('dismissed', 'Alarm interrupted while sleep protection was starting.');
-                return { status: 'dismissed', message: outcome.message };
+                outcome = finish(backendEndedAt ? 'failed' : 'dismissed', backendEndedAt ? backendMessage : 'Alarm interrupted while sleep protection was starting.');
+                return { status: outcome.status, message: outcome.message };
             }
             lease = acquired.value;
             deps.health?.record({ alarmId, occurrenceAt: scheduledAt.toISOString(), component: 'power', healthy: true, active: true, message: 'Sleep inhibition active while playing.' });
@@ -168,16 +188,18 @@ export async function runAlarm(alarmId, scheduledAtText, deps) {
         catch (error) {
             deps.health?.record({ alarmId, occurrenceAt: scheduledAt.toISOString(), component: 'power', healthy: false, active: false, message: `Playback continues without sleep protection: ${errorMessage(error)}` });
         }
+        if (backendEndedAt)
+            throw new Error(backendMessage ?? 'Alarm stream ended while sleep protection was starting.');
         const startedAt = deps.now();
         listening = true;
         try {
-            deps.store.addRecent(resolvedStation);
+            await deps.store.addRecent(resolvedStation);
         }
         catch (error) {
             recordRunnerWarning(`Recent listening history could not be saved: ${errorMessage(error)}`);
         }
         try {
-            deps.store.startListeningSession(resolvedStation, startedAt);
+            await deps.store.startListeningSession(resolvedStation, startedAt);
             historyStarted = true;
         }
         catch (error) {
@@ -221,15 +243,17 @@ export async function runAlarm(alarmId, scheduledAtText, deps) {
                 action = await Promise.race([actionPromise, timeout]);
             }
         }
-        outcome = finish(action === 'dismissed' || action === 'snoozed' || action === 'signal' ? 'dismissed' : 'played', action === 'snoozed' ? 'Snoozed.' : action === 'handoff' ? 'Handed off to interactive playback.' : action === 'signal' ? 'Interrupted.' : undefined);
+        outcome = finish(action === 'backend-ended' ? 'failed' : action === 'dismissed' || action === 'snoozed' || action === 'signal' ? 'dismissed' : 'played', action === 'backend-ended' ? backendMessage : action === 'snoozed' ? 'Snoozed.' : action === 'handoff' ? 'Handed off to interactive playback.' : action === 'signal' ? 'Interrupted.' : undefined);
         return { status: outcome.status, message: outcome.message };
     }
     catch (error) {
-        outcome = finish('failed', errorMessage(error));
-        return { status: 'failed', message: outcome.message };
+        outcome = finish(tuneAbort.signal.aborted && action !== 'backend-ended' ? 'dismissed' : 'failed', errorMessage(error));
+        return { status: outcome.status, message: outcome.message };
     }
     finally {
         listening = false;
+        unsubscribePlayer?.();
+        tuneAbort.abort();
         unsubscribeSignals?.();
         try {
             await deps.player.stop();
@@ -247,14 +271,15 @@ export async function runAlarm(alarmId, scheduledAtText, deps) {
                 catch { }
             }
         if (historyStarted) {
+            const endedAt = backendEndedAt ?? deps.now();
             try {
-                deps.store.checkpointActiveListeningSession(deps.now());
+                await deps.store.checkpointActiveListeningSession(endedAt);
             }
             catch (error) {
                 recordRunnerWarning(`Listening history could not be checkpointed: ${errorMessage(error)}`);
             }
             try {
-                deps.store.finishActiveListeningSession(deps.now());
+                await deps.store.finishActiveListeningSession(endedAt);
             }
             catch (error) {
                 recordRunnerWarning(`Listening history could not be finished: ${errorMessage(error)}`);
@@ -277,10 +302,10 @@ export async function runAlarm(alarmId, scheduledAtText, deps) {
         catch { }
         if (alarm && outcome) {
             try {
-                deps.store.recordAlarmOutcome(alarmId, outcome, { clearNextOverride: validTerminalOccurrence && !preserveNextOverride });
+                await deps.store.recordAlarmOutcome(alarmId, outcome, { clearNextOverride: validTerminalOccurrence && !preserveNextOverride });
                 const latest = deps.store.getAlarm(alarmId);
                 if (alarm.schedule.type === 'once' && latest?.schedule.type === 'once' && latest.schedule.at === alarm.schedule.at && validTerminalOccurrence && !preserveNextOverride)
-                    deps.store.toggleAlarm(alarmId, false);
+                    await deps.store.toggleAlarm(alarmId, false);
             }
             catch (error) {
                 recordRunnerWarning(`Alarm outcome or completion state could not be saved: ${errorMessage(error)}`);
@@ -317,10 +342,18 @@ export async function runAlarm(alarmId, scheduledAtText, deps) {
     }
 }
 export function acquireOccurrenceLock(alarmId, scheduledAt, root = defaultAlarmRuntimeDirectory()) {
-    const safe = `${alarmId.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 80)}-${Buffer.from(scheduledAt).toString('base64url')}`;
-    const path = join(root, 'locks', safe);
+    const occurrence = Buffer.from(scheduledAt).toString('base64url');
+    // Keep existing claims for application-generated UUIDs. Other accepted IDs
+    // need a bounded, case/normalization-safe identity on every filesystem. The
+    // dot prefix cannot be produced by the old lossy sanitizer.
+    const id = /^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/.test(alarmId)
+        ? alarmId : `.id-${createHash('sha256').update(JSON.stringify(alarmId)).digest('hex')}`;
+    const path = join(root, 'locks', `${id}-${occurrence}`);
+    const legacyPath = join(root, 'locks', `${alarmId.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 80)}-${occurrence}`);
     mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
     pruneCompletedOccurrenceLocks(root);
+    if (path !== legacyPath && hasLegacyOccurrenceClaim(legacyPath, alarmId))
+        return null;
     try {
         mkdirSync(path, { mode: 0o700 });
     }
@@ -340,12 +373,43 @@ export function acquireOccurrenceLock(alarmId, scheduledAt, root = defaultAlarmR
             return null;
         }
     }
-    writeFileSync(join(path, 'running'), String(process.pid), { mode: 0o600 });
+    try {
+        writeFileSync(join(path, 'running'), String(process.pid), { mode: 0o600 });
+        writeFileSync(join(path, 'alarm-id'), JSON.stringify(alarmId), { mode: 0o600 });
+    }
+    catch (error) {
+        try {
+            rmSync(path, { recursive: true, force: true });
+        }
+        catch { }
+        throw error;
+    }
     return (completed = true) => { if (!completed) {
         rmSync(path, { recursive: true, force: true });
         return;
     } rmSync(join(path, 'running'), { force: true }); writeFileSync(join(path, 'completed'), new Date().toISOString(), { mode: 0o600 }); };
 }
+function hasLegacyOccurrenceClaim(path, alarmId) {
+    if (!existsSync(path))
+        return false;
+    try {
+        try {
+            if (JSON.parse(readFileSync(join(path, 'alarm-id'), 'utf8')) !== alarmId)
+                return false;
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        if (existsSync(join(path, 'completed')))
+            return true;
+        const pid = Number(readFileSync(join(path, 'running'), 'utf8'));
+        return !Number.isInteger(pid) || pid < 1 || processAlive(pid);
+    }
+    catch {
+        return existsSync(path); /* Unknown legacy ownership fails closed. */
+    }
+}
 export function pruneCompletedOccurrenceLocks(root = defaultAlarmRuntimeDirectory(), olderThanMs = 30 * 24 * 60 * 60_000, now = Date.now()) { const directory = join(root, 'locks'); if (!existsSync(directory))
     return 0; let removed = 0; for (const name of readdirSync(directory)) {
     const completed = join(directory, name, 'completed');
@@ -364,8 +428,8 @@ function processAlive(pid) { try {
     process.kill(pid, 0);
     return true;
 }
-catch {
-    return false;
+catch (error) {
+    return error.code !== 'ESRCH';
 } }
 function nextExpectedOccurrence(alarm, scheduledAt) { if (alarm.nextOverride)
     return new Date(alarm.nextOverride.at); if (alarm.schedule.type === 'once')

package/dist/alarms/schedule.js

@@ -1,5 +1,7 @@
 export const NATIVE_DISPATCH_TOLERANCE_MS = 30_000;
 const formatterCache = new Map();
+const timezoneCache = new Map();
+const civilOccurrenceCache = new Map();
 export function isValidTimeZone(timezone) {
     try {
         new Intl.DateTimeFormat('en-US', { timeZone: timezone }).format();
@@ -11,13 +13,23 @@ export function isValidTimeZone(timezone) {
 }
 export function canonicalizeTimeZone(timezone) {
     const value = timezone.trim();
+    const cached = timezoneCache.get(value);
+    if (cached) {
+        timezoneCache.delete(value);
+        timezoneCache.set(value, cached);
+        return cached;
+    }
     try {
         if (!value)
             throw new Error('Empty timezone.');
         // The constructor validates the zone and resolves its canonical name.
         // Constructing twice made large-library validation expensive on Node 22
         // Intel hosts; keep one native validation for every supplied value.
-        return new Intl.DateTimeFormat('en-US', { timeZone: value }).resolvedOptions().timeZone;
+        const canonical = new Intl.DateTimeFormat('en-US', { timeZone: value }).resolvedOptions().timeZone;
+        timezoneCache.set(value, canonical);
+        while (timezoneCache.size > 256)
+            timezoneCache.delete(timezoneCache.keys().next().value);
+        return canonical;
     }
     catch {
         throw new Error(`Invalid IANA timezone: ${timezone}`);
@@ -106,6 +118,8 @@ function zonedParts(instant, timezone) {
             hourCycle: 'h23'
         });
         formatterCache.set(timezone, formatter);
+        while (formatterCache.size > 128)
+            formatterCache.delete(formatterCache.keys().next().value);
     }
     const values = Object.fromEntries(formatter.formatToParts(instant)
         .filter(part => part.type !== 'literal')
@@ -119,6 +133,20 @@ function zonedParts(instant, timezone) {
     };
 }
 function resolveCivilOccurrence(target, timezone) {
+    const key = `${timezone}:${target.year}:${target.month}:${target.day}:${target.hour}:${target.minute}`;
+    if (civilOccurrenceCache.has(key)) {
+        const cached = civilOccurrenceCache.get(key);
+        civilOccurrenceCache.delete(key);
+        civilOccurrenceCache.set(key, cached);
+        return cached === null ? null : new Date(cached);
+    }
+    const result = scanCivilOccurrence(target, timezone);
+    civilOccurrenceCache.set(key, result?.getTime() ?? null);
+    while (civilOccurrenceCache.size > 2048)
+        civilOccurrenceCache.delete(civilOccurrenceCache.keys().next().value);
+    return result;
+}
+function scanCivilOccurrence(target, timezone) {
     const estimate = Date.UTC(target.year, target.month - 1, target.day, target.hour, target.minute);
     const start = estimate - 18 * 60 * 60_000;
     const end = estimate + 18 * 60 * 60_000;

package/dist/alarms/scheduler.js

@@ -13,6 +13,7 @@ import { identifyPlatform, nativeAdapters } from '../platform/runtime.js';
 import { resolveCommandDetails } from '../platform/executables.js';
 import { launchEnvironment, nodeLaunchCommand } from '../platform/launch-command.js';
 import { powershellCommand } from '../platform/shell.js';
+import { identifyOmarchy } from '../platform/omarchy.js';
 export class SchedulerService {
     adapter;
     now;
@@ -143,7 +144,14 @@ export function createSchedulerAdapter(deps = {}) {
     const resolve = (command) => resolveCommandDetails(command, { platform, env, home }).path;
     const run = deps.run ?? ((command, args) => runCommand(resolve(command) ?? command, args));
     const commandExists = deps.commandExists ?? (command => resolve(command) !== null);
-    const common = { platform, home, nodePath, cliPath, env, terminal: detectGraphicalTerminal(platform, env), write, removeFile, run };
+    const profile = policy.scheduler === 'systemd' ? identifyOmarchy({ ...deps.omarchy, platform, env, home }) : undefined;
+    const inheritDesktop = profile?.kind === 'quattro' && profile.source === 'package' && profile.packageName === 'omarchy';
+    const detectedTerminal = detectGraphicalTerminal(platform, env, undefined, deps.omarchy);
+    // A job registered over SSH may next run inside UWSM's live desktop. Do not
+    // turn the registration-time absence of a display into a permanent selector.
+    const configuredTerminal = env.RADIOCLI_ALARM_TERMINAL?.trim();
+    const terminal = inheritDesktop && detectedTerminal.endsWith(':unsupported') ? configuredTerminal || undefined : detectedTerminal;
+    const common = { platform, home, nodePath, cliPath, env, inheritDesktop, terminal, write, removeFile, run };
     if (policy.scheduler === 'launchd')
         return launchdAdapter(common);
     if (policy.scheduler === 'task-scheduler')
@@ -156,7 +164,7 @@ export function createSchedulerAdapter(deps = {}) {
     return unsupportedAdapter(`Alarm scheduling is not supported on ${host.id === 'unknown' ? host.platform : host.id}.`);
 }
 function runtimeEnvironment(common) {
-    return launchEnvironment(common.env, { platform: common.platform, includeDesktop: true, terminal: common.terminal });
+    return launchEnvironment(common.env, { platform: common.platform, includeDesktop: true, inheritDesktop: common.inheritDesktop, terminal: common.terminal });
 }
 const jobName = (id) => `io.radiocli.alarm.${createHash('sha256').update(id).digest('hex').slice(0, 20)}`;
 const invocationArgs = (common, id, occurrence, internalCommand = 'internal-run') => [common.cliPath, 'alarm', internalCommand, id, occurrence.toISOString()];
@@ -229,7 +237,7 @@ function systemdAdapter(common) {
         capabilities,
         probeCapabilities,
         async install(alarm, occurrence) { const readiness = await probeCapabilities(); if (!readiness.supported)
-            throw new Error(readiness.message); const n = names(alarm.id); const env = Object.entries(runtimeEnvironment(common)).map(([key, value]) => `Environment=${systemdQuote(`${key}=${value}`)}\n`).join(''); const cmd = systemdExecCommand(nodeLaunchCommand(common.nodePath, invocationArgs(common, alarm.id, occurrence), runtimeEnvironment(common))); common.write(join(base, n.service), `[Unit]\nDescription=RadioCLI alarm ${unitText(alarm.label)}\n[Service]\nType=exec\n${env}ExecStart=${cmd}\n`); common.write(join(base, n.timer), `[Unit]\nDescription=RadioCLI scheduled radio ${unitText(alarm.label)}\n[Timer]\nOnCalendar=${systemdCalendar(occurrence)}\nPersistent=true\nAccuracySec=1s\nUnit=${n.service}\n[Install]\nWantedBy=timers.target\n`); ensureSuccess(await common.run('systemctl', ['--user', 'daemon-reload']), 'systemctl daemon-reload'); ensureSuccess(await common.run('systemctl', ['--user', 'enable', '--now', n.timer]), 'systemctl enable'); },
+            throw new Error(readiness.message); const n = names(alarm.id); const env = Object.entries(runtimeEnvironment(common)).map(([key, value]) => `Environment=${systemdQuote(`${key}=${value}`)}\n`).join(''); const cmd = systemdExecCommand(nodeLaunchCommand(common.nodePath, invocationArgs(common, alarm.id, occurrence), runtimeEnvironment(common), { inheritDesktop: common.inheritDesktop })); common.write(join(base, n.service), `[Unit]\nDescription=RadioCLI alarm ${unitText(alarm.label)}\n[Service]\nType=exec\n${env}ExecStart=${cmd}\n`); common.write(join(base, n.timer), `[Unit]\nDescription=RadioCLI scheduled radio ${unitText(alarm.label)}\n[Timer]\nOnCalendar=${systemdCalendar(occurrence)}\nPersistent=true\nAccuracySec=1s\nUnit=${n.service}\n[Install]\nWantedBy=timers.target\n`); ensureSuccess(await common.run('systemctl', ['--user', 'daemon-reload']), 'systemctl daemon-reload'); ensureSuccess(await common.run('systemctl', ['--user', 'enable', '--now', n.timer]), 'systemctl enable'); },
         async remove(id) {
             const n = names(id);
             await removeWithVerification(() => common.run('systemctl', ['--user', 'disable', '--now', n.timer]), () => common.run('systemctl', ['--user', 'show', n.timer, '--property=LoadState', '--property=ActiveState']), result => /^LoadState=not-found\r?$/m.test(result.stdout) && /^ActiveState=inactive\r?$/m.test(result.stdout), 'systemd timer');