@loicngr/kobo 1.11.43 → 1.11.45

package/dist/server/services/task-mutations.js

@@ -0,0 +1,186 @@
+import { nanoid } from 'nanoid';
+export class TaskValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'TaskValidationError';
+    }
+}
+function validateVerification(input, requirePassed) {
+    if (!input || typeof input !== 'object' || Array.isArray(input)) {
+        throw new TaskValidationError('Task verification is required before marking an auto-loop task done');
+    }
+    const proof = input;
+    if (typeof proof.method !== 'string' ||
+        !proof.method.trim() ||
+        typeof proof.summary !== 'string' ||
+        !proof.summary.trim() ||
+        !Array.isArray(proof.checks) ||
+        proof.checks.length === 0 ||
+        proof.checks.some((check) => !check ||
+            typeof check.name !== 'string' ||
+            !check.name.trim() ||
+            !['passed', 'failed', 'not_run'].includes(check.status) ||
+            (requirePassed && check.status !== 'passed'))) {
+        throw new TaskValidationError('Task verification requires a method, summary and named checks; every check must have passed before completion');
+    }
+    return {
+        method: proof.method.trim(),
+        summary: proof.summary.trim(),
+        checks: proof.checks.map((check) => ({ name: check.name.trim(), status: check.status })),
+    };
+}
+function validateOrder(input) {
+    if (input.sortOrder !== undefined && (!Number.isSafeInteger(input.sortOrder) || input.sortOrder < 0)) {
+        throw new TaskValidationError('sort_order must be a non-negative safe integer');
+    }
+    if (input.afterTaskId !== undefined && (typeof input.afterTaskId !== 'string' || !input.afterTaskId)) {
+        throw new TaskValidationError('after_task_id must be a non-empty task id');
+    }
+    if (input.sortOrder !== undefined && input.afterTaskId !== undefined) {
+        throw new TaskValidationError('Provide either sort_order or after_task_id, not both');
+    }
+    if ('isAcceptanceCriterion' in input &&
+        input.isAcceptanceCriterion !== undefined &&
+        typeof input.isAcceptanceCriterion !== 'boolean') {
+        throw new TaskValidationError('is_acceptance_criterion must be a boolean');
+    }
+}
+/** Task-list changes make the previous final review obsolete, even while the loop is paused. */
+export function invalidateTaskFinalization(db, workspaceId, verifiedTaskId = '') {
+    db.prepare(`UPDATE tasks SET status = 'pending', verification = NULL, updated_at = ?
+    WHERE workspace_id = ? AND role = 'finalization' AND status = 'done' AND id <> ?`).run(new Date().toISOString(), workspaceId, verifiedTaskId);
+}
+function readTask(db, workspaceId, taskId) {
+    const task = db.prepare('SELECT * FROM tasks WHERE id = ? AND workspace_id = ?').get(taskId, workspaceId);
+    if (!task)
+        throw new Error(`Task '${taskId}' not found in workspace '${workspaceId}'`);
+    return task;
+}
+/** Insert/move after an existing sibling and normalize positions within the caller's transaction. */
+function moveAfter(db, workspaceId, taskId, afterTaskId) {
+    readTask(db, workspaceId, afterTaskId);
+    if (taskId === afterTaskId)
+        throw new TaskValidationError('A task cannot be placed after itself');
+    const tasks = db
+        .prepare('SELECT id, sort_order FROM tasks WHERE workspace_id = ? ORDER BY sort_order, rowid')
+        .all(workspaceId);
+    const ordered = tasks.filter((task) => task.id !== taskId);
+    ordered.splice(ordered.findIndex((task) => task.id === afterTaskId) + 1, 0, tasks.find((task) => task.id === taskId));
+    const changed = tasks.some((task, index) => task.id !== ordered[index]?.id);
+    if (!changed)
+        return false;
+    const update = db.prepare('UPDATE tasks SET sort_order = ?, updated_at = ? WHERE id = ?');
+    const now = new Date().toISOString();
+    ordered.forEach((task, index) => {
+        update.run(index, now, task.id);
+    });
+    return true;
+}
+export function createTaskRecord(db, workspaceId, input) {
+    if (typeof input.title !== 'string' || !input.title.trim())
+        throw new TaskValidationError('title is required');
+    validateOrder(input);
+    if (input.role !== undefined && input.role !== 'work' && input.role !== 'finalization') {
+        throw new TaskValidationError('Task role must be work or finalization');
+    }
+    return db
+        .transaction(() => {
+        if (!db.prepare('SELECT 1 FROM workspaces WHERE id = ?').get(workspaceId)) {
+            throw new Error(`Workspace '${workspaceId}' not found`);
+        }
+        if (input.afterTaskId !== undefined)
+            readTask(db, workspaceId, input.afterTaskId);
+        const title = input.title.trim();
+        const role = input.role ?? (title.startsWith('[FINAL] ') ? 'finalization' : 'work');
+        const max = db
+            .prepare('SELECT COALESCE(MAX(sort_order), -1) AS value FROM tasks WHERE workspace_id = ?')
+            .get(workspaceId).value;
+        const order = input.sortOrder ?? max + 1;
+        const now = new Date().toISOString();
+        if (input.sortOrder !== undefined) {
+            db.prepare('UPDATE tasks SET sort_order = sort_order + 1 WHERE workspace_id = ? AND sort_order >= ?').run(workspaceId, order);
+        }
+        const id = nanoid();
+        db.prepare(`INSERT INTO tasks (id, workspace_id, title, status, is_acceptance_criterion, sort_order, role, verification, created_at, updated_at)
+      VALUES (?, ?, ?, 'pending', ?, ?, ?, NULL, ?, ?)`).run(id, workspaceId, title, input.isAcceptanceCriterion ? 1 : 0, order, role, now, now);
+        if (input.afterTaskId !== undefined)
+            moveAfter(db, workspaceId, id, input.afterTaskId);
+        if (role === 'work')
+            invalidateTaskFinalization(db, workspaceId);
+        return readTask(db, workspaceId, id);
+    })
+        .immediate();
+}
+export function updateTaskRecord(db, workspaceId, taskId, input) {
+    validateOrder(input);
+    if (input.title !== undefined && (typeof input.title !== 'string' || !input.title.trim())) {
+        throw new TaskValidationError('Task title cannot be empty');
+    }
+    if (input.status !== undefined && !['pending', 'in_progress', 'done'].includes(input.status)) {
+        throw new TaskValidationError(`Invalid status '${input.status}'. Must be one of: pending, in_progress, done`);
+    }
+    if (!['title', 'status', 'isAcceptanceCriterion', 'sortOrder', 'afterTaskId', 'verification'].some((key) => input[key] !== undefined)) {
+        throw new TaskValidationError('No fields to update (provide title, status, is_acceptance_criterion, order, or verification)');
+    }
+    return db
+        .transaction(() => {
+        const task = readTask(db, workspaceId, taskId);
+        const autoLoop = db.prepare('SELECT auto_loop FROM workspaces WHERE id = ?').get(workspaceId)
+            .auto_loop === 1;
+        const title = input.title?.trim() ?? task.title;
+        const isAC = input.isAcceptanceCriterion === undefined ? task.is_acceptance_criterion : Number(input.isAcceptanceCriterion);
+        const scopeChanged = title !== task.title || isAC !== task.is_acceptance_criterion;
+        const status = input.status ??
+            (scopeChanged && task.status === 'done' && (autoLoop || task.role === 'finalization') ? 'pending' : task.status);
+        const completing = status === 'done' && (input.status === 'done' || input.verification !== undefined || scopeChanged);
+        let verification = scopeChanged || status !== 'done' ? null : task.verification;
+        if (input.verification !== undefined)
+            verification = JSON.stringify(validateVerification(input.verification, completing));
+        if (completing && autoLoop && input.verification === undefined)
+            validateVerification(undefined, true);
+        if (completing &&
+            task.role === 'finalization' &&
+            db
+                .prepare("SELECT 1 FROM tasks WHERE workspace_id = ? AND role = 'work' AND status <> 'done' LIMIT 1")
+                .get(workspaceId)) {
+            throw new TaskValidationError('Finalization cannot be completed while work tasks or acceptance criteria are pending');
+        }
+        if (completing &&
+            task.role === 'finalization' &&
+            db
+                .prepare("SELECT 1 FROM auto_loop_messages WHERE workspace_id = ? AND state IN ('pending', 'unknown') LIMIT 1")
+                .get(workspaceId)) {
+            throw new TaskValidationError('Finalization cannot be completed while user instructions are pending or their delivery is unknown');
+        }
+        let orderChanged = false;
+        if (input.afterTaskId !== undefined)
+            orderChanged = moveAfter(db, workspaceId, taskId, input.afterTaskId);
+        if (input.sortOrder !== undefined && input.sortOrder !== task.sort_order) {
+            // Moving to an occupied position shifts the intervening siblings only.
+            if (input.sortOrder < task.sort_order) {
+                db.prepare('UPDATE tasks SET sort_order = sort_order + 1 WHERE workspace_id = ? AND id <> ? AND sort_order >= ? AND sort_order < ?').run(workspaceId, taskId, input.sortOrder, task.sort_order);
+            }
+            else {
+                db.prepare('UPDATE tasks SET sort_order = sort_order - 1 WHERE workspace_id = ? AND id <> ? AND sort_order > ? AND sort_order <= ?').run(workspaceId, taskId, task.sort_order, input.sortOrder);
+            }
+            db.prepare('UPDATE tasks SET sort_order = ? WHERE id = ?').run(input.sortOrder, taskId);
+            orderChanged = true;
+        }
+        db.prepare('UPDATE tasks SET title = ?, status = ?, is_acceptance_criterion = ?, verification = ?, updated_at = ? WHERE id = ?').run(title, status, isAC, verification, new Date().toISOString(), taskId);
+        if (scopeChanged || orderChanged || (task.status === 'done' && status !== 'done')) {
+            // Fresh evidence supplied with this exact edit validates its new scope;
+            // all other completed finalizations still describe the previous state.
+            invalidateTaskFinalization(db, workspaceId, completing && input.verification !== undefined ? taskId : '');
+        }
+        return readTask(db, workspaceId, taskId);
+    })
+        .immediate();
+}
+export function deleteTaskRecord(db, workspaceId, taskId) {
+    db.transaction(() => {
+        const task = readTask(db, workspaceId, taskId);
+        db.prepare('DELETE FROM tasks WHERE id = ?').run(taskId);
+        if (task.role === 'work')
+            invalidateTaskFinalization(db, workspaceId);
+    }).immediate();
+}

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

