@loicngr/kobo 1.7.22 → 1.7.23

package/AGENTS.md

@@ -100,7 +100,7 @@ src/
 
 | Table | Purpose |
 |---|---|
-| `workspaces` | the unit of work — id, name, project_path, source_branch, working_branch, status, notion_url, model, dev_server_status, `archived_at`, `auto_loop`, `auto_loop_ready`, `no_progress_streak`, timestamps |
+| `workspaces` | the unit of work — id, name, project_path, source_branch, working_branch, status, notion_url, model, dev_server_status, `archived_at`, `worktree_purged_at`, `worktree_purge_restore_data` (JSON), `auto_loop`, `auto_loop_ready`, `no_progress_streak`, timestamps |
 | `tasks` | workspace sub-items — title, status, `is_acceptance_criterion`, sort_order; CASCADE DELETE on workspace |
 | `agent_sessions` | Claude Code CLI invocations — pid, `claude_session_id`, status, started_at, ended_at, `name` |
 | `ws_events` | persisted WebSocket events for replay on reconnect — type, payload, session_id, created_at |
@@ -111,6 +111,8 @@ src/
 
 `archived_at` is **orthogonal** to `status` — archiving is a visibility flag, not a lifecycle state. Unarchive restores the exact pre-archive `status`.
 
