@loicngr/kobo 1.10.3 → 1.11.0

package/AGENTS.md

@@ -12,13 +12,13 @@ Single-user dev tool, local by default. The server binds `127.0.0.1` unless the
 
 **Backend**: Node.js ≥ 20, Hono (HTTP), `ws` (WebSocket), better-sqlite3 (WAL mode), nanoid, `@modelcontextprotocol/sdk`. TypeScript throughout, `tsx` for dev, `tsc` for production build.
 
-**Frontend**: Vue 3, Quasar 2, Pinia, vue-router, marked + dompurify for markdown rendering. Vite via `@quasar/app-vite`.
+**Frontend**: Vue 3, Quasar 2, Pinia, vue-router, marked + dompurify for markdown rendering. Vite via `@quasar/app-vite`, built and served as a Progressive Web App in production.
 
 **Database**: a single SQLite file under the **Kōbō home directory** (`~/.config/kobo/kobo.db` by default, overridable via `KOBO_HOME`). Fresh-install schema lives in `src/server/db/schema.ts` (`initSchema`); incremental migrations live in `src/server/db/migrations.ts`. **The project is in production**, so every schema change MUST ship as a migration that preserves data, never as a breaking change to `initSchema` alone. See [Database migrations](#database-migrations) below.
 
 **Kōbō home directory**: `KOBO_HOME` env var overrides everything. Otherwise `$XDG_CONFIG_HOME/kobo/`, else `~/.config/kobo/`. Contains `kobo.db`, `settings.json`, `skills.json`, `templates.json`. **Development uses `./data/`** via the `KOBO_HOME=./data` prefix in the `dev` npm script, so local dev never touches your real `~/.config/kobo/` and can run in parallel with a production-installed Kōbō (`npx @loicngr/kobo`). See `src/server/utils/paths.ts`.
 
-**Tests**: vitest (24 backend test files, 544+ tests; 5 frontend test files, 45+ tests at time of writing). Frontend tests cover Pinia stores and pure utility modules; Vue components are not tested (type-check + manual smoke only).
+**Tests**: Vitest covers backend services/routes and frontend stores/pure utilities. Vue components are not unit-tested; type-checking and manual smoke tests cover their behavior. Run `npm test` and `(cd src/client && npm test)` for the complete suites.
 
 ## Commands
 
@@ -83,7 +83,7 @@ src/
 │   ├── utils/
 │   │   ├── git-ops.ts              # pushBranch, pullBranch, getCommitsBetween, delete{Local,Remote}Branch…
 │   │   └── process-tracker.ts      # per-workspace spawned-process map
-├── client/                         # Vue 3 + Quasar SPA
+├── client/                         # Vue 3 + Quasar PWA
 │   └── src/
 │       ├── stores/                 # pinia: workspace, websocket, settings, dev-server, templates
 │       ├── components/             # WorkspaceList, NotionPanel, AcceptancePanel, ChatInput, GitPanel, PlansPanel, WorkspaceAttentionLabels…
@@ -102,10 +102,11 @@ src/
 |---|---|
 | `workspaces` | the unit of work: id, name, project_path, source_branch, working_branch, status, notion_url, model, `brainstorm_model`, dev_server_status, `archived_at`, `worktree_purged_at`, `worktree_purge_restore_data` (JSON), `auto_loop`, `auto_loop_ready`, `auto_loop_session_mode`, `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` |
+| `agent_sessions` | agent-engine sessions: pid where applicable, engine session id, status, timestamps, model, and name |
 | `ws_events` | persisted WebSocket events for replay on reconnect: type, payload, session_id, created_at |
 | `pending_wakeups` | one-row-per-workspace scheduler for the `ScheduleWakeup` tool: target_at (ISO UTC), prompt, reason; CASCADE DELETE on workspace |
 | `workspace_chat_history` | chat-input history per workspace: message text + `created_at`, ordered by autoincrement id, capped at 200 entries by the service; CASCADE DELETE on workspace |
+| `workspace_permission_rules` | remembered per-workspace tool approvals, scoped to an exact operation or every invocation of a tool; CASCADE DELETE on workspace |
 
 `status` enum: `created | extracting | brainstorming | executing | completed | idle | error | quota`. Transitions are validated in `updateWorkspaceStatus` against `VALID_TRANSITIONS`.
 

package/CHANGELOG.md

@@ -4,6 +4,31 @@ 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.11.0
+
+- feat(pwa): ship the production client as an installable Progressive Web App.
+- feat(chat): add `Ctrl+J` for a new line and `Ctrl+Enter` to force delivery of
+  a queued message while an agent is active.
+- feat(chat): move the latest Claude/Codex reasoning into one live panel above
+  the chat input, with a global visibility preference.
+- feat(integrations): independently enable or disable Notion and Sentry from
+  Settings while preserving their configuration.
+- feat(integrations): add **Test connection** checks for the configured Notion
+  and Sentry MCP servers, with actionable status and elapsed time.
+- feat(chat): add `Ctrl+F` workspace-history search with readable results;
+  opening a result loads the matching session, scrolls to its message, and
+  highlights it. Global search now deep-links to the same location.
+- feat(git): let Edit and Write cards open their exact worktree-relative file
+  in the Git diff viewer.
+- feat(observability): add a session timeline panel and downloadable redacted
+  workspace diagnostic JSON.
+- feat(pwa): show offline and update-ready states, with explicit update reload
+  instead of interrupting an active page.
+- fix(chat): consume one-shot search deep-link parameters after use so a page
+  refresh does not jump back to an old result.
+- feat(permissions): remember workspace-scoped tool or exact-operation
+  approvals across sessions.
+
 ## 1.10.3
 
 - feat(notifications): add configurable PR state sounds (#22)

package/README.md

@@ -6,7 +6,7 @@
 [![license](https://img.shields.io/npm/l/@loicngr/kobo.svg)](./LICENSE)
 [![node](https://img.shields.io/node/v/@loicngr/kobo.svg)](https://nodejs.org/)
 
-Kōbō runs multiple coding agents in parallel, each isolated in its own git worktree, branch, and dev server. A single Vue dashboard streams output, tasks, git state, and quota usage across every workspace.
+Kōbō runs multiple coding agents in parallel, each isolated in its own git worktree, branch, and dev server. Its installable Vue/Quasar dashboard streams output, tasks, git state, and quota usage across every workspace.
 
 ![Kōbō workspace view: live chat and git panel](docs/assets/images/workspace-chat.png)
 
@@ -17,11 +17,11 @@ Kōbō runs multiple coding agents in parallel, each isolated in its own git wor
 
 - **Isolated worktrees**: each workspace is a dedicated git worktree on its own branch, so parallel sessions never collide.
 - **Two agent engines**: Claude Code (via `@anthropic-ai/claude-agent-sdk`) and OpenAI Codex (via `codex app-server`), chosen per workspace.
-- **Live chat**: streaming text, reasoning blocks, inline Edit/Write diffs, per-turn cards, a compaction-in-progress indicator, infinite scrollback. `/` autocompletes skills and commands, `@` fuzzy-autocompletes worktree file paths, and you can export any workspace's session events to CSV. Messages queued while an agent is busy stay scoped to their workspace and session. **Send now** delivers a queued message to an active Claude Code stream or steers the active Codex turn; it remains queued until the engine confirms acceptance.
+- **Live chat**: streaming text, inline Edit/Write diffs, per-turn cards, a compaction-in-progress indicator, infinite scrollback, and the latest Claude or Codex reasoning in a panel immediately above the message input. `/` autocompletes skills and commands, `@` fuzzy-autocompletes worktree file paths, and `Ctrl+F` searches readable messages in the current workspace: selecting a result loads its session and scrolls to it. The global search page deep-links to the same location. Messages queued while an agent is busy stay scoped to their workspace and session. **Send now** delivers a queued message to an active Claude Code stream or steers the active Codex turn; it remains queued until the engine confirms acceptance. Use `Enter` to send, `Ctrl+Enter` to force delivery while an agent is busy, and `Shift+Enter` or `Ctrl+J` for a new line.
 - **Full MCP toolset (`kobo-tasks`)**: a per-workspace MCP server the agent uses for far more than tasks — task/acceptance-criteria CRUD, starting/stopping the dev server and reading its logs, a unified `get_ticket` (Notion or Sentry), searching past conversations across every workspace, per-session token/cost usage, and a `.ai/thoughts` decision log. Native Claude Code Task tools complement it for lightweight sub-agent coordination. See [`AGENTS.md`](./AGENTS.md) for the full tool list.
 
   ![Sub-agents panel showing parallel tool calls](docs/assets/images/sub-agents-panel.png)
-- **Git panel**: a Monaco-based diff viewer with **inline file editing** (edit the right-hand panel directly, save with `Ctrl/Cmd+S`, conflict-guarded via sha precondition), inline conflict resolution, and `Sync` / `Push` / `Open PR` / `Change PR base` / `Change source branch`. Multi-forge: GitHub (`gh`), GitLab (`glab`), or no forge, auto-detected from the remote and overridable per project.
+- **Git panel**: a Monaco-based diff viewer with **inline file editing** (edit the right-hand panel directly, save with `Ctrl/Cmd+S`, conflict-guarded via sha precondition), inline conflict resolution, and `Sync` / `Push` / `Open PR` / `Change PR base` / `Change source branch`. Edit/Write cards in chat open their exact changed file in the diff viewer. Multi-forge: GitHub (`gh`), GitLab (`glab`), or no forge, auto-detected from the remote and overridable per project.
 
   ![Diff viewer with side-by-side changes](docs/assets/images/diff-viewer.png)
 - **Dev server panel**: start, stop, and tail logs for a workspace's dev server (Docker or npm) straight from the Tools panel — no need to leave the UI.
@@ -35,7 +35,9 @@ Kōbō runs multiple coding agents in parallel, each isolated in its own git wor
 - **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). Configure them 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 — see [below](#disk-space-purge).
-- **Optional integrations**: Notion (import missions), Sentry (fix from issue URL), local voice transcription (whisper.cpp).
+- **Observability**: a compact session timeline in the right panel shows session duration and status; download a redacted workspace diagnostic JSON for troubleshooting.
+- **Optional integrations**: independently enable or disable Notion (import missions) and Sentry (fix from issue URL) in Settings, with a **Test connection** action for each; local voice transcription uses whisper.cpp.
+- **Installable PWA**: production builds work as a Progressive Web App. Install Kōbō from your browser on desktop or mobile for an app-like window; it signals offline state and offers an explicit reload when an update is ready. Live agent activity still requires a connection to the local Kōbō server.
 
 ## Quick start
 
@@ -53,6 +55,10 @@ SERVER_PORT=9997 PORT=9998 npx @loicngr/kobo@latest
 
 Open <http://localhost:3000> (or whichever port you picked). Data is persisted under `~/.config/kobo/` (override via `KOBO_HOME`).
 
+### Install as an app
+
+Kōbō's production build is a PWA. When opening a production instance, use your browser's **Install app** / **Add to Home Screen** action to install it. It shows an offline notice and lets you explicitly reload when an update is ready, so an active session is never interrupted automatically. The development client (`npm run dev:client`) intentionally runs as a normal Vite application, so it does not expose an install prompt.
+
 Want to run from source or contribute? See [`CONTRIBUTING.md`](./CONTRIBUTING.md).
 
 ### Docker
@@ -78,7 +84,7 @@ The most common knobs:
 | `ANTHROPIC_API_KEY` | none | Claude Code engine credential (alternative to `claude /login`) |
 | `OPENAI_API_KEY` | none | Codex engine credential (alternative to `codex login`) |
 
-Global and per-project settings (worktree path, dev server commands, E2E framework, prompt templates, git conventions, branch prefixes, lifecycle scripts, task prompt) are edited in **Settings** at runtime. Per-project values inherit from the global ones when left empty.
+Global and per-project settings (worktree path, dev server commands, E2E framework, prompt templates, git conventions, branch prefixes, lifecycle scripts, task prompt) are edited in **Settings** at runtime. Notion and Sentry are enabled independently in their respective tabs; disabling one keeps its configuration and existing workspace links, but removes its import and automation UI. In **Settings → General → Activity feed**, you can hide agent reasoning panels. Per-project values inherit from the global ones when left empty.
 
 The full reference (every env var, every setting key, MCP server registration, Notion / Sentry / Voice setup) is in [`CONFIGURATION.md`](./CONFIGURATION.md).
 
@@ -102,8 +108,8 @@ A merged workspace is automatically archived, but its worktree folder usually ca
 
 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.
 
-- **Notion**: import missions, tasks, and acceptance criteria from a Notion page.
-- **Sentry**: paste an issue URL to spawn a fix workspace with the stacktrace, tags, and a TDD workflow.
+- **Notion**: import missions, tasks, and acceptance criteria from a Notion page. Enable it in **Settings → Notion** when you want its creation/import flow, then use **Test connection** to validate its MCP credentials.
+- **Sentry**: paste an issue URL to spawn a fix workspace with the stacktrace, tags, and a TDD workflow. Enable it independently in **Settings → Sentry**; **Test connection** validates its MCP credentials and authenticated identity.
 - **Voice transcription**: local push-to-talk via [`whisper.cpp`](https://github.com/ggml-org/whisper.cpp).
 
 See [`CONFIGURATION.md`](./CONFIGURATION.md) for the setup of each.
@@ -145,14 +151,14 @@ Full install instructions and the prompt-suite differences are in [`CONFIGURATIO
 
 ## Architecture
 
-Hono backend, Vue 3 + Quasar SPA, SQLite (WAL) for persistence, WebSocket for live updates. Each workspace spawns its own agent engine and a dedicated MCP server (`kobo-tasks`) that the agent uses to query and mutate workspace state.
+Hono backend, Vue 3 + Quasar PWA, SQLite (WAL) for persistence, WebSocket for live updates. Each workspace spawns its own agent engine and a dedicated MCP server (`kobo-tasks`) that the agent uses to query and mutate workspace state.
 
 ```
 src/
 ├── server/         # Hono backend (routes, services, db, agent orchestrator)
 │   ├── services/agent/engines/  # claude-code/ + codex/ engines
 │   └── ...
-├── client/         # Vue 3 + Quasar SPA
+├── client/         # Vue 3 + Quasar PWA
 ├── mcp-server/     # kobo-tasks MCP server, spawned per workspace
 ├── shared/         # types shared backend ↔ frontend
 └── __tests__/      # Vitest suite, backend + client, thousands of tests

package/dist/server/db/migrations.js

@@ -420,6 +420,27 @@ export const migrations = [
             }
         },
     },
+    {
+        version: 32,
+        name: 'add-workspace-permission-rules',
+        migrate: (db) => {
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS workspace_permission_rules (
+          id TEXT PRIMARY KEY,
+          workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+          engine TEXT,
+          tool_name TEXT NOT NULL,
+          scope TEXT NOT NULL CHECK(scope IN ('operation', 'tool')),
+          fingerprint TEXT,
+          display_label TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS idx_workspace_permission_rules_lookup
+          ON workspace_permission_rules(workspace_id, engine, tool_name, scope, fingerprint);
+      `);
+        },
+    },
 ];
 /** 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

@@ -73,6 +73,20 @@ export function initSchema(db) {
       created_at TEXT NOT NULL
     );
 
+    CREATE TABLE IF NOT EXISTS workspace_permission_rules (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+      engine TEXT,
+      tool_name TEXT NOT NULL,
+      scope TEXT NOT NULL CHECK(scope IN ('operation', 'tool')),
+      fingerprint TEXT,
+      display_label TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_workspace_permission_rules_lookup
+      ON workspace_permission_rules(workspace_id, engine, tool_name, scope, fingerprint);
+
     CREATE TABLE IF NOT EXISTS pending_wakeups (
       workspace_id     TEXT PRIMARY KEY REFERENCES workspaces(id) ON DELETE CASCADE,
       target_at        TEXT NOT NULL,

package/dist/server/routes/health.js

@@ -164,8 +164,8 @@ app.get('/report', (c) => {
         },
         agentSessions: { orphaned },
         integrations: {
-            notion: { configured: Boolean(healthGlobalSettings.notionMcpKey) },
-            sentry: { configured: Boolean(healthGlobalSettings.sentryMcpKey) },
+            notion: { configured: Boolean(healthGlobalSettings.notionMcpKey), enabled: healthGlobalSettings.notionEnabled },
+            sentry: { configured: Boolean(healthGlobalSettings.sentryMcpKey), enabled: healthGlobalSettings.sentryEnabled },
             editor: { configured: Boolean(healthGlobalSettings.editorCommand) },
         },
         active: {

package/dist/server/routes/notion.js

@@ -1,10 +1,24 @@
 import { Hono } from 'hono';
-import { extractNotionPage, listNotionUsers } from '../services/notion-service.js';
+import { extractNotionPage, listNotionUsers, testNotionConnection } from '../services/notion-service.js';
+import { getGlobalSettings } from '../services/settings-service.js';
 /** Hono sub-router for Notion page extraction. */
 const app = new Hono();
+app.post('/test', async (c) => {
+    try {
+        if (!getGlobalSettings().notionEnabled)
+            return c.json({ error: 'Notion integration is disabled in Settings' }, 403);
+        return c.json(await testNotionConnection());
+    }
+    catch (err) {
+        return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+});
 // GET /api/notion/users — list workspace users (humans only, for the settings dropdown)
 app.get('/users', async (c) => {
     try {
+        if (!getGlobalSettings().notionEnabled) {
+            return c.json({ error: 'Notion integration is disabled in Settings' }, 403);
+        }
         const users = await listNotionUsers();
         return c.json({ users });
     }
@@ -16,6 +30,9 @@ app.get('/users', async (c) => {
 // POST /api/notion/extract — extract a Notion page
 app.post('/extract', async (c) => {
     try {
+        if (!getGlobalSettings().notionEnabled) {
+            return c.json({ error: 'Notion integration is disabled in Settings' }, 403);
+        }
         const body = await c.req.json();
         if (!body.url) {
             return c.json({ error: 'Missing required field: url' }, 400);

package/dist/server/routes/sentry.js

@@ -1,10 +1,24 @@
 import { Hono } from 'hono';
-import { extractSentryIssue } from '../services/sentry-service.js';
+import { extractSentryIssue, testSentryConnection } from '../services/sentry-service.js';
+import { getGlobalSettings } from '../services/settings-service.js';
 /** Hono sub-router for Sentry issue extraction (preflight). */
 const app = new Hono();
+app.post('/test', async (c) => {
+    try {
+        if (!getGlobalSettings().sentryEnabled)
+            return c.json({ error: 'Sentry integration is disabled in Settings' }, 403);
+        return c.json(await testSentryConnection());
+    }
+    catch (err) {
+        return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+});
 // POST /api/sentry/extract — extract a Sentry issue by URL
 app.post('/extract', async (c) => {
     try {
+        if (!getGlobalSettings().sentryEnabled) {
+            return c.json({ error: 'Sentry integration is disabled in Settings' }, 403);
+        }
         const body = await c.req.json();
         if (!body.url) {
             return c.json({ error: 'Missing required field: url' }, 400);

package/dist/server/routes/workspaces.js

@@ -34,6 +34,7 @@ import { getSuitePrompts } from '../services/skill-suite-prompts.js';
 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 permissionPolicyService from '../services/workspace-permission-policy-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';
@@ -181,6 +182,9 @@ app.post('/', migrationGuard, async (c) => {
         // before createWorkspace and surface failures as 422.
         let notionContent = null;
         if (body.notionUrl) {
+            if (!settingsService.getGlobalSettings().notionEnabled) {
+                return c.json({ error: 'Notion integration is disabled in Settings' }, 403);
+            }
             try {
                 notionContent = await notionService.extractNotionPage(body.notionUrl);
             }
@@ -203,6 +207,9 @@ app.post('/', migrationGuard, async (c) => {
         }
         let sentryContent = null;
         if (body.sentryUrl) {
+            if (!settingsService.getGlobalSettings().sentryEnabled) {
+                return c.json({ error: 'Sentry integration is disabled in Settings' }, 403);
+            }
             try {
                 sentryContent = await sentryService.extractSentryIssue(body.sentryUrl);
             }
@@ -376,11 +383,9 @@ app.post('/', migrationGuard, async (c) => {
             }
             // Update workspace name with Notion page title only if user didn't
             // provide a custom name. Prefix with the Notion unique-id (e.g.
-            // "TK-123 | …") when the page has one — it makes the workspace
-            // immediately scannable in the sidebar.
+            // Use the Notion page title when the user left the generic placeholder.
             if (notionContent.title && workspace.name === 'workspace') {
-                const prefix = notionContent.ticketId ? `${notionContent.ticketId} | ` : '';
-                workspace = workspaceService.updateWorkspaceName(workspace.id, `${prefix}${notionContent.title}`);
+                workspace = workspaceService.updateWorkspaceName(workspace.id, notionContent.title);
             }
         }
         // Create manual tasks/criteria if no Notion content was extracted
@@ -1275,10 +1280,14 @@ app.post('/:id/deferred-permission/decision', async (c) => {
         if (body.decision !== 'allow' && body.decision !== 'deny') {
             return c.json({ error: "decision must be 'allow' or 'deny'" }, 400);
         }
+        if (body.scope && !['once', 'turn', 'operation', 'tool'].includes(body.scope)) {
+            return c.json({ error: "scope must be 'once', 'turn', 'operation' or 'tool'" }, 400);
+        }
         await agentManager.answerPendingPermission(id, {
             toolCallId: body.toolCallId,
             decision: body.decision,
             reason: typeof body.reason === 'string' ? body.reason : undefined,
+            scope: body.scope,
         });
         return c.json({ ok: true });
     }
@@ -1288,6 +1297,20 @@ app.post('/:id/deferred-permission/decision', async (c) => {
         return c.json({ error: message }, status);
     }
 });
+app.get('/:id/permission-rules', (c) => {
+    const id = c.req.param('id');
+    if (!workspaceService.getWorkspace(id))
+        return c.json({ error: `Workspace '${id}' not found` }, 404);
+    return c.json({ rules: permissionPolicyService.listWorkspacePermissionRules(id) });
+});
+app.delete('/:id/permission-rules/:ruleId', (c) => {
+    const id = c.req.param('id');
+    if (!workspaceService.getWorkspace(id))
+        return c.json({ error: `Workspace '${id}' not found` }, 404);
+    if (!permissionPolicyService.removeWorkspacePermissionRule(id, c.req.param('ruleId')))
+        return c.json({ error: 'Permission rule not found' }, 404);
+    return c.json({ ok: true });
+});
 // DELETE /api/workspaces/:id/events/:eventId — permanently dismiss a single
 // persisted ws_events row (used today by the agent error banner so a closed
 // error doesn't replay on F5 / reconnect). Defensive: only deletes if the row
@@ -1465,6 +1488,103 @@ app.post('/:id/tasks/:taskId/notify-done', (c) => {
         return c.json({ error: message }, 500);
     }
 });
+// GET /api/workspaces/:id/history-search — full-workspace persisted conversation search.
+app.get('/:id/history-search', (c) => {
+    try {
+        const id = c.req.param('id');
+        if (!workspaceService.getWorkspace(id))
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        const query = (c.req.query('q') ?? '').trim();
+        if (query.length < 2)
+            return c.json({ results: [] });
+        const limit = Math.min(parseInt(c.req.query('limit') ?? '30', 10) || 30, 100);
+        const needle = `%${query.replace(/[%_]/g, '\\$&')}%`;
+        const rows = getDb()
+            .prepare(`SELECT id, session_id, type, payload, created_at FROM ws_events
+         WHERE workspace_id = ? AND payload LIKE ? ESCAPE '\\'
+         ORDER BY rowid DESC LIMIT ?`)
+            .all(id, needle, limit * 4);
+        const normalized = rows.flatMap((row) => {
+            const result = readableHistorySearchResult(row.type, row.payload, query);
+            if (!result)
+                return [];
+            return [{ eventId: row.id, sessionId: row.session_id, createdAt: row.created_at, ...result }];
+        });
+        return c.json({ results: normalized.slice(0, limit) });
+    }
+    catch (err) {
+        return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+});
+function readableHistorySearchResult(type, rawPayload, query) {
+    let payload;
+    try {
+        payload = JSON.parse(rawPayload);
+    }
+    catch {
+        return null;
+    }
+    let text = null;
+    let kind = 'agent';
+    if (type === 'user:message') {
+        text = typeof payload.content === 'string' ? payload.content : null;
+        kind = 'user';
+    }
+    else if (type === 'agent:event') {
+        if (payload.kind === 'message:text' && typeof payload.text === 'string')
+            text = payload.text;
+    }
+    else if (type === 'agent:output') {
+        const message = payload.message;
+        if (Array.isArray(message?.content)) {
+            text = message.content
+                .flatMap((block) => {
+                if (!block || typeof block !== 'object')
+                    return [];
+                const candidate = block;
+                return candidate.type === 'text' && typeof candidate.text === 'string' ? [candidate.text] : [];
+            })
+                .join('\n');
+        }
+    }
+    if (!text)
+        return null;
+    const matchIndex = text.toLowerCase().indexOf(query.toLowerCase());
+    if (matchIndex < 0)
+        return null;
+    const start = Math.max(0, matchIndex - 90);
+    const end = Math.min(text.length, matchIndex + query.length + 180);
+    return {
+        kind,
+        snippet: `${start > 0 ? '…' : ''}${text.slice(start, end).replace(/\s+/g, ' ').trim()}${end < text.length ? '…' : ''}`,
+    };
+}
+// GET /api/workspaces/:id/diagnostic.json — portable, redacted-by-design event diagnostic.
+app.get('/:id/diagnostic.json', (c) => {
+    try {
+        const id = c.req.param('id');
+        const workspace = workspaceService.getWorkspace(id);
+        if (!workspace)
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        const db = getDb();
+        const sessions = db
+            .prepare('SELECT id, engine_session_id, status, started_at, ended_at, model, name FROM agent_sessions WHERE workspace_id = ? ORDER BY started_at ASC')
+            .all(id);
+        const events = db
+            .prepare('SELECT id, session_id, type, created_at FROM ws_events WHERE workspace_id = ? ORDER BY rowid ASC')
+            .all(id);
+        c.header('Content-Disposition', `attachment; filename="${workspace.name.replace(/[^a-z0-9]+/gi, '-').toLowerCase() || id}-diagnostic.json"`);
+        return c.json({
+            generatedAt: new Date().toISOString(),
+            workspace: { id, name: workspace.name, engine: workspace.engine },
+            sessions,
+            events,
+        });
+    }
+    catch (err) {
+        return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+});
 // GET /api/workspaces/:id/events — paginated event history (must be before GET /:id for route ordering)
 app.get('/:id/events', (c) => {
     try {
@@ -1474,13 +1594,27 @@ app.get('/:id/events', (c) => {
             return c.json({ error: `Workspace '${id}' not found` }, 404);
         }
         const before = c.req.query('before'); // event ID cursor
+        const around = c.req.query('around'); // event ID to include in a focused history window
         // optional: scope to a session view. Session views also include
         // workspace-level rows where session_id IS NULL (legacy/pre-session items).
         const session = c.req.query('session');
         const limit = Math.min(parseInt(c.req.query('limit') ?? '100', 10) || 100, 500);
         const db = getDb();
         let rows;
-        if (before) {
+        if (around) {
+            const targetRow = db.prepare('SELECT rowid FROM ws_events WHERE id = ? AND workspace_id = ?').get(around, id);
+            if (!targetRow)
+                return c.json({ events: [], hasMore: false });
+            const halfWindow = Math.floor(limit / 2);
+            rows = session
+                ? db
+                    .prepare('SELECT * FROM ws_events WHERE workspace_id = ? AND (session_id = ? OR session_id IS NULL) AND rowid BETWEEN ? AND ? ORDER BY rowid ASC')
+                    .all(id, session, targetRow.rowid - halfWindow, targetRow.rowid + halfWindow)
+                : db
+                    .prepare('SELECT * FROM ws_events WHERE workspace_id = ? AND rowid BETWEEN ? AND ? ORDER BY rowid ASC')
+                    .all(id, targetRow.rowid - halfWindow, targetRow.rowid + halfWindow);
+        }
+        else if (before) {
             // Get the rowid of the cursor event
             const cursorRow = db.prepare('SELECT rowid FROM ws_events WHERE id = ?').get(before);
             if (!cursorRow) {
@@ -1508,7 +1642,7 @@ app.get('/:id/events', (c) => {
         }
         // Reverse to chronological order (we queried DESC for "before" pagination,
         // or for the "session + no cursor" case where we fetched the newest first).
-        if (before || session)
+        if (before || (session && !around))
             rows.reverse();
         const events = rows.map((row) => {
             let parsedPayload;

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

@@ -1,5 +1,7 @@
 import { query, } from '@anthropic-ai/claude-agent-sdk';
 import { nanoid } from 'nanoid';
+import { isWorkspacePermissionAllowed } from '../../../workspace-permission-policy-service.js';
+import { createStreamingBatcher } from '../../streaming-batcher.js';
 import { CLAUDE_CODE_CAPABILITIES } from './capabilities.js';
 import { createMapperState, mapSdkMessage, QUOTA_PATTERN, tryEmitQuota } from './event-mapper.js';
 import { buildClaudeOptions } from './options-builder.js';
@@ -100,10 +102,17 @@ export function createClaudeCodeEngine() {
                 if (toolName !== 'AskUserQuestion' && !isInteractive) {
                     return Promise.resolve({ behavior: 'allow', updatedInput: input });
                 }
+                if (toolName !== 'AskUserQuestion' &&
+                    isWorkspacePermissionAllowed(options.workspaceId, { engine: 'claude-code', toolName, payload: input })) {
+                    return Promise.resolve({ behavior: 'allow', updatedInput: input });
+                }
                 const requestKind = toolName === 'AskUserQuestion' ? 'question' : 'permission';
                 return new Promise((resolve, reject) => {
                     const resolver = { resolve, input, requestKind };
                     pendingResolvers.set(toolCallId, resolver);
+                    // A user decision is intentional inactivity. The text-only watchdog
+                    // must never end this session while the permission card is visible.
+                    clearTextIdleWatchdog();
                     const onAbort = () => {
                         if (pendingResolvers.get(toolCallId) === resolver) {
                             pendingResolvers.delete(toolCallId);
@@ -202,7 +211,7 @@ export function createClaudeCodeEngine() {
             let discoveredSessionId;
             // A throwing onEvent handler (e.g. DB query against a closed connection
             // during async test teardown) must not escape as an unhandled rejection.
-            const safeEmit = (ev) => {
+            const emitDirect = (ev) => {
                 try {
                     onEvent(ev);
                 }
@@ -210,6 +219,8 @@ export function createClaudeCodeEngine() {
                     console.error('[claude-engine] onEvent handler threw:', err);
                 }
             };
+            const streamingBatcher = createStreamingBatcher(emitDirect);
+            const safeEmit = (ev) => streamingBatcher.push(ev);
             let iteratorRunning = false;
             let userInterrupted = false;
             let completedResponses = 0;
@@ -240,6 +251,10 @@ export function createClaudeCodeEngine() {
             const armTextIdleWatchdog = () => {
                 clearTextIdleWatchdog();
                 textIdleTimer = setTimeout(() => {
+                    if (pendingResolvers.size > 0) {
+                        textIdleTimer = undefined;
+                        return;
+                    }
                     console.warn(`[claude-engine] SDK stream inactive ${TEXT_IDLE_TIMEOUT_MS}ms after a text-only response — forcing session:ended`);
                     const reason = userInterrupted ? 'killed' : mapperState.sawErrorResult ? 'error' : 'completed';
                     emitSessionEnded(reason, reason === 'completed' ? 0 : null);
@@ -322,6 +337,7 @@ export function createClaudeCodeEngine() {
                     }
                 }
                 finally {
+                    streamingBatcher.close();
                     // The post-result drain watchdog (if armed) is moot once the
                     // iterator has exited — clear it so a healthy run never triggers a
                     // stray abort after it already ended.

package/dist/server/services/agent/engines/claude-code/event-mapper.js

@@ -151,6 +151,33 @@ export function mapSdkMessage(msg, state) {
         }
         return events;
     }
+    if (type === 'stream_event') {
+        const event = parsed.event;
+        if (!event)
+            return events;
+        if (event.type === 'message_start') {
+            const streamedMessage = event.message;
+            const messageId = typeof streamedMessage?.id === 'string' ? streamedMessage.id : undefined;
+            if (messageId) {
+                state.streamingMessageId = messageId;
+                if (!state.openMessages.has(messageId))
+                    state.openMessages.set(messageId, { sawText: false });
+            }
+            return events;
+        }
+        if (event.type === 'content_block_delta') {
+            const delta = event.delta;
+            const text = delta?.type === 'text_delta' && typeof delta.text === 'string' ? delta.text : undefined;
+            if (text && state.streamingMessageId) {
+                const messageId = state.streamingMessageId;
+                const messageState = state.openMessages.get(messageId);
+                if (messageState)
+                    messageState.sawText = true;
+                events.push({ kind: 'message:text', messageId, text, streaming: true });
+            }
+        }
+        return events;
+    }
     if (type === 'system') {
         if (subtype === 'compact' || subtype === 'compact_boundary') {
             events.push({ kind: 'session:compacted' });
@@ -233,8 +260,10 @@ export function mapSdkMessage(msg, state) {
             const blockType = block.type;
             if (blockType === 'text' && typeof block.text === 'string') {
                 const text = block.text;
-                events.push({ kind: 'message:text', messageId, text, streaming: true });
-                msgState.sawText = true;
+                if (!msgState.sawText) {
+                    events.push({ kind: 'message:text', messageId, text, streaming: true });
+                    msgState.sawText = true;
+                }
                 if (text.includes('[BRAINSTORM_COMPLETE]')) {
                     events.push({ kind: 'session:brainstorm-complete' });
                 }

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

@@ -42,6 +42,9 @@ export function buildClaudeOptions(input) {
         // `~/.claude/settings.json` (where `skipDangerousModePermissionPrompt`
         // lives), breaking bypass for MCP tools.
         settingSources: ['user', 'project', 'local'],
+        // Relay the Anthropic API's raw message stream so Kōbō can display true
+        // text deltas instead of waiting for complete assistant content blocks.
+        includePartialMessages: true,
     };
     switch (input.agentPermissionMode) {
         case 'plan':