@@ -3,6 +3,7 @@ import { slugifyProjectName } from '../utils/project-slug.js';
 import { isWorkspaceLifecycleBusy } from '../utils/workspace-lifecycle-guard.js';
 import { resolveWorkspaceWorktreePath } from '../utils/worktree-paths.js';
 import * as orchestrator from './agent/orchestrator.js';
+import * as autoLoopService from './auto-loop-service.js';
 import * as settingsService from './settings-service.js';
 import { emitEphemeral } from './websocket-service.js';
 const MIN_DELAY_SECONDS = 60;
@@ -75,6 +76,14 @@ export function schedule(workspaceId, delaySeconds, prompt, reason, agentSession
         console.error('[wakeup-service] schedule failed:', err);
     }
 }
+/** Move a source conversation's pending check only once its handoff succeeds. */
+export function transferSession(workspaceId, sourceSessionId, targetSessionId) {
+    if (!sourceSessionId)
+        return;
+    getDb()
+        .prepare('UPDATE pending_wakeups SET agent_session_id = ? WHERE workspace_id = ? AND agent_session_id = ?')
+        .run(targetSessionId, workspaceId, sourceSessionId);
+}
 /** Cancel any pending wakeup for the workspace. Idempotent. */
 export function cancel(workspaceId, reason) {
     try {
@@ -184,13 +193,27 @@ function fire(workspaceId) {
             return;
         }
         const wsRow = db
-            .prepare(`SELECT project_path, working_branch, worktree_path, model, agent_permission_mode, reasoning_effort
+            .prepare(`SELECT project_path, working_branch, worktree_path, model, agent_permission_mode, reasoning_effort, auto_loop
            FROM workspaces WHERE id = ?`)
             .get(workspaceId);
         if (!wsRow) {
             emitEphemeral(workspaceId, 'wakeup:skipped', { reason: 'fire-failed' });
             return;
         }
+        if (wsRow.auto_loop !== 1 && !autoLoopService.canStartAutomatically(workspaceId)) {
+            defer(workspaceId, row);
+            return;
+        }
+        if (wsRow.auto_loop === 1) {
+            if (!autoLoopService.queueInstruction(workspaceId, row.prompt, `wakeup:${row.created_at}`)) {
+                defer(workspaceId, row);
+                return;
+            }
+            failedRetries.delete(workspaceId);
+            db.prepare('DELETE FROM pending_wakeups WHERE workspace_id = ?').run(workspaceId);
+            emitEphemeral(workspaceId, 'wakeup:fired', {});
+            return;
+        }
         const globalSettings = settingsService.getGlobalSettings();
         const projectSettings = settingsService.getProjectSettings(wsRow.project_path);
         const projectSlug = globalSettings.worktreesPrefixByProject

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

@@ -1,7 +1,9 @@
 import { assertWorkspaceLifecycleAvailable } from '../utils/workspace-lifecycle-guard.js';
 import { isAgentUnavailableError, isShuttingDown, sendMessage, startAgent } from './agent/orchestrator.js';
+import { hasLoopMessage } from './auto-loop-message-service.js';
 import * as autoLoop from './auto-loop-service.js';
 import { createChatReceipt } from './chat-receipt-service.js';
+import { emitEphemeral } from './websocket-service.js';
 import { getActiveSession, getWorkspace, updateWorkspaceStatus } from './workspace-service.js';
 /** Shared delivery for WebSocket chat and external MCP clients. */
 export async function deliverWorkspaceMessage(workspaceId, message, hooks) {
@@ -18,6 +20,18 @@ export async function deliverWorkspaceMessage(workspaceId, message, hooks) {
             throw new Error(`Workspace '${workspaceId}' not found`);
         if (workspace.archivedAt || workspace.worktreePurgedAt)
             throw new Error('Restore the workspace before sending a message');
+        if (message.delivery === 'next_iteration') {
+            if (!message.clientMessageId)
+                throw new Error('clientMessageId is required for queued delivery');
+            const acceptedBefore = hasLoopMessage(workspaceId, message.clientMessageId);
+            if (!autoLoop.queueInstruction(workspaceId, message.content, message.clientMessageId, message.source))
+                throw new Error('Auto-loop is not enabled');
+            if (!acceptedBefore)
+                receipt.accept();
+            else
+                emitEphemeral(workspaceId, 'chat:accepted', { clientMessageId: message.clientMessageId });
+            return {};
+        }
         if (workspace.status === 'compacting') {
             reason = 'compacting';
             throw new Error('Workspace is compacting its context; wait until compaction finishes before sending a message');
@@ -27,8 +41,6 @@ export async function deliverWorkspaceMessage(workspaceId, message, hooks) {
             throw new Error('Answer the pending question or permission request before sending a chat message');
         }
         const loop = autoLoop.getStatus(workspaceId);
-        if (loop.auto_loop && loop.auto_loop_ready)
-            autoLoop.disable(workspaceId, 'user-action');
         let sessionId = message.sessionId ?? getActiveSession(workspaceId)?.id;
         try {
             if (hooks?.beforeDispatch)
@@ -48,6 +60,8 @@ export async function deliverWorkspaceMessage(workspaceId, message, hooks) {
             updateWorkspaceStatus(workspaceId, 'executing');
             sessionId = message.sessionId ?? started.agentSessionId;
         }
+        if (loop.auto_loop && loop.auto_loop_ready)
+            autoLoop.disable(workspaceId, 'user-action');
         receipt.accept(sessionId);
         return { sessionId };
     }

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

@@ -1,4 +1,5 @@
 import { nanoid } from 'nanoid';
+import { parseTaskVerification } from '../../shared/task-verification.js';
 import { getDb } from '../db/index.js';
 import { isValidBranchName } from '../utils/git-ops.js';
 import { resolveWorkspaceWorktreePath } from '../utils/worktree-paths.js';
@@ -6,6 +7,8 @@ import * as orchestrator from './agent/orchestrator.js';
 import * as autoLoopService from './auto-loop-service.js';
 import * as cronService from './cron-service.js';
 import * as quotaBackoffService from './quota-backoff-service.js';
+import { SESSION_RECENCY_ORDER } from './session-activity-service.js';
+import { createTaskRecord, deleteTaskRecord, updateTaskRecord } from './task-mutations.js';
 import * as wakeupService from './wakeup-service.js';
 import { emitEphemeral } from './websocket-service.js';
 /** Allowed status transitions per current status. Enforced by updateWorkspaceStatus. */
@@ -112,6 +115,8 @@ function mapTask(row) {
         status: row.status,
         isAcceptanceCriterion: row.is_acceptance_criterion === 1,
         sortOrder: row.sort_order,
+        role: row.role,
+        verification: parseTaskVerification(row.verification),
         createdAt: row.created_at,
         updatedAt: row.updated_at,
     };
@@ -590,18 +595,10 @@ export function deleteWorkspace(id) {
 /** Create a new task under a workspace. Throws if the workspace does not exist. */
 export function createTask(workspaceId, data) {
     const db = getDb();
-    const exists = db.prepare('SELECT 1 FROM workspaces WHERE id = ?').get(workspaceId);
-    if (!exists) {
+    if (!db.prepare('SELECT 1 FROM workspaces WHERE id = ?').get(workspaceId)) {
         throw new Error(`Workspace not found: '${workspaceId}'`);
     }
-    const now = new Date().toISOString();
-    const id = nanoid();
-    db.prepare(`
-    INSERT INTO tasks (id, workspace_id, title, status, is_acceptance_criterion, sort_order, created_at, updated_at)
-    VALUES (?, ?, ?, 'pending', ?, ?, ?, ?)
-  `).run(id, workspaceId, data.title, data.isAcceptanceCriterion ? 1 : 0, data.sortOrder ?? 0, now, now);
-    const row = db.prepare('SELECT * FROM tasks WHERE id = ?').get(id);
-    return mapTask(row);
+    return mapTask(createTaskRecord(db, workspaceId, data));
 }
 /** Fetch a single task by ID scoped to a workspace, or null if not found. */
 export function getTask(taskId, workspaceId) {
@@ -613,39 +610,32 @@ export function getTask(taskId, workspaceId) {
 export function listTasks(workspaceId) {
     const db = getDb();
     const rows = db
-        .prepare('SELECT * FROM tasks WHERE workspace_id = ? ORDER BY sort_order ASC')
+        .prepare('SELECT * FROM tasks WHERE workspace_id = ? ORDER BY sort_order ASC, rowid ASC')
         .all(workspaceId);
     return rows.map(mapTask);
 }
-/** Update a task's status (pending, in_progress, done). */
-export function updateTaskStatus(taskId, status) {
+/** Update task fields atomically through the same completion policy as MCP. */
+export function updateTask(taskId, data) {
     const db = getDb();
-    const now = new Date().toISOString();
-    db.prepare('UPDATE tasks SET status = ?, updated_at = ? WHERE id = ?').run(status, now, taskId);
-    const row = db.prepare('SELECT * FROM tasks WHERE id = ?').get(taskId);
-    if (!row) {
+    const existing = db.prepare('SELECT workspace_id FROM tasks WHERE id = ?').get(taskId);
+    if (!existing)
         throw new Error(`Task '${taskId}' not found`);
-    }
-    return mapTask(row);
+    return mapTask(updateTaskRecord(db, existing.workspace_id, taskId, data));
+}
+/** Update a task's status; auto-loop completion requires successful verification. */
+export function updateTaskStatus(taskId, status, verification) {
+    return updateTask(taskId, { status, ...(verification !== undefined ? { verification } : {}) });
 }
-/** Update a task's title. Throws if the title is empty or the task does not exist. */
+/** Update a task's title and invalidate obsolete verification. */
 export function updateTaskTitle(taskId, title) {
-    if (!title?.trim()) {
-        throw new Error('Task title cannot be empty');
-    }
-    const db = getDb();
-    const now = new Date().toISOString();
-    const result = db.prepare('UPDATE tasks SET title = ?, updated_at = ? WHERE id = ?').run(title.trim(), now, taskId);
-    if (result.changes === 0) {
-        throw new Error(`Task '${taskId}' not found`);
-    }
-    const row = db.prepare('SELECT * FROM tasks WHERE id = ?').get(taskId);
-    return mapTask(row);
+    return updateTask(taskId, { title });
 }
 /** Delete a task by ID. */
 export function deleteTask(taskId) {
     const db = getDb();
-    db.prepare('DELETE FROM tasks WHERE id = ?').run(taskId);
+    const existing = db.prepare('SELECT workspace_id FROM tasks WHERE id = ?').get(taskId);
+    if (existing)
+        deleteTaskRecord(db, existing.workspace_id, taskId);
 }
 /** Fetch a workspace with all its tasks eagerly loaded. */
 export function getWorkspaceWithTasks(id) {
@@ -787,6 +777,7 @@ function mapSession(row) {
         model: row.model,
         startedAt: row.started_at,
         endedAt: row.ended_at,
+        activationOrder: row.activation_order,
         name: row.name,
     };
 }
@@ -809,8 +800,9 @@ export function getLatestSession(workspaceId) {
 /**
  * Return the "active" session for tagging events like push/pull/open-pr traces
  * or resumed chat messages. Skips idle sessions (never started) and prefers a
- * running session, falling back to the most recent session that has actually
- * been started (any non-idle status).
+ * running session, falling back to the last used session (any non-idle status).
+ * Starts and handoff rollbacks persist activation order independently of execution dates.
+ * Legacy sessions fall back to their last start/end time.
  */
 export function getActiveSession(workspaceId) {
     const db = getDb();
@@ -820,9 +812,9 @@ export function getActiveSession(workspaceId) {
         .get(workspaceId);
     if (running)
         return mapSession(running);
-    // Otherwise the most recent non-idle session (completed, error, quota, etc.)
+    // Otherwise the last used non-idle session (completed, error, quota, etc.)
     const latestNonIdle = db
-        .prepare("SELECT * FROM agent_sessions WHERE workspace_id = ? AND status != 'idle' ORDER BY started_at DESC LIMIT 1")
+        .prepare(`SELECT * FROM agent_sessions WHERE workspace_id = ? AND status != 'idle' AND activation_order >= 0 ORDER BY ${SESSION_RECENCY_ORDER} LIMIT 1`)
         .get(workspaceId);
     return latestNonIdle ? mapSession(latestNonIdle) : null;
 }

package/dist/server/utils/workspace-lifecycle-guard.js

@@ -1,4 +1,4 @@
-const busyWorkspaces = new Set();
+const busyWorkspaces = new Map();
 const deferred = new Map();
 export class WorkspaceLifecycleBusyError extends Error {
     code = 'workspace-busy';
@@ -9,10 +9,40 @@ export class WorkspaceLifecycleBusyError extends Error {
 export function isWorkspaceLifecycleBusy(id) {
     return busyWorkspaces.has(id);
 }
-export function assertWorkspaceLifecycleAvailable(id) {
-    if (busyWorkspaces.has(id))
+export function assertWorkspaceLifecycleAvailable(id, owner) {
+    const reservation = busyWorkspaces.get(id);
+    if (owner ? reservation?.owner !== owner : !!reservation)
         throw new WorkspaceLifecycleBusyError();
 }
+export function workspaceLifecycleReason(id) {
+    return busyWorkspaces.get(id)?.reason;
+}
+export function reserveWorkspaceLifecycle(id, reason) {
+    assertWorkspaceLifecycleAvailable(id);
+    const owner = Symbol(id);
+    busyWorkspaces.set(id, { owner, reason });
+    return {
+        owner,
+        release() {
+            if (busyWorkspaces.get(id)?.owner !== owner)
+                return;
+            busyWorkspaces.delete(id);
+            const callbacks = deferred.get(id);
+            deferred.delete(id);
+            if (callbacks)
+                queueMicrotask(() => {
+                    for (const retry of callbacks) {
+                        try {
+                            retry();
+                        }
+                        catch (err) {
+                            console.error('[workspace-lifecycle] deferred operation failed:', err);
+                        }
+                    }
+                });
+        },
+    };
+}
 /** Keep automatic work pending without polling or acquiring the guard recursively. */
 export function deferUntilWorkspaceAvailable(id, retry) {
     if (!busyWorkspaces.has(id))
@@ -24,26 +54,11 @@ export function deferUntilWorkspaceAvailable(id, retry) {
 }
 /** Exclude competing restore/purge/delete operations, including their awaits. */
 export async function withWorkspaceLifecycleGuard(id, action) {
-    if (busyWorkspaces.has(id))
-        throw new WorkspaceLifecycleBusyError();
-    busyWorkspaces.add(id);
+    const reservation = reserveWorkspaceLifecycle(id);
     try {
         return await action();
     }
     finally {
-        busyWorkspaces.delete(id);
-        const callbacks = deferred.get(id);
-        deferred.delete(id);
-        if (callbacks)
-            queueMicrotask(() => {
-                for (const retry of callbacks) {
-                    try {
-                        retry();
-                    }
-                    catch (err) {
-                        console.error('[workspace-lifecycle] deferred operation failed:', err);
-                    }
-                }
-            });
+        reservation.release();
     }
 }

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

@@ -50,25 +50,35 @@ export function buildAutoLoopGroomingSteps(e2e, finalization) {
     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());
+        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. Use \`after_task_id\` to insert it directly after the parent task; \`list_tasks\` exposes \`sort_order\` so you can verify ordering. 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.`);
+        steps.push(`${nextNum}. **Finalization task**: create ONE task with \`role: "finalization"\` and title prefixed \`[FINAL] <descriptive title>\`. Reuse an existing finalization task instead of duplicating it. 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.`);
+    steps.push(`${nextNum}. Call \`kobo__mark_auto_loop_ready\`. This marks preparation complete. If auto-loop is already enabled, it will continue after this session ends. Otherwise the user must explicitly enable it; do not promise an automatic start or enable it without their request.`);
     return steps.join('\n');
 }
 /** @deprecated Use buildAutoLoopGroomingSteps({ framework: '', skill: '', prompt: '' }, { prompt: '' }) instead. */
 export const AUTO_LOOP_GROOMING_STEPS = buildAutoLoopGroomingSteps({ framework: '', skill: '', prompt: '' }, { prompt: '' });
+/** These rules apply to every iteration, including custom finalization and E2E prompts. */
+export const AUTO_LOOP_ITERATION_RULES = `Mandatory completion and lifecycle rules (custom prompts cannot override them):
+- Follow the Kōbō task list and acceptance criteria. Before completion, read the latest list again.
+- Never mark a task done based only on an implementation claim, a written test, or a check that was not executed. Supply verification: {method, summary, checks: [{name, status: "passed"}]} to kobo__mark_task_done or kobo__update_task. Every required check must actually pass.
+- If a required check fails or cannot run, keep the task pending/in_progress, record honest failed/not_run verification with kobo__update_task, and explain the concrete blocker. Create prerequisite fix tasks when needed; do not claim success.
+- Finalization is a verification gate: all work tasks and acceptance criteria must be done, then rerun relevant checks against the final state. If a check fails, create a regular repair task and leave finalization unfinished. It will run again after the repairs.
+- Do NOT kill the Kōbō server or sibling processes. Do not use kill, pkill or killall to force the loop to advance. Finish the current response naturally; Kōbō owns continuation.
+- Follow the user's scope, Git and approval instructions. Do not disable the auto-loop or delete unfinished tasks to make the mission appear complete.`;
 export function buildFinalizationIterationBlock(finalization) {
-    if (!finalization.prompt)
-        return '';
+    const instructions = finalization.prompt.trim() ||
+        'Review the completed work against every acceptance criterion. Run the relevant project checks and inspect the final diff. Report the actual results with structured verification.';
     return `
-This is the **finalization task**. Follow this prompt instead of the standard 8 steps below:
+This is the **finalization task**. Apply the following project guidance while preserving all mandatory completion and lifecycle rules:
+
+${instructions}
 
-${finalization.prompt}
+Read kobo__list_tasks again. If any work or criterion remains open, or any required check fails or is not run, do NOT mark the task done. Add necessary repair tasks and keep finalization pending. Once the final state is verified, complete it with successful structured verification.
 `;
 }
 export function buildE2eIterationBlock(e2e) {
@@ -81,11 +91,12 @@ 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):
+E2E instructions, subject to the mandatory completion and lifecycle rules:
 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.
+2. Run the tests and provide the actual successful results as structured verification before completion.
+3. If the environment is broken (Docker down, browser missing, port busy, dependencies absent), do NOT mark the task done. Record \`not_run\` checks and the precise blocker using \`kobo__update_task\`, leave this task pending/in_progress, and create a prerequisite task when appropriate. A test source file by itself is not a verified result.
+4. The code-review gate still applies. Review both the relevance of the test and the evidence that it passed.
+
 `;
 }
 export const AUTO_LOOP_HARD_RULES = `Hard rules:

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

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

package/dist/shared/document-roots.js

@@ -0,0 +1,2 @@
+/** Shared allowlist for the HTTP browser and workspace MCP document tools. */
+export const DOCUMENT_DIRS = ['docs/plans', 'docs/superpowers', '.ai/thoughts', '.ai/handoffs'];

package/dist/shared/review.js

@@ -0,0 +1,6 @@
+export function reviewConfigurationChanged(a, b) {
+    return (a.engine !== b.engine ||
+        a.model !== b.model ||
+        a.reasoningEffort !== b.reasoningEffort ||
+        a.agentPermissionMode !== b.agentPermissionMode);
+}

package/dist/shared/session-handoff.js

@@ -0,0 +1,4 @@
+export function isHandoffPending(handoff) {
+    return !!handoff && handoff.state !== 'completed' && handoff.state !== 'cancelled';
+}
+export const HANDOFF_REPORT_MAX_CHARS = 24_000;

package/dist/shared/task-verification.js

@@ -0,0 +1,11 @@
+/** Read persisted evidence without inventing verification for legacy tasks. */
+export function parseTaskVerification(raw) {
+    if (!raw)
+        return null;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loicngr/kobo",
-  "version": "1.11.43",
+  "version": "1.11.45",
   "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",
@@ -69,15 +69,15 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.267",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.274",
     "@emnapi/core": "^1.11.3",
     "@emnapi/runtime": "^1.11.3",
-    "@hono/node-server": "^2.1.0",
+    "@hono/node-server": "^2.1.1",
     "@modelcontextprotocol/sdk": "^1.30.0",
-    "@openai/codex": "^0.152.0",
+    "@openai/codex": "^0.154.0",
     "better-sqlite3": "^13.0.3",
-    "cron-parser": "^5.7.0",
-    "hono": "^4.13.1",
+    "cron-parser": "^5.10.1",
+    "hono": "^4.13.8",
     "nanoid": "^6.0.1",
     "node-pty": "^1.1.0",
     "ws": "^8.21.3"
@@ -85,16 +85,16 @@
   "devDependencies": {
     "@biomejs/biome": "2.5.7",
     "@types/better-sqlite3": "^9.6.0",
-    "@types/node": "^26.2.0",
+    "@types/node": "^26.6.1",
     "@types/ws": "^8.18.1",
-    "@vitest/runner": "^4.1.10",
-    "concurrently": "^10.0.4",
-    "tsx": "^4.23.11",
+    "@vitest/runner": "^4.1.11",
+    "concurrently": "^10.0.5",
+    "tsx": "^4.23.13",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.10"
+    "vitest": "^4.1.11"
   },
   "overrides": {
-    "@hono/node-server": "^2.1.0",
+    "@hono/node-server": "^2.1.1",
     "shell-quote": "^1.10.0"
   }
 }