@loicngr/kobo 1.11.39 → 1.11.41

package/dist/server/routes/workspaces.js

@@ -1,17 +1,21 @@
 import { execFile as execFileCb, execFileSync, spawn } from 'node:child_process';
 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';
 const execFileAsync = promisify(execFileCb);
 import fs from 'node:fs';
 import path from 'node:path';
 import { Hono } from 'hono';
+import { bodyLimit } from 'hono/body-limit';
+import { MAX_ATTACHMENT_REQUEST_BYTES } from '../../shared/attachments.js';
 import { AUTO_LOOP_HARD_RULES, buildAutoLoopGroomingSteps, buildGroomingIntro } from '../../shared/auto-loop-prompts.js';
 import { getDb } from '../db/index.js';
 import { migrationGuard } from '../middleware/migration-guard.js';
 import { listEngines } from '../services/agent/engines/registry.js';
 import * as agentManager from '../services/agent/orchestrator.js';
 import * as archiveScriptService from '../services/archive-script-service.js';
+import { AttachmentRequestError, attachmentReference, readWorkspaceCreationRequest, removeAttachments, saveAttachments, } from '../services/attachment-service.js';
 import * as autoLoopService from '../services/auto-loop-service.js';
 import { changeSourceBranch } from '../services/change-source-branch-service.js';
 import { listChatHistory, pushChatHistory } from '../services/chat-history-service.js';
