@loicngr/kobo 1.11.2 → 1.11.4

package/CHANGELOG.md

@@ -4,6 +4,14 @@ 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.4
+
+- feat(workspace): switch agent engines within a workspace
+
+## 1.11.3
+
+- feat(forge): add bitbucket community support
+
 ## 1.11.2
 
 - feat(integrations): let Notion and Sentry be enabled independently, keep

package/README.md

@@ -16,12 +16,12 @@ Kōbō runs multiple coding agents in parallel, each isolated in its own git wor
 ## Features
 
 - **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, inline Edit/Write diffs, per-turn cards, a compaction-in-progress indicator, infinite scrollback, and a reasoning panel immediately above the message input while Claude or Codex is actively thinking. `/` 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. `Ctrl+K` opens a command palette for common workspace actions. 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.
+- **Two agent engines**: Claude Code (via `@anthropic-ai/claude-agent-sdk`) and OpenAI Codex (via `codex app-server`). Switch between them in the same workspace without creating another worktree: Kōbō starts a fresh session for the target engine and provides an editable handoff with tasks, Git state, diff summary, and recent context.
+- **Live chat**: streaming text, inline Edit/Write diffs, per-turn cards, a compaction-in-progress indicator, infinite scrollback, and a reasoning panel immediately above the message input while Claude or Codex is actively thinking. `/` 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. `Ctrl+K` opens a command palette for common workspace actions. The global search page deep-links to the same location. Sessions retain their engine and can be renamed or permanently deleted with only their linked history. 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` / `Commit` / `Open PR` / `Merge ready PR` / `Change PR base` / `Change source branch`. You can write the commit message yourself or ask the active engine to prepare the commit; PR/MR merging always requires a confirmation, then Kōbō can offer to delete the merged remote 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.
+- **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` / `Commit` / `Open PR` / `Merge ready PR` / `Change PR base` / `Change source branch`. You can write the commit message yourself or ask the active engine to prepare the commit; PR/MR merging always requires a confirmation, then Kōbō can offer to delete the merged remote branch. Edit/Write cards in chat open their exact changed file in the diff viewer. Multi-forge: GitHub (`gh`), GitLab (`glab`), Bitbucket Community (`bkt`), 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. When a project has no configured server, the panel and MCP tool report that explicitly instead of implying one is running.
@@ -84,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. 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.
+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. **Settings → Forge** holds local Bitbucket Community credentials for `bkt`; Kōbō uses them for PR actions and provides them only to agents working in Bitbucket projects. 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).
 
@@ -93,7 +93,7 @@ The full reference (every env var, every setting key, MCP server registration, N
 - **Claude Code.** Authenticate once with `claude /login`. Kōbō calls the embedded SDK directly, so no `claude` binary is required at runtime.
 - **OpenAI Codex.** Run `codex login` or export `OPENAI_API_KEY`. Kōbō spawns a long-lived `codex app-server` subprocess per workspace and bridges its JSON-RPC stream to the same UI.
 
-You pick the engine 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).
+You pick the engine at workspace creation and can switch it later from the workspace header. A switch never attempts to resume a Claude conversation in Codex (or the reverse): it stops the active agent, starts a fresh target-engine session in the same worktree, and lets you review the handoff before launch. The new agent can retrieve further context from prior sessions through the read-only `kobo__read_workspace_events_csv` and `kobo__search_codebase` MCP tools. Both engines 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
 

package/dist/server/db/migrations.js

