@loicngr/kobo 1.7.5 → 1.7.6

package/README.md

@@ -35,7 +35,9 @@ Think of it as an apprentice's hall: you hand out missions, each apprentice sets
 - **Attach existing worktrees** — Kōbō detects orphan git worktrees for the selected project (created outside Kōbō, or left over from an earlier install) and lets you attach them to a new workspace from the creation form, picking up the existing branch and folder instead of cloning a new one
 - **Persistent quota backoff** — when a Claude rate limit is hit mid-session, Kōbō schedules the retry at the actual reset time reported by the API (via `rate_limit.info.buckets[].resetsAt`), falling back to the OAuth usage poller, then to a 15 → 30 → 60 → 180 → 300 min ladder when both are missing. The pending backoff is **persisted in SQLite** and re-armed on server restart, so nothing is lost if the host reboots mid-window. A live banner counts down to the reset and lets the user cancel the wait. Only auto-loop workspaces resume automatically — others stay in `quota` status awaiting a manual nudge
 - **Workspace description fields** — every workspace has TWO independent description fields. The user-side `description` is editable via the header input or right-click **Modifier la description**, and stays under the user's control (the agent cannot overwrite it). The agent maintains its own `agent_description` via the `set_workspace_agent_description` MCP tool to broadcast a live status (e.g. "Investigating SERVICE-1600 → enriching local Notion file"). Both are visible: the sidebar shows `agent_description` when set, falling back to the user `description`; the workspace header shows the user input plus an italic read-only line for the agent's current focus
-- **Scheduled wakeups** — the `ScheduleWakeup` tool is honoured server-side: Kōbō persists the wakeup in SQLite, rehydrates on restart, and respawns the agent with `--resume` at the target time
+- **Scheduled wakeups** — the `ScheduleWakeup` tool is honoured server-side: Kōbō persists the wakeup in SQLite, rehydrates on restart, and respawns the agent with `--resume` at the target time. Delay is clamped to `[60s, 6h]`. The kobo-tasks MCP server also exposes `kobo__schedule_wakeup` / `kobo__cancel_wakeup` for the same flow with first-class tool descriptors
+- **Recurring & one-shot crons** — agents schedule recurring triggers via `kobo__cron_create(expression, prompt, label?, mode?, oneShot?)`. Standard 5-field cron expressions (`*/30 * * * *`) plus helpers (`@hourly`, `@daily`, `@weekly`, `@monthly`, `@yearly`). Two modes: `'resume'` (default) pins the cron to the session that scheduled it so each fire continues that conversation; `'fresh'` spawns a brand-new session per fire (clean context, ideal for periodic CI / dashboard checks). `oneShot: true` cancels the cron after the first real fire — useful for "trigger once at a specific date/time" without recurring. Crons are persisted in SQLite, re-armed on restart with skip-missed semantics (no catchup spam after downtime), and skip-if-active when a session is already running. Multiple crons per workspace. The native Claude Code `CronCreate` tool is also intercepted and mirrored as a kobo cron so even agents using the SDK-default tool benefit from persistence
+- **Schedule panel in the right drawer** — dedicated tab listing every wakeup and cron currently armed for the focused workspace, with their next/last fire times, prompt preview, and a `×` button to cancel inline. Sidebar workspace cards display an `event_repeat` icon when one or more crons are scheduled, even for workspaces not currently focused — broadcast live via WebSocket events
 
 ## Tech stack
 
@@ -231,6 +233,8 @@ src/
 │   │   ├── content-migration-service.ts    # legacy ws_events → normalised AgentEvent rows, with DB backup
 │   │   ├── usage/                          # pluggable quota provider, 60s poller, persistence, WS broadcast
 │   │   ├── quota-backoff-service.ts        # persisted Claude rate-limit backoff timers (re-armed on restart)
+│   │   ├── cron-service.ts                 # persisted cron schedules (recurring + one-shot, resume/fresh modes)
+│   │   ├── wakeup-service.ts               # persisted one-shot session resumes (clamped to [60s, 6h])
 │   │   └── …                               # workspace, dev-server, ws, notion, sentry, settings, pr-template
 │   ├── routes/                             # Hono handlers (workspaces, engines, migration, templates, usage, …)
 │   └── utils/                              # git-ops, process-tracker, paths
