@loicngr/kobo 1.6.14 → 1.7.0

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

@@ -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');
@@ -246,10 +253,14 @@ function spawnNextIteration(workspaceId, opts = {}) {
         .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';
+    // 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/usage/poller.js

@@ -1,7 +1,10 @@
 import { broadcastAll } from '../websocket-service.js';
 import { upsertUsageSnapshot } from './db.js';
 import { createClaudeCodeProvider } from './providers/claude-code.js';
-export const POLL_INTERVAL_MS = 60_000;
+// 5 minutes — the Anthropic `five_hour` / `seven_day` buckets are slow-moving
+// so a tighter cadence just burns rate limit (429s) without surfacing fresher
+// data to the UI. The user can still trigger a manual refresh via `refreshNow`.
+export const POLL_INTERVAL_MS = 5 * 60_000;
 const DEFAULT_PROVIDERS = [createClaudeCodeProvider()];
 let providers = DEFAULT_PROVIDERS;
 let intervalHandle = null;

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

@@ -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,7 +125,7 @@ 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) {
@@ -133,12 +133,11 @@ function fire(workspaceId) {
             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';
+        // 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

@@ -6,9 +6,10 @@ 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 +20,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 +44,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 +54,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,
@@ -82,13 +93,18 @@ export function createWorkspace(data) {
     const id = nanoid();
     const computedWorktreePath = data.worktreePath ?? `${data.projectPath}/.worktrees/${data.workingBranch}`;
     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 +228,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 +273,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 +401,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/utils/git-ops.js

@@ -1,5 +1,5 @@
 import { execFile as execFileCb, execFileSync } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
 import { promisify } from 'node:util';
 const execFileAsync = promisify(execFileCb);
@@ -410,7 +410,7 @@ export function moveWorktree(projectPath, oldPath, newPath) {
     git(projectPath, ['worktree', 'move', oldPath, newPath]);
 }
 /** List files changed between base and HEAD (committed), plus working tree changes. */
-export function getChangedFiles(repoPath, base) {
+export function getChangedFiles(repoPath, base, includeUntracked = false) {
     const ref = resolveBase(repoPath, base);
     const files = [];
     const seen = new Set();
@@ -443,9 +443,14 @@ export function getChangedFiles(repoPath, base) {
     catch {
         // No commits yet
     }
-    // Working tree changes (uncommitted)
+    // Working tree changes (uncommitted). Default to `-uno` to skip pure
+    // untracked files: they have never been `git add`-ed and won't ship in
+    // the next commit/PR, so showing them in the diff viewer is misleading.
+    // When `includeUntracked` is true (user opt-in via the diff viewer toggle)
+    // we use `-uall` and surface them with status='added'.
     try {
-        const output = git(repoPath, ['status', '--porcelain', '-uall']);
+        const flag = includeUntracked ? '-uall' : '-uno';
+        const output = git(repoPath, ['status', '--porcelain', flag]);
         for (const line of output.split('\n')) {
             if (!line)
                 continue;
@@ -456,7 +461,7 @@ export function getChangedFiles(repoPath, base) {
             const y = line[1];
             let status = 'modified';
             if (x === '?' && y === '?')
-                status = 'added';
+                status = 'untracked';
             else if (x === 'A' || y === 'A')
                 status = 'added';
             else if (x === 'D' || y === 'D')
@@ -523,6 +528,63 @@ export function getFileAtRef(repoPath, ref, filePath) {
         return null;
     }
 }
+/**
+ * Reset a single file in the worktree to a sensible baseline. Cascade:
+ *  1. `origin/<branchName>` if the remote ref AND the file exist there
+ *     (typical: branch is pushed, user wants to undo all local changes).
+ *  2. `HEAD` if the file exists at the last local commit (typical: branch
+ *     not yet pushed, or file was added in commits that aren't on remote
+ *     yet — discards just the uncommitted edits, keeps the commits).
+ *  3. **Delete** the file from disk when it's untracked (not on remote AND
+ *     not in HEAD): there's nothing to "rollback to", so the only sensible
+ *     undo is to remove the local-only file. Caller MUST surface this to
+ *     the user with an explicit confirmation message — the action is
+ *     permanent.
+ *
+ * Throws on filesystem errors (permission denied, etc.). Returns the
+ * target that was actually used so the caller can surface the right
+ * feedback in the UI.
+ */
+export function rollbackFile(repoPath, branchName, filePath, remote = 'origin') {
+    const remoteRef = `${remote}/${branchName}`;
+    let remoteRefExists = false;
+    try {
+        git(repoPath, ['rev-parse', '--verify', remoteRef]);
+        remoteRefExists = true;
+    }
+    catch {
+        // Branch never pushed — fall through to HEAD.
+    }
+    if (remoteRefExists) {
+        try {
+            git(repoPath, ['cat-file', '-e', `${remoteRef}:${filePath}`]);
+            git(repoPath, ['checkout', remoteRef, '--', filePath]);
+            return 'remote';
+        }
+        catch {
+            // File doesn't exist at origin/<branch> (added locally) — fall through.
+        }
+    }
+    try {
+        git(repoPath, ['cat-file', '-e', `HEAD:${filePath}`]);
+        git(repoPath, ['checkout', 'HEAD', '--', filePath]);
+        return 'head';
+    }
+    catch {
+        // File is untracked OR has already been rolled back — delete it from
+        // disk if still present. Idempotent: if the file is already gone (race
+        // with a previous rollback, stale UI list, manual rm), we still return
+        // 'deleted' since the end state matches the user's intent. `rmSync`
+        // over `git clean -f` keeps the action narrow to one file.
+        const absPath = join(repoPath, filePath);
+        if (existsSync(absPath)) {
+            rmSync(absPath, { force: true });
+        }
+        return 'deleted';
+    }
+}
+/** @deprecated kept for backwards-compat with older imports — use `rollbackFile`. */
+export const rollbackFileToRemote = rollbackFile;
 /** Get the current content of a file in the worktree. Returns null if the file doesn't exist. */
 export function getFileContent(repoPath, filePath) {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loicngr/kobo",
-  "version": "1.6.14",
+  "version": "1.7.0",
   "description": "Kōbō — multi-workspace agent manager for Claude Code. Orchestrates isolated git worktrees with dev servers, Notion integration, and MCP tools.",
   "type": "module",
   "license": "GPL-3.0-or-later",
@@ -66,6 +66,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.126",
     "@hono/node-server": "^1.19.13",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "better-sqlite3": "^12.8.0",