@loicngr/kobo 1.6.8 → 1.6.10

package/AGENTS.md

@@ -96,15 +96,18 @@ src/
 
 | Table | Purpose |
 |---|---|
-| `workspaces` | the unit of work — id, name, project_path, source_branch, working_branch, status, notion_url, model, dev_server_status, `archived_at`, timestamps |
+| `workspaces` | the unit of work — id, name, project_path, source_branch, working_branch, status, notion_url, model, dev_server_status, `archived_at`, `auto_loop`, `auto_loop_ready`, `no_progress_streak`, timestamps |
 | `tasks` | workspace sub-items — title, status, `is_acceptance_criterion`, sort_order; CASCADE DELETE on workspace |
 | `agent_sessions` | Claude Code CLI invocations — pid, `claude_session_id`, status, started_at, ended_at, `name` |
 | `ws_events` | persisted WebSocket events for replay on reconnect — type, payload, session_id, created_at |
+| `pending_wakeups` | one-row-per-workspace scheduler for the `ScheduleWakeup` tool — target_at (ISO UTC), prompt, reason; CASCADE DELETE on workspace |
 
 `status` enum: `created | extracting | brainstorming | executing | completed | idle | error | quota`. Transitions are validated in `updateWorkspaceStatus` against `VALID_TRANSITIONS`.
 
 `archived_at` is **orthogonal** to `status` — archiving is a visibility flag, not a lifecycle state. Unarchive restores the exact pre-archive `status`.
 
