@loicngr/kobo 1.3.0 → 1.4.1

package/AGENTS.md

@@ -171,6 +171,19 @@ See the "Notion integration" section of the README for the end-user setup guide.
 
 **Dependencies** — root `package.json` covers backend + tests. `src/client/package.json` is a separate npm tree. Install both.
 
+## Internationalization (i18n)
+
+The frontend uses `vue-i18n` v10 with 5 supported locales: English (`en`), French (`fr`), German (`de`), Spanish (`es`), Italian (`it`). Translation files live in `src/client/src/i18n/`.
+
+**Mandatory rules for all frontend code:**
+
+- **NEVER hardcode user-visible text** in Vue templates or scripts. Always use `$t('key')` in templates and `t('key')` in `<script setup>` (via `const { t } = useI18n()`).
+- When adding or modifying a text, **update ALL 5 locale files** (`en.ts`, `fr.ts`, `de.ts`, `es.ts`, `it.ts`) with the corresponding translation.
+- Keys follow the pattern `'component.label'` (e.g. `'git.push'`, `'settings.title'`, `'common.save'`). Use the existing key structure as reference.
+- Keep technical terms in English across all locales when that's the industry convention (Git, PR, Push, Diff, Commit, Branch, Tokens, etc.).
+- Placeholders like `{count}`, `{n}`, `{query}` must remain intact in all translations.
+- The language selector is in the Settings page (Global tab). The locale is auto-detected from the browser on first visit and persisted in `localStorage('kobo:locale')`.
+
 ## Testing discipline
 
 - **TDD for backend** — write the failing test, confirm it fails for the right reason, implement minimally, confirm it passes, commit. One commit per logical unit. See existing tests in `src/__tests__/workspace-service.test.ts` for the setup pattern (fresh in-memory DB per test via `resetDb()`).
@@ -225,3 +238,4 @@ The human user of this repository prefers French for conversational exchanges. C
 - Don't introduce ORMs, query builders, or schema validation libraries — the project is small enough for raw prepared statements and hand-written mappers.
 - Don't break the single-source-of-truth of `CLAUDE.md` → `AGENTS.md` symlink. Edit `AGENTS.md`; `CLAUDE.md` follows automatically.
 - Don't skip `try/catch` swallowing on best-effort cleanup (agent stop, dev-server stop, worktree removal). These must never break the primary operation.
+- Don't hardcode user-visible text in the frontend. Every string must go through `$t()` / `t()` with keys in all 5 locale files. See [Internationalization (i18n)](#internationalization-i18n).

package/dist/mcp-server/kobo-tasks-server.js

@@ -20,6 +20,7 @@ let db;
 try {
     db = new Database(dbPath, { readonly: false });
     db.pragma('journal_mode = WAL');
+    db.pragma('busy_timeout = 5000');
     db.pragma('foreign_keys = ON');
 }
 catch (err) {
@@ -205,6 +206,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 properties: {
                     status: {
                         type: 'string',
+                        enum: ['idle', 'completed', 'error'],
                         description: 'New status (e.g. idle, completed)',
                     },
                 },

package/dist/server/db/index.js

@@ -11,6 +11,7 @@ export function getDb(dbPath) {
     }
     instance = new Database(resolvedPath);
     instance.pragma('journal_mode=WAL');
+    instance.pragma('busy_timeout=5000');
     instance.pragma('foreign_keys=ON');
     return instance;
 }

package/dist/server/db/migrations.js

@@ -7,6 +7,17 @@ export const migrations = [
             db.exec("ALTER TABLE workspaces ADD COLUMN permission_mode TEXT NOT NULL DEFAULT 'auto-accept'");
         },
     },
