@loicngr/kobo 1.6.11 → 1.6.13

package/dist/server/services/auto-loop-service.js

@@ -1,14 +1,16 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { buildE2eIterationBlock } from '../../shared/auto-loop-prompts.js';
 import { getDb } from '../db/index.js';
 import * as orchestrator from './agent/orchestrator.js';
+import * as settingsService from './settings-service.js';
 import { emit, emitEphemeral } from './websocket-service.js';
 import { listTasks } from './workspace-service.js';
 const NO_PROGRESS_STALL_THRESHOLD = 3;
 function getRow(workspaceId) {
     const db = getDb();
     const row = db
-        .prepare(`SELECT id, project_path, working_branch, model, permission_mode, reasoning_effort,
+        .prepare(`SELECT id, project_path, working_branch, worktree_path, model, permission_mode, reasoning_effort,
               status, auto_loop, auto_loop_ready, no_progress_streak, archived_at
        FROM workspaces WHERE id = ?`)
         .get(workspaceId);
@@ -137,6 +139,13 @@ export function rehydrate() {
             try {
                 if (orchestrator.hasController(id))
                     continue;
+                // Workspaces still in grooming (ready=0) have their session killed by
+                // the server reload. Don't disable — the user can re-trigger grooming
+                // manually. Auto-disable on missing pending tasks would also fire here
+                // if the agent hadn't yet seeded any task before the reload.
+                const row = getRow(id);
+                if (row?.auto_loop_ready !== 1)
+                    continue;
                 if (countPendingTasks(id) === 0) {
                     disable(id, 'completed');
                     continue;
@@ -163,7 +172,7 @@ Current pending task (highest priority, non-acceptance-criterion first):
 - Task ID: {taskId}
 - Title: {taskTitle}
 - Is acceptance criterion: {isAcceptanceCriterion}
-
+{e2eBlock}
 Your job this iteration:
 1. Read \`kobo__list_tasks\` to see all tasks and the big picture.
 2. Implement the SINGLE task above and nothing else. Do not pick a different task.
@@ -216,11 +225,20 @@ function spawnNextIteration(workspaceId, opts = {}) {
         return;
     }
     const iterationNumber = computeIterationNumber(workspaceId);
+    // E2E iteration block: only injected for tasks whose title starts with the
+    // exact `[E2E] ` prefix (case-sensitive, trailing space required) AND when
+    // the project has an E2E framework configured. Empty string otherwise so
+    // the placeholder collapses cleanly in PROMPT_TEMPLATE.
+    const projectSettings = settingsService.getProjectSettings(row.project_path);
+    const e2eSettings = projectSettings?.e2e ?? { framework: '', skill: '', prompt: '' };
+    const isE2eTask = task.title.startsWith('[E2E] ');
+    const e2eBlock = isE2eTask && e2eSettings.framework ? buildE2eIterationBlock(e2eSettings) : '';
     const prompt = PROMPT_TEMPLATE.replaceAll('{n}', String(iterationNumber))
         .replaceAll('{taskId}', task.id)
         .replaceAll('{taskTitle}', task.title)
-        .replaceAll('{isAcceptanceCriterion}', String(task.isAcceptanceCriterion));
-    const worktreePath = path.join(row.project_path, '.worktrees', row.working_branch);
+        .replaceAll('{isAcceptanceCriterion}', String(task.isAcceptanceCriterion))
+        .replaceAll('{e2eBlock}', e2eBlock);
+    const worktreePath = row.worktree_path ?? path.join(row.project_path, '.worktrees', row.working_branch);
     // Auto-loop iterations always run in auto-accept mode. Plan mode blocks MCP
     // tools (kobo__mark_task_done, etc.) and Edit/Write/Bash — everything the
     // iteration needs — so honoring a 'plan' setting here would deadlock the loop.

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

@@ -5,9 +5,6 @@ import { getProjectSettings } from './settings-service.js';
 import { emitEphemeral } from './websocket-service.js';
 import { getWorkspace, updateDevServerStatus } from './workspace-service.js';
 // ── Helpers ───────────────────────────────────────────────────────────────────
-function getWorktreePath(projectPath, workingBranch) {
-    return path.join(projectPath, '.worktrees', workingBranch);
-}
 /** Build a clean env for child processes, stripping Kobo-specific variables. */
 function cleanEnv() {
     const { PORT, SERVER_PORT, ...rest } = process.env;
@@ -166,7 +163,7 @@ export function startDevServer(workspaceId) {
     }
     const instanceName = sanitizeBranchName(workspace.workingBranch);
     // Execute as bash script (supports multi-line scripts)
-    const worktreePath = getWorktreePath(workspace.projectPath, workspace.workingBranch);
+    const worktreePath = workspace.worktreePath;
     const cwd = existsSync(worktreePath) ? worktreePath : workspace.projectPath;
     const proc = spawn('bash', ['-c', settings.devServer.startCommand], {
         cwd,
@@ -232,7 +229,7 @@ export function stopDevServer(workspaceId) {
     }
     const config = resolveInstance(workspace.projectPath, workspace.workingBranch);
     const instanceName = config?.instanceName ?? sanitizeBranchName(workspace.workingBranch);
-    const worktreePath = getWorktreePath(workspace.projectPath, workspace.workingBranch);
+    const worktreePath = workspace.worktreePath;
     const cwd = existsSync(worktreePath) ? worktreePath : workspace.projectPath;
     // Kill tracked process first (covers Node servers and any spawned process)
     const tracked = trackedProcesses.get(workspaceId);

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

@@ -6,14 +6,28 @@ const GHERKIN_PATTERN = /^(Scénario|Étant donné|Quand|Alors|Scenario|Given|Wh
 // NOTE: `Feature`/`Fonctionnalité` are top-level containers, not a new scenario,
 // so they stay attached to the first scenario rather than triggering a split.
 const SCENARIO_START_PATTERN = /^(Scénario|Scenario)/i;
+function formatAsUuid(raw32Hex) {
+    return `${raw32Hex.slice(0, 8)}-${raw32Hex.slice(8, 12)}-${raw32Hex.slice(12, 16)}-${raw32Hex.slice(16, 20)}-${raw32Hex.slice(20)}`;
+}
 /**
  * Parse a Notion URL and extract the page_id in UUID format (with dashes).
  * Handles:
  *   https://www.notion.so/workspace/Title-<32hexChars>
  *   https://www.notion.so/workspace/<32hexChars>
  *   https://www.notion.so/<32hexChars>
+ *   https://www.notion.so/workspace/<parentId>?p=<32hexChars>&pm=s   (side-peek)
+ *   https://www.notion.so/workspace/<dbId>?v=<viewId>&p=<32hexChars>  (database peek)
+ *
+ * When the URL embeds `?p=<32hex>` the path component is the parent / database
+ * ID and the actual page being viewed is in the query parameter — that takes
+ * precedence over the path.
  */
 export function parseNotionUrl(url) {
+    // Side-peek / database pages embed the real page ID in `?p=<32hex>`.
+    const pParamMatch = url.match(/[?&]p=([0-9a-f]{32})(?:[&#]|$)/i);
+    if (pParamMatch) {
+        return formatAsUuid(pParamMatch[1]);
+    }
     // Strip query string and fragment
     const cleanUrl = url.split('?')[0].split('#')[0];
     // The page ID is always the last 32 hex characters (no dashes) at the end of the path
@@ -26,9 +40,7 @@ export function parseNotionUrl(url) {
         }
         throw new Error(`Could not extract page ID from Notion URL: ${url}`);
     }
-    const raw = match[1];
-    // Convert 32 hex chars to UUID format: 8-4-4-4-12
-    return `${raw.slice(0, 8)}-${raw.slice(8, 12)}-${raw.slice(12, 16)}-${raw.slice(16, 20)}-${raw.slice(20)}`;
+    return formatAsUuid(match[1]);
 }
 /**
  * Read the Notion token from the user's Claude Code config as a fallback.

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

@@ -228,6 +228,11 @@ function defaultProjectSettings(projectPath) {
             startCommand: '',
             stopCommand: '',
         },
+        e2e: {
+            framework: '',
+            skill: '',
+            prompt: '',
+        },
     };
 }
 function pickKnownKeys(data, allowedKeys) {
@@ -434,7 +439,7 @@ export function updateGlobalSettings(data) {
     writeSettings(settings, { backup: true });
     return settings.global;
 }
-/** Create or update project-specific settings. Merges devServer fields on update. */
+/** Create or update project-specific settings. Merges devServer and e2e fields on update. */
 export function upsertProject(projectPath, data) {
     const allowedProjectKeys = [
         'displayName',
@@ -445,23 +450,31 @@ export function upsertProject(projectPath, data) {
         'gitConventions',
         'setupScript',
         'devServer',
+        'e2e',
     ];
     const allowedDevServerKeys = ['startCommand', 'stopCommand'];
+    const allowedE2eKeys = ['framework', 'skill', 'prompt'];
     const filtered = pickKnownKeys(data, allowedProjectKeys);
     if (filtered.devServer) {
         filtered.devServer = pickKnownKeys(filtered.devServer, allowedDevServerKeys);
     }
+    if (filtered.e2e) {
+        filtered.e2e = pickKnownKeys(filtered.e2e, allowedE2eKeys);
+    }
     const settings = readSettings();
     const idx = settings.projects.findIndex((p) => p.path === projectPath);
     if (idx >= 0) {
-        // Update existing project — merge devServer separately to allow partial updates
+        // Update existing project — merge devServer and e2e separately to allow partial updates
         const existing = settings.projects[idx];
         const updatedDevServer = filtered.devServer ? { ...existing.devServer, ...filtered.devServer } : existing.devServer;
+        const existingE2e = existing.e2e ?? defaultProjectSettings(projectPath).e2e;
+        const updatedE2e = filtered.e2e ? { ...existingE2e, ...filtered.e2e } : existingE2e;
         settings.projects[idx] = {
             ...existing,
             ...filtered,
             path: projectPath,
             devServer: updatedDevServer,
+            e2e: updatedE2e,
         };
     }
     else {
@@ -474,6 +487,9 @@ export function upsertProject(projectPath, data) {
         if (filtered.devServer) {
             newProject.devServer = { ...defaultProjectSettings(projectPath).devServer, ...filtered.devServer };
         }
+        if (filtered.e2e) {
+            newProject.e2e = { ...defaultProjectSettings(projectPath).e2e, ...filtered.e2e };
+        }
         settings.projects.push(newProject);
     }
     writeSettings(settings, { backup: true });

package/dist/server/services/usage/db.js

@@ -0,0 +1,29 @@
+import { getDb } from '../../db/index.js';
+function rowToSnapshot(row) {
+    const buckets = JSON.parse(row.buckets_json);
+    const snap = {
+        providerId: row.provider_id,
+        status: row.status,
+        buckets,
+        fetchedAt: row.fetched_at,
+    };
+    if (row.error_message !== null) {
+        snap.errorMessage = row.error_message;
+    }
+    return snap;
+}
+export function upsertUsageSnapshot(snap) {
+    const db = getDb();
+    db.prepare(`INSERT INTO usage_snapshots (provider_id, status, error_message, buckets_json, fetched_at)
+     VALUES (?, ?, ?, ?, ?)
+     ON CONFLICT(provider_id) DO UPDATE SET
+       status        = excluded.status,
+       error_message = excluded.error_message,
+       buckets_json  = excluded.buckets_json,
+       fetched_at    = excluded.fetched_at`).run(snap.providerId, snap.status, snap.errorMessage ?? null, JSON.stringify(snap.buckets), snap.fetchedAt);
+}
+export function getAllPersistedSnapshots() {
+    const db = getDb();
+    const rows = db.prepare('SELECT * FROM usage_snapshots ORDER BY provider_id').all();
+    return rows.map(rowToSnapshot);
+}

package/dist/server/services/usage/index.js

@@ -0,0 +1,2 @@
+export { getAllPersistedSnapshots } from './db.js';
+export { refreshNow, startUsagePoller, stopUsagePoller } from './poller.js';

package/dist/server/services/usage/poller.js

@@ -0,0 +1,52 @@
+import { broadcastAll } from '../websocket-service.js';
+import { upsertUsageSnapshot } from './db.js';
+import { createClaudeCodeProvider } from './providers/claude-code.js';
+export const POLL_INTERVAL_MS = 60_000;
+const DEFAULT_PROVIDERS = [createClaudeCodeProvider()];
+let providers = DEFAULT_PROVIDERS;
+let intervalHandle = null;
+function persistAndBroadcast(snap) {
+    upsertUsageSnapshot(snap);
+    broadcastAll('usage:snapshot', { providerId: snap.providerId, snapshot: snap });
+}
+async function tick() {
+    for (const provider of providers) {
+        try {
+            if (!(await provider.isAvailable()))
+                continue;
+            const snap = await provider.fetchSnapshot();
+            persistAndBroadcast(snap);
+        }
+        catch (err) {
+            console.error('[usage-poller] tick failed for provider', provider.id, err);
+        }
+    }
+}
+export function startUsagePoller() {
+    if (intervalHandle !== null)
+        return;
+    void tick();
+    intervalHandle = setInterval(() => {
+        void tick();
+    }, POLL_INTERVAL_MS);
+}
+export function stopUsagePoller() {
+    if (intervalHandle === null)
+        return;
+    clearInterval(intervalHandle);
+    intervalHandle = null;
+}
+// Bypasses `isAvailable()` — a manual refresh always returns a snapshot,
+// even an `unauthenticated` one, so the UI gets feedback on the click.
+export async function refreshNow(providerId) {
+    const provider = providers.find((p) => p.id === providerId);
+    if (!provider)
+        return null;
+    const snap = await provider.fetchSnapshot();
+    persistAndBroadcast(snap);
+    return snap;
+}
+// Test seam — pass `null` to restore the default provider list.
+export function _setProvidersForTest(list) {
+    providers = list ?? DEFAULT_PROVIDERS;
+}

package/dist/server/services/usage/providers/claude-code.js

@@ -0,0 +1,93 @@
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+const API_URL = 'https://api.anthropic.com/api/oauth/usage';
+const BETA_HEADER = 'oauth-2025-04-20';
+const FETCH_TIMEOUT_MS = 10_000;
+function credentialsFilePath() {
+    const dir = process.env.CLAUDE_CONFIG_DIR ?? path.join(os.homedir(), '.claude');
+    return path.join(dir, '.credentials.json');
+}
+async function readAccessToken() {
+    try {
+        const raw = await fs.readFile(credentialsFilePath(), 'utf8');
+        const parsed = JSON.parse(raw);
+        const token = parsed?.claudeAiOauth?.accessToken;
+        return typeof token === 'string' && token.length > 0 ? token : null;
+    }
+    catch {
+        return null;
+    }
+}
+function mapBucket(id, raw) {
+    const utilization = typeof raw?.utilization === 'number' ? raw.utilization : 0;
+    const resetsAt = typeof raw?.resets_at === 'string' ? raw.resets_at : undefined;
+    return {
+        id,
+        label: id,
+        usedPct: utilization,
+        resetsAt,
+    };
+}
+export function createClaudeCodeProvider() {
+    return {
+        id: 'claude-code',
+        displayName: 'Claude Code',
+        async isAvailable() {
+            return (await readAccessToken()) !== null;
+        },
+        async fetchSnapshot() {
+            const fetchedAt = new Date().toISOString();
+            const token = await readAccessToken();
+            if (!token) {
+                return {
+                    providerId: 'claude-code',
+                    status: 'unauthenticated',
+                    buckets: [],
+                    fetchedAt,
+                };
+            }
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+            try {
+                const res = await fetch(API_URL, {
+                    headers: {
+                        Authorization: `Bearer ${token}`,
+                        'anthropic-beta': BETA_HEADER,
+                    },
+                    signal: controller.signal,
+                });
+                if (!res.ok) {
+                    return {
+                        providerId: 'claude-code',
+                        status: 'error',
+                        errorMessage: `HTTP ${res.status}`,
+                        buckets: [],
+                        fetchedAt,
+                    };
+                }
+                const body = (await res.json());
+                const buckets = [mapBucket('five_hour', body.five_hour), mapBucket('seven_day', body.seven_day)];
+                return {
+                    providerId: 'claude-code',
+                    status: 'ok',
+                    buckets,
+                    fetchedAt,
+                };
+            }
+            catch (err) {
+                const errorMessage = err instanceof Error ? err.message : String(err);
+                return {
+                    providerId: 'claude-code',
+                    status: 'error',
+                    errorMessage,
+                    buckets: [],
+                    fetchedAt,
+                };
+            }
+            finally {
+                clearTimeout(timeout);
+            }
+        },
+    };
+}

package/dist/server/services/usage/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -125,14 +125,14 @@ function fire(workspaceId) {
             return;
         }
         const wsRow = db
-            .prepare(`SELECT project_path, working_branch, model, permission_mode, reasoning_effort
+            .prepare(`SELECT project_path, working_branch, worktree_path, model, permission_mode, reasoning_effort
            FROM workspaces WHERE id = ?`)
             .get(workspaceId);
         if (!wsRow) {
             emitEphemeral(workspaceId, 'wakeup:skipped', { reason: 'fire-failed' });
             return;
         }
-        const worktreePath = path.join(wsRow.project_path, '.worktrees', wsRow.working_branch);
+        const worktreePath = wsRow.worktree_path ?? path.join(wsRow.project_path, '.worktrees', wsRow.working_branch);
         // Defensive: narrow `permission_mode` against the two known values rather
         // than trusting the DB column shape. Any unexpected value falls back to
         // the safer 'auto-accept'.

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

@@ -1,5 +1,6 @@
 import { nanoid } from 'nanoid';
 import { getDb } from '../db/index.js';
+import { getAllPersistedSnapshots } from './usage/db.js';
 // ── State ──────────────────────────────────────────────────────────────────────
 /** Maps each WS client to the set of workspaceIds they are subscribed to */
 const clients = new Map();
@@ -13,6 +14,19 @@ export function setMessageHandler(handler) {
 export function handleConnection(ws) {
     // Register client with empty subscription set
     clients.set(ws, new Set());
+    // Push the latest persisted snapshot per provider so the client renders
+    // immediately instead of waiting up to POLL_INTERVAL_MS for the next tick.
+    try {
+        for (const snap of getAllPersistedSnapshots()) {
+            ws.send(JSON.stringify({
+                type: 'usage:snapshot',
+                payload: { providerId: snap.providerId, snapshot: snap },
+            }));
+        }
+    }
+    catch (err) {
+        console.error('[ws] usage hydration failed:', err);
+    }
     ws.on('message', (data) => {
         let msg;
         try {

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

@@ -29,6 +29,7 @@ function mapWorkspace(row) {
         status: row.status,
         notionUrl: row.notion_url,
         notionPageId: row.notion_page_id,
+        sentryUrl: row.sentry_url,
         model: row.model,
         reasoningEffort: row.reasoning_effort ?? 'auto',
         permissionMode: (row.permission_mode ?? 'auto-accept'),
@@ -42,6 +43,8 @@ function mapWorkspace(row) {
         autoLoopReady: row.auto_loop_ready === 1,
         noProgressStreak: row.no_progress_streak ?? 0,
         permissionProfile: (row.permission_profile ?? 'bypass'),
+        worktreePath: row.worktree_path ?? '',
+        worktreeOwned: row.worktree_owned === 1,
         createdAt: row.created_at,
         updatedAt: row.updated_at,
     };
@@ -77,10 +80,15 @@ export function createWorkspace(data) {
     const db = getDb();
     const now = new Date().toISOString();
     const id = nanoid();
+    const computedWorktreePath = data.worktreePath ?? `${data.projectPath}/.worktrees/${data.workingBranch}`;
+    const owned = data.worktreeOwned ?? true;
     db.prepare(`
-    INSERT INTO workspaces (id, name, project_path, source_branch, working_branch, status, notion_url, notion_page_id, model, reasoning_effort, permission_mode, engine, created_at, updated_at)
-    VALUES (?, ?, ?, ?, ?, 'created', ?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(id, data.name, data.projectPath, data.sourceBranch, data.workingBranch, data.notionUrl ?? null, data.notionPageId ?? null, data.model ?? 'claude-opus-4-7', data.reasoningEffort ?? 'auto', data.permissionMode ?? 'auto-accept', data.engine ?? 'claude-code', now, now);
+    INSERT INTO workspaces (
+      id, name, project_path, source_branch, working_branch, status,
+      notion_url, notion_page_id, sentry_url, worktree_path, worktree_owned,
+      model, reasoning_effort, permission_mode, engine, created_at, updated_at
+    ) VALUES (?, ?, ?, ?, ?, 'created', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(id, data.name, data.projectPath, data.sourceBranch, data.workingBranch, data.notionUrl ?? null, data.notionPageId ?? null, data.sentryUrl ?? null, computedWorktreePath, owned ? 1 : 0, data.model ?? 'claude-opus-4-7', data.reasoningEffort ?? 'auto', data.permissionMode ?? 'auto-accept', data.engine ?? 'claude-code', now, now);
     return getWorkspace(id);
 }
 /** Fetch a single workspace by ID, or null if not found. */
@@ -113,6 +121,12 @@ export function updateWorkspaceStatus(id, status) {
     if (!workspace) {
         throw new Error(`Workspace '${id}' not found`);
     }
+    // Self-transition is a no-op. Some failure paths fan out (e.g. engine emits
+    // an error event AND the process exits non-zero), and both try to mark the
+    // workspace 'error' — the second call shouldn't throw.
+    if (workspace.status === status) {
+        return workspace;
+    }
     const allowedTransitions = VALID_TRANSITIONS[workspace.status];
     if (!allowedTransitions.includes(status)) {
         throw new Error(`Invalid status transition from '${workspace.status}' to '${status}'. Allowed: ${allowedTransitions.join(', ')}`);
@@ -186,6 +200,18 @@ export function updateWorkingBranch(id, workingBranch) {
     }
     return getWorkspace(id);
 }
+/** Update the on-disk worktree path. Used by rename / resync-branch on owned worktrees. */
+export function updateWorktreePath(id, newPath) {
+    const db = getDb();
+    const now = new Date().toISOString();
+    const result = db
+        .prepare('UPDATE workspaces SET worktree_path = ?, updated_at = ? WHERE id = ?')
+        .run(newPath, now, id);
+    if (result.changes === 0) {
+        throw new Error(`Workspace '${id}' not found`);
+    }
+    return getWorkspace(id);
+}
 /** Update the agent's permission mode (auto-accept vs plan/read-only). */
 export function updateWorkspacePermissionMode(id, permissionMode) {
     const db = getDb();

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

@@ -118,3 +118,53 @@ export function worktreeExists(projectPath, branchName) {
         return false;
     }
 }
+function canonicalize(p) {
+    try {
+        return fs.realpathSync(p);
+    }
+    catch {
+        return p;
+    }
+}
+function detectSourceBranch(projectPath, worktreePath, branch) {
+    // 1. Branch's tracked upstream (configured locally)
+    try {
+        const upstream = git(worktreePath, ['config', '--get', `branch.${branch}.merge`]);
+        if (upstream)
+            return upstream.replace(/^refs\/heads\//, '');
+    }
+    catch {
+        /* no upstream configured */
+    }
+    // 2. Repo's default branch (origin/HEAD)
+    try {
+        const head = git(projectPath, ['symbolic-ref', 'refs/remotes/origin/HEAD']);
+        if (head)
+            return head.replace(/^refs\/remotes\/origin\//, '');
+    }
+    catch {
+        /* no origin/HEAD */
+    }
+    // 3. Final fallback
+    return 'main';
+}
+/**
+ * List worktrees of a project that are NOT yet attached to a Kōbō workspace.
+ * The main worktree is excluded. Detached HEAD worktrees are excluded (no
+ * branch to anchor a workspace to). Both sides of the path comparison are
+ * canonicalized to defeat symlinks / trailing-slash variants.
+ */
+export function listOrphanWorktrees(projectPath, attachedPaths) {
+    const canonAttached = new Set(Array.from(attachedPaths).map(canonicalize));
+    const canonProject = canonicalize(projectPath);
+    return listWorktrees(projectPath)
+        .filter((wt) => canonicalize(wt.path) !== canonProject)
+        .filter((wt) => !!wt.branch && wt.branch !== '(detached HEAD)')
+        .filter((wt) => !canonAttached.has(canonicalize(wt.path)))
+        .map((wt) => ({
+        path: wt.path,
+        branch: wt.branch,
+        head: wt.head,
+        suggestedSourceBranch: detectSourceBranch(projectPath, wt.path, wt.branch),
+    }));
+}

package/dist/server/utils/mcp-client.js

@@ -59,6 +59,13 @@ export function spawnMcpProcess(command, args, env) {
         stdio: ['pipe', 'pipe', 'pipe'],
         env,
     });
+    // Defensive default 'error' listener: a ChildProcess that emits 'error'
+    // without any listener crashes the whole Node process (Unhandled 'error').
+    // Callers may attach their own listener for typed handling — listeners are
+    // additive on EventEmitter so this default never blocks them.
+    mcpProcess.on('error', (err) => {
+        console.error(`[mcp] spawn '${command}' failed: ${err.message}`);
+    });
     mcpProcess.stderr?.on('data', (data) => {
         if (process.env.DEBUG_MCP_STDERR) {
             console.error('[mcp stderr]', data.toString());

package/dist/shared/auto-loop-prompts.js

@@ -6,21 +6,59 @@
  * injected at workspace creation when autoLoop=true). Keeping these two
  * paths aligned was a copy-paste hazard — this file eliminates that.
  *
- * `AUTO_LOOP_GROOMING_STEPS` is the numbered workflow, ready to be spliced
- * into a larger prompt with a one-line intro.
+ * `buildAutoLoopGroomingSteps(e2e)` is the numbered workflow, ready to be
+ * spliced into a larger prompt with a one-line intro. When `e2e.framework`
+ * is set, an additional step 4 covers E2E regression coverage and the
+ * `kobo__mark_auto_loop_ready` call moves to step 5.
+ *
+ * `buildE2eIterationBlock(e2e)` returns the override block injected into
+ * the per-iteration prompt for tasks whose title starts with `[E2E]`.
  *
  * `AUTO_LOOP_HARD_RULES` is the trailing hard-rules block, same for both.
  */
-export const AUTO_LOOP_GROOMING_STEPS = `1. Call \`kobo__list_tasks\` FIRST to inspect any pre-existing tasks (they may have been seeded from Notion, a template, or the CreatePage form).
-2. If tasks already exist: DO NOT delete or recreate them from scratch. Read each one, judge whether it is atomic and implementable in one session with clear completion criteria. Improve them in place:
+export const PREP_AUTOLOOP_INTRO = `You are preparing this workspace for Kōbō auto-loop mode. This is a GROOMING session only — DO NOT implement anything, DO NOT write or edit code, DO NOT run tests or builds, DO NOT invoke \`superpowers:executing-plans\` or any implementation skill. Your ONLY job is to curate the Kōbō task list via MCP tools.`;
+export function buildAutoLoopGroomingSteps(e2e) {
+    const steps = [
+        `1. Call \`kobo__list_tasks\` FIRST to inspect any pre-existing tasks (they may have been seeded from Notion, a template, or the CreatePage form).`,
+        `2. If tasks already exist: DO NOT delete or recreate them from scratch. Read each one, judge whether it is atomic and implementable in one session with clear completion criteria. Improve them in place:
    - Use \`kobo__update_task\` to rename unclear titles, add completion criteria, or flip \`is_acceptance_criterion\` when needed.
    - Use \`kobo__create_task\` to SPLIT a task that is too large into smaller atomic pieces (keep the original only if it still makes sense, otherwise update it to one of the split pieces and create the rest).
-   - Use \`kobo__create_task\` to ADD missing acceptance criteria or missing implementation steps the plan requires.
-3. If no tasks exist:
+   - Use \`kobo__create_task\` to ADD missing acceptance criteria or missing implementation steps the plan requires.`,
+        `3. If no tasks exist:
    - If a plan file exists in \`docs/superpowers/plans/\` or similar, read it and derive the task list from it.
    - If no plan exists, ask the user what the workspace goal is and propose tasks accordingly.
-   - Create the tasks via \`kobo__create_task\`. For each task, decide \`is_acceptance_criterion\` appropriately.
-4. Call \`kobo__mark_auto_loop_ready\`. This will automatically start the auto-loop, which will pick up the tasks one by one in fresh sessions.`;
+   - Create the tasks via \`kobo__create_task\`. For each task, decide \`is_acceptance_criterion\` appropriately.`,
+    ];
+    if (e2e.framework) {
+        const skillHint = e2e.skill ? `Use the \`${e2e.skill}\` skill for this task. ` : '';
+        const promptHint = e2e.prompt ? `Additional guidance: ${e2e.prompt}` : '';
+        steps.push(`4. **E2E review**: walk the task list and identify which tasks produce user-visible behavior (UI flows, form submissions, page renders, etc.). For each one that warrants regression coverage, INSERT a follow-up sub-task with title prefixed \`[E2E] \` describing the test to write. Place it in \`sort_order\` directly after the parent task. Skip tasks that don't produce user-visible behavior (refactors, infra, internal services) and briefly justify your choices in chat. The project uses \`${e2e.framework}\`. ${skillHint}${promptHint}`.trim());
+        steps.push(`5. Call \`kobo__mark_auto_loop_ready\`. This will automatically start the auto-loop, which will pick up the tasks one by one in fresh sessions.`);
+    }
+    else {
+        steps.push(`4. Call \`kobo__mark_auto_loop_ready\`. This will automatically start the auto-loop, which will pick up the tasks one by one in fresh sessions.`);
+    }
+    return steps.join('\n');
+}
+/** @deprecated Use buildAutoLoopGroomingSteps({ framework: '', skill: '', prompt: '' }) instead. */
+export const AUTO_LOOP_GROOMING_STEPS = buildAutoLoopGroomingSteps({ framework: '', skill: '', prompt: '' });
+export function buildE2eIterationBlock(e2e) {
+    if (!e2e.framework)
+        return '';
+    const skillLine = e2e.skill ? `Use the \`${e2e.skill}\` skill for this task.\n` : '';
+    const promptLine = e2e.prompt ? `Additional guidance: ${e2e.prompt}\n` : '';
+    return `
+This is an **E2E regression test** task.
+
+Project E2E framework: ${e2e.framework}
+${skillLine}${promptLine}
+Hard rules specific to E2E tasks (these **override** the corresponding rules in the standard 8 steps below — read them before steps 3-4):
+1. Write the test source file in the project's existing E2E directory (look at \`cypress/\`, \`e2e/\`, \`tests/e2e/\`, or follow the skill / guidance above). Reuse existing fixtures and patterns.
+2. Try to run the tests locally. If they pass, great.
+3. **If the environment is broken** (Docker down, browser missing, port busy, dependencies not installed, etc.) — do NOT spend iterations debugging infra. **Override of step 4 of the standard prompt below**: you do NOT need to fix failing tests in this case. Commit the test source file with a message like \`test(e2e): add regression for <feature>\`, then call \`kobo__mark_task_done\` with a note in the chat: \`E2E test written but not executed locally — <reason>. Replay once env is restored.\`
+4. The code-review gate (step 6 of the standard prompt) still applies — the reviewer checks that the test is meaningful, not that it ran.
+`;
+}
 export const AUTO_LOOP_HARD_RULES = `Hard rules:
 - Do NOT touch any source file. No Edit, no Write, no Bash that changes the repo.
 - Do NOT run \`kill\`, \`pkill\`, \`killall\`, \`pgrep -k\`, or any process-killing command — you may tear down the Kōbō server itself or sibling dev servers.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loicngr/kobo",
-  "version": "1.6.11",
+  "version": "1.6.13",
   "description": "Kōbō — multi-workspace agent manager for Claude Code. Orchestrates isolated git worktrees with dev servers, Notion integration, and MCP tools.",
   "type": "module",
   "license": "GPL-3.0-or-later",