@loicngr/kobo 1.7.5 → 1.7.7

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
 
@@ -153,6 +155,90 @@ If you need to pin a specific version of the Notion MCP server, use a fork, or a
 
 Without a valid token configured, the Notion import field in the workspace creation form will return an error when you click **Refresh** or submit a Notion URL — the rest of Kōbō (workspaces, agents, tasks, Git integration) keeps working independently.
 
+## Voice transcription (local Whisper)
+
+Kōbō supports local voice transcription with push-to-talk in both:
+
+- `WorkspacePage` (chat input)
+- `CreatePage` (workspace instructions textarea)
+
+### Requirements
+
+- `whisper-cli` from [`whisper.cpp`](https://github.com/ggml-org/whisper.cpp)
+- `ffmpeg`
+- `cmake` (required to build `whisper.cpp` from source)
+- At least one Whisper model downloaded from **Settings → Voice**
+
+### Install `whisper.cpp` (Linux/macOS)
+
+```bash
+git clone https://github.com/ggml-org/whisper.cpp.git
+cd whisper.cpp
+cmake -B build
+cmake --build build -j
+```
+
+This usually produces `build/bin/whisper-cli`.
+
+You can also download a prebuilt archive from the `whisper.cpp` releases page (for example: <https://github.com/ggml-org/whisper.cpp/releases/tag/v1.8.4>) and point Kōbō to the extracted `whisper-cli` binary path.
+
+### Install `ffmpeg`
+
+Ubuntu / Debian:
+
+```bash
+sudo apt update
+sudo apt install -y cmake build-essential ffmpeg
+```
+
+Windows:
+
+- Install `ffmpeg` (for example via Chocolatey: `choco install ffmpeg`, or via Scoop: `scoop install ffmpeg`)
+- Verify in PowerShell:
+
+```powershell
+where ffmpeg
+ffmpeg -version
+```
+
+### Windows notes for `whisper.cpp`
+
+Install CMake and Visual Studio Build Tools (C/C++), then build `whisper.cpp` (or use a prebuilt `whisper-cli`), then verify:
+
+```powershell
+where whisper-cli
+whisper-cli -h
+```
+
+### Configure in Kōbō
+
+Open **Settings → Voice**:
+
+- Enable voice transcription
+- Optionally set:
+  - **Whisper binary path (optional)**
+  - **ffmpeg binary path (optional)**
+- If left empty, Kōbō falls back to:
+  - `whisper-cli` from `PATH` (or `WHISPER_CPP_COMMAND` if set)
+  - `ffmpeg` from `PATH`
+- Download a model (e.g. `base`) and select it as active
+
+The Voice panel shows runtime status (`ready/missing`) for both Whisper and ffmpeg so setup issues are visible immediately.
+
+### Advanced voice parameters
+
+Kōbō exposes additional transcription settings in **Settings → Voice**:
+
+- **Temperature** (`0..1`) — decoding stability vs flexibility
+- **Initial prompt** — optional context/jargon for better recognition
+- **Translate to English** — translate non-English speech to English
+- **Suppress non-speech tokens** — reduce non-speech artifacts in output
+
+Recommended defaults by model:
+
+- `tiny` / `base` → `0.1`
+- `small` / `medium` / `large-v3` → `0.2`
+
 ## Sentry integration
 
 Kōbō can turn a Sentry issue into a dedicated "fix workspace" — you paste the issue URL at workspace creation and Kōbō extracts the stacktrace, culprit, tags, offending spans and extra context, writes them as a local markdown file inside the worktree (`.ai/thoughts/SENTRY-<id>.md`), and primes the Claude agent with a TDD fix workflow that points at that file. The agent also keeps access to the Sentry MCP tools (`search_issue_events`, `get_issue_tag_values`, `get_sentry_resource`) so it can dig deeper on its own. **This feature is opt-in and reuses the Sentry MCP configuration you already have for Claude Code** — Kōbō does not manage a Sentry token separately.
@@ -231,6 +317,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 +349,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 +362,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

@@ -19,10 +19,12 @@ import sentryRouter from './routes/sentry.js';
 import settingsRouter from './routes/settings.js';
 import templatesRouter from './routes/templates.js';
 import usageRoutes from './routes/usage.js';
+import voiceRouter from './routes/voice.js';
 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 +62,7 @@ autoLoopService.rehydrate();
 // from retryCount=0 and undo the progression.
 restoreRetryCountsFromDb();
 quotaBackoffService.restoreOnBoot((workspaceId) => autoLoopService.onQuotaBackoffExpired(workspaceId));
+cronService.restoreOnBoot();
 startPrWatcher();
 startUsagePoller();
 // Create Hono app
@@ -81,6 +84,7 @@ app.route('/api/search', searchRouter);
 app.route('/api/health', healthRouter);
 app.route('/api/engines', enginesRouter);
 app.route('/api/migration', migrationRouter);
+app.route('/api/voice', voiceRouter);
 // Skills endpoint
 app.get('/api/skills', (c) => c.json(getAvailableSkills()));
 const PORT = parseInt(process.env.SERVER_PORT || process.env.PORT || '3000', 10);

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