@loicngr/kobo 1.1.1 → 1.3.0

package/dist/server/routes/workspaces.js

@@ -107,7 +107,30 @@ app.post('/', async (c) => {
             workspaceService.updateWorkspaceStatus(workspace.id, 'error');
             return c.json({ error: `Failed to create worktree: ${message}` }, 500);
         }
-        // 4b. Write git conventions to the worktree if configured
+        // 4b. Ensure Kobo-generated files inside .ai/ are gitignored (the .ai/ dir
+        //     itself may contain project files that SHOULD be committed).
+        try {
+            const fs = await import('node:fs');
+            const pathMod = await import('node:path');
+            const gitignorePath = pathMod.default.join(worktreePath, '.gitignore');
+            const existing = fs.existsSync(gitignorePath) ? fs.readFileSync(gitignorePath, 'utf-8') : '';
+            const lines = existing.split('\n').map((l) => l.trim());
+            const toAdd = [];
+            if (!lines.includes('.ai/git-conventions.md'))
+                toAdd.push('.ai/git-conventions.md');
+            if (!lines.includes('.ai/thoughts/'))
+                toAdd.push('.ai/thoughts/');
+            if (!lines.includes('.ai/images/'))
+                toAdd.push('.ai/images/');
+            if (toAdd.length > 0) {
+                const separator = existing.length > 0 && !existing.endsWith('\n') ? '\n' : '';
+                fs.appendFileSync(gitignorePath, `${separator}${toAdd.join('\n')}\n`, 'utf-8');
+            }
+        }
+        catch (err) {
+            console.error('[workspaces] Failed to update .gitignore:', err);
+        }
+        // 4c. Write git conventions to the worktree if configured
         const effectiveSettings = settingsService.getEffectiveSettings(body.projectPath);
         if (effectiveSettings.gitConventions) {
             try {
@@ -363,6 +386,22 @@ app.post('/:id/tasks/:taskId/notify-done', (c) => {
         return c.json({ error: message }, 500);
     }
 });
+// POST /api/workspaces/:id/tasks/notify-updated — broadcast generic task list change
+app.post('/:id/tasks/notify-updated', (c) => {
+    try {
+        const id = c.req.param('id');
+        const workspace = workspaceService.getWorkspace(id);
+        if (!workspace) {
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        }
+        wsService.emit(id, 'task:updated', {});
+        return new Response(null, { status: 204 });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
 // GET /api/workspaces/archived — list archived workspaces (must be before GET /:id)
 app.get('/archived', (c) => {
     try {
@@ -388,19 +427,32 @@ app.get('/:id', (c) => {
         return c.json({ error: message }, 500);
     }
 });
-// PATCH /api/workspaces/:id — update workspace status
+// PATCH /api/workspaces/:id — update workspace fields (status, model, permissionMode)
 app.patch('/:id', async (c) => {
     try {
         const id = c.req.param('id');
         const body = await c.req.json();
-        if (!body.status) {
-            return c.json({ error: 'Missing required field: status' }, 400);
-        }
         const workspace = workspaceService.getWorkspace(id);
         if (!workspace) {
             return c.json({ error: `Workspace '${id}' not found` }, 404);
         }
-        const updated = workspaceService.updateWorkspaceStatus(id, body.status);
+        let updated = workspace;
+        if (body.model !== undefined) {
+            updated = workspaceService.updateWorkspaceModel(id, body.model);
+        }
+        if (body.permissionMode !== undefined) {
+            const validModes = ['auto-accept', 'plan'];
+            if (!validModes.includes(body.permissionMode)) {
+                return c.json({ error: `Invalid permission mode. Must be one of: ${validModes.join(', ')}` }, 400);
+            }
+            updated = workspaceService.updateWorkspacePermissionMode(id, body.permissionMode);
+        }
+        if (body.status) {
+            updated = workspaceService.updateWorkspaceStatus(id, body.status);
+        }
+        if (!body.status && body.model === undefined && body.permissionMode === undefined) {
+            return c.json({ error: 'Missing field: status, model, or permissionMode' }, 400);
+        }
         return c.json(updated);
     }
     catch (err) {
@@ -543,7 +595,7 @@ app.post('/:id/start', async (c) => {
             // Agent may not be running — ignore
         }
         const worktreePath = `${workspace.projectPath}/.worktrees/${workspace.workingBranch}`;
-        agentManager.startAgent(id, worktreePath, prompt, workspace.model);
+        agentManager.startAgent(id, worktreePath, prompt, workspace.model, false, workspace.permissionMode);
         workspaceService.updateWorkspaceStatus(id, 'executing');
         return c.json({ status: 'started' });
     }
@@ -564,11 +616,16 @@ app.get('/:id/git-stats', async (c) => {
         const worktreePath = path.default.join(workspace.projectPath, '.worktrees', workspace.workingBranch);
         const commitCount = gitOps.getCommitCount(worktreePath, workspace.sourceBranch, workspace.workingBranch);
         const diffStats = gitOps.getStructuredDiffStatsBetween(worktreePath, workspace.sourceBranch, workspace.workingBranch);
+        const pr = gitOps.getPrStatus(workspace.projectPath, workspace.workingBranch);
+        const unpushedCount = gitOps.getUnpushedCount(worktreePath);
         return c.json({
             commitCount,
             filesChanged: diffStats.filesChanged,
             insertions: diffStats.insertions,
             deletions: diffStats.deletions,
+            prUrl: pr?.url ?? null,
+            prState: pr?.state ?? null,
+            unpushedCount,
         });
     }
     catch (err) {
@@ -701,22 +758,26 @@ app.post('/:id/open-pr', async (c) => {
         const session = workspaceService.getLatestSession(workspace.id);
         const sessionId = session?.claudeSessionId ?? undefined;
         emit(workspace.id, 'user:message', { content: rendered, sender: 'user' }, sessionId);
-        // 8. Send to the running agent (degrade on failure)
+        // 8. Send to the running agent, or resume the agent with the PR prompt
+        let messageSent = false;
         try {
             agentManager.sendMessage(workspace.id, rendered);
-            return c.json({ ok: true, prNumber, prUrl, messageSent: true });
+            messageSent = true;
         }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.warn(`[workspaces] open-pr: PR created but sendMessage failed: ${message}`);
-            return c.json({
-                ok: true,
-                prNumber,
-                prUrl,
-                messageSent: false,
-                warning: `Agent is not active — message was not sent (${message})`,
-            });
+        catch {
+            // Agent not running — resume it with the PR prompt
+            try {
+                const worktreePathForResume = `${workspace.projectPath}/.worktrees/${workspace.workingBranch}`;
+                agentManager.startAgent(workspace.id, worktreePathForResume, rendered, workspace.model, true, workspace.permissionMode);
+                workspaceService.updateWorkspaceStatus(workspace.id, 'executing');
+                messageSent = true;
+            }
+            catch (resumeErr) {
+                const resumeMsg = resumeErr instanceof Error ? resumeErr.message : String(resumeErr);
+                console.warn(`[workspaces] open-pr: PR created but agent resume failed: ${resumeMsg}`);
+            }
         }
+        return c.json({ ok: true, prNumber, prUrl, messageSent });
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);

package/dist/server/services/agent-manager.js

@@ -4,11 +4,18 @@ import path from 'node:path';
 import readline from 'node:readline';
 import { nanoid } from 'nanoid';
 import { getDb } from '../db/index.js';
-import { ensureKoboHome, getCompiledMcpServerPath, getDbPath, getMcpServerSourcePath, getSkillsPath, } from '../utils/paths.js';
+import { ensureKoboHome, getCompiledMcpServerPath, getDbPath, getMcpServerSourcePath, getSettingsPath, getSkillsPath, } from '../utils/paths.js';
 import { registerProcess, unregisterProcess } from '../utils/process-tracker.js';
+import { getEffectiveSettings } from './settings-service.js';
 import { emit } from './websocket-service.js';
 import { getWorkspace as getWs, listTasks, updateWorkspaceStatus } from './workspace-service.js';
 // ── State ──────────────────────────────────────────────────────────────────────
+/** Actual bound port of the running backend — set at startup via setBackendPort() */
+let backendPort = process.env.PORT ? parseInt(process.env.PORT, 10) : 3000;
+/** Called from index.ts once the HTTP server is listening so MCP children can reach it. */
+export function setBackendPort(port) {
+    backendPort = port;
+}
 /** workspaceId -> agent instance */
 const agents = new Map();
 /** workspaceId -> last Claude session ID (for --resume) */
@@ -29,16 +36,90 @@ const retryCounts = new Map();
 const backoffTimers = new Map();
 /** workspaceId -> pending SIGKILL timer */
 const killTimers = new Map();
+// ── Watchdog ──────────────────────────────────────────────────────────────────
+// Periodically checks that tracked agent processes are still alive.
+// If a process died without triggering the 'exit' handler (crash, OOM kill,
+// etc.), the watchdog cleans up and updates the workspace status.
+const WATCHDOG_INTERVAL_MS = 30_000;
+let watchdogTimer = null;
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0); // signal 0 = existence check, doesn't actually kill
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function runWatchdog() {
+    for (const [workspaceId, agent] of agents) {
+        const pid = agent.process.pid;
+        if (pid === undefined || isProcessAlive(pid))
+            continue;
+        console.error(`[watchdog] Agent process for workspace '${workspaceId}' (PID ${pid}) is dead — cleaning up`);
+        // Close readline to release the stream
+        try {
+            agent.rl.close();
+        }
+        catch {
+            // Ignore
+        }
+        unregisterProcess(workspaceId);
+        agents.delete(workspaceId);
+        retryCounts.delete(workspaceId);
+        // Update DB session
+        try {
+            const db = getDb();
+            db.prepare('UPDATE agent_sessions SET status = ?, ended_at = ? WHERE id = ?').run('error', new Date().toISOString(), agent.agentSessionId);
+        }
+        catch (err) {
+            console.error('[watchdog] Failed to update agent_sessions:', err);
+        }
+        // Update workspace status
+        try {
+            updateWorkspaceStatus(workspaceId, 'error');
+        }
+        catch {
+            // Transition may not be valid — ignore
+        }
+        emit(workspaceId, 'agent:status', { status: 'error', message: 'Agent process died unexpectedly' }, agent.claudeSessionId);
+    }
+}
+/** Start the watchdog (called once from server bootstrap). */
+export function startWatchdog() {
+    if (watchdogTimer)
+        return;
+    watchdogTimer = setInterval(runWatchdog, WATCHDOG_INTERVAL_MS);
+    watchdogTimer.unref?.();
+}
+/** Stop the watchdog (for clean shutdown / tests). */
+export function stopWatchdog() {
+    if (watchdogTimer) {
+        clearInterval(watchdogTimer);
+        watchdogTimer = null;
+    }
+}
 // ── Start agent ────────────────────────────────────────────────────────────────
-export function startAgent(workspaceId, workingDir, prompt, model, resume = false) {
+export function startAgent(workspaceId, workingDir, prompt, model, resume = false, permissionMode = 'auto-accept') {
     // Check if agent already running for this workspace
     if (agents.has(workspaceId)) {
         throw new Error(`Agent already running for workspace '${workspaceId}'`);
     }
     const db = getDb();
     let agentSessionId;
-    // Build CLI args
-    const args = ['--dangerously-skip-permissions', '--output-format', 'stream-json', '--verbose'];
+    let resumedClaudeSessionId;
+    // Build CLI args — read dangerouslySkipPermissions from effective settings
+    const ws = getWs(workspaceId);
+    const effectiveSettings = ws ? getEffectiveSettings(ws.projectPath) : null;
+    const skipPermissions = effectiveSettings?.dangerouslySkipPermissions ?? true;
+    const args = ['--output-format', 'stream-json', '--verbose'];
+    if (skipPermissions) {
+        args.push('--dangerously-skip-permissions');
+    }
+    if (permissionMode === 'plan') {
+        // In plan mode, prepend read-only instructions to the prompt
+        prompt = `[PLAN MODE] You are in PLAN/READ-ONLY mode. You MUST NOT create, edit, write, or delete any files. Only use read-only tools (Read, Grep, Glob, LS, Bash for read-only commands). Analyze the codebase, plan your approach, and present your findings — but do NOT execute any changes.\n\n${prompt}`;
+    }
     if (model && model !== 'auto') {
         args.push('--model', model);
     }
@@ -48,6 +129,7 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
             .get(workspaceId);
         const claudeSessionId = sessionIds.get(workspaceId) ?? lastSession?.claude_session_id;
         if (claudeSessionId) {
+            resumedClaudeSessionId = claudeSessionId;
             args.push('--resume', claudeSessionId, '-p', prompt);
             // Always reuse existing session — find by claude_session_id if lastSession didn't match
             const existingId = lastSession?.id ??
@@ -86,7 +168,8 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
                     env: {
                         KOBO_WORKSPACE_ID: workspaceId,
                         KOBO_DB_PATH: getDbPath(),
-                        KOBO_BACKEND_URL: `http://localhost:${process.env.PORT ?? '3000'}`,
+                        KOBO_SETTINGS_PATH: getSettingsPath(),
+                        KOBO_BACKEND_URL: `http://127.0.0.1:${backendPort}`,
                     },
                 },
             },
@@ -117,6 +200,7 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
         rl,
         status: 'running',
         agentSessionId,
+        claudeSessionId: resumedClaudeSessionId,
     };
     // ── stdout line-by-line (NDJSON) ──
     rl.on('line', (line) => {
@@ -287,6 +371,8 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
     });
     // Store in agents map
     agents.set(workspaceId, agent);
+    // Notify frontend that agent is now running
+    emit(workspaceId, 'agent:status', { status: 'executing' }, agent.claudeSessionId);
     return agent;
 }
 // ── Stop agent ─────────────────────────────────────────────────────────────────

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

@@ -0,0 +1,73 @@
+// src/server/services/image-service.ts
+import fs from 'node:fs';
+import path from 'node:path';
+import { nanoid } from 'nanoid';
+const ALLOWED_EXTENSIONS = new Set(['png', 'jpg', 'jpeg', 'gif', 'webp']);
+const IMAGES_DIR = '.ai/images';
+const INDEX_FILE = 'index.json';
+// Per-worktree lock to serialize index.json writes
+const locks = new Map();
+function withLock(worktreePath, fn) {
+    const prev = locks.get(worktreePath) ?? Promise.resolve();
+    // The second argument to .then() means: even if the previous operation in the
+    // queue rejected, still run fn — one failure must not block the whole queue.
+    const next = prev.then(fn, fn);
+    locks.set(worktreePath, next.then(() => { }, () => { }));
+    return next;
+}
+function readIndex(imagesDir) {
+    const indexPath = path.join(imagesDir, INDEX_FILE);
+    if (!fs.existsSync(indexPath))
+        return [];
+    try {
+        return JSON.parse(fs.readFileSync(indexPath, 'utf-8'));
+    }
+    catch (err) {
+        console.error(`[image-service] Failed to parse ${indexPath}, treating as empty index:`, err);
+        return [];
+    }
+}
+function writeIndex(imagesDir, entries) {
+    fs.writeFileSync(path.join(imagesDir, INDEX_FILE), JSON.stringify(entries, null, 2));
+}
+export async function saveImage(worktreePath, fileBuffer, originalName) {
+    const ext = path.extname(originalName).toLowerCase().replace('.', '');
+    if (!ext) {
+        throw new Error(`File has no extension. Allowed: ${[...ALLOWED_EXTENSIONS].join(', ')}`);
+    }
+    if (!ALLOWED_EXTENSIONS.has(ext)) {
+        throw new Error(`Unsupported image extension: '${ext}'. Allowed: ${[...ALLOWED_EXTENSIONS].join(', ')}`);
+    }
+    const uid = nanoid(10);
+    const imagesDir = path.join(worktreePath, IMAGES_DIR);
+    // mkdirSync is idempotent — safe to call outside the lock
+    fs.mkdirSync(imagesDir, { recursive: true });
+    const filename = `${uid}.${ext}`;
+    await withLock(worktreePath, () => {
+        // Write the image file inside the lock so both the file write and index
+        // update happen atomically — avoids orphan files on crash between the two.
+        fs.writeFileSync(path.join(imagesDir, filename), fileBuffer);
+        const entries = readIndex(imagesDir);
+        entries.push({ uid, originalName, createdAt: new Date().toISOString() });
+        writeIndex(imagesDir, entries);
+    });
+    return { uid, relativePath: `${IMAGES_DIR}/${filename}` };
+}
+export async function deleteImage(worktreePath, uid) {
+    const imagesDir = path.join(worktreePath, IMAGES_DIR);
+    await withLock(worktreePath, () => {
+        const entries = readIndex(imagesDir);
+        const idx = entries.findIndex((e) => e.uid === uid);
+        if (idx === -1) {
+            throw new Error(`Image '${uid}' not found in index`);
+        }
+        // Find the file on disk (we need the extension)
+        const files = fs.existsSync(imagesDir) ? fs.readdirSync(imagesDir) : [];
+        const imageFile = files.find((f) => f.startsWith(`${uid}.`));
+        if (imageFile) {
+            fs.unlinkSync(path.join(imagesDir, imageFile));
+        }
+        entries.splice(idx, 1);
+        writeIndex(imagesDir, entries);
+    });
+}

package/dist/server/services/pr-watcher-service.js

@@ -0,0 +1,61 @@
+import { getPrStatus } from '../utils/git-ops.js';
+import { emitEphemeral } from './websocket-service.js';
+import { archiveWorkspace, listWorkspaces } from './workspace-service.js';
+// ── PR Watcher ────────────────────────────────────────────────────────────────
+// Polls GitHub every POLL_INTERVAL_MS to detect merged/closed PRs and
+// automatically archive the corresponding workspace.
+//
+// Only archives on a STATE TRANSITION from OPEN → CLOSED/MERGED.
+// If a PR is already closed/merged when first seen (e.g. after unarchive),
+// it is recorded but NOT acted upon — prevents re-archiving manually
+// unarchived workspaces.
+const POLL_INTERVAL_MS = 30 * 1000; // 30 seconds
+let timer = null;
+/** Tracks the last known PR state per workspace to detect transitions. */
+const lastKnownState = new Map();
+function checkPrStatuses() {
+    const workspaces = listWorkspaces(false); // non-archived only
+    // Clean up entries for workspaces that no longer exist
+    for (const id of lastKnownState.keys()) {
+        if (!workspaces.some((ws) => ws.id === id)) {
+            lastKnownState.delete(id);
+        }
+    }
+    for (const ws of workspaces) {
+        // Only check workspaces that are not actively running an agent
+        if (['extracting', 'brainstorming', 'executing'].includes(ws.status))
+            continue;
+        try {
+            const pr = getPrStatus(ws.projectPath, ws.workingBranch);
+            if (!pr)
+                continue;
+            const prev = lastKnownState.get(ws.id);
+            lastKnownState.set(ws.id, pr.state);
+            // Only archive on a transition FROM OPEN — not on first sight of CLOSED/MERGED
+            if (prev === 'OPEN' && (pr.state === 'MERGED' || pr.state === 'CLOSED')) {
+                console.log(`[pr-watcher] PR ${pr.state.toLowerCase()} for workspace '${ws.name}' — archiving`);
+                archiveWorkspace(ws.id);
+                lastKnownState.delete(ws.id);
+                emitEphemeral(ws.id, 'workspace:archived', {
+                    reason: `PR ${pr.state.toLowerCase()}`,
+                    prUrl: pr.url,
+                });
+            }
+        }
+        catch (err) {
+            console.error(`[pr-watcher] Failed to check PR for workspace '${ws.name}':`, err instanceof Error ? err.message : err);
+        }
+    }
+}
+export function startPrWatcher() {
+    if (timer)
+        return;
+    timer = setInterval(checkPrStatuses, POLL_INTERVAL_MS);
+    timer.unref?.();
+}
+export function stopPrWatcher() {
+    if (timer) {
+        clearInterval(timer);
+        timer = null;
+    }
+}

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

@@ -50,7 +50,36 @@ Please:
 1. Review the PR description on GitHub and improve it if needed (add a proper summary, screenshots if relevant, a test plan)
 2. Verify that all acceptance criteria are checked
 3. Post a comment on the PR summarizing what was done and any follow-up items
+4. Do NOT add a "Generated with Claude Code" footer or any AI attribution to the PR description
 `;
+const settingsMigrations = [
+    {
+        version: 1,
+        name: 'add-git-conventions',
+        migrate: ({ global, projects }) => {
+            if (typeof global.gitConventions !== 'string')
+                global.gitConventions = '';
+            for (const p of projects) {
+                if (typeof p.gitConventions !== 'string')
+                    p.gitConventions = '';
+            }
+        },
+    },
+    {
+        version: 2,
+        name: 'add-dangerously-skip-permissions',
+        migrate: ({ global, projects }) => {
+            if (typeof global.dangerouslySkipPermissions !== 'boolean')
+                global.dangerouslySkipPermissions = true;
+            for (const p of projects) {
+                if (typeof p.dangerouslySkipPermissions !== 'boolean')
+                    p.dangerouslySkipPermissions = true;
+            }
+        },
+    },
+];
+/** Current settings schema version — always equals the highest migration version. */
+export const SETTINGS_SCHEMA_VERSION = settingsMigrations.length > 0 ? settingsMigrations[settingsMigrations.length - 1].version : 0;
 let settingsFilePath = getSettingsPath();
 /** Override the settings file path (used by tests). */
 export function _setSettingsPath(p) {
@@ -58,8 +87,10 @@ export function _setSettingsPath(p) {
 }
 function defaultSettings() {
     return {
+        schemaVersion: SETTINGS_SCHEMA_VERSION,
         global: {
             defaultModel: 'auto',
+            dangerouslySkipPermissions: true,
             prPromptTemplate: DEFAULT_PR_PROMPT_TEMPLATE,
             gitConventions: DEFAULT_GIT_CONVENTIONS,
         },
@@ -72,6 +103,7 @@ function defaultProjectSettings(projectPath) {
         displayName: '',
         defaultSourceBranch: '',
         defaultModel: '',
+        dangerouslySkipPermissions: true,
         prPromptTemplate: '',
         gitConventions: '',
         devServer: {
@@ -83,6 +115,29 @@ function defaultProjectSettings(projectPath) {
 function pickKnownKeys(data, allowedKeys) {
     return Object.fromEntries(Object.entries(data).filter(([key]) => allowedKeys.includes(key)));
 }
+/**
+ * Apply migrations sequentially to bring an older settings object up to
+ * SETTINGS_SCHEMA_VERSION. Append-only — never edit or reorder shipped entries.
+ * The returned object carries the bumped schemaVersion; callers persist it.
+ */
+export function runSettingsMigrations(raw) {
+    const current = raw;
+    if (!current.global || typeof current.global !== 'object') {
+        current.global = {};
+    }
+    if (!Array.isArray(current.projects)) {
+        current.projects = [];
+    }
+    let version = typeof current.schemaVersion === 'number' ? current.schemaVersion : 0;
+    for (const m of settingsMigrations) {
+        if (version < m.version) {
+            m.migrate({ global: current.global, projects: current.projects });
+            version = m.version;
+        }
+    }
+    current.schemaVersion = version;
+    return current;
+}
 function readSettings() {
     if (!fs.existsSync(settingsFilePath)) {
         const defaults = defaultSettings();
@@ -90,21 +145,28 @@ function readSettings() {
         return defaults;
     }
     const raw = fs.readFileSync(settingsFilePath, 'utf-8');
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed.global !== 'object' || !Array.isArray(parsed.projects)) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
         const defaults = defaultSettings();
         writeSettings(defaults);
         return defaults;
     }
-    // Backfill missing fields on load (forward compat for old settings.json)
-    if (typeof parsed.global.gitConventions !== 'string') {
-        parsed.global.gitConventions = '';
+    if (!parsed || typeof parsed !== 'object') {
+        const defaults = defaultSettings();
+        writeSettings(defaults);
+        return defaults;
     }
-    for (const p of parsed.projects) {
-        if (typeof p.gitConventions !== 'string')
-            p.gitConventions = '';
+    const originalVersion = parsed.schemaVersion;
+    const migrated = runSettingsMigrations(parsed);
+    // If migrations bumped the version, persist the upgraded settings so the
+    // next process doesn't re-run them on every load.
+    if (migrated.schemaVersion !== originalVersion) {
+        writeSettings(migrated);
     }
-    return parsed;
+    return migrated;
 }
 function writeSettings(settings) {
     const tmpPath = `${settingsFilePath}.tmp`;
@@ -131,6 +193,7 @@ export function getEffectiveSettings(projectPath) {
     if (!project) {
         return {
             model: settings.global.defaultModel,
+            dangerouslySkipPermissions: settings.global.dangerouslySkipPermissions,
             prPromptTemplate: settings.global.prPromptTemplate,
             gitConventions: settings.global.gitConventions,
             sourceBranch: '',
@@ -139,6 +202,7 @@ export function getEffectiveSettings(projectPath) {
     }
     return {
         model: project.defaultModel || settings.global.defaultModel,
+        dangerouslySkipPermissions: project.dangerouslySkipPermissions ?? settings.global.dangerouslySkipPermissions,
         prPromptTemplate: project.prPromptTemplate || settings.global.prPromptTemplate,
         gitConventions: project.gitConventions || settings.global.gitConventions,
         sourceBranch: project.defaultSourceBranch,
@@ -147,7 +211,7 @@ export function getEffectiveSettings(projectPath) {
 }
 export function updateGlobalSettings(data) {
     const settings = readSettings();
-    const allowedGlobalKeys = ['defaultModel', 'prPromptTemplate', 'gitConventions'];
+    const allowedGlobalKeys = ['defaultModel', 'dangerouslySkipPermissions', 'prPromptTemplate', 'gitConventions'];
     const filtered = pickKnownKeys(data, allowedGlobalKeys);
     settings.global = { ...settings.global, ...filtered };
     writeSettings(settings);
@@ -158,6 +222,7 @@ export function upsertProject(projectPath, data) {
         'displayName',
         'defaultSourceBranch',
         'defaultModel',
+        'dangerouslySkipPermissions',
         'prPromptTemplate',
         'gitConventions',
         'devServer',

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

@@ -22,6 +22,7 @@ function mapWorkspace(row) {
         notionUrl: row.notion_url,
         notionPageId: row.notion_page_id,
         model: row.model,
+        permissionMode: (row.permission_mode ?? 'auto-accept'),
         devServerStatus: row.dev_server_status,
         archivedAt: row.archived_at,
         createdAt: row.created_at,
@@ -90,6 +91,18 @@ export function updateWorkspaceName(id, name) {
     db.prepare('UPDATE workspaces SET name = ?, updated_at = ? WHERE id = ?').run(name, now, id);
     return getWorkspace(id);
 }
+export function updateWorkspaceModel(id, model) {
+    const db = getDb();
+    const now = new Date().toISOString();
+    db.prepare('UPDATE workspaces SET model = ?, updated_at = ? WHERE id = ?').run(model, now, id);
+    return getWorkspace(id);
+}
+export function updateWorkspacePermissionMode(id, permissionMode) {
+    const db = getDb();
+    const now = new Date().toISOString();
+    db.prepare('UPDATE workspaces SET permission_mode = ?, updated_at = ? WHERE id = ?').run(permissionMode, now, id);
+    return getWorkspace(id);
+}
 export function updateDevServerStatus(id, status) {
     const db = getDb();
     db.prepare('UPDATE workspaces SET dev_server_status = ? WHERE id = ?').run(status, id);

package/dist/server/utils/git-ops.js

@@ -125,6 +125,45 @@ export function getCommitsBetween(repoPath, base, head) {
         return '';
     }
 }
+export function getPrUrl(repoPath, branchName) {
+    try {
+        return (execFileSync('gh', ['pr', 'view', branchName, '--json', 'url', '--jq', '.url'], {
+            cwd: repoPath,
+            encoding: 'utf-8',
+        }).trim() || null);
+    }
+    catch {
+        return null;
+    }
+}
+export function getPrStatus(repoPath, branchName) {
+    try {
+        const raw = execFileSync('gh', ['pr', 'view', branchName, '--json', 'state,url'], {
+            cwd: repoPath,
+            encoding: 'utf-8',
+        }).trim();
+        if (!raw)
+            return null;
+        const parsed = JSON.parse(raw);
+        return { state: parsed.state, url: parsed.url };
+    }
+    catch {
+        return null;
+    }
+}
+/** Count commits ahead of upstream. Returns -1 if no upstream is set. */
+export function getUnpushedCount(repoPath) {
+    try {
+        const output = execFileSync('git', ['rev-list', '@{u}..HEAD', '--count'], {
+            cwd: repoPath,
+            encoding: 'utf-8',
+        }).trim();
+        return parseInt(output, 10) || 0;
+    }
+    catch {
+        return -1; // no upstream
+    }
+}
 export function getDiffStatsBetween(repoPath, base, head) {
     try {
         return git(repoPath, ['diff', '--shortstat', `${base}...${head}`]);