@loicngr/kobo 1.6.12 → 1.6.14

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

@@ -53,6 +53,12 @@ Please:
 3. Post a comment on the PR summarizing what was done and any follow-up items
 4. Do NOT add a "Generated with Claude Code" footer or any AI attribution to the PR description
 `;
+export const DEFAULT_FINALIZATION_PROMPT = `Run final quality checks before closing the workspace:
+
+1. Verify all other tasks are marked \`done\`. If any remain \`pending\`, stop and report.
+2. Run the project's linters, type-checkers, and tests (see CLAUDE.md or package.json scripts).
+3. If any check fails, create a new regular task at the end of the list with a title like \`Fix lint failure in X\` (NO \`[FINAL]\` or \`[E2E]\` prefix — it must use the default iteration prompt) and mark this \`[FINAL]\` task as \`done\`. The auto-loop will pick up the fix on the next iteration. The finalization mechanism is single-shot per grooming pass; if you want quality checks to re-run after the fix, mark the fix task \`done\` and re-trigger grooming manually.
+4. If everything passes, mark this task as \`done\`.`;
 /** Default workspace tags seeded on fresh install and on settings upgrade. */
 export const DEFAULT_WORKSPACE_TAGS = [
     'bug',
@@ -170,6 +176,21 @@ const settingsMigrations = [
             }
         },
     },
+    {
+        version: 10,
+        name: 'add-project-finalization',
+        migrate({ projects }) {
+            for (const p of projects) {
+                if (!p.finalization || typeof p.finalization !== 'object') {
+                    p.finalization = { prompt: DEFAULT_FINALIZATION_PROMPT };
+                }
+                else if (typeof p.finalization.prompt !== 'string') {
+                    ;
+                    p.finalization.prompt = DEFAULT_FINALIZATION_PROMPT;
+                }
+            }
+        },
+    },
 ];
 /** Current settings schema version — always equals the highest migration version. */
 export const SETTINGS_SCHEMA_VERSION = settingsMigrations.length > 0 ? settingsMigrations[settingsMigrations.length - 1].version : 0;
@@ -228,6 +249,14 @@ function defaultProjectSettings(projectPath) {
             startCommand: '',
             stopCommand: '',
         },
+        e2e: {
+            framework: '',
+            skill: '',
+            prompt: '',
+        },
+        finalization: {
+            prompt: DEFAULT_FINALIZATION_PROMPT,
+        },
     };
 }
 function pickKnownKeys(data, allowedKeys) {
@@ -434,7 +463,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, e2e, and finalization fields on update. */
 export function upsertProject(projectPath, data) {
     const allowedProjectKeys = [
         'displayName',
@@ -445,23 +474,41 @@ export function upsertProject(projectPath, data) {
         'gitConventions',
         'setupScript',
         'devServer',
+        'e2e',
+        'finalization',
     ];
     const allowedDevServerKeys = ['startCommand', 'stopCommand'];
+    const allowedE2eKeys = ['framework', 'skill', 'prompt'];
+    const allowedFinalizationKeys = ['prompt'];
     const filtered = pickKnownKeys(data, allowedProjectKeys);
     if (filtered.devServer) {
         filtered.devServer = pickKnownKeys(filtered.devServer, allowedDevServerKeys);
     }
+    if (filtered.e2e) {
+        filtered.e2e = pickKnownKeys(filtered.e2e, allowedE2eKeys);
+    }
+    if (filtered.finalization) {
+        filtered.finalization = pickKnownKeys(filtered.finalization, allowedFinalizationKeys);
+    }
     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, e2e, and finalization 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;
+        const existingFinalization = existing.finalization ?? defaultProjectSettings(projectPath).finalization;
+        const updatedFinalization = filtered.finalization
+            ? { ...existingFinalization, ...filtered.finalization }
+            : existingFinalization;
         settings.projects[idx] = {
             ...existing,
             ...filtered,
             path: projectPath,
             devServer: updatedDevServer,
+            e2e: updatedE2e,
+            finalization: updatedFinalization,
         };
     }
     else {
@@ -474,6 +521,12 @@ 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 };
+        }
+        if (filtered.finalization) {
+            newProject.finalization = { ...defaultProjectSettings(projectPath).finalization, ...filtered.finalization };
+        }
         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

@@ -43,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,
     };
