@loicngr/kobo 1.7.5 → 1.7.7

package/dist/server/services/cron-service.js

@@ -0,0 +1,279 @@
+import { CronExpressionParser } from 'cron-parser';
+import { nanoid } from 'nanoid';
+import { getDb } from '../db/index.js';
+import { slugifyProjectName } from '../utils/project-slug.js';
+import { resolveWorkspaceWorktreePath } from '../utils/worktree-paths.js';
+import * as orchestrator from './agent/orchestrator.js';
+import * as settingsService from './settings-service.js';
+import { emitEphemeral } from './websocket-service.js';
+export const MIN_DELAY_BETWEEN_FIRES_SECONDS = 60;
+// Node `setTimeout` stores the delay as a 32-bit signed int. Anything above
+// 2^31-1 ms (~24.8 days) triggers `TimeoutOverflowWarning` and silently
+// truncates to 1ms — which causes the timer to fire instantly and loop
+// when the real target is years away (e.g. `@yearly` or `0 0 1 1 *`).
+// We cap each setTimeout at this max and re-arm in the callback if the
+// real fire time hasn't been reached yet.
+const MAX_SETTIMEOUT_MS = 2_000_000_000; // ~23 days, with margin under 2^31-1
+const timers = new Map();
+/**
+ * Arm a setTimeout that fires `fireOrSkip(id)` when `fireAt` is reached.
+ * Replaces any existing timer for this id. Handles long horizons by
+ * chaining capped timeouts, since Node's setTimeout overflows past ~24.8
+ * days.
+ */
+function scheduleAt(id, fireAt) {
+    const previous = timers.get(id);
+    if (previous)
+        clearTimeout(previous);
+    const deltaMs = Math.max(0, fireAt.getTime() - Date.now());
+    const cappedMs = Math.min(deltaMs, MAX_SETTIMEOUT_MS);
+    const timer = setTimeout(() => {
+        timers.delete(id);
+        if (Date.now() >= fireAt.getTime()) {
+            fireOrSkip(id);
+        }
+        else {
+            // Long-horizon cron: hop forward another chunk and re-check.
+            scheduleAt(id, fireAt);
+        }
+    }, cappedMs);
+    timer.unref?.();
+    timers.set(id, timer);
+}
+function rowToCron(row) {
+    return {
+        id: row.id,
+        workspaceId: row.workspace_id,
+        expression: row.expression,
+        prompt: row.prompt,
+        label: row.label,
+        agentSessionId: row.agent_session_id,
+        nextFireAt: row.next_fire_at,
+        lastFiredAt: row.last_fired_at,
+        oneShot: row.one_shot === 1,
+        createdAt: row.created_at,
+    };
+}
+/**
+ * Compute the next fire time for an expression strictly after `from`.
+ * Uses cron-parser 5.x API. Throws with a descriptive error if the
+ * expression is invalid. Helpers `@hourly` / `@daily` / `@weekly` /
+ * `@monthly` / `@yearly` are accepted natively.
+ */
+function nextAfter(expression, from) {
+    try {
+        const it = CronExpressionParser.parse(expression, { currentDate: from });
+        return it.next().toDate();
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`Invalid cron expression: ${expression} — ${msg}`);
+    }
+}
+/**
+ * Validate the expression, persist the row, arm a setTimeout for the next
+ * fire, emit `cron:created`. Throws on invalid expression OR when the next
+ * fire is < MIN_DELAY_BETWEEN_FIRES_SECONDS seconds in the future.
+ */
+export function arm(workspaceId, args) {
+    const now = new Date();
+    const next = nextAfter(args.expression, now);
+    const deltaMs = next.getTime() - now.getTime();
+    if (deltaMs < MIN_DELAY_BETWEEN_FIRES_SECONDS * 1000) {
+        throw new Error(`Cron expression resolves too close to now (minimum ${MIN_DELAY_BETWEEN_FIRES_SECONDS}s); use a longer interval`);
+    }
+    const id = nanoid();
+    const db = getDb();
+    db.prepare(`INSERT INTO pending_crons (id, workspace_id, expression, prompt, label, agent_session_id, next_fire_at, last_fired_at, one_shot, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, NULL, ?, ?)`).run(id, workspaceId, args.expression, args.prompt, args.label ?? null, args.agentSessionId ?? null, next.toISOString(), args.oneShot ? 1 : 0, now.toISOString());
+    scheduleAt(id, next);
+    const cron = rowToCron(db.prepare('SELECT * FROM pending_crons WHERE id = ?').get(id));
+    emitEphemeral(workspaceId, 'cron:created', { cron });
+    return cron;
+}
+/**
+ * Remove a single cron by id. Idempotent — returns false if no row matched.
+ * Emits `cron:cancelled` only when a row was actually deleted.
+ */
+export function cancel(id, reason) {
+    const db = getDb();
+    const row = db.prepare('SELECT workspace_id FROM pending_crons WHERE id = ?').get(id);
+    if (!row)
+        return false;
+    db.prepare('DELETE FROM pending_crons WHERE id = ?').run(id);
+    const previous = timers.get(id);
+    if (previous) {
+        clearTimeout(previous);
+        timers.delete(id);
+    }
+    emitEphemeral(row.workspace_id, 'cron:cancelled', { id, reason });
+    return true;
+}
+/**
+ * Remove every cron for a workspace. Returns the number of rows deleted.
+ * Used by archive + delete cascades.
+ */
+export function cancelAllForWorkspace(workspaceId, reason) {
+    const db = getDb();
+    const rows = db.prepare('SELECT id FROM pending_crons WHERE workspace_id = ?').all(workspaceId);
+    let deleted = 0;
+    for (const r of rows) {
+        if (cancel(r.id, reason))
+            deleted++;
+    }
+    return deleted;
+}
+export function getCron(id) {
+    const db = getDb();
+    const row = db.prepare('SELECT * FROM pending_crons WHERE id = ?').get(id);
+    return row ? rowToCron(row) : null;
+}
+export function listForWorkspace(workspaceId) {
+    const db = getDb();
+    const rows = db
+        .prepare('SELECT * FROM pending_crons WHERE workspace_id = ? ORDER BY next_fire_at ASC')
+        .all(workspaceId);
+    return rows.map(rowToCron);
+}
+export function listAll() {
+    const db = getDb();
+    const rows = db.prepare('SELECT * FROM pending_crons ORDER BY next_fire_at ASC').all();
+    return rows.map(rowToCron);
+}
+/**
+ * Internal — invoked by setTimeout when a cron's `next_fire_at` elapses.
+ * Either fires (calls orchestrator.startAgent with resume=true) or skips
+ * (when a controller is already active for the workspace), then recomputes
+ * the next occurrence and re-arms a fresh setTimeout. Best-effort: any
+ * unexpected error is logged and the cron is preserved when possible.
+ */
+function fireOrSkip(id) {
+    try {
+        timers.delete(id);
+        const db = getDb();
+        const row = db.prepare('SELECT * FROM pending_crons WHERE id = ?').get(id);
+        if (!row)
+            return; // cancelled in flight
+        const wsRow = db
+            .prepare(`SELECT project_path, working_branch, worktree_path, model, agent_permission_mode, reasoning_effort, archived_at
+           FROM workspaces WHERE id = ?`)
+            .get(row.workspace_id);
+        if (!wsRow || wsRow.archived_at !== null) {
+            cancel(id, wsRow ? 'archive' : 'deleted');
+            return;
+        }
+        let status = 'skipped-active';
+        if (!orchestrator.hasController(row.workspace_id)) {
+            status = 'fired';
+            try {
+                const globalSettings = settingsService.getGlobalSettings();
+                const projectSettings = settingsService.getProjectSettings(wsRow.project_path);
+                const projectSlug = globalSettings.worktreesPrefixByProject
+                    ? slugifyProjectName(projectSettings?.displayName ?? '', wsRow.project_path)
+                    : undefined;
+                const worktreePath = wsRow.worktree_path ??
+                    resolveWorkspaceWorktreePath(wsRow.project_path, wsRow.working_branch, globalSettings.worktreesPath, projectSlug);
+                const stored = wsRow.agent_permission_mode;
+                const agentPermissionMode = stored === 'plan' || stored === 'strict' || stored === 'interactive' ? stored : 'bypass';
+                // agent_session_id encodes the cron's mode: non-NULL means "resume
+                // that session" (pinned at create time); NULL means "fresh session
+                // every fire" (clean context, no conversation continuity).
+                const resumeMode = row.agent_session_id !== null;
+                orchestrator.startAgent(row.workspace_id, worktreePath, row.prompt, wsRow.model, resumeMode, agentPermissionMode, row.agent_session_id ?? undefined, wsRow.reasoning_effort);
+            }
+            catch (err) {
+                console.error(`[cron-service] startAgent at fire time failed for cron '${id}':`, err);
+            }
+        }
+        const now = new Date();
+        let nextFire;
+        try {
+            nextFire = nextAfter(row.expression, now);
+        }
+        catch (err) {
+            // Defensive — the expression validated at create time, so reaching here
+            // means cron-parser changed its acceptance rules between the original
+            // arm and this fire. Cancel as 'completed' (the cron self-terminates)
+            // rather than 'user' which would imply the user requested it.
+            console.error(`[cron-service] failed to recompute next fire for cron '${id}':`, err);
+            cancel(id, 'completed');
+            return;
+        }
+        // One-shot crons cancel themselves after a real fire (not on skip-active —
+        // the user expects the cron to actually run once, so a skipped tick must
+        // be retried at the next occurrence). Recurring crons re-arm normally.
+        if (status === 'fired' && row.one_shot === 1) {
+            db.prepare(`UPDATE pending_crons SET last_fired_at = ? WHERE id = ?`).run(now.toISOString(), id);
+            emitEphemeral(row.workspace_id, 'cron:fired', {
+                id,
+                status,
+                nextFireAt: null,
+                lastFiredAt: now.toISOString(),
+                oneShotConsumed: true,
+            });
+            cancel(id, 'completed');
+            return;
+        }
+        db.prepare(`UPDATE pending_crons SET next_fire_at = ?, last_fired_at = ? WHERE id = ?`).run(nextFire.toISOString(), now.toISOString(), id);
+        scheduleAt(id, nextFire);
+        emitEphemeral(row.workspace_id, 'cron:fired', {
+            id,
+            status,
+            nextFireAt: nextFire.toISOString(),
+            lastFiredAt: now.toISOString(),
+        });
+    }
+    catch (err) {
+        console.error(`[cron-service] fireOrSkip uncaught error for cron '${id}':`, err);
+        timers.delete(id);
+    }
+}
+/**
+ * Re-arm timers for rows persisted across restart. Skip-missed semantics:
+ * if the stored next_fire_at is in the past, recompute next() based on the
+ * current time and update the row before arming (mirror of POSIX crontab —
+ * no catchup spam after server downtime).
+ *
+ * Rows pointing at deleted/archived workspaces are removed without firing.
+ */
+export function restoreOnBoot() {
+    try {
+        // Boot semantics: clear any existing in-memory timers before rearming.
+        for (const t of timers.values())
+            clearTimeout(t);
+        timers.clear();
+        const db = getDb();
+        const rows = db.prepare('SELECT * FROM pending_crons').all();
+        const now = new Date();
+        for (const row of rows) {
+            try {
+                const wsRow = db.prepare('SELECT archived_at FROM workspaces WHERE id = ?').get(row.workspace_id);
+                if (!wsRow || wsRow.archived_at !== null) {
+                    db.prepare('DELETE FROM pending_crons WHERE id = ?').run(row.id);
+                    continue;
+                }
+                const storedDate = new Date(row.next_fire_at);
+                let nextFireAt;
+                if (storedDate.getTime() <= now.getTime()) {
+                    // Skip-missed semantics — no catchup spam after downtime.
+                    const next = nextAfter(row.expression, now);
+                    nextFireAt = next.toISOString();
+                }
+                else {
+                    // Future row: normalise the persisted ISO format.
+                    nextFireAt = storedDate.toISOString();
+                }
+                db.prepare('UPDATE pending_crons SET next_fire_at = ? WHERE id = ?').run(nextFireAt, row.id);
+                scheduleAt(row.id, new Date(nextFireAt));
+            }
+            catch (err) {
+                console.error(`[cron-service] restoreOnBoot row failed for cron '${row.id}':`, err);
+            }
+        }
+    }
+    catch (err) {
+        console.error('[cron-service] restoreOnBoot failed:', err);
+    }
+}
+/** @internal test-only */
+export const _timers = timers;

