@loicngr/kobo 1.6.15 → 1.7.1

package/dist/server/services/agent/session-controller.js

@@ -1,11 +1,13 @@
-import { getWorkspace, listTasks } from '../workspace-service.js';
 export class SessionController {
     workspaceId;
     agentSessionId;
     engine;
     onEvent;
-    engineProcess;
+    _engineProcess;
     _status = 'running';
+    get engineProcess() {
+        return this._engineProcess;
+    }
     constructor(workspaceId, agentSessionId, engine, onEvent) {
         this.workspaceId = workspaceId;
         this.agentSessionId = agentSessionId;
@@ -13,67 +15,36 @@ export class SessionController {
         this.onEvent = onEvent;
     }
     async start(options) {
-        if (this.engineProcess)
+        if (this._engineProcess)
             throw new Error('SessionController already started');
-        this.engineProcess = await this.engine.start(options, (ev) => this.handle(ev));
+        this._engineProcess = await this.engine.start(options, (ev) => this.handle(ev));
         this._status = 'running';
     }
     sendMessage(content) {
-        if (!this.engineProcess)
+        if (!this._engineProcess)
             throw new Error('SessionController not started');
-        this.engineProcess.sendMessage(content);
+        this._engineProcess.sendMessage(content);
     }
     interrupt() {
-        if (!this.engineProcess)
+        if (!this._engineProcess)
             throw new Error('SessionController not started');
-        this.engineProcess.interrupt();
+        this._engineProcess.interrupt();
     }
     async stop() {
         this._status = 'stopping';
-        if (this.engineProcess)
-            await this.engineProcess.stop();
+        if (this._engineProcess)
+            await this._engineProcess.stop();
     }
     get status() {
         return this._status;
     }
     get pid() {
-        return this.engineProcess?.pid;
+        return this._engineProcess?.pid;
     }
     get engineSessionId() {
-        return this.engineProcess?.engineSessionId;
+        return this._engineProcess?.engineSessionId;
     }
     handle(ev) {
-        if (ev.kind === 'session:compacted') {
-            try {
-                this.injectPostCompactReminder();
-            }
-            catch (err) {
-                console.error('[session-controller] post-compact reminder failed:', err);
-            }
-        }
         this.onEvent(ev);
     }
-    injectPostCompactReminder() {
-        if (!this.engineProcess)
-            return;
-        const ws = getWorkspace(this.workspaceId);
-        const tasks = listTasks(this.workspaceId);
-        const criteria = tasks.filter((t) => t.isAcceptanceCriterion);
-        const todos = tasks.filter((t) => !t.isAcceptanceCriterion);
-        if (criteria.length === 0 && todos.length === 0)
-            return;
-        let reminder = `\n--- Context reminder after compaction ---\n`;
-        reminder += `Task: ${ws?.name ?? this.workspaceId}\n`;
-        if (todos.length > 0) {
-            reminder += `\nTasks:\n${todos.map((t) => `- [${t.status === 'done' ? 'x' : ' '}] ${t.title}`).join('\n')}\n`;
-        }
-        if (criteria.length > 0) {
-            reminder += `\nAcceptance criteria:\n${criteria
-                .map((t) => `- [${t.status === 'done' ? 'x' : ' '}] ${t.title}`)
-                .join('\n')}\n`;
-            reminder += `\nWhen you complete a criterion, tell me which one so I can mark it as done.\n`;
-        }
-        reminder += `--- End of reminder ---\n`;
-        this.engineProcess.sendMessage(reminder);
-    }
 }

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

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
-import path from 'node:path';
 import { buildE2eIterationBlock, buildFinalizationIterationBlock } from '../../shared/auto-loop-prompts.js';
 import { getDb } from '../db/index.js';
+import { resolveWorkspaceWorktreePath } from '../utils/worktree-paths.js';
 import * as orchestrator from './agent/orchestrator.js';
 import * as settingsService from './settings-service.js';
 import { emit, emitEphemeral } from './websocket-service.js';
@@ -10,7 +10,7 @@ const NO_PROGRESS_STALL_THRESHOLD = 3;
 function getRow(workspaceId) {
     const db = getDb();
     const row = db
-        .prepare(`SELECT id, project_path, working_branch, worktree_path, model, permission_mode, reasoning_effort,
+        .prepare(`SELECT id, project_path, working_branch, worktree_path, model, permission_mode, agent_permission_mode, reasoning_effort,
               status, auto_loop, auto_loop_ready, no_progress_streak, archived_at
        FROM workspaces WHERE id = ?`)
         .get(workspaceId);
@@ -97,6 +97,10 @@ export function onSessionEnded(workspaceId, reason, tasksDoneDelta) {
     // timer), let that timer own the next spawn so the backoff delay is respected.
     if (row.status === 'quota')
         return;
+    // Don't spawn a competing session while paused on canUseTool — the user
+    // will resume the deferred turn explicitly.
+    if (row.status === 'awaiting-user')
+        return;
     if (reason === 'error' || reason === 'killed') {
         disable(workspaceId, 'error');
         return;
@@ -219,6 +223,9 @@ function spawnNextIteration(workspaceId, opts = {}) {
     const row = getRow(workspaceId);
     if (!row)
         return;
+    // Same guard as onSessionEnded — never race a deferred-resume start.
+    if (row.status === 'awaiting-user')
+        return;
     const task = pickNextTask(workspaceId);
     if (!task) {
         disable(workspaceId, 'completed');
@@ -245,11 +252,15 @@ function spawnNextIteration(workspaceId, opts = {}) {
         .replaceAll('{taskTitle}', task.title)
         .replaceAll('{isAcceptanceCriterion}', String(task.isAcceptanceCriterion))
         .replaceAll('{overrideBlock}', overrideBlock);
-    const worktreePath = row.worktree_path ?? path.join(row.project_path, '.worktrees', row.working_branch);
-    // Auto-loop iterations always run in auto-accept mode. Plan mode blocks MCP
-    // tools (kobo__mark_task_done, etc.) and Edit/Write/Bash — everything the
-    // iteration needs — so honoring a 'plan' setting here would deadlock the loop.
-    const permissionMode = 'auto-accept';
+    const worktreePath = row.worktree_path ?? resolveWorkspaceWorktreePath(row.project_path, row.working_branch);
+    // Plan mode would deadlock the loop (blocks MCP + edits) — promote to bypass.
+    // Other modes (bypass/strict/interactive) are honored.
+    const stored = (row.agent_permission_mode ?? 'bypass');
+    const agentPermissionMode = stored === 'plan' ? 'bypass' : stored;
+    if (stored === 'plan') {
+        console.warn(`[auto-loop-service] Promoting plan → bypass for workspace ${workspaceId} — auto-loop cannot run in plan mode`);
+        emitEphemeral(workspaceId, 'autoloop:permission-overridden', { from: 'plan', to: 'bypass' });
+    }
     // Pre-check: if the worktree directory is gone (user `rm -rf`-ed it),
     // fail loudly rather than letting startAgent throw a deep engine error.
     if (!fs.existsSync(worktreePath)) {
@@ -263,7 +274,7 @@ function spawnNextIteration(workspaceId, opts = {}) {
     let agentSessionId;
     try {
         const agent = orchestrator.startAgent(workspaceId, worktreePath, prompt, row.model, false, // resume=false — fresh context for each iteration
-        permissionMode, undefined, row.reasoning_effort);
+        agentPermissionMode, undefined, row.reasoning_effort);
         agentSessionId = agent.agentSessionId;
     }
     catch (err) {

package/dist/server/services/content-migration-service.js

@@ -1,7 +1,3 @@
-import { nanoid } from 'nanoid';
-import { createParserState, parseClaudeLine } from './agent/engines/claude-code/stream-parser.js';
-import { createPreMigrationBackup } from './db-backup-service.js';
-import { broadcastAll } from './websocket-service.js';
 const internal = { state: 'idle', total: 0, processed: 0 };
 let isRunning = false;
 function snapshot() {
@@ -41,105 +37,39 @@ function snapshot() {
 export function getContentMigrationStatus() {
     return snapshot();
 }
-export async function runContentMigrationIfNeeded(db, dbPath) {
+/**
+ * Legacy ws_events content migration.
+ *
+ * Historical context: earlier versions of Kōbō persisted Claude Code stdout as
+ * `agent:output` / `agent:stderr` / `agent:status` rows. The migration to the
+ * unified `agent:event` shape was completed in v10. As of the Claude Agent SDK
+ * cutover, the stream-parser used to reconstruct AgentEvents from those legacy
+ * rows has been removed.
+ *
+ * All production databases have been migrated. This function is now a no-op
+ * kept for API compatibility — it always reports `idle`. Should any rare,
+ * unmigrated row remain, it is left untouched in `ws_events` (and ignored by
+ * the new replay path which only reads `agent:event`).
+ */
+export async function runContentMigrationIfNeeded(_db, _dbPath) {
     if (isRunning)
         return;
     isRunning = true;
     try {
-        const row = db
-            .prepare("SELECT COUNT(*) AS c FROM ws_events WHERE type IN ('agent:output', 'agent:stderr', 'agent:status')")
-            .get();
-        if (row.c === 0) {
-            internal.state = 'idle';
-            isRunning = false;
-            return;
-        }
-        internal.state = 'backing-up';
-        internal.startedAt = new Date().toISOString();
-        broadcastStatus();
-        const backup = await createPreMigrationBackup(db, dbPath, 'v10');
-        internal.backupPath = backup.created ?? undefined;
-        internal.state = 'running';
-        internal.total = row.c;
-        internal.processed = 0;
-        broadcastStatus();
-        await processLoop(db);
-        internal.state = 'done';
-        internal.finishedAt = new Date().toISOString();
-        broadcastStatus();
-    }
-    catch (err) {
-        internal.state = 'error';
-        internal.errorMessage = err instanceof Error ? err.message : String(err);
-        broadcastStatus();
-        throw err;
+        internal.state = 'idle';
     }
     finally {
         isRunning = false;
     }
 }
-function broadcastStatus() {
-    // Content-migration events are global (no workspace context) — use broadcastAll so every
-    // connected WS client receives them regardless of their workspace subscriptions.
-    broadcastAll(internal.state === 'error' ? 'migration:error' : 'migration:progress', getContentMigrationStatus());
-}
-async function processLoop(db) {
-    const batchSize = 500;
-    const selectStmt = db.prepare("SELECT id, workspace_id, type, payload, session_id, created_at FROM ws_events WHERE type IN ('agent:output', 'agent:stderr', 'agent:status') ORDER BY created_at ASC LIMIT ?");
-    const insertStmt = db.prepare('INSERT INTO ws_events (id, workspace_id, type, payload, session_id, created_at) VALUES (?, ?, ?, ?, ?, ?)');
-    const deleteStmt = db.prepare('DELETE FROM ws_events WHERE id = ?');
-    while (true) {
-        const rows = selectStmt.all(batchSize);
-        if (rows.length === 0)
-            break;
-        db.transaction(() => {
-            for (const r of rows) {
-                const events = convertRow(r.type, r.payload, { workspaceId: r.workspace_id });
-                for (const ev of events) {
-                    insertStmt.run(nanoid(), r.workspace_id, 'agent:event', JSON.stringify(ev), r.session_id, r.created_at);
-                }
-                deleteStmt.run(r.id);
-            }
-        })();
-        internal.processed += rows.length;
-        broadcastStatus();
-        // Yield to the event loop
-        await new Promise((resolve) => setImmediate(resolve));
-    }
-}
-export function convertRow(type, payload, context) {
-    if (type === 'agent:status')
-        return []; // redundant — re-derivable from session events
-    if (type === 'agent:stderr') {
-        // Drop: the new engine only logs non-quota stderr via console.warn and
-        // does not persist it. Converting legacy stderr rows to error events
-        // would surface every historical Claude CLI warning ("no stdin data in
-        // 3s…", debug lines) as a UI-blocking banner. Quota-bearing stderr is
-        // handled live by the engine's backoff path, not via replay.
-        return [];
-    }
-    if (type === 'agent:output') {
-        try {
-            const parsed = JSON.parse(payload);
-            // The legacy payload may be either the raw Claude NDJSON already-parsed object,
-            // or a wrapper { type: 'raw', content: '...' } for non-JSON output. Handle both.
-            if (parsed && typeof parsed === 'object' && parsed.type === 'raw') {
-                return [{ kind: 'message:raw', content: String(parsed.content ?? '') }];
-            }
-            const state = createParserState();
-            const { events } = parseClaudeLine(JSON.stringify(parsed), state);
-            return events;
-        }
-        catch {
-            // Log enough to debug (first 200 chars of the bad payload + the owning
-            // workspace id when the caller passed one). We intentionally do not log
-            // the full payload to keep the console readable on noisy migrations.
-            const preview = payload.length > 200 ? `${payload.slice(0, 200)}…` : payload;
-            const ctx = context?.workspaceId ? ` (workspace=${context.workspaceId})` : '';
-            console.warn(`[content-migration] Could not parse agent:output payload${ctx}, falling back to message:raw. Preview: ${preview}`);
-            return [{ kind: 'message:raw', content: payload }];
-        }
-    }
+/**
+ * Convert a legacy ws_events row into AgentEvents.
+ *
+ * The stream-parser has been removed; this function now skips every legacy
+ * type and returns an empty array. It is preserved as an export for API
+ * compatibility with old call sites and tests.
+ */
+export function convertRow(_type, _payload, _context) {
     return [];
 }
 /** Test-only. */

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

@@ -1,7 +1,9 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { WORKTREES_PATH } from '../../shared/consts.js';
 import { listClaudeMcpEntries } from '../utils/mcp-client.js';
 import { getSettingsPath } from '../utils/paths.js';
+import { InvalidWorktreesPathError, resolveGlobalWorktreesRoot, sanitizeWorktreesPath, validateWorktreesPath, } from '../utils/worktree-paths.js';
 const DEFAULT_GIT_CONVENTIONS = `# Git conventions
 
 ## Commits
@@ -191,6 +193,13 @@ const settingsMigrations = [
             }
         },
     },
+    {
+        version: 11,
+        name: 'add-global-worktrees-path',
+        migrate({ global }) {
+            global.worktreesPath = sanitizeWorktreesPath(global.worktreesPath);
+        },
+    },
 ];
 /** Current settings schema version — always equals the highest migration version. */
 export const SETTINGS_SCHEMA_VERSION = settingsMigrations.length > 0 ? settingsMigrations[settingsMigrations.length - 1].version : 0;
