@loicngr/kobo 1.11.1 → 1.11.3

package/CHANGELOG.md

@@ -4,6 +4,42 @@ 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.3
+
+- feat(forge): add bitbucket community support
+
+## 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

package/README.md

@@ -17,11 +17,11 @@ 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 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. 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` / `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. 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`), Bitbucket Community (`bkt`), 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. When a project has no configured server, the panel and MCP tool report that explicitly instead of implying one is running.
@@ -29,15 +29,15 @@ Kōbō runs multiple coding agents in parallel, each isolated in its own git wor
 - **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
 
@@ -84,7 +84,7 @@ The most common knobs:
 | `ANTHROPIC_API_KEY` | none | Claude Code engine credential (alternative to `claude /login`) |
 | `OPENAI_API_KEY` | none | Codex engine credential (alternative to `codex login`) |
 
-Global and per-project settings (worktree path, dev server commands, E2E framework, prompt templates, git conventions, branch prefixes, lifecycle scripts, task prompt) are edited in **Settings** at runtime. Notion and Sentry are enabled independently in their respective tabs; disabling one keeps its configuration and existing workspace links, but removes its import and automation UI. In **Settings → General → Activity feed**, you can hide agent reasoning panels. Per-project values inherit from the global ones when left empty.
+Global and per-project settings (worktree path, dev server commands, E2E framework, prompt templates, git conventions, branch prefixes, lifecycle scripts, task prompt) are edited in **Settings** at runtime. Notion and Sentry are enabled independently in their respective tabs; disabling one keeps its configuration and existing workspace links, but removes its import and automation UI. **Settings → Forge** holds local Bitbucket Community credentials for `bkt`; Kōbō uses them for PR actions and provides them only to agents working in Bitbucket projects. In **Settings → General → Activity feed**, you can hide agent reasoning panels. Per-project values inherit from the global ones when left empty.
 
 The full reference (every env var, every setting key, MCP server registration, Notion / Sentry / Voice setup) is in [`CONFIGURATION.md`](./CONFIGURATION.md).
 

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 {
@@ -3186,7 +3228,8 @@ app.post('/:id/merge-pr', async (c) => {
             return c.json({ error: 'This PR is not ready to merge', code: 'pr_not_ready' }, 409);
         }
         await provider.mergeRequest(workspace.worktreePath, snapshot.number);
-        return c.json({ success: true });
+        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) {
@@ -3196,6 +3239,31 @@ app.post('/:id/merge-pr', async (c) => {
         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/engine.js

@@ -199,6 +199,7 @@ export function createClaudeCodeEngine() {
                         console.warn(`[claude-engine stderr] ${data}`);
                     }
                 },
+                env: options.env,
             });
             sdkOptions.abortController = abortController;
             // Override the SDK's libc-blind binary resolution on Linux glibc — see

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/claude-code/options-builder.js

@@ -82,5 +82,7 @@ export function buildClaudeOptions(input) {
         options.canUseTool = input.canUseTool;
     if (input.stderr)
         options.stderr = input.stderr;
+    if (input.env)
+        options.env = input.env;
     return { options, effectivePrompt: prompt };
 }

package/dist/server/services/agent/engines/codex/engine.js

@@ -60,7 +60,7 @@ export function createCodexEngine() {
             };
             const streamingBatcher = createStreamingBatcher(emitDirect);
             const safeEmit = (ev) => streamingBatcher.push(ev);
-            const child = spawnAppServer({ cwd: options.workingDir, signal: abortController.signal });
+            const child = spawnAppServer({ cwd: options.workingDir, env: options.env, signal: abortController.signal });
             if (child.stderr) {
                 child.stderr.setEncoding('utf8');
                 child.stderr.on('data', (chunk) => {

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

@@ -6,8 +6,9 @@ import { unregisterProcess } from '../../utils/process-tracker.js';
 import * as autoLoopService from '../auto-loop-service.js';
 import * as cleanupScriptService from '../cleanup-script-service.js';
 import * as cronService from '../cron-service.js';
+import { resolveForge } from '../forge/resolve.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';
@@ -342,6 +343,38 @@ function buildMcpServers(workspaceId) {
         },
     ];
 }
+function isBitbucketProject(projectPath) {
+    try {
+        return resolveForge(projectPath) === 'bitbucket-community';
+    }
+    catch {
+        return false;
+    }
+}
+function buildAgentEnv(projectPath) {
+    if (!isBitbucketProject(projectPath))
+        return undefined;
+    const global = getGlobalSettings();
+    if (!global.bitbucketToken)
+        return undefined;
+    return {
+        ...process.env,
+        BKT_HOST: 'https://bitbucket.org',
+        BKT_TOKEN: global.bitbucketToken,
+        BKT_USERNAME: global.bitbucketUsername,
+    };
+}
+function buildAgentPrompt(prompt, projectPath) {
+    if (!projectPath || !isBitbucketProject(projectPath))
+        return prompt;
+    return [
+        '[Kōbō Bitbucket] Bitbucket credentials are available through the `bkt` CLI in this session.',
+        'Use `bkt pr edit <number> --body <description>` and `bkt pr comment <number> --body <comment>` for PR updates.',
+        'Do not call the Bitbucket REST API with curl or reuse BKT_TOKEN as a Bearer token: Bitbucket Cloud API tokens require the bkt CLI authentication flow.',
+        '',
+        prompt,
+    ].join('\n');
+}
 function resolveSessionForResume(workspaceId, existingSessionId, model) {
     const db = getDb();
     let lastSession;
@@ -540,6 +573,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);
@@ -755,7 +794,7 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
     const options = {
         workspaceId,
         workingDir,
-        prompt,
+        prompt: buildAgentPrompt(prompt, ws?.projectPath),
         model,
         effort: reasoningEffort,
         // Cascade: explicit caller override → workspace setting → 'bypass'.
@@ -772,6 +811,7 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
         })(),
         settings,
         mcpServers: buildMcpServers(workspaceId),
+        env: ws ? buildAgentEnv(ws.projectPath) : undefined,
     };
     const controller = new SessionController(workspaceId, agentSessionId, engine, (ev) => handleEvent(workspaceId, agentSessionId, ev));
     controllers.set(workspaceId, controller);
@@ -1195,6 +1235,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 +1256,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 +1316,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`.