+`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.
+
 ## Database migrations
 
 **The project is in production**. Every schema change MUST ship as an incremental migration that preserves existing data. Never drop-and-recreate, never rely on `initSchema` alone to patch running databases.

package/README.md

@@ -12,7 +12,7 @@ Think of it as an apprentice's hall: you hand out missions, each apprentice sets
 ## Features
 
 - **Isolated git worktrees** — every workspace runs on its own branch in its own directory, so concurrent Claude sessions never step on each other
-- **Pluggable agent engine** — Kōbō talks to agents through an `AgentEngine` contract with a normalised `AgentEvent` stream (`src/server/services/agent/engines/`). Claude Code is the first engine; dropping in another runtime (e.g. the Claude Agent SDK) only requires a new adapter, not a rewrite of the UI or orchestration layer
+- **Pluggable agent engine** — Kōbō talks to agents through an `AgentEngine` contract with a normalised `AgentEvent` stream (`src/server/services/agent/engines/`). Claude Code is the first engine; dropping in another runtime (e.g. the Claude Agent SDK) only requires a new adapter, not a rewrite of the UI or orchestration layer. Migration to the official Claude Agent SDK is tracked in [#9](https://github.com/loicngr/Kobo/issues/9)
 - **Rich chat feed** — live streaming text, thinking blocks, inline tool calls with expandable diffs for Edit/Write, per-turn session cards, markdown rendering, jump-to-previous-user-message button, and infinite scroll-up over persisted history
 - **Task & acceptance criteria tracking** — the agent reports progress through a dedicated MCP server (`kobo-tasks`) that reads and updates tasks directly from the SQLite database
 - **Documents panel** — tree view in the right drawer that surfaces every AI-generated markdown file under `docs/plans/`, `docs/superpowers/`, and `.ai/thoughts/`. Paths mentioned in chat messages are auto-detected against the catalogue and become one-click deep-links into the panel
@@ -30,6 +30,9 @@ Think of it as an apprentice's hall: you hand out missions, each apprentice sets
 - **Resizable right drawer** — drag-to-resize horizontally and vertically, with tab state and split ratio persisted to localStorage
 - **Soft interrupt** — pause an agent mid-execution (SIGINT, like pressing Escape in Claude Code) without killing the process; the agent stops the current tool and waits for the next message
 - **Archive instead of delete** — soft-remove workspaces without losing the worktree, branches, or history; unarchive restores the exact pre-archive state
+- **Auto-loop mode** — opt-in, per-workspace: when enabled, Kōbō spawns a fresh Claude session for the next pending task after every `session:ended`, walking through the task list until all are `done`. Stops automatically on error, on stall (3 consecutive sessions with no task completed), or when the user clicks Stop. A grooming step (`/kobo-prep-autoloop`) ensures tasks are atomic before the loop runs; Notion-imported workspaces with both todos and acceptance criteria are auto-unlocked
+- **Quota-aware retry backoff** — when a Claude rate limit is hit mid-session, Kōbō schedules the retry at the actual reset time reported by the API (via `rate_limit.info.buckets[].resetsAt`), falling back to a 15 → 30 → 60 → 180 → 300 min ladder only when the reset info is missing or implausible
+- **Scheduled wakeups** — the `ScheduleWakeup` tool is honoured server-side: Kōbō persists the wakeup in SQLite, rehydrates on restart, and respawns the agent with `--resume` at the target time
 
 ## Tech stack
 

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

@@ -18,6 +18,22 @@ export function listTasksHandler(db, workspaceId) {
         .all(workspaceId);
     return rows.map(rowToDto);
 }
+/**
+ * Flip the workspace's `auto_loop_ready` flag. Called at the end of a
+ * `/kobo-prep-autoloop` grooming session to unlock the auto-loop toggle.
+ *
+ * The DB write itself happens here; the caller in kobo-tasks-server.ts
+ * also fires a notify-autoloop-ready POST so the backend emits
+ * `autoloop:ready-flipped` over WebSocket and any live frontend refreshes.
+ */
+export function markAutoLoopReadyHandler(db, workspaceId) {
+    const row = db.prepare('SELECT id FROM workspaces WHERE id = ?').get(workspaceId);
+    if (!row) {
+        throw new Error(`Workspace '${workspaceId}' not found`);
+    }
+    db.prepare('UPDATE workspaces SET auto_loop_ready = 1 WHERE id = ?').run(workspaceId);
+    return { ok: true };
+}
 /** Set a task's status to "done" and return the updated task. */
 export function markTaskDoneHandler(db, workspaceId, taskId) {
     const now = new Date().toISOString();
@@ -136,7 +152,7 @@ export function getSettingsHandler(settingsPath, projectPath) {
 /** Fetch workspace metadata from the database, computing the worktree path from project_path and working_branch. */
 export function getWorkspaceInfoHandler(db, workspaceId) {
     const row = db
-        .prepare('SELECT id, name, project_path, source_branch, working_branch, status, notion_url, notion_page_id, model, dev_server_status, has_unread, created_at, updated_at FROM workspaces WHERE id = ?')
+        .prepare('SELECT id, name, project_path, source_branch, working_branch, status, notion_url, notion_page_id, model, dev_server_status, has_unread, auto_loop, auto_loop_ready, created_at, updated_at FROM workspaces WHERE id = ?')
         .get(workspaceId);
     if (!row) {
         throw new Error(`Workspace '${workspaceId}' not found`);
@@ -154,6 +170,8 @@ export function getWorkspaceInfoHandler(db, workspaceId) {
         notionPageId: row.notion_page_id,
         devServerStatus: row.dev_server_status,
         hasUnread: row.has_unread === 1,
+        autoLoop: row.auto_loop === 1,
+        autoLoopReady: row.auto_loop_ready === 1,
         createdAt: row.created_at,
         updatedAt: row.updated_at,
     };

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

@@ -5,7 +5,7 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import Database from 'better-sqlite3';
-import { createTaskHandler, deleteTaskHandler, getDevServerStatusHandler, getSessionUsageHandler, getSettingsHandler, getWorkspaceInfoHandler, listDocumentsHandler, listTasksHandler, listWorkspaceImagesHandler, logThoughtHandler, markTaskDoneHandler, readDocumentHandler, updateTaskHandler, } from './kobo-tasks-handlers.js';
+import { createTaskHandler, deleteTaskHandler, getDevServerStatusHandler, getSessionUsageHandler, getSettingsHandler, getWorkspaceInfoHandler, listDocumentsHandler, listTasksHandler, listWorkspaceImagesHandler, logThoughtHandler, markAutoLoopReadyHandler, markTaskDoneHandler, readDocumentHandler, updateTaskHandler, } from './kobo-tasks-handlers.js';
 const workspaceId = process.env.KOBO_WORKSPACE_ID;
 const dbPath = process.env.KOBO_DB_PATH;
 const settingsPath = process.env.KOBO_SETTINGS_PATH;
@@ -52,6 +52,22 @@ async function notifyTasksUpdated() {
         console.error('[kobo-tasks-server] notify-updated failed:', err);
     }
 }
+/**
+ * Fire-and-forget POST that lands on `/auto-loop-ready`, which itself emits
+ * the `autoloop:ready-flipped` WS event so the frontend's toggle unlocks
+ * immediately after the grooming session completes. The handler already
+ * flipped the DB flag; this call is ONLY for the event emission + the
+ * (harmless) idempotent second write.
+ */
+async function notifyAutoLoopReady() {
+    try {
+        const url = `${backendUrl}/api/workspaces/${workspaceId}/auto-loop-ready`;
+        await fetch(url, { method: 'POST' });
+    }
+    catch (err) {
+        console.error('[kobo-tasks-server] notify-autoloop-ready failed:', err);
+    }
+}
 /** Generic HTTP request to the Kobo backend, returning parsed JSON or null. */
 async function backendRequest(method, pathname, body) {
     const url = `${backendUrl}${pathname}`;
@@ -87,6 +103,11 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: ['task_id'],
             },
         },
+        {
+            name: 'mark_auto_loop_ready',
+            description: 'CALL ONLY at the end of a `/kobo-prep-autoloop` grooming session, once all tasks look atomic and implementable in one session. Flips a flag on the workspace that unlocks the auto-loop toggle in the UI. Do NOT call during normal sessions.',
+            inputSchema: { type: 'object', properties: {}, required: [] },
+        },
         {
             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.',
@@ -296,6 +317,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             void notifyBackend(taskId);
             return ok(result);
         }
+        if (name === 'mark_auto_loop_ready') {
+            const result = markAutoLoopReadyHandler(db, workspaceId);
+            void notifyAutoLoopReady();
+            return ok(result);
+        }
         if (name === 'create_task') {
             const title = a.title;
             if (!title)

package/dist/server/db/migrations.js

@@ -101,6 +101,28 @@ export const migrations = [
         )`).run();
         },
     },
