@loicngr/kobo 1.11.42 → 1.11.44

package/dist/server/routes/workspaces.js

@@ -3,6 +3,7 @@ import { promisify } from 'node:util';
 import { getSearchIndexStatus, searchEvents } from '../services/search-service.js';
 import { AgentStopError, assertAgentStopped } from '../utils/agent-stop-result.js';
 import { withGitRepoLock } from '../utils/git-repo-lock.js';
+import autoLoopMessagesRoutes from './auto-loop-messages.js';
 const execFileAsync = promisify(execFileCb);
 import fs from 'node:fs';
 import path from 'node:path';
@@ -34,11 +35,12 @@ import * as notionService from '../services/notion-service.js';
 import { renderPrTemplate } from '../services/pr-template-service.js';
 import { clearPrSnapshotCache, getAllGitStats, getAllPrSnapshots, refreshPrSnapshot, } from '../services/pr-watcher-service.js';
 import * as quotaBackoffService from '../services/quota-backoff-service.js';
-import { getActiveReviewTemplate, renderReviewTemplate } from '../services/review-template-service.js';
+import { ReviewRequestError, startWorkspaceReview } from '../services/review-service.js';
 import * as sentryService from '../services/sentry-service.js';
 import * as settingsService from '../services/settings-service.js';
 import { runSetupScript } from '../services/setup-script-service.js';
 import { getSuitePrompts } from '../services/skill-suite-prompts.js';
+import { TaskValidationError } from '../services/task-mutations.js';
 import * as terminalService from '../services/terminal-service.js';
 import * as wakeupService from '../services/wakeup-service.js';
 import * as wsService from '../services/websocket-service.js';
