@loicngr/kobo 1.7.5 → 1.7.7

package/dist/server/routes/voice.js

@@ -0,0 +1,149 @@
+import { Hono } from 'hono';
+import * as settingsService from '../services/settings-service.js';
+import * as transcriptionService from '../services/transcription-service.js';
+import * as workspaceService from '../services/workspace-service.js';
+const app = new Hono();
+const MAX_AUDIO_SIZE = 10 * 1024 * 1024;
+const ALLOWED_AUDIO_MIME = new Set(['audio/webm', 'audio/ogg', 'audio/wav', 'audio/mpeg', 'audio/mp4']);
+const LANGUAGE_RE = /^[a-z-]+$/i;
+function isVoiceLikeError(err) {
+    if (!err || typeof err !== 'object')
+        return false;
+    const e = err;
+    return typeof e.message === 'string' && typeof e.code === 'string' && typeof e.status === 'number';
+}
+function toVoiceHttpStatus(status) {
+    return status === 400 ? 400 : 500;
+}
+async function parseAndTranscribeFromBody(c, config) {
+    const body = await c.req.parseBody();
+    const audio = body.audio;
+    const languageRaw = body.language;
+    const language = typeof languageRaw === 'string' && languageRaw.trim().length > 0 ? languageRaw.trim() : 'auto';
+    if (language !== 'auto' && (!LANGUAGE_RE.test(language) || language.length > 16)) {
+        return c.json({ error: `Invalid language '${language}'`, code: 'LANGUAGE_INVALID' }, 400);
+    }
+    if (!audio || !(audio instanceof File)) {
+        return c.json({ error: 'Missing audio field in multipart body', code: 'MIC_AUDIO_INVALID' }, 400);
+    }
+    if (!ALLOWED_AUDIO_MIME.has(audio.type)) {
+        return c.json({ error: `Unsupported audio type '${audio.type}'`, code: 'MIC_AUDIO_INVALID' }, 400);
+    }
+    const buffer = Buffer.from(await audio.arrayBuffer());
+    if (buffer.length === 0 || buffer.length > MAX_AUDIO_SIZE) {
+        return c.json({ error: 'Invalid audio size', code: 'MIC_AUDIO_INVALID' }, 400);
+    }
+    const result = await transcriptionService.transcribeAudio({
+        audioBuffer: buffer,
+        modelName: config.modelName,
+        language,
+        temperature: config.temperature,
+        prompt: config.prompt,
+        translateToEnglish: config.translateToEnglish,
+        suppressNonSpeechTokens: config.suppressNonSpeechTokens,
+    });
+    return c.json(result);
+}
+app.get('/models', (c) => {
+    try {
+        return c.json(transcriptionService.listVoiceModels());
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
+app.get('/runtime', async (c) => {
+    try {
+        const status = await transcriptionService.getVoiceRuntimeStatus();
+        return c.json(status);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message, code: 'VOICE_RUNTIME_CHECK_FAILED' }, 500);
+    }
+});
+app.post('/models/:name/download', async (c) => {
+    try {
+        const name = c.req.param('name');
+        const result = await transcriptionService.downloadVoiceModel(name);
+        return c.json(result, 201);
+    }
+    catch (err) {
+        if (err instanceof transcriptionService.VoiceError || isVoiceLikeError(err)) {
+            return c.json({ error: err.message, code: err.code }, toVoiceHttpStatus(err.status));
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message, code: 'MODEL_DOWNLOAD_FAILED' }, 500);
+    }
+});
+app.delete('/models/:name', (c) => {
+    try {
+        const name = c.req.param('name');
+        transcriptionService.deleteVoiceModel(name);
+        return c.body(null, 204);
+    }
+    catch (err) {
+        if (err instanceof transcriptionService.VoiceError || isVoiceLikeError(err)) {
+            return c.json({ error: err.message, code: err.code }, toVoiceHttpStatus(err.status));
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message, code: 'MODEL_DELETE_FAILED' }, 500);
+    }
+});
+app.post('/workspaces/:id/transcribe', async (c) => {
+    try {
+        const id = c.req.param('id');
+        const workspace = workspaceService.getWorkspace(id);
+        if (!workspace)
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        const global = settingsService.getGlobalSettings();
+        if (!global.voiceEnabled) {
+            return c.json({ error: 'Voice transcription is disabled', code: 'VOICE_DISABLED' }, 400);
+        }
+        if (!global.voiceModel) {
+            return c.json({ error: 'No voice model configured', code: 'MODEL_NOT_CONFIGURED' }, 400);
+        }
+        return await parseAndTranscribeFromBody(c, {
+            modelName: global.voiceModel,
+            temperature: global.voiceTemperature,
+            prompt: global.voicePrompt,
+            translateToEnglish: global.voiceTranslateToEnglish,
+            suppressNonSpeechTokens: global.voiceSuppressNonSpeechTokens,
+        });
+    }
+    catch (err) {
+        if (err instanceof transcriptionService.VoiceError || isVoiceLikeError(err)) {
+            return c.json({ error: err.message, code: err.code }, toVoiceHttpStatus(err.status));
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message, code: 'TRANSCRIPTION_FAILED' }, 500);
+    }
+});
+// Draft transcription endpoint used before a workspace exists (Create page).
+app.post('/transcribe', async (c) => {
+    try {
+        const global = settingsService.getGlobalSettings();
+        if (!global.voiceEnabled) {
+            return c.json({ error: 'Voice transcription is disabled', code: 'VOICE_DISABLED' }, 400);
+        }
+        if (!global.voiceModel) {
+            return c.json({ error: 'No voice model configured', code: 'MODEL_NOT_CONFIGURED' }, 400);
+        }
+        return await parseAndTranscribeFromBody(c, {
+            modelName: global.voiceModel,
+            temperature: global.voiceTemperature,
+            prompt: global.voicePrompt,
+            translateToEnglish: global.voiceTranslateToEnglish,
+            suppressNonSpeechTokens: global.voiceSuppressNonSpeechTokens,
+        });
+    }
+    catch (err) {
+        if (err instanceof transcriptionService.VoiceError) {
+            return c.json({ error: err.message, code: err.code }, toVoiceHttpStatus(err.status));
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message, code: 'TRANSCRIPTION_FAILED' }, 500);
+    }
+});
+export default app;