package/dist/server/services/settings-service.js

@@ -266,6 +266,39 @@ const settingsMigrations = [
             }
         },
     },
+    {
+        version: 17,
+        name: 'add-voice-transcription-settings',
+        migrate({ global }) {
+            if (typeof global.voiceEnabled !== 'boolean')
+                global.voiceEnabled = false;
+            if (global.voicePttKey !== 'alt' && global.voicePttKey !== 'ctrl+space')
+                global.voicePttKey = 'alt';
+            if (typeof global.voiceLanguage !== 'string' || global.voiceLanguage.length === 0)
+                global.voiceLanguage = 'auto';
+            if (typeof global.voiceModel !== 'string' && global.voiceModel !== null)
+                global.voiceModel = null;
+            if (typeof global.voiceCommandPath !== 'string')
+                global.voiceCommandPath = '';
+            if (typeof global.voiceFfmpegPath !== 'string')
+                global.voiceFfmpegPath = '';
+        },
+    },
+    {
+        version: 18,
+        name: 'add-voice-advanced-settings',
+        migrate({ global }) {
+            const t = Number(global.voiceTemperature);
+            if (!Number.isFinite(t) || t < 0 || t > 1)
+                global.voiceTemperature = 0;
+            if (typeof global.voicePrompt !== 'string')
+                global.voicePrompt = '';
+            if (typeof global.voiceTranslateToEnglish !== 'boolean')
+                global.voiceTranslateToEnglish = false;
+            if (typeof global.voiceSuppressNonSpeechTokens !== 'boolean')
+                global.voiceSuppressNonSpeechTokens = true;
+        },
+    },
 ];
 /** Current settings schema version — always equals the highest migration version. */
 export const SETTINGS_SCHEMA_VERSION = settingsMigrations.length > 0 ? settingsMigrations[settingsMigrations.length - 1].version : 0;