+`worktree_purged_at` + `worktree_purge_restore_data` drive the disk-space purge feature (see [Worktree purge](#worktree-purge) below): when set, the workspace's worktree folder has been removed from disk but the chat history is preserved. `worktree_purge_restore_data` is a JSON blob (`{ prNumber, prUrl, forge, mergeCommitSha, originalWorktreePath, originalSourceBranch, originalWorkingBranch }`) captured at purge time for future "Restore" UX. Both fields are cleared automatically by the pr-watcher when the worktree folder reappears on disk.
+
 `auto_loop` (bool, default 0), `auto_loop_ready` (bool, default 0) and `no_progress_streak` (int, default 0) drive the auto-loop feature: when `auto_loop=1`, `session:ended` triggers `auto-loop-service.onSessionEnded` which either spawns the next iteration via a fresh `startAgent(resume=false)`, disables with `reason='completed'` (no pending tasks), or disables with `reason='stall'` (3 consecutive sessions without a task completed). Archive + delete both auto-disable.
 
 ## Database migrations
@@ -219,6 +221,14 @@ Background: the engine was migrated from `@openai/codex-sdk` (one-shot `codex ex
 - **Custom bash override** — if `effective.changeSourceBranchScript` is non-empty (per-project override or global default), the script **replaces** the built-in flow. Spawned with `bash -c`, cwd = worktree, 5 min timeout, stderr captured (last 8 KB). Exit 0 → Kōbō updates the source-branch metadata; any non-zero exit → the stderr tail is propagated as a clean error. The user-facing menu item only shows when the resolved script is non-empty — empty = feature disabled (opt-in).
 - **Custom-script env vars** — `KOBO_NEW_BASE`, `KOBO_OLD_BASE`, `KOBO_WORKING_BRANCH`, `KOBO_WORKTREE_PATH`, `KOBO_PROJECT_PATH`, `KOBO_PROJECT_NAME`, `KOBO_WORKSPACE_ID`, `KOBO_WORKSPACE_NAME`, `KOBO_FORGE`, `KOBO_PR_NUMBER` (empty when no PR/MR is open). The default script lives in `settings-defaults.ts` and is seeded into `global.changeSourceBranchScript` by settings migration v33; the client reads it through `GET /api/settings/defaults` for the "Reset to Kōbō default" button. See [CONFIGURATION.md → Custom change-source-branch script](CONFIGURATION.md#custom-change-source-branch-script).
 
+### Worktree purge
+
+`src/server/services/worktree-purge-service.ts` removes a workspace's worktree from disk while preserving the chat history and PR metadata. Triggered manually via `POST /api/workspaces/:id/purge-worktree` from the workspace context menu, or automatically by the pr-watcher when a PR transitions to MERGED **and** `global.autoPurgeOnPrMerged` is enabled (Settings → Worktrees toggle, settings migration v36).
+
+Sequence: `captureRestoreData` (best-effort forge lookup for PR number / URL / merge SHA) → stop agent + dev server + terminal → `archiveWorkspace` → `removeWorktree` → `markWorktreePurged(restoreData)` → emit `workspace:worktree-purged`. Permission errors on removal (EACCES / EPERM — typically Docker-owned files in `node_modules` / `vendor`) are detected via regex on the error message and the warning toast carries a copy-pasteable `sudo rm -rf` + `git worktree prune` recovery command plus prevention tips (Docker `USER` directive, `setfacl` default ACL). See [CONFIGURATION.md → Auto-purge worktree on PR merged](CONFIGURATION.md#auto-purge-worktree-on-pr-merged).
+
+**Auto-restore on manual recreation.** When the user manually recreates the worktree folder (`gh pr checkout <pr-number>` or `git worktree add <path> <branch>`), the pr-watcher detects the folder reappearing on its next 30 s tick via `autoRestoreManuallyRecreatedWorktrees()`: it iterates archived workspaces with `worktreePurgedAt`, checks `fs.existsSync(worktreePath)`, and on a hit calls `restoreWorktreeFromDisk(id)` which clears `worktree_purged_at` + `worktree_purge_restore_data` + `archived_at` in one transaction, then emits `workspace:worktree-restored`. The client websocket store reuses the same handler as `workspace:archived`/`unarchived` to refresh both the active and archived workspace lists. No UI action needed.
+
 ### Workspace attention indicators
 
 `src/client/src/utils/workspace-attention.ts` derives a small set of badges (CI failure, changes-requested) from the PR snapshot + git stats stored on each workspace. `WorkspaceAttentionLabels.vue` renders them inline on the workspace cards in the left drawer. The derivation is a pure function — easy to unit-test, no IO. Drawer cards therefore stay reactive to whatever the pr-watcher / bulk-info refresh writes back into the store.

package/CHANGELOG.md

@@ -4,6 +4,21 @@ All notable changes to Kōbō are documented here. The format is based on
 [Keep a Changelog](https://keepachangelog.com/). Each release is an `## <version>`
 section — the in-app "What's new" dialog reads this file.
 
+## 1.7.23
+
+- docs: document worktree purge, auto-restore, and permission recovery
+- feat(client): onboarding highlights changelog and auto-purge toggle
+- feat(pr-watcher): auto-restore manually-recreated worktrees
+- feat(workspace): worktree purge with auto-archive and restore metadata
+- feat(templates): add /kobo-context slash command (you need to re-import default templates)
+
+## Unreleased
+
+- feat(workspace): disk-space purge — remove a workspace's worktree from disk while preserving chat history and PR metadata. Manual trigger from the workspace menu ("Libérer l'espace disque") or auto-purge on PR merged via Settings → Worktrees toggle.
+- feat(workspace): auto-detect manual worktree restoration — when the user recreates a purged worktree folder (`gh pr checkout` or `git worktree add`), the pr-watcher detects it within 30 s and unarchives the workspace automatically.
+- feat(client): dedicated banner for purged workspaces on the workspace page, with the restoration commands and `setfacl` / `chown` recovery guide for Docker-induced permission errors.
+- fix(pr-watcher): skip workspaces whose worktree directory no longer exists, stopping the `spawn git ENOENT` log spam.
+
 ## 1.7.22
 
 - feat(client): accept the new app.notion.com URL format

package/README.md

@@ -24,6 +24,7 @@ Kōbō runs multiple coding agents in parallel, each isolated in its own git wor
 - **Scheduled wakeups** — the agent schedules a one-shot wake-up via the `ScheduleWakeup` tool; Kōbō persists it across restarts, shows a live countdown, and re-invokes the agent with the stored prompt at the chosen time.
 - **Cron schedules** — recurring per-workspace triggers the agent registers through MCP tools (`cron_create` / `cron_delete` / `cron_list`); each tick resumes the workspace session (skipped if already active), and schedules are re-armed at boot with skip-missed semantics.
 - **Lifecycle scripts** — shell scripts run automatically at key moments: **setup** (worktree created), **cleanup** (session ended), **archive** (workspace archived). Configured globally or per project, with their output streamed into the chat.
+- **Disk-space purge** — free a merged workspace's disk space without losing its chat history: the worktree folder is removed (PR metadata is captured for later restore), the workspace is archived, and the chat log stays queryable. Trigger manually from the workspace menu or enable **auto-purge on PR merged** in Settings → Worktrees. Recreate the worktree later with `gh pr checkout <pr-number>` and Kōbō auto-detects the folder reappearing within 30 seconds — workspace is unarchived and reactivated, no UI action needed.
 - **Optional integrations** — Notion (import missions), Sentry (fix from issue URL), local voice transcription (whisper.cpp).
 
 ## Quick start
@@ -77,6 +78,36 @@ The full reference — every env var, every setting key, MCP server registration
 
 Engine selection happens at workspace creation. Both share the same task tracking, permission modes, sub-agent panel, and quota footer. The mapping of Kōbō's four permission modes (`plan` / `bypass` / `strict` / `interactive`) to each engine's native sandbox + approval semantics is in [`CONFIGURATION.md`](./CONFIGURATION.md#permission-modes).
 
+## Disk-space purge
+
+A merged workspace is automatically archived but its worktree folder usually carries a lot of weight (`node_modules`, `vendor`, build artefacts…). Kōbō can free that space without losing anything queryable:
+
+- **Manual** — workspace context menu → *Libérer l'espace disque*. The worktree is removed, the chat history and PR metadata stay in the database.
+- **Automatic** — **Settings → Worktrees → Purger le worktree quand la PR est mergée**. When the pr-watcher sees the OPEN → MERGED transition, it archives **and** purges.
+- **Restore** — recreate the folder yourself (`gh pr checkout <pr>` or `git worktree add <path> <branch>`). The pr-watcher detects the directory reappearing within 30 seconds and re-activates the workspace automatically (clears purge flag + unarchives). No UI action needed.
+
+### Avoiding permission errors during purge
+
+Docker containers usually write as `root`, so files in `node_modules` / `vendor` end up root-owned on the host. Plain `rm -rf` (which Kōbō uses under the hood) then fails with `EACCES` / `EPERM`. Pick one of these strategies depending on your setup:
+
+1. **Best — run your container as the host user.** Add a `USER` directive in your `Dockerfile`, or set `user: "${UID}:${GID}"` in `docker-compose.yml` with `UID`/`GID` exported in your shell. No more root-owned files; nothing extra to do.
+2. **Preventive ACL on the worktrees root.** On ext4 / btrfs / xfs with a regular Docker bind mount, a default ACL grants your user access to every file created later:
+   ```bash
+   setfacl -d -m u:$(whoami):rwX <worktrees-root>   # e.g. ~/.worktrees
+   ```
+   Caveats: does **not** work on named Docker volumes (use a bind mount), filesystems without ACL support (NTFS, exFAT, tmpfs), strict SELinux with `:Z`, or with Docker `userns-remap`.
+3. **Unblock an already-broken worktree** (existing root-owned files):
+   ```bash
+   # Option A — recursive ACL (keeps ownership intact, just adds your user)
+   sudo setfacl -Rd -m u:$(whoami):rwX . && sudo setfacl -R -m u:$(whoami):rwX .
+
+   # Option B — take ownership outright (simpler, loses the "root-from-container" trace)
+   sudo chown -R $(whoami):$(whoami) .
+   ```
+   Run from inside the worktree folder, or directly on your worktrees root (e.g. `~/.worktrees/`) to cover all existing and future workspaces at once.
+
+When a purge does fail, Kōbō surfaces a toast with a copy-pasteable recovery command and a `git worktree prune` follow-up. The same guide is wired into **Settings → Worktrees → Comment ça marche** for in-app reference.
+
 ## Optional integrations
 
 Kōbō ships first-class support for three external systems. All are opt-in and reuse credentials you may already have configured for Claude Code.

package/dist/server/db/migrations.js

@@ -339,6 +339,29 @@ export const migrations = [
             }
         },
     },
+    {
+        version: 27,
+        name: 'add-workspace-worktree-purge',
+        migrate: (db) => {
+            // Worktree purge: deletes the worktree from disk to reclaim space while
+            // keeping the chat/session history queryable. `worktree_purged_at` is the
+            // ISO timestamp of the purge (null = not purged). `worktree_purge_restore_data`
+            // is a JSON blob with the metadata needed to restore the worktree later
+            // (PR number, forge, merge commit sha, original paths). Restoration is
+            // not implemented yet, but the data is captured at purge time so future
+            // versions can rebuild the worktree from the merged PR.
+            const table = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='workspaces'").get();
+            if (!table)
+                return;
+            const cols = db.prepare('PRAGMA table_info(workspaces)').all();
+            if (!cols.some((c) => c.name === 'worktree_purged_at')) {
+                db.prepare('ALTER TABLE workspaces ADD COLUMN worktree_purged_at TEXT').run();
+            }
+            if (!cols.some((c) => c.name === 'worktree_purge_restore_data')) {
+                db.prepare('ALTER TABLE workspaces ADD COLUMN worktree_purge_restore_data TEXT').run();
+            }
+        },
+    },
 ];
 /** Current schema version — always equals the highest migration version. */
 export const SCHEMA_VERSION = migrations.length > 0 ? migrations[migrations.length - 1].version : 1;

package/dist/server/db/schema.js

@@ -32,6 +32,8 @@ export function initSchema(db) {
       initial_prompt TEXT,
       pr_changes_dismissed_at TEXT,
       pr_ci_failure_dismissed_at TEXT,
+      worktree_purged_at TEXT,
+      worktree_purge_restore_data TEXT,
       created_at TEXT NOT NULL,
       updated_at TEXT NOT NULL
     );

package/dist/server/routes/workspaces.js

@@ -35,6 +35,7 @@ import * as terminalService from '../services/terminal-service.js';
 import * as wakeupService from '../services/wakeup-service.js';
 import * as wsService from '../services/websocket-service.js';
 import * as workspaceService from '../services/workspace-service.js';
+import * as purgeWorktreeService from '../services/worktree-purge-service.js';
 import * as worktreeService from '../services/worktree-service.js';
 import { resolveUniqueBranchAndPath } from '../utils/branch-resolver.js';
 import * as gitOps from '../utils/git-ops.js';
@@ -1922,6 +1923,31 @@ app.post('/:id/archive', migrationGuard, (c) => {
         return c.json({ error: message }, 500);
     }
 });