+    {
+        version: 12,
+        name: 'add-auto-loop-columns',
+        migrate: (db) => {
+            db.transaction(() => {
+                db.prepare('ALTER TABLE workspaces ADD COLUMN auto_loop INTEGER NOT NULL DEFAULT 0').run();
+                db.prepare('ALTER TABLE workspaces ADD COLUMN auto_loop_ready INTEGER NOT NULL DEFAULT 0').run();
+                db.prepare('ALTER TABLE workspaces ADD COLUMN no_progress_streak INTEGER NOT NULL DEFAULT 0').run();
+            })();
+        },
+    },
+    {
+        version: 13,
+        name: 'add-permission-profile-column',
+        migrate: (db) => {
+            // 'bypass' (default, pre-existing behavior) or 'strict' (respects
+            // the project's .claude/settings.json allow/deny lists — needed when
+            // the user wants to authorize writes under .claude/** or .github/workflows/**
+            // which the CLI hard-denies under --dangerously-skip-permissions).
+            db.prepare("ALTER TABLE workspaces ADD COLUMN permission_profile TEXT NOT NULL DEFAULT 'bypass'").run();
+        },
+    },
 ];
 /** 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/schema.js

@@ -19,6 +19,10 @@ export function initSchema(db) {
       favorited_at TEXT,
       tags TEXT NOT NULL DEFAULT '[]',
       engine TEXT NOT NULL DEFAULT 'claude-code',
+      auto_loop INTEGER NOT NULL DEFAULT 0,
+      auto_loop_ready INTEGER NOT NULL DEFAULT 0,
+      no_progress_streak INTEGER NOT NULL DEFAULT 0,
+      permission_profile TEXT NOT NULL DEFAULT 'bypass',
       created_at TEXT NOT NULL,
       updated_at TEXT NOT NULL
     );

package/dist/server/index.js

@@ -21,6 +21,7 @@ import settingsRouter from './routes/settings.js';
 import templatesRouter from './routes/templates.js';
 import workspacesRouter from './routes/workspaces.js';
 import { getAvailableSkills, reconcileOrphanSessions, sendMessage, setBackendPort, startAgent, startWatchdog, stopAgent, stopWatchdog, } from './services/agent/orchestrator.js';
+import * as autoLoopService from './services/auto-loop-service.js';
 import { runContentMigrationIfNeeded } from './services/content-migration-service.js';
 import { createDailyDbBackupIfNeeded } from './services/db-backup-service.js';
 import { startDevServer, stopDevServer } from './services/dev-server-service.js';
@@ -59,6 +60,7 @@ initProcessCleanup();
 reconcileOrphanSessions();
 startWatchdog();
 wakeupService.rehydrate();
+autoLoopService.rehydrate();
 startPrWatcher();
 // Create Hono app
 const app = new Hono();

package/dist/server/routes/images.js

@@ -1,3 +1,5 @@
+import fs from 'node:fs';
+import path from 'node:path';
 import { Hono } from 'hono';
 import * as imageService from '../services/image-service.js';
 import * as workspaceService from '../services/workspace-service.js';
@@ -5,6 +7,14 @@ import * as workspaceService from '../services/workspace-service.js';
 const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10 MB
 /** MIME types accepted for image uploads. */
 const ALLOWED_MIME_TYPES = new Set(['image/png', 'image/jpeg', 'image/gif', 'image/webp']);
