@loicngr/kobo 1.11.39 → 1.11.41

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

@@ -142,6 +142,7 @@ export function createClaudeCodeEngine() {
                     // A user decision is intentional inactivity — suspend the deadline
                     // rather than cancel it, so it resumes the moment the card is answered.
                     turnLiveness.pause();
+                    clearSubagentStallWatchdog();
                     const onAbort = () => {
                         if (pendingResolvers.get(toolCallId) === resolver) {
                             pendingResolvers.delete(toolCallId);
@@ -327,6 +328,10 @@ export function createClaudeCodeEngine() {
             // windows. Every call site that changes one of these three conditions
             // must re-evaluate through this helper, not duplicate the check.
             const reevaluateLivenessPause = () => {
+                if (pendingResolvers.size > 0 || activeSubagentTaskIds.size === 0)
+                    clearSubagentStallWatchdog();
+                else if (!subagentStallTimer)
+                    armSubagentStallWatchdog();
                 if (activeSubagentTaskIds.size > 0 || pendingResolvers.size > 0 || isCompacting)
                     turnLiveness.pause();
                 else
@@ -355,16 +360,6 @@ export function createClaudeCodeEngine() {
                     isCompacting = false;
                     safeEmit({ kind: 'session:compacting', active: 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?.();
             };
@@ -406,27 +401,24 @@ export function createClaudeCodeEngine() {
                 clearTimeout(subagentStallTimer);
                 subagentStallTimer = undefined;
             };
-            // Re-armed (not merely armed-once) on every qualifying `result` so the
-            // deadline tracks the last observed activity, matching the warning
-            // message below — a long chain of legitimate subagent-backed turns
-            // must not be cut off just because 10 minutes have passed in total.
+            // Runs from the first task_started, including before the first result.
+            // Human waits suspend it independently; genuine activity restarts it.
             const armSubagentStallWatchdog = () => {
                 clearSubagentStallWatchdog();
+                if (pendingResolvers.size > 0 || activeSubagentTaskIds.size === 0)
+                    return;
                 subagentStallTimer = setTimeout(() => {
                     subagentStallTimer = undefined;
-                    // A message queued between arming and firing means a new turn is
-                    // about to start on this same stream — don't discard the subagent
-                    // tracking or force-close under it; the next 'result' re-evaluates.
-                    if (inputStream.hasUnansweredInput(completedResponses))
+                    if (pendingResolvers.size > 0 || activeSubagentTaskIds.size === 0)
                         return;
-                    console.warn(`[claude-engine] Subagent(s) still tracked active ${SUBAGENT_STALL_TIMEOUT_MS}ms after the last turn ended — forcing session drain.`);
-                    activeSubagentTaskIds.clear();
-                    // This is a forced, unclean termination (the subagent may still be
-                    // alive server-side) — never report it as a normal completion, so
-                    // auto-loop doesn't treat an orphaned run as forward progress.
-                    mapperState.sawErrorResult = true;
-                    inputStream.close();
-                    armResultDrainWatchdog();
+                    console.warn(`[claude-engine] No subagent activity for ${SUBAGENT_STALL_TIMEOUT_MS}ms — forcing session:ended`);
+                    safeEmit({
+                        kind: 'error',
+                        category: 'other',
+                        message: 'Session force-ended: background subagents stopped reporting activity (watchdog).',
+                    });
+                    emitSessionEnded('watchdog', null);
+                    abortController.abort();
                 }, SUBAGENT_STALL_TIMEOUT_MS);
                 subagentStallTimer.unref?.();
             };
@@ -454,6 +446,14 @@ export function createClaudeCodeEngine() {
                             else
                                 activeSubagentTaskIds.delete(ev.toolCallId);
                         }
+                        if (activeSubagentTaskIds.size > 0 &&
+                            (events.some((ev) => ev.kind === 'subagent:progress' ||
+                                ev.kind === 'message:text' ||
+                                ev.kind === 'message:thinking' ||
+                                ev.kind === 'tool:call' ||
+                                ev.kind === 'tool:result') ||
+                                ('parent_tool_use_id' in msg && msg.parent_tool_use_id != null)))
+                            armSubagentStallWatchdog();
                         for (const ev of events) {
                             if (ev.kind === 'session:compacting') {
                                 isCompacting = ev.active;
@@ -485,10 +485,8 @@ export function createClaudeCodeEngine() {
                             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
-                        // reports done). React the moment the last one clears instead of
-                        // waiting for a 'result' message that may never come.
+                        // After a settled result, the last background completion can
+                        // drain the stream without waiting for another result.
                         if (subagentStallTimer &&
                             activeSubagentTaskIds.size === 0 &&
                             !inputStream.hasUnansweredInput(completedResponses)) {
@@ -601,6 +599,7 @@ export function createClaudeCodeEngine() {
                     if (!iteratorRunning)
                         throw new Error(`Claude ${AGENT_NO_LONGER_RUNNING_TEXT}`);
                     inputStream.send(text);
+                    armSubagentStallWatchdog();
                 },
                 sendWakeupIfWaiting(text) {
                     if (!iteratorRunning ||
@@ -615,9 +614,8 @@ export function createClaudeCodeEngine() {
                         return false;
                     inputStream.send(text);
                     waitingForBackground = false;
-                    // The wakeup starts another turn on this stream; its result will
-                    // re-arm the stall deadline if background work is still outstanding.
-                    clearSubagentStallWatchdog();
+                    // Sending a new turn restarts, but never removes, the stall bound.
+                    armSubagentStallWatchdog();
                     return true;
                 },
                 interrupt() {

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

@@ -220,6 +220,8 @@ export function createCodexEngine() {
                 err.name = 'AbortError';
                 rejectTurnDone(err);
             });
+            const fileChanges = new Map();
+            const itemKey = (threadId, turnId, itemId) => JSON.stringify([threadId, turnId, itemId]);
             const client = createAppServerClient({
                 stdin: child.stdin,
                 stdout: child.stdout,
@@ -253,6 +255,8 @@ export function createCodexEngine() {
                     }
                     if (method === 'item/started') {
                         const n = params;
+                        if (n.item.type === 'fileChange')
+                            fileChanges.set(itemKey(n.threadId, n.turnId, n.item.id), n.item);
                         const events = handleItemStarted(n.item, mapperState);
                         for (const ev of events)
                             safeEmit(ev);
@@ -272,6 +276,8 @@ export function createCodexEngine() {
                     }
                     if (method === 'item/completed') {
                         const n = params;
+                        if (n.item.type === 'fileChange')
+                            fileChanges.set(itemKey(n.threadId, n.turnId, n.item.id), n.item);
                         const events = handleItemCompleted(n.item, mapperState);
                         for (const ev of events)
                             safeEmit(ev);
@@ -302,6 +308,11 @@ export function createCodexEngine() {
                     }
                     if (method === 'turn/completed') {
                         const n = params;
+                        for (const key of fileChanges.keys()) {
+                            const [threadId, turnId] = JSON.parse(key);
+                            if (threadId === n.threadId && turnId === n.turn.id)
+                                fileChanges.delete(key);
+                        }
                         for (const ev of handleTurnCompleted(n, mapperState))
                             safeEmit(ev);
                         if (!activeTurnId || !n.turn?.id || n.turn.id === activeTurnId) {
@@ -338,7 +349,9 @@ export function createCodexEngine() {
                     }
                     if (method === 'error') {
                         const n = params;
-                        const msg = n?.message ?? 'unknown error';
+                        if (n.willRetry)
+                            return;
+                        const msg = n?.error?.message ?? 'unknown error';
                         if (QUOTA_PATTERN.test(msg)) {
                             tryEmitQuota(mapperState, safeEmit, msg);
                         }
@@ -361,6 +374,14 @@ export function createCodexEngine() {
                         },
                         respondError: (reqId, code, message) => client.peer.respondError(reqId, code, message),
                         respond: (reqId, result) => client.peer.respond(reqId, result),
+                        resolveFileChange: (params) => {
+                            if (typeof params.threadId !== 'string' ||
+                                typeof params.turnId !== 'string' ||
+                                typeof params.itemId !== 'string')
+                                return undefined;
+                            const item = fileChanges.get(itemKey(params.threadId, params.turnId, params.itemId));
+                            return item ? { changes: item.changes, cwd: options.workingDir } : undefined;
+                        },
                         autoApprove: (toolName, payload) => isWorkspacePermissionAllowed(options.workspaceId, { engine: 'codex', toolName, payload }),
                     });
                 },
@@ -379,8 +400,9 @@ export function createCodexEngine() {
                     // install hangs.
                     turnLiveness.start();
                     await waitForChild(client.connect());
+                    let threadResponse;
                     if (isResume && options.resumeFromEngineSessionId) {
-                        await waitForChild(client.resumeThread({
+                        threadResponse = await waitForChild(client.resumeThread({
                             threadId: options.resumeFromEngineSessionId,
                             cwd: options.workingDir,
                             persistExtendedHistory: false,
@@ -394,8 +416,14 @@ export function createCodexEngine() {
                         }));
                     }
                     else {
-                        const startResp = await waitForChild(client.startThread(threadParams));
-                        discoveredSessionId = startResp.thread.id;
+                        threadResponse = await waitForChild(client.startThread(threadParams));
+                        discoveredSessionId = threadResponse.thread.id;
+                    }
+                    // "auto" is a Kōbō sentinel, never a provider model identifier. The
+                    // collaboration override must use the model the app-server resolved.
+                    const model = threadParams.model ?? threadResponse.model;
+                    if (typeof model !== 'string' || !model.trim() || model === 'auto') {
+                        throw new Error('Codex did not return a resolved model. Select an explicit model or update the Codex CLI.');
                     }
                     for (const ev of emitSessionStarted(discoveredSessionId, mapperState))
                         safeEmit(ev);
@@ -404,9 +432,9 @@ export function createCodexEngine() {
                     const initialTurn = await waitForChild(client.startTurn({
                         threadId: discoveredSessionId,
                         input,
-                        collaborationMode,
+                        collaborationMode: { ...collaborationMode, settings: { ...collaborationMode.settings, model } },
                     }));
-                    activeTurnId = initialTurn.turnId;
+                    activeTurnId = initialTurn.turn.id;
                     turnLiveness.activity();
                     readySettled = true;
                     resolveReady();
@@ -468,6 +496,7 @@ export function createCodexEngine() {
                             // best-effort
                         }
                     }
+                    fileChanges.clear();
                     pendingByCallId.clear();
                     pendingToolCalls.clear();
                     client.close();
@@ -526,9 +555,9 @@ export function createCodexEngine() {
                     if (gracefulInterruptPromise)
                         return;
                     gracefulInterruptPromise = (async () => {
-                        if (discoveredSessionId) {
+                        if (discoveredSessionId && activeTurnId) {
                             await Promise.race([
-                                client.interruptTurn({ threadId: discoveredSessionId }).catch(() => { }),
+                                client.interruptTurn({ threadId: discoveredSessionId, turnId: activeTurnId }).catch(() => { }),
                                 wait(CODEX_GRACEFUL_INTERRUPT_TIMEOUT_MS),
                             ]);
                         }

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

@@ -8,6 +8,8 @@ import { nanoid } from 'nanoid';
 //   - "out of extra usage" / "out of usage"
 //   - "usage limit exceeded"
 export const QUOTA_PATTERN = /\b429\b|rate[_ ]limit|quota|usage limit|insufficient[_ ]quota|out of (extra )?usage/i;
+// Standalone provider notices only: normal assistant prose can discuss quotas.
+const ASSISTANT_QUOTA_NOTICE = /^(?:rate[_ ]limit (?:exceeded|reached)|quota exceeded|insufficient[_ ]quota|out of (?:extra )?usage|usage limit (?:exceeded|reached)|you(?:'ve| have) (?:hit|reached) (?:your |the )?usage limit)(?:[.!]?(?:[ \t]*[·—-]?[ \t]*resets?\b[^\r\n]*)?)?[.!]?$/i;
 export function createMapperState(opts) {
     return {
         sessionStartedEmitted: false,
@@ -204,7 +206,7 @@ export function handleItemCompleted(item, state) {
         if (text.includes('[BRAINSTORM_COMPLETE]')) {
             events.push({ kind: 'session:brainstorm-complete' });
         }
-        if (QUOTA_PATTERN.test(text)) {
+        if (ASSISTANT_QUOTA_NOTICE.test(text.trim())) {
             tryEmitQuotaInline(state, events, text);
         }
         events.push({ kind: 'message:end', messageId });

package/dist/server/services/agent/engines/codex/options-builder.js

@@ -66,18 +66,19 @@ export function buildCodexOptions(input) {
     // Always emit collaborationMode — it's sticky server-side, so omitting it
     // would leave a resumed thread stuck in the previous turn's mode. Plan also
     // gates the `request_user_input` internal tool. Settings echo the resolved
-    // model/effort because collaborationMode takes precedence over them.
+    // model/effort because collaborationMode takes precedence over them. Automatic
+    // model selection is filled from thread/start or thread/resume by the engine.
     const collaborationMode = {
         mode: input.agentPermissionMode === 'plan' ? 'plan' : 'default',
         settings: {
-            model: threadParams.model ?? 'auto',
+            ...(threadParams.model ? { model: threadParams.model } : {}),
             reasoning_effort: threadParams.modelReasoningEffort ?? null,
             developer_instructions: null,
         },
     };
     return {
         threadParams,
-        input: [{ type: 'text', text: effectivePrompt }],
+        input: [{ type: 'text', text: effectivePrompt, text_elements: [] }],
         isResume,
         collaborationMode,
     };

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

@@ -29,7 +29,14 @@ export function handleServerRequest(args) {
         return true;
     }
     if (method === 'item/fileChange/requestApproval' || method === 'applyPatchApproval') {
-        const payload = { changes: p.changes, reason: p.reason };
+        const details = args.resolveFileChange?.(p);
+        const payload = {
+            changes: details?.changes ?? p.changes,
+            cwd: details?.cwd,
+            grantRoot: p.grantRoot ?? null,
+            reason: p.reason,
+            operationApprovalAvailable: Boolean(details && details.changes.length > 0),
+        };
         if (autoApprove?.('Edit', payload)) {
             respond?.(requestId, { decision: 'accept' });
             return true;

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

@@ -704,6 +704,21 @@ export function forgetTasksDoneSnapshot(workspaceId) {
 export function forgetResumeFailed(workspaceId) {
     resumeFailedSessions.delete(workspaceId);
 }
+/** Public reconnect snapshot: select DTO fields and detach nested JSON inputs. */
+export function getPendingInputs(workspaceId) {
+    return (pendingQueue.get(workspaceId) ?? []).map((item) => {
+        const identity = {
+            agentSessionId: item.agentSessionId,
+            toolCallId: item.toolCallId,
+            toolName: item.toolName,
+        };
+        // Engine tool inputs are JSON. Serialization also strips accidental callbacks.
+        const input = JSON.parse(JSON.stringify((item.kind === 'question' ? item.input : item.toolInput) ?? null));
+        return item.kind === 'question'
+            ? { kind: 'question', ...identity, input }
+            : { kind: 'permission', ...identity, toolInput: input };
+    });
+}
 /** Drop the pending question/permission queue for a workspace (called on delete). */
 export function forgetPendingQueue(workspaceId) {
     pendingQueue.delete(workspaceId);
@@ -1134,7 +1149,7 @@ function onSessionEnded(workspaceId, agentSessionId, sourceController, exitCode,
  * after `engine.start` resolves — callers should subscribe to WS events or
  * query the controller via `_getControllers()` for tests.
  */
-export function startAgent(workspaceId, workingDir, prompt, model, resume = false, agentPermissionMode, existingSessionId, reasoningEffort) {
+export function startAgent(workspaceId, workingDir, prompt, model, resume = false, agentPermissionMode, existingSessionId, reasoningEffort, beforeDispatch) {
     if (shuttingDown)
         throw new Error('Cannot start an agent while the server is shutting down');
     assertWorkspaceLifecycleAvailable(workspaceId);
@@ -1231,6 +1246,7 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
         mcpServers: buildMcpServers(workspaceId),
         env: ws ? buildAgentEnv(ws.projectPath) : undefined,
     };
+    beforeDispatch?.();
     let controller;
     controller = new SessionController(workspaceId, agentSessionId, engine, (ev) => handleEvent(workspaceId, agentSessionId, controller, ev));
     registerSessionLifecycleOwner(workspaceId, agentSessionId, controller);
@@ -1490,7 +1506,7 @@ export function sendWakeupIfWaiting(workspaceId, content, expectedSessionId) {
     return true;
 }
 /** Write a user message to the running agent. */
-export async function sendMessage(workspaceId, content, expectedSessionId) {
+export async function sendMessage(workspaceId, content, expectedSessionId, beforeDispatch) {
     assertWorkspaceNotCompacting(workspaceId);
     const ctrl = controllers.get(workspaceId);
     if (!ctrl) {
@@ -1500,6 +1516,7 @@ export async function sendMessage(workspaceId, content, expectedSessionId) {
         throw new Error(`Session '${expectedSessionId}' is not active for workspace '${workspaceId}'`);
     }
     wakeupService.cancel(workspaceId, 'user-message');
+    beforeDispatch?.();
     await ctrl.sendMessage(content);
 }
 export async function sendMessageForFallback(workspaceId, content) {
@@ -1671,7 +1688,7 @@ export async function answerPendingQuestion(workspaceId, answers, expectedToolCa
     try {
         const formatted = formatDeferredAnswerForChat(questions, answers);
         if (formatted) {
-            emit(workspaceId, 'user:message', { content: formatted, sender: 'user' }, head.agentSessionId);
+            emit(workspaceId, 'user:message', { content: formatted, sender: 'user', ...(opts?.source ? { source: opts.source } : {}) }, head.agentSessionId);
         }
     }
     catch (err) {

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

@@ -0,0 +1,122 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { nanoid } from 'nanoid';
+import { attachmentFormat, validateAttachments } from '../../shared/attachments.js';
+import { ensureDirectoryInside, resolvePathInside } from '../utils/safe-path.js';
+import { deleteImage, saveImage } from './image-service.js';
+export class AttachmentRequestError extends Error {
+}
+/** Existing JSON clients stay supported; browser attachments travel with the creation request. */
+export async function readWorkspaceCreationRequest(request) {
+    let body;
+    let attachments = [];
+    try {
+        if (request.headers.get('content-type')?.toLowerCase().startsWith('multipart/form-data')) {
+            const form = await request.formData();
+            const metadata = form.get('workspace');
+            if (typeof metadata !== 'string' || form.getAll('workspace').length !== 1) {
+                throw new AttachmentRequestError('Expected one JSON workspace field');
+            }
+            body = JSON.parse(metadata);
+            const files = [...form.getAll('attachments'), ...form.getAll('images')];
+            if (files.some((file) => !(file instanceof File))) {
+                throw new AttachmentRequestError('Each attachment must be a file');
+            }
+            attachments = files;
+        }
+        else {
+            body = await request.json();
+        }
+    }
+    catch (error) {
+        if (error instanceof AttachmentRequestError)
+            throw error;
+        throw new AttachmentRequestError('Invalid workspace creation body');
+    }
+    if (!body || typeof body !== 'object' || Array.isArray(body)) {
+        throw new AttachmentRequestError('Workspace must be a JSON object');
+    }
+    if ('description' in body && body.description !== undefined && typeof body.description !== 'string') {
+        throw new AttachmentRequestError('description must be a string');
+    }
+    const error = validateAttachments(attachments);
+    if (error) {
+        const messages = {
+            type: 'Unsupported attachment type. Use PNG, JPEG, GIF, WebP, PDF, Markdown or text documents',
+            size: 'Each attachment must be non-empty and no larger than 50 MB',
+            count: 'A workspace can be created with at most 10 attachments',
+            total: 'Creation attachments must total no more than 50 MB',
+        };
+        throw new AttachmentRequestError(messages[error]);
+    }
+    return { body: body, attachments };
+}
+/** Remove only this creation's files, preserving existing worktree content. */
+export async function removeAttachments(worktreePath, attachments) {
+    const warnings = [];
+    for (const attachment of attachments) {
+        try {
+            if (attachment.kind === 'image') {
+                await deleteImage(worktreePath, attachment.uid);
+            }
+            else {
+                const directory = ensureDirectoryInside(worktreePath, '.ai/attachments');
+                // Paths come exclusively from saveAttachments; never use the original upload name.
+                fs.unlinkSync(path.join(directory, path.basename(attachment.relativePath)));
+            }
+        }
+        catch (error) {
+            warnings.push(`Could not remove creation attachment '${attachment.uid}': ${error instanceof Error ? error.message : error}`);
+        }
+    }
+    return warnings;
+}
+export async function saveAttachments(worktreePath, files) {
+    const saved = [];
+    try {
+        for (const file of files) {
+            const format = attachmentFormat(file);
+            if (!format)
+                throw new AttachmentRequestError('Unsupported attachment type');
+            const buffer = Buffer.from(await file.arrayBuffer());
+            if (format.kind === 'image') {
+                const name = path.extname(file.name).toLowerCase() === format.extension
+                    ? file.name
+                    : `${file.name || 'image'}${format.extension}`;
+                saved.push({ ...(await saveImage(worktreePath, buffer, name)), kind: 'image', originalName: file.name });
+            }
+            else {
+                const directory = ensureDirectoryInside(worktreePath, '.ai/attachments');
+                const ignorePath = resolvePathInside(worktreePath, '.gitignore');
+                const ignore = fs.existsSync(ignorePath) ? fs.readFileSync(ignorePath, 'utf8') : '';
+                if (!ignore.split('\n').some((line) => line.trim() === '.ai/attachments/')) {
+                    fs.appendFileSync(ignorePath, `${ignore && !ignore.endsWith('\n') ? '\n' : ''}.ai/attachments/\n`);
+                }
+                const uid = nanoid(10);
+                const filename = `${uid}${format.extension}`;
+                const descriptor = fs.openSync(path.join(directory, filename), 'wx', 0o600);
+                // Track ownership as soon as exclusive creation succeeds: a failed
+                // write can leave bytes on disk and must participate in rollback.
+                saved.push({ uid, relativePath: `.ai/attachments/${filename}`, kind: 'file', originalName: file.name });
+                try {
+                    fs.writeFileSync(descriptor, buffer);
+                }
+                finally {
+                    fs.closeSync(descriptor);
+                }
+            }
+        }
+        return saved;
+    }
+    catch (error) {
+        const warnings = await removeAttachments(worktreePath, saved);
+        for (const warning of warnings)
+            console.error(`[creation-attachments] ${warning}`);
+        throw error;
+    }
+}
+export function attachmentReference(attachment) {
+    return attachment.kind === 'image'
+        ? `[image: ${attachment.relativePath}]`
+        : `Attached document ${JSON.stringify(attachment.originalName)}: [file: ${attachment.relativePath}]`;
+}

package/dist/server/services/change-source-branch-service.js

@@ -1,7 +1,7 @@
 import { withWorkspaceLifecycleGuard } from '../utils/workspace-lifecycle-guard.js';
 // src/server/services/change-source-branch-service.ts
-import { spawn } from 'node:child_process';
 import * as path from 'node:path';
+import { runBoundedProcess } from '../utils/bounded-process.js';
 import * as gitOps from '../utils/git-ops.js';
 import { withGitRepoLock } from '../utils/git-repo-lock.js';
 import { getAgentStatus } from './agent/orchestrator.js';
@@ -255,9 +255,10 @@ async function runCustomScript(workspace, oldBase, newBase, script) {
         return { status: 'dirty', forcePushNeeded: false, commitCount: 0 };
     if (getAgentStatus(workspace.id) !== null)
         throw new Error('Cannot change the source branch while the agent is running');
-    return new Promise((resolve, reject) => {
-        const child = spawn('bash', ['-c', script], {
+    try {
+        await runBoundedProcess('bash', ['-c', script], {
             cwd: workspace.worktreePath,
+            timeoutMs: SCRIPT_TIMEOUT_MS,
             env: {
                 ...process.env,
                 KOBO_NEW_BASE: newBase,
@@ -271,46 +272,13 @@ async function runCustomScript(workspace, oldBase, newBase, script) {
                 KOBO_FORGE: forgeId,
                 KOBO_PR_NUMBER: prNumber,
             },
-            // Detached so `child` leads its own process group. Node's native
-            // `timeout` option below only signals `child` itself — without this,
-            // a script that backgrounds a long-running command (`docker compose
-            // up -d &`) leaves it running as an orphan after the timeout fires.
-            detached: true,
-            timeout: SCRIPT_TIMEOUT_MS,
-            killSignal: 'SIGTERM',
-        });
-        // Node's `timeout` option kills only `child`. Mirror that same signal to
-        // the whole process group so a backgrounded child dies with it.
-        const groupKillTimer = setTimeout(() => {
-            try {
-                if (child.pid)
-                    process.kill(-child.pid, 'SIGTERM');
-            }
-            catch {
-                /* process group already gone */
-            }
-        }, SCRIPT_TIMEOUT_MS);
-        let stderrBuf = '';
-        child.stderr?.on('data', (chunk) => {
-            stderrBuf += chunk.toString();
-            if (stderrBuf.length > 8 * 1024)
-                stderrBuf = stderrBuf.slice(-8 * 1024);
-        });
-        child.on('error', (err) => {
-            clearTimeout(groupKillTimer);
-            reject(new Error(`Custom change-source-branch script failed to spawn: ${err.message}`));
         });
-        child.on('exit', (code, signal) => {
-            clearTimeout(groupKillTimer);
-            if (code === 0) {
-                updateWorkspaceSourceBranch(workspace.id, newBase);
-                resolve({ status: 'done', forcePushNeeded: false, commitCount: 0 });
-                return;
-            }
-            const detail = stderrBuf.trim().slice(-500) || `exit code ${code ?? signal ?? 'unknown'}`;
-            reject(new Error(`Custom change-source-branch script failed: ${detail}`));
-        });
-    });
+    }
+    catch (err) {
+        throw new Error(`Custom change-source-branch script failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    updateWorkspaceSourceBranch(workspace.id, newBase);
+    return { status: 'done', forcePushNeeded: false, commitCount: 0 };
 }
 /** Async lookups must not authorize mutations using obsolete workspace metadata. */
 function assertWorkspaceUnchanged(id, worktreePath, branch, sourceBranch) {

package/dist/server/services/chat-receipt-service.js

@@ -0,0 +1,33 @@
+import { emit, emitEphemeral } from './websocket-service.js';
+/** Correlate delivery confirmations without changing the legacy queue protocol. */
+export function createChatReceipt(workspaceId, delivery, persist) {
+    const correlation = delivery.clientMessageId ? { clientMessageId: delivery.clientMessageId } : {};
+    return {
+        accept(sessionId) {
+            const payload = {
+                content: delivery.content,
+                sender: 'user',
+                ...correlation,
+                ...(delivery.source ? { source: delivery.source } : {}),
+            };
+            if (persist)
+                persist(payload, sessionId);
+            else if (delivery.clientMessageId)
+                emit(workspaceId, 'user:message', payload, sessionId, { requirePersistence: true });
+            else
+                emit(workspaceId, 'user:message', payload, sessionId);
+            if (delivery.force || delivery.clientMessageId) {
+                emitEphemeral(workspaceId, 'chat:accepted', { sessionId, ...correlation });
+            }
+        },
+        reject(message, reason) {
+            emitEphemeral(workspaceId, 'chat:rejected', {
+                sessionId: delivery.sessionId,
+                content: delivery.content,
+                message,
+                ...correlation,
+                ...(reason ? { reason } : {}),
+            });
+        },
+    };
+}