@loicngr/kobo 1.11.39 → 1.11.41

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

@@ -5,10 +5,69 @@ import { getAllPersistedSnapshots } from './usage/db.js';
 // ── State ──────────────────────────────────────────────────────────────────────
 /** Maps each WS client to the set of workspaceIds they are subscribed to */
 const clients = new Map();
-/** Above this many bytes queued for a single client, we stop sending it events
- *  rather than growing the process heap on its behalf. It will catch up through
+/** Above this many bytes queued for a single client, we terminate the connection
+ *  before a later event can advance its cursor past an undelivered frame. It will catch up through
  *  `sync:request` on its next reconnect. */
 const MAX_BUFFERED_BYTES = 1024 * 1024;
+/** A dropped frame must end the connection so its replay cursor cannot skip it. */
+function sendFrame(ws, message) {
+    if (ws.readyState !== 1)
+        return;
+    if (ws.bufferedAmount > MAX_BUFFERED_BYTES) {
+        clients.delete(ws);
+        ws.terminate();
+        return;
+    }
+    try {
+        ws.send(message);
+    }
+    catch {
+        clients.delete(ws);
+        ws.terminate();
+    }
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function validMessage(value) {
+    if (!isRecord(value) || typeof value.type !== 'string')
+        return false;
+    const p = value.payload;
+    if (!isRecord(p))
+        return false;
+    if (value.type === 'sync:request') {
+        return ((p.lastEventId === undefined || typeof p.lastEventId === 'string') &&
+            (p.workspaceIds === undefined ||
+                (Array.isArray(p.workspaceIds) && p.workspaceIds.every((id) => typeof id === 'string' && id.length > 0))));
+    }
+    if (![
+        'subscribe',
+        'unsubscribe',
+        'chat:message',
+        'workspace:start',
+        'workspace:stop',
+        'devserver:start',
+        'devserver:stop',
+    ].includes(value.type))
+        return true;
+    if (typeof p.workspaceId !== 'string' || !p.workspaceId)
+        return false;
+    if (p.sessionId !== undefined && typeof p.sessionId !== 'string')
+        return false;
+    if (value.type === 'workspace:start' && p.prompt !== undefined && typeof p.prompt !== 'string')
+        return false;
+    if (value.type === 'chat:message') {
+        return (typeof p.content === 'string' &&
+            p.content.length > 0 &&
+            (p.sessionId === undefined || typeof p.sessionId === 'string') &&
+            (p.clientMessageId === undefined || (typeof p.clientMessageId === 'string' && p.clientMessageId.length > 0)) &&
+            (p.force === undefined || typeof p.force === 'boolean') &&
+            (p.agentPermissionModeOverride === undefined ||
+                (typeof p.agentPermissionModeOverride === 'string' &&
+                    ['plan', 'bypass', 'strict', 'interactive'].includes(p.agentPermissionModeOverride))));
+    }
+    return true;
+}
 let messageHandler = null;
 /** Register the handler that processes routed WS messages (e.g. chat:message, workspace:start). */
 export function setMessageHandler(handler) {
@@ -23,7 +82,7 @@ export function handleConnection(ws) {
     // immediately instead of waiting up to POLL_INTERVAL_MS for the next tick.
     try {
         for (const snap of getAllPersistedSnapshots()) {
-            ws.send(JSON.stringify({
+            sendFrame(ws, JSON.stringify({
                 type: 'usage:snapshot',
                 payload: { providerId: snap.providerId, snapshot: snap },
             }));
@@ -35,10 +94,18 @@ export function handleConnection(ws) {
     ws.on('message', (data) => {
         let msg;
         try {
-            msg = JSON.parse(data.toString());
+            const parsed = JSON.parse(data.toString());
+            if (!validMessage(parsed)) {
+                sendFrame(ws, JSON.stringify({
+                    type: 'error',
+                    payload: { message: 'Invalid message payload (check workspaceId and field types)' },
+                }));
+                return;
+            }
+            msg = parsed;
         }
         catch {
-            ws.send(JSON.stringify({ type: 'error', payload: { message: 'Invalid JSON' } }));
+            sendFrame(ws, JSON.stringify({ type: 'error', payload: { message: 'Invalid JSON' } }));
             return;
         }
         const { type, payload } = msg;
@@ -46,23 +113,23 @@ export function handleConnection(ws) {
             case 'subscribe': {
                 const workspaceId = payload?.workspaceId;
                 if (!workspaceId) {
-                    ws.send(JSON.stringify({ type: 'error', payload: { message: 'Missing workspaceId' } }));
+                    sendFrame(ws, JSON.stringify({ type: 'error', payload: { message: 'Missing workspaceId' } }));
                     return;
                 }
                 const subs = clients.get(ws);
                 subs?.add(workspaceId);
-                ws.send(JSON.stringify({ type: 'subscribed', payload: { workspaceId } }));
+                sendFrame(ws, JSON.stringify({ type: 'subscribed', payload: { workspaceId } }));
                 break;
             }
             case 'unsubscribe': {
                 const workspaceId = payload?.workspaceId;
                 if (!workspaceId) {
-                    ws.send(JSON.stringify({ type: 'error', payload: { message: 'Missing workspaceId' } }));
+                    sendFrame(ws, JSON.stringify({ type: 'error', payload: { message: 'Missing workspaceId' } }));
                     return;
                 }
                 const subs = clients.get(ws);
                 subs?.delete(workspaceId);
-                ws.send(JSON.stringify({ type: 'unsubscribed', payload: { workspaceId } }));
+                sendFrame(ws, JSON.stringify({ type: 'unsubscribed', payload: { workspaceId } }));
                 break;
             }
             case 'sync:request': {
@@ -89,13 +156,26 @@ export function handleConnection(ws) {
                         // Every other branch of this switch answers on failure; a routed
                         // message that vanishes silently leaves the user waiting forever.
                         const message = err instanceof Error ? err.message : String(err);
-                        ws.send(JSON.stringify({ type: 'error', payload: { message: `Failed to handle '${type}': ${message}` } }));
+                        if (type === 'chat:message' && isRecord(payload) && typeof payload.clientMessageId === 'string') {
+                            sendFrame(ws, JSON.stringify({
+                                type: 'chat:rejected',
+                                workspaceId: payload.workspaceId,
+                                payload: {
+                                    clientMessageId: payload.clientMessageId,
+                                    sessionId: payload.sessionId,
+                                    content: payload.content,
+                                    message,
+                                },
+                            }));
+                            return;
+                        }
+                        sendFrame(ws, JSON.stringify({ type: 'error', payload: { message: `Failed to handle '${type}': ${message}` } }));
                     });
                 }
                 break;
             }
             default:
-                ws.send(JSON.stringify({ type: 'error', payload: { message: `Unknown message type: ${type}` } }));
+                sendFrame(ws, JSON.stringify({ type: 'error', payload: { message: `Unknown message type: ${type}` } }));
         }
     });
     // Heartbeat with a verdict. Pinging without ever waiting for a pong detected
@@ -154,7 +234,7 @@ function insertEventStatement() {
     }
     return cachedInsert.statement;
 }
-export function emit(workspaceId, type, payload, sessionId) {
+export function emit(workspaceId, type, payload, sessionId, options) {
     recordActivity(workspaceId, type, payload, sessionId);
     const id = nanoid();
     const createdAt = new Date().toISOString();
@@ -165,35 +245,48 @@ export function emit(workspaceId, type, payload, sessionId) {
         replayable = true;
     }
     catch (err) {
+        if (options?.requirePersistence)
+            throw err;
         console.error(`[websocket-service] Failed to persist event (workspace=${workspaceId}, type=${type}):`, err);
     }
     // Build the event object to send
     const event = { id, workspaceId, type, payload, sessionId, createdAt, replayable };
+    broadcastPersistedEvent(event);
+    return id;
+}
+/** Insert durably within the caller's transaction; broadcast only after commit. */
+export function persistWorkspaceEvent(workspaceId, type, payload, sessionId) {
+    const event = {
+        id: nanoid(),
+        workspaceId,
+        type,
+        payload,
+        sessionId,
+        createdAt: new Date().toISOString(),
+        replayable: true,
+    };
+    insertEventStatement().run(event.id, workspaceId, type, JSON.stringify(payload), sessionId ?? null, event.createdAt);
+    recordActivity(workspaceId, type, payload, sessionId);
+    return event;
+}
+export function broadcastPersistedEvent(event) {
     const message = JSON.stringify(event);
     // Broadcast to subscribed clients. Wrap `.send` in try/catch so a dropped
     // client doesn't throw and abort delivery to the remaining subscribers.
     let emitSendErrorLogged = false;
     for (const [ws, subs] of clients) {
-        if (subs.has(workspaceId) && ws.readyState === 1 /* WebSocket.OPEN */) {
-            if ((ws.bufferedAmount ?? 0) > MAX_BUFFERED_BYTES) {
-                if (!emitSendErrorLogged) {
-                    console.warn(`[ws] client backlogged, dropping live events (workspace=${workspaceId}, type=${type})`);
-                    emitSendErrorLogged = true;
-                }
-                continue;
-            }
+        if (subs.has(event.workspaceId) && ws.readyState === 1 /* WebSocket.OPEN */) {
             try {
-                ws.send(message);
+                sendFrame(ws, message);
             }
             catch (err) {
                 if (!emitSendErrorLogged) {
-                    console.warn(`[ws] emit send failed (workspace=${workspaceId}, type=${type}):`, err);
+                    console.warn(`[ws] emit send failed (workspace=${event.workspaceId}, type=${event.type}):`, err);
                     emitSendErrorLogged = true;
                 }
             }
         }
     }
-    return id;
 }
 /**
  * Broadcast an event to subscribed clients WITHOUT persisting to the database.
@@ -216,15 +309,8 @@ export function emitEphemeral(workspaceId, type, payload, sessionId) {
     let sendErrorLogged = false;
     for (const [ws, subs] of clients) {
         if (subs.has(workspaceId) && ws.readyState === 1 /* WebSocket.OPEN */) {
-            if ((ws.bufferedAmount ?? 0) > MAX_BUFFERED_BYTES) {
-                if (!sendErrorLogged) {
-                    console.warn(`[ws] client backlogged, dropping ephemeral event (workspace=${workspaceId}, type=${type})`);
-                    sendErrorLogged = true;
-                }
-                continue;
-            }
             try {
-                ws.send(message);
+                sendFrame(ws, message);
             }
             catch (err) {
                 if (!sendErrorLogged) {
@@ -248,7 +334,7 @@ export function handleSyncRequest(ws, lastEventId, workspaceIds) {
             return subs ? [...subs] : [];
         })();
     if (resolvedIds.length === 0) {
-        ws.send(JSON.stringify({ type: 'sync:empty', payload: { message: 'No subscriptions' } }));
+        sendFrame(ws, JSON.stringify({ type: 'sync:empty', payload: { message: 'No subscriptions' } }));
         return;
     }
     // Initial window size: on a fresh connection (no lastEventId), we only
@@ -329,14 +415,14 @@ export function handleSyncRequest(ws, lastEventId, workspaceIds) {
                 replayable: true,
             };
         });
-        ws.send(JSON.stringify({ type: 'sync:response', payload: { events, mode, truncated } }));
+        sendFrame(ws, JSON.stringify({ type: 'sync:response', payload: { events, mode, truncated } }));
     }
     catch (err) {
         // This handler runs inside ws's 'message' callback: an uncaught SQLite
         // error here used to reach the process, not the client.
         console.error('[ws] sync request failed:', err);
         try {
-            ws.send(JSON.stringify({
+            sendFrame(ws, JSON.stringify({
                 type: 'sync:error',
                 payload: { message: err instanceof Error ? err.message : String(err) },
             }));
@@ -372,7 +458,7 @@ export function broadcastAll(type, payload) {
     for (const client of clients.keys()) {
         if (client.readyState === 1 /* WebSocket.OPEN */) {
             try {
-                client.send(message);
+                sendFrame(client, message);
             }
             catch (err) {
                 // client dropped; next iteration will fail its .readyState check.

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

@@ -0,0 +1,128 @@
+import { nanoid } from 'nanoid';
+import { validateDialogueArguments } from '../../shared/workspace-dialogue-tools.js';
+import { parseMessageSource } from '../../shared/workspace-message-types.js';
+import { getDb } from '../db/index.js';
+import { assertWorkspaceLifecycleAvailable } from '../utils/workspace-lifecycle-guard.js';
+import { answerPendingQuestion, getPendingInputs } from './agent/orchestrator.js';
+import { createMcpClientContext } from './mcp-client-context.js';
+import { deliverKeyedMcpMessage } from './mcp-message-delivery-service.js';
+import { deliverWorkspaceMessage } from './workspace-message-service.js';
+import { getActiveSession, getWorkspace, listSessions, listTasks, listWorkspaces } from './workspace-service.js';
+function readableMessage(row) {
+    let payload;
+    try {
+        payload = JSON.parse(row.payload);
+    }
+    catch {
+        return [];
+    }
+    if (!payload || typeof payload !== 'object')
+        return [];
+    let text;
+    if (row.type === 'user:message' && typeof payload.content === 'string')
+        text = payload.content;
+    if (row.type === 'agent:event' && payload.kind === 'message:text' && typeof payload.text === 'string')
+        text = payload.text;
+    if (row.type === 'agent:output') {
+        const content = payload.message?.content;
+        if (Array.isArray(content))
+            text = content
+                .flatMap((block) => (block?.type === 'text' && typeof block.text === 'string' ? [block.text] : []))
+                .join('\n');
+    }
+    return text === undefined
+        ? []
+        : [
+            {
+                id: row.id,
+                sessionId: row.session_id,
+                role: row.type === 'user:message' ? 'user' : 'assistant',
+                text,
+                messageId: typeof payload.messageId === 'string' ? payload.messageId : row.id,
+                createdAt: row.created_at,
+                ...(parseMessageSource(payload.source) ? { source: parseMessageSource(payload.source) } : {}),
+                ...(typeof payload.clientMessageId === 'string' ? { clientMessageId: payload.clientMessageId } : {}),
+            },
+        ];
+}
+export async function executeWorkspaceDialogueTool(name, input, source = createMcpClientContext()) {
+    const args = validateDialogueArguments(name, input);
+    if (name === 'list_workspaces')
+        return listWorkspaces(args.include_archived === true).map((ws) => ({
+            id: ws.id,
+            name: ws.name,
+            status: ws.status,
+            projectPath: ws.projectPath,
+            archivedAt: ws.archivedAt,
+        }));
+    const workspaceId = args.workspace_id;
+    const workspace = getWorkspace(workspaceId);
+    if (!workspace)
+        throw new Error(`Workspace '${workspaceId}' not found`);
+    if (name === 'get_workspace')
+        return { workspace, tasks: listTasks(workspaceId), activeSession: getActiveSession(workspaceId) };
+    if (name === 'list_workspace_sessions')
+        return listSessions(workspaceId);
+    if (name === 'get_workspace_questions') {
+        const pending = getPendingInputs(workspaceId);
+        return {
+            questions: pending.filter((item) => item.kind === 'question'),
+            requiresHumanApproval: pending[0]?.kind === 'permission',
+        };
+    }
+    if (name === 'answer_workspace_question') {
+        assertWorkspaceLifecycleAvailable(workspaceId);
+        if (workspace.archivedAt || workspace.worktreePurgedAt)
+            throw new Error('Restore the workspace before answering a question');
+        const head = getPendingInputs(workspaceId)[0];
+        if (head?.kind !== 'question' || head.toolCallId !== args.tool_call_id)
+            throw new Error('The requested question is not the current pending question');
+        await answerPendingQuestion(workspaceId, args.answers, args.tool_call_id, {
+            source,
+        });
+        return { accepted: true };
+    }
+    if (name === 'send_workspace_message' && args.idempotency_key)
+        return deliverKeyedMcpMessage(workspaceId, args.idempotency_key, {
+            content: args.content,
+            sessionId: args.session_id,
+            source,
+        });
+    if (name === 'send_workspace_message')
+        return {
+            accepted: true,
+            ...(await deliverWorkspaceMessage(workspaceId, {
+                content: args.content,
+                sessionId: args.session_id,
+                clientMessageId: `mcp-${nanoid()}`,
+                source,
+            })),
+        };
+    const db = getDb();
+    let after = 0;
+    if (args.after_cursor) {
+        const cursor = db
+            .prepare('SELECT rowid FROM ws_events WHERE id = ? AND workspace_id = ?')
+            .get(args.after_cursor, workspaceId);
+        if (!cursor)
+            throw new Error('Unknown or expired history cursor for this workspace; restart reading without after_cursor');
+        after = cursor.rowid;
+    }
+    const limit = args.limit ?? 100;
+    const params = [workspaceId, after];
+    if (args.session_id)
+        params.push(args.session_id);
+    params.push(limit + 1);
+    const rows = db
+        .prepare(`SELECT id,session_id,type,payload,created_at FROM ws_events WHERE workspace_id = ? AND rowid > ?
+    ${args.session_id ? 'AND (session_id = ? OR session_id IS NULL)' : ''} ORDER BY rowid LIMIT ?`)
+        .all(...params);
+    const page = rows.slice(0, limit);
+    return {
+        messages: page.flatMap(readableMessage),
+        nextCursor: page.at(-1)?.id ?? args.after_cursor ?? null,
+        hasMore: rows.length > limit,
+        workspaceStatus: workspace.status,
+        activeSessionId: getActiveSession(workspaceId)?.id ?? null,
+    };
+}

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

@@ -0,0 +1,58 @@
+import { assertWorkspaceLifecycleAvailable } from '../utils/workspace-lifecycle-guard.js';
+import { isAgentUnavailableError, isShuttingDown, sendMessage, startAgent } from './agent/orchestrator.js';
+import * as autoLoop from './auto-loop-service.js';
+import { createChatReceipt } from './chat-receipt-service.js';
+import { getActiveSession, getWorkspace, updateWorkspaceStatus } from './workspace-service.js';
+/** Shared delivery for WebSocket chat and external MCP clients. */
+export async function deliverWorkspaceMessage(workspaceId, message, hooks) {
+    const receipt = createChatReceipt(workspaceId, message, hooks?.persist);
+    let reason;
+    try {
+        if (!message.content.trim())
+            throw new Error('Message content must not be empty');
+        if (isShuttingDown())
+            throw new Error('Kōbō is shutting down');
+        assertWorkspaceLifecycleAvailable(workspaceId);
+        const workspace = getWorkspace(workspaceId);
+        if (!workspace)
+            throw new Error(`Workspace '${workspaceId}' not found`);
+        if (workspace.archivedAt || workspace.worktreePurgedAt)
+            throw new Error('Restore the workspace before sending a message');
+        if (workspace.status === 'compacting') {
+            reason = 'compacting';
+            throw new Error('Workspace is compacting its context; wait until compaction finishes before sending a message');
+        }
+        if (workspace.status === 'awaiting-user') {
+            reason = 'awaiting-user';
+            throw new Error('Answer the pending question or permission request before sending a chat message');
+        }
+        const loop = autoLoop.getStatus(workspaceId);
+        if (loop.auto_loop && loop.auto_loop_ready)
+            autoLoop.disable(workspaceId, 'user-action');
+        let sessionId = message.sessionId ?? getActiveSession(workspaceId)?.id;
+        try {
+            if (hooks?.beforeDispatch)
+                await sendMessage(workspaceId, message.content, message.sessionId, hooks.beforeDispatch);
+            else
+                await sendMessage(workspaceId, message.content, message.sessionId);
+        }
+        catch (error) {
+            if (!isAgentUnavailableError(error instanceof Error ? error.message : String(error)))
+                throw error;
+            // Re-read after asynchronous delivery: metadata may have changed meanwhile.
+            assertWorkspaceLifecycleAvailable(workspaceId);
+            const current = getWorkspace(workspaceId);
+            if (!current || current.archivedAt || current.worktreePurgedAt)
+                throw new Error('Workspace is unavailable');
+            const started = startAgent(workspaceId, current.worktreePath, message.content, current.model, true, message.agentPermissionModeOverride ?? current.agentPermissionMode, message.sessionId, current.reasoningEffort, ...(hooks?.beforeDispatch ? [hooks.beforeDispatch] : []));
+            updateWorkspaceStatus(workspaceId, 'executing');
+            sessionId = message.sessionId ?? started.agentSessionId;
+        }
+        receipt.accept(sessionId);
+        return { sessionId };
+    }
+    catch (error) {
+        receipt.reject(error instanceof Error ? error.message : String(error), reason);
+        throw error;
+    }
+}

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

@@ -27,8 +27,33 @@ function stable(value) {
 export function permissionFingerprint(payload) {
     return createHash('sha256').update(stable(payload)).digest('hex');
 }
+const CODEX_EDIT_FINGERPRINT_PREFIX = 'codex-edit-v2:';
+function operationFingerprint(request) {
+    if (request.engine !== 'codex' || request.toolName !== 'Edit')
+        return permissionFingerprint(request.payload);
+    const payload = request.payload;
+    if (payload?.operationApprovalAvailable !== true || !Array.isArray(payload.changes) || payload.changes.length === 0)
+        return null;
+    if (typeof payload.cwd !== 'string' ||
+        payload.changes.some((change) => !change ||
+            typeof change.path !== 'string' ||
+            typeof change.diff !== 'string' ||
+            !change.kind ||
+            !['add', 'delete', 'update'].includes(change.kind.type)))
+        return null;
+    return (CODEX_EDIT_FINGERPRINT_PREFIX +
+        permissionFingerprint({
+            changes: payload.changes,
+            cwd: payload.cwd,
+            grantRoot: payload.grantRoot ?? null,
+        }));
+}
 function toRule(row) {
     return {
+        active: !(row.scope === 'operation' &&
+            row.tool_name === 'Edit' &&
+            (row.engine ?? row.workspace_engine) === 'codex' &&
+            !String(row.fingerprint ?? '').startsWith(CODEX_EDIT_FINGERPRINT_PREFIX)),
         id: String(row.id),
         workspaceId: String(row.workspace_id),
         engine: row.engine,
@@ -42,13 +67,17 @@ function toRule(row) {
 }
 export function listWorkspacePermissionRules(workspaceId) {
     return getDb()
-        .prepare('SELECT * FROM workspace_permission_rules WHERE workspace_id=? ORDER BY created_at DESC')
+        .prepare(`SELECT rules.*, workspaces.engine AS workspace_engine
+        FROM workspace_permission_rules AS rules JOIN workspaces ON workspaces.id=rules.workspace_id
+        WHERE workspace_id=? ORDER BY rules.created_at DESC`)
         .all(workspaceId).map(toRule);
 }
 export function createWorkspacePermissionRule(workspaceId, request, scope) {
     const now = new Date().toISOString();
     const id = nanoid();
-    const fingerprint = scope === 'operation' ? permissionFingerprint(request.payload) : null;
+    const fingerprint = scope === 'operation' ? operationFingerprint(request) : null;
+    if (scope === 'operation' && fingerprint === null)
+        throw new Error('Exact operation details are unavailable');
     const displayLabel = scope === 'tool' ? request.toolName : `${request.toolName} — opération précise`;
     getDb()
         .prepare('INSERT INTO workspace_permission_rules (id,workspace_id,engine,tool_name,scope,fingerprint,display_label,created_at,updated_at) VALUES (?,?,?,?,?,?,?,?,?)')
@@ -61,6 +90,7 @@ export function createWorkspacePermissionRule(workspaceId, request, scope) {
         scope,
         fingerprint,
         displayLabel,
+        active: true,
         createdAt: now,
         updatedAt: now,
     };
@@ -72,7 +102,7 @@ export function removeWorkspacePermissionRule(workspaceId, ruleId) {
 export function isWorkspacePermissionAllowed(workspaceId, request) {
     if (turnRules.get(workspaceId)?.has(turnKey(request)))
         return true;
-    const fingerprint = permissionFingerprint(request.payload);
+    const fingerprint = operationFingerprint(request);
     try {
         return Boolean(getDb()
             .prepare(`SELECT 1 FROM workspace_permission_rules WHERE workspace_id=? AND tool_name=? AND (engine IS NULL OR engine=?) AND (scope='tool' OR (scope='operation' AND fingerprint=?)) LIMIT 1`)

package/dist/server/services/worktree-restore-service.js

@@ -43,13 +43,13 @@ export async function restorePurgedWorktree(id) {
                     headCommitSha: savedHead(workspace.worktreePurgeRestoreData),
                 };
                 if (!workspace.worktreePurgedAt) {
-                    if (!isMatchingWorkspaceWorktree(input)) {
+                    if (!(await isMatchingWorkspaceWorktree(input))) {
                         throw new WorktreeRestoreError('not-purged', 'Workspace is not marked as purged and its checkout is missing or different.');
                     }
                     return { workspace, outcome: 'already-restored', source: 'existing-worktree' };
                 }
                 const checkout = await restoreWorktreeCheckoutUnlocked(input);
-                if (!isMatchingWorkspaceWorktree(input)) {
+                if (!(await isMatchingWorkspaceWorktree(input))) {
                     throw new WorktreeRestoreError('path-conflict', 'The recreated checkout does not match this workspace.');
                 }
                 // Preserve a valid checkout on DB failure. A retry or manual detection can