@loicngr/kobo 1.11.37 → 1.11.39

package/AGENTS.md

@@ -114,7 +114,9 @@ src/
 | `workspace_chat_history` | chat-input history per workspace: message text + `created_at`, ordered by autoincrement id, capped at 200 entries by the service; CASCADE DELETE on workspace |
 | `workspace_permission_rules` | remembered per-workspace tool approvals, scoped to an exact operation or every invocation of a tool; CASCADE DELETE on workspace |
 
-`status` enum: `created | extracting | brainstorming | executing | completed | idle | error | quota`. Transitions are validated in `updateWorkspaceStatus` against `VALID_TRANSITIONS`.
+`status` enum: `created | extracting | brainstorming | executing | compacting | awaiting-user | completed | idle | error | quota`. Transitions are validated in `updateWorkspaceStatus` against `VALID_TRANSITIONS`.
+
+`compacting` is a server-owned busy state while the agent compacts context. The orchestrator associates the previous status with the current controller and restores it when compaction ends; stop, errors and startup reconciliation must not leave the workspace stuck in compaction. Normal workspace status updates make this state available after reload and across clients. Chat sends are refused during compaction before delivery or fallback starts, and the client keeps the user's draft while disabling send. The existing status column is unrestricted TEXT, so adding this state does not change the database schema.
 
 `archived_at` is **orthogonal** to `status`. Archiving is a visibility flag, not a lifecycle state. Unarchive restores the exact pre-archive `status`.
 

package/CHANGELOG.md

@@ -4,6 +4,14 @@ 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.39
+
+- fix(deps): require Claude SDK with Fable 5.1 support
+
+## 1.11.38
+
+- feat(workspaces): show compaction status and block chat sends
+
 ## 1.11.37
 
 - fix(kobo): harden workspace lifecycle and comparison navigation

package/dist/server/index.js

