@loicngr/kobo 1.2.0 → 1.4.0

package/dist/server/routes/workspaces.js

@@ -1,8 +1,14 @@
-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 * as wsService from '../services/websocket-service.js';
 import * as workspaceService from '../services/workspace-service.js';
@@ -107,15 +113,34 @@ app.post('/', async (c) => {
             workspaceService.updateWorkspaceStatus(workspace.id, 'error');
             return c.json({ error: `Failed to create worktree: ${message}` }, 500);
         }
-        // 4b. Write git conventions to the worktree if configured
+        // 4b. Ensure Kobo-generated files inside .ai/ are gitignored (the .ai/ dir
+        //     itself may contain project files that SHOULD be committed).
+        try {
+            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 = [];
+            if (!lines.includes('.ai/git-conventions.md'))
+                toAdd.push('.ai/git-conventions.md');
+            if (!lines.includes('.ai/thoughts/'))
+                toAdd.push('.ai/thoughts/');
+            if (!lines.includes('.ai/images/'))
+                toAdd.push('.ai/images/');
+            if (toAdd.length > 0) {
+                const separator = existing.length > 0 && !existing.endsWith('\n') ? '\n' : '';
+                fs.appendFileSync(gitignorePath, `${separator}${toAdd.join('\n')}\n`, 'utf-8');
+            }
+        }
+        catch (err) {
+            console.error('[workspaces] Failed to update .gitignore:', err);
+        }
+        // 4c. Write git conventions to the worktree if configured
         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) {
@@ -126,16 +151,14 @@ app.post('/', async (c) => {
         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`;
@@ -196,8 +219,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);
         }
@@ -246,7 +268,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) {
@@ -304,7 +326,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);
@@ -338,6 +369,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 });
     }
@@ -346,6 +381,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 {
@@ -363,16 +416,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);
@@ -404,7 +507,7 @@ app.get('/:id', (c) => {
         return c.json({ error: message }, 500);
     }
 });
-// PATCH /api/workspaces/:id — update workspace fields (status, model)
+// PATCH /api/workspaces/:id — update workspace fields (status, model, permissionMode)
 app.patch('/:id', async (c) => {
     try {
         const id = c.req.param('id');
@@ -417,11 +520,18 @@ app.patch('/:id', async (c) => {
         if (body.model !== undefined) {
             updated = workspaceService.updateWorkspaceModel(id, body.model);
         }
+        if (body.permissionMode !== undefined) {
+            const validModes = ['auto-accept', 'plan'];
+            if (!validModes.includes(body.permissionMode)) {
+                return c.json({ error: `Invalid permission mode. Must be one of: ${validModes.join(', ')}` }, 400);
+            }
+            updated = workspaceService.updateWorkspacePermissionMode(id, body.permissionMode);
+        }
         if (body.status) {
             updated = workspaceService.updateWorkspaceStatus(id, body.status);
         }
-        if (!body.status && body.model === undefined) {
-            return c.json({ error: 'Missing field: status or model' }, 400);
+        if (!body.status && body.model === undefined && body.permissionMode === undefined) {
+            return c.json({ error: 'Missing field: status, model, or permissionMode' }, 400);
         }
         return c.json(updated);
     }
@@ -565,7 +675,7 @@ app.post('/:id/start', async (c) => {
             // Agent may not be running — ignore
         }
         const worktreePath = `${workspace.projectPath}/.worktrees/${workspace.workingBranch}`;
-        agentManager.startAgent(id, worktreePath, prompt, workspace.model);
+        agentManager.startAgent(id, worktreePath, prompt, workspace.model, false, workspace.permissionMode);
         workspaceService.updateWorkspaceStatus(id, 'executing');
         return c.json({ status: 'started' });
     }
@@ -582,17 +692,21 @@ 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 prUrl = gitOps.getPrUrl(workspace.projectPath, workspace.workingBranch);
+        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,
             insertions: diffStats.insertions,
             deletions: diffStats.deletions,
-            prUrl,
+            prUrl: pr?.url ?? null,
+            prState: pr?.state ?? null,
+            unpushedCount,
+            workingTree,
         });
     }
     catch (err) {
@@ -600,6 +714,49 @@ app.get('/:id/git-stats', async (c) => {
         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) {
+        const message = err instanceof Error ? err.message : String(err);
+        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 {
@@ -608,8 +765,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);
         }
@@ -618,10 +774,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) {
@@ -637,15 +792,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 = '';
@@ -655,8 +809,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);
@@ -675,7 +829,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',
@@ -687,7 +841,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);
@@ -708,7 +862,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);
@@ -721,26 +874,29 @@ 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);
-        // 8. Send to the running agent (degrade on failure)
+        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 {
             agentManager.sendMessage(workspace.id, rendered);
-            return c.json({ ok: true, prNumber, prUrl, messageSent: true });
+            messageSent = true;
         }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.warn(`[workspaces] open-pr: PR created but sendMessage failed: ${message}`);
-            return c.json({
-                ok: true,
-                prNumber,
-                prUrl,
-                messageSent: false,
-                warning: `Agent is not active — message was not sent (${message})`,
-            });
+        catch {
+            // Agent not running — resume it with the PR prompt
+            try {
+                const worktreePathForResume = `${workspace.projectPath}/.worktrees/${workspace.workingBranch}`;
+                agentManager.startAgent(workspace.id, worktreePathForResume, rendered, workspace.model, true, workspace.permissionMode);
+                workspaceService.updateWorkspaceStatus(workspace.id, 'executing');
+                messageSent = true;
+            }
+            catch (resumeErr) {
+                const resumeMsg = resumeErr instanceof Error ? resumeErr.message : String(resumeErr);
+                console.warn(`[workspaces] open-pr: PR created but agent resume failed: ${resumeMsg}`);
+            }
         }
+        return c.json({ ok: true, prNumber, prUrl, messageSent });
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);

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

@@ -6,6 +6,7 @@ import { nanoid } from 'nanoid';
 import { getDb } from '../db/index.js';
 import { ensureKoboHome, getCompiledMcpServerPath, getDbPath, getMcpServerSourcePath, getSettingsPath, getSkillsPath, } from '../utils/paths.js';
 import { registerProcess, unregisterProcess } from '../utils/process-tracker.js';
+import { getEffectiveSettings } from './settings-service.js';
 import { emit } from './websocket-service.js';
 import { getWorkspace as getWs, listTasks, updateWorkspaceStatus } from './workspace-service.js';
 // ── State ──────────────────────────────────────────────────────────────────────
@@ -35,8 +36,71 @@ const retryCounts = new Map();
 const backoffTimers = new Map();
 /** workspaceId -> pending SIGKILL timer */
 const killTimers = new Map();
+// ── Watchdog ──────────────────────────────────────────────────────────────────
+// Periodically checks that tracked agent processes are still alive.
+// If a process died without triggering the 'exit' handler (crash, OOM kill,
+// etc.), the watchdog cleans up and updates the workspace status.
+const WATCHDOG_INTERVAL_MS = 30_000;
+let watchdogTimer = null;
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0); // signal 0 = existence check, doesn't actually kill
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function runWatchdog() {
+    for (const [workspaceId, agent] of agents) {
+        const pid = agent.process.pid;
+        if (pid === undefined || isProcessAlive(pid))
+            continue;
+        console.error(`[watchdog] Agent process for workspace '${workspaceId}' (PID ${pid}) is dead — cleaning up`);
+        // Close readline to release the stream
+        try {
+            agent.rl.close();
+        }
+        catch {
+            // Ignore
+        }
+        unregisterProcess(workspaceId);
+        agents.delete(workspaceId);
+        retryCounts.delete(workspaceId);
+        // Update DB session
+        try {
+            const db = getDb();
+            db.prepare('UPDATE agent_sessions SET status = ?, ended_at = ? WHERE id = ?').run('error', new Date().toISOString(), agent.agentSessionId);
+        }
+        catch (err) {
+            console.error('[watchdog] Failed to update agent_sessions:', err);
+        }
+        // Update workspace status
+        try {
+            updateWorkspaceStatus(workspaceId, 'error');
+        }
+        catch {
+            // Transition may not be valid — ignore
+        }
+        emit(workspaceId, 'agent:status', { status: 'error', message: 'Agent process died unexpectedly' }, agent.claudeSessionId);
+    }
+}
+/** Start the watchdog (called once from server bootstrap). */
+export function startWatchdog() {
+    if (watchdogTimer)
+        return;
+    watchdogTimer = setInterval(runWatchdog, WATCHDOG_INTERVAL_MS);
+    watchdogTimer.unref?.();
+}
+/** Stop the watchdog (for clean shutdown / tests). */
+export function stopWatchdog() {
+    if (watchdogTimer) {
+        clearInterval(watchdogTimer);
+        watchdogTimer = null;
+    }
+}
 // ── Start agent ────────────────────────────────────────────────────────────────
-export function startAgent(workspaceId, workingDir, prompt, model, resume = false) {
+export function startAgent(workspaceId, workingDir, prompt, model, resume = false, permissionMode = 'auto-accept') {
     // Check if agent already running for this workspace
     if (agents.has(workspaceId)) {
         throw new Error(`Agent already running for workspace '${workspaceId}'`);
@@ -44,8 +108,18 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
     const db = getDb();
     let agentSessionId;
     let resumedClaudeSessionId;
-    // Build CLI args
-    const args = ['--dangerously-skip-permissions', '--output-format', 'stream-json', '--verbose'];
+    // Build CLI args — read dangerouslySkipPermissions from effective settings
+    const ws = getWs(workspaceId);
+    const effectiveSettings = ws ? getEffectiveSettings(ws.projectPath) : null;
+    const skipPermissions = effectiveSettings?.dangerouslySkipPermissions ?? true;
+    const args = ['--output-format', 'stream-json', '--verbose'];
+    if (skipPermissions) {
+        args.push('--dangerously-skip-permissions');
+    }
+    if (permissionMode === 'plan') {
+        // In plan mode, prepend read-only instructions to the prompt
+        prompt = `[PLAN MODE] You are in PLAN/READ-ONLY mode. You MUST NOT create, edit, write, or delete any files. Only use read-only tools (Read, Grep, Glob, LS, Bash for read-only commands). Analyze the codebase, plan your approach, and present your findings — but do NOT execute any changes.\n\n${prompt}`;
+    }
     if (model && model !== 'auto') {
         args.push('--model', model);
     }
@@ -234,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);
@@ -251,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)
@@ -308,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) {
@@ -330,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;
         }
@@ -372,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');
@@ -397,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

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

@@ -1,5 +1,6 @@
 import { spawn } from 'node:child_process';
 import { readFileSync } from 'node:fs';
+import { getPackageVersion } from '../utils/paths.js';
 // Gherkin keywords (French and English)
 const GHERKIN_PATTERN = /^(Scénario|Étant donné|Quand|Alors|Scenario|Given|When|Then|Feature|Fonctionnalité|And|Et|But|Mais)/i;
 // C2: rpcIdCounter encapsulated in a closure to avoid module-level mutable state
@@ -53,10 +54,11 @@ export async function callMcpTool(mcpProcess, toolName, args) {
             return;
         }
         let buffer = '';
-        // C1: 30s timeout
+        // C1: 30s timeout — I7: kill the MCP process on timeout to avoid zombie
         const timeout = setTimeout(() => {
             mcpProcess.stdout?.removeListener('data', onData);
             mcpProcess.stdout?.removeListener('error', onError);
+            mcpProcess.kill();
             reject(new Error(`callMcpTool('${toolName}') timed out after 30s`));
         }, 30_000);
         const onData = (chunk) => {
@@ -155,7 +157,7 @@ async function initializeMcp(mcpProcess) {
         params: {
             protocolVersion: '2024-11-05',
             capabilities: {},
-            clientInfo: { name: 'kobo', version: '0.1.0' },
+            clientInfo: { name: 'kobo', version: getPackageVersion() },
         },
     });
     await new Promise((resolve, reject) => {
@@ -164,9 +166,10 @@ async function initializeMcp(mcpProcess) {
             return;
         }
         let buffer = '';
-        // C1: 10s timeout for initialization
+        // C1: 10s timeout for initialization — I7: kill the MCP process on timeout
         const timeout = setTimeout(() => {
             mcpProcess.stdout?.removeListener('data', onData);
+            mcpProcess.kill();
             reject(new Error('initializeMcp timed out after 10s'));
         }, 10_000);
         const onData = (chunk) => {