@loicngr/kobo 1.1.1 → 1.2.0

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

@@ -1,3 +1,7 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { nanoid } from 'nanoid';
+export const VALID_TASK_STATUSES = ['pending', 'in_progress', 'done'];
 function rowToDto(row) {
     return {
         id: row.id,
@@ -25,3 +29,146 @@ export function markTaskDoneHandler(db, workspaceId, taskId) {
         .get(taskId);
     return { success: true, task: rowToDto(row) };
 }
+export function createTaskHandler(db, workspaceId, data) {
+    if (!data.title?.trim()) {
+        throw new Error('title is required');
+    }
+    // Verify workspace exists
+    const ws = db.prepare('SELECT id FROM workspaces WHERE id = ?').get(workspaceId);
+    if (!ws) {
+        throw new Error(`Workspace '${workspaceId}' not found`);
+    }
+    const id = nanoid();
+    const now = new Date().toISOString();
+    const isAC = data.is_acceptance_criterion ? 1 : 0;
+    // Append at the end: max(sort_order) + 1
+    const maxRow = db
+        .prepare('SELECT COALESCE(MAX(sort_order), -1) AS max FROM tasks WHERE workspace_id = ?')
+        .get(workspaceId);
+    const sortOrder = maxRow.max + 1;
+    db.prepare('INSERT INTO tasks (id, workspace_id, title, status, is_acceptance_criterion, sort_order, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)').run(id, workspaceId, data.title.trim(), 'pending', isAC, sortOrder, now, now);
+    const row = db.prepare('SELECT id, title, status, is_acceptance_criterion FROM tasks WHERE id = ?').get(id);
+    return rowToDto(row);
+}
+export function updateTaskHandler(db, workspaceId, taskId, data) {
+    // Verify task belongs to workspace
+    const existing = db.prepare('SELECT id FROM tasks WHERE id = ? AND workspace_id = ?').get(taskId, workspaceId);
+    if (!existing) {
+        throw new Error(`Task '${taskId}' not found in workspace '${workspaceId}'`);
+    }
+    const sets = [];
+    const values = [];
+    if (data.title !== undefined) {
+        if (!data.title.trim())
+            throw new Error('title cannot be empty');
+        sets.push('title = ?');
+        values.push(data.title.trim());
+    }
+    if (data.status !== undefined) {
+        if (!VALID_TASK_STATUSES.includes(data.status)) {
+            throw new Error(`Invalid status '${data.status}'. Must be one of: ${VALID_TASK_STATUSES.join(', ')}`);
+        }
+        sets.push('status = ?');
+        values.push(data.status);
+    }
+    if (data.is_acceptance_criterion !== undefined) {
+        sets.push('is_acceptance_criterion = ?');
+        values.push(data.is_acceptance_criterion ? 1 : 0);
+    }
+    if (sets.length === 0) {
+        throw new Error('No fields to update (provide title, status, or is_acceptance_criterion)');
+    }
+    sets.push('updated_at = ?');
+    values.push(new Date().toISOString());
+    values.push(taskId);
+    db.prepare(`UPDATE tasks SET ${sets.join(', ')} WHERE id = ?`).run(...values);
+    const row = db
+        .prepare('SELECT id, title, status, is_acceptance_criterion FROM tasks WHERE id = ?')
+        .get(taskId);
+    return rowToDto(row);
+}
+export function deleteTaskHandler(db, workspaceId, taskId) {
+    const result = db.prepare('DELETE FROM tasks WHERE id = ? AND workspace_id = ?').run(taskId, workspaceId);
+    if (result.changes === 0) {
+        throw new Error(`Task '${taskId}' not found in workspace '${workspaceId}'`);
+    }
+    return { success: true, task_id: taskId };
+}
+export function getDevServerStatusHandler(db, workspaceId) {
+    const row = db.prepare('SELECT dev_server_status FROM workspaces WHERE id = ?').get(workspaceId);
+    if (!row) {
+        throw new Error(`Workspace '${workspaceId}' not found`);
+    }
+    return { workspaceId, status: row.dev_server_status };
+}
+export function getSettingsHandler(settingsPath, projectPath) {
+    // Shape is determined solely by whether projectPath was provided:
+    //  - with projectPath → { global, project }
+    //  - without         → { global, projects }
+    // The `error` field is added on top when settings are unavailable.
+    if (!settingsPath || !fs.existsSync(settingsPath)) {
+        const base = projectPath ? { global: null, project: null } : { global: null, projects: [] };
+        return { ...base, error: 'Settings file not available' };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+    }
+    catch (err) {
+        throw new Error(`Failed to read settings: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const global = parsed.global ?? null;
+    const projects = Array.isArray(parsed.projects) ? parsed.projects : [];
+    if (projectPath) {
+        const project = projects.find((p) => p.path === projectPath) ?? null;
+        return { global, project };
+    }
+    return { global, projects };
+}
+export function getWorkspaceInfoHandler(db, workspaceId) {
+    const row = db
+        .prepare('SELECT id, name, project_path, source_branch, working_branch, status, notion_url, notion_page_id, model, dev_server_status, created_at, updated_at FROM workspaces WHERE id = ?')
+        .get(workspaceId);
+    if (!row) {
+        throw new Error(`Workspace '${workspaceId}' not found`);
+    }
+    return {
+        id: row.id,
+        name: row.name,
+        projectPath: row.project_path,
+        sourceBranch: row.source_branch,
+        workingBranch: row.working_branch,
+        worktreePath: path.join(row.project_path, '.worktrees', row.working_branch),
+        status: row.status,
+        model: row.model,
+        notionUrl: row.notion_url,
+        notionPageId: row.notion_page_id,
+        devServerStatus: row.dev_server_status,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+export function listWorkspaceImagesHandler(worktreePath) {
+    const imagesDir = path.join(worktreePath, '.ai', 'images');
+    const indexPath = path.join(imagesDir, 'index.json');
+    if (!fs.existsSync(indexPath))
+        return [];
+    let entries;
+    try {
+        entries = JSON.parse(fs.readFileSync(indexPath, 'utf-8'));
+    }
+    catch {
+        return [];
+    }
+    // Read directory once — imagesDir is guaranteed to exist because indexPath does
+    const files = fs.readdirSync(imagesDir);
+    return entries.map((e) => {
+        const match = files.find((f) => f.startsWith(`${e.uid}.`));
+        return {
+            uid: e.uid,
+            originalName: e.originalName,
+            relativePath: match ? path.join('.ai', 'images', match) : '',
+            createdAt: e.createdAt,
+        };
+    });
+}

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

@@ -3,9 +3,10 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import Database from 'better-sqlite3';
-import { listTasksHandler, markTaskDoneHandler } from './kobo-tasks-handlers.js';
+import { createTaskHandler, deleteTaskHandler, getDevServerStatusHandler, getSettingsHandler, getWorkspaceInfoHandler, listTasksHandler, listWorkspaceImagesHandler, markTaskDoneHandler, updateTaskHandler, } from './kobo-tasks-handlers.js';
 const workspaceId = process.env.KOBO_WORKSPACE_ID;
 const dbPath = process.env.KOBO_DB_PATH;
+const settingsPath = process.env.KOBO_SETTINGS_PATH;
 const backendUrl = process.env.KOBO_BACKEND_URL ?? 'http://localhost:3000';
 if (!workspaceId) {
     console.error('[kobo-tasks-server] KOBO_WORKSPACE_ID env var is required');
@@ -37,12 +38,36 @@ async function notifyBackend(taskId) {
         console.error('[kobo-tasks-server] notify-done failed:', err);
     }
 }
+async function notifyTasksUpdated() {
+    try {
+        const url = `${backendUrl}/api/workspaces/${workspaceId}/tasks/notify-updated`;
+        await fetch(url, { method: 'POST' });
+    }
+    catch (err) {
+        console.error('[kobo-tasks-server] notify-updated failed:', err);
+    }
+}
+async function backendRequest(method, pathname, body) {
+    const url = `${backendUrl}${pathname}`;
+    const init = { method };
+    if (body !== undefined) {
+        init.headers = { 'Content-Type': 'application/json' };
+        init.body = JSON.stringify(body);
+    }
+    const res = await fetch(url, init);
+    if (!res.ok) {
+        const errText = await res.text().catch(() => '');
+        throw new Error(`Backend ${method} ${pathname} returned ${res.status}: ${errText}`);
+    }
+    const text = await res.text();
+    return text ? JSON.parse(text) : null;
+}
 const server = new Server({ name: 'kobo-tasks', version: '1.0.0' }, { capabilities: { tools: {} } });
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: [
         {
             name: 'list_tasks',
-            description: 'List all tasks and acceptance criteria for the current workspace with their IDs and current status. Call this first to discover task IDs before calling mark_task_done.',
+            description: 'List all tasks and acceptance criteria for the current workspace with their IDs and current status. Call this first to discover task IDs before calling mark_task_done / update_task / delete_task.',
             inputSchema: {
                 type: 'object',
                 properties: {},
@@ -63,43 +88,225 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: ['task_id'],
             },
         },
+        {
+            name: 'create_task',
+            description: 'Create a new task or acceptance criterion for the current workspace. Appended at the end of the list.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    title: { type: 'string', description: 'Task title' },
+                    is_acceptance_criterion: {
+                        type: 'boolean',
+                        description: 'Whether this is an acceptance criterion (default: false)',
+                    },
+                },
+                required: ['title'],
+            },
+        },
+        {
+            name: 'update_task',
+            description: 'Update an existing task — change title, status, or is_acceptance_criterion flag. At least one field is required.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    task_id: { type: 'string', description: 'The ID of the task to update' },
+                    title: { type: 'string', description: 'New title (optional)' },
+                    status: {
+                        type: 'string',
+                        enum: ['pending', 'in_progress', 'done'],
+                        description: 'New status (optional)',
+                    },
+                    is_acceptance_criterion: {
+                        type: 'boolean',
+                        description: 'Toggle acceptance criterion flag (optional)',
+                    },
+                },
+                required: ['task_id'],
+            },
+        },
+        {
+            name: 'delete_task',
+            description: 'Delete a task from the current workspace permanently.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    task_id: { type: 'string', description: 'The ID of the task to delete' },
+                },
+                required: ['task_id'],
+            },
+        },
+        {
+            name: 'get_settings',
+            description: 'Read Kōbō settings (global + projects). Optionally filter to a specific project by path to get both global and that project override.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    project_path: {
+                        type: 'string',
+                        description: 'Optional project path to resolve a specific project entry',
+                    },
+                },
+                required: [],
+            },
+        },
+        {
+            name: 'get_dev_server_status',
+            description: 'Check whether the dev server is running for the current workspace.',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+                required: [],
+            },
+        },
+        {
+            name: 'get_workspace_info',
+            description: 'Get all metadata about the current workspace (name, project path, branches, model, notion URL, worktree path, status).',
+            inputSchema: { type: 'object', properties: {}, required: [] },
+        },
+        {
+            name: 'start_dev_server',
+            description: 'Start the dev server configured for the current workspace.',
+            inputSchema: { type: 'object', properties: {}, required: [] },
+        },
+        {
+            name: 'stop_dev_server',
+            description: 'Stop the dev server of the current workspace.',
+            inputSchema: { type: 'object', properties: {}, required: [] },
+        },
+        {
+            name: 'get_dev_server_logs',
+            description: 'Fetch the last N lines of the dev server logs for the current workspace.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    tail: {
+                        type: 'number',
+                        description: 'Number of lines to fetch from the end (default: 200)',
+                    },
+                },
+                required: [],
+            },
+        },
+        {
+            name: 'list_workspace_images',
+            description: 'List all images uploaded to the current workspace (from .ai/images/index.json). Returns uid, originalName, relativePath and createdAt for each image.',
+            inputSchema: { type: 'object', properties: {}, required: [] },
+        },
+        {
+            name: 'get_git_info',
+            description: 'Get git stats for the current workspace (commit count, files changed, insertions, deletions, PR URL if any).',
+            inputSchema: { type: 'object', properties: {}, required: [] },
+        },
+        {
+            name: 'set_workspace_status',
+            description: 'Update the current workspace status. Valid values: idle, completed, error. Transitions are validated by the backend.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    status: {
+                        type: 'string',
+                        description: 'New status (e.g. idle, completed)',
+                    },
+                },
+                required: ['status'],
+            },
+        },
     ],
 }));
+function ok(data) {
+    return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+}
+function fail(message) {
+    return { content: [{ type: 'text', text: `Error: ${message}` }], isError: true };
+}
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
-    if (name === 'list_tasks') {
-        const tasks = listTasksHandler(db, workspaceId);
-        return {
-            content: [{ type: 'text', text: JSON.stringify(tasks, null, 2) }],
-        };
-    }
-    if (name === 'mark_task_done') {
-        const taskId = args?.task_id;
-        if (!taskId) {
-            return {
-                content: [{ type: 'text', text: 'Error: task_id parameter is required' }],
-                isError: true,
-            };
+    const a = (args ?? {});
+    try {
+        if (name === 'list_tasks') {
+            return ok(listTasksHandler(db, workspaceId));
         }
-        try {
+        if (name === 'mark_task_done') {
+            const taskId = a.task_id;
+            if (!taskId)
+                return fail('task_id parameter is required');
             const result = markTaskDoneHandler(db, workspaceId, taskId);
             void notifyBackend(taskId);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-            };
+            return ok(result);
+        }
+        if (name === 'create_task') {
+            const title = a.title;
+            if (!title)
+                return fail('title parameter is required');
+            const task = createTaskHandler(db, workspaceId, {
+                title,
+                is_acceptance_criterion: a.is_acceptance_criterion,
+            });
+            void notifyTasksUpdated();
+            return ok(task);
         }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            return {
-                content: [{ type: 'text', text: `Error: ${message}` }],
-                isError: true,
-            };
+        if (name === 'update_task') {
+            const taskId = a.task_id;
+            if (!taskId)
+                return fail('task_id parameter is required');
+            const task = updateTaskHandler(db, workspaceId, taskId, {
+                title: a.title,
+                status: a.status,
+                is_acceptance_criterion: a.is_acceptance_criterion,
+            });
+            void notifyTasksUpdated();
+            return ok(task);
         }
+        if (name === 'delete_task') {
+            const taskId = a.task_id;
+            if (!taskId)
+                return fail('task_id parameter is required');
+            const result = deleteTaskHandler(db, workspaceId, taskId);
+            void notifyTasksUpdated();
+            return ok(result);
+        }
+        if (name === 'get_settings') {
+            return ok(getSettingsHandler(settingsPath, a.project_path));
+        }
+        if (name === 'get_dev_server_status') {
+            return ok(getDevServerStatusHandler(db, workspaceId));
+        }
+        if (name === 'get_workspace_info') {
+            return ok(getWorkspaceInfoHandler(db, workspaceId));
+        }
+        if (name === 'start_dev_server') {
+            const result = await backendRequest('POST', `/api/dev-server/${workspaceId}/start`);
+            return ok(result);
+        }
+        if (name === 'stop_dev_server') {
+            const result = await backendRequest('POST', `/api/dev-server/${workspaceId}/stop`);
+            return ok(result);
+        }
+        if (name === 'get_dev_server_logs') {
+            const tail = a.tail ?? 200;
+            const result = await backendRequest('GET', `/api/dev-server/${workspaceId}/logs?tail=${tail}`);
+            return ok(result);
+        }
+        if (name === 'list_workspace_images') {
+            const info = getWorkspaceInfoHandler(db, workspaceId);
+            return ok(listWorkspaceImagesHandler(info.worktreePath));
+        }
+        if (name === 'get_git_info') {
+            const result = await backendRequest('GET', `/api/workspaces/${workspaceId}/git-stats`);
+            return ok(result);
+        }
+        if (name === 'set_workspace_status') {
+            const status = a.status;
+            if (!status)
+                return fail('status parameter is required');
+            const result = await backendRequest('PATCH', `/api/workspaces/${workspaceId}`, { status });
+            return ok(result);
+        }
+        return fail(`Unknown tool: ${name}`);
+    }
+    catch (err) {
+        return fail(err instanceof Error ? err.message : String(err));
     }
-    return {
-        content: [{ type: 'text', text: `Unknown tool: ${name}` }],
-        isError: true,
-    };
 });
 const transport = new StdioServerTransport();
 server.connect(transport).catch((err) => {

package/dist/server/index.js

@@ -9,10 +9,11 @@ import { getDb } from './db/index.js';
 import { runMigrations } from './db/migrations.js';
 import devServerRouter from './routes/dev-server.js';
 import gitRouter from './routes/git.js';
+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, startAgent, stopAgent } from './services/agent-manager.js';
+import { getAvailableSkills, sendMessage, setBackendPort, startAgent, stopAgent } from './services/agent-manager.js';
 import { startDevServer, stopDevServer } from './services/dev-server-service.js';
 import { emit, handleConnection, setMessageHandler } from './services/websocket-service.js';
 import { getLatestSession, getWorkspace, updateWorkspaceStatus } from './services/workspace-service.js';
@@ -39,6 +40,7 @@ const app = new Hono();
 app.get('/api/health', (c) => c.json({ status: 'ok', version: '0.1.0' }));
 // 4. Mount route sub-routers
 app.route('/api/workspaces', workspacesRouter);
+app.route('/api/workspaces', imagesRouter);
 app.route('/api/notion', notionRouter);
 app.route('/api/git', gitRouter);
 app.route('/api/settings', settingsRouter);
@@ -91,6 +93,7 @@ const server = serve({
     fetch: app.fetch,
     port: PORT,
 }, (info) => {
+    setBackendPort(info.port);
     console.log(`Server running at http://localhost:${info.port}`);
 });
 // 6. Create WebSocketServer attached to the HTTP server

package/dist/server/routes/images.js

@@ -0,0 +1,57 @@
+import { Hono } from 'hono';
+import * as imageService from '../services/image-service.js';
+import * as workspaceService from '../services/workspace-service.js';
+const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10 MB
+const ALLOWED_MIME_TYPES = new Set(['image/png', 'image/jpeg', 'image/gif', 'image/webp']);
+const app = new Hono();
+// POST /:id/images — upload an image
+app.post('/:id/images', async (c) => {
+    try {
+        const { id } = c.req.param();
+        const workspace = workspaceService.getWorkspace(id);
+        if (!workspace) {
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        }
+        const body = await c.req.parseBody();
+        const file = body.image;
+        if (!file || !(file instanceof File)) {
+            return c.json({ error: 'Missing image field in multipart body' }, 400);
+        }
+        if (!ALLOWED_MIME_TYPES.has(file.type)) {
+            return c.json({ error: `Unsupported MIME type: '${file.type}'. Allowed: ${[...ALLOWED_MIME_TYPES].join(', ')}` }, 400);
+        }
+        const arrayBuffer = await file.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        if (buffer.length > MAX_FILE_SIZE) {
+            return c.json({ error: `File too large (${(buffer.length / 1024 / 1024).toFixed(1)} MB). Max: 10 MB` }, 400);
+        }
+        const worktreePath = `${workspace.projectPath}/.worktrees/${workspace.workingBranch}`;
+        const result = await imageService.saveImage(worktreePath, buffer, file.name);
+        return c.json({ uid: result.uid, path: result.relativePath }, 201);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
+// DELETE /:id/images/:uid — delete an uploaded image
+app.delete('/:id/images/:uid', async (c) => {
+    try {
+        const { id, uid } = c.req.param();
+        const workspace = workspaceService.getWorkspace(id);
+        if (!workspace) {
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        }
+        const worktreePath = `${workspace.projectPath}/.worktrees/${workspace.workingBranch}`;
+        await imageService.deleteImage(worktreePath, uid);
+        return c.body(null, 204);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.includes('not found')) {
+            return c.json({ error: message }, 404);
+        }
+        return c.json({ error: message }, 500);
+    }
+});
+export default app;

package/dist/server/routes/workspaces.js

@@ -363,6 +363,22 @@ 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) => {
+    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);
+    }
+});
 // GET /api/workspaces/archived — list archived workspaces (must be before GET /:id)
 app.get('/archived', (c) => {
     try {
@@ -388,19 +404,25 @@ app.get('/:id', (c) => {
         return c.json({ error: message }, 500);
     }
 });
-// PATCH /api/workspaces/:id — update workspace status
+// PATCH /api/workspaces/:id — update workspace fields (status, model)
 app.patch('/:id', async (c) => {
     try {
         const id = c.req.param('id');
         const body = await c.req.json();
-        if (!body.status) {
-            return c.json({ error: 'Missing required field: status' }, 400);
-        }
         const workspace = workspaceService.getWorkspace(id);
         if (!workspace) {
             return c.json({ error: `Workspace '${id}' not found` }, 404);
         }
-        const updated = workspaceService.updateWorkspaceStatus(id, body.status);
+        let updated = workspace;
+        if (body.model !== undefined) {
+            updated = workspaceService.updateWorkspaceModel(id, body.model);
+        }
+        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);
+        }
         return c.json(updated);
     }
     catch (err) {
@@ -564,11 +586,13 @@ app.get('/:id/git-stats', async (c) => {
         const worktreePath = path.default.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);
         return c.json({
             commitCount,
             filesChanged: diffStats.filesChanged,
             insertions: diffStats.insertions,
             deletions: diffStats.deletions,
+            prUrl,
         });
     }
     catch (err) {

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

@@ -4,11 +4,17 @@ import path from 'node:path';
 import readline from 'node:readline';
 import { nanoid } from 'nanoid';
 import { getDb } from '../db/index.js';
-import { ensureKoboHome, getCompiledMcpServerPath, getDbPath, getMcpServerSourcePath, getSkillsPath, } from '../utils/paths.js';
+import { ensureKoboHome, getCompiledMcpServerPath, getDbPath, getMcpServerSourcePath, getSettingsPath, getSkillsPath, } from '../utils/paths.js';
 import { registerProcess, unregisterProcess } from '../utils/process-tracker.js';
 import { emit } from './websocket-service.js';
 import { getWorkspace as getWs, listTasks, updateWorkspaceStatus } from './workspace-service.js';
 // ── State ──────────────────────────────────────────────────────────────────────
+/** Actual bound port of the running backend — set at startup via setBackendPort() */
+let backendPort = process.env.PORT ? parseInt(process.env.PORT, 10) : 3000;
+/** Called from index.ts once the HTTP server is listening so MCP children can reach it. */
+export function setBackendPort(port) {
+    backendPort = port;
+}
 /** workspaceId -> agent instance */
 const agents = new Map();
 /** workspaceId -> last Claude session ID (for --resume) */
@@ -37,6 +43,7 @@ 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'];
     if (model && model !== 'auto') {
@@ -48,6 +55,7 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
             .get(workspaceId);
         const claudeSessionId = sessionIds.get(workspaceId) ?? lastSession?.claude_session_id;
         if (claudeSessionId) {
+            resumedClaudeSessionId = claudeSessionId;
             args.push('--resume', claudeSessionId, '-p', prompt);
             // Always reuse existing session — find by claude_session_id if lastSession didn't match
             const existingId = lastSession?.id ??
@@ -86,7 +94,8 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
                     env: {
                         KOBO_WORKSPACE_ID: workspaceId,
                         KOBO_DB_PATH: getDbPath(),
-                        KOBO_BACKEND_URL: `http://localhost:${process.env.PORT ?? '3000'}`,
+                        KOBO_SETTINGS_PATH: getSettingsPath(),
+                        KOBO_BACKEND_URL: `http://127.0.0.1:${backendPort}`,
                     },
                 },
             },
@@ -117,6 +126,7 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
         rl,
         status: 'running',
         agentSessionId,
+        claudeSessionId: resumedClaudeSessionId,
     };
     // ── stdout line-by-line (NDJSON) ──
     rl.on('line', (line) => {
@@ -287,6 +297,8 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
     });
     // Store in agents map
     agents.set(workspaceId, agent);
+    // Notify frontend that agent is now running
+    emit(workspaceId, 'agent:status', { status: 'executing' }, agent.claudeSessionId);
     return agent;
 }
 // ── Stop agent ─────────────────────────────────────────────────────────────────