+    {
+        version: 3,
+        name: 'add-workspace-id-indexes',
+        migrate: (db) => {
+            db.exec(`
+        CREATE INDEX IF NOT EXISTS idx_tasks_workspace_id ON tasks(workspace_id);
+        CREATE INDEX IF NOT EXISTS idx_agent_sessions_workspace_id ON agent_sessions(workspace_id);
+        CREATE INDEX IF NOT EXISTS idx_ws_events_workspace_id ON ws_events(workspace_id);
+      `);
+        },
+    },
 ];
 /** 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

@@ -46,5 +46,9 @@ export function initSchema(db) {
       session_id TEXT,
       created_at TEXT NOT NULL
     );
+
+    CREATE INDEX IF NOT EXISTS idx_tasks_workspace_id ON tasks(workspace_id);
+    CREATE INDEX IF NOT EXISTS idx_agent_sessions_workspace_id ON agent_sessions(workspace_id);
+    CREATE INDEX IF NOT EXISTS idx_ws_events_workspace_id ON ws_events(workspace_id);
   `);
 }

package/dist/server/index.js

@@ -5,7 +5,7 @@ import path from 'node:path';
 import { serve } from '@hono/node-server';
 import { Hono } from 'hono';
 import { WebSocketServer } from 'ws';
-import { getDb } from './db/index.js';
+import { closeDb, getDb } from './db/index.js';
 import { runMigrations } from './db/migrations.js';
 import devServerRouter from './routes/dev-server.js';
 import gitRouter from './routes/git.js';
@@ -13,12 +13,13 @@ import imagesRouter from './routes/images.js';
 import notionRouter from './routes/notion.js';
 import settingsRouter from './routes/settings.js';
 import workspacesRouter from './routes/workspaces.js';
-import { getAvailableSkills, sendMessage, setBackendPort, startAgent, startWatchdog, stopAgent, } from './services/agent-manager.js';
+import { getAvailableSkills, sendMessage, setBackendPort, startAgent, startWatchdog, stopAgent, stopWatchdog, } from './services/agent-manager.js';
 import { startDevServer, stopDevServer } from './services/dev-server-service.js';
+import { startPrWatcher, stopPrWatcher } from './services/pr-watcher-service.js';
 import { emit, handleConnection, setMessageHandler } from './services/websocket-service.js';
 import { getLatestSession, getWorkspace, updateWorkspaceStatus } from './services/workspace-service.js';
-import { getClientSpaPath, getKoboHome } from './utils/paths.js';
-import { initProcessCleanup } from './utils/process-tracker.js';
+import { getClientSpaPath, getKoboHome, getPackageVersion } from './utils/paths.js';
+import { initProcessCleanup, killAll as killAllTrackedProcesses } from './utils/process-tracker.js';
 // 0. Runtime prerequisite check — warn if claude CLI is missing. Don't block
 // startup: the user may still want to configure settings or browse workspaces
 // before installing Claude Code.
@@ -35,12 +36,11 @@ runMigrations(db);
 // 2. Initialize process cleanup, agent watchdog, and PR watcher
 initProcessCleanup();
 startWatchdog();
-import { startPrWatcher } from './services/pr-watcher-service.js';
 startPrWatcher();
 // 3. Create Hono app
 const app = new Hono();
 // Health check (root / is handled by the SPA catch-all below)
-app.get('/api/health', (c) => c.json({ status: 'ok', version: '0.1.0' }));
+app.get('/api/health', (c) => c.json({ status: 'ok', version: getPackageVersion() }));
 // 4. Mount route sub-routers
 app.route('/api/workspaces', workspacesRouter);
 app.route('/api/workspaces', imagesRouter);
@@ -50,7 +50,7 @@ app.route('/api/settings', settingsRouter);
 app.route('/api/dev-server', devServerRouter);
 // Skills endpoint
 app.get('/api/skills', (c) => c.json(getAvailableSkills()));
-const PORT = process.env.PORT ? parseInt(process.env.PORT, 10) : 3000;
+const PORT = parseInt(process.env.SERVER_PORT || process.env.PORT || '3000', 10);
 // 9. Serve static files from the built SPA if present (production mode).
 // The path is resolved relative to the package install directory, so this
 // works both in dev (tsx running from src/) and when installed via npm / npx
@@ -182,3 +182,54 @@ server.on('upgrade', (request, socket, head) => {
         socket.destroy();
     }
 });
+// 9. Graceful shutdown handler
+let isShuttingDown = false;
+function gracefulShutdown(signal) {
+    if (isShuttingDown)
+        return;
+    isShuttingDown = true;
+    console.log(`\n[kobo] Received ${signal}, shutting down gracefully…`);
+    // 1. Stop accepting new connections
+    wss.close(() => {
+        console.log('[kobo] WebSocket server closed');
+    });
+    server.close(() => {
+        console.log('[kobo] HTTP server closed');
+    });
+    // 2. Stop background services
+    try {
+        stopWatchdog();
+    }
+    catch {
+        // Best-effort
+    }
+    try {
+        stopPrWatcher();
+    }
+    catch {
+        // Best-effort
+    }
+    // 3. Kill all tracked child processes (agents, dev servers)
+    try {
+        killAllTrackedProcesses();
+        console.log('[kobo] Tracked processes killed');
+    }
+    catch {
+        // Best-effort
+    }
+    // 4. Close database
+    try {
+        closeDb();
+        console.log('[kobo] Database closed');
+    }
+    catch {
+        // Best-effort
+    }
+    // 4. Give a short grace period for in-flight requests, then exit
+    setTimeout(() => {
+        console.log('[kobo] Shutdown complete');
+        process.exit(0);
+    }, 2000).unref();
+}
+process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+process.on('SIGINT', () => gracefulShutdown('SIGINT'));

package/dist/server/routes/workspaces.js

@@ -1,9 +1,16 @@
-import { execFileSync } from 'node:child_process';
+import { execFile as execFileCb } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFileCb);
+import fs from 'node:fs';
+import path from 'node:path';
 import { Hono } from 'hono';
+import { getDb } from '../db/index.js';
 import * as agentManager from '../services/agent-manager.js';
 import * as devServerService from '../services/dev-server-service.js';
 import * as notionService from '../services/notion-service.js';
+import { renderPrTemplate } from '../services/pr-template-service.js';
 import * as settingsService from '../services/settings-service.js';
+import { runSetupScript } from '../services/setup-script-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';
@@ -110,9 +117,7 @@ app.post('/', async (c) => {
         // 4b. Ensure Kobo-generated files inside .ai/ are gitignored (the .ai/ dir
         //     itself may contain project files that SHOULD be committed).
         try {
-            const fs = await import('node:fs');
-            const pathMod = await import('node:path');
-            const gitignorePath = pathMod.default.join(worktreePath, '.gitignore');
+            const gitignorePath = path.join(worktreePath, '.gitignore');
             const existing = fs.existsSync(gitignorePath) ? fs.readFileSync(gitignorePath, 'utf-8') : '';
             const lines = existing.split('\n').map((l) => l.trim());
             const toAdd = [];
@@ -122,6 +127,8 @@ app.post('/', async (c) => {
                 toAdd.push('.ai/thoughts/');
             if (!lines.includes('.ai/images/'))
                 toAdd.push('.ai/images/');
+            if (!lines.includes('.ai/.setup-script.tmp'))
+                toAdd.push('.ai/.setup-script.tmp');
             if (toAdd.length > 0) {
                 const separator = existing.length > 0 && !existing.endsWith('\n') ? '\n' : '';
                 fs.appendFileSync(gitignorePath, `${separator}${toAdd.join('\n')}\n`, 'utf-8');
@@ -134,31 +141,50 @@ app.post('/', async (c) => {
         const effectiveSettings = settingsService.getEffectiveSettings(body.projectPath);
         if (effectiveSettings.gitConventions) {
             try {
-                const fs = await import('node:fs');
-                const path = await import('node:path');
-                const aiDir = path.default.join(worktreePath, '.ai');
+                const aiDir = path.join(worktreePath, '.ai');
                 fs.mkdirSync(aiDir, { recursive: true });
-                const conventionsPath = path.default.join(aiDir, 'git-conventions.md');
+                const conventionsPath = path.join(aiDir, 'git-conventions.md');
                 fs.writeFileSync(conventionsPath, effectiveSettings.gitConventions, 'utf-8');
             }
             catch (err) {
                 console.error('[workspaces] Failed to write git-conventions.md:', err);
             }
         }
+        // 4d. Run setup script if configured
+        if (effectiveSettings.setupScript) {
+            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: body.workingBranch,
+                    sourceBranch: body.sourceBranch,
+                    projectPath: body.projectPath,
+                });
+                if (result.exitCode !== 0) {
+                    workspaceService.updateWorkspaceStatus(workspace.id, 'error');
+                    return c.json({ error: `Setup script failed with exit code ${result.exitCode}` }, 500);
+                }
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                console.error(`[workspaces] Setup script error: ${message}`);
+                workspaceService.updateWorkspaceStatus(workspace.id, 'error');
+                return c.json({ error: `Setup script error: ${message}` }, 500);
+            }
+        }
         // 5. Save Notion content as markdown in worktree
         let notionFilePath = null;
         if (notionContent && body.notionUrl) {
             try {
-                const fs = await import('node:fs');
-                const path = await import('node:path');
-                const thoughtsDir = path.default.join(worktreePath, '.ai', 'thoughts');
+                const thoughtsDir = path.join(worktreePath, '.ai', 'thoughts');
                 fs.mkdirSync(thoughtsDir, { recursive: true });
                 // Derive filename from title (TK-XXX pattern or slug)
                 const tkMatch = workspace.name.match(/TK-\d+/i);
                 const filename = tkMatch
                     ? `${tkMatch[0]}.md`
                     : `PAGE-${notionService.parseNotionUrl(body.notionUrl).replace(/-/g, '')}.md`;
-                notionFilePath = path.default.join(thoughtsDir, filename);
+                notionFilePath = path.join(thoughtsDir, filename);
                 const today = new Date().toISOString().split('T')[0];
                 let md = `# ${workspace.name}\n\n`;
                 md += `## Source\n\n`;
@@ -219,8 +245,7 @@ app.post('/', async (c) => {
         brainstormPrompt += `\nIMPORTANT: Start by reading CLAUDE.md and/or AGENTS.md at the project root if they exist — they contain project conventions and instructions you must follow.`;
         brainstormPrompt += `\n\nThen brainstorm the implementation approach. Explore the codebase to understand the existing structure. Ask clarifying questions if needed. When you're done brainstorming and have a clear plan, create a plan file and proceed with implementation. Once you have completed the brainstorming phase, output [BRAINSTORM_COMPLETE] on its own line.`;
         // Persist the initial prompt in the feed so it's visible in the chat
-        const { emit } = await import('../services/websocket-service.js');
-        emit(workspace.id, 'user:message', { content: brainstormPrompt, sender: 'system-prompt' });
+        wsService.emit(workspace.id, 'user:message', { content: brainstormPrompt, sender: 'system-prompt' });
         try {
             agentManager.startAgent(workspace.id, worktreePath, brainstormPrompt, workspace.model);
         }
@@ -269,7 +294,7 @@ app.post('/:id/refresh-notion', async (c) => {
             return c.json({ error: 'No Notion URL configured' }, 400);
         const notionContent = await notionService.extractNotionPage(workspace.notionUrl);
         // Delete existing tasks and recreate from Notion
-        const db = (await import('../db/index.js')).getDb();
+        const db = getDb();
         db.prepare('DELETE FROM tasks WHERE workspace_id = ?').run(id);
         let sortOrder = 0;
         for (const todo of notionContent.todos) {
@@ -327,7 +352,16 @@ app.post('/:id/tasks', async (c) => {
 // PATCH /api/workspaces/:id/tasks/:taskId — update task status and/or title
 app.patch('/:id/tasks/:taskId', async (c) => {
     try {
+        const id = c.req.param('id');
         const taskId = c.req.param('taskId');
+        const workspace = workspaceService.getWorkspace(id);
+        if (!workspace) {
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        }
+        const task = workspaceService.getTask(taskId, id);
+        if (!task) {
+            return c.json({ error: `Task '${taskId}' not found in workspace '${id}'` }, 404);
+        }
         const body = await c.req.json();
         if (body.status === undefined && body.title === undefined) {
             return c.json({ error: 'At least one of status or title is required' }, 400);
@@ -361,6 +395,10 @@ app.delete('/:id/tasks/:taskId', (c) => {
         if (!workspace) {
             return c.json({ error: `Workspace '${id}' not found` }, 404);
         }
+        const task = workspaceService.getTask(taskId, id);
+        if (!task) {
+            return c.json({ error: `Task '${taskId}' not found in workspace '${id}'` }, 404);
+        }
         workspaceService.deleteTask(taskId);
         return new Response(null, { status: 204 });
     }
@@ -369,6 +407,24 @@ app.delete('/:id/tasks/:taskId', (c) => {
         return c.json({ error: message }, 500);
     }
 });
+// POST /api/workspaces/:id/tasks/notify-updated — broadcast generic task list change
+// Must be declared BEFORE /:id/tasks/:taskId/notify-done so Hono doesn't capture
+// "notify-updated" as a :taskId parameter.
+app.post('/:id/tasks/notify-updated', (c) => {
+    try {
+        const id = c.req.param('id');
+        const workspace = workspaceService.getWorkspace(id);
+        if (!workspace) {
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        }
+        wsService.emit(id, 'task:updated', {});
+        return new Response(null, { status: 204 });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
 // POST /api/workspaces/:id/tasks/:taskId/notify-done — broadcast task:updated event
 app.post('/:id/tasks/:taskId/notify-done', (c) => {
     try {
@@ -386,16 +442,66 @@ app.post('/:id/tasks/:taskId/notify-done', (c) => {
         return c.json({ error: message }, 500);
     }
 });
-// POST /api/workspaces/:id/tasks/notify-updated — broadcast generic task list change
-app.post('/:id/tasks/notify-updated', (c) => {
+// GET /api/workspaces/:id/events — paginated event history (must be before GET /:id for route ordering)
+app.get('/:id/events', (c) => {
     try {
         const id = c.req.param('id');
         const workspace = workspaceService.getWorkspace(id);
         if (!workspace) {
             return c.json({ error: `Workspace '${id}' not found` }, 404);
         }
-        wsService.emit(id, 'task:updated', {});
-        return new Response(null, { status: 204 });
+        const before = c.req.query('before'); // event ID cursor
+        const limit = Math.min(parseInt(c.req.query('limit') ?? '100', 10) || 100, 500);
+        const db = getDb();
+        let rows;
+        if (before) {
+            // Get the rowid of the cursor event
+            const cursorRow = db.prepare('SELECT rowid FROM ws_events WHERE id = ?').get(before);
+            if (!cursorRow) {
+                return c.json({ events: [], hasMore: false });
+            }
+            rows = db
+                .prepare('SELECT * FROM ws_events WHERE workspace_id = ? AND rowid < ? ORDER BY rowid DESC LIMIT ?')
+                .all(id, cursorRow.rowid, limit);
+        }
+        else {
+            // No cursor — return the oldest events
+            rows = db
+                .prepare('SELECT * FROM ws_events WHERE workspace_id = ? ORDER BY rowid ASC LIMIT ?')
+                .all(id, limit);
+        }
+        // Reverse to chronological order (we queried DESC for "before" pagination)
+        if (before)
+            rows.reverse();
+        const events = rows.map((row) => {
+            let parsedPayload;
+            try {
+                parsedPayload = JSON.parse(row.payload);
+            }
+            catch {
+                parsedPayload = row.payload;
+            }
+            return {
+                id: row.id,
+                workspaceId: row.workspace_id,
+                type: row.type,
+                payload: parsedPayload,
+                sessionId: row.session_id,
+                createdAt: row.created_at,
+            };
+        });
+        // Check if there are more older events beyond what we returned
+        let hasMore = false;
+        if (before && rows.length > 0) {
+            const firstRow = db.prepare('SELECT rowid FROM ws_events WHERE id = ?').get(rows[0].id);
+            if (firstRow) {
+                const older = db
+                    .prepare('SELECT COUNT(*) as c FROM ws_events WHERE workspace_id = ? AND rowid < ?')
+                    .get(id, firstRow.rowid);
+                hasMore = older.c > 0;
+            }
+        }
+        return c.json({ events, hasMore });
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
@@ -612,12 +718,12 @@ app.get('/:id/git-stats', async (c) => {
         if (!workspace) {
             return c.json({ error: `Workspace '${id}' not found` }, 404);
         }
-        const path = await import('node:path');
-        const worktreePath = path.default.join(workspace.projectPath, '.worktrees', workspace.workingBranch);
+        const worktreePath = path.join(workspace.projectPath, '.worktrees', workspace.workingBranch);
         const commitCount = gitOps.getCommitCount(worktreePath, workspace.sourceBranch, workspace.workingBranch);
         const diffStats = gitOps.getStructuredDiffStatsBetween(worktreePath, workspace.sourceBranch, workspace.workingBranch);
-        const pr = gitOps.getPrStatus(workspace.projectPath, workspace.workingBranch);
-        const unpushedCount = gitOps.getUnpushedCount(worktreePath);
+        const pr = await gitOps.getPrStatusAsync(workspace.projectPath, workspace.workingBranch);
+        const unpushedCount = await gitOps.getUnpushedCountAsync(worktreePath);
+        const workingTree = gitOps.getWorkingTreeStatus(worktreePath);
         return c.json({
             commitCount,
             filesChanged: diffStats.filesChanged,
@@ -626,6 +732,28 @@ app.get('/:id/git-stats', async (c) => {
             prUrl: pr?.url ?? null,
             prState: pr?.state ?? null,
             unpushedCount,
+            workingTree,
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
+// GET /api/workspaces/:id/diff — list changed files
+app.get('/:id/diff', (c) => {
+    try {
+        const id = c.req.param('id');
+        const workspace = workspaceService.getWorkspace(id);
+        if (!workspace) {
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        }
+        const worktreePath = path.join(workspace.projectPath, '.worktrees', workspace.workingBranch);
+        const files = gitOps.getChangedFiles(worktreePath, workspace.sourceBranch);
+        return c.json({
+            files,
+            sourceBranch: workspace.sourceBranch,
+            workingBranch: workspace.workingBranch,
         });
     }
     catch (err) {
@@ -633,6 +761,28 @@ app.get('/:id/git-stats', async (c) => {
         return c.json({ error: message }, 500);
     }
 });
+// GET /api/workspaces/:id/diff/:filePath — get original and modified content for a file
+app.get('/:id/diff-file', (c) => {
+    try {
+        const id = c.req.param('id');
+        const filePath = c.req.query('path');
+        if (!filePath) {
+            return c.json({ error: 'Missing path query parameter' }, 400);
+        }
+        const workspace = workspaceService.getWorkspace(id);
+        if (!workspace) {
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        }
+        const worktreePath = path.join(workspace.projectPath, '.worktrees', workspace.workingBranch);
+        const original = gitOps.getFileAtRef(worktreePath, workspace.sourceBranch, filePath);
+        const modified = gitOps.getFileContent(worktreePath, filePath);
+        return c.json({ original: original ?? '', modified: modified ?? '', filePath });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
 // POST /api/workspaces/:id/push — push working branch to origin
 app.post('/:id/push', async (c) => {
     try {
@@ -641,8 +791,7 @@ app.post('/:id/push', async (c) => {
         if (!workspace) {
             return c.json({ error: `Workspace '${id}' not found` }, 404);
         }
-        const path = await import('node:path');
-        const worktreePath = path.default.join(workspace.projectPath, '.worktrees', workspace.workingBranch);
+        const worktreePath = path.join(workspace.projectPath, '.worktrees', workspace.workingBranch);
         try {
             gitOps.pushBranch(worktreePath, workspace.workingBranch);
         }
@@ -651,10 +800,9 @@ app.post('/:id/push', async (c) => {
             return c.json({ error: message }, 500);
         }
         // Emit a trace into the chat feed so the user sees the action
-        const { emit } = await import('../services/websocket-service.js');
         const session = workspaceService.getLatestSession(id);
         const sessionId = session?.claudeSessionId ?? undefined;
-        emit(id, 'user:message', { content: `Pushed branch ${workspace.workingBranch} to origin`, sender: 'system-prompt' }, sessionId);
+        wsService.emit(id, 'user:message', { content: `Pushed branch ${workspace.workingBranch} to origin`, sender: 'system-prompt' }, sessionId);
         return c.json({ ok: true, branch: workspace.workingBranch });
     }
     catch (err) {
@@ -670,15 +818,14 @@ app.post('/:id/open-pr', async (c) => {
         if (!workspace) {
             return c.json({ error: `Workspace '${id}' not found` }, 404);
         }
-        const path = await import('node:path');
-        const worktreePath = path.default.join(workspace.projectPath, '.worktrees', workspace.workingBranch);
+        const worktreePath = path.join(workspace.projectPath, '.worktrees', workspace.workingBranch);
         // 1. Check branch is on remote
         let lsRemoteOut = '';
         try {
-            const result = execFileSync('git', ['ls-remote', '--heads', 'origin', workspace.workingBranch], {
+            const { stdout } = await execFileAsync('git', ['ls-remote', '--heads', 'origin', workspace.workingBranch], {
                 cwd: worktreePath,
             });
-            lsRemoteOut = result.toString();
+            lsRemoteOut = stdout;
         }
         catch {
             lsRemoteOut = '';
@@ -688,8 +835,8 @@ app.post('/:id/open-pr', async (c) => {
         }
         // 2. Check all local commits are pushed
         try {
-            const result = execFileSync('git', ['rev-list', '@{u}..HEAD', '--count'], { cwd: worktreePath });
-            const countStr = result.toString().trim();
+            const { stdout } = await execFileAsync('git', ['rev-list', '@{u}..HEAD', '--count'], { cwd: worktreePath });
+            const countStr = stdout.trim();
             const count = parseInt(countStr, 10) || 0;
             if (count > 0) {
                 return c.json({ error: 'Local commits not pushed', code: 'unpushed_commits' }, 409);
@@ -708,7 +855,7 @@ app.post('/:id/open-pr', async (c) => {
         let ghOutput;
         try {
             const placeholderBody = 'Automated PR — description will be updated by the agent.';
-            const result = execFileSync('gh', [
+            const { stdout } = await execFileAsync('gh', [
                 'pr',
                 'create',
                 '--base',
@@ -720,7 +867,7 @@ app.post('/:id/open-pr', async (c) => {
                 '--body',
                 placeholderBody,
             ], { cwd: worktreePath });
-            ghOutput = result.toString();
+            ghOutput = stdout;
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
@@ -741,7 +888,6 @@ app.post('/:id/open-pr', async (c) => {
             return c.json({ ok: true, prNumber, prUrl, messageSent: false });
         }
         // 6. Build context and render the template
-        const { renderPrTemplate } = await import('../services/pr-template-service.js');
         const commits = gitOps.getCommitsBetween(worktreePath, workspace.sourceBranch, workspace.workingBranch);
         const diffStats = gitOps.getDiffStatsBetween(worktreePath, workspace.sourceBranch, workspace.workingBranch);
         const tasks = workspaceService.listTasks(workspace.id);
@@ -754,10 +900,9 @@ app.post('/:id/open-pr', async (c) => {
             tasks,
         });
         // 7. Emit user:message into the chat feed
-        const { emit } = await import('../services/websocket-service.js');
         const session = workspaceService.getLatestSession(workspace.id);
         const sessionId = session?.claudeSessionId ?? undefined;
-        emit(workspace.id, 'user:message', { content: rendered, sender: 'user' }, sessionId);
+        wsService.emit(workspace.id, 'user:message', { content: rendered, sender: 'user' }, sessionId);
         // 8. Send to the running agent, or resume the agent with the PR prompt
         let messageSent = false;
         try {

package/dist/server/services/agent-manager.js

@@ -308,7 +308,7 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
         const text = data.toString();
         const lowerText = text.toLowerCase();
         if (lowerText.includes('rate limit') || lowerText.includes('quota') || lowerText.includes('limit exceeded')) {
-            handleQuota(workspaceId, workingDir, agent.claudeSessionId);
+            handleQuota(workspaceId, agent.claudeSessionId);
         }
         // Also emit stderr for visibility
         emit(workspaceId, 'agent:stderr', { content: text }, agent.claudeSessionId);
@@ -325,7 +325,13 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
         // I3: Close readline interface to release the stream reference
         agent.rl.close();
         unregisterProcess(workspaceId);
-        agents.delete(workspaceId);
+        // Only remove from the map if this exact agent instance is still current.
+        // stopAgent() eagerly removes the entry so startAgent() can proceed
+        // immediately; if a new agent was started in the meantime, we must not
+        // remove it.
+        if (agents.get(workspaceId) === agent) {
+            agents.delete(workspaceId);
+        }
         // Clean up retry state and inactivity timer
         retryCounts.delete(workspaceId);
         // C2: Clear the kill timer if it's still pending (process exited naturally before SIGKILL)
@@ -382,6 +388,10 @@ export function stopAgent(workspaceId) {
         throw new Error(`No agent running for workspace '${workspaceId}'`);
     }
     agent.status = 'stopping';
+    // Remove from the map immediately so startAgent() can be called right after
+    // without hitting "Agent already running". The exit handler checks identity
+    // before removing, so a new agent started in the meantime won't be affected.
+    agents.delete(workspaceId);
     // Cancel any pending backoff timer
     const timer = backoffTimers.get(workspaceId);
     if (timer) {
@@ -404,8 +414,10 @@ export function stopAgent(workspaceId) {
     }
     // After 5s timeout, send SIGKILL if still running
     const killTimer = setTimeout(() => {
-        // C2: Guard against race with natural exit — only act if this exact agent instance is still current
-        if (agents.get(workspaceId) !== agent) {
+        // C2: If a new agent has been started for this workspace in the meantime,
+        // don't kill the old process — it's handled by the new lifecycle.
+        const currentAgent = agents.get(workspaceId);
+        if (currentAgent && currentAgent !== agent) {
             killTimers.delete(workspaceId);
             return;
         }
@@ -446,7 +458,7 @@ export function getAvailableSkills() {
     return availableSkills;
 }
 // ── Quota handling ─────────────────────────────────────────────────────────────
-function handleQuota(workspaceId, workingDir, claudeSessionId) {
+function handleQuota(workspaceId, claudeSessionId) {
     // Update workspace status
     try {
         updateWorkspaceStatus(workspaceId, 'quota');
@@ -471,8 +483,14 @@ function handleQuota(workspaceId, workingDir, claudeSessionId) {
         backoffTimers.delete(workspaceId);
         // Only restart if not already running or stopped
         if (!agents.has(workspaceId)) {
+            // Re-read workspace from DB — it may have been deleted or archived during backoff
+            const freshWs = getWs(workspaceId);
+            if (!freshWs || freshWs.archivedAt !== null || freshWs.status !== 'quota') {
+                return;
+            }
             try {
-                startAgent(workspaceId, workingDir, 'Continue the previous task where you left off.', undefined, true);
+                const freshWorkingDir = `${freshWs.projectPath}/.worktrees/${freshWs.workingBranch}`;
+                startAgent(workspaceId, freshWorkingDir, 'Continue the previous task where you left off.', undefined, true);
             }
             catch {
                 // Agent restart failed