@loicngr/kobo 1.7.17 → 1.7.19

package/CHANGELOG.md

@@ -4,6 +4,20 @@ All notable changes to Kōbō are documented here. The format is based on
 [Keep a Changelog](https://keepachangelog.com/). Each release is an `## <version>`
 section — the in-app "What's new" dialog reads this file.
 
+## 1.7.19
+
+- feat(client): archived banner, Fix-CI button, changelog page, prompt-retry banner (Open archived workspace)
+- feat(server): workspace lifecycle, CI failure UX, collision-safe creation (error in setup script)
+- feat(client): disable mutating actions on archived workspaces
+- feat(pr-watcher): mark workspace unread on attention transitions (ci request changes)
+- chore(deps): npm audit fix
+- chore(CHANGELOG): update
+
+## 1.7.18
+
+- chore(audit): fix npm audit
+- feat(client): collapsible ask-user-question panel
+
 ## 1.7.17
 
 - feat: per-workspace chat history + inline file editing in the diff viewer

package/dist/server/db/migrations.js

@@ -300,6 +300,25 @@ export const migrations = [
       `);
         },
     },
+    {
+        version: 25,
+        name: 'add-workspace-initial-prompt',
+        migrate: (db) => {
+            // Stores the initial agent prompt assembled at workspace-creation time so
+            // it survives a setup-script crash. Cleared after the agent successfully
+            // ingests it; null otherwise (= nothing pending or already consumed).
+            // Defensive: skip if the workspaces table doesn't exist yet — covers
+            // synthetic test DBs that seed only a subset of tables before running
+            // migrations.
+            const table = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='workspaces'").get();
+            if (!table)
+                return;
+            const cols = db.prepare('PRAGMA table_info(workspaces)').all();
+            if (!cols.some((c) => c.name === 'initial_prompt')) {
+                db.prepare('ALTER TABLE workspaces ADD COLUMN initial_prompt TEXT').run();
+            }
+        },
+    },
 ];
 /** Current schema version — always equals the highest migration version. */
 export const SCHEMA_VERSION = migrations.length > 0 ? migrations[migrations.length - 1].version : 1;

package/dist/server/db/schema.js

@@ -29,6 +29,7 @@ export function initSchema(db) {
       agent_permission_mode TEXT NOT NULL DEFAULT 'bypass',
       description TEXT,
       agent_description TEXT,
+      initial_prompt TEXT,
       created_at TEXT NOT NULL,
       updated_at TEXT NOT NULL
     );

package/dist/server/routes/settings.js

@@ -3,7 +3,7 @@ import { DEFAULT_NOTION_INITIAL_PROMPT, DEFAULT_SENTRY_INITIAL_PROMPT, } from '.
 import { DEFAULT_REVIEW_PROMPT_TEMPLATE } from '../services/review-template-service.js';
 import { DEFAULT_CHANGE_SOURCE_BRANCH_SCRIPT } from '../services/settings-defaults.js';
 import * as settingsService from '../services/settings-service.js';
-import { DEFAULT_GIT_CONVENTIONS, DEFAULT_PR_PROMPT_TEMPLATE, } from '../services/settings-service.js';
+import { DEFAULT_CI_FIX_PROMPT_TEMPLATE, DEFAULT_GIT_CONVENTIONS, DEFAULT_PR_PROMPT_TEMPLATE, } from '../services/settings-service.js';
 import { listTemplates, replaceAllTemplates } from '../services/templates-service.js';
 /** Hono sub-router for global and per-project settings CRUD. */
 const app = new Hono();
@@ -37,6 +37,7 @@ app.get('/defaults', (c) => {
     return c.json({
         prPromptTemplate: DEFAULT_PR_PROMPT_TEMPLATE,
         reviewPromptTemplate: DEFAULT_REVIEW_PROMPT_TEMPLATE,
+        ciFixPromptTemplate: DEFAULT_CI_FIX_PROMPT_TEMPLATE,
         gitConventions: DEFAULT_GIT_CONVENTIONS,
         notionInitialPromptTemplate: DEFAULT_NOTION_INITIAL_PROMPT,
         sentryInitialPromptTemplate: DEFAULT_SENTRY_INITIAL_PROMPT,

package/dist/server/routes/workspaces.js

@@ -13,6 +13,7 @@ import * as archiveScriptService from '../services/archive-script-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';
+import { renderCiFixTemplate } from '../services/ci-fix-template-service.js';
 import * as cronService from '../services/cron-service.js';
 import * as devServerService from '../services/dev-server-service.js';
 import { saveWorkspaceFile, shaOf } from '../services/file-editor-service.js';
@@ -35,9 +36,10 @@ import * as wakeupService from '../services/wakeup-service.js';
 import * as wsService from '../services/websocket-service.js';
 import * as workspaceService from '../services/workspace-service.js';
 import * as worktreeService from '../services/worktree-service.js';
+import { resolveUniqueBranchAndPath } from '../utils/branch-resolver.js';
 import * as gitOps from '../utils/git-ops.js';
 import { slugifyProjectName } from '../utils/project-slug.js';
-import { resolveSiblingWorkspaceWorktreePath, resolveWorkspaceWorktreePath } from '../utils/worktree-paths.js';
+import { resolveSiblingWorkspaceWorktreePath } from '../utils/worktree-paths.js';
 /** Hono sub-router for workspace CRUD, tasks, agent lifecycle, git operations, and PR creation. */
 const app = new Hono();
 /** Tracks workspaces currently running a setup script to prevent concurrent executions. */
@@ -242,17 +244,33 @@ app.post('/', migrationGuard, async (c) => {
             ? slugifyProjectName(projectSettings?.displayName ?? '', body.projectPath)
             : undefined;
         // Resolve the prospective worktree path unconditionally so that:
-        //   1. We can refuse the request before any DB write when the path exists.
-        //   2. createWorkspace always receives the correct slug-prefixed path and
+        //   1. createWorkspace always receives the correct slug-prefixed path and
         //      never falls back to the no-slug resolver inside workspace-service.
+        //   2. When the requested branch / on-disk path is already taken we append
+        //      a short hash (e.g. `feature/foo-A45C`) instead of rejecting the
+        //      request — keeps the user's flow smooth at the cost of a longer
+        //      branch name. The same hash is applied to BOTH the branch and the
+        //      worktree path so they stay aligned.
         let prospectiveWorktreePath;
+        let workingBranchAdjusted = false;
         if (useReusedWorktree) {
             prospectiveWorktreePath = body.worktreePath;
         }
         else {
-            prospectiveWorktreePath = resolveWorkspaceWorktreePath(body.projectPath, workingBranch, globalSettings.worktreesPath, projectSlug);
-            if (fs.existsSync(prospectiveWorktreePath)) {
-                return c.json({ error: `Worktree path already exists: ${prospectiveWorktreePath}` }, 409);
+            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);
+                return c.json({ error: message }, 409);
             }
         }
         let workspace = workspaceService.createWorkspace({
@@ -413,33 +431,10 @@ app.post('/', migrationGuard, async (c) => {
                 console.error('[workspaces] Failed to write .git-conventions.md:', err);
             }
         }
-        // Run setup script if configured and not skipped
+        // The setup script runs LATER (after the brainstorm prompt is built and
+        // persisted via setInitialPrompt). This guarantees the prompt survives a
+        // setup-script crash and can be replayed by /:id/start.
         let setupScriptFailed = false;
-        // Skip the setup script when reusing an existing worktree — the user
-        // already has the environment set up there and rerunning it could be
-        // destructive (drop a node_modules they curated, etc.).
-        if (effectiveSettings.setupScript && !body.skipSetupScript && !useReusedWorktree) {
-            workspaceService.updateWorkspaceStatus(workspace.id, 'extracting');
-            wsService.emit(workspace.id, 'setup:output', { text: '[kobo] Running setup script...' });
-            try {
-                const result = await runSetupScript(workspace.id, worktreePath, effectiveSettings.setupScript, {
-                    workspaceName: workspace.name,
-                    branchName: workingBranch,
-                    sourceBranch: body.sourceBranch,
-                    projectPath: body.projectPath,
-                });
-                if (result.exitCode !== 0) {
-                    workspaceService.updateWorkspaceStatus(workspace.id, 'error');
-                    setupScriptFailed = true;
-                }
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                console.error(`[workspaces] Setup script error: ${message}`);
-                workspaceService.updateWorkspaceStatus(workspace.id, 'error');
-                setupScriptFailed = true;
-            }
-        }
         // Save Notion content as markdown in worktree
         let notionFilePath = null;
         if (notionContent && body.notionUrl) {
@@ -551,10 +546,15 @@ app.post('/', migrationGuard, async (c) => {
                 console.error('[workspaces] Failed to update Notion status:', err);
             });
         }
-        // Skip agent launch if setup script failed — workspace stays in 'error' status
-        if (!setupScriptFailed) {
-            // Transition to brainstorming and build the initial agent prompt
-            workspaceService.updateWorkspaceStatus(workspace.id, 'brainstorming');
+        // Build the initial agent prompt BEFORE the setup script runs so a crash
+        // there cannot lose user input (description, Notion/Sentry context, tasks).
+        // The prompt is persisted to workspace.initial_prompt; the agent-start path
+        // clears it once successfully consumed. The workspace status is moved to
+        // `brainstorming` LATER — either after a successful setup script, or
+        // directly if no setup script is configured. This keeps the
+        // VALID_TRANSITIONS contract intact (`created → extracting → brainstorming`
+        // vs `created → brainstorming` when setup is skipped).
+        {
             // Resolve the per-feature initial-prompt templates with single-fallback
             // semantics: project || global is already handled inside getEffectiveSettings,
             // and a whitespace-only string acts as a user escape hatch (skip injection).
@@ -684,20 +684,79 @@ ${AUTO_LOOP_HARD_RULES}`;
 
 Once the brainstorming + planning steps above are complete and you have a saved plan file, output [BRAINSTORM_COMPLETE] on its own line BEFORE starting implementation. Kōbō uses that marker to transition the workspace from \`brainstorming\` to \`executing\`. Then proceed with implementation.`;
             }
+            // Persist the assembled prompt so a setup-script crash (or any later
+            // failure) doesn't lose the user's input. Cleared once the agent
+            // successfully ingests it below or by POST /:id/start on retry.
             try {
-                const agent = agentManager.startAgent(workspace.id, worktreePath, brainstormPrompt, workspace.model, false, workspace.agentPermissionMode, undefined, workspace.reasoningEffort);
-                // Persist the initial prompt in the feed so it's visible in the chat,
-                // tagged with the freshly created session id so the strict session filter shows it.
-                wsService.emit(workspace.id, 'user:message', { content: brainstormPrompt, sender: 'system-prompt' }, agent.agentSessionId);
+                workspaceService.setInitialPrompt(workspace.id, brainstormPrompt);
             }
             catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                console.error(`[workspaces] Failed to start agent: ${message}`);
+                console.error('[workspaces] setInitialPrompt failed:', err);
+            }
+            // Setup script — runs AFTER the prompt is persisted so a crash here
+            // leaves the workspace in `error` state with `initial_prompt` ready for
+            // a retry via POST /:id/start. Skipped when reusing an existing worktree
+            // (rerunning could be destructive — drop a curated node_modules, etc.).
+            const setupScriptConfigured = effectiveSettings.setupScript && !body.skipSetupScript && !useReusedWorktree;
+            if (setupScriptConfigured) {
+                workspaceService.updateWorkspaceStatus(workspace.id, 'extracting');
+                wsService.emit(workspace.id, 'setup:output', { text: '[kobo] Running setup script...' });
                 try {
+                    const result = await runSetupScript(workspace.id, worktreePath, effectiveSettings.setupScript, {
+                        workspaceName: workspace.name,
+                        branchName: workingBranch,
+                        sourceBranch: body.sourceBranch,
+                        projectPath: body.projectPath,
+                    });
+                    if (result.exitCode !== 0) {
+                        workspaceService.updateWorkspaceStatus(workspace.id, 'error');
+                        setupScriptFailed = true;
+                    }
+                    else {
+                        workspaceService.updateWorkspaceStatus(workspace.id, 'brainstorming');
+                    }
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    console.error(`[workspaces] Setup script error: ${message}`);
                     workspaceService.updateWorkspaceStatus(workspace.id, 'error');
+                    setupScriptFailed = true;
+                }
+            }
+            else {
+                // No setup step → go straight from `created` to `brainstorming`.
+                workspaceService.updateWorkspaceStatus(workspace.id, 'brainstorming');
+            }
+            if (setupScriptFailed) {
+                wsService.emit(workspace.id, 'setup:output', {
+                    text: '[kobo] Setup script failed — the agent was NOT started. Your initial prompt has been saved. ' +
+                        'Fix the setup script (Settings → Scripts) and click Start to retry with the original prompt.',
+                });
+            }
+            else {
+                try {
+                    const agent = agentManager.startAgent(workspace.id, worktreePath, brainstormPrompt, workspace.model, false, workspace.agentPermissionMode, undefined, workspace.reasoningEffort);
+                    // Persist the initial prompt in the feed so it's visible in the chat,
+                    // tagged with the freshly created session id so the strict session filter shows it.
+                    wsService.emit(workspace.id, 'user:message', { content: brainstormPrompt, sender: 'system-prompt' }, agent.agentSessionId);
+                    // Agent successfully ingested the prompt — clear it so /:id/start
+                    // doesn't replay it on a future restart.
+                    try {
+                        workspaceService.clearInitialPrompt(workspace.id);
+                    }
+                    catch (err) {
+                        console.error('[workspaces] clearInitialPrompt failed:', err);
+                    }
                 }
-                catch {
-                    /* already logged */
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    console.error(`[workspaces] Failed to start agent: ${message}`);
+                    try {
+                        workspaceService.updateWorkspaceStatus(workspace.id, 'error');
+                    }
+                    catch {
+                        /* already logged */
+                    }
                 }
             }
         }