@@ -59,7 +63,7 @@ function workspaceErrorStatus(err) {
 /** Hono sub-router for workspace CRUD, tasks, agents, Git and PR creation. */
 const app = new Hono();
 // These handlers own teardown across awaits; purge/delete/restore own their guard in the service.
-for (const route of ['/:id/archive', '/:id/run-setup-script', '/:id/cancel-source-change']) {
+for (const route of ['/:id/archive', '/:id/run-setup-script', '/:id/cancel-source-change', '/:id/rollback-file']) {
     app.use(route, async (c, next) => {
         try {
             await withWorkspaceLifecycleGuard(c.req.param('id'), next);
@@ -182,11 +186,16 @@ function emitCreateFailed(creationId, step, message) {
  */
 async function rollbackFailedCreation(workspace, opts) {
     try {
-        return await deleteWorkspaceWithSideEffects(workspace, {
+        const warnings = await deleteWorkspaceWithSideEffects(workspace, {
             deleteLocalBranch: opts.deleteLocalBranch,
+            removeWorktree: opts.removeWorktree,
             // Nothing was ever pushed at this point in the creation flow.
             deleteRemoteBranch: false,
         });
+        if (!opts.removeWorktree && opts.attachments?.length && fs.existsSync(workspace.worktreePath)) {
+            warnings.push(...(await removeAttachments(workspace.worktreePath, opts.attachments)));
+        }
+        return warnings;
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
@@ -351,8 +360,11 @@ app.post('/:id/switch-engine', migrationGuard, async (c) => {
         return c.json({ error: err instanceof Error ? err.message : 'Failed to switch engine' }, 500);
     }
 });
-// POST /api/workspaces — create workspace
-app.post('/', migrationGuard, async (c) => {
+const creationBodyLimit = bodyLimit({
+    maxSize: MAX_ATTACHMENT_REQUEST_BYTES,
+    onError: (c) => c.json({ error: 'Workspace creation request is too large', step: 'validate' }, 413),
+});
+app.post('/', migrationGuard, creationBodyLimit, async (c) => {
     // Declared outside the try so the outermost catch (any unforeseen throw,
     // including a malformed request body) can still name a step instead of
     // leaving the create-progress channel silent. Updated in lockstep with
@@ -368,14 +380,14 @@ app.post('/', migrationGuard, async (c) => {
     // Set only once WE created the worktree, which is also what created the
     // branch. A failure before that point must not delete a branch we never made.
     let createdBranch = false;
+    let createdWorktree = false;
+    let creationAttachments = [];
     // Hoisted out of the `build-prompt` block (declared with `const` there) so
     // both rollback paths — the `start-agent` branch and the outermost catch —
     // can read it to decide whether the setup-script caveat applies.
     let setupScriptConfigured = false;
     try {
-        const body = await c.req
-            .json()
-            .catch(() => ({}));
+        const { body, attachments } = await readWorkspaceCreationRequest(c.req.raw);
         // workingBranch is derived from git when worktreePath is provided, so
         // it's not required in that flow. The other 3 fields stay mandatory.
         if (!body.name || !body.projectPath || !body.sourceBranch) {
@@ -671,190 +683,206 @@ app.post('/', migrationGuard, async (c) => {
         //      worktree path so they stay aligned.
         currentStep = 'create-record';
         emitCreateProgress(creationId, currentStep);
-        let prospectiveWorktreePath;
         let workingBranchAdjusted = false;
-        if (useReusedWorktree) {
-            prospectiveWorktreePath = body.worktreePath;
-        }
-        else {
-            try {
-                const resolved = resolveUniqueBranchAndPath({
-                    projectPath: body.projectPath,
-                    baseBranch: workingBranch,
-                    worktreesPath: globalSettings.worktreesPath,
-                    projectSlug,
-                });
-                workingBranch = resolved.workingBranch;
-                prospectiveWorktreePath = resolved.worktreePath;
-                workingBranchAdjusted = resolved.adjusted;
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                emitCreateFailed(creationId, 'create-record', message);
-                return c.json({ error: message, step: 'create-record' }, 409);
+        // Allocate the unique branch/path and create its checkout under one lock.
+        // Cleanup is deliberately outside: it acquires the same repository lock.
+        const creation = await withGitRepoLock(body.projectPath, async () => {
+            let prospectiveWorktreePath;
+            if (useReusedWorktree) {
+                // Another attachment may have completed while this request waited for the lock.
+                const existing = getDb().prepare('SELECT id FROM workspaces WHERE worktree_path = ?').get(body.worktreePath);
+                if (existing) {
+                    const failure = 'This worktree is already attached to another Kōbō workspace';
+                    emitCreateFailed(creationId, 'inspect-worktree', failure);
+                    return c.json({ error: failure, step: 'inspect-worktree' }, 422);
+                }
+                prospectiveWorktreePath = body.worktreePath;
             }
-        }
-        let workspace = workspaceService.createWorkspace({
-            name: body.name,
-            projectPath: body.projectPath,
-            sourceBranch: body.sourceBranch,
-            workingBranch,
-            notionUrl: body.notionUrl,
-            notionPageId: body.notionPageId,
-            sentryUrl: body.sentryUrl,
-            prUrl: body.prUrl,
-            worktreePath: prospectiveWorktreePath,
-            worktreeOwned: !useReusedWorktree,
-            model: body.model,
-            brainstormModel: body.brainstormModel,
-            reasoningEffort: body.reasoningEffort,
-            agentPermissionMode: resolveCreateAgentPermissionMode(body.agentPermissionMode, body.projectPath, globalSettings, body.engine ?? 'claude-code'),
-            engine: body.engine,
-            // Set by the engine-comparison flow, which posts here once per engine
-            // with the same id so the resulting workspaces can find each other.
-            comparisonId: body.comparisonId,
-            ...(useReusedWorktree ? {} : { worktreesPath: globalSettings.worktreesPath }),
-        });
-        createdWorkspace = workspace;
-        // Enable auto-loop before starting the initial brainstorming session so
-        // its model override is available when selecting that session's model.
-        if (body.autoLoop === true) {
-            const notionProducedTasks = body.notionUrl !== undefined &&
-                notionContent != null &&
-                notionContent.todos.length > 0 &&
-                notionContent.gherkinFeatures.length > 0;
-            const sessionMode = body.autoLoopSessionMode === 'continuous' ? 'continuous' : 'per_task';
-            const db = getDb();
-            db.prepare('UPDATE workspaces SET auto_loop = 1, auto_loop_ready = ?, auto_loop_session_mode = ? WHERE id = ?').run(notionProducedTasks ? 1 : 0, sessionMode, workspace.id);
-            workspace = workspaceService.getWorkspace(workspace.id) ?? workspace;
-            // Emit events so the frontend refreshes autoLoopStates without F5.
-            wsService.emitEphemeral(workspace.id, 'autoloop:enabled', {});
-            if (notionProducedTasks) {
-                wsService.emitEphemeral(workspace.id, 'autoloop:ready-flipped', {});
+            else {
+                try {
+                    const resolved = resolveUniqueBranchAndPath({
+                        projectPath: body.projectPath,
+                        baseBranch: workingBranch,
+                        worktreesPath: globalSettings.worktreesPath,
+                        projectSlug,
+                    });
+                    workingBranch = resolved.workingBranch;
+                    prospectiveWorktreePath = resolved.worktreePath;
+                    workingBranchAdjusted = resolved.adjusted;
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    emitCreateFailed(creationId, 'create-record', message);
+                    return c.json({ error: message, step: 'create-record' }, 409);
+                }
             }
-        }
-        // Auto-tag the workspace based on its creation source — `notion` when
-        // imported from a Notion page, `sentry` when bootstrapped from a Sentry
-        // issue URL. Pre-seeded in the global tag catalogue via migration v9.
-        // Skip any tag the user has removed from the catalogue so we respect
-        // their choice (they may have pruned "notion"/"sentry" on purpose).
-        const catalogTags = new Set(globalSettings.tags ?? []);
-        const autoTags = [];
-        if (body.notionUrl && catalogTags.has('notion'))
-            autoTags.push('notion');
-        if (body.sentryUrl && catalogTags.has('sentry'))
-            autoTags.push('sentry');
-        if (autoTags.length > 0) {
-            try {
-                const tagged = workspaceService.setWorkspaceTags(workspace.id, autoTags);
-                if (tagged)
-                    workspace = tagged;
+            let workspace = workspaceService.createWorkspace({
+                name: body.name,
+                projectPath: body.projectPath,
+                sourceBranch: body.sourceBranch,
+                workingBranch,
+                notionUrl: body.notionUrl,
+                notionPageId: body.notionPageId,
+                sentryUrl: body.sentryUrl,
+                prUrl: body.prUrl,
+                worktreePath: prospectiveWorktreePath,
+                worktreeOwned: !useReusedWorktree,
+                model: body.model,
+                brainstormModel: body.brainstormModel,
+                reasoningEffort: body.reasoningEffort,
+                agentPermissionMode: resolveCreateAgentPermissionMode(body.agentPermissionMode, body.projectPath, globalSettings, body.engine ?? 'claude-code'),
+                engine: body.engine,
+                // Set by the engine-comparison flow, which posts here once per engine
+                // with the same id so the resulting workspaces can find each other.
+                comparisonId: body.comparisonId,
+                ...(useReusedWorktree ? {} : { worktreesPath: globalSettings.worktreesPath }),
+            });
+            createdWorkspace = workspace;
+            // Enable auto-loop before starting the initial brainstorming session so
+            // its model override is available when selecting that session's model.
+            if (body.autoLoop === true) {
+                const notionProducedTasks = body.notionUrl !== undefined &&
+                    notionContent != null &&
+                    notionContent.todos.length > 0 &&
+                    notionContent.gherkinFeatures.length > 0;
+                const sessionMode = body.autoLoopSessionMode === 'continuous' ? 'continuous' : 'per_task';
+                const db = getDb();
+                db.prepare('UPDATE workspaces SET auto_loop = 1, auto_loop_ready = ?, auto_loop_session_mode = ? WHERE id = ?').run(notionProducedTasks ? 1 : 0, sessionMode, workspace.id);
+                workspace = workspaceService.getWorkspace(workspace.id) ?? workspace;
+                // Emit events so the frontend refreshes autoLoopStates without F5.
+                wsService.emitEphemeral(workspace.id, 'autoloop:enabled', {});
+                if (notionProducedTasks) {
+                    wsService.emitEphemeral(workspace.id, 'autoloop:ready-flipped', {});
+                }
             }
-            catch (err) {
-                console.error('[workspaces] Failed to apply auto tags:', err);
+            // Auto-tag the workspace based on its creation source — `notion` when
+            // imported from a Notion page, `sentry` when bootstrapped from a Sentry
+            // issue URL. Pre-seeded in the global tag catalogue via migration v9.
+            // Skip any tag the user has removed from the catalogue so we respect
+            // their choice (they may have pruned "notion"/"sentry" on purpose).
+            const catalogTags = new Set(globalSettings.tags ?? []);
+            const autoTags = [];
+            if (body.notionUrl && catalogTags.has('notion'))
+                autoTags.push('notion');
+            if (body.sentryUrl && catalogTags.has('sentry'))
+                autoTags.push('sentry');
+            if (autoTags.length > 0) {
+                try {
+                    const tagged = workspaceService.setWorkspaceTags(workspace.id, autoTags);
+                    if (tagged)
+                        workspace = tagged;
+                }
+                catch (err) {
+                    console.error('[workspaces] Failed to apply auto tags:', err);
+                }
             }
-        }
-        // Update workspace name with Sentry issue title if the user did not provide
-        // a custom name and Notion hasn't already filled it. Prefix with the Sentry
-        // short-id (e.g. "SEKUR-IOS-9 | TypeError: …") so the workspace stays
-        // identifiable in the sidebar without opening the panel.
-        if (sentryContent?.title && !notionContent?.title) {
-            const prefix = sentryContent.issueId ? `${sentryContent.issueId} | ` : '';
-            const renamed = resolveExtractedName(workspace.name, `${prefix}${sentryContent.title}`);
-            if (renamed)
-                workspace = workspaceService.updateWorkspaceName(workspace.id, renamed);
-        }
-        currentStep = 'create-tasks';
-        emitCreateProgress(creationId, currentStep);
-        // Create tasks from extracted Notion data
-        if (notionContent) {
-            let sortOrder = 0;
-            for (const todo of notionContent.todos) {
-                workspaceService.createTask(workspace.id, {
-                    title: todo.title,
-                    isAcceptanceCriterion: false,
-                    sortOrder: sortOrder++,
-                });
+            // Update workspace name with Sentry issue title if the user did not provide
+            // a custom name and Notion hasn't already filled it. Prefix with the Sentry
+            // short-id (e.g. "SEKUR-IOS-9 | TypeError: …") so the workspace stays
+            // identifiable in the sidebar without opening the panel.
+            if (sentryContent?.title && !notionContent?.title) {
+                const prefix = sentryContent.issueId ? `${sentryContent.issueId} | ` : '';
+                const renamed = resolveExtractedName(workspace.name, `${prefix}${sentryContent.title}`);
+                if (renamed)
+                    workspace = workspaceService.updateWorkspaceName(workspace.id, renamed);
             }
-            for (const feature of notionContent.gherkinFeatures) {
-                workspaceService.createTask(workspace.id, {
-                    title: feature,
-                    isAcceptanceCriterion: true,
-                    sortOrder: sortOrder++,
-                });
+            currentStep = 'create-tasks';
+            emitCreateProgress(creationId, currentStep);
+            // Create tasks from extracted Notion data
+            if (notionContent) {
+                let sortOrder = 0;
+                for (const todo of notionContent.todos) {
+                    workspaceService.createTask(workspace.id, {
+                        title: todo.title,
+                        isAcceptanceCriterion: false,
+                        sortOrder: sortOrder++,
+                    });
+                }
+                for (const feature of notionContent.gherkinFeatures) {
+                    workspaceService.createTask(workspace.id, {
+                        title: feature,
+                        isAcceptanceCriterion: true,
+                        sortOrder: sortOrder++,
+                    });
+                }
+                // Update workspace name with Notion page title only if user didn't
+                // provide a custom name. Prefix with the Notion unique-id (e.g.
+                // Use the Notion page title when the user left the generic placeholder.
+                if (notionContent.title) {
+                    const renamed = resolveExtractedName(workspace.name, notionContent.title);
+                    if (renamed)
+                        workspace = workspaceService.updateWorkspaceName(workspace.id, renamed);
+                }
             }
-            // Update workspace name with Notion page title only if user didn't
-            // provide a custom name. Prefix with the Notion unique-id (e.g.
-            // Use the Notion page title when the user left the generic placeholder.
-            if (notionContent.title) {
-                const renamed = resolveExtractedName(workspace.name, notionContent.title);
+            // Update workspace name with the PR/MR title if the user did not provide
+            // a custom name and neither Notion nor Sentry already claimed it. This
+            // makes the PR a THIRD context source, lowest priority of the three
+            // (Notion > Sentry > PR), consistent with the checks above.
+            if (prContent && !notionContent?.title && !sentryContent?.title) {
+                const renamed = resolveExtractedName(workspace.name, prContent.title);
                 if (renamed)
                     workspace = workspaceService.updateWorkspaceName(workspace.id, renamed);
             }
-        }
-        // Update workspace name with the PR/MR title if the user did not provide
-        // a custom name and neither Notion nor Sentry already claimed it. This
-        // makes the PR a THIRD context source, lowest priority of the three
-        // (Notion > Sentry > PR), consistent with the checks above.
-        if (prContent && !notionContent?.title && !sentryContent?.title) {
-            const renamed = resolveExtractedName(workspace.name, prContent.title);
-            if (renamed)
-                workspace = workspaceService.updateWorkspaceName(workspace.id, renamed);
-        }
-        // Create manual tasks/criteria if no Notion content was extracted
-        if (!notionContent && (Array.isArray(body.tasks) || Array.isArray(body.acceptanceCriteria))) {
-            let sortOrder = 0;
-            if (Array.isArray(body.tasks)) {
-                for (const title of body.tasks) {
-                    if (typeof title === 'string' && title.trim()) {
-                        workspaceService.createTask(workspace.id, {
-                            title: title.trim(),
-                            isAcceptanceCriterion: false,
-                            sortOrder: sortOrder++,
-                        });
+            // Create manual tasks/criteria if no Notion content was extracted
+            if (!notionContent && (Array.isArray(body.tasks) || Array.isArray(body.acceptanceCriteria))) {
+                let sortOrder = 0;
+                if (Array.isArray(body.tasks)) {
+                    for (const title of body.tasks) {
+                        if (typeof title === 'string' && title.trim()) {
+                            workspaceService.createTask(workspace.id, {
+                                title: title.trim(),
+                                isAcceptanceCriterion: false,
+                                sortOrder: sortOrder++,
+                            });
+                        }
                     }
                 }
-            }
-            if (Array.isArray(body.acceptanceCriteria)) {
-                for (const title of body.acceptanceCriteria) {
-                    if (typeof title === 'string' && title.trim()) {
-                        workspaceService.createTask(workspace.id, {
-                            title: title.trim(),
-                            isAcceptanceCriterion: true,
-                            sortOrder: sortOrder++,
-                        });
+                if (Array.isArray(body.acceptanceCriteria)) {
+                    for (const title of body.acceptanceCriteria) {
+                        if (typeof title === 'string' && title.trim()) {
+                            workspaceService.createTask(workspace.id, {
+                                title: title.trim(),
+                                isAcceptanceCriterion: true,
+                                sortOrder: sortOrder++,
+                            });
+                        }
                     }
                 }
             }
-        }
-        currentStep = 'create-worktree';
-        emitCreateProgress(creationId, currentStep);
-        // Create git worktree for the working branch — unless we're reusing an
-        // existing one, in which case the path is taken straight from the body.
-        let worktreePath;
-        if (useReusedWorktree) {
-            worktreePath = body.worktreePath;
-        }
-        else {
-            try {
-                const created = worktreeService.createWorktree(body.projectPath, workingBranch, baseRef, globalSettings.worktreesPath, projectSlug);
-                worktreePath = created.worktreePath;
-                // Not an assumption: `createWorktree` reports which git command it ran.
-                // It falls back to attaching an existing branch, and deleting that one
-                // on rollback would destroy commits the user made before Kobo existed.
-                createdBranch = created.branchCreated;
+            currentStep = 'create-worktree';
+            emitCreateProgress(creationId, currentStep);
+            // Create git worktree for the working branch — unless we're reusing an
+            // existing one, in which case the path is taken straight from the body.
+            let worktreePath;
+            if (useReusedWorktree) {
+                worktreePath = body.worktreePath;
             }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                // Roll back the half-created workspace through the SHARED demolition
-                // path — a second inline cleanup here would drift from it. The branch
-                // is not deleted: `createWorktree` failed, so we never created one.
-                const rollbackWarnings = await rollbackFailedCreation(workspace, { deleteLocalBranch: false });
-                const failure = `Failed to create worktree: ${message}`;
-                emitCreateFailed(creationId, 'create-worktree', failure);
-                return c.json({ error: failure, step: 'create-worktree', rollback: { done: true, warnings: rollbackWarnings } }, 500);
+            else {
+                try {
+                    const created = await worktreeService.createWorktreeUnlocked(body.projectPath, workingBranch, baseRef, globalSettings.worktreesPath, projectSlug);
+                    worktreePath = created.worktreePath;
+                    // Not an assumption: `createWorktree` reports which git command it ran.
+                    // It falls back to attaching an existing branch, and deleting that one
+                    // on rollback would destroy commits the user made before Kobo existed.
+                    createdBranch = created.branchCreated;
+                    createdWorktree = true;
+                }
+                catch (err) {
+                    if (err instanceof worktreeService.WorktreeCreationError) {
+                        createdWorktree = true;
+                        createdBranch = err.branchCreated;
+                    }
+                    throw new Error(`Failed to create worktree: ${err instanceof Error ? err.message : String(err)}`, {
+                        cause: err,
+                    });
+                }
             }
-        }
+            return { workspace, worktreePath };
+        });
+        if (creation instanceof Response)
+            return creation;
+        const { workspace } = creation;
+        const { worktreePath } = creation;
         currentStep = 'write-conventions';
         emitCreateProgress(creationId, currentStep);
         // Ensure Kobo-generated files are gitignored. Check both the root
@@ -871,6 +899,7 @@ app.post('/', migrationGuard, async (c) => {
                 ['.ai/.git-conventions.md', '.git-conventions.md'],
                 ['.ai/thoughts/', 'thoughts/'],
                 ['.ai/images/', 'images/'],
+                ['.ai/attachments/', 'attachments/'],
                 ['.ai/.setup-script.tmp', '.setup-script.tmp'],
                 ['.ai/.cleanup-script.tmp', '.cleanup-script.tmp'],
                 ['.ai/.archive-script.tmp', '.archive-script.tmp'],
@@ -924,6 +953,12 @@ app.post('/', migrationGuard, async (c) => {
         let agentStartError = null;
         currentStep = 'write-context-files';
         emitCreateProgress(creationId, currentStep);
+        creationAttachments = await saveAttachments(worktreePath, attachments);
+        if (creationAttachments.length > 0) {
+            body.description = [body.description?.trim(), ...creationAttachments.map(attachmentReference)]
+                .filter(Boolean)
+                .join('\n\n');
+        }
         // Save Notion content as markdown in worktree
         let notionFilePath = null;
         if (notionContent && body.notionUrl) {
@@ -1322,12 +1357,19 @@ Once the brainstorming + planning steps above are complete and you have a saved
             // already guards the worktree via `worktreeOwned`; the branch flag is
             // ours to set.
             const rollbackWarnings = await rollbackFailedCreation(workspace, {
-                deleteLocalBranch: !useReusedWorktree,
+                deleteLocalBranch: createdBranch,
+                removeWorktree: createdWorktree,
+                attachments: creationAttachments,
             });
             // The setup script has already run by this point — see the caveat's own
             // comment for what that rollback cannot reach.
             const setupCaveat = setupScriptConfigured ? SETUP_SCRIPT_ROLLBACK_CAVEAT : '';
-            const failure = `Failed to start the agent: ${agentStartError}. The workspace, its worktree and its branch were removed.${setupCaveat}`;
+            const removed = createdBranch
+                ? 'The workspace, its worktree and its branch were removed.'
+                : createdWorktree
+                    ? 'The workspace and its worktree were removed.'
+                    : 'The half-created workspace was removed.';
+            const failure = `Failed to start the agent: ${agentStartError}. ${removed}${setupCaveat}`;
             emitCreateFailed(creationId, 'start-agent', failure);
             return c.json({ error: failure, step: 'start-agent', rollback: { done: true, warnings: rollbackWarnings } }, 500);
         }
@@ -1372,7 +1414,11 @@ Once the brainstorming + planning steps above are complete and you have a saved
         // reported error.
         if (createdWorkspace) {
             emitCreateProgress(creationId, 'rollback');
-            const rollbackWarnings = await rollbackFailedCreation(createdWorkspace, { deleteLocalBranch: createdBranch });
+            const rollbackWarnings = await rollbackFailedCreation(createdWorkspace, {
+                deleteLocalBranch: createdBranch,
+                removeWorktree: createdWorktree,
+                attachments: creationAttachments,
+            });
             logError('workspaces', 'Rolled back a creation that failed outside any per-step handler', {
                 workspaceId: createdWorkspace.id,
                 step: currentStep,
@@ -1390,7 +1436,7 @@ Once the brainstorming + planning steps above are complete and you have a saved
             return c.json({ error: failure, step: currentStep, rollback: { done: true, warnings: rollbackWarnings } }, 500);
         }
         emitCreateFailed(creationId, currentStep, message);
-        return c.json({ error: message, step: currentStep }, 500);
+        return c.json({ error: message, step: currentStep }, err instanceof AttachmentRequestError ? 400 : 500);
     }
 });
 // POST /api/workspaces/:id/sessions — create a new idle agent session
@@ -1450,8 +1496,10 @@ app.get('/pr-states', (c) => {
 // stay before GET /:id.
 app.get('/info', (c) => {
     try {
+        const workspaces = workspaceService.listWorkspaces(false);
         return c.json({
-            workspaces: workspaceService.listWorkspaces(false),
+            workspaces,
+            pendingInputs: Object.fromEntries(workspaces.map((workspace) => [workspace.id, agentManager.getPendingInputs(workspace.id)])),
             prSnapshots: getAllPrSnapshots(),
             gitStats: getAllGitStats(),
             // In-memory truth, not the `status` column: a workspace missing from
@@ -2119,12 +2167,8 @@ app.post('/:id/tasks/:taskId/notify-done', (c) => {
         return c.json({ error: message }, workspaceErrorStatus(err));
     }
 });
-// Cap how many recent rows one search may scan: the LIKE below cannot use an
-// index past the workspace_id prefix, and better-sqlite3 is synchronous — an
-// unbounded scan of a months-old workspace blocks every request and WS emit.
-const HISTORY_SEARCH_SCAN_CAP = 20_000;
-// GET /api/workspaces/:id/history-search — full-workspace persisted conversation search.
-app.get('/:id/history-search', (c) => {
+// GET /api/workspaces/:id/history-search — the same logical-message index as global search.
+app.get('/:id/history-search', async (c) => {
     try {
         const id = c.req.param('id');
         if (!workspaceService.getWorkspace(id))
@@ -2132,71 +2176,23 @@ app.get('/:id/history-search', (c) => {
         const query = (c.req.query('q') ?? '').trim();
         if (query.length < 2)
             return c.json({ results: [] });
-        const limit = Math.min(parseInt(c.req.query('limit') ?? '30', 10) || 30, 100);
-        const needle = `%${query.replace(/[%_]/g, '\\$&')}%`;
-        const rows = getDb()
-            .prepare(`SELECT id, session_id, type, payload, created_at FROM (
-           SELECT rowid AS rid, id, session_id, type, payload, created_at FROM ws_events
-           WHERE workspace_id = ? ORDER BY rowid DESC LIMIT ?
-         )
-         WHERE payload LIKE ? ESCAPE '\\'
-         ORDER BY rid DESC LIMIT ?`)
-            .all(id, HISTORY_SEARCH_SCAN_CAP, needle, limit * 4);
-        const normalized = rows.flatMap((row) => {
-            const result = readableHistorySearchResult(row.type, row.payload, query);
-            if (!result)
-                return [];
-            return [{ eventId: row.id, sessionId: row.session_id, createdAt: row.created_at, ...result }];
+        const limit = Math.max(1, Math.min(parseInt(c.req.query('limit') ?? '30', 10) || 30, 100));
+        const results = await searchEvents(query, { workspaceId: id, includeArchived: true, limit }, c.req.raw.signal);
+        return c.json({
+            results: results.map((result) => ({
+                eventId: result.eventId,
+                sessionId: result.sessionId,
+                createdAt: result.timestamp,
+                kind: result.type === 'user:message' ? 'user' : 'agent',
+                snippet: result.snippet,
+            })),
+            partial: getSearchIndexStatus().state !== 'ready',
         });
-        return c.json({ results: normalized.slice(0, limit) });
     }
     catch (err) {
-        return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+        return c.json({ error: err instanceof Error ? err.message : String(err) }, 503);
     }
 });
-function readableHistorySearchResult(type, rawPayload, query) {
-    let payload;
-    try {
-        payload = JSON.parse(rawPayload);
-    }
-    catch {
-        return null;
-    }
-    let text = null;
-    let kind = 'agent';
-    if (type === 'user:message') {
-        text = typeof payload.content === 'string' ? payload.content : null;
-        kind = 'user';
-    }
-    else if (type === 'agent:event') {
-        if (payload.kind === 'message:text' && typeof payload.text === 'string')
-            text = payload.text;
-    }
-    else if (type === 'agent:output') {
-        const message = payload.message;
-        if (Array.isArray(message?.content)) {
-            text = message.content
-                .flatMap((block) => {
-                if (!block || typeof block !== 'object')
-                    return [];
-                const candidate = block;
-                return candidate.type === 'text' && typeof candidate.text === 'string' ? [candidate.text] : [];
-            })
-                .join('\n');
-        }
-    }
-    if (!text)
-        return null;
-    const matchIndex = text.toLowerCase().indexOf(query.toLowerCase());
-    if (matchIndex < 0)
-        return null;
-    const start = Math.max(0, matchIndex - 90);
-    const end = Math.min(text.length, matchIndex + query.length + 180);
-    return {
-        kind,
-        snippet: `${start > 0 ? '…' : ''}${text.slice(start, end).replace(/\s+/g, ' ').trim()}${end < text.length ? '…' : ''}`,
-    };
-}
 /**
  * GET /api/workspaces/:id/sessions/:sessionId/summary — why a session ended.
  *
@@ -3061,7 +3057,7 @@ async function deleteWorkspaceWithSideEffectsUnlocked(workspace, opts) {
     if (workspace.worktreePurgedAt) {
         console.log(`[workspaces] skipping worktree removal on delete (already purged): ${worktreePath}`);
     }
-    else if (workspace.worktreeOwned) {
+    else if (workspace.worktreeOwned && opts.removeWorktree !== false) {
         try {
             await worktreeService.removeWorktree(workspace.projectPath, worktreePath);
         }
@@ -3423,7 +3419,7 @@ app.post('/:id/rollback-file', async (c) => {
             return c.json({ error: `Workspace '${id}' not found` }, 404);
         }
         const body = await c.req.json().catch(() => ({}));
-        const filePath = typeof body?.path === 'string' ? body.path.trim() : '';
+        const filePath = typeof body?.path === 'string' ? body.path : '';
         if (!filePath) {
             return c.json({ error: 'Missing or invalid `path` field' }, 400);
         }
@@ -3436,7 +3432,13 @@ app.post('/:id/rollback-file', async (c) => {
         }
         let target;
         try {
-            target = gitOps.rollbackFile(workspace.worktreePath, workspace.workingBranch, filePath);
+            target = await withGitRepoLock(workspace.worktreePath, async () => {
+                if (agentManager.getAgentStatus(id) !== null)
+                    throw new Error('Stop the agent before rolling back a file');
+                gitOps.assertCurrentBranch(workspace.worktreePath, workspace.workingBranch);
+                gitOps.assertNoIndexLock(workspace.worktreePath);
+                return gitOps.rollbackFile(workspace.worktreePath, workspace.workingBranch, filePath);
+            });
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);