@loicngr/kobo 1.11.39 → 1.11.40

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/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 } : {}),
+            });
+        },
+    };
+}

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

@@ -63,8 +63,22 @@ function rowToCron(row) {
         lastFiredAt: row.last_fired_at,
         oneShot: row.one_shot === 1,
         createdAt: row.created_at,
+        ...(expressionError(row.expression) ? { validationError: expressionError(row.expression) } : {}),
     };
 }
+function expressionError(expression) {
+    const trimmed = expression.trim();
+    if (!['@hourly', '@daily', '@weekly', '@monthly', '@yearly'].includes(trimmed) && trimmed.split(/\s+/).length !== 5) {
+        return `Invalid cron expression: ${expression} — expected five fields or a supported alias`;
+    }
+    try {
+        CronExpressionParser.parse(trimmed);
+        return null;
+    }
+    catch (err) {
+        return `Invalid cron expression: ${expression} — ${err instanceof Error ? err.message : String(err)}`;
+    }
+}
 /**
  * Compute the next fire time for an expression strictly after `from`.
  * Uses cron-parser 5.x API. Throws with a descriptive error if the
@@ -72,6 +86,9 @@ function rowToCron(row) {
  * `@monthly` / `@yearly` are accepted natively.
  */
 function nextAfter(expression, from) {
+    const validationError = expressionError(expression);
+    if (validationError)
+        throw new Error(validationError);
     try {
         const it = CronExpressionParser.parse(expression, { currentDate: from });
         return it.next().toDate();
@@ -173,6 +190,8 @@ function fireOrSkip(id) {
         const row = db.prepare('SELECT * FROM pending_crons WHERE id = ?').get(id);
         if (!row)
             return; // cancelled in flight
+        if (expressionError(row.expression))
+            return; // Retain invalid legacy intent without executing it.
         const wsRow = db
             .prepare(`SELECT project_path, working_branch, worktree_path, model, agent_permission_mode, reasoning_effort, archived_at
            FROM workspaces WHERE id = ?`)
@@ -212,6 +231,9 @@ function fireOrSkip(id) {
         const now = new Date();
         let nextFire;
         try {
+            // Valid five-field schedules have at most one occurrence per minute.
+            // Skip missed slots from now, without adding a minute of timer jitter
+            // that would discard the next scheduled occurrence too.
             nextFire = nextAfter(row.expression, now);
         }
         catch (err) {
@@ -220,7 +242,6 @@ function fireOrSkip(id) {
             // arm and this fire. Cancel as 'completed' (the cron self-terminates)
             // rather than 'user' which would imply the user requested it.
             console.error(`[cron-service] failed to recompute next fire for cron '${id}':`, err);
-            cancel(id, 'completed');
             return;
         }
         // One-shot crons cancel themselves after a real fire (not on skip-active —
@@ -278,6 +299,11 @@ export function restoreOnBoot() {
                     db.prepare('DELETE FROM pending_crons WHERE id = ?').run(row.id);
                     continue;
                 }
+                const validationError = expressionError(row.expression);
+                if (validationError) {
+                    console.warn(`[cron-service] ${validationError}; cron ${row.id} remains inactive`);
+                    continue;
+                }
                 const storedDate = new Date(row.next_fire_at);
                 let nextFireAt;
                 if (storedDate.getTime() <= now.getTime()) {

package/dist/server/services/mcp-client-context.js

@@ -0,0 +1,12 @@
+import { normalizeClientName } from '../../shared/workspace-message-types.js';
+export function createMcpClientContext(name, transport = 'http', encoding) {
+    if (encoding === 'uri' && typeof name === 'string') {
+        try {
+            name = decodeURIComponent(name);
+        }
+        catch {
+            name = undefined;
+        }
+    }
+    return { kind: 'mcp', clientName: normalizeClientName(name), transport };
+}

package/dist/server/services/mcp-connection-info-service.js

@@ -0,0 +1,63 @@
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { getCompiledMcpServerPath, getDbPath, getMcpServerSourcePath } from '../utils/paths.js';
+import { getLanHostnames, isAllowedRequestHost, resolveProxyHostname } from './network-access-service.js';
+/** No request/forwarded headers or credentials participate in generated metadata. */
+export function buildMcpConnectionInfo(input) {
+    const backendUrl = `http://127.0.0.1:${input.port}`;
+    const args = input.compiledPath
+        ? [input.compiledPath]
+        : input.sourcePath && input.loaderPath
+            ? ['--import', pathToFileURL(input.loaderPath).href, input.sourcePath]
+            : null;
+    return {
+        localUrl: `${backendUrl}/api/mcp`,
+        lanUrls: input.networkEnabled
+            ? input.lanHostnames
+                .map((host) => `${host.includes(':') ? `[${host}]` : host}:${input.port}`)
+                .filter((host) => isAllowedRequestHost({
+                host,
+                enabled: input.networkEnabled,
+                lanHostnames: input.lanHostnames,
+                behindProxy: input.behindProxy,
+                proxyHostname: input.proxyHostname,
+            }))
+                .map((host) => `http://${host}/api/mcp`)
+            : [],
+        networkEnabled: input.networkEnabled,
+        behindProxy: input.behindProxy,
+        proxyHostname: input.proxyHostname,
+        localRequiresToken: input.behindProxy,
+        stdio: args
+            ? {
+                command: input.command,
+                args,
+                env: { KOBO_DB_PATH: input.databasePath, KOBO_BACKEND_URL: backendUrl, KOBO_WORKSPACE_ID: '' },
+            }
+            : null,
+    };
+}
+export function getMcpConnectionInfo(port, settings, databasePath = getDbPath()) {
+    const source = getMcpServerSourcePath();
+    let loaderPath = null;
+    try {
+        loaderPath = createRequire(import.meta.url).resolve('tsx');
+    }
+    catch {
+        /* Production installs can omit the development loader. */
+    }
+    return buildMcpConnectionInfo({
+        port,
+        networkEnabled: settings.networkAccessEnabled,
+        behindProxy: settings.networkAccessBehindProxy,
+        proxyHostname: resolveProxyHostname(),
+        lanHostnames: getLanHostnames(),
+        command: process.execPath,
+        compiledPath: getCompiledMcpServerPath(),
+        sourcePath: fs.existsSync(source) ? source : null,
+        loaderPath,
+        databasePath: path.resolve(databasePath),
+    });
+}