package/dist/server/routes/workspaces.js

@@ -10,6 +10,7 @@ import { migrationGuard } from '../middleware/migration-guard.js';
 import { listEngines } from '../services/agent/engines/registry.js';
 import * as agentManager from '../services/agent/orchestrator.js';
 import * as autoLoopService from '../services/auto-loop-service.js';
+import * as cronService from '../services/cron-service.js';
 import * as devServerService from '../services/dev-server-service.js';
 import { DEFAULT_NOTION_INITIAL_PROMPT, DEFAULT_SENTRY_INITIAL_PROMPT, renderNotionInitialPrompt, renderSentryInitialPrompt, } from '../services/initial-prompt-template-service.js';
 import * as notionService from '../services/notion-service.js';
@@ -587,6 +588,9 @@ app.post('/', migrationGuard, async (c) => {
                 brainstormPrompt += `- get_notion_ticket() — retrieve the Notion ticket info (URL, ticket ID, extracted content)\n`;
             }
             brainstormPrompt += `- kobo__set_workspace_agent_description(description) — keep the workspace's agent_description up to date as a short one-line summary of what you're currently doing or have just accomplished. The user sees this in the sidebar without opening the workspace. Update it whenever your focus shifts (e.g. "Investigating SERVICE-1600 → enriching local Notion file", then "Writing failing test for FacturX validator"). Plain text, max 200 chars. The current value is in kobo__get_workspace_info.\nThere is also a separate user-controlled \`description\` field on the workspace — DO NOT touch it. Only set_workspace_agent_description is yours to write; the user owns the other one.\n`;
+            brainstormPrompt += `- kobo__cron_create(expression, prompt, label?, mode?, oneShot?) — schedule a (recurring or one-shot) trigger on THIS workspace. At each fire Kōbō waits for the workspace to be idle and then injects \`prompt\` as the next user message. \`expression\` is a standard 5-field cron (\`min hour dom month dow\`) or a helper (\`@hourly\`, \`@daily\`, \`@weekly\`, \`@monthly\`, \`@yearly\`). Examples: \`*/30 * * * *\` = every 30 min; \`0 9 * * 1\` = every Monday at 9am; \`0 14 7 6 *\` = 7 June at 14:00. \`mode\` is \`'resume'\` (default — every fire continues the SAME conversation that scheduled the cron, so you can chain follow-ups) or \`'fresh'\` (every fire starts a brand-new session with a clean context, ideal for periodic checks like CI watch). \`oneShot\` (default false): when true, the cron cancels itself after the first real fire — use this to trigger once at a specific time without recurring. Skip-if-active: occurrences fired while a session is running are skipped, the next is computed, and the cron continues. Persists across restarts. Returns a cron \`id\`.\n`;
+            brainstormPrompt += `- kobo__cron_delete(id) — cancel a previously-armed cron by id (idempotent).\n`;
+            brainstormPrompt += `- kobo__cron_list() — list every cron currently armed on THIS workspace, with their next/last fire times.\n`;
             if (effectiveSettings.gitConventions) {
                 brainstormPrompt += `\n# Git conventions\nIMPORTANT: Before any git operation (commit, branch, rebase, merge, push), read and apply the conventions defined in \`.ai/.git-conventions.md\`. They are project-specific and override any default behavior. Re-read this file if you're unsure or if context was compacted.\n`;
             }
@@ -720,7 +724,8 @@ app.get('/auto-loop-states', (c) => {
         const rows = db
             .prepare(`SELECT w.id, w.auto_loop, w.auto_loop_ready, w.no_progress_streak,
                 COUNT(t.id) AS tasks_total,
-                SUM(CASE WHEN t.status = 'done' THEN 1 ELSE 0 END) AS tasks_done
+                SUM(CASE WHEN t.status = 'done' THEN 1 ELSE 0 END) AS tasks_done,
+                (SELECT COUNT(*) FROM pending_crons p WHERE p.workspace_id = w.id) AS crons_count
          FROM workspaces w
          LEFT JOIN tasks t ON t.workspace_id = w.id
          WHERE w.archived_at IS NULL
@@ -734,6 +739,7 @@ app.get('/auto-loop-states', (c) => {
                 no_progress_streak: r.no_progress_streak,
                 tasks_done: r.tasks_done ?? 0,
                 tasks_total: r.tasks_total ?? 0,
+                crons_count: r.crons_count ?? 0,
             };
         }
         return c.json(out);
@@ -795,6 +801,85 @@ app.post('/:id/auto-loop-ready', (c) => {
         return c.json({ error: message }, 500);
     }
 });
+// GET /api/workspaces/:id/crons — list pending crons for a workspace.
+app.get('/:id/crons', (c) => {
+    try {
+        const id = c.req.param('id');
+        const workspace = workspaceService.getWorkspace(id);
+        if (!workspace)
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        return c.json({ crons: cronService.listForWorkspace(id) });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
+// POST /api/workspaces/:id/crons — arm a new cron. Validates the expression
+// in the service layer; invalid expressions surface as a 400.
+app.post('/:id/crons', async (c) => {
+    try {
+        const id = c.req.param('id');
+        const workspace = workspaceService.getWorkspace(id);
+        if (!workspace)
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        const body = (await c.req.json().catch(() => ({})));
+        const expression = typeof body.expression === 'string' ? body.expression : '';
+        const prompt = typeof body.prompt === 'string' ? body.prompt : '';
+        const label = typeof body.label === 'string' ? body.label : undefined;
+        const rawMode = typeof body.mode === 'string' ? body.mode : 'resume';
+        if (rawMode !== 'resume' && rawMode !== 'fresh') {
+            return c.json({ error: "mode must be 'resume' or 'fresh'" }, 400);
+        }
+        const mode = rawMode;
+        const oneShot = body.oneShot === true;
+        if (!expression || !prompt) {
+            return c.json({ error: 'expression and prompt are required' }, 400);
+        }
+        try {
+            // Mode controls how each fire is handled:
+            //   - 'resume' (default): pin the cron to the session that scheduled it,
+            //     so each fire resumes THAT conversation. Same pattern as wakeup.
+            //   - 'fresh': don't pin a session — every fire spawns a new session
+            //     with a clean context. Useful for periodic checks (e.g. CI watch)
+            //     that don't need conversation continuity.
+            // oneShot=true cancels the cron after the first real fire (skip-active
+            // ticks don't consume the one-shot — the cron retries at the next
+            // occurrence until it actually fires once).
+            // The DB encodes mode via `agent_session_id`: non-NULL = resume that
+            // session; NULL = fresh. When mode='resume' but no session is active
+            // at create time, fall back to NULL — fire will spawn fresh.
+            const agentSessionId = mode === 'resume' ? (agentManager.getActiveSessionId(id) ?? undefined) : undefined;
+            const cron = cronService.arm(id, { expression, prompt, label, agentSessionId, oneShot });
+            return c.json({ cron }, 201);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return c.json({ error: message }, 400);
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
+// DELETE /api/workspaces/:id/crons/:cronId — cancel a single cron. Idempotent:
+// returns 204 even when the cron does not exist (matches pending-wakeup style).
+app.delete('/:id/crons/:cronId', (c) => {
+    try {
+        const id = c.req.param('id');
+        const cronId = c.req.param('cronId');
+        const workspace = workspaceService.getWorkspace(id);
+        if (!workspace)
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        cronService.cancel(cronId, 'user');
+        return new Response(null, { status: 204 });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
 // GET /api/workspaces/:id/pending-wakeup — returns the pending wakeup or null.
 app.get('/:id/pending-wakeup', (c) => {
     try {
@@ -1122,6 +1207,22 @@ app.post('/:id/agent-description/notify-updated', (c) => {
         return c.json({ error: message }, 500);
     }
 });
+// POST /api/workspaces/:id/crons/notify-updated — broadcast cron list changed
+// after the MCP cron_create / cron_delete handlers wrote directly to DB.
+app.post('/:id/crons/notify-updated', (c) => {
+    try {
+        const id = c.req.param('id');
+        const workspace = workspaceService.getWorkspace(id);
+        if (!workspace)
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        wsService.emitEphemeral(id, 'cron:updated', { crons: cronService.listForWorkspace(id) });
+        return new Response(null, { status: 204 });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
 // POST /api/workspaces/:id/tasks/:taskId/notify-done — broadcast task:updated event
 app.post('/:id/tasks/:taskId/notify-done', (c) => {
     try {

package/dist/server/services/agent/engines/claude-code/engine.js

@@ -1,7 +1,7 @@
 import { query, } from '@anthropic-ai/claude-agent-sdk';
 import { nanoid } from 'nanoid';
 import { CLAUDE_CODE_CAPABILITIES } from './capabilities.js';
-import { createMapperState, mapSdkMessage } from './event-mapper.js';
+import { createMapperState, mapSdkMessage, QUOTA_PATTERN, tryEmitQuota } from './event-mapper.js';
 import { buildClaudeOptions } from './options-builder.js';
 import { buildPreCompactCustomInstructions } from './precompact-hook.js';
 import { resolveClaudeBinaryPath } from './resolve-binary.js';
@@ -97,15 +97,19 @@ export function createClaudeCodeEngine() {
                 hooks,
                 canUseTool,
                 stderr: (data) => {
+                    // QUOTA_PATTERN covers the canonical surfaces (rate_limit,
+                    // out of extra usage, usage limit, quota exceeded). The 429+rate
+                    // combo is a CLI-only HTTP-level surface that the SDK never emits
+                    // structurally, so it stays as a separate guard alongside.
                     const lower = data.toLowerCase();
-                    if (lower.includes('rate limit exceeded') ||
-                        lower.includes('rate_limit_exceeded') ||
-                        (lower.includes('429') && lower.includes('rate')) ||
-                        lower.includes('quota exceeded') ||
-                        lower.includes('out of extra usage') ||
-                        // "Claude AI usage limit reached" — Anthropic's 5h/4h cap message
-                        lower.includes('usage limit')) {
-                        onEvent({ kind: 'error', category: 'quota', message: data });
+                    const isQuota = QUOTA_PATTERN.test(data) || (lower.includes('429') && lower.includes('rate'));
+                    if (isQuota) {
+                        // Share `mapperState.quotaErrorEmitted` with the SDK iterator so
+                        // a single run that surfaces quota via BOTH stderr AND a
+                        // structured SDK signal (assistant.error / rate_limit_event)
+                        // does not double-fire `handleQuota` (which would double the
+                        // retryCount and overwrite the persisted backoff row).
+                        tryEmitQuota(mapperState, onEvent, data);
                     }
                     else if (lower.includes('no conversation found with session id')) {
                         onEvent({ kind: 'error', category: 'resume_failed', message: data });

package/dist/server/services/agent/engines/claude-code/event-mapper.js

@@ -29,6 +29,14 @@ function makeBucket(id, source) {
     const details = used !== undefined && limit !== undefined ? `${String(used)} / ${String(limit)}` : undefined;
     return { id, label, usedPct: Math.max(0, Math.min(100, usedPct)), resetsAt, details };
 }
+const RATE_LIMIT_STATUSES = new Set(['allowed', 'allowed_warning', 'rejected']);
+function extractStatus(info) {
+    const raw = info.status;
+    if (typeof raw === 'string' && RATE_LIMIT_STATUSES.has(raw)) {
+        return raw;
+    }
+    return undefined;
+}
 function normalizeRateLimitInfo(info) {
     const buckets = [];
     if (typeof info.rateLimitType === 'string') {
@@ -50,10 +58,32 @@ function normalizeRateLimitInfo(info) {
                 buckets.push(b);
         }
     }
-    return { buckets };
+    const status = extractStatus(info);
+    return status ? { buckets, status } : { buckets };
 }
+// ── Public API ────────────────────────────────────────────────────────────────
+/**
+ * Canonical "out of quota" surfaces from the Claude SDK and CLI. Centralised
+ * so the three call-sites stay in sync:
+ *  - `result` events with an error subtype (`parsed.error` / `parsed.result`)
+ *  - assistant `message:text` blocks (the SDK occasionally streams the user-
+ *    visible quota notice as plain assistant text instead of a structured
+ *    error result; see workspace `-GyiAYM7X4xTWyZbcHGiR` session #25 for the
+ *    repro that motivated this path)
+ *  - CLI stderr in `engine.ts`
+ *
+ * Patterns are kept loose on purpose to absorb minor wording drift between
+ * Anthropic's surfaces (`rate_limit_exceeded`, `Claude AI usage limit
+ * reached`, `You're out of extra usage`, `quota exceeded`).
+ */
+export const QUOTA_PATTERN = /out of extra usage|rate[_ ]limit|usage limit|quota exceeded/i;
 export function createMapperState() {
-    return { sessionStartedEmitted: false, openMessages: new Map(), sawErrorResult: false };
+    return {
+        sessionStartedEmitted: false,
+        openMessages: new Map(),
+        sawErrorResult: false,
+        quotaErrorEmitted: false,
+    };
 }
 /** Known SDK `result` subtypes that indicate the run failed. */
 export const KNOWN_ERROR_RESULT_SUBTYPES = new Set(['error_max_turns', 'error_during_execution']);
@@ -64,6 +94,36 @@ function isErrorResultSubtype(subtype) {
         return true;
     return subtype.startsWith('error');
 }
+/**
+ * SDK error codes (`SDKAssistantMessageError`) that map to a quota exhaustion
+ * — the user has hit the 5h/7d cap or run out of overage credits.
+ *  - `'rate_limit'`: classic 429 / Anthropic rate-limit reached
+ *  - `'billing_error'`: claude.ai overage credits exhausted
+ */
+export const QUOTA_ASSISTANT_ERRORS = new Set(['rate_limit', 'billing_error']);
+/**
+ * Emit an `error/quota` event exactly once per SDK run, regardless of which
+ * surface detected the quota (stderr, SDK iterator, message:text fallback…).
+ * Also sets `sawErrorResult` so the engine surfaces
+ * `session:ended.reason='error'`, which the orchestrator then maps to a
+ * `quota` status transition via the `category: 'quota'` discriminator.
+ *
+ * Exported so the stderr path in `engine.ts` (which bypasses `mapSdkMessage`)
+ * can share the same one-shot guard. Without this, two quota surfaces in the
+ * same run would call `handleQuota` twice → `retryCount` doubled and the
+ * persisted backoff row overwritten.
+ */
+export function tryEmitQuota(state, emit, message) {
+    if (state.quotaErrorEmitted)
+        return;
+    state.quotaErrorEmitted = true;
+    state.sawErrorResult = true;
+    emit({ kind: 'error', category: 'quota', message });
+}
+/** Internal wrapper for the in-mapper push pattern. */
+function tryEmitQuotaError(state, events, message) {
+    tryEmitQuota(state, (ev) => events.push(ev), message);
+}
 /**
  * Maps a single typed `SDKMessage` to zero or more `AgentEvent`s, mutating
  * `state` as needed.
@@ -80,7 +140,13 @@ export function mapSdkMessage(msg, state) {
     if (type === 'rate_limit_event') {
         const info = parsed.rate_limit_info;
         if (info && typeof info === 'object') {
-            events.push({ kind: 'rate_limit', info: normalizeRateLimitInfo(info) });
+            const normalized = normalizeRateLimitInfo(info);
+            events.push({ kind: 'rate_limit', info: normalized });
+            // `status: 'rejected'` from the SDK is the explicit "request blocked,
+            // out of quota" signal — the most reliable structured surface.
+            if (normalized.status === 'rejected') {
+                tryEmitQuotaError(state, events, 'Rate limit rejected by Claude SDK (rate_limit_event)');
+            }
         }
         return events;
     }
@@ -129,6 +195,14 @@ export function mapSdkMessage(msg, state) {
         return events;
     }
     if (type === 'assistant') {
+        // `SDKAssistantMessage.error` is a typed enum that includes 'rate_limit'
+        // and 'billing_error' — explicit, structured quota signals. Surface them
+        // before any text processing so the orchestrator transitions to `quota`
+        // even on otherwise empty assistant turns.
+        const assistantError = typeof parsed.error === 'string' ? parsed.error : undefined;
+        if (assistantError && QUOTA_ASSISTANT_ERRORS.has(assistantError)) {
+            tryEmitQuotaError(state, events, `Assistant message error: ${assistantError}`);
+        }
         const message = parsed.message;
         const messageId = typeof message?.id === 'string' ? message.id : 'unknown';
         const content = Array.isArray(message?.content) ? message?.content : [];
@@ -149,11 +223,19 @@ export function mapSdkMessage(msg, state) {
         for (const block of content) {
             const blockType = block.type;
             if (blockType === 'text' && typeof block.text === 'string') {
-                events.push({ kind: 'message:text', messageId, text: block.text, streaming: true });
+                const text = block.text;
+                events.push({ kind: 'message:text', messageId, text, streaming: true });
                 msgState.sawText = true;
-                if (block.text.includes('[BRAINSTORM_COMPLETE]')) {
+                if (text.includes('[BRAINSTORM_COMPLETE]')) {
                     events.push({ kind: 'session:brainstorm-complete' });
                 }
+                // Last-resort fallback: some SDK runs surface the quota notice as
+                // plain assistant text without setting `assistant.error` or a
+                // `result.error`. The structured signals above cover modern SDK
+                // versions; this regex absorbs older or drifted wordings.
+                if (QUOTA_PATTERN.test(text)) {
+                    tryEmitQuotaError(state, events, text);
+                }
             }
             if (blockType === 'tool_use') {
                 events.push({
@@ -211,12 +293,15 @@ export function mapSdkMessage(msg, state) {
         if (isErrorResultSubtype(subtype)) {
             state.sawErrorResult = true;
             const detail = (typeof parsed.error === 'string' && parsed.error) || (typeof parsed.result === 'string' && parsed.result) || '';
-            // "Claude AI usage limit reached" is Anthropic's 5h/4h cap surface — added
-            // to the regex so the orchestrator transitions the workspace to `quota`
-            // (not `error`) and the auto-loop backoff path engages.
-            const isQuota = /out of extra usage|rate limit|usage limit/i.test(detail);
+            const isQuota = QUOTA_PATTERN.test(detail);
             const message = detail ? `Agent run failed (${subtype}): ${detail}` : `Agent run failed (${subtype})`;
-            events.push({ kind: 'error', category: isQuota ? 'quota' : 'other', message });
+            if (isQuota) {
+                // Coordinate with the structured quota path so we never emit twice.
+                tryEmitQuotaError(state, events, message);
+            }
+            else {
+                events.push({ kind: 'error', category: 'other', message });
+            }
         }
         const usage = parsed.usage;
         if (usage) {

package/dist/server/services/agent/orchestrator.js

@@ -4,6 +4,7 @@ import { getDb } from '../../db/index.js';
 import { ensureKoboHome, getCompiledMcpServerPath, getDbPath, getKoboHome, getMcpServerSourcePath, getSettingsPath, getSkillsPath, } from '../../utils/paths.js';
 import { unregisterProcess } from '../../utils/process-tracker.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 { getEffectiveSettings } from '../settings-service.js';
 import { refreshNow } from '../usage/poller.js';
@@ -447,6 +448,46 @@ function handleEvent(workspaceId, agentSessionId, ev) {
             wakeupService.schedule(workspaceId, delay, prompt, reason, agentSessionId);
         }
     }
+    // Same legacy bridge for the SDK's native `CronCreate`. The native tool is
+    // session-only (the cron dies when the agent session exits and is not
+    // persisted to disk), which makes it useless for any real "schedule a
+    // recurring trigger" need. We intercept the tool:call and arm an equivalent
+    // kobo cron in parallel — persistent across restarts, owned by the backend.
+    if (ev.kind === 'tool:call' && ev.name === 'CronCreate') {
+        const input = ev.input;
+        const prompt = typeof input?.prompt === 'string' ? input.prompt : '';
+        // The SDK's exact field name has drifted across versions — try the most
+        // likely candidates. If none match we log the input shape so the user
+        // can extend this list.
+        const expression = (typeof input?.cron === 'string' && input.cron) ||
+            (typeof input?.schedule === 'string' && input.schedule) ||
+            (typeof input?.expression === 'string' && input.expression) ||
+            '';
+        if (prompt && expression) {
+            console.warn(`[orchestrator] Native CronCreate intercepted for workspace '${workspaceId}' — armed equivalent kobo cron. Prefer kobo__cron_create.`);
+            try {
+                cronService.arm(workspaceId, {
+                    expression,
+                    prompt,
+                    label: 'from-native-CronCreate',
+                    agentSessionId,
+                });
+            }
+            catch (err) {
+                console.error('[orchestrator] Failed to mirror native CronCreate as kobo cron:', err);
+            }
+        }
+        else if (prompt || input) {
+            console.warn(`[orchestrator] Native CronCreate intercepted but unrecognised input shape (workspace '${workspaceId}'):`, Object.keys(input ?? {}));
+        }
+    }
+    // Native `CronDelete` and `CronList` are noisy but harmless to ignore.
+    // The native cron is session-only so deletion is moot once the session
+    // ends; the kobo equivalents (kobo__cron_delete / kobo__cron_list) are
+    // the persistent path. Log to track usage and avoid silent confusion.
+    if (ev.kind === 'tool:call' && (ev.name === 'CronDelete' || ev.name === 'CronList')) {
+        console.warn(`[orchestrator] Native ${ev.name} called on workspace '${workspaceId}' — has no effect on kobo crons. Use kobo__${ev.name === 'CronDelete' ? 'cron_delete' : 'cron_list'} instead.`);
+    }
     if (ev.kind === 'skills:discovered') {
         availableSkills = ev.skills;
         try {

package/dist/server/services/auto-loop-service.js

@@ -54,12 +54,17 @@ export function enable(workspaceId) {
     if (row.auto_loop_ready !== 1) {
         throw new Error(`Workspace '${workspaceId}' is not ready for auto-loop (run grooming first)`);
     }
+    // Refuse to enable when there is nothing to spawn — without this, auto_loop
+    // would flip to 1 silently with no iteration running, locking the chat input
+    // (auto-loop banner) without doing any work. The user must add a task or
+    // unmark a done task before re-enabling.
+    const pending = countPendingTasks(workspaceId);
+    if (pending === 0) {
+        throw new Error(`Workspace '${workspaceId}' has no pending tasks; add or unmark a task before enabling auto-loop`);
+    }
     const db = getDb();
     db.prepare('UPDATE workspaces SET auto_loop = 1, no_progress_streak = 0 WHERE id = ?').run(workspaceId);
     emitEphemeral(workspaceId, 'autoloop:enabled', {});
-    const pending = countPendingTasks(workspaceId);
-    if (pending === 0)
-        return;
     if (orchestrator.hasController(workspaceId))
         return;
     // spawnNextIteration throws on initial spawn failure (see flag).