@@ -346,6 +346,15 @@ terminalWss.on('connection', (ws, workspaceId) => {
 setMessageHandler(async (type, payload) => {
     const p = payload;
     if (type === 'chat:message' && p?.workspaceId && p?.content) {
+        if (getWorkspace(p.workspaceId)?.status === 'compacting') {
+            emitEphemeral(p.workspaceId, 'chat:rejected', {
+                reason: 'compacting',
+                sessionId: p.sessionId,
+                content: p.content,
+                message: 'Workspace is compacting its context; wait until compaction finishes before sending a message',
+            });
+            return;
+        }
         // Auto-loop owns the agent's turns. A user message means the user wants
         // to redirect the conversation, so disable the loop (idempotent — the
         // `autoloop:disabled` event is emitted with reason='user-action' so the

package/dist/server/routes/workspaces.js

@@ -71,6 +71,27 @@ for (const route of ['/:id/archive', '/:id/run-setup-script', '/:id/cancel-sourc
         }
     });
 }
+// User prompt actions must reject before cancelling timers, stopping engines,
+// creating a PR or persisting input. The orchestrator also checks at delivery.
+for (const route of [
+    '/:id/start',
+    '/:id/switch-engine',
+    '/:id/git/commit-with-agent',
+    '/:id/git/resolve-with-agent',
+    '/:id/open-pr',
+    '/:id/start-review',
+    '/:id/start-ci-fix',
+]) {
+    app.use(route, async (c, next) => {
+        if (c.req.method === 'POST' && workspaceService.getWorkspace(c.req.param('id'))?.status === 'compacting') {
+            return c.json({
+                code: 'compacting',
+                error: 'Workspace is compacting its context; wait until compaction finishes before sending a message',
+            }, 409);
+        }
+        await next();
+    });
+}
 /** Tracks workspaces currently running a setup script to prevent concurrent executions. */
 const setupScriptRunning = new Set();
 /**
@@ -310,6 +331,12 @@ app.post('/:id/switch-engine', migrationGuard, async (c) => {
         const handoff = typeof body.handoff === 'string' && body.handoff.trim()
             ? body.handoff.trim().slice(0, 30_000)
             : buildEngineHandoff(workspace, workspace.engine, body.engine);
+        if (workspaceService.getWorkspace(workspace.id)?.status === 'compacting') {
+            return c.json({
+                code: 'compacting',
+                error: 'Workspace is compacting its context; wait until compaction finishes before sending a message',
+            }, 409);
+        }
         // A new engine is started three lines below: the previous one must be dead
         // first, or two agents share the worktree.
         if (agentManager.hasController(id))
@@ -3180,6 +3207,12 @@ app.post('/:id/start', migrationGuard, async (c) => {
         const prompt = body.prompt ?? pendingInitialPrompt ?? 'Continue the previous task where you left off.';
         const agentSessionId = body.agentSessionId;
         const resume = body.resume === true;
+        if (workspaceService.getWorkspace(id)?.status === 'compacting') {
+            return c.json({
+                code: 'compacting',
+                error: 'Workspace is compacting its context; wait until compaction finishes before sending a message',
+            }, 409);
+        }
         // A manual start supersedes any scheduled retry (quota or transient
         // watchdog recovery). Leaving its timer armed could spawn a second agent
         // after the user has already resumed the workspace.
@@ -3831,7 +3864,6 @@ app.post('/:id/git/commit-with-agent', migrationGuard, async (c) => {
 5. Do NOT push the branch.
 
 When finished, report the commit SHA, its message, the files included, and the checks you ran.`;
-        wakeupService.cancel(workspace.id, 'user-message');
         let messageSent = false;
         try {
             const { agentSessionId } = await deliverAgentPrompt(workspace, workspace.worktreePath, prompt);
@@ -3914,9 +3946,6 @@ ${fileList}
 6. Report the summary: which files you touched, the key decisions you made, and the final test result.${cherryPickNote}
 
 Start now.`;
-        // Cancel any pending wakeup: the user is driving this turn, the
-        // scheduler should not also wake the agent a few minutes later.
-        wakeupService.cancel(workspace.id, 'user-message');
         let messageSent = false;
         try {
             const { agentSessionId } = await deliverAgentPrompt(workspace, worktreePath, prompt);
@@ -4251,8 +4280,6 @@ app.post('/:id/open-pr', async (c) => {
             diffStats,
             tasks,
         });
-        // Cancel any pending wakeup: the user is driving this turn.
-        wakeupService.cancel(workspace.id, 'user-message');
         // Send to the running agent, or resume the agent with the PR prompt
         let messageSent = false;
         try {
@@ -4320,14 +4347,14 @@ app.post('/:id/start-review', async (c) => {
             baseCommit,
             additionalInstructions,
         });
-        try {
-            wakeupService.cancel(workspace.id, 'user-message');
-        }
-        catch {
-            /* swallow */
-        }
         let messageSent = false;
         let emitSessionId;
+        if (workspaceService.getWorkspace(workspace.id)?.status === 'compacting') {
+            return c.json({
+                code: 'compacting',
+                error: 'Workspace is compacting its context; wait until compaction finishes before sending a message',
+            }, 409);
+        }
         if (newSession) {
             // Stop current agent, wait for it, then start fresh.
             try {
@@ -4414,12 +4441,6 @@ app.post('/:id/start-ci-fix', migrationGuard, async (c) => {
             failedChecks,
             ciRunUrl,
         });
-        try {
-            wakeupService.cancel(workspace.id, 'user-message');
-        }
-        catch {
-            /* swallow */
-        }
         const session = workspaceService.getActiveSession(workspace.id);
         let emitSessionId = session?.id;
         try {

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

@@ -353,6 +353,7 @@ export function createClaudeCodeEngine() {
                         return;
                     console.warn(`[claude-engine] Compaction still reported active ${COMPACTION_STALL_TIMEOUT_MS}ms after it started — resuming the liveness deadline.`);
                     isCompacting = false;
+                    safeEmit({ kind: 'session:compacting', active: false });
                     reevaluateLivenessPause();
                     if (activeSubagentTaskIds.size > 0 && !subagentStallTimer) {
                         // Resume declined because a subagent is still tracked — but the
@@ -468,6 +469,16 @@ export function createClaudeCodeEngine() {
                                 clearCompactionStallTimer();
                             }
                         }
+                        // Actual foreground output proves work resumed even if the SDK
+                        // omitted its trailing status/compact_boundary message. Tool results
+                        // and background progress can drain during compaction, so exclude them.
+                        if (isCompacting &&
+                            !('parent_tool_use_id' in msg && msg.parent_tool_use_id != null) &&
+                            events.some((ev) => ev.kind === 'message:text' || ev.kind === 'message:thinking' || ev.kind === 'tool:call')) {
+                            isCompacting = false;
+                            clearCompactionStallTimer();
+                            safeEmit({ kind: 'session:compacting', active: false });
+                        }
                         for (const ev of events) {
                             if (ev.kind === 'tool:call')
                                 pendingToolCallIds.add(ev.toolCallId);

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

@@ -179,7 +179,7 @@ export function handleItemStarted(item, state) {
         return events;
     }
     if (item.type === 'contextCompaction') {
-        events.push({ kind: 'session:compacted' });
+        events.push({ kind: 'session:compacting', active: true });
         return events;
     }
     return events;
@@ -189,6 +189,8 @@ export function handleItemStarted(item, state) {
  */
 export function handleItemCompleted(item, state) {
     const events = [];
+    if (item.type === 'contextCompaction')
+        return [{ kind: 'session:compacted' }];
     if (item.type === 'agentMessage') {
         const text = item.text ?? '';
         const messageId = scopedId(state, item.id);

package/dist/server/services/agent/event-router.js

@@ -3,7 +3,7 @@ export function routeEvent(workspaceId, agentSessionId, event) {
     // The compaction "in progress" signal is a transient live indicator — deliver
     // it once and never persist/replay it. The persistent trace is `session:compacted`.
     if (event.kind === 'session:compacting') {
-        emitEphemeral(workspaceId, 'agent:event', event);
+        emitEphemeral(workspaceId, 'agent:event', event, agentSessionId);
         return;
     }
     if (event.kind === 'mcp:status' && event.status !== 'error') {

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

@@ -131,6 +131,25 @@ const pendingQueue = new Map();
  * returns to that status instead of being yanked to `executing`.
  */
 const preAwaitStatus = new Map();
+/** The lifecycle phase hidden by this controller's temporary compaction. */
+const preCompactionStatus = new Map();
+function finishCompaction(workspaceId, controller) {
+    const previous = preCompactionStatus.get(controller);
+    preCompactionStatus.delete(controller);
+    if (getWs(workspaceId)?.status !== 'compacting')
+        return;
+    const restored = peekPending(workspaceId)
+        ? 'awaiting-user'
+        : previous === 'awaiting-user'
+            ? consumePreAwaitStatus(workspaceId)
+            : (previous ?? 'executing');
+    updateWorkspaceStatus(workspaceId, restored);
+}
+export function assertWorkspaceNotCompacting(workspaceId) {
+    if (getWs(workspaceId)?.status === 'compacting') {
+        throw new Error('Workspace is compacting its context; wait until compaction finishes before sending a message');
+    }
+}
 function enqueuePending(workspaceId, item) {
     const arr = pendingQueue.get(workspaceId) ?? [];
     arr.push(item);
@@ -198,6 +217,13 @@ function rememberPreAwaitStatus(workspaceId) {
         return;
     if (ws.status === 'awaiting-user')
         return;
+    if (ws.status === 'compacting') {
+        const controller = controllers.get(workspaceId);
+        const previous = controller && preCompactionStatus.get(controller);
+        if (previous && previous !== 'awaiting-user')
+            preAwaitStatus.set(workspaceId, previous);
+        return;
+    }
     preAwaitStatus.set(workspaceId, ws.status);
 }
 /**
@@ -298,6 +324,7 @@ function runWatchdog() {
             controllers.delete(workspaceId);
             notifyCapacityAvailable(workspaceId);
         }
+        preCompactionStatus.delete(ctrl);
         retryCounts.delete(workspaceId);
         // This end never goes through handleEvent → onSessionEnded, so the user's
         // hook would otherwise miss precisely the case it is most useful for.
@@ -363,7 +390,7 @@ export function reconcileOrphanSessions() {
         const db = getDb();
         const result = db
             .prepare(`UPDATE workspaces SET status = 'idle', updated_at = ?
-          WHERE status IN ('executing', 'brainstorming', 'extracting', 'awaiting-user')`)
+          WHERE status IN ('executing', 'brainstorming', 'extracting', 'awaiting-user', 'compacting')`)
             .run(now);
         if (result.changes > 0) {
             console.log(`[orchestrator] Reconciled ${result.changes} orphan workspace status(es) at boot.`);
@@ -723,8 +750,24 @@ function handleEvent(workspaceId, agentSessionId, sourceController, ev) {
     // `awaiting-user`/`executing`. Every branch that does one of those must
     // check this guard.
     const sourceControllerIsStopping = sourceController?.status === 'stopping';
+    if (sourceControllerIsStopping && ev.kind === 'session:compacting')
+        return;
     const routedEvent = ev.kind === 'session:ended' && (hasReplacement || sourceIsSuperseded) ? { ...ev, superseded: true } : ev;
     routeEvent(workspaceId, agentSessionId, routedEvent);
+    if (sourceController && !sourceControllerIsStopping) {
+        if (ev.kind === 'session:compacting' && ev.active) {
+            const status = getWs(workspaceId)?.status;
+            if (status && ['extracting', 'brainstorming', 'executing', 'awaiting-user'].includes(status)) {
+                preCompactionStatus.set(sourceController, status);
+                updateWorkspaceStatus(workspaceId, 'compacting');
+            }
+        }
+        else if ((ev.kind === 'session:compacting' && !ev.active) ||
+            ev.kind === 'session:compacted' ||
+            ev.kind === 'error') {
+            finishCompaction(workspaceId, sourceController);
+        }
+    }
     // A fresh tool invocation proves this controller resumed working (for
     // example after an account change). Tool results can still drain after a
     // rejection, so they must never count as recovery.
@@ -815,7 +858,9 @@ function handleEvent(workspaceId, agentSessionId, sourceController, ev) {
     // nothing but this status transition (no separate bookkeeping to preserve),
     // so it is entirely behind the guard; the event itself is still
     // persisted/broadcast unconditionally via `routeEvent` above.
-    if (ev.kind === 'session:brainstorm-complete' && !sourceControllerIsStopping) {
+    if (ev.kind === 'session:brainstorm-complete' &&
+        !sourceControllerIsStopping &&
+        getWs(workspaceId)?.status !== 'compacting') {
         try {
             const ws = getWs(workspaceId);
             if (ws && ws.status !== 'executing') {
@@ -930,7 +975,8 @@ function handleEvent(workspaceId, agentSessionId, sourceController, ev) {
         }
         rememberPreAwaitStatus(workspaceId);
         try {
-            updateWorkspaceStatus(workspaceId, 'awaiting-user');
+            if (getWs(workspaceId)?.status !== 'compacting')
+                updateWorkspaceStatus(workspaceId, 'awaiting-user');
         }
         catch (err) {
             console.warn('[orchestrator] Failed to transition to awaiting-user:', err);
@@ -1007,6 +1053,8 @@ function onSessionEnded(workspaceId, agentSessionId, sourceController, exitCode,
     }
     const registeredController = controllers.get(workspaceId);
     const isSuperseded = sourceController !== undefined && registeredController !== undefined && registeredController !== sourceController;
+    if (sourceController)
+        preCompactionStatus.delete(sourceController);
     if (isSuperseded)
         return false;
     // A superseded end (above) is a session that was replaced, not one that
@@ -1093,6 +1141,7 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
     const workspace = getWs(workspaceId);
     if (!workspace)
         throw new Error(`Workspace '${workspaceId}' not found`);
+    assertWorkspaceNotCompacting(workspaceId);
     if (workspace.archivedAt)
         throw new Error(`Workspace '${workspaceId}' is archived`);
     if (workspace.worktreePurgedAt)
@@ -1272,6 +1321,7 @@ export function interruptAgent(workspaceId, options = {}) {
 export const STOP_AGENT_TIMEOUT_MS = 15_000;
 async function stopController(workspaceId, ctrl, cause = 'user') {
     ctrl.stopCause = cause;
+    preCompactionStatus.delete(ctrl);
     // Normalize the state synchronously so callers (archive, delete, manual
     // stop) see a clean workspace immediately — without waiting for the async
     // controller.stop() → session:ended round-trip, which onSessionEnded skips
@@ -1288,9 +1338,9 @@ async function stopController(workspaceId, ctrl, cause = 'user') {
     // Steps 1-2 are `awaiting-user`-specific: they only make sense when the
     // session actually left a pending question/permission behind.
     const wsBefore = getWs(workspaceId);
-    const activeStatuses = ['executing', 'brainstorming', 'extracting', 'awaiting-user'];
+    const activeStatuses = ['executing', 'brainstorming', 'extracting', 'awaiting-user', 'compacting'];
     if (wsBefore && activeStatuses.includes(wsBefore.status)) {
-        if (wsBefore.status === 'awaiting-user') {
+        if (wsBefore.status === 'awaiting-user' || wsBefore.status === 'compacting') {
             clearPendingForSession(workspaceId, ctrl.agentSessionId);
             purgeAllPersistedUserInputRequests(workspaceId, ctrl.agentSessionId);
         }
@@ -1432,7 +1482,7 @@ export function sendWakeupIfWaiting(workspaceId, content, expectedSessionId) {
     const workspace = getWs(workspaceId);
     if (!workspace || workspace.archivedAt || workspace.worktreePurgedAt)
         return false;
-    if (workspace.status === 'awaiting-user' || workspace.status === 'quota')
+    if (workspace.status === 'awaiting-user' || workspace.status === 'quota' || workspace.status === 'compacting')
         return false;
     if (!ctrl.engineProcess?.sendWakeupIfWaiting?.(content))
         return false;
@@ -1441,6 +1491,7 @@ export function sendWakeupIfWaiting(workspaceId, content, expectedSessionId) {
 }
 /** Write a user message to the running agent. */
 export async function sendMessage(workspaceId, content, expectedSessionId) {
+    assertWorkspaceNotCompacting(workspaceId);
     const ctrl = controllers.get(workspaceId);
     if (!ctrl) {
         throw new Error(`No agent running for workspace '${workspaceId}'`);
@@ -1452,15 +1503,17 @@ export async function sendMessage(workspaceId, content, expectedSessionId) {
     await ctrl.sendMessage(content);
 }
 export async function sendMessageForFallback(workspaceId, content) {
+    assertWorkspaceNotCompacting(workspaceId);
     const capturedController = controllers.get(workspaceId);
+    wakeupService.cancel(workspaceId, 'user-message');
     if (!capturedController)
         return { status: 'stopped' };
-    wakeupService.cancel(workspaceId, 'user-message');
     try {
         await capturedController.sendMessage(content);
         return { status: 'sent', sessionId: capturedController.agentSessionId };
     }
     catch {
+        assertWorkspaceNotCompacting(workspaceId);
         const deadline = Date.now() + FALLBACK_CONTROLLER_TURNOVER_TIMEOUT_MS;
         while (controllers.get(workspaceId) === capturedController) {
             const remaining = deadline - Date.now();
@@ -1474,6 +1527,7 @@ export async function sendMessageForFallback(workspaceId, content) {
         const replacementController = controllers.get(workspaceId);
         if (!replacementController)
             return { status: 'stopped' };
+        assertWorkspaceNotCompacting(workspaceId);
         await replacementController.sendMessage(content);
         return { status: 'sent', sessionId: replacementController.agentSessionId };
     }
@@ -1593,7 +1647,10 @@ export async function answerPendingQuestion(workspaceId, answers, expectedToolCa
     purgePersistedUserInputRequest(workspaceId, head.toolCallId);
     const restoreTo = peekPending(workspaceId) ? 'awaiting-user' : consumePreAwaitStatus(workspaceId);
     try {
-        updateWorkspaceStatus(workspaceId, restoreTo);
+        if (getWs(workspaceId)?.status === 'compacting')
+            preCompactionStatus.set(ctrl, restoreTo);
+        else
+            updateWorkspaceStatus(workspaceId, restoreTo);
     }
     catch (err) {
         console.warn(`[orchestrator] Failed to transition awaiting-user → ${restoreTo}:`, err);
@@ -1681,7 +1738,10 @@ export async function answerPendingPermission(workspaceId, decision) {
     purgePersistedUserInputRequest(workspaceId, head.toolCallId);
     const restoreTo = peekPending(workspaceId) ? 'awaiting-user' : consumePreAwaitStatus(workspaceId);
     try {
-        updateWorkspaceStatus(workspaceId, restoreTo);
+        if (getWs(workspaceId)?.status === 'compacting')
+            preCompactionStatus.set(ctrl, restoreTo);
+        else
+            updateWorkspaceStatus(workspaceId, restoreTo);
     }
     catch (err) {
         console.warn(`[orchestrator] Failed to transition awaiting-user → ${restoreTo}:`, err);
@@ -1739,7 +1799,10 @@ export async function cancelPendingQuestion(workspaceId, reason, expectedToolCal
     purgePersistedUserInputRequest(workspaceId, head.toolCallId);
     const restoreTo = peekPending(workspaceId) ? 'awaiting-user' : consumePreAwaitStatus(workspaceId);
     try {
-        updateWorkspaceStatus(workspaceId, restoreTo);
+        if (getWs(workspaceId)?.status === 'compacting')
+            preCompactionStatus.set(ctrl, restoreTo);
+        else
+            updateWorkspaceStatus(workspaceId, restoreTo);
     }
     catch (err) {
         console.warn(`[orchestrator] Failed to transition awaiting-user → ${restoreTo}:`, err);

package/dist/server/services/auto-loop-service.js

@@ -131,7 +131,7 @@ export function onSessionEnded(workspaceId, reason, taskProgressDelta) {
         return;
     // Don't spawn a competing session while paused on canUseTool — the user
     // will resume the deferred turn explicitly.
-    if (row.status === 'awaiting-user')
+    if (row.status === 'awaiting-user' || row.status === 'compacting')
         return;
     // A watchdog denotes Kōbō's own forced recovery from a stuck engine stream.
     // The orchestrator owns its bounded backoff/retry path; counting it as a
@@ -315,7 +315,7 @@ export function resumeWaitingWorkspaces(excluded = new Set()) {
             continue;
         // Same guards as spawnNextIteration's own callers: a quota backoff or a
         // pending question owns the next start of that workspace.
-        if (row.status === 'awaiting-user' || row.status === 'quota')
+        if (row.status === 'awaiting-user' || row.status === 'compacting' || row.status === 'quota')
             continue;
         try {
             spawnNextIteration(row.id);
@@ -337,7 +337,7 @@ function spawnNextIteration(workspaceId, opts = {}) {
     if (orchestrator.hasController(workspaceId))
         return;
     // Same guard as onSessionEnded — never race a deferred-resume start.
-    if (row.status === 'awaiting-user')
+    if (row.status === 'awaiting-user' || row.status === 'compacting')
         return;
     const task = pickNextTask(workspaceId);
     if (!task) {

package/dist/server/services/pr-watcher-service.js

@@ -226,7 +226,7 @@ export async function checkPrStatuses() {
                     });
                     prMergedHook = lifecycleHookService.onPrMerged(ws.id, { prNumber: pr.number, prUrl: pr.url });
                 }
-                if (['extracting', 'brainstorming', 'executing'].includes(ws.status) || hasController(ws.id)) {
+                if (['extracting', 'brainstorming', 'executing', 'compacting'].includes(ws.status) || hasController(ws.id)) {
                     // Agent is working — update the cache but skip auto-archive.
                     // (The defensive base preservation from the no-base branch doesn't apply here
                     // because we ARE in the OPEN→MERGED/CLOSED branch which always has a base.)
@@ -252,7 +252,9 @@ export async function checkPrStatuses() {
                 if (stale())
                     return;
                 const current = getWorkspace(ws.id);
-                if (!current || ['extracting', 'brainstorming', 'executing'].includes(current.status) || hasController(ws.id))
+                if (!current ||
+                    ['extracting', 'brainstorming', 'executing', 'compacting'].includes(current.status) ||
+                    hasController(ws.id))
                     return;
                 try {
                     destroyTerminal(ws.id);
@@ -320,7 +322,7 @@ export async function checkPrStatuses() {
                     emitEphemeral(ws.id, 'pr:merge-conflict', payload);
                     markUnread(ws.id);
                 }
-                const notBusy = !['extracting', 'brainstorming', 'executing'].includes(ws.status);
+                const notBusy = !['extracting', 'brainstorming', 'executing', 'compacting'].includes(ws.status);
                 if (notBusy && !prev.readyToMerge && pr.readyToMerge) {
                     emitEphemeral(ws.id, 'pr:ready-to-merge', payload);
                     markUnread(ws.id);

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

@@ -199,11 +199,19 @@ export function emit(workspaceId, type, payload, sessionId) {
  * Broadcast an event to subscribed clients WITHOUT persisting to the database.
  * Used for ephemeral status updates (e.g., dev-server status) that don't need replay.
  */
-export function emitEphemeral(workspaceId, type, payload) {
+export function emitEphemeral(workspaceId, type, payload, sessionId) {
     recordActivity(workspaceId, type, payload);
     const id = nanoid();
     const createdAt = new Date().toISOString();
-    const event = { id, workspaceId, type, payload, createdAt, replayable: false };
+    const event = {
+        id,
+        workspaceId,
+        type,
+        payload,
+        createdAt,
+        replayable: false,
+        ...(sessionId ? { sessionId } : {}),
+    };
     const message = JSON.stringify(event);
     let sendErrorLogged = false;
     for (const [ws, subs] of clients) {

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

@@ -16,10 +16,11 @@ const VALID_TRANSITIONS = {
     // workspace with a distinct brainstormModel silently lost its backoff: the
     // transition threw, the error was swallowed, and the very next lines
     // cancelled the timer that had just been armed.
-    extracting: ['extracting', 'brainstorming', 'idle', 'error', 'awaiting-user', 'quota'],
-    brainstorming: ['executing', 'completed', 'idle', 'error', 'awaiting-user', 'quota'],
-    executing: ['completed', 'idle', 'error', 'quota', 'awaiting-user'],
-    'awaiting-user': ['executing', 'brainstorming', 'extracting', 'idle', 'error', 'completed', 'quota'],
+    extracting: ['compacting', 'extracting', 'brainstorming', 'idle', 'error', 'awaiting-user', 'quota'],
+    brainstorming: ['compacting', 'executing', 'completed', 'idle', 'error', 'awaiting-user', 'quota'],
+    executing: ['compacting', 'completed', 'idle', 'error', 'quota', 'awaiting-user'],
+    'awaiting-user': ['compacting', 'executing', 'brainstorming', 'extracting', 'idle', 'error', 'completed', 'quota'],
+    compacting: ['extracting', 'brainstorming', 'executing', 'awaiting-user', 'completed', 'idle', 'error', 'quota'],
     completed: ['idle', 'executing'],
     idle: ['executing', 'brainstorming', 'extracting', 'error'],
     error: ['idle', 'executing', 'brainstorming', 'extracting'],
@@ -196,6 +197,9 @@ export function updateWorkspaceStatus(id, status) {
     }
     const now = new Date().toISOString();
     db.prepare('UPDATE workspaces SET status = ?, updated_at = ? WHERE id = ?').run(status, now, id);
+    if (status === 'compacting' || workspace.status === 'compacting') {
+        emitEphemeral(id, 'workspace:status', { status });
+    }
     return getWorkspace(id);
 }
 const WORKSPACE_NAME_MAX_LENGTH = 200;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loicngr/kobo",
-  "version": "1.11.37",
+  "version": "1.11.39",
   "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",
@@ -68,7 +68,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.252",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.267",
     "@emnapi/core": "^1.11.3",
     "@emnapi/runtime": "^1.11.3",
     "@hono/node-server": "^2.1.0",