@loicngr/kobo 1.7.4 → 1.7.6

package/dist/server/routes/workspaces.js

@@ -10,11 +10,13 @@ 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';
 import { renderPrTemplate } from '../services/pr-template-service.js';
 import { getAllPrStates } from '../services/pr-watcher-service.js';
+import * as quotaBackoffService from '../services/quota-backoff-service.js';
 import { DEFAULT_REVIEW_PROMPT_TEMPLATE, renderReviewTemplate } from '../services/review-template-service.js';
 import * as sentryService from '../services/sentry-service.js';
 import * as settingsService from '../services/settings-service.js';
@@ -585,6 +587,10 @@ app.post('/', migrationGuard, async (c) => {
             if (body.notionUrl) {
                 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`;
             }
@@ -713,8 +719,17 @@ app.get('/pr-states', (c) => {
 app.get('/auto-loop-states', (c) => {
     try {
         const db = getDb();
+        // Task counts via LEFT JOIN so workspaces without tasks still appear with 0/0.
+        // Drives the sidebar AutoLoopChip badge (X / Y) for non-focused workspaces.
         const rows = db
-            .prepare('SELECT id, auto_loop, auto_loop_ready, no_progress_streak FROM workspaces WHERE archived_at IS NULL')
+            .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,
+                (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
+         GROUP BY w.id`)
             .all();
         const out = {};
         for (const r of rows) {
@@ -722,6 +737,9 @@ app.get('/auto-loop-states', (c) => {
                 auto_loop: r.auto_loop === 1,
                 auto_loop_ready: r.auto_loop_ready === 1,
                 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);
@@ -783,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 {
@@ -808,6 +905,37 @@ app.delete('/:id/pending-wakeup', (c) => {
         return c.json({ error: message }, 500);
     }
 });
+// GET /api/workspaces/:id/quota-backoff — returns the pending quota backoff or null.
+app.get('/:id/quota-backoff', (c) => {
+    try {
+        const id = c.req.param('id');
+        const ws = workspaceService.getWorkspace(id);
+        if (!ws)
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        const pending = quotaBackoffService.getPending(id);
+        c.header('Cache-Control', 'no-store');
+        return c.json(pending);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
+// DELETE /api/workspaces/:id/quota-backoff — user-initiated cancel ("×" button).
+app.delete('/:id/quota-backoff', (c) => {
+    try {
+        const id = c.req.param('id');
+        const ws = workspaceService.getWorkspace(id);
+        if (!ws)
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        quotaBackoffService.cancel(id, 'user');
+        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/pending-wakeup — agent-initiated schedule via the
 // `kobo__schedule_wakeup` MCP tool. Replaces any existing pending wakeup.
 app.post('/:id/pending-wakeup', async (c) => {
@@ -1057,6 +1185,44 @@ app.post('/:id/tasks/notify-updated', (c) => {
         return c.json({ error: message }, 500);
     }
 });
+// POST /api/workspaces/:id/agent-description/notify-updated — broadcast
+// workspace:agent-description-updated after the MCP set_workspace_agent_description
+// handler wrote the column directly. Mirrors the notify-done / notify-updated
+// pattern: the route doesn't re-write, just emits the WS event so the sidebar
+// chip + workspace header italic line refresh in real time.
+app.post('/:id/agent-description/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, 'workspace:agent-description-updated', {
+            agentDescription: workspace.agentDescription,
+        });
+        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/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 {
@@ -1270,6 +1436,10 @@ app.patch('/:id', migrationGuard, async (c) => {
         if (!workspace) {
             return c.json({ error: `Workspace '${id}' not found` }, 404);
         }
+        // agent_description is exclusively writable via the MCP tool, never via the API.
+        if ('agent_description' in body) {
+            return c.json({ error: 'agent_description must be set via the agent MCP tool, not via the API' }, 400);
+        }
         let updated = workspace;
         if (body.model !== undefined) {
             updated = workspaceService.updateWorkspaceModel(id, body.model);
@@ -1289,12 +1459,20 @@ app.patch('/:id', migrationGuard, async (c) => {
         if (body.name !== undefined) {
             updated = workspaceService.updateWorkspaceName(id, body.name);
         }
+        if ('description' in body) {
+            const desc = body.description;
+            if (desc !== null && typeof desc !== 'string') {
+                return c.json({ error: 'description must be a string or null' }, 400);
+            }
+            updated = workspaceService.updateWorkspaceDescription(id, desc);
+        }
         if (!body.status &&
             body.model === undefined &&
             body.reasoningEffort === undefined &&
             body.agentPermissionMode === undefined &&
-            body.name === undefined) {
-            return c.json({ error: 'Missing field: status, model, reasoningEffort, agentPermissionMode, or name' }, 400);
+            body.name === undefined &&
+            !('description' in body)) {
+            return c.json({ error: 'Missing field: status, model, reasoningEffort, agentPermissionMode, name, or description' }, 400);
         }
         return c.json(updated);
     }
@@ -1305,7 +1483,8 @@ app.patch('/:id', migrationGuard, async (c) => {
         }
         if (message.includes('Invalid status transition') ||
             message.includes('name cannot be empty') ||
-            message.includes('name cannot exceed')) {
+            message.includes('name cannot exceed') ||
+            message.includes('Description must be')) {
             return c.json({ error: message }, 400);
         }
         return c.json({ error: message }, 500);

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,12 +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')) {
-                        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,13 +58,35 @@ 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. */
-const KNOWN_ERROR_RESULT_SUBTYPES = new Set(['error_max_turns', 'error_during_execution']);
+export const KNOWN_ERROR_RESULT_SUBTYPES = new Set(['error_max_turns', 'error_during_execution']);
 function isErrorResultSubtype(subtype) {
     if (!subtype)
         return false;
@@ -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,8 +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) || '';
+            const isQuota = QUOTA_PATTERN.test(detail);
             const message = detail ? `Agent run failed (${subtype}): ${detail}` : `Agent run failed (${subtype})`;
-            events.push({ kind: 'error', category: '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) {