@@ -78,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, sentry_url, 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, 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. */
@@ -114,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(', ')}`);
@@ -187,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,71 @@
  * 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, finalization) {
+    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.`,
+    ];
+    let nextNum = 4;
+    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(`${nextNum}. **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());
+        nextNum++;
+    }
+    if (finalization.prompt) {
+        steps.push(`${nextNum}. **Finalization task**: create ONE task with title prefixed \`[FINAL] <descriptive title>\`. Place it at the END of the task list (sort_order = max + 1, AFTER any [E2E] tasks). The agent will execute this task using the project's finalization prompt — do NOT inline the prompt content into the task title or description.`);
+        nextNum++;
+    }
+    steps.push(`${nextNum}. 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: '' }, { prompt: '' }) instead. */
+export const AUTO_LOOP_GROOMING_STEPS = buildAutoLoopGroomingSteps({ framework: '', skill: '', prompt: '' }, { prompt: '' });
+export function buildFinalizationIterationBlock(finalization) {
+    if (!finalization.prompt)
+        return '';
+    return `
+This is the **finalization task**. Follow this prompt instead of the standard 8 steps below:
+
+${finalization.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.12",
+  "version": "1.6.14",
   "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",

package/src/client/dist/spa/assets/ActivityFeed-Be0QQryJ.css

@@ -0,0 +1 @@
+.message-choices[data-v-29c0dc7a]{flex-wrap:wrap;align-items:stretch;display:flex}.message-choice-btn[data-v-29c0dc7a]{background:#818cf814;border:1px solid #818cf859;border-radius:6px;max-width:360px;font-size:12px}.message-choice-btn[data-v-29c0dc7a] .q-btn__content{flex-wrap:nowrap;justify-content:flex-start}.message-choice-btn[data-v-29c0dc7a]:hover{background:#818cf82e}.choice-label[data-v-29c0dc7a]{text-overflow:ellipsis;white-space:nowrap;max-width:320px;overflow:hidden}.markdown-message[data-v-8382750f]{color:#e0e0e0;word-break:break-word;overflow-wrap:anywhere;min-width:0;max-width:100%;font-size:13px;line-height:1.55}.markdown-message[data-v-8382750f] *{max-width:100%}.markdown-message[data-v-8382750f] p{margin:0 0 .5em}.markdown-message[data-v-8382750f] p:last-child{margin-bottom:0}.markdown-message[data-v-8382750f] pre{background:#00000059;border-radius:4px;margin:.5em 0;padding:.5em .75em;overflow-x:auto}.markdown-message[data-v-8382750f] code{word-break:break-all;background:#0000004d;border-radius:3px;padding:.1em .3em;font-size:.9em}.markdown-message[data-v-8382750f] pre code{background:0 0;padding:0}.markdown-message[data-v-8382750f] ul,.markdown-message[data-v-8382750f] ol{margin:.25em 0 .5em;padding-left:1.5em}.markdown-message[data-v-8382750f] li{margin:.15em 0}.markdown-message[data-v-8382750f] a{color:#7986cb;text-decoration:underline}.markdown-message[data-v-8382750f] .document-link{color:#9fa8da;cursor:pointer;-webkit-text-decoration:underline dotted;text-decoration:underline dotted}.markdown-message[data-v-8382750f] .document-link:hover{color:#c5cae9;-webkit-text-decoration:underline;text-decoration:underline}.markdown-message[data-v-8382750f] h1,.markdown-message[data-v-8382750f] h2,.markdown-message[data-v-8382750f] h3,.markdown-message[data-v-8382750f] h4,.markdown-message[data-v-8382750f] h5,.markdown-message[data-v-8382750f] h6{margin:.5em 0 .3em;font-weight:600;line-height:1.3}.markdown-message[data-v-8382750f] h1{font-size:1.25em}.markdown-message[data-v-8382750f] h2{font-size:1.15em}.markdown-message[data-v-8382750f] h3{font-size:1.08em}.markdown-message[data-v-8382750f] h4,.markdown-message[data-v-8382750f] h5,.markdown-message[data-v-8382750f] h6{font-size:1em}.markdown-message[data-v-8382750f] blockquote{color:#ffffffb3;border-left:3px solid #fff3;margin:.5em 0;padding-left:.75em}.markdown-message[data-v-8382750f] table{border-collapse:collapse;margin:.5em 0}.markdown-message[data-v-8382750f] th,.markdown-message[data-v-8382750f] td{border:1px solid #ffffff26;padding:.25em .5em}.markdown-thinking[data-v-4e64694c] p{margin:0 0 .4em}.markdown-thinking[data-v-4e64694c] p:last-child{margin-bottom:0}.markdown-thinking[data-v-4e64694c] code{background:#ffffff14;border-radius:3px;padding:.1em .3em}.tool-row[data-v-b1fcd20d]{border-radius:4px;margin:0;font-size:12px}.tool-header[data-v-b1fcd20d]{color:#bbb;cursor:default;align-items:center;gap:10px;min-width:0;padding:5px 10px;display:flex}.tool-row:not(.tool-row-generic) .tool-header[data-v-b1fcd20d],.tool-row--toggleable .tool-header[data-v-b1fcd20d]{cursor:pointer}.tool-row:has(.tool-diff) .tool-header[data-v-b1fcd20d]{cursor:pointer}.tool-row:not(.tool-row-generic) .tool-header[data-v-b1fcd20d]:hover,.tool-row--toggleable .tool-header[data-v-b1fcd20d]:hover{background:#ffffff08}.tool-icon[data-v-b1fcd20d]{color:#9fbce0;flex-shrink:0}.tool-name[data-v-b1fcd20d]{color:#d0d0d0;flex-shrink:0;font-weight:600}.tool-arg[data-v-b1fcd20d],.tool-path[data-v-b1fcd20d]{color:#999;text-overflow:ellipsis;white-space:nowrap;min-width:0;max-width:100%;font-family:SF Mono,Menlo,Consolas,monospace;font-size:11.5px;overflow:hidden}.tool-path[data-v-b1fcd20d],.tool-arg[data-v-b1fcd20d]{flex:1}.tool-stat-add[data-v-b1fcd20d]{color:#66bb6a;flex-shrink:0;font-size:11px;font-weight:600}.tool-stat-del[data-v-b1fcd20d]{color:#ef5350;flex-shrink:0;font-size:11px;font-weight:600}.tool-diff[data-v-b1fcd20d]{background:#0003;border-radius:4px;max-height:400px;margin-top:4px;padding:8px 0;font-family:SF Mono,Menlo,Consolas,monospace;font-size:11px;line-height:1.5;overflow:auto}.diff-line[data-v-b1fcd20d]{white-space:pre;color:#bbb;padding:0 12px}.diff-sign[data-v-b1fcd20d]{color:#555;-webkit-user-select:none;user-select:none;width:14px;display:inline-block}.diff-add[data-v-b1fcd20d]{color:#c8e6c9;background:#66bb6a1a}.diff-add .diff-sign[data-v-b1fcd20d]{color:#66bb6a}.diff-del[data-v-b1fcd20d]{color:#ffcdd2;background:#ef53501a}.diff-del .diff-sign[data-v-b1fcd20d]{color:#ef5350}.tool-output[data-v-b1fcd20d]{color:#aaa;white-space:pre-wrap;background:#00000026;border-radius:4px;max-height:8em;margin-top:4px;padding:6px 10px;font-family:SF Mono,Menlo,Consolas,monospace;font-size:11px;overflow:auto}.markdown-message[data-v-c2e7c407]{color:#e0e0e0;word-break:break-word;overflow-wrap:anywhere;min-width:0;max-width:100%;font-size:13px;line-height:1.55}.markdown-message[data-v-c2e7c407] *{max-width:100%}.markdown-message[data-v-c2e7c407] img{-o-object-fit:contain;object-fit:contain;cursor:zoom-in;background:#0003;border-radius:4px;max-width:180px;max-height:100px;margin:.3em 0;display:block}.markdown-message[data-v-c2e7c407] code{word-break:break-all}.markdown-message[data-v-c2e7c407] p{margin:0 0 .4em}.markdown-message[data-v-c2e7c407] p:last-child{margin-bottom:0}.markdown-message[data-v-c2e7c407] code{background:#00000040;border-radius:3px;padding:.1em .3em}.markdown-message[data-v-c2e7c407] h1,.markdown-message[data-v-c2e7c407] h2,.markdown-message[data-v-c2e7c407] h3,.markdown-message[data-v-c2e7c407] h4,.markdown-message[data-v-c2e7c407] h5,.markdown-message[data-v-c2e7c407] h6{margin:.4em 0 .25em;font-weight:600;line-height:1.3}.markdown-message[data-v-c2e7c407] h1{font-size:1.25em}.markdown-message[data-v-c2e7c407] h2{font-size:1.15em}.markdown-message[data-v-c2e7c407] h3{font-size:1.08em}.markdown-message[data-v-c2e7c407] h4,.markdown-message[data-v-c2e7c407] h5,.markdown-message[data-v-c2e7c407] h6{font-size:1em}.markdown-user-prompt[data-v-c2e7c407]{color:#aaa;font-size:12px;font-style:italic}.markdown-user-prompt[data-v-c2e7c407] p{margin:0 0 .4em}.markdown-user-prompt[data-v-c2e7c407] code{background:#ffffff14;border-radius:3px;padding:.1em .3em;font-style:normal}.image-lightbox-img{-o-object-fit:contain;object-fit:contain;cursor:zoom-out;background:#0000004d;border-radius:4px;max-width:92vw;max-height:92vh;display:block}.turn-card[data-v-813aff2b]{border:1px solid #ffffff14;border-left:3px solid var(--turn-accent);background:#ffffff05;border-radius:6px;min-width:0;max-width:100%;margin:14px 0;overflow:hidden}.turn-header[data-v-813aff2b]{color:#888;background:#ffffff08;border-bottom:1px solid #ffffff0d;align-items:center;gap:8px;padding:8px 14px;font-size:11px;display:flex}.turn-badge[data-v-813aff2b]{letter-spacing:.3px;border-radius:3px;padding:2px 8px;font-size:11px;font-weight:700}.turn-badge-user[data-v-813aff2b]{color:#ce93d8;background:#ce93d826}.turn-badge-agent[data-v-813aff2b]{color:#7986cb;background:#7986cb26}.turn-badge-system[data-v-813aff2b]{color:#bdbdbd;background:#75757533;font-style:italic}.turn-badge-session[data-v-813aff2b]{color:#9e9e9e;background:#61616133}.turn-time[data-v-813aff2b]{color:#666;font-family:SF Mono,Menlo,Consolas,monospace;font-size:11px}.turn-time-arrow[data-v-813aff2b]{opacity:.7;margin:0 -2px}.turn-time-updated[data-v-813aff2b]{color:#8891a3}.turn-actions[data-v-813aff2b]{color:#777;font-size:11px}.turn-body[data-v-813aff2b]{flex-direction:column;gap:12px;min-width:0;padding:14px 18px;display:flex}.turn-body[data-v-813aff2b]>*{min-width:0;max-width:100%}.turn-body[data-v-813aff2b] .tool-row+.tool-row{margin-top:-8px}.turn-scroll-top[data-v-813aff2b]{justify-content:flex-start;padding:0 8px 6px;display:flex}.turn-scroll-top-btn[data-v-813aff2b]{opacity:.5;transition:opacity .15s}.turn-scroll-top-btn[data-v-813aff2b]:hover{opacity:1}.activity-feed-wrap[data-v-ea6b67c0]{width:100%;height:100%;position:relative}.activity-feed-scroll[data-v-ea6b67c0]{width:100%;height:100%}.activity-feed-nav-cluster[data-v-ea6b67c0]{z-index:2;align-items:center;gap:8px;display:flex;position:absolute;bottom:14px;right:14px}.activity-feed-nav-btn[data-v-ea6b67c0]{opacity:.8;transition:opacity .12s}.activity-feed-nav-btn[data-v-ea6b67c0]:hover{opacity:1}.content-origin-marker[data-v-ea6b67c0]{pointer-events:none;width:0;height:0;margin:0;padding:0}.activity-feed-scroll[data-v-ea6b67c0] .q-scrollarea__content{max-width:100%;overflow-x:hidden}.activity-feed-switching[data-v-ea6b67c0]{justify-content:center;align-items:center;width:100%;height:100%;display:flex}