@@ -261,6 +265,7 @@ See [`AGENTS.md`](./AGENTS.md) for a deeper dive into conventions, data model, W
 | `usage_snapshots` | latest quota snapshot per provider (one row per `provider_id`) — populated by the 60s polling loop, used for cold-start hydration of the chat-footer quota badge |
 | `pending_wakeups` | one row per scheduled wakeup, target time and resume context, re-armed on server restart |
 | `pending_quota_backoffs` | one row per workspace currently waiting on a Claude rate-limit reset, target time + reset metadata + retry count, re-armed on server restart |
+| `pending_crons` | one row per scheduled cron — expression, prompt, label, optional pinned `agent_session_id` (= resume mode) or NULL (= fresh mode), `next_fire_at`, `last_fired_at`, `one_shot` flag, re-armed on server restart with skip-missed semantics |
 
 ## MCP server
 
@@ -273,9 +278,9 @@ Each workspace spawns its own `kobo-tasks` MCP server as a child process of the
 - **Dev server** — `get_dev_server_status`, `start_dev_server`, `stop_dev_server`, `get_dev_server_logs`
 - **External sources** — `get_notion_ticket`, `get_settings`
 - **Documents & search** — `list_documents`, `read_document`, `log_thought`, `search_codebase`, `list_workspace_images`
-- **Scheduling & telemetry** — `schedule_wakeup`, `cancel_wakeup`, `get_session_usage`
+- **Scheduling & telemetry** — `schedule_wakeup`, `cancel_wakeup`, `cron_create`, `cron_delete`, `cron_list`, `get_session_usage`
 
-State-mutating tools that change UI-visible data (tasks, agent description, auto-loop readiness) write directly to SQLite for low latency, then fire-and-forget a `notify-*` HTTP call to the backend so the WebSocket layer broadcasts the change to every connected client.
+State-mutating tools that change UI-visible data (tasks, agent description, auto-loop readiness) write directly to SQLite for low latency, then fire-and-forget a `notify-*` HTTP call to the backend so the WebSocket layer broadcasts the change to every connected client. Tools that arm in-memory timers (`cron_create`, `cron_delete`) route through the backend HTTP API instead — the timer Map lives in the backend process which owns the orchestrator, so the cron survives the MCP server's session-bound lifetime.
 
 The MCP server reads and writes the same SQLite database as the main backend. Isolation between workspaces is enforced via the `KOBO_WORKSPACE_ID` environment variable passed at spawn time and validated on every query.
 

package/dist/mcp-server/kobo-tasks-handlers.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { nanoid } from 'nanoid';
+import * as cronService from '../server/services/cron-service.js';
 import * as settingsService from '../server/services/settings-service.js';
 import { slugifyProjectName } from '../server/utils/project-slug.js';
 import { resolveWorkspaceWorktreePath } from '../server/utils/worktree-paths.js';
@@ -379,3 +380,17 @@ export function getSessionUsageHandler(db, workspaceId) {
         currentSession: { sessionId: currentSessionId, ...current },
     };
 }
+// ── Crons ────────────────────────────────────────────────────────────────────
+/**
+ * List every cron currently armed for a workspace.
+ *
+ * Note: cron_create and cron_delete are NOT exposed as handlers — they route
+ * through the backend HTTP API (`POST/DELETE /api/workspaces/:id/crons`)
+ * because their `setTimeout` must live in the backend process (which owns
+ * the orchestrator). Handlers here would arm timers in the MCP sub-process,
+ * which dies with the agent session, and fires would never reach a real
+ * session resume. The list handler is a pure read so it's safe to keep local.
+ */
+export function cronListHandler(_db, workspaceId) {
+    return { ok: true, crons: cronService.listForWorkspace(workspaceId) };
+}

package/dist/mcp-server/kobo-tasks-server.js