@@ -231,6 +240,7 @@ function defaultSettings() {
             notionMcpKey: '',
             sentryMcpKey: '',
             tags: [...DEFAULT_WORKSPACE_TAGS],
+            worktreesPath: WORKTREES_PATH,
         },
         projects: [],
     };
@@ -278,6 +288,7 @@ export function runSettingsMigrations(raw) {
             version = m.version;
         }
     }
+    current.global.worktreesPath = sanitizeWorktreesPath(current.global.worktreesPath);
     current.schemaVersion = version;
     return current;
 }
@@ -310,9 +321,11 @@ function readSettings() {
     // Restore any global fields that may have been removed by external edits.
     // Defaults act as fallback for missing keys; existing values are preserved.
     const globalDefaults = defaultSettings().global;
+    const globalBeforeDefaults = JSON.stringify(migrated.global);
     migrated.global = { ...globalDefaults, ...migrated.global };
+    const restoredGlobalFields = JSON.stringify(migrated.global) !== globalBeforeDefaults;
     // Persist if migrations bumped the version, or if global fields were restored.
-    if (migrated.schemaVersion !== originalVersion) {
+    if (migrated.schemaVersion !== originalVersion || restoredGlobalFields) {
         writeSettings(migrated);
     }
     return migrated;
@@ -450,6 +463,7 @@ export function updateGlobalSettings(data) {
         'notionMcpKey',
         'sentryMcpKey',
         'tags',
+        'worktreesPath',
     ];
     const filtered = pickKnownKeys(data, allowedGlobalKeys);
     if (filtered.tags !== undefined) {
@@ -459,10 +473,30 @@ export function updateGlobalSettings(data) {
                 .filter((t) => t.length > 0 && t.length <= 50)))
             : settings.global.tags;
     }
+    if (filtered.worktreesPath !== undefined) {
+        filtered.worktreesPath = validateWorktreesPath(filtered.worktreesPath, { allowEmpty: false });
+        ensureGlobalWorktreesRootExists(filtered.worktreesPath);
+    }
     settings.global = { ...settings.global, ...filtered };
     writeSettings(settings, { backup: true });
     return settings.global;
 }