@@ -441,6 +441,26 @@ export const migrations = [
       `);
         },
     },
+    {
+        version: 33,
+        name: 'add-agent-session-engine',
+        migrate: (db) => {
+            const table = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'agent_sessions'").get();
+            if (!table)
+                return;
+            const cols = db.prepare('PRAGMA table_info(agent_sessions)').all();
+            if (!cols.some((col) => col.name === 'engine')) {
+                db.exec('ALTER TABLE agent_sessions ADD COLUMN engine TEXT');
+            }
+            // Historical rows predate per-session engine tracking. The workspace
+            // value is the best available attribution and keeps their history useful.
+            db.exec(`
+        UPDATE agent_sessions
+        SET engine = (SELECT engine FROM workspaces WHERE workspaces.id = agent_sessions.workspace_id)
+        WHERE engine IS NULL
+      `);
+        },
+    },
 ];
 /** 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

@@ -57,6 +57,7 @@ export function initSchema(db) {
       workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
       pid INTEGER,
       engine_session_id TEXT,
+      engine TEXT,
       status TEXT NOT NULL DEFAULT 'running',
       model TEXT,
       started_at TEXT NOT NULL,

package/dist/server/routes/workspaces.js

@@ -16,6 +16,7 @@ import { listChatHistory, pushChatHistory } from '../services/chat-history-servi
 import { renderCiFixTemplate } from '../services/ci-fix-template-service.js';
 import * as cronService from '../services/cron-service.js';
 import * as devServerService from '../services/dev-server-service.js';
+import { buildEngineHandoff } from '../services/engine-handoff-service.js';
 import { saveWorkspaceFile, shaOf } from '../services/file-editor-service.js';
 import { getForgeProvider } from '../services/forge/registry.js';
 import { resolveForge } from '../services/forge/resolve.js';
@@ -77,6 +78,61 @@ app.get('/', (c) => {
         return c.json({ error: message }, 500);
     }
 });
+// POST /api/workspaces/:id/engine-handoff-preview — build an editable, deterministic handoff.
+app.post('/:id/engine-handoff-preview', migrationGuard, async (c) => {
+    try {
+        const id = c.req.param('id');
+        const body = await c.req.json();
+        const workspace = workspaceService.getWorkspaceWithTasks(id);
+        if (!workspace)
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        const engine = listEngines().find((item) => item.id === body.engine);
+        if (!engine)
+            return c.json({ error: `Unknown engine '${body.engine ?? ''}'` }, 400);
+        return c.json({ handoff: buildEngineHandoff(workspace, workspace.engine, engine.id) });
+    }
+    catch (err) {
+        return c.json({ error: err instanceof Error ? err.message : 'Failed to build engine handoff' }, 500);
+    }
+});
+// POST /api/workspaces/:id/switch-engine — stop the current controller and start a fresh engine session.
+app.post('/:id/switch-engine', migrationGuard, async (c) => {
+    try {
+        const id = c.req.param('id');
+        const body = await c.req.json();
+        const workspace = workspaceService.getWorkspaceWithTasks(id);
+        if (!workspace)
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        if (!body.engine || body.engine === workspace.engine)
+            return c.json({ error: 'Choose a different engine' }, 400);
+        const engine = listEngines().find((item) => item.id === body.engine);
+        if (!engine)
+            return c.json({ error: `Unknown engine '${body.engine}'` }, 400);
+        const model = typeof body.model === 'string' && engine.capabilities.models.some((item) => item.id === body.model)
+            ? body.model
+            : engine.capabilities.models[0]?.id;
+        if (!model)
+            return c.json({ error: `Engine '${body.engine}' has no available model` }, 400);
+        if (!isAgentPermissionMode(body.agentPermissionMode) ||
+            !engine.capabilities.permissionModes.includes(body.agentPermissionMode)) {
+            return c.json({ error: `Engine '${body.engine}' does not support the selected permission mode` }, 400);
+        }
+        const effort = typeof body.reasoningEffort === 'string' ? body.reasoningEffort : 'auto';
+        const handoff = typeof body.handoff === 'string' && body.handoff.trim()
+            ? body.handoff.trim().slice(0, 30_000)
+            : buildEngineHandoff(workspace, workspace.engine, body.engine);
+        if (agentManager.hasController(id))
+            agentManager.stopAgent(id);
+        const updated = workspaceService.updateWorkspaceEngineConfiguration(id, body.engine, model, effort, body.agentPermissionMode);
+        const session = agentManager.startAgent(id, updated.worktreePath, handoff, updated.model, false, updated.agentPermissionMode, undefined, updated.reasoningEffort);
+        workspaceService.updateWorkspaceStatus(id, 'executing');
+        wsService.emit(id, 'user:message', { content: handoff, sender: 'user', kind: 'engine-handoff' }, session.agentSessionId);
+        return c.json({ workspace: workspaceService.getWorkspace(id), sessionId: session.agentSessionId });
+    }
+    catch (err) {
+        return c.json({ error: err instanceof Error ? err.message : 'Failed to switch engine' }, 500);
+    }
+});
 // POST /api/workspaces — create workspace
 app.post('/', migrationGuard, async (c) => {
     try {
@@ -1222,6 +1278,21 @@ app.patch('/:id/sessions/:sessionId', async (c) => {
         return c.json({ error: message }, 500);
     }
 });
+// DELETE /api/workspaces/:id/sessions/:sessionId — remove a stopped session and its history.
+app.delete('/:id/sessions/:sessionId', migrationGuard, (c) => {
+    try {
+        const workspaceId = c.req.param('id');
+        const sessionId = c.req.param('sessionId');
+        const deleted = workspaceService.deleteSession(sessionId, workspaceId);
+        if (!deleted)
+            return c.json({ error: `Session '${sessionId}' not found` }, 404);
+        return c.json({ ok: true, workspace: workspaceService.getWorkspace(workspaceId) });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, message.includes('active session') ? 409 : 500);
+    }
+});
 // POST /api/workspaces/:id/deferred-tool-use/answer — resume a deferred
 // AskUserQuestion call by feeding the user's answers back to the SDK.
 app.post('/:id/deferred-tool-use/answer', async (c) => {

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

@@ -199,6 +199,7 @@ export function createClaudeCodeEngine() {
                         console.warn(`[claude-engine stderr] ${data}`);
                     }
                 },
+                env: options.env,
             });
             sdkOptions.abortController = abortController;
             // Override the SDK's libc-blind binary resolution on Linux glibc — see

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

@@ -82,5 +82,7 @@ export function buildClaudeOptions(input) {
         options.canUseTool = input.canUseTool;
     if (input.stderr)
         options.stderr = input.stderr;
+    if (input.env)
+        options.env = input.env;
     return { options, effectivePrompt: prompt };
 }

package/dist/server/services/agent/engines/codex/capabilities.js

@@ -3,11 +3,12 @@ export const CODEX_CAPABILITIES = {
     models: CODEX_MODELS.map((m) => ({ id: m.id, label: m.label })),
     effortLevels: [
         { id: 'auto', label: 'Auto' },
-        { id: 'minimal', label: 'Minimal' },
+        { id: 'none', label: 'None' },
         { id: 'low', label: 'Low' },
         { id: 'medium', label: 'Medium' },
         { id: 'high', label: 'High' },
         { id: 'xhigh', label: 'Extra High' },
+        { id: 'max', label: 'Maximum' },
     ],
     permissionModes: ['plan', 'bypass', 'strict', 'interactive'],
     supportsResume: true,

package/dist/server/services/agent/engines/codex/engine.js

@@ -60,7 +60,7 @@ export function createCodexEngine() {
             };
             const streamingBatcher = createStreamingBatcher(emitDirect);
             const safeEmit = (ev) => streamingBatcher.push(ev);
-            const child = spawnAppServer({ cwd: options.workingDir, signal: abortController.signal });
+            const child = spawnAppServer({ cwd: options.workingDir, env: options.env, signal: abortController.signal });
             if (child.stderr) {
                 child.stderr.setEncoding('utf8');
                 child.stderr.on('data', (chunk) => {

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

@@ -41,9 +41,11 @@ export function buildCodexOptions(input) {
     if (input.model && input.model !== 'auto') {
         threadParams.model = input.model;
     }
-    // Effort: omit when undefined or 'auto'
+    // Effort: omit when undefined or 'auto'. `minimal` was emitted by older
+    // Kōbō versions; Codex 5.6 rejects it, so preserve old workspaces by
+    // translating it to the closest current setting instead of failing a turn.
     if (input.effort && input.effort !== 'auto') {
-        threadParams.modelReasoningEffort = input.effort;
+        threadParams.modelReasoningEffort = (input.effort === 'minimal' ? 'none' : input.effort);
     }
     // `default_tools_approval_mode: 'auto'` pre-approves the namespace —
     // without it Codex blocks every MCP tool call with "user cancelled".

package/dist/server/services/agent/orchestrator.js

@@ -6,6 +6,7 @@ import { unregisterProcess } from '../../utils/process-tracker.js';
 import * as autoLoopService from '../auto-loop-service.js';
 import * as cleanupScriptService from '../cleanup-script-service.js';
 import * as cronService from '../cron-service.js';
+import { resolveForge } from '../forge/resolve.js';
 import * as quotaBackoffService from '../quota-backoff-service.js';
 import { getEffectiveSettings, getGlobalSettings } from '../settings-service.js';
 import { refreshNow } from '../usage/poller.js';
@@ -342,12 +343,44 @@ function buildMcpServers(workspaceId) {
         },
     ];
 }
+function isBitbucketProject(projectPath) {
+    try {
+        return resolveForge(projectPath) === 'bitbucket-community';
+    }
+    catch {
+        return false;
+    }
+}
+function buildAgentEnv(projectPath) {
+    if (!isBitbucketProject(projectPath))
+        return undefined;
+    const global = getGlobalSettings();
+    if (!global.bitbucketToken)
+        return undefined;
+    return {
+        ...process.env,
+        BKT_HOST: 'https://bitbucket.org',
+        BKT_TOKEN: global.bitbucketToken,
+        BKT_USERNAME: global.bitbucketUsername,
+    };
+}
+function buildAgentPrompt(prompt, projectPath) {
+    if (!projectPath || !isBitbucketProject(projectPath))
+        return prompt;
+    return [
+        '[Kōbō Bitbucket] Bitbucket credentials are available through the `bkt` CLI in this session.',
+        'Use `bkt pr edit <number> --body <description>` and `bkt pr comment <number> --body <comment>` for PR updates.',
+        'Do not call the Bitbucket REST API with curl or reuse BKT_TOKEN as a Bearer token: Bitbucket Cloud API tokens require the bkt CLI authentication flow.',
+        '',
+        prompt,
+    ].join('\n');
+}
 function resolveSessionForResume(workspaceId, existingSessionId, model) {
     const db = getDb();
     let lastSession;
     if (existingSessionId) {
         lastSession = db
-            .prepare('SELECT id, engine_session_id FROM agent_sessions WHERE id = ? AND workspace_id = ? AND engine_session_id IS NOT NULL LIMIT 1')
+            .prepare('SELECT id, engine_session_id, engine FROM agent_sessions WHERE id = ? AND workspace_id = ? AND engine_session_id IS NOT NULL LIMIT 1')
             .get(existingSessionId, workspaceId);
         if (!lastSession) {
             throw new Error(`Cannot resume session '${existingSessionId}' for workspace '${workspaceId}': ` +
@@ -356,7 +389,7 @@ function resolveSessionForResume(workspaceId, existingSessionId, model) {
     }
     else {
         lastSession = db
-            .prepare('SELECT id, engine_session_id FROM agent_sessions WHERE workspace_id = ? AND engine_session_id IS NOT NULL ORDER BY started_at DESC LIMIT 1')
+            .prepare('SELECT id, engine_session_id, engine FROM agent_sessions WHERE workspace_id = ? AND engine_session_id IS NOT NULL ORDER BY started_at DESC LIMIT 1')
             .get(workspaceId);
     }
     const engineSessionId = lastSession?.engine_session_id ?? (existingSessionId ? undefined : sessionIds.get(workspaceId));
@@ -379,19 +412,19 @@ function resolveSessionForResume(workspaceId, existingSessionId, model) {
     db.prepare('INSERT INTO agent_sessions (id, workspace_id, pid, status, model, started_at) VALUES (?, ?, ?, ?, ?, ?)').run(agentSessionId, workspaceId, null, 'running', model ?? null, new Date().toISOString());
     return { agentSessionId, engineSessionId: undefined, existed: false };
 }
-function reuseOrCreateFreshSession(workspaceId, existingSessionId, model) {
+function reuseOrCreateFreshSession(workspaceId, existingSessionId, model, engine) {
     const db = getDb();
     if (existingSessionId) {
         const result = db
-            .prepare('UPDATE agent_sessions SET status = ?, started_at = ?, ended_at = NULL, model = ? WHERE id = ? AND workspace_id = ?')
-            .run('running', new Date().toISOString(), model ?? null, existingSessionId, workspaceId);
+            .prepare('UPDATE agent_sessions SET status = ?, started_at = ?, ended_at = NULL, model = ?, engine = ? WHERE id = ? AND workspace_id = ?')
+            .run('running', new Date().toISOString(), model ?? null, engine, existingSessionId, workspaceId);
         if (result.changes === 0) {
             throw new Error(`Agent session '${existingSessionId}' not found for workspace '${workspaceId}'`);
         }
         return existingSessionId;
     }
     const agentSessionId = nanoid();
-    db.prepare('INSERT INTO agent_sessions (id, workspace_id, pid, status, model, started_at) VALUES (?, ?, ?, ?, ?, ?)').run(agentSessionId, workspaceId, null, 'running', model ?? null, new Date().toISOString());
+    db.prepare('INSERT INTO agent_sessions (id, workspace_id, pid, engine, status, model, started_at) VALUES (?, ?, ?, ?, ?, ?, ?)').run(agentSessionId, workspaceId, null, engine, 'running', model ?? null, new Date().toISOString());
     return agentSessionId;
 }
 // ── Event handler ─────────────────────────────────────────────────────────────
@@ -753,15 +786,18 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
         const r = resolveSessionForResume(workspaceId, existingSessionId, model);
         agentSessionId = r.agentSessionId;
         resumeFromEngineSessionId = r.engineSessionId;
+        // A native resume is only used by the currently selected workspace engine.
+        // Keep older DB rows attributable even when they were created pre-migration.
+        getDb().prepare('UPDATE agent_sessions SET engine = ? WHERE id = ?').run(engineId, agentSessionId);
     }
     else {
-        agentSessionId = reuseOrCreateFreshSession(workspaceId, existingSessionId, model);
+        agentSessionId = reuseOrCreateFreshSession(workspaceId, existingSessionId, model, engineId);
     }
     const settings = ws ? readEffectiveSettingsSafe(ws.projectPath) : readEffectiveSettingsSafe(workingDir);
     const options = {
         workspaceId,
         workingDir,
-        prompt,
+        prompt: buildAgentPrompt(prompt, ws?.projectPath),
         model,
         effort: reasoningEffort,
         // Cascade: explicit caller override → workspace setting → 'bypass'.
@@ -778,6 +814,7 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
         })(),
         settings,
         mcpServers: buildMcpServers(workspaceId),
+        env: ws ? buildAgentEnv(ws.projectPath) : undefined,
     };
     const controller = new SessionController(workspaceId, agentSessionId, engine, (ev) => handleEvent(workspaceId, agentSessionId, ev));
     controllers.set(workspaceId, controller);

package/dist/server/services/engine-handoff-service.js

@@ -0,0 +1,41 @@
+import { execFileSync } from 'node:child_process';
+import { getDb } from '../db/index.js';
+function runGit(worktreePath, args) {
+    try {
+        return execFileSync('git', args.split(' '), { cwd: worktreePath, encoding: 'utf8', timeout: 10_000 }).trim();
+    }
+    catch {
+        return '';
+    }
+}
+function recentConversation(workspaceId) {
+    const rows = getDb()
+        .prepare(`SELECT type, payload FROM ws_events
+       WHERE workspace_id = ?
+         AND (type = 'user:message' OR (type = 'agent:event' AND json_extract(payload, '$.kind') = 'message:text'))
+       ORDER BY rowid DESC LIMIT 6`)
+        .all(workspaceId);
+    return rows
+        .reverse()
+        .flatMap((row) => {
+        try {
+            const payload = JSON.parse(row.payload);
+            const text = typeof payload.content === 'string' ? payload.content : typeof payload.text === 'string' ? payload.text : '';
+            return text ? [text.slice(0, 1600)] : [];
+        }
+        catch {
+            return [];
+        }
+    })
+        .join('\n\n');
+}
+/** Build a deterministic, secret-free handoff for a fresh session on another engine. */
+export function buildEngineHandoff(workspace, sourceEngine, targetEngine) {
+    const taskLines = workspace.tasks.length
+        ? workspace.tasks.map((task) => `- [${task.status === 'done' ? 'x' : ' '}] ${task.title}`).join('\n')
+        : '- No Kōbō task recorded.';
+    const changedFiles = runGit(workspace.worktreePath, 'status --short') || 'No uncommitted changes detected.';
+    const diffStat = runGit(workspace.worktreePath, 'diff --stat') || 'No uncommitted diff stat available.';
+    const history = recentConversation(workspace.id) || 'No recent conversation message available.';
+    return `# Kōbō engine handoff\n\nYou are taking over this workspace from ${sourceEngine} using ${targetEngine}. Work in the existing worktree and verify the repository state before making changes.\n\n## Objective\n${workspace.description ?? workspace.name}\n\n## Tasks\n${taskLines}\n\n## Git state\n- Branch: ${workspace.workingBranch}\n- Base: ${workspace.sourceBranch}\n- Worktree: ${workspace.worktreePath}\n\nChanged files:\n\`\`\`\n${changedFiles}\n\`\`\`\n\nDiff summary:\n\`\`\`\n${diffStat}\n\`\`\`\n\n## Recent conversation\n${history}\n\n## Recover more context\nIf this handoff is insufficient, use \`kobo__read_workspace_events_csv\` to read the previous workspace conversation in pages (optionally filter by \`session_id\`). Use \`kobo__search_codebase\` to find a precise past decision or user request. Read only the context needed, then continue the task.\n`;
+}