@@ -1601,9 +1603,7 @@ app.get('/auto-loop-states', (c) => {
         const out = {};
         for (const r of rows) {
             out[r.id] = {
-                auto_loop: r.auto_loop === 1,
-                auto_loop_ready: r.auto_loop_ready === 1,
-                no_progress_streak: r.no_progress_streak,
+                ...autoLoopService.getStatus(r.id),
                 tasks_done: r.tasks_done ?? 0,
                 tasks_total: r.tasks_total ?? 0,
                 crons_count: r.crons_count ?? 0,
@@ -1616,6 +1616,7 @@ app.get('/auto-loop-states', (c) => {
         return c.json({ error: message }, workspaceErrorStatus(err));
     }
 });
+app.route('/', autoLoopMessagesRoutes);
 // GET /api/workspaces/:id/auto-loop — current auto-loop status for one workspace.
 app.get('/:id/auto-loop', (c) => {
     try {
@@ -2011,67 +2012,68 @@ app.delete('/:id/events/:eventId', (c) => {
 app.post('/:id/tasks', async (c) => {
     try {
         const id = c.req.param('id');
-        const workspace = workspaceService.getWorkspace(id);
-        if (!workspace) {
+        if (!workspaceService.getWorkspace(id))
             return c.json({ error: `Workspace '${id}' not found` }, 404);
-        }
-        const body = await c.req
-            .json()
-            .catch(() => ({}));
-        if (!body.title?.trim()) {
+        const body = await c.req.json().catch(() => null);
+        if (!body || typeof body.title !== 'string' || !body.title.trim()) {
             return c.json({ error: 'Title is required' }, 400);
         }
-        const existing = workspaceService.listTasks(id);
-        const nextSortOrder = existing.length > 0 ? Math.max(...existing.map((t) => t.sortOrder)) + 1 : 0;
         const task = workspaceService.createTask(id, {
             title: body.title.trim(),
-            isAcceptanceCriterion: !!body.isAcceptanceCriterion,
-            sortOrder: nextSortOrder,
+            isAcceptanceCriterion: body.isAcceptanceCriterion,
+            sortOrder: body.sortOrder,
+            afterTaskId: body.afterTaskId,
+            role: body.role,
         });
         return c.json(task, 201);
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        return c.json({ error: message }, workspaceErrorStatus(err));
+        return c.json({ error: message }, err instanceof TaskValidationError ? 400 : workspaceErrorStatus(err));
     }
 });
-// PATCH /api/workspaces/:id/tasks/:taskId — update task status and/or title
+// PATCH /api/workspaces/:id/tasks/:taskId — validate and apply every field atomically
 app.patch('/:id/tasks/:taskId', async (c) => {
     try {
         const id = c.req.param('id');
         const taskId = c.req.param('taskId');
-        const workspace = workspaceService.getWorkspace(id);
-        if (!workspace) {
+        if (!workspaceService.getWorkspace(id))
             return c.json({ error: `Workspace '${id}' not found` }, 404);
-        }
-        const task = workspaceService.getTask(taskId, id);
-        if (!task) {
+        if (!workspaceService.getTask(taskId, id)) {
             return c.json({ error: `Task '${taskId}' not found in workspace '${id}'` }, 404);
         }
-        const body = await c.req
-            .json()
-            .catch(() => ({}));
-        if (body.status === undefined && body.title === undefined) {
-            return c.json({ error: 'At least one of status or title is required' }, 400);
-        }
-        if (body.title !== undefined) {
-            if (!body.title.trim()) {
-                return c.json({ error: 'Title cannot be empty' }, 400);
-            }
-            workspaceService.updateTaskTitle(taskId, body.title.trim());
-        }
-        if (body.status !== undefined) {
-            const validStatuses = ['pending', 'in_progress', 'done'];
-            if (!validStatuses.includes(body.status)) {
-                return c.json({ error: `Invalid status. Must be one of: ${validStatuses.join(', ')}` }, 400);
-            }
-            workspaceService.updateTaskStatus(taskId, body.status);
+        const body = await c.req.json().catch(() => null);
+        if (!body || typeof body !== 'object' || Array.isArray(body)) {
+            return c.json({ error: 'Request body must be a JSON object' }, 400);
         }
+        const fields = {};
+        for (const key of [
+            'title',
+            'status',
+            'isAcceptanceCriterion',
+            'sortOrder',
+            'afterTaskId',
+            'verification',
+        ]) {
+            if (body[key] !== undefined)
+                Object.assign(fields, { [key]: body[key] });
+        }
+        if (Object.keys(fields).length === 0)
+            return c.json({ error: 'At least one task field is required' }, 400);
+        if (fields.title !== undefined && (typeof fields.title !== 'string' || !fields.title.trim())) {
+            return c.json({ error: 'Title cannot be empty' }, 400);
+        }
+        if (fields.status !== undefined && !['pending', 'in_progress', 'done'].includes(fields.status)) {
+            return c.json({ error: 'Invalid status. Must be one of: pending, in_progress, done' }, 400);
+        }
+        if (fields.title !== undefined)
+            fields.title = fields.title.trim();
+        workspaceService.updateTask(taskId, fields);
         return c.json({ ok: true });
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        return c.json({ error: message }, workspaceErrorStatus(err));
+        return c.json({ error: message }, err instanceof TaskValidationError ? 400 : workspaceErrorStatus(err));
     }
 });
 // DELETE /api/workspaces/:id/tasks/:taskId — delete a task
@@ -4302,104 +4304,12 @@ app.post('/:id/open-pr', async (c) => {
     }
 });
 // POST /api/workspaces/:id/start-review — ask the agent to review committed + uncommitted changes
-app.post('/:id/start-review', async (c) => {
+app.post('/:id/start-review', migrationGuard, async (c) => {
     try {
-        const id = c.req.param('id');
-        const workspace = workspaceService.getWorkspace(id);
-        if (!workspace) {
-            return c.json({ error: `Workspace '${id}' not found` }, 404);
-        }
-        const body = await c.req
-            .json()
-            .catch(() => ({}));
-        const additionalInstructions = (body.additionalInstructions ?? '').trim();
-        const newSession = body.newSession === true;
-        const worktreePath = workspace.worktreePath;
-        // Best-effort fetch so the base ref is fresh
-        try {
-            await execFileAsync('git', ['fetch', 'origin', workspace.sourceBranch], { cwd: worktreePath });
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            console.warn(`[start-review] git fetch origin ${workspace.sourceBranch} failed: ${msg}`);
-        }
-        // Resolve base commit
-        let baseCommit;
-        try {
-            const { stdout } = await execFileAsync('git', ['rev-parse', `origin/${workspace.sourceBranch}`], {
-                cwd: worktreePath,
-            });
-            baseCommit = stdout.trim();
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            return c.json({ error: `Cannot resolve base commit for branch ${workspace.sourceBranch}: ${msg}` }, 500);
-        }
-        // Build context
-        const commits = gitOps.getCommitsBetween(worktreePath, workspace.sourceBranch, workspace.workingBranch);
-        const committedStats = gitOps.getDiffStatsBetween(worktreePath, workspace.sourceBranch, workspace.workingBranch);
-        const workingTreeStats = gitOps.getWorkingTreeDiffStats(worktreePath);
-        const diffStats = workingTreeStats.trim().length > 0
-            ? `${committedStats}\n\n— Working tree (uncommitted) —\n${workingTreeStats}`
-            : committedStats;
-        const template = getActiveReviewTemplate();
-        const rendered = renderReviewTemplate(template, {
-            workspace,
-            commits,
-            diffStats,
-            baseCommit,
-            additionalInstructions,
-        });
-        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 {
-                assertAgentStopped(await agentManager.stopAgentAndWait(workspace.id, undefined, 'replacement'));
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                console.error(`[start-review] stopAgentAndWait failed (continuing): ${msg}`);
-                throw err;
-            }
-            try {
-                const agent = agentManager.startAgent(workspace.id, worktreePath, rendered, workspace.model, false /* resume */, workspace.agentPermissionMode, undefined, workspace.reasoningEffort);
-                workspaceService.updateWorkspaceStatus(workspace.id, 'executing');
-                emitSessionId = agent?.agentSessionId;
-                messageSent = true;
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return c.json({ error: `Failed to start review session: ${msg}` }, 500);
-            }
-        }
-        else {
-            const session = workspaceService.getActiveSession(workspace.id);
-            emitSessionId = session?.id;
-            try {
-                const delivery = await deliverAgentPrompt(workspace, worktreePath, rendered);
-                emitSessionId = delivery.agentSessionId;
-                messageSent = true;
-            }
-            catch (deliveryErr) {
-                const message = deliveryErr instanceof Error ? deliveryErr.message : String(deliveryErr);
-                return c.json({ error: `Failed to dispatch review prompt: ${message}` }, 500);
-            }
-        }
-        // Emit AFTER dispatch so the user:message lands in the correct session id —
-        // for newSession=true that's the freshly created session, not the previous one.
-        wsService.emit(workspace.id, 'user:message', { content: rendered, sender: 'user' }, emitSessionId);
-        return c.json({ ok: true, messageSent, newSession });
+        return c.json(await startWorkspaceReview(c.req.param('id'), await c.req.json().catch(() => ({}))));
     }
     catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return c.json({ error: message }, workspaceErrorStatus(err));
+        return c.json({ error: err instanceof Error ? err.message : String(err) }, err instanceof ReviewRequestError ? err.status : workspaceErrorStatus(err));
     }
 });
 // POST /api/workspaces/:id/start-ci-fix — dispatch the configured CI-fix

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

@@ -315,6 +315,7 @@ export function createClaudeCodeEngine() {
                             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.',
+                            code: 'stream_idle_timeout',
                         });
                         emitSessionEnded('watchdog', null);
                     }
@@ -587,6 +588,7 @@ export function createClaudeCodeEngine() {
                 }
             })();
             const engineProcess = {
+                closed: iteratorPromise.then(() => { }),
                 get pid() {
                     return undefined;
                 },

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

@@ -124,14 +124,41 @@ export function createCodexEngine() {
             });
             void childFailurePromise.catch(() => { });
             const child = spawnAppServer({ cwd: options.workingDir, env: options.env, signal: abortController.signal });
+            let childExited = false;
+            let resolveChildExited;
+            const childExitedPromise = new Promise((resolve) => {
+                resolveChildExited = resolve;
+            });
+            const confirmChildExited = () => {
+                childExited = true;
+                resolveChildExited();
+            };
+            let shutdownPromise;
+            const terminateChild = () => {
+                if (childExited)
+                    return Promise.resolve();
+                shutdownPromise ??= (async () => {
+                    if (!(await signalAndWaitForExit(child, 'SIGTERM', CODEX_FORCE_KILL_TIMEOUT_MS))) {
+                        console.warn('[codex] app-server ignored SIGTERM — sending SIGKILL');
+                        if (!(await signalAndWaitForExit(child, 'SIGKILL', CODEX_FORCE_KILL_TIMEOUT_MS))) {
+                            throw new Error('Codex app-server did not exit after SIGKILL');
+                        }
+                    }
+                    confirmChildExited();
+                })();
+                return shutdownPromise;
+            };
             child.on('error', (error) => {
                 const isExpectedAbort = abortController.signal.aborted && (error.code === 'ABORT_ERR' || error.name === 'AbortError');
                 if (isExpectedAbort)
                     return;
+                if (child.pid === undefined)
+                    confirmChildExited();
                 console.error('[codex] child process error:', error);
                 rejectChildFailure(error);
             });
             child.once('exit', (code, signal) => {
+                confirmChildExited();
                 if (!iteratorRunning || abortController.signal.aborted)
                     return;
                 const detail = code === null ? `signal ${signal ?? 'unknown'}` : `code ${code}`;
@@ -154,6 +181,7 @@ export function createCodexEngine() {
             let rejectTurnDone;
             const activeSubagentThreads = new Map();
             let waitingForBackgroundSubagents = false;
+            let watchdogEnded = false;
             const turnDonePromise = new Promise((resolve, reject) => {
                 resolveTurnDone = resolve;
                 rejectTurnDone = reject;
@@ -169,6 +197,8 @@ export function createCodexEngine() {
             // deadline tracks the last activity, not the start of the wait.
             const armSubagentStallWatchdog = () => {
                 clearSubagentStallWatchdog();
+                if (!waitingForBackgroundSubagents || pendingByCallId.size > 0 || activeSubagentThreads.size === 0)
+                    return;
                 subagentStallTimer = setTimeout(() => {
                     subagentStallTimer = undefined;
                     console.warn(`[codex-engine] Background subagent thread(s) still tracked active ${CODEX_SUBAGENT_STALL_TIMEOUT_MS}ms after the turn completed — forcing session drain.`);
@@ -176,7 +206,13 @@ export function createCodexEngine() {
                     // Forced, unclean termination (a thread 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;
+                    watchdogEnded = true;
+                    safeEmit({
+                        kind: 'error',
+                        category: 'other',
+                        code: 'subagent_idle_timeout',
+                        message: 'Session force-ended: background subagents stopped reporting activity (watchdog).',
+                    });
                     if (waitingForBackgroundSubagents)
                         resolveTurnDone();
                 }, CODEX_SUBAGENT_STALL_TIMEOUT_MS);
@@ -209,8 +245,13 @@ export function createCodexEngine() {
             const turnLiveness = createTurnLiveness({
                 timeoutMs: CODEX_TURN_IDLE_TIMEOUT_MS,
                 onTimeout() {
-                    mapperState.sawErrorResult = true;
-                    safeEmit({ kind: 'error', category: 'other', message: 'Codex stopped reporting activity for this turn' });
+                    watchdogEnded = true;
+                    safeEmit({
+                        kind: 'error',
+                        category: 'other',
+                        code: 'stream_idle_timeout',
+                        message: 'Codex stopped reporting activity for this turn',
+                    });
                     rejectTurnDone(new CodexTurnTimeoutError());
                 },
             });
@@ -221,6 +262,21 @@ export function createCodexEngine() {
                 rejectTurnDone(err);
             });
             const fileChanges = new Map();
+            const isParentTurn = (threadId, turnId) => (!threadId || threadId === discoveredSessionId) && (!activeTurnId || !turnId || turnId === activeTurnId);
+            const otherTurnMappers = new Map();
+            const mapTurnEvents = (notification, map) => {
+                if (isParentTurn(notification.threadId, notification.turnId))
+                    return map(mapperState);
+                const key = JSON.stringify([notification.threadId, notification.turnId]);
+                let state = otherTurnMappers.get(key);
+                if (!state) {
+                    state = createMapperState();
+                    otherTurnMappers.set(key, state);
+                }
+                // Child output remains visible, but its failures/compaction/markers
+                // cannot control the parent session or its auto-loop lifecycle.
+                return map(state).filter((event) => event.kind !== 'error' && !event.kind.startsWith('session:'));
+            };
             const itemKey = (threadId, turnId, itemId) => JSON.stringify([threadId, turnId, itemId]);
             const client = createAppServerClient({
                 stdin: child.stdin,
@@ -228,6 +284,10 @@ export function createCodexEngine() {
                 clientInfo: { name: 'kobo', version: getPackageVersion() },
                 onNotification(method, params) {
                     turnLiveness.activity();
+                    const notification = params;
+                    if (notification?.threadId && activeSubagentThreads.has(notification.threadId)) {
+                        armSubagentStallWatchdog();
+                    }
                     // Ignored notifications — harmless bookkeeping by the server
                     if (method === 'mcpServer/startupStatus/updated') {
                         const status = (params ?? {});
@@ -257,7 +317,7 @@ export function createCodexEngine() {
                         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);
+                        const events = mapTurnEvents(n, (state) => handleItemStarted(n.item, state));
                         for (const ev of events)
                             safeEmit(ev);
                         if (n.item.type === 'collabAgentToolCall' && n.item.tool === 'spawnAgent') {
@@ -278,7 +338,7 @@ export function createCodexEngine() {
                         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);
+                        const events = mapTurnEvents(n, (state) => handleItemCompleted(n.item, state));
                         for (const ev of events)
                             safeEmit(ev);
                         if (n.item.type === 'collabAgentToolCall') {
@@ -302,7 +362,7 @@ export function createCodexEngine() {
                     }
                     if (method === 'item/agentMessage/delta') {
                         const n = params;
-                        for (const ev of handleAgentMessageDelta(n, mapperState))
+                        for (const ev of mapTurnEvents(n, (state) => handleAgentMessageDelta(n, state)))
                             safeEmit(ev);
                         return;
                     }
@@ -313,9 +373,9 @@ export function createCodexEngine() {
                             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) {
+                        if (isParentTurn(n.threadId, n.turn.id)) {
+                            for (const ev of handleTurnCompleted(n, mapperState))
+                                safeEmit(ev);
                             if (n.turn?.status === 'completed' && activeSubagentThreads.size > 0) {
                                 waitingForBackgroundSubagents = true;
                                 turnLiveness.pause();
@@ -349,6 +409,8 @@ export function createCodexEngine() {
                     }
                     if (method === 'error') {
                         const n = params;
+                        if (!isParentTurn(n.threadId, n.turnId))
+                            return;
                         if (n.willRetry)
                             return;
                         const msg = n?.error?.message ?? 'unknown error';
@@ -371,6 +433,7 @@ export function createCodexEngine() {
                         register(callId, pending) {
                             pendingByCallId.set(callId, pending);
                             turnLiveness.pause();
+                            clearSubagentStallWatchdog();
                         },
                         respondError: (reqId, code, message) => client.peer.respondError(reqId, code, message),
                         respond: (reqId, result) => client.peer.respond(reqId, result),
@@ -444,7 +507,9 @@ export function createCodexEngine() {
                         ? 'error'
                         : mapperState.sawTurnInterrupted
                             ? 'killed'
-                            : 'completed';
+                            : watchdogEnded
+                                ? 'watchdog'
+                                : 'completed';
                     safeEmit({
                         kind: 'session:ended',
                         reason,
@@ -465,7 +530,11 @@ export function createCodexEngine() {
                         safeEmit({ kind: 'session:ended', reason: 'killed', exitCode: null });
                     }
                     else if (error.name === 'CodexTurnTimeoutError') {
-                        safeEmit({ kind: 'session:ended', reason: 'error', exitCode: null });
+                        safeEmit({
+                            kind: 'session:ended',
+                            reason: mapperState.sawErrorResult ? 'error' : 'watchdog',
+                            exitCode: null,
+                        });
                     }
                     else if (QUOTA_PATTERN.test(message)) {
                         tryEmitQuota(mapperState, safeEmit, message);
@@ -497,18 +566,15 @@ export function createCodexEngine() {
                         }
                     }
                     fileChanges.clear();
+                    otherTurnMappers.clear();
                     pendingByCallId.clear();
                     pendingToolCalls.clear();
                     client.close();
-                    try {
-                        child.kill('SIGTERM');
-                    }
-                    catch {
-                        // best-effort
-                    }
+                    await terminateChild().catch((error) => console.error('[codex] runtime shutdown unconfirmed:', error));
                 }
             })();
             const engineProcess = {
+                closed: Promise.all([iteratorPromise, childExitedPromise]).then(() => { }),
                 get pid() {
                     return child.pid;
                 },
@@ -516,7 +582,7 @@ export function createCodexEngine() {
                     return discoveredSessionId;
                 },
                 isAlive() {
-                    return iteratorRunning;
+                    return iteratorRunning || !childExited;
                 },
                 sendMessage(text) {
                     const steer = async () => {
@@ -581,17 +647,7 @@ export function createCodexEngine() {
                     catch {
                         // swallow
                     }
-                    // Escalate. The SIGTERM in the `finally` below is a request, not a
-                    // guarantee: a wedged `codex app-server` that ignores it outlives the
-                    // stop, the archive, the delete and Kōbō's own shutdown, holding the
-                    // worktree and its share of the model quota, with nothing left in
-                    // this process tracking it.
-                    if (!(await signalAndWaitForExit(child, 'SIGTERM', CODEX_FORCE_KILL_TIMEOUT_MS))) {
-                        console.warn('[codex] app-server ignored SIGTERM — sending SIGKILL');
-                        if (!(await signalAndWaitForExit(child, 'SIGKILL', CODEX_FORCE_KILL_TIMEOUT_MS))) {
-                            throw new Error('Codex app-server did not exit after SIGKILL');
-                        }
-                    }
+                    await terminateChild();
                 },
                 resolvePendingUserInput(callId, response) {
                     const pending = pendingByCallId.get(callId);
@@ -601,8 +657,12 @@ export function createCodexEngine() {
                     // Only resume the idle-timeout clock once every outstanding
                     // approval has been answered — a sibling request may still be
                     // waiting on a human decision.
-                    if (pendingByCallId.size === 0)
-                        turnLiveness.resume();
+                    if (pendingByCallId.size === 0) {
+                        if (waitingForBackgroundSubagents)
+                            armSubagentStallWatchdog();
+                        else
+                            turnLiveness.resume();
+                    }
                     const result = buildResponseForResolve(pending, response);
                     client.peer.respond(pending.requestId, result);
                     return true;