@loicngr/kobo 1.11.0 → 1.11.2

package/CHANGELOG.md

@@ -4,6 +4,44 @@ All notable changes to Kōbō are documented here. The format is based on
 [Keep a Changelog](https://keepachangelog.com/). Each release is an `## <version>`
 section — the in-app "What's new" dialog reads this file.
 
+## 1.11.2
+
+- feat(integrations): let Notion and Sentry be enabled independently, keep
+  their settings isolated, hide inactive project overrides, and add detailed
+  **Test connection** feedback.
+- feat(chat): stream Claude output token-by-token like Codex, consolidate agent
+  reasoning into one live panel above the composer, and add a visibility
+  preference for reasoning and verbose system messages.
+- feat(chat): add `Ctrl+J` for a new line, `Ctrl+Enter` to force a queued
+  message while an agent is busy, and keep the shortcuts visible below chat.
+- feat(chat): add session-aware `Ctrl+F` workspace-history search, scrolling to
+  the selected result; global search now opens the same exact message.
+- feat(chat): add a `Ctrl+K` workspace command palette for common actions.
+- feat(chat): make worktree-relative paths and Edit/Write cards open the
+  corresponding file in the Git diff viewer.
+- feat(git): add workspace commits with either a user-written message or an
+  agent request; add confirmed PR/MR merging and an optional remote-branch
+  deletion after merge.
+- feat(auto-loop): retry quota, rate-limit, and temporary upstream failures;
+  add a configurable maximum retry count.
+- feat(notifications): add `basic-notification.mp3`, event-level sound
+  inheritance, an agent-error sound, browser-permission diagnostics, and more
+  reliable playback while Kobo is in a background tab.
+- feat(settings): extend the project color palette and improve save-state
+  handling for activity-feed preferences.
+- feat(observability): enrich the session timeline with tools, tokens, and
+  errors; keep it fresh during an active run and retain diagnostic export.
+- feat(pwa): show install, offline, update, and WebSocket-reconnection states;
+  preserve the visible chat area when the status banner is displayed.
+- fix(websocket): avoid reconnecting after an explicit disconnect and resume
+  safely after network connectivity returns.
+
+## 1.11.1
+
+- feat(workspace): improve workspace actions
+- feat(workspace): Forge merge button
+- feat(workspace): Commit button
+
 ## 1.11.0
 
 - feat(pwa): ship the production client as an installable Progressive Web App.

package/README.md

@@ -17,27 +17,27 @@ Kōbō runs multiple coding agents in parallel, each isolated in its own git wor
 
 - **Isolated worktrees**: each workspace is a dedicated git worktree on its own branch, so parallel sessions never collide.
 - **Two agent engines**: Claude Code (via `@anthropic-ai/claude-agent-sdk`) and OpenAI Codex (via `codex app-server`), chosen per workspace.
-- **Live chat**: streaming text, inline Edit/Write diffs, per-turn cards, a compaction-in-progress indicator, infinite scrollback, and the latest Claude or Codex reasoning in a panel immediately above the message input. `/` autocompletes skills and commands, `@` fuzzy-autocompletes worktree file paths, and `Ctrl+F` searches readable messages in the current workspace: selecting a result loads its session and scrolls to it. The global search page deep-links to the same location. Messages queued while an agent is busy stay scoped to their workspace and session. **Send now** delivers a queued message to an active Claude Code stream or steers the active Codex turn; it remains queued until the engine confirms acceptance. Use `Enter` to send, `Ctrl+Enter` to force delivery while an agent is busy, and `Shift+Enter` or `Ctrl+J` for a new line.
+- **Live chat**: streaming text, inline Edit/Write diffs, per-turn cards, a compaction-in-progress indicator, infinite scrollback, and a reasoning panel immediately above the message input while Claude or Codex is actively thinking. `/` autocompletes skills and commands, `@` fuzzy-autocompletes worktree file paths, and `Ctrl+F` searches readable messages in the current workspace: selecting a result loads its session and scrolls to it. `Ctrl+K` opens a command palette for common workspace actions. The global search page deep-links to the same location. Messages queued while an agent is busy stay scoped to their workspace and session. **Send now** delivers a queued message to an active Claude Code stream or steers the active Codex turn; it remains queued until the engine confirms acceptance. Use `Enter` to send, `Ctrl+Enter` to force delivery while an agent is busy, and `Shift+Enter` or `Ctrl+J` for a new line.
 - **Full MCP toolset (`kobo-tasks`)**: a per-workspace MCP server the agent uses for far more than tasks — task/acceptance-criteria CRUD, starting/stopping the dev server and reading its logs, a unified `get_ticket` (Notion or Sentry), searching past conversations across every workspace, per-session token/cost usage, and a `.ai/thoughts` decision log. Native Claude Code Task tools complement it for lightweight sub-agent coordination. See [`AGENTS.md`](./AGENTS.md) for the full tool list.
 
   ![Sub-agents panel showing parallel tool calls](docs/assets/images/sub-agents-panel.png)
-- **Git panel**: a Monaco-based diff viewer with **inline file editing** (edit the right-hand panel directly, save with `Ctrl/Cmd+S`, conflict-guarded via sha precondition), inline conflict resolution, and `Sync` / `Push` / `Open PR` / `Change PR base` / `Change source branch`. Edit/Write cards in chat open their exact changed file in the diff viewer. Multi-forge: GitHub (`gh`), GitLab (`glab`), or no forge, auto-detected from the remote and overridable per project.
+- **Git panel**: a Monaco-based diff viewer with **inline file editing** (edit the right-hand panel directly, save with `Ctrl/Cmd+S`, conflict-guarded via sha precondition), inline conflict resolution, and `Sync` / `Push` / `Commit` / `Open PR` / `Merge ready PR` / `Change PR base` / `Change source branch`. You can write the commit message yourself or ask the active engine to prepare the commit; PR/MR merging always requires a confirmation, then Kōbō can offer to delete the merged remote branch. Edit/Write cards in chat open their exact changed file in the diff viewer. Multi-forge: GitHub (`gh`), GitLab (`glab`), or no forge, auto-detected from the remote and overridable per project.
 
   ![Diff viewer with side-by-side changes](docs/assets/images/diff-viewer.png)
-- **Dev server panel**: start, stop, and tail logs for a workspace's dev server (Docker or npm) straight from the Tools panel — no need to leave the UI.
+- **Dev server panel**: start, stop, and tail logs for a workspace's dev server (Docker or npm) straight from the Tools panel — no need to leave the UI. When a project has no configured server, the panel and MCP tool report that explicitly instead of implying one is running.
 - **Attention indicators**: workspace cards surface CI failures, review-requested changes, and a conflict-aware **ready-to-merge** badge, plus a one-click **Fix CI** button that spawns a fix workspace automatically. Seven PR/MR and CI transitions each have their own audio toggle, sound, and volume; simultaneous transitions play sequentially.
 - **Interactive Q&A**: an agent can pause mid-session to ask a clarifying question through the UI; the workspace surfaces under "Needs Attention" until you answer. Choosing **Other** opens an inline free-form field, and option previews are available on hover. Codex native interactive questions require its `plan` permission mode.
 
   ![Agent asking a clarifying question, awaiting the user's answer](docs/assets/images/agent-question.png)
-- **Auto-loop**: an opt-in mode that walks the task list, spawning a fresh session per task and stopping once there's nothing left to do, progress stalls, an error occurs, or the agent needs input from you. Optionally run the initial brainstorming session on a stronger model and every task after that on a cheaper one, without leaving the engine you picked.
+- **Auto-loop**: an opt-in mode that walks the task list, spawning a fresh session per task and stopping once there's nothing left to do, progress stalls, an error occurs, or the agent needs input from you. Rate-limit and temporary upstream failures retry on the quota backoff ladder; Settings controls the maximum number of automatic retries. Optionally run the initial brainstorming session on a stronger model and every task after that on a cheaper one, without leaving the engine you picked.
 - **Quota-aware**: 5-hour / 7-day Claude usage and Codex rate-limit buckets sit in the footer, and sessions auto-resume after a rate-limit reset.
 - **Scheduled wakeups**: the agent schedules a one-shot wake-up via the `schedule_wakeup` MCP tool. Kōbō persists it across restarts, shows a live countdown, and re-invokes the agent with the stored prompt at the chosen time.
 - **Cron schedules**: recurring per-workspace triggers the agent registers through MCP tools (`cron_create` / `cron_delete` / `cron_list`). Each tick resumes the workspace session (skipped if already active), and schedules are re-armed at boot with skip-missed semantics.
 - **Lifecycle scripts**: shell scripts run automatically at key moments — **setup** (worktree created), **cleanup** (session ended), **archive** (workspace archived). Configure them globally or per project, with their output streamed into the chat.
 - **Disk-space purge**: free a merged workspace's disk space without losing its chat history — see [below](#disk-space-purge).
-- **Observability**: a compact session timeline in the right panel shows session duration and status; download a redacted workspace diagnostic JSON for troubleshooting.
+- **Observability**: a compact session timeline in the right panel shows each session’s duration, tools, tokens, and errors; download a redacted workspace diagnostic JSON for troubleshooting.
 - **Optional integrations**: independently enable or disable Notion (import missions) and Sentry (fix from issue URL) in Settings, with a **Test connection** action for each; local voice transcription uses whisper.cpp.
-- **Installable PWA**: production builds work as a Progressive Web App. Install Kōbō from your browser on desktop or mobile for an app-like window; it signals offline state and offers an explicit reload when an update is ready. Live agent activity still requires a connection to the local Kōbō server.
+- **Installable PWA**: production builds work as a Progressive Web App. Install Kōbō from your browser on desktop or mobile for an app-like window; it signals offline state, WebSocket reconnection, and offers an explicit reload when an update is ready. Live agent activity still requires a connection to the local Kōbō server.
 
 ## Quick start
 

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

@@ -298,7 +298,7 @@ const WORKSPACE_SCOPED_TOOLS = [
     },
     {
         name: 'get_dev_server_status',
-        description: 'CALL BEFORE asking the user whether the app is running, or when your change is dev-server-sensitive. Returns running/stopped/starting/error + URL, port, container names.',
+        description: 'CALL BEFORE asking the user whether the app is running, or when your change is dev-server-sensitive. Returns `not_configured` when this project has no dev server: do not start one manually in that case. Otherwise returns running/stopped/starting/error + URL, port, container names.',
         inputSchema: { type: 'object', properties: {}, required: [] },
         annotations: { readOnlyHint: true, openWorldHint: false },
     },

package/dist/server/routes/dev-server.js

@@ -1,6 +1,7 @@
 import { Hono } from 'hono';
 import { migrationGuard } from '../middleware/migration-guard.js';
 import { getDevServerLogs, getStatus, startDevServer, stopDevServer } from '../services/dev-server-service.js';
+import { getProjectSettings } from '../services/settings-service.js';
 import { getWorkspace } from '../services/workspace-service.js';
 /** Hono sub-router for per-workspace dev server lifecycle (start, stop, status, logs). */
 const app = new Hono();
@@ -12,6 +13,19 @@ app.get('/:workspaceId/status', (c) => {
         if (!workspace) {
             return c.json({ error: `Workspace '${workspaceId}' not found` }, 404);
         }
+        const devServer = getProjectSettings(workspace.projectPath)?.devServer;
+        if (!devServer?.startCommand?.trim()) {
+            return c.json({
+                status: 'not_configured',
+                configured: false,
+                message: 'No dev server is configured for this project',
+                instanceName: '',
+                projectName: '',
+                httpPort: '',
+                url: '',
+                containers: [],
+            });
+        }
         const status = getStatus(workspace.projectPath, workspace.workingBranch, workspaceId);
         // If runtime detection returns unknown, use persisted status from DB
         if (status.status === 'unknown' && workspace.devServerStatus && workspace.devServerStatus !== 'stopped') {

package/dist/server/routes/workspaces.js

@@ -1559,6 +1559,48 @@ function readableHistorySearchResult(type, rawPayload, query) {
         snippet: `${start > 0 ? '…' : ''}${text.slice(start, end).replace(/\s+/g, ' ').trim()}${end < text.length ? '…' : ''}`,
     };
 }
+// GET /api/workspaces/:id/session-metrics — compact observability data for the timeline.
+app.get('/:id/session-metrics', (c) => {
+    try {
+        const id = c.req.param('id');
+        if (!workspaceService.getWorkspace(id))
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        const db = getDb();
+        const sessions = workspaceService.listSessions(id);
+        const metrics = new Map(sessions.map((session) => [
+            session.id,
+            { sessionId: session.id, toolCalls: 0, errors: 0, inputTokens: 0, outputTokens: 0 },
+        ]));
+        const events = db
+            .prepare("SELECT session_id, payload FROM ws_events WHERE workspace_id = ? AND type = 'agent:event' AND session_id IS NOT NULL")
+            .all(id);
+        for (const row of events) {
+            const metric = metrics.get(row.session_id);
+            if (!metric)
+                continue;
+            try {
+                const event = JSON.parse(row.payload);
+                if (event.kind === 'tool:call')
+                    metric.toolCalls++;
+                if (event.kind === 'error' || (event.kind === 'tool:result' && event.isError === true))
+                    metric.errors++;
+                if (event.kind === 'usage') {
+                    if (typeof event.inputTokens === 'number')
+                        metric.inputTokens = Math.max(metric.inputTokens, event.inputTokens);
+                    if (typeof event.outputTokens === 'number')
+                        metric.outputTokens = Math.max(metric.outputTokens, event.outputTokens);
+                }
+            }
+            catch {
+                // Corrupt historical events are intentionally ignored in diagnostics.
+            }
+        }
+        return c.json({ sessions, metrics: [...metrics.values()] });
+    }
+    catch (err) {
+        return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+});
 // GET /api/workspaces/:id/diagnostic.json — portable, redacted-by-design event diagnostic.
 app.get('/:id/diagnostic.json', (c) => {
     try {
@@ -2988,6 +3030,51 @@ app.post('/:id/git/commit-all', async (c) => {
         return c.json({ error: message }, 500);
     }
 });
+/** Ask the workspace agent to inspect and commit the current working tree. */
+app.post('/:id/git/commit-with-agent', migrationGuard, 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 workingTree = gitOps.getWorkingTreeStatus(workspace.worktreePath);
+        if (workingTree.staged + workingTree.modified + workingTree.untracked === 0) {
+            return c.json({ error: 'No uncommitted changes to commit' }, 400);
+        }
+        const prompt = `Please prepare a clean commit for the uncommitted changes in this workspace.
+
+1. Read .ai/.git-conventions.md if it exists and follow it exactly.
+2. Inspect git status and the staged and unstaged diffs. Do not include unrelated files.
+3. Run the relevant focused checks when practical.
+4. Stage the intended changes and create one conventional, descriptive commit.
+5. Do NOT push the branch.
+
+When finished, report the commit SHA, its message, the files included, and the checks you ran.`;
+        const session = workspaceService.getActiveSession(workspace.id);
+        wsService.emit(workspace.id, 'user:message', { content: prompt, sender: 'user' }, session?.id ?? undefined);
+        wakeupService.cancel(workspace.id, 'user-message');
+        let messageSent = false;
+        try {
+            agentManager.sendMessage(workspace.id, prompt);
+            messageSent = true;
+        }
+        catch {
+            try {
+                agentManager.startAgent(workspace.id, workspace.worktreePath, prompt, workspace.model, true, workspace.agentPermissionMode, undefined, workspace.reasoningEffort);
+                workspaceService.updateWorkspaceStatus(workspace.id, 'executing');
+                messageSent = true;
+            }
+            catch (resumeErr) {
+                const message = resumeErr instanceof Error ? resumeErr.message : String(resumeErr);
+                return c.json({ error: `Unable to ask the agent to commit: ${message}` }, 409);
+            }
+        }
+        return c.json({ ok: true, messageSent });
+    }
+    catch (err) {
+        return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+});
 /** Discard working-tree changes (destructive recovery action for a dirty rebase/merge). */
 app.post('/:id/git/discard', (c) => {
     try {
@@ -3115,6 +3202,68 @@ app.post('/:id/change-pr-base', async (c) => {
         return c.json({ error: message }, 500);
     }
 });
+/** Merge a ready, open PR/MR through its resolved forge provider. */
+app.post('/:id/merge-pr', 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 provider = getForgeProvider(resolveForge(workspace.projectPath));
+        if (!provider.capabilities.canMergeRequest) {
+            return c.json({ error: 'This project has no forge that can merge the PR', code: 'forge_unsupported' }, 409);
+        }
+        const availability = await provider.isAvailable(workspace.worktreePath);
+        if (!availability.available) {
+            return c.json({
+                error: `Forge CLI unavailable (${availability.reason ?? 'unknown'})`,
+                code: `forge_${availability.reason ?? 'unavailable'}`,
+            }, 409);
+        }
+        const snapshot = await provider.getPrStatus(workspace.worktreePath, workspace.workingBranch);
+        if (!snapshot || snapshot.state !== 'OPEN') {
+            return c.json({ error: 'No open PR found for this workspace', code: 'pr_not_open' }, 409);
+        }
+        if (!snapshot.readyToMerge) {
+            return c.json({ error: 'This PR is not ready to merge', code: 'pr_not_ready' }, 409);
+        }
+        await provider.mergeRequest(workspace.worktreePath, snapshot.number);
+        const merged = await provider.getPrStatus(workspace.worktreePath, workspace.workingBranch);
+        return c.json({ success: true, merged: merged?.state === 'MERGED', branch: workspace.workingBranch });
+    }
+    catch (err) {
+        if (err instanceof ForgeUnavailableError) {
+            return c.json({ error: err.message, code: 'forge_unavailable' }, 409);
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
+/** Delete the workspace branch from the remote after its PR/MR was merged. */
+app.post('/:id/delete-remote-branch', 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 provider = getForgeProvider(resolveForge(workspace.projectPath));
+        if (!provider.capabilities.canDeleteRemoteBranch) {
+            return c.json({ error: 'This project cannot delete remote branches', code: 'forge_unsupported' }, 409);
+        }
+        const availability = await provider.isAvailable(workspace.worktreePath);
+        if (!availability.available)
+            return c.json({ error: 'Forge CLI unavailable', code: 'forge_unavailable' }, 409);
+        const snapshot = await provider.getPrStatus(workspace.worktreePath, workspace.workingBranch);
+        if (snapshot?.state !== 'MERGED')
+            return c.json({ error: 'The PR is not merged yet', code: 'pr_not_merged' }, 409);
+        await provider.deleteRemoteBranch(workspace.worktreePath, workspace.workingBranch);
+        return c.json({ success: true });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
 /** Re-target a workspace onto a new source branch (metadata + worktree + PR base). */
 app.post('/:id/change-source-branch', async (c) => {
     const id = c.req.param('id');

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

@@ -76,7 +76,7 @@ function normalizeRateLimitInfo(info) {
  * 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 const QUOTA_PATTERN = /\b429\b|out of extra usage|rate[_ ]limit|usage limit|quota exceeded/i;
 export function createMapperState() {
     return {
         sessionStartedEmitted: false,

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

@@ -7,7 +7,7 @@ import { nanoid } from 'nanoid';
 //   - "quota exceeded" / "insufficient_quota" / "insufficient quota"
 //   - "out of extra usage" / "out of usage"
 //   - "usage limit exceeded"
-export const QUOTA_PATTERN = /rate[_ ]limit|quota|usage limit|insufficient[_ ]quota|out of (extra )?usage/i;
+export const QUOTA_PATTERN = /\b429\b|rate[_ ]limit|quota|usage limit|insufficient[_ ]quota|out of (extra )?usage/i;
 export function createMapperState(opts) {
     return {
         sessionStartedEmitted: false,

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

@@ -7,7 +7,7 @@ import * as autoLoopService from '../auto-loop-service.js';
 import * as cleanupScriptService from '../cleanup-script-service.js';
 import * as cronService from '../cron-service.js';
 import * as quotaBackoffService from '../quota-backoff-service.js';
-import { getEffectiveSettings } from '../settings-service.js';
+import { getEffectiveSettings, getGlobalSettings } from '../settings-service.js';
 import { refreshNow } from '../usage/poller.js';
 import * as wakeupService from '../wakeup-service.js';
 import { emit, emitEphemeral } from '../websocket-service.js';
@@ -540,6 +540,12 @@ function handleEvent(workspaceId, agentSessionId, ev) {
     if (ev.kind === 'error' && ev.category === 'quota') {
         void handleQuota(workspaceId, agentSessionId);
     }
+    if (ev.kind === 'error' &&
+        ev.category === 'other' &&
+        TRANSIENT_SERVER_ERROR_PATTERN.test(ev.message) &&
+        getWs(workspaceId)?.autoLoop) {
+        void handleTransientAutoLoopFailure(workspaceId);
+    }
     if (ev.kind === 'error' && ev.category === 'resume_failed') {
         resumeFailedSet.add(workspaceId);
         clearStaleEngineSessionId(workspaceId);
@@ -1195,6 +1201,8 @@ function clearStaleEngineSessionId(workspaceId) {
         console.error('[orchestrator] Failed to clear stale engine session ID:', err);
     }
 }
+/** Retryable upstream failures for an auto-loop iteration (not coding errors). */
+export const TRANSIENT_SERVER_ERROR_PATTERN = /\b(?:http\s*)?500\b|internal server error|service unavailable|temporarily unavailable|overloaded/i;
 const QUOTA_SAFETY_MARGIN_MS = 30_000;
 const QUOTA_MAX_BACKOFF_MS = 24 * 60 * 60 * 1000;
 const QUOTA_SATURATION_THRESHOLD_PCT = 95;
@@ -1214,7 +1222,11 @@ const QUOTA_FALLBACK_LADDER_MINUTES = [15, 30, 60, 180, 300];
  * finally (2) a fixed ladder (15 → 30 → 60 → 180 → 300 min) whenever neither
  * source is usable.
  */
-export async function computeQuotaBackoffMs(workspaceId, retryCount) {
+export async function computeQuotaBackoffMs(workspaceId, retryCount, preferQuotaReset = true) {
+    if (!preferQuotaReset) {
+        const idx = Math.min(Math.max(0, retryCount), QUOTA_FALLBACK_LADDER_MINUTES.length - 1);
+        return { delayMs: QUOTA_FALLBACK_LADDER_MINUTES[idx] * 60 * 1000, source: 'fallback_ladder' };
+    }
     // 1. Prefer the rate_limit event from the agent stream — most recent + most precise.
     const info = latestRateLimitInfo.get(workspaceId);
     if (info?.buckets?.length) {
@@ -1270,14 +1282,56 @@ async function handleQuota(workspaceId, _agentSessionId) {
         // May fail if transition is not valid
     }
     const retryCount = retryCounts.get(workspaceId) ?? 0;
+    const autoLoopEnabled = getWs(workspaceId)?.autoLoop === true;
+    const maxRetries = autoLoopEnabled ? (getGlobalSettings().autoLoopMaxRetries ?? 5) : 5;
+    if (autoLoopEnabled && retryCount >= maxRetries) {
+        autoLoopService.disable(workspaceId, 'error');
+        try {
+            updateWorkspaceStatus(workspaceId, 'error');
+        }
+        catch {
+            // The loop is disabled even if an already-terminal status rejects this transition.
+        }
+        return;
+    }
     const { delayMs, resetsAt, source } = await computeQuotaBackoffMs(workspaceId, retryCount);
     retryCounts.set(workspaceId, retryCount + 1);
     // The quotaBackoffService owns the timer + the persistent row + the
     // 'agent:quota-backoff' WS emit. Hand off everything to it.
     quotaBackoffService.arm(workspaceId, delayMs, { resetsAt: resetsAt ?? null, source });
 }
+/**
+ * Use the same persisted retry path for temporary upstream failures (HTTP 500
+ * and overloads) while deliberately ignoring quota-reset data: a server error
+ * is unrelated to the user's quota window and follows the fallback ladder.
+ */
+async function handleTransientAutoLoopFailure(workspaceId) {
+    try {
+        updateWorkspaceStatus(workspaceId, 'quota');
+    }
+    catch {
+        // May fail if transition is not valid.
+    }
+    const retryCount = retryCounts.get(workspaceId) ?? 0;
+    const maxRetries = getGlobalSettings().autoLoopMaxRetries ?? 5;
+    if (retryCount >= maxRetries) {
+        autoLoopService.disable(workspaceId, 'error');
+        try {
+            updateWorkspaceStatus(workspaceId, 'error');
+        }
+        catch {
+            // The loop is disabled even if an already-terminal status rejects this transition.
+        }
+        return;
+    }
+    const { delayMs, resetsAt, source } = await computeQuotaBackoffMs(workspaceId, retryCount, false);
+    retryCounts.set(workspaceId, retryCount + 1);
+    quotaBackoffService.arm(workspaceId, delayMs, { resetsAt: resetsAt ?? null, source });
+}
 /** @internal test-only — re-export of `handleQuota` for direct testing. */
 export const _handleQuota = handleQuota;
+/** @internal test-only — re-export of the transient auto-loop retry handler. */
+export const _handleTransientAutoLoopFailure = handleTransientAutoLoopFailure;
 /**
  * Rebuild the in-memory `retryCounts` map from the persisted `pending_quota_backoffs`
  * rows. Called from `index.ts` at boot, before `quotaBackoffService.restoreOnBoot`.

package/dist/server/services/forge/github/provider.js

@@ -92,7 +92,13 @@ function availabilityFromError(err) {
 }
 export const githubProvider = {
     id: 'github',
-    capabilities: { canCreatePr: true, canChangePrBase: true, requestTermShort: 'PR' },
+    capabilities: {
+        canCreatePr: true,
+        canChangePrBase: true,
+        canMergeRequest: true,
+        canDeleteRemoteBranch: true,
+        requestTermShort: 'PR',
+    },
     async isAvailable(repoPath) {
         try {
             await execFileAsync('gh', ['auth', 'status'], { cwd: repoPath, encoding: 'utf-8' });
@@ -127,4 +133,10 @@ export const githubProvider = {
     async changePrBase(repoPath, base) {
         await execFileAsync('gh', ['pr', 'edit', '--base', base], { cwd: repoPath, encoding: 'utf-8' });
     },
+    async mergeRequest(repoPath, number) {
+        await execFileAsync('gh', ['pr', 'merge', String(number), '--merge'], { cwd: repoPath, encoding: 'utf-8' });
+    },
+    async deleteRemoteBranch(repoPath, branch) {
+        await execFileAsync('git', ['push', 'origin', '--delete', branch], { cwd: repoPath, encoding: 'utf-8' });
+    },
 };

package/dist/server/services/forge/gitlab/provider.js

@@ -129,7 +129,13 @@ function availabilityFromError(err) {
 }
 export const gitlabProvider = {
     id: 'gitlab',
-    capabilities: { canCreatePr: true, canChangePrBase: true, requestTermShort: 'MR' },
+    capabilities: {
+        canCreatePr: true,
+        canChangePrBase: true,
+        canMergeRequest: true,
+        canDeleteRemoteBranch: true,
+        requestTermShort: 'MR',
+    },
     async isAvailable(repoPath) {
         try {
             await execFileAsync('glab', ['auth', 'status'], { cwd: repoPath, encoding: 'utf-8' });
@@ -179,4 +185,10 @@ export const gitlabProvider = {
     async changePrBase(repoPath, base) {
         await execFileAsync('glab', ['mr', 'update', '--target-branch', base], { cwd: repoPath, encoding: 'utf-8' });
     },
+    async mergeRequest(repoPath, number) {
+        await execFileAsync('glab', ['mr', 'merge', String(number), '--yes'], { cwd: repoPath, encoding: 'utf-8' });
+    },
+    async deleteRemoteBranch(repoPath, branch) {
+        await execFileAsync('git', ['push', 'origin', '--delete', branch], { cwd: repoPath, encoding: 'utf-8' });
+    },
 };

package/dist/server/services/forge/none.js

@@ -7,7 +7,13 @@ import { ForgeUnavailableError } from './types.js';
  */
 export const noneProvider = {
     id: 'none',
-    capabilities: { canCreatePr: false, canChangePrBase: false, requestTermShort: 'PR' },
+    capabilities: {
+        canCreatePr: false,
+        canChangePrBase: false,
+        canMergeRequest: false,
+        canDeleteRemoteBranch: false,
+        requestTermShort: 'PR',
+    },
     async isAvailable() {
         return { available: false };
     },
@@ -20,4 +26,10 @@ export const noneProvider = {
     async changePrBase() {
         throw new ForgeUnavailableError('This project has no supported forge configured');
     },
+    async mergeRequest() {
+        throw new ForgeUnavailableError('This project has no supported forge configured');
+    },
+    async deleteRemoteBranch() {
+        throw new ForgeUnavailableError('This project has no supported forge configured');
+    },
 };

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

@@ -768,6 +768,31 @@ const settingsMigrations = [
                 global.showThinkingBlocks = true;
         },
     },
+    {
+        version: 48,
+        name: 'add-agent-error-notification-sound',
+        migrate: ({ global }) => {
+            if (typeof global.audioAgentErrorNotifications !== 'boolean')
+                global.audioAgentErrorNotifications = false;
+            if (typeof global.audioAgentErrorSound !== 'string' || global.audioAgentErrorSound.length === 0) {
+                global.audioAgentErrorSound = 'inherit';
+            }
+            if (typeof global.audioAgentErrorVolume !== 'number' || !Number.isFinite(global.audioAgentErrorVolume)) {
+                global.audioAgentErrorVolume = 1;
+            }
+        },
+    },
+    {
+        version: 49,
+        name: 'add-auto-loop-max-retries',
+        migrate: ({ global }) => {
+            if (typeof global.autoLoopMaxRetries !== 'number' ||
+                !Number.isInteger(global.autoLoopMaxRetries) ||
+                global.autoLoopMaxRetries < 1) {
+                global.autoLoopMaxRetries = 5;
+            }
+        },
+    },
 ];
 /** Current settings schema version — always equals the highest migration version. */
 export const SETTINGS_SCHEMA_VERSION = settingsMigrations.length > 0 ? settingsMigrations[settingsMigrations.length - 1].version : 0;
@@ -814,40 +839,44 @@ function defaultSettings() {
             fileManagerCommand: '',
             terminalCommand: '',
             autoPurgeOnPrMerged: false,
+            autoLoopMaxRetries: 5,
             networkAccessEnabled: false,
             networkAccessToken: '',
             networkAccessBehindProxy: false,
             browserNotifications: true,
             audioNotifications: true,
-            audioQuestionNotifications: true,
-            audioWorkspaceCreatedNotifications: true,
+            audioQuestionNotifications: false,
+            audioWorkspaceCreatedNotifications: false,
+            audioAgentErrorNotifications: false,
             audioNotificationSound: 'hey.mp3',
-            audioQuestionSound: 'hey.mp3',
-            audioWorkspaceCreatedSound: 'warcraft-3-humain-travail.mp3',
+            audioQuestionSound: 'inherit',
+            audioWorkspaceCreatedSound: 'inherit',
+            audioAgentErrorSound: 'inherit',
             audioPrCiFailedSound: 'inherit',
-            audioPrCiFailedEnabled: true,
+            audioPrCiFailedEnabled: false,
             audioPrCiFailedVolume: 1,
             audioPrCiRecoveredSound: 'inherit',
-            audioPrCiRecoveredEnabled: true,
+            audioPrCiRecoveredEnabled: false,
             audioPrCiRecoveredVolume: 1,
             audioPrChangesRequestedSound: 'inherit',
-            audioPrChangesRequestedEnabled: true,
+            audioPrChangesRequestedEnabled: false,
             audioPrChangesRequestedVolume: 1,
             audioPrApprovedSound: 'inherit',
-            audioPrApprovedEnabled: true,
+            audioPrApprovedEnabled: false,
             audioPrApprovedVolume: 1,
             audioPrMergeConflictSound: 'inherit',
-            audioPrMergeConflictEnabled: true,
+            audioPrMergeConflictEnabled: false,
             audioPrMergeConflictVolume: 1,
             audioPrReadyToMergeSound: 'inherit',
-            audioPrReadyToMergeEnabled: true,
+            audioPrReadyToMergeEnabled: false,
             audioPrReadyToMergeVolume: 1,
             audioPrMergedSound: 'inherit',
-            audioPrMergedEnabled: true,
+            audioPrMergedEnabled: false,
             audioPrMergedVolume: 1,
             audioNotificationVolume: 1,
             audioQuestionVolume: 1,
             audioWorkspaceCreatedVolume: 1,
+            audioAgentErrorVolume: 1,
             notionStatusProperty: '',
             notionInProgressStatus: '',
             notionAssigneeProperty: '',
@@ -1182,6 +1211,15 @@ export function updateGlobalSettings(data) {
             delete data.cleanupScriptMode;
         }
     }
+    if ('autoLoopMaxRetries' in data) {
+        if (typeof data.autoLoopMaxRetries !== 'number' ||
+            !Number.isInteger(data.autoLoopMaxRetries) ||
+            data.autoLoopMaxRetries < 1 ||
+            data.autoLoopMaxRetries > 20) {
+            console.warn(`[settings] Invalid autoLoopMaxRetries value rejected: ${data.autoLoopMaxRetries}`);
+            delete data.autoLoopMaxRetries;
+        }
+    }
     const allowedGlobalKeys = [
         'defaultModelByEngine',
         'dangerouslySkipPermissions',
@@ -1202,13 +1240,16 @@ export function updateGlobalSettings(data) {
         'fileManagerCommand',
         'terminalCommand',
         'autoPurgeOnPrMerged',
+        'autoLoopMaxRetries',
         'browserNotifications',
         'audioNotifications',
         'audioQuestionNotifications',
         'audioWorkspaceCreatedNotifications',
+        'audioAgentErrorNotifications',
         'audioNotificationSound',
         'audioQuestionSound',
         'audioWorkspaceCreatedSound',
+        'audioAgentErrorSound',
         'audioPrCiFailedSound',
         'audioPrCiFailedEnabled',
         'audioPrCiFailedVolume',
@@ -1233,6 +1274,7 @@ export function updateGlobalSettings(data) {
         'audioNotificationVolume',
         'audioQuestionVolume',
         'audioWorkspaceCreatedVolume',
+        'audioAgentErrorVolume',
         'notionStatusProperty',
         'notionInProgressStatus',
         'notionAssigneeProperty',

package/dist/shared/project-colors.js

@@ -17,6 +17,13 @@ export const PROJECT_COLOR_PALETTE = [
     'amber-5',
     'orange-5',
     'brown-5',
+    'light-blue-5',
+    'light-green-5',
+    'lime-5',
+    'yellow-6',
+    'deep-orange-5',
+    'blue-grey-5',
+    'grey-6',
 ];
 export function isValidProjectColor(value) {
     return typeof value === 'string' && PROJECT_COLOR_PALETTE.includes(value);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loicngr/kobo",
-  "version": "1.11.0",
+  "version": "1.11.2",
   "description": "Kōbō — multi-workspace agent manager for Claude Code. Orchestrates isolated git worktrees with dev servers, Notion integration, and MCP tools.",
   "type": "module",
   "license": "GPL-3.0-or-later",