@loicngr/kobo 1.11.43 → 1.11.44

package/AGENTS.md

@@ -116,6 +116,7 @@ src/
 | `tasks` | workspace sub-items: title, status, `is_acceptance_criterion`, sort_order; CASCADE DELETE on workspace |
 | `agent_sessions` | agent-engine sessions: pid where applicable, engine session id, status, timestamps, model, and name |
 | `ws_events` | persisted WebSocket events for replay on reconnect: type, payload, session_id, created_at |
+| `pending_review_returns` | one-shot return from a review to its original session and LLM configuration (migration v44) |
 | `pending_wakeups` | one-row-per-workspace scheduler for the `schedule_wakeup` MCP tool: target_at (ISO UTC), prompt, reason; CASCADE DELETE on workspace |
 | `pending_quota_backoffs` | persisted quota retries and their attempt counts |
 | `pending_crons` | recurring workspace schedules and their next run |
@@ -135,7 +136,11 @@ src/
 
 `worktree_purged_at` + `worktree_purge_restore_data` drive the disk-space purge feature (see [Worktree purge](#worktree-purge) below): when set, the workspace's worktree folder has been removed from disk but the chat history is preserved. `worktree_purge_restore_data` is a JSON blob (`{ prNumber, prUrl, forge, mergeCommitSha, originalWorktreePath, originalSourceBranch, originalWorkingBranch }`) captured at purge time for future "Restore" UX. Both fields are cleared automatically by the pr-watcher when the worktree folder reappears on disk.
 
-`auto_loop` (bool, default 0), `auto_loop_ready` (bool, default 0) and `no_progress_streak` (int, default 0) drive the auto-loop feature: when `auto_loop=1`, `session:ended` triggers `auto-loop-service.onSessionEnded` which either spawns the next iteration via a fresh `startAgent(resume=false)`, disables with `reason='completed'` (no pending tasks), or disables with `reason='stall'` (3 consecutive sessions without a task completed). Archive + delete both auto-disable.
+`auto_loop` preserves the user's execution intent. `auto_loop_runs` (migration v45) stores phase (`grooming | execution | finalization`), operational state (`active | waiting | blocked | completed | stopped`), iteration count and diagnostic recovery. `auto_loop_progress` records monotone task milestones; metadata changes are not progress. After three stagnant iterations, run one diagnostic and two further attempts, then block explicitly without clearing intent. Quotas wait for their actual reset, including multi-day windows; only transient failures use the retry cap. Archived/deleted workspaces disable the loop.
+
+Tasks have `role` (`work | finalization`) and structured `verification`. MCP and HTTP share transactional task mutations. An auto-loop task cannot become done without passing reported checks. Finalization runs after all other tasks/criteria, is invalidated by scope changes, and is mandatory before completion. The proof is agent-reported evidence, not server-side execution of arbitrary commands.
+
+`auto_loop_messages` durably queues next-iteration instructions, independently of engine session ids. A dispatch interrupted before confirmed completion becomes `unknown`, requiring explicit acknowledgement or retry. Unknown or in-flight instructions prevent completion. Actual engine closure (`EngineProcess.closed`), not a logical end event alone, releases controller ownership and permits the next writer.
 
 `brainstorm_model` (nullable, set only at creation) lets a workspace created with `auto_loop=1` run its initial brainstorming session on a different model than the auto-loop iterations that follow, while staying on the same engine. `POST /api/workspaces` uses it for the very first `startAgent` call only; every subsequent auto-loop iteration (`auto-loop-service.ts`'s `spawnNextIteration`) always reads `model`, unchanged. The switch to `model` takes effect once that first live session ends naturally — not at the `[BRAINSTORM_COMPLETE]` marker, since the same session keeps running under `brainstorm_model` until it stops on its own.
 
@@ -259,6 +264,36 @@ Background: the engine was migrated from `@openai/codex-sdk` (one-shot `codex ex
 
 ## Workspace operations
 
+### Review LLM and return to the original session
+
+The current conversation is the running session, or the last used session by
+`max(startedAt, endedAt)` after it stops. Keep the session list in creation order,
+but do not use its first entry to identify the current conversation: a temporary
+review can return to an older session. The stale-session banner and the next
+review's return target must recognize that original session, including on reload.
+
+`StartReviewDialog.vue` uses the shared model/effort/permission catalogues. Changed
+settings force a new session on both client and server. `review-service.ts`
+validates before side effects, waits for confirmed shutdown, then applies the
+selected configuration and launches the review. Without a return request, these
+settings remain the workspace defaults. Legacy requests retain their behavior.
+
+The optional `returnToSession` flag captures the exact resumable original session.
+`pending_review_returns` persists its configuration and the review session id
+before switching engines. The orchestrator intercepts a successful review end
+(including watchdog closure without a nonzero exit), restores configuration and
+resumes that exact native conversation with the reviewer's final text report.
+Resume selection is scoped to the target engine; never pass a reviewer's native
+conversation id to the original engine, even after cancellation or restart.
+The report reassembles text deltas/final snapshots, is bounded to 24,000 characters,
+and links back to the complete review session through the conversation tool.
+The receiving agent is asked to summarize and await instructions before fixes.
+The intent is consumed before delivery, preventing repeated ends from sending twice.
+Errors restore settings without automatically resuming; explicit stop cancels the
+return. Startup restores interrupted-review settings without replaying a possibly
+already-delivered handoff. Preserve these guards and the auto-loop interception.
+`workspace:configuration` is ephemeral and updates all four LLM settings across tabs.
+
 ### Delete confirmation
 
 The workspace deletion dialog requires the exact `workingBranch`, not the editable

package/CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to Kōbō are documented here. The format is based on
 [Keep a Changelog](https://keepachangelog.com/). Each release is an `## <version>`
 section — the in-app "What's new" dialog reads this file.
 
+## 1.11.44
+
+- chore(deps): update packages and node to 24.21.0
+- fix(auto-loop): preserve mission intent until verified completion
+- feat(review): configure review LLM and return to original session
+
 ## 1.11.43
 
 - fix(workspaces): refine watchdog stops and deletion confirmation

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

@@ -3,10 +3,12 @@ import path from 'node:path';
 import { nanoid } from 'nanoid';
 import * as cronService from '../server/services/cron-service.js';
 import * as settingsService from '../server/services/settings-service.js';
+import { createTaskRecord, deleteTaskRecord, updateTaskRecord, } from '../server/services/task-mutations.js';
 import { slugifyProjectName } from '../server/utils/project-slug.js';
 import { ensureDirectoryInside, resolveExistingPathInside } from '../server/utils/safe-path.js';
 import { resolveWorkspaceWorktreePath } from '../server/utils/worktree-paths.js';
 import { MASKED_SECRET, SECRET_GLOBAL_KEYS } from '../shared/consts.js';
+import { parseTaskVerification } from '../shared/task-verification.js';
 /** Allowed task status values. */
 export const VALID_TASK_STATUSES = ['pending', 'in_progress', 'done'];
 function rowToDto(row) {
@@ -15,12 +17,15 @@ function rowToDto(row) {
         title: row.title,
         status: row.status,
         is_acceptance_criterion: row.is_acceptance_criterion === 1,
+        sort_order: row.sort_order,
+        role: row.role,
+        verification: parseTaskVerification(row.verification),
     };
 }
 /** Return all tasks for a workspace, ordered by sort_order. */
 export function listTasksHandler(db, workspaceId) {
     const rows = db
-        .prepare('SELECT id, title, status, is_acceptance_criterion 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(rowToDto);
 }
@@ -81,86 +86,38 @@ export function setWorkspaceAgentDescriptionHandler(db, workspaceId, args) {
     }
     return { ok: true, description: stored };
 }
-/** Set a task's status to "done" and return the updated task. */
-export function markTaskDoneHandler(db, workspaceId, taskId) {
-    const now = new Date().toISOString();
-    const result = db
-        .prepare('UPDATE tasks SET status = ?, updated_at = ? WHERE id = ? AND workspace_id = ?')
-        .run('done', now, taskId, workspaceId);
-    if (result.changes === 0) {
-        throw new Error(`Task '${taskId}' not found in workspace '${workspaceId}'`);
-    }
-    const row = db
-        .prepare('SELECT id, title, status, is_acceptance_criterion FROM tasks WHERE id = ?')
-        .get(taskId);
+/** Set a task's status to done; auto-loop tasks require successful evidence. */
+export function markTaskDoneHandler(db, workspaceId, taskId, verification) {
+    const row = updateTaskRecord(db, workspaceId, taskId, {
+        status: 'done',
+        ...(verification !== undefined ? { verification } : {}),
+    });
     return { success: true, task: rowToDto(row) };
 }
-/** Create a new task appended at the end of the workspace's task list. */
+/** Create a task at an explicit position or append it to the list. */
 export function createTaskHandler(db, workspaceId, data) {
-    if (!data.title?.trim()) {
-        throw new Error('title is required');
-    }
-    // Verify workspace exists
-    const ws = db.prepare('SELECT id FROM workspaces WHERE id = ?').get(workspaceId);
-    if (!ws) {
-        throw new Error(`Workspace '${workspaceId}' not found`);
-    }
-    const id = nanoid();
-    const now = new Date().toISOString();
-    const isAC = data.is_acceptance_criterion ? 1 : 0;
-    // Append at the end: max(sort_order) + 1
-    const maxRow = db
-        .prepare('SELECT COALESCE(MAX(sort_order), -1) AS max FROM tasks WHERE workspace_id = ?')
-        .get(workspaceId);
-    const sortOrder = maxRow.max + 1;
-    db.prepare('INSERT INTO tasks (id, workspace_id, title, status, is_acceptance_criterion, sort_order, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)').run(id, workspaceId, data.title.trim(), 'pending', isAC, sortOrder, now, now);
-    const row = db.prepare('SELECT id, title, status, is_acceptance_criterion FROM tasks WHERE id = ?').get(id);
-    return rowToDto(row);
+    return rowToDto(createTaskRecord(db, workspaceId, {
+        title: data.title,
+        isAcceptanceCriterion: data.is_acceptance_criterion,
+        sortOrder: data.sort_order,
+        afterTaskId: data.after_task_id,
+        role: data.role,
+    }));
 }
-/** Update one or more fields of an existing task (title, status, or acceptance criterion flag). */
+/** Update task fields atomically, including insertion order and verification. */
 export function updateTaskHandler(db, workspaceId, taskId, data) {
-    // Verify task belongs to workspace
-    const existing = db.prepare('SELECT id FROM tasks WHERE id = ? AND workspace_id = ?').get(taskId, workspaceId);
-    if (!existing) {
-        throw new Error(`Task '${taskId}' not found in workspace '${workspaceId}'`);
-    }
-    const sets = [];
-    const values = [];
-    if (data.title !== undefined) {
-        if (!data.title.trim())
-            throw new Error('title cannot be empty');
-        sets.push('title = ?');
-        values.push(data.title.trim());
-    }
-    if (data.status !== undefined) {
-        if (!VALID_TASK_STATUSES.includes(data.status)) {
-            throw new Error(`Invalid status '${data.status}'. Must be one of: ${VALID_TASK_STATUSES.join(', ')}`);
-        }
-        sets.push('status = ?');
-        values.push(data.status);
-    }
-    if (data.is_acceptance_criterion !== undefined) {
-        sets.push('is_acceptance_criterion = ?');
-        values.push(data.is_acceptance_criterion ? 1 : 0);
-    }
-    if (sets.length === 0) {
-        throw new Error('No fields to update (provide title, status, or is_acceptance_criterion)');
-    }
-    sets.push('updated_at = ?');
-    values.push(new Date().toISOString());
-    values.push(taskId);
-    db.prepare(`UPDATE tasks SET ${sets.join(', ')} WHERE id = ?`).run(...values);
-    const row = db
-        .prepare('SELECT id, title, status, is_acceptance_criterion FROM tasks WHERE id = ?')
-        .get(taskId);
-    return rowToDto(row);
+    return rowToDto(updateTaskRecord(db, workspaceId, taskId, {
+        title: data.title,
+        status: data.status,
+        isAcceptanceCriterion: data.is_acceptance_criterion,
+        sortOrder: data.sort_order,
+        afterTaskId: data.after_task_id,
+        verification: data.verification,
+    }));
 }
-/** Permanently delete a task from a workspace. */
+/** Permanently delete a task from a workspace and invalidate its final review. */
 export function deleteTaskHandler(db, workspaceId, taskId) {
-    const result = db.prepare('DELETE FROM tasks WHERE id = ? AND workspace_id = ?').run(taskId, workspaceId);
-    if (result.changes === 0) {
-        throw new Error(`Task '${taskId}' not found in workspace '${workspaceId}'`);
-    }
+    deleteTaskRecord(db, workspaceId, taskId);
     return { success: true, task_id: taskId };
 }
 /** Read the dev-server status for a workspace directly from the database. */

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

@@ -113,20 +113,53 @@ async function backendRequest(method, pathname, body) {
     return text ? JSON.parse(text) : null;
 }
 const server = new Server({ name: 'kobo-tasks', version: '1.0.0' }, { capabilities: { tools: {} } });
+const TASK_VERIFICATION_SCHEMA = {
+    type: 'object',
+    description: 'Required to complete an auto-loop task. Describe checks actually performed; every check must be passed for done. Record failed/not_run checks only on an unfinished task.',
+    properties: {
+        method: { type: 'string', minLength: 1 },
+        summary: { type: 'string', minLength: 1 },
+        checks: {
+            type: 'array',
+            minItems: 1,
+            items: {
+                type: 'object',
+                properties: {
+                    name: { type: 'string', minLength: 1 },
+                    status: { type: 'string', enum: ['passed', 'failed', 'not_run'] },
+                },
+                required: ['name', 'status'],
+            },
+        },
+    },
+    required: ['method', 'summary', 'checks'],
+};
+const TASK_ORDER_PROPERTIES = {
+    sort_order: {
+        type: 'integer',
+        minimum: 0,
+        description: 'Insert/move at this order, shifting siblings. Omit to append on creation. Mutually exclusive with after_task_id.',
+    },
+    after_task_id: {
+        type: 'string',
+        description: 'Insert/move immediately after this task in the same workspace, preserving the remaining order.',
+    },
+};
 const WORKSPACE_SCOPED_TOOLS = [
     {
         name: 'list_tasks',
-        description: 'CALL FIRST on any non-trivial turn to know what the user wants done and what is already completed. Returns every task and acceptance criterion for the current workspace with its id and status. Re-call periodically (before marking something done, or after the user asks for a status) to stay in sync with user-added or external updates.',
+        description: 'CALL FIRST on any non-trivial turn to know what the user wants done and what is already completed. Returns every task and acceptance criterion for the current workspace with its id, status, sort_order, role, and verification evidence. Re-call periodically (before marking something done, or after the user asks for a status) to stay in sync with user-added or external updates.',
         inputSchema: { type: 'object', properties: {}, required: [] },
         annotations: { readOnlyHint: true, openWorldHint: false },
     },
     {
         name: 'mark_task_done',
-        description: 'CALL AS SOON AS a task or acceptance criterion is finished AND verified (tests pass, feature works, diff committed). Do not wait for the end of the turn — the user watches progress live and marking each item as it completes is the primary signal Kōbō uses to track you.',
+        description: 'CALL AS SOON AS a task or acceptance criterion is finished AND verified by checks actually performed. Auto-loop requires structured verification evidence with all checks passed. Never mark done if required checks failed or were not run. Finalization also requires all work tasks and criteria done. Do not wait for the end of the turn — the user watches progress live and marking each item as it completes is the primary signal Kōbō uses to track you.',
         inputSchema: {
             type: 'object',
             properties: {
                 task_id: { type: 'string', description: 'Task id from list_tasks.' },
+                verification: TASK_VERIFICATION_SCHEMA,
             },
             required: ['task_id'],
         },
@@ -140,10 +173,16 @@ const WORKSPACE_SCOPED_TOOLS = [
     },
     {
         name: 'create_task',
-        description: 'CALL WHEN you discover follow-up work that was not in the original list and needs to stick around (e.g. "refactor this helper later", "add a test for edge case"). Appends at the end of the list. Do not use it for ephemeral internal notes — prefer log_thought for those.',
+        description: 'CALL WHEN you discover follow-up work that was not in the original list and needs to stick around (e.g. "refactor this helper later", "add a test for edge case"). Appends by default; use after_task_id for a dependent check immediately after its parent. Use role finalization for the final verification gate. Do not use it for ephemeral internal notes — prefer log_thought for those.',
         inputSchema: {
             type: 'object',
             properties: {
+                ...TASK_ORDER_PROPERTIES,
+                role: {
+                    type: 'string',
+                    enum: ['work', 'finalization'],
+                    description: 'Default work. Finalization is the final verification gate and cannot finish while work/criteria remain open.',
+                },
                 title: { type: 'string', description: 'Short, imperative title (e.g. "Add retry to fetchUser").' },
                 is_acceptance_criterion: {
                     type: 'boolean',
@@ -161,6 +200,8 @@ const WORKSPACE_SCOPED_TOOLS = [
             type: 'object',
             properties: {
                 task_id: { type: 'string', description: 'Task id from list_tasks.' },
+                ...TASK_ORDER_PROPERTIES,
+                verification: TASK_VERIFICATION_SCHEMA,
                 title: { type: 'string', description: 'New title (optional).' },
                 status: {
                     type: 'string',
@@ -612,7 +653,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const taskId = a.task_id;
             if (!taskId)
                 return fail('task_id parameter is required');
-            const result = markTaskDoneHandler(db, workspaceId, taskId);
+            const result = markTaskDoneHandler(db, workspaceId, taskId, a.verification);
             void notifyBackend(taskId);
             return ok(result);
         }
@@ -627,7 +668,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 return fail('title parameter is required');
             const task = createTaskHandler(db, workspaceId, {
                 title,
+                role: a.role,
                 is_acceptance_criterion: a.is_acceptance_criterion,
+                sort_order: a.sort_order,
+                after_task_id: a.after_task_id,
             });
             void notifyTasksUpdated();
             return ok(task);
@@ -639,7 +683,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const task = updateTaskHandler(db, workspaceId, taskId, {
                 title: a.title,
                 status: a.status,
+                verification: a.verification,
                 is_acceptance_criterion: a.is_acceptance_criterion,
+                sort_order: a.sort_order,
+                after_task_id: a.after_task_id,
             });
             void notifyTasksUpdated();
             return ok(task);

package/dist/server/db/auto-loop-schema.js

@@ -0,0 +1,44 @@
+/** Shared by fresh installs and the append-only upgrade. */
+export function initAutoLoopSchema(db) {
+    const columns = db.prepare('PRAGMA table_info(tasks)').all();
+    if (columns.length) {
+        if (!columns.some((c) => c.name === 'role'))
+            db.exec("ALTER TABLE tasks ADD COLUMN role TEXT NOT NULL DEFAULT 'work'");
+        if (!columns.some((c) => c.name === 'verification'))
+            db.exec('ALTER TABLE tasks ADD COLUMN verification TEXT');
+        if (columns.some((c) => c.name === 'title')) {
+            db.exec("UPDATE tasks SET role = 'finalization' WHERE title LIKE '[FINAL] %' AND role = 'work'");
+        }
+    }
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS auto_loop_runs (
+      workspace_id TEXT PRIMARY KEY REFERENCES workspaces(id) ON DELETE CASCADE,
+      phase TEXT NOT NULL DEFAULT 'grooming',
+      state TEXT NOT NULL DEFAULT 'waiting',
+      reason TEXT,
+      iteration INTEGER NOT NULL DEFAULT 0,
+      diagnostic_attempts INTEGER NOT NULL DEFAULT 0,
+      current_task_id TEXT,
+      current_session_id TEXT,
+      updated_at TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS auto_loop_progress (
+      workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+      task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+      milestone INTEGER NOT NULL DEFAULT 0,
+      PRIMARY KEY (workspace_id, task_id)
+    );
+    CREATE TABLE IF NOT EXISTS auto_loop_messages (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+      client_message_id TEXT NOT NULL,
+      content TEXT NOT NULL,
+      source TEXT,
+      state TEXT NOT NULL DEFAULT 'pending',
+      session_id TEXT,
+      created_at TEXT NOT NULL,
+      UNIQUE (workspace_id, client_message_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_auto_loop_messages_pending ON auto_loop_messages(workspace_id, state, id);
+  `);
+}

package/dist/server/db/migrations.js

@@ -1,4 +1,6 @@
+import { initAutoLoopSchema } from './auto-loop-schema.js';
 import { initMcpMessageSchema } from './mcp-message-schema.js';
+import { initReviewReturnSchema } from './review-return-schema.js';
 import { initSchema } from './schema.js';
 import { initSearchSchema } from './search-schema.js';
 /** Ordered registry of all schema migrations. Append new entries at the end. */
@@ -744,6 +746,8 @@ export const migrations = [
     },
     { version: 42, name: 'index-logical-search-messages', migrate: initSearchSchema },
     { version: 43, name: 'durable-mcp-message-requests', migrate: initMcpMessageSchema },
+    { version: 44, name: 'review-session-returns', migrate: initReviewReturnSchema },
+    { version: 45, name: 'durable-auto-loop', migrate: initAutoLoopSchema },
 ];
 /** Current schema version — always equals the highest migration version. */
 export const SCHEMA_VERSION = migrations.length > 0 ? migrations[migrations.length - 1].version : 1;

package/dist/server/db/review-return-schema.js

@@ -0,0 +1,10 @@
+export function initReviewReturnSchema(db) {
+    db.exec(`CREATE TABLE IF NOT EXISTS pending_review_returns (
+    workspace_id TEXT PRIMARY KEY REFERENCES workspaces(id) ON DELETE CASCADE,
+    review_session_id TEXT NOT NULL REFERENCES agent_sessions(id) ON DELETE CASCADE,
+    original_session_id TEXT NOT NULL REFERENCES agent_sessions(id) ON DELETE CASCADE,
+    original_configuration TEXT NOT NULL,
+    review_configuration TEXT NOT NULL,
+    created_at TEXT NOT NULL
+  )`);
+}

package/dist/server/db/schema.js

@@ -1,4 +1,6 @@
+import { initAutoLoopSchema } from './auto-loop-schema.js';
 import { initMcpMessageSchema } from './mcp-message-schema.js';
+import { initReviewReturnSchema } from './review-return-schema.js';
 import { initSearchSchema } from './search-schema.js';
 /** Create all tables and indexes for a fresh install. Not used for upgrades -- see migrations.ts. */
 export function initSchema(db) {
@@ -225,4 +227,6 @@ export function initSchema(db) {
   `);
     initSearchSchema(db);
     initMcpMessageSchema(db);
+    initReviewReturnSchema(db);
+    initAutoLoopSchema(db);
 }

package/dist/server/index.js

@@ -41,6 +41,7 @@ import { reconcileMessageRequests } from './services/mcp-message-request-service
 import { authorizeWsUpgrade, generateToken, getLanHostnames, getLanUrls, isAllowedOrigin, isAllowedRequestHost, resolveBindHost, resolveDevClientOrigin, resolveNetworkAccessEnvOverrides, resolveProxyHostname, } from './services/network-access-service.js';
 import { startPrWatcher, stopPrWatcher } from './services/pr-watcher-service.js';
 import * as quotaBackoffService from './services/quota-backoff-service.js';
+import { reconcileReviewReturns } from './services/review-return-service.js';
 import { startSearchIndex, stopSearchIndex } from './services/search-service.js';
 import { getGlobalSettings, updateNetworkAccessSettings } from './services/settings-service.js';
 import { reloadDefaultTemplates } from './services/templates-service.js';
@@ -116,15 +117,7 @@ const dailyBackupScheduler = startDailyDbBackupScheduler(async () => {
 });
 // Initialize process cleanup, agent watchdog, PR watcher, and wakeup rehydration
 reconcileOrphanSessions();
-startWatchdog();
-wakeupService.rehydrate();
-autoLoopService.rehydrate();
-// Restore in-memory retry counts BEFORE re-arming the persisted backoff timers,
-// otherwise the next arm() after restart would compute the next ladder rung
-// from retryCount=0 and undo the progression.
-restoreRetryCountsFromDb();
-quotaBackoffService.restoreOnBoot((workspaceId, pending) => autoLoopService.onQuotaBackoffExpired(workspaceId, pending));
-cronService.restoreOnBoot();
+reconcileReviewReturns();
 // Deliver any new default prompt templates to existing installs (seed-once via the
 // seededDefaultSlugs watermark; never overwrites or re-adds deleted defaults).
 try {
@@ -229,6 +222,14 @@ const server = serve({
     hostname: bindHost,
 }, (info) => {
     setBackendPort(info.port);
+    // Restored agents receive the actual listening endpoint, including an
+    // ephemeral or SERVER_PORT-selected port. Quota ownership comes first.
+    restoreRetryCountsFromDb();
+    quotaBackoffService.restoreOnBoot((workspaceId, pending) => autoLoopService.onQuotaBackoffExpired(workspaceId, pending));
+    autoLoopService.rehydrate();
+    wakeupService.rehydrate();
+    cronService.restoreOnBoot();
+    startWatchdog();
     startUpdateChecker();
     stopStartupSpinner();
     const settings = getGlobalSettings();

package/dist/server/routes/auto-loop-messages.js

@@ -0,0 +1,51 @@
+import { Hono } from 'hono';
+import { listLoopMessages, resolveLoopMessage } from '../services/auto-loop-message-service.js';
+import { deliverWorkspaceMessage } from '../services/workspace-message-service.js';
+import { getWorkspace } from '../services/workspace-service.js';
+import { assertWorkspaceLifecycleAvailable } from '../utils/workspace-lifecycle-guard.js';
+const app = new Hono();
+app.get('/:id/auto-loop/messages', (c) => {
+    try {
+        const id = c.req.param('id');
+        if (!getWorkspace(id))
+            return c.json({ error: 'Workspace not found' }, 404);
+        return c.json(listLoopMessages(id));
+    }
+    catch (error) {
+        return c.json({ error: error instanceof Error ? error.message : String(error) }, 400);
+    }
+});
+app.post('/:id/auto-loop/messages', async (c) => {
+    try {
+        const body = await c.req.json();
+        if (typeof body.content !== 'string' || typeof body.clientMessageId !== 'string')
+            return c.json({ error: 'content and clientMessageId are required' }, 400);
+        await deliverWorkspaceMessage(c.req.param('id'), {
+            content: body.content,
+            clientMessageId: body.clientMessageId,
+            delivery: 'next_iteration',
+        });
+        return c.json({ accepted: true });
+    }
+    catch (error) {
+        return c.json({ error: error instanceof Error ? error.message : String(error) }, 400);
+    }
+});
+app.patch('/:id/auto-loop/messages/:messageId', async (c) => {
+    try {
+        const id = c.req.param('id');
+        assertWorkspaceLifecycleAvailable(id);
+        const workspace = getWorkspace(id);
+        if (!workspace || workspace.archivedAt || workspace.worktreePurgedAt)
+            return c.json({ error: 'Workspace unavailable' }, 409);
+        const { action } = await c.req.json();
+        if (!['cancel', 'acknowledge', 'retry'].includes(action))
+            return c.json({ error: 'Invalid resolution' }, 400);
+        resolveLoopMessage(id, Number(c.req.param('messageId')), action);
+        return c.json({ ok: true });
+    }
+    catch (error) {
+        return c.json({ error: error instanceof Error ? error.message : String(error) }, 400);
+    }
+});
+export default app;