@@ -4,8 +4,9 @@ import path from 'node:path';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import Database from 'better-sqlite3';
-import { createTaskHandler, deleteTaskHandler, getDevServerStatusHandler, getSessionUsageHandler, getSettingsHandler, getWorkspaceInfoHandler, listDocumentsHandler, listTasksHandler, listWorkspaceImagesHandler, logThoughtHandler, markAutoLoopReadyHandler, markTaskDoneHandler, readDocumentHandler, setWorkspaceAgentDescriptionHandler, updateTaskHandler, } from './kobo-tasks-handlers.js';
+import { getDb } from '../server/db/index.js';
+import { runMigrations } from '../server/db/migrations.js';
+import { createTaskHandler, cronListHandler, deleteTaskHandler, getDevServerStatusHandler, getSessionUsageHandler, getSettingsHandler, getWorkspaceInfoHandler, listDocumentsHandler, listTasksHandler, listWorkspaceImagesHandler, logThoughtHandler, markAutoLoopReadyHandler, markTaskDoneHandler, readDocumentHandler, setWorkspaceAgentDescriptionHandler, updateTaskHandler, } from './kobo-tasks-handlers.js';
 const workspaceId = process.env.KOBO_WORKSPACE_ID;
 const dbPath = process.env.KOBO_DB_PATH;
 const settingsPath = process.env.KOBO_SETTINGS_PATH;
@@ -20,10 +21,21 @@ if (!dbPath) {
 }
 let db;
 try {
-    db = new Database(dbPath, { readonly: false });
-    db.pragma('journal_mode = WAL');
-    db.pragma('busy_timeout = 5000');
-    db.pragma('foreign_keys = ON');
+    // Use the shared `getDb` singleton so any service that calls `getDb()`
+    // internally (e.g. cron-service.arm) hits the SAME connection as this
+    // MCP server, against the SAME DB file. Without this bootstrap, the
+    // singleton would resolve via getDbPath() → getKoboHome() → KOBO_HOME
+    // env var, which the agent SDK does NOT pass to the MCP server (only
+    // KOBO_DB_PATH is passed). That would silently open a second connection
+    // against the user's prod DB at ~/.config/kobo/kobo.db, which may not
+    // even have the same schema as the dev DB the backend is using.
+    db = getDb(dbPath);
+    // Defensive: run migrations to ensure the schema is at the latest version.
+    // The backend already ran them at boot, but this MCP server might be the
+    // first to touch the DB (e.g. tests, race at first boot, or KOBO_DB_PATH
+    // pointing somewhere the backend hasn't migrated). Idempotent — no-op if
+    // the DB is already at SCHEMA_VERSION.
+    runMigrations(db);
 }
 catch (err) {
     console.error('[kobo-tasks-server] Failed to open database:', err);
@@ -190,6 +202,53 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: ['description'],
             },
         },