@@ -719,6 +778,12 @@ Once the brainstorming + planning steps above are complete and you have a saved
         }
         // Return created workspace with tasks
         const workspaceWithTasks = workspaceService.getWorkspaceWithTasks(workspace.id);
+        if (workingBranchAdjusted) {
+            // Surface the auto-suffix via a custom header so the client can toast
+            // "Branch already existed — created <new-branch> instead". The actual
+            // resolved branch is on the returned workspace already.
+            c.header('X-Kobo-Branch-Adjusted', '1');
+        }
         return c.json(workspaceWithTasks, 201);
     }
     catch (err) {
@@ -1979,7 +2044,13 @@ app.post('/:id/start', migrationGuard, async (c) => {
         const body = await c.req
             .json()
             .catch(() => ({ prompt: undefined, agentSessionId: undefined, resume: undefined }));
-        const prompt = body.prompt ?? 'Continue the previous task where you left off.';
+        // Prompt resolution order:
+        //  1. Explicit body.prompt (user-typed in the chat input)
+        //  2. Pending workspace.initial_prompt — set by workspace creation when
+        //     a setup-script crash prevented the original agent launch
+        //  3. Generic resume fallback
+        const pendingInitialPrompt = workspace.initialPrompt && workspace.initialPrompt.length > 0 ? workspace.initialPrompt : null;
+        const prompt = body.prompt ?? pendingInitialPrompt ?? 'Continue the previous task where you left off.';
         const agentSessionId = body.agentSessionId;
         const resume = body.resume === true;
         // Stop existing agent if running
@@ -1998,6 +2069,21 @@ app.post('/:id/start', migrationGuard, async (c) => {
         if (body.prompt) {
             wsService.emit(id, 'user:message', { content: body.prompt, sender: 'user' }, agent.agentSessionId);
         }
+        else if (pendingInitialPrompt) {
+            // Pending brainstorm prompt — surface it in the feed so the user sees
+            // what the agent just received, mirroring the workspace-creation flow.
+            wsService.emit(id, 'user:message', { content: pendingInitialPrompt, sender: 'system-prompt' }, agent.agentSessionId);
+        }
+        // Clear the pending prompt once the agent has been handed it — subsequent
+        // /:id/start calls fall back to the generic "Continue…" string.
+        if (pendingInitialPrompt) {
+            try {
+                workspaceService.clearInitialPrompt(id);
+            }
+            catch (err) {
+                console.error('[workspaces] clearInitialPrompt after start failed:', err);
+            }
+        }
         return c.json({ status: 'started' });
     }
     catch (err) {
@@ -2032,11 +2118,13 @@ app.get('/:id/git-stats', async (c) => {
     }
 });
 // GET /api/workspaces/:id/diff?mode=branch|unpushed — list changed files
-// - `branch` (default): committed + working tree changes vs sourceBranch,
-//   i.e. what the PR will contain.
+// - `branch` (default): committed + working tree changes vs
+//   `origin/<sourceBranch>` (which can be ahead of the local ref when
+//   upstream landed merges Kōbō hasn't pulled). The handler refreshes
+//   `origin/<sourceBranch>` synchronously so the diff is never stale.
 // - `unpushed`: committed-only changes vs `origin/<workingBranch>`,
 //   i.e. what the next `git push` will send.
-app.get('/:id/diff', (c) => {
+app.get('/:id/diff', async (c) => {
     try {
         const id = c.req.param('id');
         const mode = c.req.query('mode') === 'unpushed' ? 'unpushed' : 'branch';
@@ -2048,6 +2136,13 @@ app.get('/:id/diff', (c) => {
             return c.json({ error: `Workspace '${id}' not found` }, 404);
         }
         const worktreePath = workspace.worktreePath;
+        // Sync fetch in `branch` mode so the diff reflects upstream's HEAD, not a
+        // stale local copy of the source branch. Best-effort: a failed fetch
+        // (offline, no remote configured) still returns the diff against whatever
+        // `origin/<source>` we have in cache.
+        if (mode === 'branch') {
+            await gitOps.fetchSourceBranchAsync(worktreePath, workspace.sourceBranch);
+        }
         const files = mode === 'unpushed'
             ? gitOps.getUnpushedChangedFiles(worktreePath, workspace.workingBranch)
             : gitOps.getChangedFiles(worktreePath, workspace.sourceBranch, includeUntracked);
@@ -2132,10 +2227,11 @@ app.post('/:id/rollback-file', async (c) => {
     }
 });
 // GET /api/workspaces/:id/branch-divergence?limit=50
-// Returns commits on the working branch ahead of source (`ahead`) and
-// commits on source not yet on the working branch (`behind`). One round-trip
-// for the BranchDivergenceDialog.
-app.get('/:id/branch-divergence', (c) => {
+// Returns commits on the working branch ahead of `origin/<sourceBranch>`
+// (`ahead`) and commits on `origin/<sourceBranch>` not yet on the working
+// branch (`behind`). Refreshes `origin/<sourceBranch>` synchronously so the
+// counts and lists are never computed against a stale local source ref.
+app.get('/:id/branch-divergence', async (c) => {
     try {
         const id = c.req.param('id');
         const workspace = workspaceService.getWorkspace(id);
@@ -2146,6 +2242,7 @@ app.get('/:id/branch-divergence', (c) => {
         const parsed = parseInt(limitRaw ?? '50', 10);
         const limit = Math.min(Math.max(1, Number.isNaN(parsed) ? 50 : parsed), 200);
         const worktreePath = workspace.worktreePath;
+        await gitOps.fetchSourceBranchAsync(worktreePath, workspace.sourceBranch);
         const ahead = gitOps.listBranchCommits(worktreePath, workspace.sourceBranch, workspace.workingBranch, limit);
         const behind = gitOps.listCommitsBehind(worktreePath, workspace.sourceBranch, workspace.workingBranch, limit);
         c.header('Cache-Control', 'no-store');
@@ -2161,9 +2258,11 @@ app.get('/:id/branch-divergence', (c) => {
         return c.json({ error: message }, 500);
     }
 });
-// GET /api/workspaces/:id/commits?limit=50 — list commits between sourceBranch
-// and HEAD, each tagged with whether it's already pushed to origin/<branch>.
-app.get('/:id/commits', (c) => {
+// GET /api/workspaces/:id/commits?limit=50 — list commits between
+// `origin/<sourceBranch>` and HEAD, each tagged with whether it's already
+// pushed to origin/<branch>. Refreshes `origin/<sourceBranch>` synchronously
+// so the list is not computed against a stale local source ref.
+app.get('/:id/commits', async (c) => {
     try {
         const id = c.req.param('id');
         const workspace = workspaceService.getWorkspace(id);
@@ -2173,6 +2272,7 @@ app.get('/:id/commits', (c) => {
         const limitRaw = c.req.query('limit');
         const limit = Math.min(Math.max(1, parseInt(limitRaw ?? '50', 10) || 50), 200);
         const worktreePath = workspace.worktreePath;
+        await gitOps.fetchSourceBranchAsync(worktreePath, workspace.sourceBranch);
         const commits = gitOps.listBranchCommits(worktreePath, workspace.sourceBranch, workspace.workingBranch, limit);
         c.header('Cache-Control', 'no-store');
         return c.json({ commits, sourceBranch: workspace.sourceBranch, workingBranch: workspace.workingBranch });
@@ -2835,6 +2935,78 @@ app.post('/:id/start-review', async (c) => {
         return c.json({ error: message }, 500);
     }
 });
+// POST /api/workspaces/:id/start-ci-fix — dispatch the configured CI-fix
+// prompt to the agent when the workspace's PR has failing CI.
+// Resumes the current session (or starts a fresh one if none is alive).
+app.post('/:id/start-ci-fix', migrationGuard, async (c) => {
+    try {
+        const id = c.req.param('id');
+        const workspace = workspaceService.getWorkspace(id);
+        if (!workspace) {
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        }
+        if (workspace.archivedAt) {
+            return c.json({ error: `Workspace '${id}' is archived` }, 400);
+        }
+        // Refresh the PR snapshot best-effort so the action operates on the
+        // freshest CI rollup; fall back to the cache if the refresh fails.
+        let snapshot = await refreshPrSnapshot(id).catch(() => null);
+        if (!snapshot) {
+            snapshot = getAllPrSnapshots()[id] ?? null;
+        }
+        if (!snapshot || snapshot.state !== 'OPEN' || snapshot.ci.rollup !== 'FAILURE') {
+            return c.json({ error: 'No failing CI detected on this workspace' }, 400);
+        }
+        const effective = settingsService.getEffectiveSettings(workspace.projectPath);
+        const template = effective.ciFixPromptTemplate;
+        if (!template || template.trim().length === 0) {
+            return c.json({ error: 'No CI-fix prompt template configured. Set one in Settings → Prompts.' }, 400);
+        }
+        const failedChecks = snapshot.ci.checks
+            .filter((check) => check.conclusion === 'FAILURE')
+            .map((check) => ({ name: check.name, detailsUrl: check.detailsUrl }));
+        // Best-effort first details URL as a stand-in for `ci_run_url` — the
+        // forge providers don't expose a top-level run URL, but the first failed
+        // check's `detailsUrl` reliably points back at the failing run.
+        const ciRunUrl = failedChecks.find((c) => c.detailsUrl)?.detailsUrl ?? null;
+        const rendered = renderCiFixTemplate(template, {
+            workspace,
+            prNumber: snapshot.number,
+            prUrl: snapshot.url,
+            prTitle: snapshot.title,
+            failedChecks,
+            ciRunUrl,
+        });
+        try {
+            wakeupService.cancel(workspace.id, 'user-message');
+        }
+        catch {
+            /* swallow */
+        }
+        const session = workspaceService.getActiveSession(workspace.id);
+        let emitSessionId = session?.id;
+        try {
+            agentManager.sendMessage(workspace.id, rendered);
+        }
+        catch {
+            try {
+                const agent = agentManager.startAgent(workspace.id, workspace.worktreePath, rendered, workspace.model, true /* resume */, workspace.agentPermissionMode, undefined, workspace.reasoningEffort);
+                workspaceService.updateWorkspaceStatus(workspace.id, 'executing');
+                emitSessionId = agent?.agentSessionId ?? emitSessionId;
+            }
+            catch (resumeErr) {
+                const msg = resumeErr instanceof Error ? resumeErr.message : String(resumeErr);
+                return c.json({ error: `Failed to dispatch CI-fix prompt: ${msg}` }, 500);
+            }
+        }
+        wsService.emit(workspace.id, 'user:message', { content: rendered, sender: 'user' }, emitSessionId);
+        return c.json({ ok: true, failedChecksCount: failedChecks.length });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
 /** POST /api/workspaces/:id/mark-read — mark workspace as read (clear unread indicator). */
 app.post('/:id/mark-read', (c) => {
     try {

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

@@ -303,6 +303,7 @@ function readEffectiveSettingsSafe(projectPath) {
             dangerouslySkipPermissions: true,
             prPromptTemplate: '',
             reviewPromptTemplate: '',
+            ciFixPromptTemplate: '',
             notionInitialPromptTemplate: '',
             sentryInitialPromptTemplate: '',
             gitConventions: '',

package/dist/server/services/ci-fix-template-service.js

@@ -0,0 +1,34 @@
+import path from 'node:path';
+function formatFailedJobs(checks) {
+    if (checks.length === 0)
+        return '(no failed jobs reported)';
+    return checks.map((c) => (c.detailsUrl ? `- ${c.name} — ${c.detailsUrl}` : `- ${c.name}`)).join('\n');
+}
+function buildVariableMap(ctx) {
+    return {
+        pr_number: ctx.prNumber != null ? String(ctx.prNumber) : '',
+        pr_url: ctx.prUrl ?? '',
+        pr_title: ctx.prTitle ?? '',
+        branch_name: ctx.workspace.workingBranch,
+        source_branch: ctx.workspace.sourceBranch,
+        workspace_name: ctx.workspace.name,
+        workspace_id: ctx.workspace.id,
+        project_name: path.basename(ctx.workspace.projectPath),
+        failed_jobs: formatFailedJobs(ctx.failedChecks),
+        ci_run_url: ctx.ciRunUrl ?? '',
+    };
+}
+/**
+ * Render a CI-fix prompt template by substituting {{variable}} placeholders.
+ * Pure function — no I/O. Unknown variables are left as-is so user-defined
+ * placeholders can be resolved downstream by the agent itself.
+ */
+export function renderCiFixTemplate(template, ctx) {
+    const vars = buildVariableMap(ctx);
+    return template.replace(/\{\{(\w+)\}\}/g, (match, name) => {
+        if (Object.hasOwn(vars, name)) {
+            return vars[name];
+        }
+        return match;
+    });
+}

package/dist/server/services/pr-watcher-service.js

@@ -5,7 +5,7 @@ import { resolveForge } from './forge/resolve.js';
 import { computeGitStats } from './git-stats-service.js';
 import { destroyTerminal } from './terminal-service.js';
 import { emitEphemeral } from './websocket-service.js';
-import { archiveWorkspace, getWorkspace, listWorkspaces, updateWorkspaceSourceBranch } from './workspace-service.js';
+import { archiveWorkspace, getWorkspace, listWorkspaces, markWorkspaceUnread, updateWorkspaceSourceBranch, } from './workspace-service.js';
 // ── PR Watcher ────────────────────────────────────────────────────────────────
 // Polls GitHub every POLL_INTERVAL_MS to detect merged/closed PRs and
 // automatically archive the corresponding workspace.
@@ -50,6 +50,19 @@ export function _resetForTest() {
     lastKnownPr.clear();
     lastKnownGitStats.clear();
 }
+/**
+ * Flip a workspace to unread (DB + WS event) on a PR-attention transition.
+ * Best-effort: a failure here must never break the watcher loop.
+ */
+function markUnread(workspaceId) {
+    try {
+        markWorkspaceUnread(workspaceId);
+        emitEphemeral(workspaceId, 'workspace:unread', { hasUnread: true });
+    }
+    catch (err) {
+        console.error('[pr-watcher] markUnread failed:', err instanceof Error ? err.message : err);
+    }
+}
 export async function checkPrStatuses() {
     const workspaces = listWorkspaces(false); // non-archived only
     // Clean up entries for workspaces that no longer exist
@@ -117,15 +130,20 @@ export async function checkPrStatuses() {
                 });
                 continue; // do not run base-change detection on a workspace we just archived
             }
-            // Review-decision transitions (only on OPEN PRs; first-sight is silent).
-            // Reuses the baseline rule from base-change detection: emits only when we
-            // observe an actual transition between two known states.
+            // Review-decision and CI transitions (only on OPEN PRs; first-sight is
+            // silent). Reuses the baseline rule from base-change detection: act only
+            // on an actual transition between two known states. Each notable
+            // transition (changes-requested newly raised, CI newly failing) flips
+            // `hasUnread` so the workspace card stands out as "something new to
+            // look at" in the drawer — the unread bit persists until the user opens
+            // the workspace, matching the existing read/unread UX.
             if (pr.state === 'OPEN' && prev) {
                 if (prev.reviewDecision !== 'CHANGES_REQUESTED' && pr.reviewDecision === 'CHANGES_REQUESTED') {
                     emitEphemeral(ws.id, 'pr:changes-requested', {
                         prNumber: pr.number,
                         prUrl: pr.url,
                     });
+                    markUnread(ws.id);
                 }
                 else if (prev.reviewDecision === 'CHANGES_REQUESTED' && pr.reviewDecision === 'APPROVED') {
                     emitEphemeral(ws.id, 'pr:approved', {
@@ -133,6 +151,9 @@ export async function checkPrStatuses() {
                         prUrl: pr.url,
                     });
                 }
+                if (prev.ci.rollup !== 'FAILURE' && pr.ci.rollup === 'FAILURE') {
+                    markUnread(ws.id);
+                }
             }
             // Base-branch change detection. Only relevant for OPEN PRs — closed/
             // merged PRs don't accept base changes. Skip if the GitHub response