@loicngr/kobo 1.11.26 → 1.11.27

package/CHANGELOG.md

@@ -4,6 +4,10 @@ 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.27
+
+- fix: session watchdog false-positives, sync drain, and terminal leaks, audit npm
+
 ## 1.11.26
 
 - fix(client): resume the interrupted session on manual quota resume

package/dist/server/routes/workspaces.js

@@ -1821,13 +1821,18 @@ app.delete('/:id/events/:eventId', (c) => {
         const db = getDb();
         // Capture the session BEFORE deleting: since v36 there is no AFTER DELETE
         // trigger, so the metrics of that session must be recomputed once, here.
-        const row = db
-            .prepare('SELECT session_id FROM ws_events WHERE id = ? AND workspace_id = ?')
-            .get(eventId, workspaceId);
-        db.prepare('DELETE FROM ws_events WHERE id = ? AND workspace_id = ?').run(eventId, workspaceId);
-        if (row?.session_id) {
-            workspaceService.recomputeSessionMetrics(workspaceId, row.session_id);
-        }
+        // Transactional for the same reason deleteSession is: a crash between the
+        // delete and the recompute must not leave stale metrics behind.
+        const transaction = db.transaction(() => {
+            const row = db
+                .prepare('SELECT session_id FROM ws_events WHERE id = ? AND workspace_id = ?')
+                .get(eventId, workspaceId);
+            db.prepare('DELETE FROM ws_events WHERE id = ? AND workspace_id = ?').run(eventId, workspaceId);
+            if (row?.session_id) {
+                workspaceService.recomputeSessionMetrics(workspaceId, row.session_id);
+            }
+        });
+        transaction();
         return c.json({ ok: true });
     }
     catch (err) {
@@ -1992,6 +1997,10 @@ app.post('/:id/tasks/:taskId/notify-done', (c) => {
         return c.json({ error: message }, 500);
     }
 });
+// Cap how many recent rows one search may scan: the LIKE below cannot use an
+// index past the workspace_id prefix, and better-sqlite3 is synchronous — an
+// unbounded scan of a months-old workspace blocks every request and WS emit.
+const HISTORY_SEARCH_SCAN_CAP = 20_000;
 // GET /api/workspaces/:id/history-search — full-workspace persisted conversation search.
 app.get('/:id/history-search', (c) => {
     try {
@@ -2004,10 +2013,13 @@ app.get('/:id/history-search', (c) => {
         const limit = Math.min(parseInt(c.req.query('limit') ?? '30', 10) || 30, 100);
         const needle = `%${query.replace(/[%_]/g, '\\$&')}%`;
         const rows = getDb()
-            .prepare(`SELECT id, session_id, type, payload, created_at FROM ws_events
-         WHERE workspace_id = ? AND payload LIKE ? ESCAPE '\\'
-         ORDER BY rowid DESC LIMIT ?`)
-            .all(id, needle, limit * 4);
+            .prepare(`SELECT id, session_id, type, payload, created_at FROM (
+           SELECT rowid AS rid, id, session_id, type, payload, created_at FROM ws_events
+           WHERE workspace_id = ? ORDER BY rowid DESC LIMIT ?
+         )
+         WHERE payload LIKE ? ESCAPE '\\'
+         ORDER BY rid DESC LIMIT ?`)
+            .all(id, HISTORY_SEARCH_SCAN_CAP, needle, limit * 4);
         const normalized = rows.flatMap((row) => {
             const result = readableHistorySearchResult(row.type, row.payload, query);
             if (!result)
@@ -2866,6 +2878,11 @@ async function deleteWorkspaceWithSideEffects(workspace, opts) {
     }
     // Delete workspace from DB (cascades to tasks, sessions, events)
     workspaceService.deleteWorkspace(workspace.id);
+    // Announce the deletion so any other tab with this workspace open (or a
+    // live terminal attached to it) can react — mirrors workspace:archived's
+    // cross-tab-sync purpose. Ephemeral: a deleted workspace has no future
+    // ws_events history to replay, so persisting this would be pointless.
+    wsService.emitEphemeral(workspace.id, 'workspace:deleted', { workspaceId: workspace.id });
     return warnings;
 }
 // DELETE /api/workspaces/archived — bulk-delete every archived workspace.

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

@@ -17,7 +17,7 @@ import { buildStopHookOutput } from './stop-hook.js';
  * post-result drain watchdog force-emits `session:ended` so the orchestrator
  * and auto-loop are not frozen forever.
  */
-const RESULT_DRAIN_TIMEOUT_MS = 15_000;
+export const RESULT_DRAIN_TIMEOUT_MS = 15_000;
 /**
  * Deadline for a stream that stops reporting ANY activity. The former
  * text-only guard was re-armed solely on a message with text and no tool call
@@ -26,12 +26,23 @@ const RESULT_DRAIN_TIMEOUT_MS = 15_000;
  * forever with zero trace. Exported so tests never hard-code the value.
  */
 export const CLAUDE_STREAM_IDLE_TIMEOUT_MS = 120_000;
+/**
+ * Idle ceiling while a FOREGROUND tool call is in flight (tool:call seen, no
+ * tool:result yet). A long Bash run — a test suite, a CI-poll sleep — emits no
+ * SDK message until its tool_result, so the short deadline would kill a
+ * healthy session mid-tool (the "random session stops" bug). A genuinely dead
+ * stream is still reaped once this longer ceiling elapses.
+ */
+export const CLAUDE_TOOL_IDLE_TIMEOUT_MS = 30 * 60_000;
+/** Ceiling on a context compaction: past this, assume it wedged and let the
+ *  liveness deadline take over instead of pausing forever. */
+export const COMPACTION_STALL_TIMEOUT_MS = 10 * 60_000;
 // Safety net for a subagent whose terminal `task_notification` carries a
 // status outside the mapper's known-terminal set (SDK schema drift) — it
 // never clears `activeSubagentToolCallIds`, which otherwise blocks
 // `inputStream.close()`/the result-drain watchdog forever. Generous window:
 // legitimate subagents can run for several minutes.
-const SUBAGENT_STALL_TIMEOUT_MS = 10 * 60_000;
+export const SUBAGENT_STALL_TIMEOUT_MS = 10 * 60_000;
 const MAX_PENDING_USER_MESSAGES = 20;
 function toMcpServersMap(specs) {
     if (!specs || specs.length === 0)
@@ -106,6 +117,9 @@ export function createClaudeCodeEngine() {
             // UI/tool ids can differ from the SDK task id. Key by the stable UI id
             // so a terminal notification that omits task_id still clears the task.
             const activeSubagentTaskIds = new Map();
+            // Foreground tool calls currently awaiting their tool_result. Cleared on
+            // every `result` message: a turn cannot end with a tool still in flight.
+            const pendingToolCallIds = new Set();
             // Pending canUseTool callbacks, keyed by SDK ctx.toolUseID.
             const pendingResolvers = new Map();
             const isInteractive = options.agentPermissionMode === 'interactive';
@@ -283,16 +297,74 @@ export function createClaudeCodeEngine() {
             const turnLiveness = createTurnLiveness({
                 timeoutMs: CLAUDE_STREAM_IDLE_TIMEOUT_MS,
                 onTimeout() {
-                    console.warn(`[claude-engine] SDK stream reported no activity for ${CLAUDE_STREAM_IDLE_TIMEOUT_MS}ms — forcing session:ended`);
+                    // The armed deadline tracks whether a foreground tool call is in
+                    // flight (see `turnLiveness.setTimeoutMs` below) — log the duration
+                    // that actually elapsed, not always the shorter baseline, so the
+                    // watchdog's own diagnostic message stays trustworthy.
+                    const timeoutMs = pendingToolCallIds.size > 0 ? CLAUDE_TOOL_IDLE_TIMEOUT_MS : CLAUDE_STREAM_IDLE_TIMEOUT_MS;
+                    console.warn(`[claude-engine] SDK stream reported no activity for ${timeoutMs}ms — forcing session:ended`);
                     if (userInterrupted)
                         emitSessionEnded('killed', null);
                     else if (mapperState.sawErrorResult)
                         emitSessionEnded('error', null);
-                    else
+                    else {
+                        safeEmit({
+                            kind: 'error',
+                            category: 'other',
+                            message: 'Session force-ended by the liveness watchdog: no SDK activity within the deadline. If the agent was legitimately busy, this is a bug worth reporting.',
+                        });
                         emitSessionEnded('watchdog', null);
+                    }
                     abortController.abort();
                 },
             });
+            // The single source of truth for "should the idle deadline be paused
+            // right now" — a background subagent, a pending permission/question
+            // card, or an in-progress compaction can each legitimately keep the
+            // stream quiet for minutes; their own dedicated watchdogs own those
+            // windows. Every call site that changes one of these three conditions
+            // must re-evaluate through this helper, not duplicate the check.
+            const reevaluateLivenessPause = () => {
+                if (activeSubagentTaskIds.size > 0 || pendingResolvers.size > 0 || isCompacting)
+                    turnLiveness.pause();
+                else
+                    turnLiveness.resume();
+            };
+            // Backstop for a compaction that never reports completion (stuck
+            // `session:compacting` with `active: true` forever): `isCompacting`
+            // pauses `turnLiveness` indefinitely, and a wedged-but-alive generator
+            // never trips `isAlive()`'s own sweep either. Past this ceiling, assume
+            // it wedged and resume the liveness deadline so the existing tool-aware
+            // / short deadline can reap it, mirroring `armSubagentStallWatchdog`.
+            let compactionStallTimer;
+            const clearCompactionStallTimer = () => {
+                if (!compactionStallTimer)
+                    return;
+                clearTimeout(compactionStallTimer);
+                compactionStallTimer = undefined;
+            };
+            const armCompactionStallTimer = () => {
+                clearCompactionStallTimer();
+                compactionStallTimer = setTimeout(() => {
+                    compactionStallTimer = undefined;
+                    if (!isCompacting)
+                        return;
+                    console.warn(`[claude-engine] Compaction still reported active ${COMPACTION_STALL_TIMEOUT_MS}ms after it started — resuming the liveness deadline.`);
+                    isCompacting = false;
+                    reevaluateLivenessPause();
+                    if (activeSubagentTaskIds.size > 0 && !subagentStallTimer) {
+                        // Resume declined because a subagent is still tracked — but the
+                        // subagent stall net is only armed from the `result` branch, which
+                        // a fully wedged generator may never reach. Arm it here as a
+                        // second stage so this combination can't hang forever. The
+                        // `!subagentStallTimer` guard matters: arming re-sets the
+                        // deadline, and a net already armed by a prior `result` must not
+                        // be extended by this backstop (it is not new activity).
+                        armSubagentStallWatchdog();
+                    }
+                }, COMPACTION_STALL_TIMEOUT_MS);
+                compactionStallTimer.unref?.();
+            };
             const armResultDrainWatchdog = () => {
                 if (resultDrainTimer)
                     return;
@@ -302,8 +374,14 @@ export function createClaudeCodeEngine() {
                         emitSessionEnded('killed', null);
                     else if (mapperState.sawErrorResult)
                         emitSessionEnded('error', null);
-                    else
+                    else {
+                        safeEmit({
+                            kind: 'error',
+                            category: 'other',
+                            message: 'Session force-ended: the SDK generator stayed open after its final result (drain watchdog).',
+                        });
                         emitSessionEnded('watchdog', null);
+                    }
                     abortController.abort();
                 }, RESULT_DRAIN_TIMEOUT_MS);
                 resultDrainTimer.unref?.();
@@ -369,12 +447,25 @@ export function createClaudeCodeEngine() {
                                 activeSubagentTaskIds.delete(ev.toolCallId);
                         }
                         for (const ev of events) {
-                            if (ev.kind === 'session:compacting')
+                            if (ev.kind === 'session:compacting') {
                                 isCompacting = ev.active;
+                                if (ev.active)
+                                    armCompactionStallTimer();
+                                else
+                                    clearCompactionStallTimer();
+                            }
                             // Older SDKs can emit only compact_boundary, without a trailing
                             // status update. This boundary marks compaction as complete.
-                            else if (ev.kind === 'session:compacted')
+                            else if (ev.kind === 'session:compacted') {
                                 isCompacting = false;
+                                clearCompactionStallTimer();
+                            }
+                        }
+                        for (const ev of events) {
+                            if (ev.kind === 'tool:call')
+                                pendingToolCallIds.add(ev.toolCallId);
+                            else if (ev.kind === 'tool:result')
+                                pendingToolCallIds.delete(ev.toolCallId);
                         }
                         // The stall watchdog is only armed while we're waiting purely on
                         // background subagents (no further SDK turn expected unless one
@@ -398,11 +489,12 @@ export function createClaudeCodeEngine() {
                         // A background subagent or a pending permission card can stay
                         // legitimately quiet for minutes; their own dedicated watchdogs
                         // own those windows, so suspend the turn deadline meanwhile.
-                        if (activeSubagentTaskIds.size > 0 || pendingResolvers.size > 0 || isCompacting)
-                            turnLiveness.pause();
-                        else
-                            turnLiveness.resume();
+                        // A FOREGROUND tool call in flight keeps the deadline armed but
+                        // stretched to the tool-aware ceiling.
+                        turnLiveness.setTimeoutMs(pendingToolCallIds.size > 0 ? CLAUDE_TOOL_IDLE_TIMEOUT_MS : CLAUDE_STREAM_IDLE_TIMEOUT_MS);
+                        reevaluateLivenessPause();
                         if (msg.type === 'result') {
+                            pendingToolCallIds.clear();
                             completedResponses++;
                             emitTurnCompletedIfSettled();
                             // A queued forced message starts the next response on this same SDK stream.
@@ -457,6 +549,7 @@ export function createClaudeCodeEngine() {
                     clearResultDrainWatchdog();
                     turnLiveness.stop();
                     clearSubagentStallWatchdog();
+                    clearCompactionStallTimer();
                     // Drain any callback still pending (SDK terminated while awaiting an
                     // answer). canUseTool's abort path covers signalled stops; this
                     // covers natural iterator completion.
@@ -541,10 +634,11 @@ export function createClaudeCodeEngine() {
                     if (!resolver)
                         return false;
                     pendingResolvers.delete(toolCallId);
-                    // Only resume the deadline once every outstanding card is answered —
-                    // a sibling request may still be waiting on a human.
-                    if (pendingResolvers.size === 0)
-                        turnLiveness.resume();
+                    // Re-evaluate rather than unconditionally resuming: a sibling
+                    // request, a still-active subagent, or an in-progress compaction
+                    // may each still have their own legitimate reason to keep the
+                    // deadline paused.
+                    reevaluateLivenessPause();
                     if (response.kind === 'question') {
                         // Echo the original questions array + answers so the SDK
                         // reconstructs the AskUserQuestion tool input.

package/dist/server/services/agent/engines/codex/server-requests.js

@@ -67,14 +67,11 @@ export function handleServerRequest(args) {
         return true;
     }
     if (method === 'item/permissions/requestApproval') {
-        register(callId, { requestId, kind: 'permissions', payload: p });
-        emit({
-            kind: 'session:user-input-requested',
-            requestKind: 'permission',
-            toolCallId: callId,
-            toolName: 'Permissions',
-            payload: p,
-        });
+        // Kōbō doesn't model granular permission grants: the only answer we can
+        // send is the empty grant (Codex then falls back to the turn policy), so
+        // an Allow/Deny card would be a lie — "Allow" and "Deny" produced the
+        // same decline. Answer immediately and keep the session moving.
+        respond?.(requestId, { permissions: {}, scope: 'turn' });
         return true;
     }
     return false; // unknown method
@@ -87,12 +84,6 @@ export function handleServerRequest(args) {
  * (and the matching `FileChangeApprovalDecision`): `'accept' | 'acceptForSession' | 'decline' | 'cancel'`.
  * NOT `'approve' / 'reject'` — those would be silently rejected as unknown
  * variants, which breaks the strict and interactive permission modes.
- *
- * `PermissionsRequestApprovalResponse` has a completely different shape:
- * `{ permissions, scope, strictAutoReview? }` — no `decision` field. Since
- * Kōbō doesn't yet model permission grants, we deny the request by sending
- * an empty permissions response. A future iteration could add a UI for
- * granular permission grants.
  */
 export function buildResponseForResolve(pending, response) {
     if (pending.kind === 'command' || pending.kind === 'file_change') {
@@ -100,12 +91,6 @@ export function buildResponseForResolve(pending, response) {
             return { decision: 'accept' };
         return { decision: 'decline' };
     }
-    if (pending.kind === 'permissions') {
-        // Codex's PermissionsRequestApprovalResponse shape — not { decision }.
-        // We don't yet model granular permission grants, so deny by returning an
-        // empty permissions object; Codex falls back to the existing turn policy.
-        return { permissions: {}, scope: 'turn' };
-    }
     if (pending.kind === 'user_input') {
         if (response.kind === 'question') {
             const answers = {};

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

@@ -957,7 +957,16 @@ function onSessionEnded(workspaceId, agentSessionId, sourceController, exitCode,
     // `reason` is authoritative (with the SDK engine `exitCode` is often null,
     // so reason='error'+exitCode=null would otherwise map wrongly to 'completed').
     // `resumeFailed` is benign: stale id cleared, next iteration starts fresh.
-    const isErrorOutcome = !resumeFailed && (reason === 'error' || (exitCode !== null && exitCode !== 0));
+    // 'watchdog' is a forced kill, never a success. For an auto-loop workspace,
+    // handleTransientAutoLoopFailure (called above, before onSessionEnded) runs
+    // synchronously up to its first await and writes status 'quota' as its very
+    // first statement — that write lands before `currentWorkspace` is read above
+    // (line ~1144), so `preserveQuotaBackoff` is already true and this function
+    // returns early at the `if (preserveQuotaBackoff) return true` branch above.
+    // This computation is therefore never reached at all for that path, not
+    // merely short-circuited afterwards — it only runs on session ends that
+    // don't go through the auto-loop transient-failure path.
+    const isErrorOutcome = !resumeFailed && (reason === 'error' || reason === 'watchdog' || (exitCode !== null && exitCode !== 0));
     const targetStatus = isErrorOutcome ? 'error' : 'completed';
     // Skip the transition when the workspace is already in a terminal state.
     // This happens when stopAgent (or an equivalent caller) synchronously
@@ -1801,6 +1810,10 @@ async function handleQuota(workspaceId, _agentSessionId) {
     // 'agent:quota-backoff' WS emit. Hand off everything to it.
     quotaBackoffService.arm(workspaceId, delayMs, { resetsAt: resetsAt ?? null, source, reason: 'quota' });
 }
+/** First retry after a transient failure (watchdog recovery, HTTP 500). The
+ *  quota ladder's 15-minute floor is tuned for real quota windows — a forced
+ *  kill or a server blip deserves a much faster first attempt. */
+const TRANSIENT_FIRST_RETRY_MS = 2 * 60_000;
 /**
  * Use the same persisted retry path for temporary upstream failures (HTTP 500
  * and overloads) while deliberately ignoring quota-reset data: a server error
@@ -1826,8 +1839,9 @@ async function handleTransientAutoLoopFailure(workspaceId) {
         return;
     }
     const { delayMs, resetsAt, source } = await computeQuotaBackoffMs(workspaceId, retryCount, false);
+    const effectiveDelayMs = retryCount === 0 ? Math.min(delayMs, TRANSIENT_FIRST_RETRY_MS) : delayMs;
     retryCounts.set(workspaceId, retryCount + 1);
-    quotaBackoffService.arm(workspaceId, delayMs, { resetsAt: resetsAt ?? null, source, reason: 'transient' });
+    quotaBackoffService.arm(workspaceId, effectiveDelayMs, { resetsAt: resetsAt ?? null, source, reason: 'transient' });
 }
 /** @internal test-only — re-export of `handleQuota` for direct testing. */
 export const _handleQuota = handleQuota;

package/dist/server/services/agent/streaming-batcher.js

@@ -19,6 +19,7 @@ export function createStreamingBatcher(emit, options = {}) {
                     return;
                 }
                 const timer = setTimeout(() => flush(event.messageId), windowMs);
+                timer.unref?.();
                 pending.set(event.messageId, { text: event.text, timer });
                 return;
             }

package/dist/server/services/agent/turn-liveness.js

@@ -11,6 +11,7 @@ export function createTurnLiveness(input) {
     let active = false;
     let paused = false;
     let timedOut = false;
+    let currentTimeoutMs = input.timeoutMs;
     const arm = () => {
         if (!active || paused || timedOut)
             return;
@@ -22,7 +23,8 @@ export function createTurnLiveness(input) {
                 return;
             timedOut = true;
             input.onTimeout();
-        }, input.timeoutMs);
+        }, currentTimeoutMs);
+        timer.unref?.();
     };
     return {
         start() {
@@ -53,5 +55,14 @@ export function createTurnLiveness(input) {
                 clearTimeout(timer);
             timer = undefined;
         },
+        setTimeoutMs(ms) {
+            if (ms === currentTimeoutMs)
+                return;
+            currentTimeoutMs = ms;
+            // Re-arm only if a deadline is currently pending; a paused/stopped
+            // liveness picks the new duration up on its next arm().
+            if (timer)
+                arm();
+        },
     };
 }

package/dist/server/services/file-editor-service.js

@@ -1,7 +1,6 @@
 import { createHash } from 'node:crypto';
-import { realpathSync } from 'node:fs';
-import * as path from 'node:path';
 import { getFileContent, writeFileInWorktree } from '../utils/git-ops.js';
+import { resolvePathInside } from '../utils/safe-path.js';
 const MAX_FILE_BYTES = 1024 * 1024;
 export function shaOf(content) {
     return createHash('sha256').update(content, 'utf8').digest('hex');
@@ -12,7 +11,7 @@ export function shaOf(content) {
  * escapes the worktree (including via symlinks), or when content exceeds 1 MB.
  */
 export function saveWorkspaceFile(worktreePath, relativePath, content, baseSha) {
-    const absPath = resolveSafe(worktreePath, relativePath);
+    const absPath = resolvePathInside(worktreePath, relativePath);
     if (Buffer.byteLength(content, 'utf8') > MAX_FILE_BYTES) {
         throw new Error(`File too large (max ${MAX_FILE_BYTES / 1024 / 1024} MB)`);
     }
@@ -24,46 +23,3 @@ export function saveWorkspaceFile(worktreePath, relativePath, content, baseSha)
     writeFileInWorktree(absPath, content);
     return { status: 'saved' };
 }
-function resolveSafe(worktreePath, relativePath) {
-    const abs = path.resolve(worktreePath, relativePath);
-    const lexicalRoot = path.resolve(worktreePath);
-    // Lexical containment check FIRST: a path that escapes the worktree via `..`
-    // (or an absolute path) must be reported as an escape deterministically —
-    // independent of whether the traversal happens to land on a directory that
-    // exists on disk. Without this, `../../etc/passwd` surfaces as "parent
-    // directory does not exist" instead of "escapes the worktree" whenever the
-    // worktree sits deep enough that the `..` chain lands on a missing dir.
-    if (abs !== lexicalRoot && !abs.startsWith(lexicalRoot + path.sep)) {
-        throw new Error(`Path '${relativePath}' escapes the worktree`);
-    }
-    const root = realpathSync(lexicalRoot);
-    const rootWithSep = root + path.sep;
-    // Resolve the parent's realpath (parent must exist; if it doesn't, the path
-    // is invalid anyway and we surface that). Then join the lexical basename so
-    // a non-existent leaf doesn't trigger ENOENT.
-    let realParent;
-    try {
-        realParent = realpathSync(path.dirname(abs));
-    }
-    catch {
-        throw new Error(`Path '${relativePath}' is invalid (parent directory does not exist)`);
-    }
-    const realAbs = path.join(realParent, path.basename(abs));
-    if (realAbs !== root && !realAbs.startsWith(rootWithSep)) {
-        throw new Error(`Path '${relativePath}' escapes the worktree`);
-    }
-    // If the leaf exists and is itself a symlink, follow it and re-check
-    // containment so we never write through a symlink that escapes the worktree.
-    try {
-        const leafReal = realpathSync(realAbs);
-        if (leafReal !== root && !leafReal.startsWith(rootWithSep)) {
-            throw new Error(`Path '${relativePath}' escapes the worktree`);
-        }
-        return leafReal;
-    }
-    catch (err) {
-        if (err.code === 'ENOENT')
-            return realAbs;
-        throw err;
-    }
-}

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

@@ -1,6 +1,7 @@
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { getGlobalSettings } from '../../settings-service.js';
+import { parseCliJson } from '../parse-cli-json.js';
 import { deriveReadyToMerge } from '../types.js';
 const execFileAsync = promisify(execFile);
 function record(value) {
@@ -233,14 +234,14 @@ async function resolveTarget(repoPath) {
     if (bktEnv().BKT_TOKEN)
         return { ...target, context: null };
     const { stdout: contextOutput } = await execFileAsync('bkt', ['context', 'list', '--json'], bktOptions(repoPath));
-    const contexts = record(JSON.parse(contextOutput)).contexts;
+    const contexts = record(parseCliJson(contextOutput, 'bkt context list')).contexts;
     const existing = (Array.isArray(contexts) ? contexts : [])
         .map(record)
         .find((context) => string(context.workspace) === target.workspace && string(context.default_repo) === target.repo);
     if (existing && string(existing.name))
         return { ...target, context: string(existing.name) };
     const { stdout: authOutput } = await execFileAsync('bkt', ['auth', 'status', '--json'], bktOptions(repoPath));
-    const hosts = record(JSON.parse(authOutput)).hosts;
+    const hosts = record(parseCliJson(authOutput, 'bkt auth status')).hosts;
     const host = (Array.isArray(hosts) ? hosts : []).map(record).find((item) => string(item.kind) === 'cloud');
     const hostKey = string(host?.key);
     if (!hostKey)
@@ -255,7 +256,7 @@ function targetArgs(target) {
 async function fetchCi(repoPath, number, target) {
     try {
         const { stdout } = await execFileAsync('bkt', bktArgs(target, ['pr', 'checks', String(number), ...targetArgs(target), '--json']), bktOptions(repoPath));
-        const statuses = record(JSON.parse(stdout)).statuses;
+        const statuses = record(parseCliJson(stdout, 'bkt pr checks')).statuses;
         const checks = (Array.isArray(statuses) ? statuses : []).map(mapCheck);
         const rollup = checks.length === 0
             ? null
@@ -286,7 +287,7 @@ export const bitbucketProvider = {
     async isAvailable(repoPath) {
         try {
             const { stdout } = await execFileAsync('bkt', ['auth', 'status', '--json'], bktOptions(repoPath));
-            const status = record(JSON.parse(stdout));
+            const status = record(parseCliJson(stdout, 'bkt auth status'));
             const hosts = status.hosts;
             if ((Array.isArray(hosts) && hosts.length > 0) || bktEnv().BKT_TOKEN)
                 return { available: true };
@@ -304,7 +305,7 @@ export const bitbucketProvider = {
             // branch deletion, so do not stop at OPEN requests.
             for (const state of ['OPEN', 'MERGED', 'DECLINED']) {
                 const { stdout: listOutput } = await execFileAsync('bkt', bktArgs(target, ['pr', 'list', '--state', state, '--limit', '50', ...targetArgs(target), '--json']), bktOptions(repoPath));
-                const pullRequests = record(JSON.parse(listOutput)).pull_requests;
+                const pullRequests = record(parseCliJson(listOutput, 'bkt pr list')).pull_requests;
                 match = (Array.isArray(pullRequests) ? pullRequests : [])
                     .map(record)
                     .find((pullRequest) => branch(pullRequest, 'source', 'fromRef') === branchName);
@@ -314,7 +315,7 @@ export const bitbucketProvider = {
             if (!match)
                 return null;
             const { stdout: viewOutput } = await execFileAsync('bkt', bktArgs(target, ['pr', 'view', String(number(match.id)), ...targetArgs(target), '--json']), bktOptions(repoPath));
-            const raw = record(record(JSON.parse(viewOutput)).pull_request);
+            const raw = record(record(parseCliJson(viewOutput, 'bkt pr view')).pull_request);
             if (!number(raw.id))
                 return null;
             const ci = await fetchCi(repoPath, number(raw.id), target);
@@ -340,7 +341,7 @@ export const bitbucketProvider = {
             ...targetArgs(target),
             '--json',
         ]), bktOptions(repoPath));
-        const raw = record(JSON.parse(stdout));
+        const raw = record(parseCliJson(stdout, 'bkt pr create'));
         const prNumber = number(raw.id);
         const prUrl = string(raw.url);
         if (!prNumber || !prUrl)
@@ -363,7 +364,7 @@ export const bitbucketProvider = {
         if (opts.cursor)
             args.push('--page', opts.cursor);
         const { stdout } = await execFileAsync('bkt', bktArgs(target, args), bktOptions(repoPath));
-        const page = mapBitbucketPage(JSON.parse(stdout || '{}'));
+        const page = mapBitbucketPage(parseCliJson(stdout || '{}', 'bkt pr list'));
         if (opts.filter === 'all' && !opts.search?.trim())
             return page;
         const currentUser = getGlobalSettings().bitbucketUsername || undefined;

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

@@ -1,6 +1,7 @@
 // src/server/services/forge/github/provider.ts
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
+import { parseCliJson } from '../parse-cli-json.js';
 import { deriveReadyToMerge } from '../types.js';
 const execFileAsync = promisify(execFile);
 const CLI_TIMEOUT_MS = 30_000;
@@ -174,7 +175,7 @@ export const githubProvider = {
             const raw = stdout.trim();
             if (!raw)
                 return null;
-            return mapGhPrToSnapshot(JSON.parse(raw));
+            return mapGhPrToSnapshot(parseCliJson(raw, 'gh pr view'));
         }
         catch {
             return null;
@@ -198,7 +199,7 @@ export const githubProvider = {
     },
     async listPullRequests(repoPath, opts) {
         const { stdout: repoJson } = await execFileAsync('gh', ['repo', 'view', '--json', 'nameWithOwner'], cliOptions(repoPath));
-        const nameWithOwner = String(JSON.parse(repoJson).nameWithOwner ?? '');
+        const nameWithOwner = String(parseCliJson(repoJson, 'gh repo view').nameWithOwner ?? '');
         if (!nameWithOwner)
             throw new Error('Could not determine the GitHub repository for this path');
         const args = [
@@ -214,6 +215,6 @@ export const githubProvider = {
         if (opts.cursor)
             args.push('-f', `after=${opts.cursor}`);
         const { stdout } = await execFileAsync('gh', args, cliOptions(repoPath));
-        return mapGithubSearchPage(JSON.parse(stdout));
+        return mapGithubSearchPage(parseCliJson(stdout, 'gh api graphql (list PRs)'));
     },
 };

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

@@ -1,6 +1,7 @@
 // src/server/services/forge/gitlab/provider.ts
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
+import { parseCliJson } from '../parse-cli-json.js';
 import { deriveReadyToMerge } from '../types.js';
 const execFileAsync = promisify(execFile);
 const CLI_TIMEOUT_MS = 30_000;
@@ -108,7 +109,7 @@ async function fetchGlabCi(repoPath, branch) {
         const raw = stdout.trim();
         if (!raw)
             return { rollup: null, checks: [] };
-        const pipeline = JSON.parse(raw);
+        const pipeline = parseCliJson(raw, 'glab ci get');
         return {
             rollup: mapPipelineRollup(pipeline.status),
             checks: (pipeline.jobs ?? []).map(mapGlabJobToCheck),
@@ -192,7 +193,7 @@ export const gitlabProvider = {
             const raw = stdout.trim();
             if (!raw)
                 return null;
-            const snapshot = mapGlabMrToSnapshot(JSON.parse(raw));
+            const snapshot = mapGlabMrToSnapshot(parseCliJson(raw, 'glab mr view'));
             snapshot.ci = await fetchGlabCi(repoPath, branch);
             snapshot.readyToMerge = deriveReadyToMerge(snapshot);
             return snapshot;
@@ -231,6 +232,6 @@ export const gitlabProvider = {
     },
     async listPullRequests(repoPath, opts) {
         const { stdout } = await execFileAsync('glab', buildGitlabListArgs(opts), cliOptions(repoPath));
-        return mapGitlabPage(JSON.parse(stdout || '[]'), opts);
+        return mapGitlabPage(parseCliJson(stdout || '[]', 'glab mr list'), opts);
     },
 };

package/dist/server/services/forge/parse-cli-json.js

@@ -0,0 +1,14 @@
+/** JSON.parse with a message a user can act on: a truncated or non-JSON CLI
+ *  response otherwise surfaces as a raw "Unexpected token…" 500. */
+export function parseCliJson(raw, context) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        // Keep the diagnostic trail: the user-facing message stays terse, but the
+        // original parse error and a sample of the offending output land in the
+        // server log so "unparsable output" reports can actually be investigated.
+        console.error(`[forge] ${context} returned unparsable output:`, err, raw.slice(0, 200));
+        throw new Error(`${context} returned unparsable output`);
+    }
+}