+        {
+            name: 'cron_create',
+            description: 'Schedule a recurring trigger on THIS workspace. At each fire, Kōbō waits for the workspace to be idle (no active session) and then resumes the same conversation by injecting `prompt` as the next user message — same UX as `schedule_wakeup` but recurring. Skip-if-active: if a session is already running when the timer fires, that occurrence is skipped, the next occurrence is computed, and the cron continues. The cron persists across server restarts (skip-missed semantics on boot — no catchup spam). Delete with `cron_delete(id)`. Multiple crons per workspace are allowed.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    expression: {
+                        type: 'string',
+                        description: 'Standard 5-field cron expression (`min hour dom month dow`) or one of the helpers `@hourly`, `@daily`, `@weekly`, `@monthly`, `@yearly`. Example: `*/30 * * * *` = every 30 minutes; `0 9 * * 1` = every Monday at 9am. Validated at create time.',
+                    },
+                    prompt: {
+                        type: 'string',
+                        description: 'The prompt to inject as the next user message at each fire.',
+                    },
+                    label: {
+                        type: 'string',
+                        description: 'Optional human-readable label for the cron (shown in the UI).',
+                    },
+                    mode: {
+                        type: 'string',
+                        enum: ['resume', 'fresh'],
+                        description: "How each fire is handled. 'resume' (default) pins the cron to the session you're calling from, so every fire continues THAT conversation by injecting `prompt` as the next user message — use this when the cron should follow up on ongoing work. 'fresh' starts a brand-new session at every fire with a clean context — use this for periodic checks (e.g. CI watch, daily standup) that don't need conversation continuity.",
+                    },
+                    oneShot: {
+                        type: 'boolean',
+                        description: "When true, the cron cancels itself after the first real fire (default false = recurring). Use this to schedule a single trigger at a specific cron-expressible time (e.g. `0 14 7 6 *` = next 7 June at 14:00) without it repeating yearly. Skip-active fires don't consume the one-shot — the cron retries at the next occurrence until it actually runs once.",
+                    },
+                },
+                required: ['expression', 'prompt'],
+            },
+        },
+        {
+            name: 'cron_delete',
+            description: "Cancel a previously-armed cron by id. Idempotent — returns ok=true even if the id is unknown. Only the workspace's own crons can be cancelled (cron_list to see them).",
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    id: { type: 'string', description: 'The cron id returned by cron_create.' },
+                },
+                required: ['id'],
+            },
+        },
+        {
+            name: 'cron_list',
+            description: 'List all crons currently armed on THIS workspace, including their next and last fire times.',
+            inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+        },
         {
             name: 'get_git_info',
             description: 'CALL BEFORE creating a PR, committing in batches, or reporting progress to the user. Returns commit count ahead of source, files changed, insertions/deletions, and existing PR URL if any.',
@@ -324,13 +383,13 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         },
         {
             name: 'schedule_wakeup',
-            description: 'CALL to schedule a follow-up turn on THIS workspace after a delay. End the current turn normally; once it finishes and the workspace is idle, Kōbō waits `delaySeconds`, then resumes the same conversation by injecting `prompt` as the next user message. The wakeup is scoped to the current workspace and resumes its latest session — you cannot target another workspace or another session. If a turn is still active when the timer fires, the wakeup is skipped (status: `session-active`). Replaces any previously pending wakeup on this workspace. Delay is clamped to [60, 3600] seconds. Prefer this over the built-in `ScheduleWakeup` tool — it is the SDK-supported entry point.',
+            description: 'CALL to schedule a follow-up turn on THIS workspace after a delay. End the current turn normally; once it finishes and the workspace is idle, Kōbō waits `delaySeconds`, then resumes the same conversation by injecting `prompt` as the next user message. The wakeup is scoped to the current workspace and resumes its latest session — you cannot target another workspace or another session. If a turn is still active when the timer fires, the wakeup is skipped (status: `session-active`). Replaces any previously pending wakeup on this workspace. Delay is clamped to [60, 21600] seconds (1min to 6h). Prefer this over the built-in `ScheduleWakeup` tool — it is the SDK-supported entry point.',
             inputSchema: {
                 type: 'object',
                 properties: {
                     delaySeconds: {
                         type: 'number',
-                        description: 'Seconds from now until the wakeup fires. Clamped to [60, 3600].',
+                        description: 'Seconds from now until the wakeup fires. Clamped to [60, 21600] (1min to 6h).',
                     },
                     prompt: {
                         type: 'string',
@@ -436,6 +495,56 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             }
             return ok(result);
         }
+        if (name === 'cron_create') {
+            const expression = a.expression;
+            const prompt = a.prompt;
+            const label = typeof a.label === 'string' ? a.label : undefined;
+            const mode = typeof a.mode === 'string' ? a.mode : undefined;
+            const oneShot = typeof a.oneShot === 'boolean' ? a.oneShot : undefined;
+            if (typeof expression !== 'string' || typeof prompt !== 'string') {
+                return fail('expression and prompt parameters are required');
+            }
+            if (mode !== undefined && mode !== 'resume' && mode !== 'fresh') {
+                return fail("mode must be 'resume' or 'fresh'");
+            }
+            // Route through the backend so the in-memory `setTimeout` lives in the
+            // backend process (which owns orchestrator + WS broadcast). Calling
+            // cron-service.arm() directly here would persist the row but arm the
+            // timer in the MCP server sub-process, which dies with the agent
+            // session — fires would never trigger a real session resume.
+            try {
+                const created = (await backendRequest('POST', `/api/workspaces/${workspaceId}/crons`, {
+                    expression,
+                    prompt,
+                    label,
+                    mode,
+                    oneShot,
+                }));
+                return ok({ ok: true, cron: created.cron });
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return ok({ ok: false, error: message });
+            }
+        }
+        if (name === 'cron_delete') {
+            const id = a.id;
+            if (typeof id !== 'string')
+                return fail('id parameter is required');
+            // Same reason as cron_create — the backend owns the timer Map.
+            try {
+                await backendRequest('DELETE', `/api/workspaces/${workspaceId}/crons/${id}`);
+                return ok({ ok: true });
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return ok({ ok: false, error: message });
+            }
+        }
+        if (name === 'cron_list') {
+            const result = cronListHandler(db, workspaceId);
+            return ok(result);
+        }
         if (name === 'start_dev_server') {
             const result = await backendRequest('POST', `/api/dev-server/${workspaceId}/start`);
             return ok(result);

package/dist/server/db/migrations.js

@@ -243,6 +243,44 @@ export const migrations = [
             db.prepare('ALTER TABLE workspaces ADD COLUMN agent_description TEXT').run();
         },
     },
+    {
+        version: 22,
+        name: 'add-pending-crons',
+        migrate: (db) => {
+            // Per-workspace cron schedules: each row arms a recurring agent prompt
+            // on a cron expression. Sibling timer table to pending_wakeups /
+            // pending_quota_backoffs. Many rows per workspace (unlike the one-row
+            // sibling tables), so id is the primary key. CASCADE on workspace
+            // delete to keep the timer set tidy. Idempotent via IF NOT EXISTS.
+            db.prepare(`CREATE TABLE IF NOT EXISTS pending_crons (
+          id                TEXT PRIMARY KEY,
+          workspace_id      TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+          expression        TEXT NOT NULL,
+          prompt            TEXT NOT NULL,
+          label             TEXT,
+          agent_session_id  TEXT,
+          next_fire_at      TEXT NOT NULL,
+          last_fired_at     TEXT,
+          created_at        TEXT NOT NULL
+        )`).run();
+            db.prepare('CREATE INDEX IF NOT EXISTS idx_pending_crons_workspace ON pending_crons(workspace_id)').run();
+            db.prepare('CREATE INDEX IF NOT EXISTS idx_pending_crons_next_fire ON pending_crons(next_fire_at)').run();
+        },
+    },
+    {
+        version: 23,
+        name: 'add-pending-crons-one-shot',
+        migrate: (db) => {
+            // One-shot cron: fires once and cancels itself. Distinct from a wakeup
+            // because it still uses cron expressions (can target an absolute date,
+            // e.g. `0 14 7 6 *` = "next 7 June at 14:00") rather than a delay.
+            // Default 0 (recurring) preserves existing behaviour.
+            const cols = db.prepare('PRAGMA table_info(pending_crons)').all();
+            if (!cols.some((c) => c.name === 'one_shot')) {
+                db.prepare('ALTER TABLE pending_crons ADD COLUMN one_shot INTEGER NOT NULL DEFAULT 0').run();
+            }
+        },
+    },
 ];
 /** Current schema version — always equals the highest migration version. */
 export const SCHEMA_VERSION = migrations.length > 0 ? migrations[migrations.length - 1].version : 1;

package/dist/server/db/schema.js

@@ -82,6 +82,22 @@ export function initSchema(db) {
       created_at   TEXT NOT NULL
     );
 
+    CREATE TABLE IF NOT EXISTS pending_crons (
+      id                TEXT PRIMARY KEY,
+      workspace_id      TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+      expression        TEXT NOT NULL,
+      prompt            TEXT NOT NULL,
+      label             TEXT,
+      agent_session_id  TEXT,
+      next_fire_at      TEXT NOT NULL,
+      last_fired_at     TEXT,
+      one_shot          INTEGER NOT NULL DEFAULT 0,
+      created_at        TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_pending_crons_workspace ON pending_crons(workspace_id);
+    CREATE INDEX IF NOT EXISTS idx_pending_crons_next_fire ON pending_crons(next_fire_at);
+
     CREATE TABLE IF NOT EXISTS usage_snapshots (
       provider_id   TEXT PRIMARY KEY,
       status        TEXT NOT NULL,

package/dist/server/index.js

@@ -23,6 +23,7 @@ import workspacesRouter from './routes/workspaces.js';
 import { getAvailableSkills, reconcileOrphanSessions, restoreRetryCountsFromDb, sendMessage, setBackendPort, startAgent, startWatchdog, stopAgent, stopWatchdog, } from './services/agent/orchestrator.js';
 import * as autoLoopService from './services/auto-loop-service.js';
 import { runContentMigrationIfNeeded } from './services/content-migration-service.js';
+import * as cronService from './services/cron-service.js';
 import { createDailyDbBackupIfNeeded } from './services/db-backup-service.js';
 import { startDevServer, stopDevServer } from './services/dev-server-service.js';
 import { startPrWatcher, stopPrWatcher } from './services/pr-watcher-service.js';
@@ -60,6 +61,7 @@ autoLoopService.rehydrate();
 // from retryCount=0 and undo the progression.
 restoreRetryCountsFromDb();
 quotaBackoffService.restoreOnBoot((workspaceId) => autoLoopService.onQuotaBackoffExpired(workspaceId));
+cronService.restoreOnBoot();
 startPrWatcher();
 startUsagePoller();
 // Create Hono app

package/dist/server/routes/health.js

@@ -63,15 +63,73 @@ app.get('/report', (c) => {
             worktreesMissing.push({ workspaceId: ws.id, name: ws.name, path: wtPath, exists: false });
         }
     }
-    // Orphan agent sessions — marked running but PID no longer alive
+    // Orphan agent sessions — marked running but PID no longer alive.
+    // Also collect the alive ones for the active-state panel.
     const runningSessions = db
-        .prepare("SELECT pid FROM agent_sessions WHERE status = 'running' AND pid IS NOT NULL")
+        .prepare(`
+      SELECT s.pid AS pid, s.workspace_id AS workspaceId, s.started_at AS startedAt, w.name AS workspaceName
+      FROM agent_sessions s
+      JOIN workspaces w ON w.id = s.workspace_id
+      WHERE s.status = 'running' AND s.pid IS NOT NULL
+    `)
         .all();
     let orphaned = 0;
+    const agentSessionsAlive = [];
     for (const s of runningSessions) {
-        if (s.pid && !isProcessAlive(s.pid))
+        if (!s.pid)
+            continue;
+        if (isProcessAlive(s.pid)) {
+            agentSessionsAlive.push({
+                workspaceId: s.workspaceId,
+                workspaceName: s.workspaceName,
+                pid: s.pid,
+                startedAt: s.startedAt,
+            });
+        }
+        else {
             orphaned++;
+        }
     }
+    // Active state — features the user wants to see at a glance:
+    // pending quota backoffs, scheduled wakeups, armed auto-loops, running dev servers.
+    const quotaBackoffs = db
+        .prepare(`
+      SELECT q.workspace_id AS workspaceId, w.name AS name, q.target_at AS targetAt,
+             q.resets_at AS resetsAt, q.source AS source, q.retry_count AS retryCount
+      FROM pending_quota_backoffs q
+      JOIN workspaces w ON w.id = q.workspace_id
+      ORDER BY q.target_at ASC
+    `)
+        .all();
+    const pendingWakeups = db
+        .prepare(`
+      SELECT p.workspace_id AS workspaceId, w.name AS name, p.target_at AS targetAt, p.reason AS reason
+      FROM pending_wakeups p
+      JOIN workspaces w ON w.id = p.workspace_id
+      ORDER BY p.target_at ASC
+    `)
+        .all();
+    const autoLoopActiveRaw = db
+        .prepare(`
+      SELECT id AS workspaceId, name, auto_loop_ready AS ready
+      FROM workspaces
+      WHERE auto_loop = 1 AND archived_at IS NULL
+      ORDER BY name ASC
+    `)
+        .all();
+    const autoLoopActive = autoLoopActiveRaw.map((r) => ({
+        workspaceId: r.workspaceId,
+        name: r.name,
+        ready: r.ready === 1,
+    }));
+    const devServersRunning = db
+        .prepare(`
+      SELECT id AS workspaceId, name
+      FROM workspaces
+      WHERE dev_server_status = 'running' AND archived_at IS NULL
+      ORDER BY name ASC
+    `)
+        .all();
     const settingsRow = db.prepare('SELECT COUNT(*) as n FROM workspaces').get();
     const archivedRow = db.prepare('SELECT COUNT(*) as n FROM workspaces WHERE archived_at IS NOT NULL').get();
     const report = {
@@ -95,6 +153,13 @@ app.get('/report', (c) => {
             sentry: { configured: Boolean(healthGlobalSettings.sentryMcpKey) },
             editor: { configured: Boolean(healthGlobalSettings.editorCommand) },
         },
+        active: {
+            quotaBackoffs,
+            pendingWakeups,
+            autoLoopActive,
+            agentSessionsAlive,
+            devServersRunning,
+        },
     };
     return c.json(report);
 });

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 });