+/** File extension → MIME type, used to serve uploaded images back to the frontend. */
+const EXT_TO_MIME = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+};
 /** Hono sub-router for workspace image upload and deletion. */
 const app = new Hono();
 // POST /:id/images — upload an image
@@ -37,6 +47,55 @@ app.post('/:id/images', async (c) => {
         return c.json({ error: message }, 500);
     }
 });
+// GET /:id/images/file?path=.ai/images/<file>
+// Serve an uploaded image file from the worktree so the chat feed can show
+// inline previews for `[image: <path>]` tokens the user pastes in messages.
+//
+// Security: only paths under `.ai/images/` are served, the resolved absolute
+// path must stay inside the worktree's images directory (defense against
+// `..` traversal and absolute paths). Anything outside → 400.
+app.get('/:id/images/file', async (c) => {
+    try {
+        const { id } = c.req.param();
+        const workspace = workspaceService.getWorkspace(id);
+        if (!workspace) {
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        }
+        const requested = c.req.query('path');
+        if (!requested || typeof requested !== 'string') {
+            return c.json({ error: 'Missing required query param: path' }, 400);
+        }
+        // Allowlist: only the upload storage layout is served. No symlink escape
+        // either — we resolve and check containment.
+        if (!/^(\.ai\/images\/|images\/)[^/]/.test(requested) || requested.includes('..')) {
+            return c.json({ error: 'Invalid or disallowed image path' }, 400);
+        }
+        const worktreePath = `${workspace.projectPath}/.worktrees/${workspace.workingBranch}`;
+        const imagesRoot = path.resolve(worktreePath, '.ai/images');
+        const fullPath = path.resolve(worktreePath, requested);
+        // Containment check: fullPath must be a descendant of imagesRoot. `+ path.sep`
+        // guards against prefix collisions (`.../images-evil`).
+        if (fullPath !== imagesRoot && !fullPath.startsWith(imagesRoot + path.sep)) {
+            return c.json({ error: 'Path escapes images root' }, 400);
+        }
+        let buffer;
+        try {
+            buffer = await fs.promises.readFile(fullPath);
+        }
+        catch {
+            return c.json({ error: 'Image not found' }, 404);
+        }
+        const mime = EXT_TO_MIME[path.extname(fullPath).toLowerCase()] ?? 'application/octet-stream';
+        c.header('Content-Type', mime);
+        // Uploads are immutable content-addressed (uid filename) — cache aggressively.
+        c.header('Cache-Control', 'private, max-age=3600, immutable');
+        return c.body(new Uint8Array(buffer));
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
 // DELETE /:id/images/:uid — delete an uploaded image
 app.delete('/:id/images/:uid', async (c) => {
     try {

package/dist/server/routes/workspaces.js

@@ -4,10 +4,12 @@ const execFileAsync = promisify(execFileCb);
 import fs from 'node:fs';
 import path from 'node:path';
 import { Hono } from 'hono';
+import { AUTO_LOOP_GROOMING_STEPS, AUTO_LOOP_HARD_RULES } from '../../shared/auto-loop-prompts.js';
 import { getDb } from '../db/index.js';
 import { migrationGuard } from '../middleware/migration-guard.js';
 import { listEngines } from '../services/agent/engines/registry.js';
 import * as agentManager from '../services/agent/orchestrator.js';
+import * as autoLoopService from '../services/auto-loop-service.js';
 import * as devServerService from '../services/dev-server-service.js';
 import * as notionService from '../services/notion-service.js';
 import { renderPrTemplate } from '../services/pr-template-service.js';
@@ -453,7 +455,23 @@ app.post('/', migrationGuard, async (c) => {
                 brainstormPrompt += `\n# Git conventions\nIMPORTANT: Before any git operation (commit, branch, rebase, merge, push), read and apply the conventions defined in \`.ai/.git-conventions.md\`. They are project-specific and override any default behavior. Re-read this file if you're unsure or if context was compacted.\n`;
             }
             brainstormPrompt += `\nIMPORTANT: Start by reading CLAUDE.md and/or AGENTS.md at the project root if they exist — they contain project conventions and instructions you must follow.`;
-            brainstormPrompt += `\n\nThen brainstorm the implementation approach. Explore the codebase to understand the existing structure. Ask clarifying questions if needed. When you're done brainstorming and have a clear plan, create a plan file and proceed with implementation. Once you have completed the brainstorming phase, output [BRAINSTORM_COMPLETE] on its own line.`;
+            if (body.autoLoop === true) {
+                // Auto-loop is armed — brainstorm must end with task seeding + mark-ready,
+                // NOT with implementation. The auto-loop will drive implementation after.
+                // The grooming steps + hard rules are shared with the PREP_AUTOLOOP_PROMPT
+                // sent by the "Prepare for auto-loop" button (src/shared/auto-loop-prompts.ts).
+                brainstormPrompt += `\n\nThen brainstorm the implementation approach. Explore the codebase to understand the existing structure. Ask clarifying questions if needed. When you have a clear plan, create a plan file.
+
+Auto-loop mode is active for this workspace. After the plan is ready, DO NOT implement anything. Instead:
+
+${AUTO_LOOP_GROOMING_STEPS}
+5. Output [BRAINSTORM_COMPLETE] on its own line and end your turn cleanly.
+
+${AUTO_LOOP_HARD_RULES}`;
+            }
+            else {
+                brainstormPrompt += `\n\nThen brainstorm the implementation approach. Explore the codebase to understand the existing structure. Ask clarifying questions if needed. When you're done brainstorming and have a clear plan, create a plan file and proceed with implementation. Once you have completed the brainstorming phase, output [BRAINSTORM_COMPLETE] on its own line.`;
+            }
             try {
                 const agent = agentManager.startAgent(workspace.id, worktreePath, brainstormPrompt, workspace.model, false, workspace.permissionMode, undefined, workspace.reasoningEffort);
                 // Persist the initial prompt in the feed so it's visible in the chat,
@@ -471,6 +489,22 @@ app.post('/', migrationGuard, async (c) => {
                 }
             }
         }
+        // Apply the auto-loop checkbox from CreatePage. Notion-imported workspaces
+        // with both todos AND gherkin features auto-unlock `auto_loop_ready=1` —
+        // they're considered good enough to drive the loop without grooming.
+        if (body.autoLoop === true) {
+            const notionProducedTasks = body.notionUrl !== undefined &&
+                notionContent != null &&
+                notionContent.todos.length > 0 &&
+                notionContent.gherkinFeatures.length > 0;
+            const db = getDb();
+            db.prepare('UPDATE workspaces SET auto_loop = 1, auto_loop_ready = ? WHERE id = ?').run(notionProducedTasks ? 1 : 0, workspace.id);
+            // Emit events so the frontend refreshes autoLoopStates without F5.
+            wsService.emitEphemeral(workspace.id, 'autoloop:enabled', {});
+            if (notionProducedTasks) {
+                wsService.emitEphemeral(workspace.id, 'autoloop:ready-flipped', {});
+            }
+        }
         // Return created workspace with tasks
         const workspaceWithTasks = workspaceService.getWorkspaceWithTasks(workspace.id);
         return c.json(workspaceWithTasks, 201);
@@ -531,6 +565,81 @@ app.get('/pr-states', (c) => {
         return c.json({ error: message }, 500);
     }
 });
+// GET /api/workspaces/auto-loop-states — batch snapshot keyed by workspace id.
+// Used by the drawer + Pinia store. Static path — must be BEFORE /:id.
+app.get('/auto-loop-states', (c) => {
+    try {
+        const db = getDb();
+        const rows = db
+            .prepare('SELECT id, auto_loop, auto_loop_ready, no_progress_streak FROM workspaces WHERE archived_at IS NULL')
+            .all();
+        const out = {};
+        for (const r of rows) {
+            out[r.id] = {
+                auto_loop: r.auto_loop === 1,
+                auto_loop_ready: r.auto_loop_ready === 1,
+                no_progress_streak: r.no_progress_streak,
+            };
+        }
+        return c.json(out);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
+// GET /api/workspaces/:id/auto-loop — current auto-loop status for one workspace.
+app.get('/:id/auto-loop', (c) => {
+    try {
+        return c.json(autoLoopService.getStatus(c.req.param('id')));
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
+// POST /api/workspaces/:id/auto-loop — enable the loop (user toggle ON).
+app.post('/:id/auto-loop', (c) => {
+    try {
+        autoLoopService.enable(c.req.param('id'));
+        return c.json({ ok: true });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 400);
+    }
+});
+// DELETE /api/workspaces/:id/auto-loop — disable the loop (user toggle OFF).
+app.delete('/:id/auto-loop', (c) => {
+    try {
+        autoLoopService.disable(c.req.param('id'), 'user-action');
+        return c.json({ ok: true });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
+// POST /api/workspaces/:id/auto-loop-ready — force auto_loop_ready=true.
+// Used by the "Force ready (skip grooming)" UI button AND by the MCP tool
+// `kobo__mark_auto_loop_ready` at the end of a grooming session. Emits a
+// WS event so any live frontend refreshes the toggle state immediately.
+app.post('/:id/auto-loop-ready', (c) => {
+    try {
+        const id = c.req.param('id');
+        const ws = workspaceService.getWorkspace(id);
+        if (!ws)
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        workspaceService.setAutoLoopReady(id, true);
+        wsService.emitEphemeral(id, 'autoloop:ready-flipped', {});
+        autoLoopService.onAutoLoopReadySet(id);
+        return c.json({ ok: true });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
 // GET /api/workspaces/:id/pending-wakeup — returns the pending wakeup or null.
 app.get('/:id/pending-wakeup', (c) => {
     try {
@@ -747,6 +856,9 @@ app.get('/:id/events', (c) => {
             return c.json({ error: `Workspace '${id}' not found` }, 404);
         }
         const before = c.req.query('before'); // event ID cursor
+        // optional: scope to a session view. Session views also include
+        // workspace-level rows where session_id IS NULL (legacy/pre-session items).
+        const session = c.req.query('session');
         const limit = Math.min(parseInt(c.req.query('limit') ?? '100', 10) || 100, 500);
         const db = getDb();
         let rows;
@@ -756,18 +868,29 @@ app.get('/:id/events', (c) => {
             if (!cursorRow) {
                 return c.json({ events: [], hasMore: false });
             }
-            rows = db
-                .prepare('SELECT * FROM ws_events WHERE workspace_id = ? AND rowid < ? ORDER BY rowid DESC LIMIT ?')
-                .all(id, cursorRow.rowid, limit);
+            rows = session
+                ? db
+                    .prepare('SELECT * FROM ws_events WHERE workspace_id = ? AND (session_id = ? OR session_id IS NULL) AND rowid < ? ORDER BY rowid DESC LIMIT ?')
+                    .all(id, session, cursorRow.rowid, limit)
+                : db
+                    .prepare('SELECT * FROM ws_events WHERE workspace_id = ? AND rowid < ? ORDER BY rowid DESC LIMIT ?')
+                    .all(id, cursorRow.rowid, limit);
         }
         else {
-            // No cursor — return the oldest events
-            rows = db
-                .prepare('SELECT * FROM ws_events WHERE workspace_id = ? ORDER BY rowid ASC LIMIT ?')
-                .all(id, limit);
-        }
-        // Reverse to chronological order (we queried DESC for "before" pagination)
-        if (before)
+            // No cursor — return events. When filtering by session, we want the
+            // MOST RECENT events of that session first (so the feed renders from
+            // the end), reversed to chronological order below.
+            rows = session
+                ? db
+                    .prepare('SELECT * FROM ws_events WHERE workspace_id = ? AND (session_id = ? OR session_id IS NULL) ORDER BY rowid DESC LIMIT ?')
+                    .all(id, session, limit)
+                : db
+                    .prepare('SELECT * FROM ws_events WHERE workspace_id = ? ORDER BY rowid ASC LIMIT ?')
+                    .all(id, limit);
+        }
+        // Reverse to chronological order (we queried DESC for "before" pagination,
+        // or for the "session + no cursor" case where we fetched the newest first).
+        if (before || session)
             rows.reverse();
         const events = rows.map((row) => {
             let parsedPayload;
@@ -788,13 +911,25 @@ app.get('/:id/events', (c) => {
         });
         // Check if there are more older events beyond what we returned
         let hasMore = false;
-        if (before && rows.length > 0) {
-            const firstRow = db.prepare('SELECT rowid FROM ws_events WHERE id = ?').get(rows[0].id);
-            if (firstRow) {
-                const older = db
-                    .prepare('SELECT COUNT(*) as c FROM ws_events WHERE workspace_id = ? AND rowid < ?')
-                    .get(id, firstRow.rowid);
-                hasMore = older.c > 0;
+        if (rows.length > 0) {
+            if (before) {
+                const firstRow = db.prepare('SELECT rowid FROM ws_events WHERE id = ?').get(rows[0].id);
+                if (firstRow) {
+                    const older = session
+                        ? db
+                            .prepare('SELECT COUNT(*) as c FROM ws_events WHERE workspace_id = ? AND (session_id = ? OR session_id IS NULL) AND rowid < ?')
+                            .get(id, session, firstRow.rowid)
+                        : db
+                            .prepare('SELECT COUNT(*) as c FROM ws_events WHERE workspace_id = ? AND rowid < ?')
+                            .get(id, firstRow.rowid);
+                    hasMore = older.c > 0;
+                }
+            }
+            else if (session) {
+                const total = db
+                    .prepare('SELECT COUNT(*) as c FROM ws_events WHERE workspace_id = ? AND (session_id = ? OR session_id IS NULL)')
+                    .get(id, session);
+                hasMore = total.c > rows.length;
             }
         }
         return c.json({ events, hasMore });
@@ -898,6 +1033,12 @@ app.patch('/:id', migrationGuard, async (c) => {
             }
             updated = workspaceService.updateWorkspacePermissionMode(id, body.permissionMode);
         }
+        if (body.permissionProfile !== undefined) {
+            if (body.permissionProfile !== 'bypass' && body.permissionProfile !== 'strict') {
+                return c.json({ error: "Invalid permission profile. Must be 'bypass' or 'strict'." }, 400);
+            }
+            updated = workspaceService.setPermissionProfile(id, body.permissionProfile);
+        }
         if (body.status) {
             updated = workspaceService.updateWorkspaceStatus(id, body.status);
         }
@@ -908,8 +1049,9 @@ app.patch('/:id', migrationGuard, async (c) => {
             body.model === undefined &&
             body.reasoningEffort === undefined &&
             body.permissionMode === undefined &&
+            body.permissionProfile === undefined &&
             body.name === undefined) {
-            return c.json({ error: 'Missing field: status, model, reasoningEffort, permissionMode, or name' }, 400);
+            return c.json({ error: 'Missing field: status, model, reasoningEffort, permissionMode, permissionProfile, or name' }, 400);
         }
         return c.json(updated);
     }
@@ -1086,6 +1228,13 @@ app.delete('/:id', migrationGuard, async (c) => {
         catch {
             // Terminal may not exist — ignore
         }
+        // Collected best-effort warnings: the DB deletion always proceeds, but
+        // side-effects (worktree, local/remote branches) can fail independently.
+        // We surface a user-friendly message per failure so the UI can show a
+        // sticky toast with a copy-pasteable recovery command — common case:
+        // Docker leaves root-owned files inside the worktree, git worktree
+        // remove fails with EACCES.
+        const warnings = [];
         // Remove worktree
         const worktreesDir = `${workspace.projectPath}/.worktrees`;
         const worktreePath = `${worktreesDir}/${workspace.workingBranch}`;
@@ -1095,6 +1244,11 @@ app.delete('/:id', migrationGuard, async (c) => {
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
             console.error(`[workspaces] Failed to remove worktree: ${message}`);
+            warnings.push(`Failed to remove worktree directory '${worktreePath}'. The git entry may still reference it. ` +
+                `Fix manually:\n` +
+                `  sudo rm -rf '${worktreePath}'\n` +
+                `  cd '${workspace.projectPath}' && git worktree prune\n` +
+                `Reason: ${message}`);
         }
         // Delete local branch if requested
         if (body.deleteLocalBranch) {
@@ -1104,6 +1258,9 @@ app.delete('/:id', migrationGuard, async (c) => {
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
                 console.error(`[workspaces] Failed to delete local branch: ${message}`);
+                warnings.push(`Failed to delete local branch '${workspace.workingBranch}'. Fix manually:\n` +
+                    `  cd '${workspace.projectPath}' && git branch -D '${workspace.workingBranch}'\n` +
+                    `Reason: ${message}`);
             }
         }
         // Delete remote branch if requested
@@ -1114,11 +1271,20 @@ app.delete('/:id', migrationGuard, async (c) => {
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
                 console.error(`[workspaces] Failed to delete remote branch: ${message}`);
+                warnings.push(`Failed to delete remote branch '${workspace.workingBranch}'. Fix manually:\n` +
+                    `  cd '${workspace.projectPath}' && git push origin --delete '${workspace.workingBranch}'\n` +
+                    `Reason: ${message}`);
             }
         }
         // Delete workspace from DB (cascades to tasks, sessions, events)
         workspaceService.deleteWorkspace(id);
-        return new Response(null, { status: 204 });
+        // When everything worked cleanly we keep the legacy 204 response so
+        // existing clients aren't surprised by a JSON body. Warnings promote the
+        // response to 200 so the body is readable.
+        if (warnings.length === 0) {
+            return new Response(null, { status: 204 });
+        }
+        return c.json({ ok: true, warnings }, 200);
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
@@ -1364,6 +1530,20 @@ app.post('/:id/resync-branch', (c) => {
         if (!actual || actual === workspace.workingBranch) {
             return c.json({ ok: true, changed: false, workingBranch: workspace.workingBranch });
         }
+        // Branch was renamed in-place by the agent (`git branch -m ...`). The
+        // worktree directory is still at .worktrees/<old-name>; move it so it
+        // matches the new ref, otherwise Kōbō's path resolver (projectPath +
+        // .worktrees + workingBranch) breaks and subsequent session spawns fail
+        // with ENOENT on .mcp.json. Best-effort: if the move fails (dir already
+        // moved, lockfile, dirty tree), we still update the DB so git ops stay
+        // aligned with the current ref name — the user can repair the dir manually.
+        const newWorktreePath = path.join(workspace.projectPath, '.worktrees', actual);
+        try {
+            gitOps.moveWorktree(workspace.projectPath, worktreePath, newWorktreePath);
+        }
+        catch (err) {
+            console.error('[workspaces] resync-branch: moveWorktree failed (DB update proceeds):', err);
+        }
         const updated = workspaceService.updateWorkingBranch(id, actual);
         return c.json({ ok: true, changed: true, workingBranch: updated.workingBranch });
     }
@@ -1380,9 +1560,19 @@ app.post('/:id/push', async (c) => {
         if (!workspace) {
             return c.json({ error: `Workspace '${id}' not found` }, 404);
         }
+        const body = await c.req.json().catch(() => ({}));
+        const force = body?.force === true;
         const worktreePath = path.join(workspace.projectPath, '.worktrees', workspace.workingBranch);
         try {
-            gitOps.pushBranch(worktreePath, workspace.workingBranch);
+            // Only pass an options arg when force is requested — keeps the
+            // no-options call shape identical to before for callers/tests that
+            // assert on argument count.
+            if (force) {
+                gitOps.pushBranch(worktreePath, workspace.workingBranch, { force: true });
+            }
+            else {
+                gitOps.pushBranch(worktreePath, workspace.workingBranch);
+            }
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);

package/dist/server/services/agent/engines/claude-code/args-builder.js

@@ -24,6 +24,12 @@ export function buildClaudeArgs(input) {
     if (input.permissionMode === 'plan') {
         args.push('--permission-mode', 'plan');
     }
+    else if (input.permissionProfile === 'strict') {
+        // Strict profile: respect the project's settings.json allow/deny.
+        // `acceptEdits` auto-accepts Edit/Write but enforces the allow list,
+        // so `Edit(.claude/**)` and similar take effect (unlike in bypass mode).
+        args.push('--permission-mode', 'acceptEdits');
+    }
     else if (input.skipPermissions) {
         args.push('--dangerously-skip-permissions');
     }