@@ -313,6 +346,16 @@ function defaultSettings() {
             tags: [...DEFAULT_WORKSPACE_TAGS],
             worktreesPath: WORKTREES_PATH,
             worktreesPrefixByProject: false,
+            voiceEnabled: false,
+            voicePttKey: 'alt',
+            voiceLanguage: 'auto',
+            voiceModel: null,
+            voiceCommandPath: '',
+            voiceFfmpegPath: '',
+            voiceTemperature: 0,
+            voicePrompt: '',
+            voiceTranslateToEnglish: false,
+            voiceSuppressNonSpeechTokens: true,
         },
         projects: [],
     };
@@ -551,6 +594,16 @@ export function updateGlobalSettings(data) {
         'tags',
         'worktreesPath',
         'worktreesPrefixByProject',
+        'voiceEnabled',
+        'voicePttKey',
+        'voiceLanguage',
+        'voiceModel',
+        'voiceCommandPath',
+        'voiceFfmpegPath',
+        'voiceTemperature',
+        'voicePrompt',
+        'voiceTranslateToEnglish',
+        'voiceSuppressNonSpeechTokens',
     ];
     const filtered = pickKnownKeys(data, allowedGlobalKeys);
     if (filtered.tags !== undefined) {
@@ -564,6 +617,10 @@ export function updateGlobalSettings(data) {
         const v = Number(filtered.audioNotificationVolume);
         filtered.audioNotificationVolume = Number.isFinite(v) ? Math.max(0, Math.min(1, v)) : 1;
     }
+    if (filtered.voiceTemperature !== undefined) {
+        const t = Number(filtered.voiceTemperature);
+        filtered.voiceTemperature = Number.isFinite(t) ? Math.max(0, Math.min(1, t)) : settings.global.voiceTemperature;
+    }
     if (filtered.worktreesPath !== undefined) {
         filtered.worktreesPath = validateWorktreesPath(filtered.worktreesPath, { allowEmpty: false });
         ensureGlobalWorktreesRootExists(filtered.worktreesPath);

package/dist/server/services/transcription-service.js

@@ -0,0 +1,206 @@
+import { execFile } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { getKoboHome } from '../utils/paths.js';
+import { getGlobalSettings } from './settings-service.js';
+const execFileAsync = promisify(execFile);
+const MAX_LANG_LENGTH = 16;
+export class VoiceError extends Error {
+    code;
+    status;
+    constructor(message, code, status = 400) {
+        super(message);
+        this.code = code;
+        this.status = status;
+        this.name = 'VoiceError';
+    }
+}
+export const VOICE_MODELS = [
+    {
+        name: 'tiny',
+        fileName: 'ggml-tiny.bin',
+        url: 'https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-tiny.bin?download=true',
+    },
+    {
+        name: 'base',
+        fileName: 'ggml-base.bin',
+        url: 'https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base.bin?download=true',
+    },
+    {
+        name: 'small',
+        fileName: 'ggml-small.bin',
+        url: 'https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-small.bin?download=true',
+    },
+    {
+        name: 'medium',
+        fileName: 'ggml-medium.bin',
+        url: 'https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-medium.bin?download=true',
+    },
+    {
+        name: 'large-v3',
+        fileName: 'ggml-large-v3.bin',
+        url: 'https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-large-v3.bin?download=true',
+    },
+];
+function voiceHome() {
+    return path.join(getKoboHome(), 'voice');
+}
+function modelsDir() {
+    return path.join(voiceHome(), 'models', 'whisper');
+}
+function resolveWhisperCommand() {
+    const global = getGlobalSettings();
+    const fromSettings = (global.voiceCommandPath ?? '').trim();
+    if (fromSettings.length > 0)
+        return fromSettings;
+    return process.env.WHISPER_CPP_COMMAND || 'whisper-cli';
+}
+function resolveFfmpegCommand() {
+    const global = getGlobalSettings();
+    const fromSettings = (global.voiceFfmpegPath ?? '').trim();
+    if (fromSettings.length > 0)
+        return fromSettings;
+    return 'ffmpeg';
+}
+function ensureVoiceDirs() {
+    fs.mkdirSync(modelsDir(), { recursive: true });
+}
+function resolveModel(name) {
+    const model = VOICE_MODELS.find((m) => m.name === name);
+    if (!model)
+        throw new VoiceError(`Unknown voice model '${name}'`, 'MODEL_UNKNOWN', 400);
+    return model;
+}
+export function listVoiceModels() {
+    ensureVoiceDirs();
+    const settings = getGlobalSettings();
+    const available = VOICE_MODELS.map((m) => ({
+        name: m.name,
+        fileName: m.fileName,
+        installed: fs.existsSync(path.join(modelsDir(), m.fileName)),
+    }));
+    return { available, activeModel: settings.voiceModel };
+}
+export async function getVoiceRuntimeStatus() {
+    const command = resolveWhisperCommand();
+    let ffmpegAvailable = true;
+    let ffmpegError;
+    try {
+        await execFileAsync(resolveFfmpegCommand(), ['-version'], { timeout: 5000 });
+    }
+    catch (err) {
+        ffmpegAvailable = false;
+        ffmpegError = err instanceof Error ? err.message : String(err);
+    }
+    try {
+        await execFileAsync(command, ['-h'], { timeout: 5000 });
+        return { available: ffmpegAvailable, command, ffmpegAvailable, ffmpegError };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { available: false, command, error: message, ffmpegAvailable, ffmpegError };
+    }
+}
+export async function downloadVoiceModel(name) {
+    ensureVoiceDirs();
+    const model = resolveModel(name);
+    const res = await fetch(model.url);
+    if (!res.ok) {
+        throw new VoiceError(`Failed to download model '${name}' (HTTP ${res.status})`, 'MODEL_DOWNLOAD_FAILED', 500);
+    }
+    const filePath = path.join(modelsDir(), model.fileName);
+    const tmpPath = `${filePath}.tmp`;
+    try {
+        const bytes = Buffer.from(await res.arrayBuffer());
+        fs.writeFileSync(tmpPath, bytes);
+        fs.renameSync(tmpPath, filePath);
+    }
+    finally {
+        if (fs.existsSync(tmpPath))
+            fs.rmSync(tmpPath, { force: true });
+    }
+    return { name, filePath };
+}
+export function deleteVoiceModel(name) {
+    const model = resolveModel(name);
+    const filePath = path.join(modelsDir(), model.fileName);
+    if (fs.existsSync(filePath))
+        fs.unlinkSync(filePath);
+}
+function getInstalledModelPath(name) {
+    const model = resolveModel(name);
+    const fullPath = path.join(modelsDir(), model.fileName);
+    if (!fs.existsSync(fullPath)) {
+        throw new VoiceError(`Model '${name}' is not installed`, 'MODEL_NOT_INSTALLED', 400);
+    }
+    return fullPath;
+}
+export async function transcribeAudio(params) {
+    const { audioBuffer, modelName } = params;
+    const language = params.language && params.language.trim().length > 0 ? params.language : 'auto';
+    const temperature = Number.isFinite(Number(params.temperature))
+        ? Math.max(0, Math.min(1, Number(params.temperature)))
+        : 0;
+    const prompt = (params.prompt ?? '').trim();
+    const translateToEnglish = params.translateToEnglish === true;
+    const suppressNst = params.suppressNonSpeechTokens !== false;
+    if (language.length > MAX_LANG_LENGTH || !/^[a-z-]+$/i.test(language)) {
+        throw new VoiceError(`Invalid language '${language}'`, 'LANGUAGE_INVALID', 400);
+    }
+    const modelPath = getInstalledModelPath(modelName);
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kobo-voice-'));
+    const audioPath = path.join(tmpDir, 'input.webm');
+    const wavPath = path.join(tmpDir, 'input.wav');
+    try {
+        fs.writeFileSync(audioPath, audioBuffer);
+        // Normalize browser-recorded audio (webm/ogg/...) to a mono WAV file that
+        // whisper-cli can decode reliably across platforms.
+        await execFileAsync(resolveFfmpegCommand(), ['-y', '-i', audioPath, '-ar', '16000', '-ac', '1', wavPath], {
+            timeout: 60000,
+        });
+        const cmd = resolveWhisperCommand();
+        const args = [
+            '-m',
+            modelPath,
+            '-f',
+            wavPath,
+            '-otxt',
+            '-of',
+            path.join(tmpDir, 'out'),
+            '--temperature',
+            String(temperature),
+        ];
+        if (language !== 'auto')
+            args.push('-l', language);
+        if (translateToEnglish)
+            args.push('--translate');
+        if (suppressNst)
+            args.push('--suppress-nst');
+        if (prompt.length > 0)
+            args.push('--prompt', prompt);
+        const start = Date.now();
+        const { stderr } = await execFileAsync(cmd, args, { timeout: 120000 });
+        const durationMs = Date.now() - start;
+        const outTxt = path.join(tmpDir, 'out.txt');
+        if (!fs.existsSync(outTxt)) {
+            throw new VoiceError(`Transcription output missing (${stderr || 'no stderr'})`, 'TRANSCRIPTION_FAILED', 500);
+        }
+        const text = fs.readFileSync(outTxt, 'utf-8').trim();
+        return { text, durationMs, model: modelName, language };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.includes('ENOENT')) {
+            throw new VoiceError('Voice runtime missing (whisper-cli or ffmpeg)', 'VOICE_RUNTIME_MISSING', 500);
+        }
+        if (message.includes('timed out')) {
+            throw new VoiceError('Whisper transcription timed out', 'TRANSCRIPTION_TIMEOUT', 500);
+        }
+        throw err;
+    }
+    finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+}

package/dist/server/services/wakeup-service.js

@@ -5,7 +5,7 @@ import * as orchestrator from './agent/orchestrator.js';
 import * as settingsService from './settings-service.js';
 import { emitEphemeral } from './websocket-service.js';
 const MIN_DELAY_SECONDS = 60;
-const MAX_DELAY_SECONDS = 3600;
+const MAX_DELAY_SECONDS = 21600;
 const STALE_WAKEUP_GRACE_MS = 5 * 60 * 1000;
 const AUTONOMOUS_LOOP_SENTINEL = '<<autonomous-loop-dynamic>>';
 const AUTONOMOUS_LOOP_FALLBACK_PROMPT = 'Continue where you left off.';

package/dist/server/services/workspace-service.js

@@ -3,6 +3,7 @@ import { getDb } from '../db/index.js';
 import { resolveWorkspaceWorktreePath } from '../utils/worktree-paths.js';
 import * as orchestrator from './agent/orchestrator.js';
 import * as autoLoopService from './auto-loop-service.js';
+import * as cronService from './cron-service.js';
 import * as quotaBackoffService from './quota-backoff-service.js';
 import * as wakeupService from './wakeup-service.js';
 import { emitEphemeral } from './websocket-service.js';
@@ -363,6 +364,15 @@ export function deleteWorkspace(id) {
     catch (err) {
         console.error('[workspace-service] cancel quota backoff on delete failed:', err);
     }
+    // Cancel every pending cron BEFORE the FK cascade removes the rows so
+    // in-memory setTimeout timers are cleared. Best-effort: failure must not
+    // block delete.
+    try {
+        cronService.cancelAllForWorkspace(id, 'deleted');
+    }
+    catch (err) {
+        console.error('[workspace-service] cancel crons on delete failed:', err);
+    }
     // Drop the cached rate_limit.info so memory doesn't leak on workspace
     // churn. The Map has no FK to clean up for it automatically.
     orchestrator.forgetRateLimitInfo(id);
@@ -463,6 +473,14 @@ export function archiveWorkspace(id) {
     catch (err) {
         console.error('[workspace-service] cancel quota backoff on archive failed:', err);
     }
+    // Cancel every pending cron — archived workspaces must not fire scheduled
+    // prompts. Best-effort: failure here must not block archive.
+    try {
+        cronService.cancelAllForWorkspace(id, 'archive');
+    }
+    catch (err) {
+        console.error('[workspace-service] cancel crons on archive failed:', err);
+    }
     // Disable auto-loop — archived workspaces should not keep looping.
     // Idempotent: no-op if auto_loop was already 0.
     autoLoopService.disable(id, 'user-action');

package/dist/server/utils/git-ops.js

@@ -583,7 +583,14 @@ export function getUnpushedChangedFiles(repoPath, branchName, remote = 'origin')
 export function getFileAtRef(repoPath, ref, filePath) {
     const resolvedRef = resolveBase(repoPath, ref);
     try {
-        return git(repoPath, ['show', `${resolvedRef}:${filePath}`]);
+        // Bypass the `git()` helper here: it `.trimEnd()`s the output, which would
+        // strip trailing newlines from the original file content and produce a
+        // false diff against `getFileContent`'s untrimmed `readFileSync` output
+        // (last line marked added/removed even when identical).
+        return execFileSync('git', ['show', `${resolvedRef}:${filePath}`], {
+            cwd: repoPath,
+            encoding: 'utf-8',
+        });
     }
     catch {
         return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loicngr/kobo",
-  "version": "1.7.5",
+  "version": "1.7.7",
   "description": "Kōbō — multi-workspace agent manager for Claude Code. Orchestrates isolated git worktrees with dev servers, Notion integration, and MCP tools.",
   "type": "module",
   "license": "GPL-3.0-or-later",
@@ -66,24 +66,27 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.126",
-    "@hono/node-server": "^1.19.13",
+    "@anthropic-ai/claude-agent-sdk": "^0.2.90",
+    "@emnapi/core": "^1.10.0",
+    "@emnapi/runtime": "^1.10.0",
+    "@hono/node-server": "^2.0.2",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "better-sqlite3": "^12.8.0",
-    "hono": "^4.12.12",
-    "nanoid": "^5.1.7",
+    "better-sqlite3": "^12.9.0",
+    "cron-parser": "^5.5.0",
+    "hono": "^4.12.18",
+    "nanoid": "^5.1.11",
     "node-pty": "^1.1.0",
     "ws": "^8.20.0"
   },
   "devDependencies": {
     "@biomejs/biome": "2.4.10",
     "@types/better-sqlite3": "^7.6.13",
-    "@types/node": "^25.5.2",
+    "@types/node": "^25.6.2",
     "@types/ws": "^8.18.1",
-    "@vitest/runner": "^4.1.2",
+    "@vitest/runner": "^4.1.5",
     "concurrently": "^9.2.1",
     "tsx": "^4.21.0",
-    "typescript": "^6.0.2",
-    "vitest": "^3.2.4"
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.5"
   }
 }