+// POST /api/workspaces/:id/purge-worktree — delete the worktree from disk
+// to reclaim space while keeping the chat / session history queryable. Auto-
+// archives the workspace, stops the agent / dev server / terminal, and
+// records restore metadata so a future feature can rebuild the worktree
+// from the merged PR.
+app.post('/:id/purge-worktree', migrationGuard, async (c) => {
+    try {
+        const id = c.req.param('id');
+        const result = await purgeWorktreeService.purgeWorktree(id);
+        if (result.outcome === 'not-found') {
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        }
+        if (result.outcome === 'worktree-not-owned') {
+            return c.json({
+                error: "This workspace attached to an external worktree (you own it). Kōbō refuses to delete files it didn't create.",
+            }, 400);
+        }
+        const workspace = workspaceService.getWorkspace(id);
+        return c.json({ workspace, warnings: result.warnings, outcome: result.outcome });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
 // POST /api/workspaces/:id/unarchive — restore an archived workspace
 app.post('/:id/unarchive', migrationGuard, (c) => {
     try {
@@ -1933,6 +1959,14 @@ app.post('/:id/unarchive', migrationGuard, (c) => {
         if (!workspace.archivedAt) {
             return c.json({ error: 'Not archived' }, 400);
         }
+        // A workspace whose worktree was purged from disk can't be safely
+        // unarchived — its worktreePath points to nothing, every git/forge call
+        // would fail, and the agent has no working tree. Force the user to
+        // restore the worktree first (manual `gh pr checkout` / `git worktree
+        // add`); the pr-watcher then auto-clears the purge flag + unarchives.
+        if (workspace.worktreePurgedAt) {
+            return c.json({ error: 'worktree-purged' }, 409);
+        }
         const updated = workspaceService.unarchiveWorkspace(id);
         wsService.emitEphemeral(id, 'workspace:unarchived', { workspace: updated });
         return c.json(updated);
@@ -1956,6 +1990,14 @@ function deleteWorkspaceWithSideEffects(workspace, opts) {
     catch {
         // Agent may not be running — ignore
     }
+    // Stop dev server if it was running. The processSpawn would otherwise
+    // outlive the workspace (and keep its port + docker containers alive).
+    try {
+        devServerService.stopDevServer(workspace.id);
+    }
+    catch (err) {
+        console.error(`[workspaces] stopDevServer during delete failed for '${workspace.name}':`, err);
+    }
     try {
         terminalService.destroyTerminal(workspace.id);
     }
@@ -1972,7 +2014,14 @@ function deleteWorkspaceWithSideEffects(workspace, opts) {
     // Remove worktree (only if owned — for attached external worktrees we
     // never created the dir, so we must not delete it on the user's behalf).
     const worktreePath = workspace.worktreePath;
-    if (workspace.worktreeOwned) {
+    if (workspace.worktreePurgedAt) {
+        // Already purged earlier: the worktree folder is gone AND `git worktree
+        // remove` already cleaned the `.git/worktrees/<name>/` entry. Retrying
+        // here just fails with "fatal: <path> does not exist" and pushes a noisy
+        // warning. Skip cleanly.
+        console.log(`[workspaces] skipping worktree removal on delete (already purged): ${worktreePath}`);
+    }
+    else if (workspace.worktreeOwned) {
         try {
             worktreeService.removeWorktree(workspace.projectPath, worktreePath);
         }

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

@@ -1,11 +1,14 @@
+import fs from 'node:fs';
 import { fetchSourceBranchAsync } from '../utils/git-ops.js';
 import { stopDevServer } from './dev-server-service.js';
 import { getForgeProvider } from './forge/registry.js';
 import { resolveForge } from './forge/resolve.js';
 import { computeGitStats } from './git-stats-service.js';
+import { getGlobalSettings } from './settings-service.js';
 import { destroyTerminal } from './terminal-service.js';
 import { emitEphemeral } from './websocket-service.js';
-import { archiveWorkspace, getWorkspace, listWorkspaces, markWorkspaceUnread, updateWorkspaceSourceBranch, } from './workspace-service.js';
+import { archiveWorkspace, getWorkspace, listArchivedWorkspaces, listWorkspaces, markWorkspaceUnread, restoreWorktreeFromDisk, updateWorkspaceSourceBranch, } from './workspace-service.js';
+import { purgeWorktree } from './worktree-purge-service.js';
 // ── PR Watcher ────────────────────────────────────────────────────────────────
 // Polls GitHub every POLL_INTERVAL_MS to detect merged/closed PRs and
 // automatically archive the corresponding workspace.
@@ -63,7 +66,30 @@ function markUnread(workspaceId) {
         console.error('[pr-watcher] markUnread failed:', err instanceof Error ? err.message : err);
     }
 }
+/**
+ * Detect manually-restored worktrees: if a purged workspace's worktreePath
+ * has reappeared on disk (user ran `gh pr checkout` or `git worktree add`
+ * themselves), clear the purge metadata + unarchive it. Best-effort, runs
+ * once per watcher tick before the PR-status pass.
+ */
+function autoRestoreManuallyRecreatedWorktrees() {
+    for (const ws of listArchivedWorkspaces()) {
+        if (!ws.worktreePurgedAt)
+            continue;
+        if (!fs.existsSync(ws.worktreePath))
+            continue;
+        try {
+            const restored = restoreWorktreeFromDisk(ws.id);
+            emitEphemeral(ws.id, 'workspace:worktree-restored', { workspace: restored });
+            console.log(`[pr-watcher] auto-restored worktree for workspace '${ws.name}' (manual restore detected)`);
+        }
+        catch (err) {
+            console.error(`[pr-watcher] auto-restore failed for '${ws.name}':`, err instanceof Error ? err.message : err);
+        }
+    }
+}
 export async function checkPrStatuses() {
+    autoRestoreManuallyRecreatedWorktrees();
     const workspaces = listWorkspaces(false); // non-archived only
     // Clean up entries for workspaces that no longer exist
     for (const id of lastKnownPr.keys()) {
@@ -77,6 +103,11 @@ export async function checkPrStatuses() {
         }
     }
     for (const ws of workspaces) {
+        // Skip workspaces whose worktree directory has disappeared (purged
+        // externally, manually deleted). Without this guard, every git/forge
+        // spawn below fails with ENOENT and floods the logs.
+        if (!fs.existsSync(ws.worktreePath))
+            continue;
         try {
             const pr = await getForgeProvider(resolveForge(ws.projectPath)).getPrStatus(ws.worktreePath, ws.workingBranch);
             // Detect a PR base change BEFORE computing git stats so the new base
@@ -151,6 +182,24 @@ export async function checkPrStatuses() {
                     reason: `PR ${pr.state.toLowerCase()}`,
                     prUrl: pr.url,
                 });
+                // Auto-purge the worktree on MERGED + opt-in setting. The purge
+                // service is idempotent + best-effort: any failure surfaces as
+                // warnings on the next listing instead of crashing the watcher.
+                // Only acts on MERGED — closed-without-merge keeps the worktree
+                // around so the user can inspect / push fixes.
+                if (pr.state === 'MERGED') {
+                    try {
+                        const { autoPurgeOnPrMerged } = getGlobalSettings();
+                        if (autoPurgeOnPrMerged) {
+                            void purgeWorktree(ws.id).catch((err) => {
+                                console.error(`[pr-watcher] auto-purge failed for '${ws.name}':`, err instanceof Error ? err.message : err);
+                            });
+                        }
+                    }
+                    catch (err) {
+                        console.error(`[pr-watcher] auto-purge guard failed for '${ws.name}':`, err instanceof Error ? err.message : err);
+                    }
+                }
                 continue; // do not run base-change detection on a workspace we just archived
             }
             // Review-decision and CI transitions (only on OPEN PRs; first-sight is

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

@@ -598,6 +598,19 @@ const settingsMigrations = [
             }
         },
     },
+    {
+        version: 36,
+        name: 'add-auto-purge-on-pr-merged',
+        migrate: ({ global }) => {
+            // Opt-in: when true, the pr-watcher purges the worktree from disk
+            // immediately after auto-archiving on a PR merge transition. The
+            // workspace stays consultable (chat history, sessions) but reclaims
+            // the disk space. Default false — feature is silent until enabled.
+            if (typeof global.autoPurgeOnPrMerged !== 'boolean') {
+                global.autoPurgeOnPrMerged = false;
+            }
+        },
+    },
 ];
 /** Current settings schema version — always equals the highest migration version. */
 export const SETTINGS_SCHEMA_VERSION = settingsMigrations.length > 0 ? settingsMigrations[settingsMigrations.length - 1].version : 0;
@@ -641,6 +654,7 @@ function defaultSettings() {
             changeSourceBranchScript: DEFAULT_CHANGE_SOURCE_BRANCH_SCRIPT,
             editorCommand: '',
             fileManagerCommand: '',
+            autoPurgeOnPrMerged: false,
             browserNotifications: true,
             audioNotifications: true,
             audioNotificationSound: 'hey.mp3',
@@ -979,6 +993,7 @@ export function updateGlobalSettings(data) {
         'changeSourceBranchScript',
         'editorCommand',
         'fileManagerCommand',
+        'autoPurgeOnPrMerged',
         'browserNotifications',
         'audioNotifications',
         'audioNotificationSound',

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

@@ -127,6 +127,38 @@ export function replaceAllTemplates(templates) {
     writeTemplates(validated);
 }
 export const DEFAULT_TEMPLATES = [
+    {
+        slug: 'kobo-context',
+        description: "Onboard the agent on Kōbō's core concepts and tools",
+        content: `You are working inside a Kōbō workspace (workspace "{workspace_name}", branch \`{working_branch}\`).\n\n` +
+            `# What Kōbō is\n` +
+            `Kōbō orchestrates multiple coding agents in parallel. Each "workspace" is a self-contained mission with:\n` +
+            `- An isolated git worktree (your current working directory)\n` +
+            `- A dedicated branch (\`{working_branch}\`), targeting a source branch\n` +
+            `- Its own session history and task list, persisted in Kōbō's SQLite DB\n` +
+            `- A dedicated MCP server (\`kobo-tasks\`) exposing tools to read/write workspace state\n\n` +
+            `# Lifecycle\n` +
+            `1. **Brainstorming** — you scope the work, output a plan, end with the literal marker \`[BRAINSTORM_COMPLETE]\`\n` +
+            `2. **Executing** — you implement the plan, commit, push\n` +
+            `3. **Auto-loop (opt-in)** — Kōbō re-spawns a fresh session per task; each iteration sees a clean context\n` +
+            `4. **Completed / Archived** — the workspace freezes; the worktree stays available read-only\n\n` +
+            `# Kōbō MCP tools (always namespaced \`kobo__…\`)\n` +
+            `- \`kobo__list_tasks\` / \`create_task\` / \`update_task\` / \`mark_task_done\` / \`delete_task\` — manage the visible task list\n` +
+            `- \`kobo__set_workspace_agent_description\` — short one-line summary shown in the sidebar; keep it current\n` +
+            `- \`kobo__get_workspace_info\` / \`kobo__get_git_info\` — read workspace metadata + git state\n` +
+            `- \`kobo__cron_create\` / \`cron_delete\` / \`cron_list\` — schedule recurring or one-shot triggers on THIS workspace\n` +
+            `- \`kobo__mark_auto_loop_ready\` — flip the loop into auto-execution after grooming\n\n` +
+            `# Conventions\n` +
+            `- \`CLAUDE.md\` / \`AGENTS.md\` at the project root override default behavior — read them first\n` +
+            `- \`.ai/.git-conventions.md\` (when present) defines per-project commit / branch rules — apply them on every git op\n` +
+            `- \`.ai/thoughts/\` is your persistent scratch (Notion imports, Sentry context, planning notes) — write freely\n` +
+            `- Never use \`--no-verify\` or skip CI hooks unless explicitly asked\n` +
+            `- Always target \`origin/<source_branch>\` for diffs and PRs, not the local branch\n\n` +
+            `# Boundaries\n` +
+            `- The user owns the \`description\` field of the workspace — never write it; you only own \`agent_description\`\n` +
+            `- The user can interrupt you at any time via the chat; treat their messages as authoritative redirections\n` +
+            `- Auto-loop is automatically disabled if the user sends a chat message during a loop — they'll re-enable it manually after\n`,
+    },
     {
         slug: 'review-quality',
         description: 'Code quality review',

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

@@ -59,6 +59,8 @@ function mapWorkspace(row) {
         initialPrompt: row.initial_prompt,
         prChangesDismissedAt: row.pr_changes_dismissed_at,
         prCiFailureDismissedAt: row.pr_ci_failure_dismissed_at,
+        worktreePurgedAt: row.worktree_purged_at,
+        worktreePurgeRestoreData: row.worktree_purge_restore_data,
         engine: row.engine ?? 'claude-code',
         autoLoop: row.auto_loop === 1,
         autoLoopReady: row.auto_loop_ready === 1,
@@ -365,6 +367,38 @@ export function dismissPrAttention(id, kind, prUpdatedAt) {
         throw new Error(`Workspace '${id}' not found`);
     }
 }
+/**
+ * Mark a workspace's worktree as purged from disk. Persists the supplied
+ * restore data as JSON so a future "unpurge" feature can recreate the
+ * worktree from the merged PR. Idempotent: re-purging a workspace just
+ * overwrites the timestamp + data.
+ */
+export function markWorktreePurged(id, restoreData) {
+    const db = getDb();
+    const now = new Date().toISOString();
+    const result = db
+        .prepare('UPDATE workspaces SET worktree_purged_at = ?, worktree_purge_restore_data = ?, updated_at = ? WHERE id = ?')
+        .run(now, JSON.stringify(restoreData), now, id);
+    if (result.changes === 0) {
+        throw new Error(`Workspace '${id}' not found`);
+    }
+}
+/**
+ * Reverse of `markWorktreePurged` + `archiveWorkspace`: clears the purge
+ * metadata and unarchives the workspace in a single transaction. Used by the
+ * auto-restore watcher when the user manually recreates the worktree folder
+ * on disk. Idempotent: no-op if already restored.
+ */
+export function restoreWorktreeFromDisk(id) {
+    const db = getDb();
+    const workspace = getWorkspace(id);
+    if (!workspace) {
+        throw new Error(`Workspace '${id}' not found`);
+    }
+    const now = new Date().toISOString();
+    db.prepare('UPDATE workspaces SET worktree_purged_at = NULL, worktree_purge_restore_data = NULL, archived_at = NULL, updated_at = ? WHERE id = ?').run(now, id);
+    return getWorkspace(id);
+}
 /** Update the dev-server status column for a workspace. */
 export function updateDevServerStatus(id, status) {
     const db = getDb();

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

@@ -0,0 +1,151 @@
+import fs from 'node:fs';
+import * as agentManager from './agent/orchestrator.js';
+import * as devServerService from './dev-server-service.js';
+import { getForgeProvider } from './forge/registry.js';
+import { resolveForge } from './forge/resolve.js';
+import { destroyTerminal } from './terminal-service.js';
+import { emitEphemeral } from './websocket-service.js';
+import { archiveWorkspace, getWorkspace, markWorktreePurged, } from './workspace-service.js';
+import { removeWorktree } from './worktree-service.js';
+/**
+ * Purge the worktree of a workspace: stops the agent, the dev server and the
+ * terminal (best-effort), removes the worktree dir + git registration, then
+ * records the purge timestamp + restore metadata so a future version can
+ * recreate the worktree from the merged PR.
+ *
+ * The workspace is auto-archived on purge — disk-purged is a strict superset
+ * of archived (no agent can run on a missing worktree). Archive emits its
+ * own event before this function tags the workspace as purged.
+ */
+export async function purgeWorktree(workspaceId) {
+    const workspace = getWorkspace(workspaceId);
+    if (!workspace)
+        return { outcome: 'not-found', warnings: [] };
+    if (workspace.worktreePurgedAt)
+        return { outcome: 'already-purged', warnings: [] };
+    if (!workspace.worktreeOwned)
+        return { outcome: 'worktree-not-owned', warnings: [] };
+    const warnings = [];
+    // Best-effort cleanup before touching the disk. A failure here is logged
+    // but does NOT block the purge — leaving a stranded worktree on disk would
+    // defeat the feature's purpose.
+    try {
+        agentManager.stopAgent(workspaceId);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`[purge] stopAgent failed for '${workspace.name}':`, msg);
+    }
+    try {
+        devServerService.stopDevServer(workspaceId);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`[purge] stopDevServer failed for '${workspace.name}':`, msg);
+    }
+    try {
+        destroyTerminal(workspaceId);
+    }
+    catch {
+        // terminal may not exist — silent
+    }
+    // Capture restore metadata BEFORE removing the worktree so we still have a
+    // chance to query the forge for the latest PR snapshot.
+    const restoreData = await captureRestoreData(workspace);
+    // Archive first so the workspace:archived event fires while the worktree
+    // still technically exists — listeners that snapshot disk state get a
+    // consistent picture. Archive is idempotent.
+    if (!workspace.archivedAt) {
+        try {
+            const archived = archiveWorkspace(workspaceId);
+            emitEphemeral(workspaceId, 'workspace:archived', { workspace: archived });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            warnings.push(`Archive failed: ${msg}`);
+        }
+    }
+    // Remove the worktree. fs.existsSync guard handles the case where the user
+    // already nuked it externally — the git registration still needs cleaning,
+    // which removeWorktree does too.
+    if (fs.existsSync(workspace.worktreePath)) {
+        try {
+            removeWorktree(workspace.projectPath, workspace.worktreePath);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            warnings.push(buildRemovalFailureMessage(workspace.worktreePath, workspace.projectPath, msg));
+        }
+    }
+    try {
+        markWorktreePurged(workspaceId, restoreData);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        warnings.push(`DB metadata update failed: ${msg}`);
+    }
+    emitEphemeral(workspaceId, 'workspace:worktree-purged', {
+        workspaceId,
+        purgedAt: new Date().toISOString(),
+        restoreData,
+    });
+    return { outcome: 'purged', warnings };
+}
+/**
+ * Pretty failure message for `removeWorktree` errors. Detects permission
+ * issues (typical when Docker / docker-compose left root-owned files in
+ * `node_modules`, `vendor`, etc.) and surfaces a one-line `sudo` command
+ * the user can paste to recover. Other errors get a generic recovery hint.
+ */
+function buildRemovalFailureMessage(worktreePath, projectPath, errMsg) {
+    const isPermission = /EACCES|EPERM|permission denied|operation not permitted/i.test(errMsg);
+    const baseLine = `Failed to remove worktree '${worktreePath}'.`;
+    const recovery = ['Recovery:', `  sudo rm -rf '${worktreePath}'`, `  cd '${projectPath}' && git worktree prune`].join('\n');
+    if (isPermission) {
+        return [
+            `${baseLine} Permission denied — typically caused by Docker leaving root-owned files inside node_modules / vendor.`,
+            recovery,
+            'Prevention: configure your container to run as your host user (USER directive in Dockerfile, or `user: "$(id -u):$(id -g)"` in docker-compose), OR pre-seed the worktrees root with a default ACL:',
+            `  setfacl -d -m u:$(whoami):rwx '${projectPath}/..'/worktrees`,
+            `Reason: ${errMsg}`,
+        ].join('\n');
+    }
+    return [baseLine, recovery, `Reason: ${errMsg}`].join('\n');
+}
+/**
+ * Build the restore-data snapshot stored alongside the purge. Reads the PR
+ * snapshot from the watcher cache when available, then tries a fresh forge
+ * lookup as a fallback. Never throws — best-effort. Reserved for a future
+ * unpurge feature.
+ */
+async function captureRestoreData(workspace) {
+    const forge = resolveForge(workspace.projectPath);
+    let prNumber = null;
+    let prUrl = null;
+    // Forge lookup is best-effort — silent on failure since the field is
+    // purely advisory for the future unpurge feature. We always go direct to
+    // the provider (no pr-watcher cache) to avoid an import cycle between
+    // the watcher and the purge service.
+    if (forge !== 'none') {
+        try {
+            const provider = getForgeProvider(forge);
+            const fresh = await provider.getPrStatus(workspace.worktreePath, workspace.workingBranch);
+            if (fresh) {
+                prNumber = fresh.number ?? null;
+                prUrl = fresh.url ?? null;
+            }
+        }
+        catch (err) {
+            console.warn(`[purge] PR lookup for restore data failed:`, err instanceof Error ? err.message : err);
+        }
+    }
+    return {
+        prNumber,
+        prUrl,
+        forge: forge,
+        mergeCommitSha: null,
+        originalWorktreePath: workspace.worktreePath,
+        originalSourceBranch: workspace.sourceBranch,
+        originalWorkingBranch: workspace.workingBranch,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loicngr/kobo",
-  "version": "1.7.22",
+  "version": "1.7.23",
   "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",

package/src/client/dist/spa/assets/{ActivityFeed-B73SoxPh.js → ActivityFeed-CPvR4uDQ.js}

@@ -1,4 +1,4 @@
-import{D as e,G as t,I as n,N as r,P as i,R as a,St as o,W as s,_ as c,at as l,d as u,et as d,f,g as p,l as m,p as h,r as g,u as _,xt as v,y,yt as b}from"./runtime-core.esm-bundler-D_RRiKBh.js";import{U as x,l as S,t as C}from"./QIcon-BmEX2rXO.js";import{c as w,s as T}from"./notifications-Dq_CVZlr.js";import{t as E}from"./QBtn-CoU-UC_j.js";import{n as D}from"./vue-i18n-Cq-KgjJC.js";import{_ as O,c as k,m as A,u as j}from"./index-djIkvHo7.js";import{t as M}from"./QSpinnerDots-DspFKwCZ.js";import{t as N}from"./QTooltip-CxkTFl9W.js";import{t as ee}from"./QExpansionItem-C3koMJhv.js";import{t as te}from"./QScrollArea-HmkWoNcD.js";import{i as ne,n as re,t as P}from"./render-chat-markdown-D5id7lkF.js";import{t as F}from"./documents-CX2-4fhr.js";import{t as I}from"./_plugin-vue_export-helper-r4mAJOHR.js";function ie(e,t,n=!0){let r=[],i=new Map,a=new Map;for(let n=0;n<e.length;n++){let o=e[n],s=t?.[n];switch(o.kind){case`message:text`:{let e=i.get(o.messageId);if(e)e.text+=o.text,e.streaming=o.streaming;else{let e={type:`text`,messageId:o.messageId,text:o.text,streaming:o.streaming,ts:s};i.set(o.messageId,e),r.push(e)}break}case`message:end`:{let e=i.get(o.messageId);e&&(e.streaming=!1);break}case`message:thinking`:r.push({type:`thinking`,messageId:o.messageId,text:o.text,ts:s});break;case`tool:call`:{let e={type:`tool`,toolCallId:o.toolCallId,name:o.name,input:o.input,ts:s};a.set(o.toolCallId,e),r.push(e);break}case`tool:result`:{let e=a.get(o.toolCallId);e&&(e.result={output:o.output,isError:o.isError});break}case`session:started`:r.push({type:`session`,kind:`started`,detail:{engineSessionId:o.engineSessionId,model:o.model},ts:s});break;case`session:ended`:r.push({type:`session`,kind:`ended`,detail:{reason:o.reason,exitCode:o.exitCode},ts:s});break;case`session:compacted`:r.push({type:`session`,kind:`compacted`,ts:s});break;case`session:brainstorm-complete`:case`session:user-input-requested`:case`message:raw`:case`skills:discovered`:case`usage`:case`rate_limit`:case`subagent:progress`:case`error`:break;default:}}let o=null;for(let e of r)e.type===`text`&&e.streaming&&(o&&(o.streaming=!1),o=e);return o&&!n&&(o.streaming=!1),r}function ae(e,t){if(t.length===0)return e;let n=t.map(e=>({type:`user`,content:e.content,sender:e.sender,ts:e.ts})),r=[...e,...n];r.sort((e,t)=>{let n=e.ts??``,r=t.ts??``;return n===r?0:n?r?n<r?-1:1:-1:1});let i;for(let e of r)e.type===`user`&&e.sender!==`system-prompt`&&e.ts&&(!i||e.ts>i)&&(i=e.ts);if(i)for(let e of r)e.type===`text`&&e.streaming&&(!e.ts||e.ts<i)&&(e.streaming=!1);return r}var L=new Set([`setup`,`cleanup`,`archive`]);function R(e){switch(e.type){case`user`:return e.sender===`system-prompt`?`system-prompt`:L.has(e.sender)?`script`:`user`;case`session`:return`session`;default:return`agent`}}function oe(e){let t=[],n=null,r=null;for(let i of e){let e=R(i),a=e===`session`||e===`system-prompt`,o=e===`script`&&i.type===`user`?`script:${i.sender}`:e;!n||r!==o||a?(n={speaker:e,ts:i.ts,items:[i]},r=o,t.push(n),a&&(n=null)):n.items.push(i)}return t}var z={class:`text-caption text-grey-6`},B=y({__name:`SessionEventItem`,props:{item:{}},setup(e){let t=e,r=m(()=>{switch(t.item.kind){case`started`:return`session.started`;case`ended`:return`session.ended`;case`compacted`:return`session.compacted`;default:return`session.started`}});return(e,t)=>(n(),h(`span`,z,o(e.$t(r.value)),1))}});function se(e,t){if(t.length===0||e.length===0)return e;let n=[...t].sort((e,t)=>t.length-e.length),r=new DOMParser().parseFromString(`<div>${e}</div>`,`text/html`),i=r.body.firstChild;if(!i)return e;function a(e){if(e.nodeType===Node.TEXT_NODE){V(e,n,r);return}if(e.nodeName===`A`)return;let t=Array.from(e.childNodes);for(let e of t)a(e)}return a(i),i.innerHTML}function V(e,t,n){let r=e.textContent??``;if(!t.some(e=>r.includes(e)))return;let i=n.createDocumentFragment(),a=0;for(;a<r.length;){let e=H(r,a,t);if(!e){i.appendChild(n.createTextNode(r.slice(a)));break}e.index>a&&i.appendChild(n.createTextNode(r.slice(a,e.index)));let o=n.createElement(`a`);o.className=`document-link`,o.setAttribute(`data-document-path`,e.path),o.setAttribute(`href`,`#`),o.textContent=e.path,i.appendChild(o),a=e.index+e.path.length}e.parentNode?.replaceChild(i,e)}function H(e,t,n){let r=null;for(let i of n){let n=e.indexOf(i,t);n<0||(!r||n<r.index||n===r.index&&i.length>r.path.length)&&(r={index:n,path:i})}return r}var U=[`innerHTML`],ce=I(y({__name:`TextMessageItem`,props:{item:{}},setup(e){let t=e,r=F(),i=k(),a=m(()=>{let e=i.selectedWorkspaceId;return e?r.documentsFor(e).map(e=>e.path):[]}),o=m(()=>re(se(ne.parse(t.item.text,{async:!1,breaks:!0,gfm:!0}),a.value),{addAttr:[`data-document-path`]}));function s(e){let t=e.target?.closest(`.document-link`);if(!t)return;e.preventDefault();let n=t.getAttribute(`data-document-path`),a=i.selectedWorkspaceId;!n||!a||r.openDocumentByPath(a,n)}return(t,r)=>(n(),h(`div`,{class:`markdown-message`,onClick:s},[_(`div`,{innerHTML:o.value},null,8,U),e.item.streaming?(n(),u(S,{key:0,size:`xs`,class:`q-ml-xs`})):f(``,!0)]))}}),[[`__scopeId`,`data-v-1b7bd8ca`]]),W={key:0,class:`text-caption text-grey-5`,style:{"font-style":`italic`}},G=[`innerHTML`],K={key:1,style:{"white-space":`pre-wrap`}},le=I(y({__name:`ThinkingItem`,props:{item:{}},setup(e){let r=e,i=m(()=>r.item.text.trim().slice(0,100)),a=m(()=>r.item.text.trim().length>0),s=m(()=>r.item.text.trim().length>100),c=m(()=>P(r.item.text));return(r,l)=>a.value?(n(),h(`div`,W,[s.value?(n(),u(ee,{key:0,dense:``,"dense-toggle":``,label:i.value,"header-class":`text-grey-5 text-caption`,style:{"font-style":`italic`}},{default:t(()=>[_(`div`,{class:`q-py-xs markdown-thinking`,innerHTML:c.value},null,8,G)]),_:1},8,[`label`])):(n(),h(`span`,K,o(e.item.text),1))])):f(``,!0)}}),[[`__scopeId`,`data-v-7f45ed94`]]);function ue(e,t){let n=e.split(`
+import{D as e,G as t,I as n,N as r,P as i,R as a,St as o,W as s,_ as c,at as l,d as u,et as d,f,g as p,l as m,p as h,r as g,u as _,xt as v,y,yt as b}from"./runtime-core.esm-bundler-D_RRiKBh.js";import{U as x,l as S,t as C}from"./QIcon-BmEX2rXO.js";import{c as w,s as T}from"./notifications-l1Pxijve.js";import{t as E}from"./QBtn-CoU-UC_j.js";import{n as D}from"./vue-i18n-Cq-KgjJC.js";import{_ as O,c as k,m as A,u as j}from"./index-Bt877CHx.js";import{t as M}from"./QSpinnerDots-DspFKwCZ.js";import{t as N}from"./QTooltip-CwBZU_bs.js";import{t as ee}from"./QExpansionItem-CiBP4NiY.js";import{t as te}from"./QScrollArea-CZVgBUBp.js";import{i as ne,n as re,t as P}from"./render-chat-markdown-947qhJXu.js";import{t as F}from"./documents-CX2-4fhr.js";import{t as I}from"./_plugin-vue_export-helper-r4mAJOHR.js";function ie(e,t,n=!0){let r=[],i=new Map,a=new Map;for(let n=0;n<e.length;n++){let o=e[n],s=t?.[n];switch(o.kind){case`message:text`:{let e=i.get(o.messageId);if(e)e.text+=o.text,e.streaming=o.streaming;else{let e={type:`text`,messageId:o.messageId,text:o.text,streaming:o.streaming,ts:s};i.set(o.messageId,e),r.push(e)}break}case`message:end`:{let e=i.get(o.messageId);e&&(e.streaming=!1);break}case`message:thinking`:r.push({type:`thinking`,messageId:o.messageId,text:o.text,ts:s});break;case`tool:call`:{let e={type:`tool`,toolCallId:o.toolCallId,name:o.name,input:o.input,ts:s};a.set(o.toolCallId,e),r.push(e);break}case`tool:result`:{let e=a.get(o.toolCallId);e&&(e.result={output:o.output,isError:o.isError});break}case`session:started`:r.push({type:`session`,kind:`started`,detail:{engineSessionId:o.engineSessionId,model:o.model},ts:s});break;case`session:ended`:r.push({type:`session`,kind:`ended`,detail:{reason:o.reason,exitCode:o.exitCode},ts:s});break;case`session:compacted`:r.push({type:`session`,kind:`compacted`,ts:s});break;case`session:brainstorm-complete`:case`session:user-input-requested`:case`message:raw`:case`skills:discovered`:case`usage`:case`rate_limit`:case`subagent:progress`:case`error`:break;default:}}let o=null;for(let e of r)e.type===`text`&&e.streaming&&(o&&(o.streaming=!1),o=e);return o&&!n&&(o.streaming=!1),r}function ae(e,t){if(t.length===0)return e;let n=t.map(e=>({type:`user`,content:e.content,sender:e.sender,ts:e.ts})),r=[...e,...n];r.sort((e,t)=>{let n=e.ts??``,r=t.ts??``;return n===r?0:n?r?n<r?-1:1:-1:1});let i;for(let e of r)e.type===`user`&&e.sender!==`system-prompt`&&e.ts&&(!i||e.ts>i)&&(i=e.ts);if(i)for(let e of r)e.type===`text`&&e.streaming&&(!e.ts||e.ts<i)&&(e.streaming=!1);return r}var L=new Set([`setup`,`cleanup`,`archive`]);function R(e){switch(e.type){case`user`:return e.sender===`system-prompt`?`system-prompt`:L.has(e.sender)?`script`:`user`;case`session`:return`session`;default:return`agent`}}function oe(e){let t=[],n=null,r=null;for(let i of e){let e=R(i),a=e===`session`||e===`system-prompt`,o=e===`script`&&i.type===`user`?`script:${i.sender}`:e;!n||r!==o||a?(n={speaker:e,ts:i.ts,items:[i]},r=o,t.push(n),a&&(n=null)):n.items.push(i)}return t}var z={class:`text-caption text-grey-6`},B=y({__name:`SessionEventItem`,props:{item:{}},setup(e){let t=e,r=m(()=>{switch(t.item.kind){case`started`:return`session.started`;case`ended`:return`session.ended`;case`compacted`:return`session.compacted`;default:return`session.started`}});return(e,t)=>(n(),h(`span`,z,o(e.$t(r.value)),1))}});function se(e,t){if(t.length===0||e.length===0)return e;let n=[...t].sort((e,t)=>t.length-e.length),r=new DOMParser().parseFromString(`<div>${e}</div>`,`text/html`),i=r.body.firstChild;if(!i)return e;function a(e){if(e.nodeType===Node.TEXT_NODE){V(e,n,r);return}if(e.nodeName===`A`)return;let t=Array.from(e.childNodes);for(let e of t)a(e)}return a(i),i.innerHTML}function V(e,t,n){let r=e.textContent??``;if(!t.some(e=>r.includes(e)))return;let i=n.createDocumentFragment(),a=0;for(;a<r.length;){let e=H(r,a,t);if(!e){i.appendChild(n.createTextNode(r.slice(a)));break}e.index>a&&i.appendChild(n.createTextNode(r.slice(a,e.index)));let o=n.createElement(`a`);o.className=`document-link`,o.setAttribute(`data-document-path`,e.path),o.setAttribute(`href`,`#`),o.textContent=e.path,i.appendChild(o),a=e.index+e.path.length}e.parentNode?.replaceChild(i,e)}function H(e,t,n){let r=null;for(let i of n){let n=e.indexOf(i,t);n<0||(!r||n<r.index||n===r.index&&i.length>r.path.length)&&(r={index:n,path:i})}return r}var U=[`innerHTML`],ce=I(y({__name:`TextMessageItem`,props:{item:{}},setup(e){let t=e,r=F(),i=k(),a=m(()=>{let e=i.selectedWorkspaceId;return e?r.documentsFor(e).map(e=>e.path):[]}),o=m(()=>re(se(ne.parse(t.item.text,{async:!1,breaks:!0,gfm:!0}),a.value),{addAttr:[`data-document-path`]}));function s(e){let t=e.target?.closest(`.document-link`);if(!t)return;e.preventDefault();let n=t.getAttribute(`data-document-path`),a=i.selectedWorkspaceId;!n||!a||r.openDocumentByPath(a,n)}return(t,r)=>(n(),h(`div`,{class:`markdown-message`,onClick:s},[_(`div`,{innerHTML:o.value},null,8,U),e.item.streaming?(n(),u(S,{key:0,size:`xs`,class:`q-ml-xs`})):f(``,!0)]))}}),[[`__scopeId`,`data-v-1b7bd8ca`]]),W={key:0,class:`text-caption text-grey-5`,style:{"font-style":`italic`}},G=[`innerHTML`],K={key:1,style:{"white-space":`pre-wrap`}},le=I(y({__name:`ThinkingItem`,props:{item:{}},setup(e){let r=e,i=m(()=>r.item.text.trim().slice(0,100)),a=m(()=>r.item.text.trim().length>0),s=m(()=>r.item.text.trim().length>100),c=m(()=>P(r.item.text));return(r,l)=>a.value?(n(),h(`div`,W,[s.value?(n(),u(ee,{key:0,dense:``,"dense-toggle":``,label:i.value,"header-class":`text-grey-5 text-caption`,style:{"font-style":`italic`}},{default:t(()=>[_(`div`,{class:`q-py-xs markdown-thinking`,innerHTML:c.value},null,8,G)]),_:1},8,[`label`])):(n(),h(`span`,K,o(e.item.text),1))])):f(``,!0)}}),[[`__scopeId`,`data-v-7f45ed94`]]);function ue(e,t){let n=e.split(`
 `),r=t.split(`
 `),i=n.length,a=r.length,o=Array.from({length:i+1},()=>Array(a+1).fill(0));for(let e=i-1;e>=0;e--)for(let t=a-1;t>=0;t--)n[e]===r[t]?o[e][t]=o[e+1][t+1]+1:o[e][t]=Math.max(o[e+1][t],o[e][t+1]);let s=[],c=0,l=0;for(;c<i&&l<a;)n[c]===r[l]?(s.push({type:`context`,content:n[c]}),c++,l++):o[c+1][l]>=o[c][l+1]?(s.push({type:`del`,content:n[c]}),c++):(s.push({type:`add`,content:r[l]}),l++);for(;c<i;)s.push({type:`del`,content:n[c++]});for(;l<a;)s.push({type:`add`,content:r[l++]});return s}function de(e){let t=e.split(`
 `),n=[];for(let e of t)e.startsWith(`@@`)||e.startsWith(`+++`)||e.startsWith(`---`)||(e.startsWith(`+`)?n.push({type:`add`,content:e.slice(1)}):e.startsWith(`-`)?n.push({type:`del`,content:e.slice(1)}):e.startsWith(` `)?n.push({type:`context`,content:e.slice(1)}):e.length>0&&n.push({type:`context`,content:e}));return n}function fe(e,t){if(!t||typeof t!=`object`)return null;let n=t;if(e===`Edit`){let e=n.file_path;if(!e)return null;let t=n.old_string??``,r=n.new_string??``,i=typeof n.diff==`string`?n.diff:``;if(!t&&!r&&i.length>0){let t=de(i);return{toolName:`Edit`,filePath:e,additions:t.filter(e=>e.type===`add`).length,deletions:t.filter(e=>e.type===`del`).length,diffLines:t}}return{toolName:`Edit`,filePath:e,oldString:t,newString:r,replaceAll:n.replace_all??!1,additions:r?r.split(`