@loicngr/kobo 1.4.10 → 1.4.12

package/dist/server/routes/workspaces.js

@@ -11,6 +11,7 @@ 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 terminalService from '../services/terminal-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';
@@ -286,10 +287,11 @@ 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
-            wsService.emit(workspace.id, 'user:message', { content: brainstormPrompt, sender: 'system-prompt' });
             try {
-                agentManager.startAgent(workspace.id, worktreePath, brainstormPrompt, workspace.model);
+                const agent = agentManager.startAgent(workspace.id, worktreePath, brainstormPrompt, workspace.model);
+                // 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);
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
@@ -311,6 +313,28 @@ app.post('/', async (c) => {
         return c.json({ error: message }, 500);
     }
 });
+// POST /api/workspaces/:id/sessions — create a new idle agent session
+app.post('/:id/sessions', (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);
+        }
+        if (agentManager.getAgentStatus(id) !== null) {
+            return c.json({ error: 'An agent is already running for this workspace' }, 409);
+        }
+        const session = workspaceService.createIdleSession(id);
+        return c.json(session, 201);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
 // GET /api/workspaces/:id/sessions — list sessions for a workspace
 app.get('/:id/sessions', (c) => {
     try {
@@ -326,6 +350,30 @@ app.get('/:id/sessions', (c) => {
         return c.json({ error: message }, 500);
     }
 });
+// PATCH /api/workspaces/:id/sessions/:sessionId — rename a session
+app.patch('/:id/sessions/:sessionId', async (c) => {
+    try {
+        const id = c.req.param('id');
+        const sessionId = c.req.param('sessionId');
+        const workspace = workspaceService.getWorkspace(id);
+        if (!workspace) {
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        }
+        const body = await c.req.json().catch(() => ({}));
+        if (!body.name?.trim()) {
+            return c.json({ error: 'name is required and must not be empty' }, 400);
+        }
+        const updated = workspaceService.renameSession(sessionId, id, body.name.trim());
+        if (!updated) {
+            return c.json({ error: `Session '${sessionId}' not found` }, 404);
+        }
+        return c.json(updated);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
 // POST /api/workspaces/:id/refresh-notion — re-extract Notion page and update tasks
 app.post('/:id/refresh-notion', async (c) => {
     try {
@@ -715,6 +763,12 @@ app.post('/:id/archive', (c) => {
             const message = err instanceof Error ? err.message : String(err);
             console.error(`[workspaces] stopDevServer during archive failed: ${message}`);
         }
+        try {
+            terminalService.destroyTerminal(id);
+        }
+        catch {
+            // Terminal may not exist — ignore
+        }
         const updated = workspaceService.archiveWorkspace(id);
         wsService.emitEphemeral(id, 'workspace:archived', { workspace: updated });
         return c.json(updated);
@@ -763,6 +817,12 @@ app.delete('/:id', async (c) => {
         catch {
             // Agent may not be running — ignore
         }
+        try {
+            terminalService.destroyTerminal(id);
+        }
+        catch {
+            // Terminal may not exist — ignore
+        }
         // Remove worktree
         const worktreesDir = `${workspace.projectPath}/.worktrees`;
         const worktreePath = `${worktreesDir}/${workspace.workingBranch}`;
@@ -810,8 +870,12 @@ app.post('/:id/start', async (c) => {
         if (!workspace) {
             return c.json({ error: `Workspace '${id}' not found` }, 404);
         }
-        const body = await c.req.json().catch(() => ({ prompt: undefined }));
+        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.';
+        const agentSessionId = body.agentSessionId;
+        const resume = body.resume === true;
         // Stop existing agent if running
         try {
             agentManager.stopAgent(id);
@@ -820,8 +884,14 @@ 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, false, workspace.permissionMode);
+        const agent = agentManager.startAgent(id, worktreePath, prompt, workspace.model, resume, workspace.permissionMode, agentSessionId);
         workspaceService.updateWorkspaceStatus(id, 'executing');
+        // Persist the user prompt so it survives page refresh.
+        // When agentSessionId is provided (idle-session flow), the prompt was typed
+        // by the user in the chat input; otherwise it's the workspace start prompt.
+        if (body.prompt) {
+            wsService.emit(id, 'user:message', { content: body.prompt, sender: 'user' }, agent.agentSessionId);
+        }
         return c.json({ status: 'started' });
     }
     catch (err) {
@@ -919,9 +989,34 @@ 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 session = workspaceService.getLatestSession(id);
-        const sessionId = session?.claudeSessionId ?? undefined;
-        wsService.emit(id, 'user:message', { content: `Pushed branch ${workspace.workingBranch} to origin`, sender: 'system-prompt' }, sessionId);
+        const session = workspaceService.getActiveSession(id);
+        wsService.emit(id, 'user:message', { content: `Pushed branch ${workspace.workingBranch} to origin`, sender: 'system-prompt' }, session?.id ?? undefined);
+        return c.json({ ok: true, branch: workspace.workingBranch });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
+// POST /api/workspaces/:id/pull — pull working branch from origin (fast-forward only)
+app.post('/:id/pull', (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);
+        try {
+            gitOps.pullBranch(worktreePath, workspace.workingBranch);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return c.json({ error: message }, 500);
+        }
+        // Emit a trace into the chat feed so the user sees the action
+        const session = workspaceService.getActiveSession(id);
+        wsService.emit(id, 'user:message', { content: `Pulled branch ${workspace.workingBranch} from origin`, sender: 'system-prompt' }, session?.id ?? undefined);
         return c.json({ ok: true, branch: workspace.workingBranch });
     }
     catch (err) {
@@ -1054,9 +1149,8 @@ app.post('/:id/open-pr', async (c) => {
             tasks,
         });
         // Emit user:message into the chat feed
-        const session = workspaceService.getLatestSession(workspace.id);
-        const sessionId = session?.claudeSessionId ?? undefined;
-        wsService.emit(workspace.id, 'user:message', { content: rendered, sender: 'user' }, sessionId);
+        const session = workspaceService.getActiveSession(workspace.id);
+        wsService.emit(workspace.id, 'user:message', { content: rendered, sender: 'user' }, session?.id ?? undefined);
         // Send to the running agent, or resume the agent with the PR prompt
         let messageSent = false;
         try {
@@ -1128,4 +1222,20 @@ app.post('/:id/stop', (c) => {
         return c.json({ error: message }, 500);
     }
 });
+// POST /api/workspaces/:id/interrupt — soft-interrupt agent (SIGINT, like Escape in Claude Code)
+app.post('/:id/interrupt', (c) => {
+    try {
+        const id = c.req.param('id');
+        const workspace = workspaceService.getWorkspace(id);
+        if (!workspace) {
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        }
+        agentManager.interruptAgent(id);
+        return c.json({ status: 'interrupted' });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
 export default app;

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

@@ -89,7 +89,7 @@ function runWatchdog() {
         catch {
             // best-effort
         }
-        emit(workspaceId, 'agent:status', { status: 'error', message: 'Agent process died unexpectedly' }, agent.claudeSessionId);
+        emit(workspaceId, 'agent:status', { status: 'error', message: 'Agent process died unexpectedly' }, agent.agentSessionId);
     }
 }
 /** Start the watchdog (called once from server bootstrap). */
@@ -108,7 +108,7 @@ export function stopWatchdog() {
 }
 // ── Start agent ────────────────────────────────────────────────────────────────
 /** Spawn a Claude Code CLI process for a workspace and wire up stdout/stderr/exit handling. */
-export function startAgent(workspaceId, workingDir, prompt, model, resume = false, permissionMode = 'auto-accept') {
+export function startAgent(workspaceId, workingDir, prompt, model, resume = false, permissionMode = 'auto-accept', existingSessionId) {
     // Check if agent already running for this workspace
     if (agents.has(workspaceId)) {
         throw new Error(`Agent already running for workspace '${workspaceId}'`);
@@ -132,10 +132,28 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
         args.push('--model', model);
     }
     if (resume) {
-        const lastSession = db
-            .prepare('SELECT id, claude_session_id FROM agent_sessions WHERE workspace_id = ? AND claude_session_id IS NOT NULL ORDER BY started_at DESC LIMIT 1')
-            .get(workspaceId);
-        const claudeSessionId = sessionIds.get(workspaceId) ?? lastSession?.claude_session_id;
+        // Prefer resuming the specific session requested by the caller (existingSessionId).
+        // Otherwise fall back to the most recent session for the workspace.
+        let lastSession;
+        if (existingSessionId) {
+            lastSession = db
+                .prepare('SELECT id, claude_session_id FROM agent_sessions WHERE id = ? AND workspace_id = ? AND claude_session_id IS NOT NULL LIMIT 1')
+                .get(existingSessionId, workspaceId);
+            // If the caller explicitly asked to resume a specific session, fail loudly
+            // when it cannot be resumed (no claude_session_id, wrong workspace, or
+            // missing row). Silently creating a new session would orphan the target.
+            if (!lastSession) {
+                throw new Error(`Cannot resume session '${existingSessionId}' for workspace '${workspaceId}': ` +
+                    'session not found or has no associated Claude conversation');
+            }
+        }
+        else {
+            lastSession = db
+                .prepare('SELECT id, claude_session_id FROM agent_sessions WHERE workspace_id = ? AND claude_session_id IS NOT NULL ORDER BY started_at DESC LIMIT 1')
+                .get(workspaceId);
+        }
+        // The in-memory cache is workspace-scoped, only useful when no specific session was requested.
+        const claudeSessionId = lastSession?.claude_session_id ?? (existingSessionId ? undefined : sessionIds.get(workspaceId));
         if (claudeSessionId) {
             resumedClaudeSessionId = claudeSessionId;
             args.push('--resume', claudeSessionId, '-p', prompt);
@@ -160,8 +178,19 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
     }
     else {
         args.push('-p', prompt);
-        agentSessionId = nanoid();
-        db.prepare('INSERT INTO agent_sessions (id, workspace_id, pid, status, started_at) VALUES (?, ?, ?, ?, ?)').run(agentSessionId, workspaceId, null, 'running', new Date().toISOString());
+        if (existingSessionId) {
+            const result = db
+                .prepare('UPDATE agent_sessions SET status = ?, started_at = ?, ended_at = NULL WHERE id = ? AND workspace_id = ?')
+                .run('running', new Date().toISOString(), existingSessionId, workspaceId);
+            if (result.changes === 0) {
+                throw new Error(`Agent session '${existingSessionId}' not found for workspace '${workspaceId}'`);
+            }
+            agentSessionId = existingSessionId;
+        }
+        else {
+            agentSessionId = nanoid();
+            db.prepare('INSERT INTO agent_sessions (id, workspace_id, pid, status, started_at) VALUES (?, ?, ?, ?, ?)').run(agentSessionId, workspaceId, null, 'running', new Date().toISOString());
+        }
     }
     // Write .mcp.json to workingDir so claude picks up the kobo-tasks MCP server
     const mcpConfigPath = path.join(workingDir, '.mcp.json');
@@ -220,12 +249,12 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
         }
         catch {
             // Parsing failed — emit raw line
-            emit(workspaceId, 'agent:output', { type: 'raw', content: line }, agent.claudeSessionId);
+            emit(workspaceId, 'agent:output', { type: 'raw', content: line }, agent.agentSessionId);
             // Check for BRAINSTORM_COMPLETE marker in raw lines
             if (line.includes('[BRAINSTORM_COMPLETE]')) {
                 try {
                     updateWorkspaceStatus(workspaceId, 'executing');
-                    emit(workspaceId, 'agent:status', { status: 'executing' }, agent.claudeSessionId);
+                    emit(workspaceId, 'agent:status', { status: 'executing' }, agent.agentSessionId);
                 }
                 catch (err) {
                     console.error('[agent] Failed to transition to executing:', err);
@@ -289,7 +318,7 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
         if (msgType === 'user') {
             return;
         }
-        emit(workspaceId, 'agent:output', parsed, agent.claudeSessionId);
+        emit(workspaceId, 'agent:output', parsed, agent.agentSessionId);
         // Detect brainstorming completion from parsed output
         if (msgType === 'assistant' && Array.isArray(p.content)) {
             const hasMarker = p.content.some((block) => {
@@ -299,7 +328,7 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
             if (hasMarker) {
                 try {
                     updateWorkspaceStatus(workspaceId, 'executing');
-                    emit(workspaceId, 'agent:status', { status: 'executing' }, agent.claudeSessionId);
+                    emit(workspaceId, 'agent:status', { status: 'executing' }, agent.agentSessionId);
                 }
                 catch (err) {
                     console.error('[agent] Failed to transition to executing:', err);
@@ -315,10 +344,10 @@ 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, agent.claudeSessionId);
+            handleQuota(workspaceId, agent.agentSessionId);
         }
         // Also emit stderr for visibility
-        emit(workspaceId, 'agent:stderr', { content: text }, agent.claudeSessionId);
+        emit(workspaceId, 'agent:stderr', { content: text }, agent.agentSessionId);
     });
     // ── process exit ──
     proc.on('exit', (code) => {
@@ -353,7 +382,7 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
         }
         if (agent.status === 'stopping') {
             // Clean stop requested
-            emit(workspaceId, 'agent:status', { status: 'stopped' }, agent.claudeSessionId);
+            emit(workspaceId, 'agent:status', { status: 'stopped' }, agent.agentSessionId);
             return;
         }
         // Also clear backoff timers on non-stopping exit
@@ -376,7 +405,7 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
             catch {
                 // best-effort
             }
-            emit(workspaceId, 'agent:status', { status: 'error', exitCode: code }, agent.claudeSessionId);
+            emit(workspaceId, 'agent:status', { status: 'error', exitCode: code }, agent.agentSessionId);
         }
         else {
             try {
@@ -392,15 +421,39 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
             catch {
                 // best-effort
             }
-            emit(workspaceId, 'agent:status', { status: 'completed' }, agent.claudeSessionId);
+            emit(workspaceId, 'agent:status', { status: 'completed' }, agent.agentSessionId);
         }
     });
     // Store in agents map
     agents.set(workspaceId, agent);
     // Notify frontend that agent is now running
-    emit(workspaceId, 'agent:status', { status: 'executing' }, agent.claudeSessionId);
+    emit(workspaceId, 'agent:status', { status: 'executing' }, agent.agentSessionId);
     return agent;
 }
+// ── Interrupt agent ────────────────────────────────────────────────────────────
+/**
+ * Soft-interrupt the running agent by sending SIGINT. This mirrors pressing
+ * Escape in Claude Code CLI: the current tool call is aborted but the process
+ * stays alive and waits for the next user message. The agent session remains
+ * in 'running' status.
+ */
+export function interruptAgent(workspaceId) {
+    const agent = agents.get(workspaceId);
+    if (!agent) {
+        throw new Error(`No agent running for workspace '${workspaceId}'`);
+    }
+    const pid = agent.process.pid;
+    if (pid === undefined) {
+        throw new Error(`Agent process has no PID for workspace '${workspaceId}'`);
+    }
+    try {
+        process.kill(pid, 'SIGINT');
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Failed to interrupt agent for workspace '${workspaceId}': ${message}`);
+    }
+}
 // ── Stop agent ─────────────────────────────────────────────────────────────────
 /** Gracefully stop an agent (SIGTERM, then SIGKILL after 5s). */
 export function stopAgent(workspaceId) {
@@ -484,7 +537,7 @@ export function getAvailableSkills() {
     return [...KOBO_COMMANDS, ...availableSkills];
 }
 // ── Quota handling ─────────────────────────────────────────────────────────────
-function handleQuota(workspaceId, claudeSessionId) {
+function handleQuota(workspaceId, agentSessionId) {
     // Update workspace status
     try {
         updateWorkspaceStatus(workspaceId, 'quota');
@@ -493,7 +546,7 @@ function handleQuota(workspaceId, claudeSessionId) {
         // May fail if transition is not valid
     }
     // Emit status event
-    emit(workspaceId, 'agent:status', { status: 'quota' }, claudeSessionId);
+    emit(workspaceId, 'agent:status', { status: 'quota' }, agentSessionId);
     // Calculate backoff: 15min first, then 30min, then 60min cap
     const retryCount = retryCounts.get(workspaceId) ?? 0;
     const backoffMinutes = Math.min(15 * 2 ** retryCount, 60);
@@ -503,7 +556,7 @@ function handleQuota(workspaceId, claudeSessionId) {
         status: 'quota:backoff',
         retryCount: retryCount + 1,
         backoffMinutes,
-    }, claudeSessionId);
+    }, agentSessionId);
     // Set timer to restart agent
     const timer = setTimeout(() => {
         backoffTimers.delete(workspaceId);

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

@@ -0,0 +1,173 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { getTemplatesPath } from '../utils/paths.js';
+const CURRENT_FILE_VERSION = 1;
+const SLUG_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/;
+const MAX_CONTENT_LENGTH = 4096;
+const MAX_DESCRIPTION_LENGTH = 120;
+/**
+ * Read the templates list from disk. Seeds with defaults if the file does
+ * not exist yet. Returns an empty array (with a logged error) on corruption.
+ */
+export function listTemplates() {
+    const filePath = getTemplatesPath();
+    if (!existsSync(filePath)) {
+        seedTemplates();
+    }
+    try {
+        const raw = readFileSync(filePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (parsed.version !== CURRENT_FILE_VERSION) {
+            console.warn(`[templates-service] templates.json has version ${parsed.version}, expected ${CURRENT_FILE_VERSION}. Reading best-effort.`);
+        }
+        return Array.isArray(parsed.templates) ? parsed.templates : [];
+    }
+    catch (err) {
+        console.error('[templates-service] Failed to read templates.json:', err);
+        return [];
+    }
+}
+/** Create a new template. Throws on invalid input or duplicate slug. */
+export function createTemplate(input) {
+    validateTemplateInput(input);
+    const templates = listTemplates();
+    if (templates.some((t) => t.slug === input.slug)) {
+        throw new Error(`Template '${input.slug}' already exists`);
+    }
+    const now = new Date().toISOString();
+    const template = {
+        slug: input.slug,
+        description: input.description,
+        content: input.content,
+        createdAt: now,
+        updatedAt: now,
+    };
+    writeTemplates([...templates, template]);
+    return template;
+}
+/** Update an existing template. Returns null if slug not found. */
+export function updateTemplate(slug, updates) {
+    const templates = listTemplates();
+    const idx = templates.findIndex((t) => t.slug === slug);
+    if (idx < 0)
+        return null;
+    const current = templates[idx];
+    const next = {
+        ...current,
+        description: updates.description ?? current.description,
+        content: updates.content ?? current.content,
+        updatedAt: new Date().toISOString(),
+    };
+    validateTemplateInput({ slug: next.slug, description: next.description, content: next.content });
+    templates[idx] = next;
+    writeTemplates(templates);
+    return next;
+}
+/** Delete a template. Returns true if deleted, false if not found. */
+export function deleteTemplate(slug) {
+    const templates = listTemplates();
+    const next = templates.filter((t) => t.slug !== slug);
+    if (next.length === templates.length)
+        return false;
+    writeTemplates(next);
+    return true;
+}
+// ── Internals ──────────────────────────────────────────────────────────────
+function validateTemplateInput(input) {
+    if (!SLUG_PATTERN.test(input.slug)) {
+        throw new Error(`Invalid slug '${input.slug}': must match ${SLUG_PATTERN} (lowercase letters, digits, hyphens; 1–64 chars)`);
+    }
+    // Consistent rule for both description and content:
+    //  - reject if empty after trim (all-whitespace is not valid)
+    //  - reject if raw length exceeds the max (trailing whitespace still counts)
+    const rawDescription = input.description ?? '';
+    if (rawDescription.trim().length === 0 || rawDescription.length > MAX_DESCRIPTION_LENGTH) {
+        throw new Error(`Invalid description: must be 1..${MAX_DESCRIPTION_LENGTH} chars`);
+    }
+    const rawContent = input.content ?? '';
+    if (rawContent.trim().length === 0 || rawContent.length > MAX_CONTENT_LENGTH) {
+        throw new Error(`Invalid content: must be 1..${MAX_CONTENT_LENGTH} chars`);
+    }
+}
+function writeTemplates(templates) {
+    const filePath = getTemplatesPath();
+    mkdirSync(path.dirname(filePath), { recursive: true });
+    const file = { version: CURRENT_FILE_VERSION, templates };
+    writeFileSync(filePath, JSON.stringify(file, null, 2), 'utf-8');
+}
+function seedTemplates() {
+    const now = new Date().toISOString();
+    const seed = [
+        {
+            slug: 'review-quality',
+            description: 'Code quality review',
+            content: 'Review the recently modified code in {working_branch} for:\n- Logic bugs\n- Missing error handling\n- Style issues\n\nReport only high-confidence findings.',
+            createdAt: now,
+            updatedAt: now,
+        },
+        {
+            slug: 'add-tests',
+            description: 'Add unit tests following existing patterns',
+            content: 'Add unit tests for the recently modified code. Follow the existing test patterns in this project. Focus on:\n- Happy paths\n- Edge cases\n- Error handling',
+            createdAt: now,
+            updatedAt: now,
+        },
+        {
+            slug: 'explain',
+            description: 'Explain the recent changes',
+            content: 'Explain what the recently modified code does in {working_branch}, focusing on the non-obvious parts.',
+            createdAt: now,
+            updatedAt: now,
+        },
+        {
+            slug: 'refactor',
+            description: 'Safe refactoring',
+            content: 'Refactor the selected code to improve readability without changing its behavior. Explain your reasoning as you go.',
+            createdAt: now,
+            updatedAt: now,
+        },
+        {
+            slug: 'plan-tasks',
+            description: 'Break work into kobo tasks',
+            content: 'Break down the work for this workspace ({workspace_name}) into concrete tasks. Use the kobo-tasks MCP tool `create_task` to register each one with a short, actionable title. Start with a high-level analysis of what needs to happen.',
+            createdAt: now,
+            updatedAt: now,
+        },
+        {
+            slug: 'show-tasks',
+            description: 'List current kobo tasks',
+            content: 'List the current tasks for this workspace using the kobo-tasks MCP tool `list_tasks`. Show their status and highlight what is still pending.',
+            createdAt: now,
+            updatedAt: now,
+        },
+        {
+            slug: 'mark-done',
+            description: 'Mark completed kobo tasks',
+            content: 'Review the work completed so far. Identify which tasks from the kobo-tasks list are now done, and mark them using the `mark_task_done` MCP tool.',
+            createdAt: now,
+            updatedAt: now,
+        },
+        {
+            slug: 'sync-tasks',
+            description: 'Sync kobo tasks with the codebase',
+            content: 'Compare the current state of the codebase against the kobo-tasks list. Create missing tasks with `create_task`, mark completed ones with `mark_task_done`, and delete stale ones with `delete_task`. Explain each change before making it.',
+            createdAt: now,
+            updatedAt: now,
+        },
+        {
+            slug: 'pr-review-comments',
+            description: 'List PR review comments requesting changes',
+            content: 'Check if a pull request exists for branch {working_branch}.\n\nIf a PR exists (PR {pr_url}):\n1. Use the GitHub MCP tools to fetch the PR reviews and comments\n2. Filter for reviews with status "CHANGES_REQUESTED"\n3. List each review comment with:\n   - The reviewer name\n   - The file and line referenced\n   - The comment body\n   - Whether it has been resolved\n4. Summarize the outstanding requested changes that still need to be addressed\n\nIf no PR exists, say so and suggest pushing the branch first.',
+            createdAt: now,
+            updatedAt: now,
+        },
+        {
+            slug: 'ci-status',
+            description: 'Check GitHub Actions status on PR',
+            content: 'Check the CI/CD status for the pull request on branch {working_branch}.\n\nIf a PR exists (PR {pr_url}):\n1. Use the GitHub MCP tools to list the check runs / status checks on the latest commit of the PR\n2. For each check, report:\n   - Check name\n   - Status (queued, in_progress, completed)\n   - Conclusion (success, failure, neutral, skipped, etc.)\n   - Duration if available\n3. If any checks failed, fetch the logs or annotations and summarize what went wrong\n4. Give an overall summary: all green, some failing, or still running\n\nIf no PR exists, say so and suggest creating one first.',
+            createdAt: now,
+            updatedAt: now,
+        },
+    ];
+    writeTemplates(seed);
+}

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

@@ -0,0 +1,44 @@
+import fs from 'node:fs';
+import * as pty from 'node-pty';
+const terminals = new Map();
+export function createTerminal(workspaceId, cwd) {
+    if (terminals.has(workspaceId)) {
+        return terminals.get(workspaceId).pty;
+    }
+    if (!fs.existsSync(cwd)) {
+        throw new Error(`Worktree directory does not exist: ${cwd}`);
+    }
+    const shell = process.env.SHELL || '/bin/sh';
+    const term = pty.spawn(shell, [], {
+        name: 'xterm-256color',
+        cols: 80,
+        rows: 24,
+        cwd,
+        env: process.env,
+    });
+    terminals.set(workspaceId, { pty: term });
+    term.onExit(() => {
+        terminals.delete(workspaceId);
+    });
+    return term;
+}
+export function getTerminal(workspaceId) {
+    return terminals.get(workspaceId)?.pty ?? null;
+}
+export function destroyTerminal(workspaceId) {
+    const instance = terminals.get(workspaceId);
+    if (instance) {
+        try {
+            instance.pty.kill();
+        }
+        catch (err) {
+            console.error(`[terminal] Failed to kill PTY for workspace ${workspaceId}:`, err);
+        }
+        terminals.delete(workspaceId);
+    }
+}
+export function destroyAllTerminals() {
+    for (const [id] of terminals) {
+        destroyTerminal(id);
+    }
+}