+function ensureGlobalWorktreesRootExists(worktreesPath) {
+    const root = resolveGlobalWorktreesRoot(worktreesPath);
+    if (!root || isNonNativeWindowsPath(root))
+        return;
+    try {
+        fs.mkdirSync(root, { recursive: true });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new InvalidWorktreesPathError(`Cannot create worktrees directory '${root}': ${message}`);
+    }
+}
+function isNonNativeWindowsPath(value) {
+    return (process.platform !== 'win32' &&
+        (/^[A-Za-z]:[\\/]/.test(value) || value.startsWith('\\\\') || value.startsWith('//')));
+}
 /** Create or update project-specific settings. Merges devServer, e2e, and finalization fields on update. */
 export function upsertProject(projectPath, data) {
     const allowedProjectKeys = [

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

@@ -1,5 +1,5 @@
-import path from 'node:path';
 import { getDb } from '../db/index.js';
+import { resolveWorkspaceWorktreePath } from '../utils/worktree-paths.js';
 import * as orchestrator from './agent/orchestrator.js';
 import { emitEphemeral } from './websocket-service.js';
 const MIN_DELAY_SECONDS = 60;
@@ -18,7 +18,7 @@ function rowToPending(row) {
     return { targetAt: row.target_at, reason: row.reason ?? undefined };
 }
 /** Schedule a wakeup for the given workspace. Replaces any existing pending wakeup. */
-export function schedule(workspaceId, delaySeconds, prompt, reason) {
+export function schedule(workspaceId, delaySeconds, prompt, reason, agentSessionId) {
     try {
         const clampedSeconds = clamp(Math.floor(delaySeconds), MIN_DELAY_SECONDS, MAX_DELAY_SECONDS);
         const effectivePrompt = prompt === AUTONOMOUS_LOOP_SENTINEL ? AUTONOMOUS_LOOP_FALLBACK_PROMPT : prompt;
@@ -28,8 +28,8 @@ export function schedule(workspaceId, delaySeconds, prompt, reason) {
             clearTimeout(existing);
         const db = getDb();
         db.prepare(`INSERT OR REPLACE INTO pending_wakeups
-         (workspace_id, target_at, prompt, reason, created_at)
-       VALUES (?, ?, ?, ?, ?)`).run(workspaceId, targetAtIso, effectivePrompt, reason ?? null, new Date().toISOString());
+         (workspace_id, target_at, prompt, reason, created_at, agent_session_id)
+       VALUES (?, ?, ?, ?, ?, ?)`).run(workspaceId, targetAtIso, effectivePrompt, reason ?? null, new Date().toISOString(), agentSessionId ?? null);
         const timeout = setTimeout(() => fire(workspaceId), clampedSeconds * 1000);
         timeout.unref?.();
         timers.set(workspaceId, timeout);
@@ -125,20 +125,19 @@ function fire(workspaceId) {
             return;
         }
         const wsRow = db
-            .prepare(`SELECT project_path, working_branch, worktree_path, model, permission_mode, reasoning_effort
+            .prepare(`SELECT project_path, working_branch, worktree_path, model, agent_permission_mode, reasoning_effort
            FROM workspaces WHERE id = ?`)
             .get(workspaceId);
         if (!wsRow) {
             emitEphemeral(workspaceId, 'wakeup:skipped', { reason: 'fire-failed' });
             return;
         }
-        const worktreePath = wsRow.worktree_path ?? path.join(wsRow.project_path, '.worktrees', wsRow.working_branch);
-        // Defensive: narrow `permission_mode` against the two known values rather
-        // than trusting the DB column shape. Any unexpected value falls back to
-        // the safer 'auto-accept'.
-        const permissionMode = wsRow.permission_mode === 'plan' ? 'plan' : 'auto-accept';
+        const worktreePath = wsRow.worktree_path ?? resolveWorkspaceWorktreePath(wsRow.project_path, wsRow.working_branch);
+        // Narrow against the four known values; unknowns → 'bypass'.
+        const stored = wsRow.agent_permission_mode;
+        const agentPermissionMode = stored === 'plan' || stored === 'strict' || stored === 'interactive' ? stored : 'bypass';
         try {
-            orchestrator.startAgent(workspaceId, worktreePath, row.prompt, wsRow.model, true, permissionMode, undefined, wsRow.reasoning_effort);
+            orchestrator.startAgent(workspaceId, worktreePath, row.prompt, wsRow.model, true, agentPermissionMode, row.agent_session_id ?? undefined, wsRow.reasoning_effort);
             emitEphemeral(workspaceId, 'wakeup:fired', {});
         }
         catch (err) {

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

@@ -1,14 +1,16 @@
 import { nanoid } from 'nanoid';
 import { getDb } from '../db/index.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 wakeupService from './wakeup-service.js';
 /** Allowed status transitions per current status. Enforced by updateWorkspaceStatus. */
 const VALID_TRANSITIONS = {
     created: ['extracting', 'brainstorming', 'idle', 'error'],
-    extracting: ['extracting', 'brainstorming', 'idle', 'error'],
-    brainstorming: ['executing', 'completed', 'idle', 'error'],
-    executing: ['completed', 'idle', 'error', 'quota'],
+    extracting: ['extracting', 'brainstorming', 'idle', 'error', 'awaiting-user'],
+    brainstorming: ['executing', 'completed', 'idle', 'error', 'awaiting-user'],
+    executing: ['completed', 'idle', 'error', 'quota', 'awaiting-user'],
+    'awaiting-user': ['executing', 'brainstorming', 'extracting', 'idle', 'error', 'completed', 'quota'],
     completed: ['idle', 'executing'],
     idle: ['executing', 'brainstorming', 'extracting', 'error'],
     error: ['idle', 'executing', 'brainstorming', 'extracting'],
@@ -19,6 +21,17 @@ const VALID_TRANSITIONS = {
 // is untyped, so we intentionally do not narrow here — validation against
 // `listEngines()` is expected to happen at workspace creation (see the
 // routes/engines handler) and when resolving an engine at agent-start time.
+/**
+ * Coerce a raw `agent_permission_mode` cell into the typed union.
+ * Falls back to `bypass` for unknown / null values — guarantees callers
+ * always get a valid SDK-mappable mode regardless of legacy or corrupted rows.
+ */
+function coerceAgentPermissionMode(raw) {
+    if (raw === 'plan' || raw === 'bypass' || raw === 'strict' || raw === 'interactive') {
+        return raw;
+    }
+    return 'bypass';
+}
 function mapWorkspace(row) {
     return {
         id: row.id,
@@ -32,7 +45,7 @@ function mapWorkspace(row) {
         sentryUrl: row.sentry_url,
         model: row.model,
         reasoningEffort: row.reasoning_effort ?? 'auto',
-        permissionMode: (row.permission_mode ?? 'auto-accept'),
+        agentPermissionMode: coerceAgentPermissionMode(row.agent_permission_mode),
         devServerStatus: row.dev_server_status,
         hasUnread: row.has_unread === 1,
         archivedAt: row.archived_at,
@@ -42,7 +55,6 @@ function mapWorkspace(row) {
         autoLoop: row.auto_loop === 1,
         autoLoopReady: row.auto_loop_ready === 1,
         noProgressStreak: row.no_progress_streak ?? 0,
-        permissionProfile: (row.permission_profile ?? 'bypass'),
         worktreePath: row.worktree_path ?? '',
         worktreeOwned: row.worktree_owned === 1,
         createdAt: row.created_at,
@@ -80,15 +92,20 @@ export function createWorkspace(data) {
     const db = getDb();
     const now = new Date().toISOString();
     const id = nanoid();
-    const computedWorktreePath = data.worktreePath ?? `${data.projectPath}/.worktrees/${data.workingBranch}`;
+    const computedWorktreePath = data.worktreePath ?? resolveWorkspaceWorktreePath(data.projectPath, data.workingBranch, data.worktreesPath);
     const owned = data.worktreeOwned ?? true;
+    // Mirror the unified mode into the legacy columns so older readers (in-flight
+    // requests during deploy, external scripts) still see a sane value.
+    const unifiedMode = data.agentPermissionMode ?? 'bypass';
+    const legacyMode = unifiedMode === 'plan' ? 'plan' : 'auto-accept';
+    const legacyProfile = unifiedMode === 'plan' ? 'bypass' : unifiedMode;
     db.prepare(`
     INSERT INTO workspaces (
       id, name, project_path, source_branch, working_branch, status,
       notion_url, notion_page_id, sentry_url, worktree_path, worktree_owned,
-      model, reasoning_effort, permission_mode, engine, created_at, updated_at
-    ) VALUES (?, ?, ?, ?, ?, 'created', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(id, data.name, data.projectPath, data.sourceBranch, data.workingBranch, data.notionUrl ?? null, data.notionPageId ?? null, data.sentryUrl ?? null, computedWorktreePath, owned ? 1 : 0, data.model ?? 'claude-opus-4-7', data.reasoningEffort ?? 'auto', data.permissionMode ?? 'auto-accept', data.engine ?? 'claude-code', now, now);
+      model, reasoning_effort, permission_mode, permission_profile, agent_permission_mode, engine, created_at, updated_at
+    ) VALUES (?, ?, ?, ?, ?, 'created', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(id, data.name, data.projectPath, data.sourceBranch, data.workingBranch, data.notionUrl ?? null, data.notionPageId ?? null, data.sentryUrl ?? null, computedWorktreePath, owned ? 1 : 0, data.model ?? 'claude-opus-4-7', data.reasoningEffort ?? 'auto', legacyMode, legacyProfile, unifiedMode, data.engine ?? 'claude-code', now, now);
     return getWorkspace(id);
 }
 /** Fetch a single workspace by ID, or null if not found. */
@@ -212,13 +229,21 @@ export function updateWorktreePath(id, newPath) {
     }
     return getWorkspace(id);
 }
-/** Update the agent's permission mode (auto-accept vs plan/read-only). */
-export function updateWorkspacePermissionMode(id, permissionMode) {
+/**
+ * Update the agent's unified permission mode (plan | bypass | strict | interactive).
+ *
+ * Also writes the legacy `permission_mode` and `permission_profile` columns to
+ * keep them coherent with the new value — they remain readable by legacy code
+ * paths during deploy. The unified column is the source of truth.
+ */
+export function updateAgentPermissionMode(id, mode) {
     const db = getDb();
     const now = new Date().toISOString();
+    const legacyMode = mode === 'plan' ? 'plan' : 'auto-accept';
+    const legacyProfile = mode === 'plan' ? 'bypass' : mode;
     const result = db
-        .prepare('UPDATE workspaces SET permission_mode = ?, updated_at = ? WHERE id = ?')
-        .run(permissionMode, now, id);
+        .prepare('UPDATE workspaces SET agent_permission_mode = ?, permission_mode = ?, permission_profile = ?, updated_at = ? WHERE id = ?')
+        .run(mode, legacyMode, legacyProfile, now, id);
     if (result.changes === 0) {
         throw new Error(`Workspace '${id}' not found`);
     }
@@ -249,6 +274,10 @@ export function deleteWorkspace(id) {
     // churn. The Map has no FK to clean up for it automatically.
     orchestrator.forgetRateLimitInfo(id);
     orchestrator.forgetTasksDoneSnapshot(id);
+    orchestrator.forgetResumeFailed(id);
+    orchestrator.forgetPendingQueue(id);
+    orchestrator.forgetPreAwaitStatus(id);
+    orchestrator.forgetSessionId(id);
     autoLoopService.forgetAutoLoopState(id);
     const db = getDb();
     db.prepare('DELETE FROM workspaces WHERE id = ?').run(id);
@@ -373,30 +402,6 @@ export function setAutoLoopReady(id, ready) {
     db.prepare('UPDATE workspaces SET auto_loop_ready = ? WHERE id = ?').run(ready ? 1 : 0, id);
     return getWorkspace(id);
 }
-/**
- * Set the permission profile for a workspace.
- *
- * - `bypass` (default): Kōbō passes `--dangerously-skip-permissions` — no
- *   prompts, but the CLI hard-denies writes under `.claude/**` and
- *   `.github/workflows/**` regardless of the project's settings.json.
- * - `strict`: Kōbō passes `--permission-mode acceptEdits` — the CLI respects
- *   the project's `.claude/settings.json` allow/deny lists. Enables writes
- *   under `.claude/**` / `.github/workflows/**` when the user has explicitly
- *   allowed them, at the cost of potential prompts on un-allow-listed Bash
- *   or MCP calls.
- *
- * Takes effect on the next session spawn — running sessions keep whichever
- * flag they were started with.
- */
-export function setPermissionProfile(id, profile) {
-    const workspace = getWorkspace(id);
-    if (!workspace)
-        throw new Error(`Workspace '${id}' not found`);
-    const db = getDb();
-    const now = new Date().toISOString();
-    db.prepare('UPDATE workspaces SET permission_profile = ?, updated_at = ? WHERE id = ?').run(profile, now, id);
-    return getWorkspace(id);
-}
 /** Remove a workspace from favorites. Idempotent: safe to call on a non-favorite, though `updated_at` still refreshes. */
 export function unsetFavorite(id) {
     const db = getDb();

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

@@ -2,21 +2,29 @@ import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import { isGitBranchExistsError } from '../utils/git-ops.js';
+import { resolveWorkspaceWorktreePath, resolveWorktreesRoot } from '../utils/worktree-paths.js';
 function git(repoPath, args) {
     return execFileSync('git', args, { cwd: repoPath, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
 }
 function getExcludeFilePath(projectPath) {
     return path.join(projectPath, '.git', 'info', 'exclude');
 }
+function projectRelativeWorktreePath(projectPath, worktreePath) {
+    const relativePath = path.relative(projectPath, worktreePath);
+    if (!relativePath || relativePath.startsWith('..') || path.isAbsolute(relativePath))
+        return null;
+    return relativePath;
+}
 function addToExclude(projectPath, worktreePath) {
+    const relativePath = projectRelativeWorktreePath(projectPath, worktreePath);
+    if (!relativePath)
+        return;
     const excludeFile = getExcludeFilePath(projectPath);
     // Ensure the .git/info directory exists
     const infoDir = path.dirname(excludeFile);
     if (!fs.existsSync(infoDir)) {
         fs.mkdirSync(infoDir, { recursive: true });
     }
-    // Make the path relative to projectPath for cleaner exclude entries
-    const relativePath = path.relative(projectPath, worktreePath);
     const entry = `/${relativePath}`;
     let current = '';
     if (fs.existsSync(excludeFile)) {
@@ -28,23 +36,25 @@ function addToExclude(projectPath, worktreePath) {
     }
 }
 function removeFromExclude(projectPath, worktreePath) {
+    const relativePath = projectRelativeWorktreePath(projectPath, worktreePath);
+    if (!relativePath)
+        return;
     const excludeFile = getExcludeFilePath(projectPath);
     if (!fs.existsSync(excludeFile))
         return;
-    const relativePath = path.relative(projectPath, worktreePath);
     const entry = `/${relativePath}`;
     const lines = fs.readFileSync(excludeFile, 'utf-8').split('\n');
     const filtered = lines.filter((line) => line !== entry);
     const trimmed = filtered.join('\n').replace(/\n+$/, '');
     fs.writeFileSync(excludeFile, trimmed ? `${trimmed}\n` : '', 'utf-8');
 }
-/** Create a git worktree under `.worktrees/` for the given branch. Returns the worktree path. */
-export function createWorktree(projectPath, branchName, sourceBranch) {
-    const worktreesDir = path.join(projectPath, '.worktrees');
+/** Create a git worktree for the given branch. Returns the worktree path. */
+export function createWorktree(projectPath, branchName, sourceBranch, worktreesPath) {
+    const worktreesDir = resolveWorktreesRoot(projectPath, worktreesPath);
     if (!fs.existsSync(worktreesDir)) {
         fs.mkdirSync(worktreesDir, { recursive: true });
     }
-    const worktreePath = path.join(worktreesDir, branchName);
+    const worktreePath = resolveWorkspaceWorktreePath(projectPath, branchName, worktreesPath);
     try {
         // Use origin/<sourceBranch> as the base so the worktree starts from the
         // freshly-fetched remote ref (fetchSourceBranch is always called first).