@loicngr/kobo 2.1.4 → 2.1.6

package/dist/server/routes/workspaces.js

@@ -6,7 +6,7 @@ import { getSearchIndexStatus, searchEvents } from '../services/search-service.j
 import { createSessionHandoff, decideSessionHandoff, getCurrentSessionHandoff, SessionHandoffError, submitSessionHandoff, waitForSessionHandoff, } from '../services/session-handoff-service.js';
 import { AgentStopError, assertAgentStopped } from '../utils/agent-stop-result.js';
 import { withGitRepoLock } from '../utils/git-repo-lock.js';
-import { isWorkspaceLifecycleBusy, workspaceLifecycleReason } from '../utils/workspace-lifecycle-guard.js';
+import { assertWorkspaceLifecycleAvailable, isWorkspaceLifecycleBusy, workspaceLifecycleReason, } from '../utils/workspace-lifecycle-guard.js';
 import autoLoopMessagesRoutes from './auto-loop-messages.js';
 const execFileAsync = promisify(execFileCb);
 import fs from 'node:fs';
@@ -73,7 +73,11 @@ function realPathOrResolved(p) {
     }
 }
 function workspaceErrorStatus(err) {
-    return err instanceof AgentStopError || err instanceof WorkspaceLifecycleBusyError ? 409 : 500;
+    return err instanceof AgentStopError ||
+        err instanceof WorkspaceLifecycleBusyError ||
+        err instanceof terminalService.TerminalStopError
+        ? 409
+        : 500;
 }
 /** Hono sub-router for workspace CRUD, tasks, agents, Git and PR creation. */
 const app = new Hono();
@@ -381,7 +385,7 @@ app.post('/:id/engine-handoff-preview', migrationGuard, async (c) => {
         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) });
+        return c.json({ handoff: await buildEngineHandoff(workspace, workspace.engine, engine.id) });
     }
     catch (err) {
         return c.json({ error: err instanceof Error ? err.message : 'Failed to build engine handoff' }, 500);
@@ -414,7 +418,7 @@ app.post('/:id/switch-engine', migrationGuard, async (c) => {
         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);
+            : await buildEngineHandoff(workspace, workspace.engine, body.engine);
         if (workspaceService.getWorkspace(workspace.id)?.status === 'compacting') {
             return c.json({
                 code: 'compacting',
@@ -1914,13 +1918,19 @@ app.post('/:id/pending-wakeup', async (c) => {
         if (rawMode !== 'fresh' && rawMode !== 'resume') {
             return c.json({ error: "mode must be 'fresh' or 'resume'" }, 400);
         }
+        const workspace = workspaceService.getWorkspace(id);
+        if (!workspace)
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        if (workspace.archivedAt || workspace.worktreePurgedAt) {
+            return c.json({ error: 'Restore the workspace before scheduling a wakeup' }, 409);
+        }
+        assertWorkspaceLifecycleAvailable(id);
         // 'resume' pins the active session so the wakeup resumes that conversation;
         // 'fresh' (default) — or 'resume' with no active session — leaves it unpinned
         // so the wakeup fires a brand-new session running `prompt`. This is what makes
         // manual scheduling on an idle workspace possible (no more hard 409).
         const agentSessionId = rawMode === 'resume' ? (agentManager.getActiveSessionId(id) ?? undefined) : undefined;
-        wakeupService.schedule(id, delaySeconds, prompt, reason, agentSessionId);
-        const pending = wakeupService.getPending(id);
+        const pending = wakeupService.schedule(id, delaySeconds, prompt, reason, agentSessionId);
         return c.json({ ok: true, pending });
     }
     catch (err) {
@@ -2408,8 +2418,34 @@ app.get('/:id/events', (c) => {
         // 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');
+        // Optional, narrow history to one child. Nested tool calls keep their
+        // parent origin, so match both that origin and their own toolCallId.
+        const subagentToolCallId = c.req.query('subagentToolCallId');
+        const subagentThreadIds = (c.req.query('subagentThreadIds') ?? '')
+            .split(',')
+            .map((threadId) => threadId.trim())
+            .filter(Boolean)
+            .slice(0, 50);
         const parsedLimit = parseInt(c.req.query('limit') ?? '100', 10);
         const limit = Math.max(1, Math.min(Number.isFinite(parsedLimit) ? parsedLimit : 100, 500));
+        const sessionClause = session ? ' AND (session_id = ? OR session_id IS NULL)' : '';
+        const sessionParams = session ? [session] : [];
+        const originPayload = "CASE WHEN json_valid(payload) THEN payload ELSE '{}' END";
+        const originClauses = [];
+        const originParams = [];
+        if (subagentToolCallId) {
+            originClauses.push(`(json_extract(${originPayload}, '$.origin.toolCallId') = ? OR json_extract(${originPayload}, '$.toolCallId') = ?)`);
+            originParams.push(subagentToolCallId, subagentToolCallId);
+        }
+        if (subagentThreadIds.length > 0) {
+            originClauses.push(`json_extract(${originPayload}, '$.origin.threadId') IN (${subagentThreadIds.map(() => '?').join(', ')})`);
+            originParams.push(...subagentThreadIds);
+        }
+        const originClause = originClauses.length
+            ? ` AND type = 'agent:event' AND json_extract(${originPayload}, '$.origin.kind') = 'subagent' AND (${originClauses.join(' OR ')})`
+            : '';
+        const scopedClause = `${sessionClause}${originClause}`;
+        const scopedParams = [...sessionParams, ...originParams];
         const db = getDb();
         let rows;
         if (around) {
@@ -2417,13 +2453,9 @@ app.get('/:id/events', (c) => {
             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);
+            rows = db
+                .prepare(`SELECT * FROM ws_events WHERE workspace_id = ?${scopedClause} AND rowid BETWEEN ? AND ? ORDER BY rowid ASC`)
+                .all(id, ...scopedParams, targetRow.rowid - halfWindow, targetRow.rowid + halfWindow);
         }
         else if (before) {
             // Get the rowid of the cursor event
@@ -2431,25 +2463,17 @@ app.get('/:id/events', (c) => {
             if (!cursorRow) {
                 return c.json({ events: [], hasMore: false });
             }
-            rows = session
-                ? db
-                    .prepare('SELECT * FROM ws_events WHERE workspace_id = ? AND (session_id = ? OR session_id IS NULL) AND rowid < ? ORDER BY rowid DESC LIMIT ?')
-                    .all(id, session, cursorRow.rowid, limit)
-                : db
-                    .prepare('SELECT * FROM ws_events WHERE workspace_id = ? AND rowid < ? ORDER BY rowid DESC LIMIT ?')
-                    .all(id, cursorRow.rowid, limit);
+            rows = db
+                .prepare(`SELECT * FROM ws_events WHERE workspace_id = ?${scopedClause} AND rowid < ? ORDER BY rowid DESC LIMIT ?`)
+                .all(id, ...scopedParams, cursorRow.rowid, limit);
         }
         else {
             // No cursor — return events. When filtering by session, we want the
             // MOST RECENT events of that session first (so the feed renders from
             // the end), reversed to chronological order below.
-            rows = session
-                ? db
-                    .prepare('SELECT * FROM ws_events WHERE workspace_id = ? AND (session_id = ? OR session_id IS NULL) ORDER BY rowid DESC LIMIT ?')
-                    .all(id, session, limit)
-                : db
-                    .prepare('SELECT * FROM ws_events WHERE workspace_id = ? ORDER BY rowid DESC LIMIT ?')
-                    .all(id, limit);
+            rows = db
+                .prepare(`SELECT * FROM ws_events WHERE workspace_id = ?${scopedClause} ORDER BY rowid DESC LIMIT ?`)
+                .all(id, ...scopedParams, limit);
         }
         // Reverse to chronological order (we queried DESC for "before" pagination,
         // or for the "session + no cursor" case where we fetched the newest first).
@@ -2478,13 +2502,9 @@ app.get('/:id/events', (c) => {
             if (before || around) {
                 const firstRow = db.prepare('SELECT rowid FROM ws_events WHERE id = ?').get(rows[0].id);
                 if (firstRow) {
-                    const older = session
-                        ? db
-                            .prepare('SELECT 1 as c FROM ws_events WHERE workspace_id = ? AND (session_id = ? OR session_id IS NULL) AND rowid < ? LIMIT 1')
-                            .get(id, session, firstRow.rowid)
-                        : db
-                            .prepare('SELECT 1 as c FROM ws_events WHERE workspace_id = ? AND rowid < ? LIMIT 1')
-                            .get(id, firstRow.rowid);
+                    const older = db
+                        .prepare(`SELECT 1 as c FROM ws_events WHERE workspace_id = ?${scopedClause} AND rowid < ? LIMIT 1`)
+                        .get(id, ...scopedParams, firstRow.rowid);
                     hasMore = older !== undefined;
                 }
             }
@@ -2492,11 +2512,9 @@ app.get('/:id/events', (c) => {
                 // `LIMIT 1 OFFSET <page size>` answers "is there anything past this
                 // page?" by reading one row, where COUNT(*) walked every event the
                 // workspace ever produced — on each page, synchronously.
-                const beyond = session
-                    ? db
-                        .prepare('SELECT 1 as c FROM ws_events WHERE workspace_id = ? AND (session_id = ? OR session_id IS NULL) LIMIT 1 OFFSET ?')
-                        .get(id, session, rows.length)
-                    : db.prepare('SELECT 1 as c FROM ws_events WHERE workspace_id = ? LIMIT 1 OFFSET ?').get(id, rows.length);
+                const beyond = db
+                    .prepare(`SELECT 1 as c FROM ws_events WHERE workspace_id = ?${scopedClause} LIMIT 1 OFFSET ?`)
+                    .get(id, ...scopedParams, rows.length);
                 hasMore = beyond !== undefined;
             }
         }
@@ -3018,12 +3036,7 @@ app.post('/:id/archive', migrationGuard, async (c) => {
             console.error(`[workspaces] stopDevServer during archive failed: ${message}`);
             throw err;
         }
-        try {
-            terminalService.destroyTerminal(id);
-        }
-        catch {
-            // Terminal may not exist — ignore
-        }
+        await terminalService.destroyTerminal(id);
         const updated = workspaceService.archiveWorkspace(id);
         wsService.emitEphemeral(id, 'workspace:archived', { workspace: updated });
         // Run the project's archive script (best-effort — never blocks the archive).
@@ -3140,12 +3153,7 @@ async function deleteWorkspaceWithSideEffectsUnlocked(workspace, opts) {
         console.error(`[workspaces] stopDevServer during delete failed for '${workspace.name}':`, err);
         throw err;
     }
-    try {
-        terminalService.destroyTerminal(workspace.id);
-    }
-    catch {
-        // Terminal may not exist — ignore
-    }
+    await terminalService.destroyTerminal(workspace.id);
     // Collected best-effort warnings: the DB deletion always proceeds, but
     // side-effects (worktree, local/remote branches) can fail independently.
     // We surface a user-friendly message per failure so the UI can show a
@@ -3178,7 +3186,7 @@ async function deleteWorkspaceWithSideEffectsUnlocked(workspace, opts) {
     // Delete local branch if requested
     if (opts.deleteLocalBranch) {
         try {
-            gitOps.deleteLocalBranch(workspace.projectPath, workspace.workingBranch);
+            await gitOps.deleteLocalBranchAsync(workspace.projectPath, workspace.workingBranch);
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
@@ -3191,7 +3199,7 @@ async function deleteWorkspaceWithSideEffectsUnlocked(workspace, opts) {
     // Delete remote branch if requested
     if (opts.deleteRemoteBranch) {
         try {
-            gitOps.deleteRemoteBranch(workspace.projectPath, workspace.workingBranch);
+            await gitOps.deleteRemoteBranchAsync(workspace.projectPath, workspace.workingBranch);
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
@@ -3405,7 +3413,7 @@ app.get('/:id/diff', async (c) => {
             if (!from || !to) {
                 return c.json({ error: 'mode=commits requires from and to query params' }, 400);
             }
-            if (!gitOps.commitExists(worktreePath, to)) {
+            if (!(await gitOps.commitExistsAsync(worktreePath, to))) {
                 return c.json({ error: `Invalid commit ref '${to}'` }, 400);
             }
             // `to` is strict (400 above). `from` is intentionally lenient: any ref it
@@ -3413,8 +3421,8 @@ app.get('/:id/diff', async (c) => {
             // only unresolved `from` the UI ever sends is a root commit's `<sha>^`
             // (single-commit diff of the first commit); the compare dialog otherwise
             // only offers refs that resolve.
-            const fromRef = gitOps.commitExists(worktreePath, from) ? from : gitOps.EMPTY_TREE_SHA;
-            const files = gitOps.getChangedFilesBetween(worktreePath, fromRef, to);
+            const fromRef = (await gitOps.commitExistsAsync(worktreePath, from)) ? from : gitOps.EMPTY_TREE_SHA;
+            const files = await gitOps.getChangedFilesBetweenAsync(worktreePath, fromRef, to);
             c.header('Cache-Control', 'no-store');
             return c.json({ files, mode: 'commits', from: fromRef, to });
         }
@@ -3426,8 +3434,8 @@ app.get('/:id/diff', async (c) => {
             await gitOps.fetchSourceBranchAsync(worktreePath, workspace.sourceBranch);
         }
         const files = mode === 'unpushed'
-            ? gitOps.getUnpushedChangedFiles(worktreePath, workspace.workingBranch)
-            : gitOps.getChangedFiles(worktreePath, workspace.sourceBranch, includeUntracked);
+            ? await gitOps.getUnpushedChangedFilesAsync(worktreePath, workspace.workingBranch)
+            : await gitOps.getChangedFilesAsync(worktreePath, workspace.sourceBranch, includeUntracked);
         c.header('Cache-Control', 'no-store');
         return c.json({
             files,
@@ -3446,7 +3454,7 @@ app.get('/:id/diff', async (c) => {
 //  - `branch`   → sourceBranch
 //  - `unpushed` → origin/<workingBranch>
 // `modified` is always the current worktree content.
-app.get('/:id/diff-file', (c) => {
+app.get('/:id/diff-file', async (c) => {
     try {
         const id = c.req.param('id');
         const filePath = c.req.query('path');
@@ -3472,14 +3480,16 @@ app.get('/:id/diff-file', (c) => {
             if (!from || !to) {
                 return c.json({ error: 'mode=commits requires from and to query params' }, 400);
             }
-            if (!gitOps.commitExists(worktreePath, to)) {
+            if (!(await gitOps.commitExistsAsync(worktreePath, to))) {
                 return c.json({ error: `Invalid commit ref '${to}'` }, 400);
             }
             // `from` is lenient (empty-tree fallback) for a root commit's `<sha>^` —
             // see the matching note in the `/diff` commits branch above.
-            const fromRef = gitOps.commitExists(worktreePath, from) ? from : gitOps.EMPTY_TREE_SHA;
-            const original = gitOps.getFileAtRef(worktreePath, fromRef, filePath);
-            const modified = gitOps.getFileAtRef(worktreePath, to, filePath);
+            const fromRef = (await gitOps.commitExistsAsync(worktreePath, from)) ? from : gitOps.EMPTY_TREE_SHA;
+            const [original, modified] = await Promise.all([
+                gitOps.getFileAtRefAsync(worktreePath, fromRef, filePath),
+                gitOps.getFileAtRefAsync(worktreePath, to, filePath),
+            ]);
             c.header('Cache-Control', 'no-store');
             return c.json({
                 original: original ?? '',
@@ -3491,7 +3501,7 @@ app.get('/:id/diff-file', (c) => {
             });
         }
         const baseRef = mode === 'unpushed' ? `origin/${workspace.workingBranch}` : workspace.sourceBranch;
-        const original = gitOps.getFileAtRef(worktreePath, baseRef, filePath);
+        const original = await gitOps.getFileAtRefAsync(worktreePath, baseRef, filePath);
         const modified = gitOps.getFileContent(worktreePath, filePath);
         c.header('Cache-Control', 'no-store');
         return c.json({
@@ -3555,7 +3565,7 @@ app.post('/:id/rollback-file', async (c) => {
 // GET /api/workspaces/:id/branch-divergence?limit=50
 // Returns commits on the working branch ahead of `origin/<sourceBranch>`
 // (`ahead`) and commits on `origin/<sourceBranch>` not yet on the working
-// branch (`behind`). Refreshes `origin/<sourceBranch>` synchronously so the
+// branch (`behind`). Awaits refreshing `origin/<sourceBranch>` so the
 // counts and lists are never computed against a stale local source ref.
 app.get('/:id/branch-divergence', async (c) => {
     try {
@@ -3569,8 +3579,8 @@ app.get('/:id/branch-divergence', async (c) => {
         const limit = Math.min(Math.max(1, Number.isNaN(parsed) ? 50 : parsed), 200);
         const worktreePath = workspace.worktreePath;
         await gitOps.fetchSourceBranchAsync(worktreePath, workspace.sourceBranch);
-        const ahead = gitOps.listBranchCommits(worktreePath, workspace.sourceBranch, workspace.workingBranch, limit);
-        const behind = gitOps.listCommitsBehind(worktreePath, workspace.sourceBranch, workspace.workingBranch, limit);
+        const ahead = await gitOps.listBranchCommitsAsync(worktreePath, workspace.sourceBranch, workspace.workingBranch, limit);
+        const behind = await gitOps.listCommitsBehindAsync(worktreePath, workspace.sourceBranch, workspace.workingBranch, limit);
         c.header('Cache-Control', 'no-store');
         return c.json({
             ahead,
@@ -3586,7 +3596,7 @@ app.get('/:id/branch-divergence', async (c) => {
 });
 // GET /api/workspaces/:id/commits?limit=50 — list commits between
 // `origin/<sourceBranch>` and HEAD, each tagged with whether it's already
-// pushed to origin/<branch>. Refreshes `origin/<sourceBranch>` synchronously
+// pushed to origin/<branch>. Awaits refreshing `origin/<sourceBranch>`
 // so the list is not computed against a stale local source ref.
 app.get('/:id/commits', async (c) => {
     try {
@@ -3599,7 +3609,7 @@ app.get('/:id/commits', async (c) => {
         const limit = Math.min(Math.max(1, parseInt(limitRaw ?? '50', 10) || 50), 200);
         const worktreePath = workspace.worktreePath;
         await gitOps.fetchSourceBranchAsync(worktreePath, workspace.sourceBranch);
-        const commits = gitOps.listBranchCommits(worktreePath, workspace.sourceBranch, workspace.workingBranch, limit);
+        const commits = await gitOps.listBranchCommitsAsync(worktreePath, workspace.sourceBranch, workspace.workingBranch, limit);
         c.header('Cache-Control', 'no-store');
         return c.json({ commits, sourceBranch: workspace.sourceBranch, workingBranch: workspace.workingBranch });
     }
@@ -3609,13 +3619,13 @@ app.get('/:id/commits', async (c) => {
     }
 });
 // GET /:id/working-tree-files — list uncommitted working-tree files (read-only)
-app.get('/:id/working-tree-files', (c) => {
+app.get('/:id/working-tree-files', async (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 files = gitOps.getWorkingTreeFiles(workspace.worktreePath);
+        const files = await gitOps.getWorkingTreeFilesAsync(workspace.worktreePath);
         return c.json({ files });
     }
     catch (err) {
@@ -3954,7 +3964,7 @@ app.post('/:id/git/commit-with-agent', migrationGuard, async (c) => {
         const workspace = workspaceService.getWorkspace(id);
         if (!workspace)
             return c.json({ error: `Workspace '${id}' not found` }, 404);
-        const workingTree = gitOps.getWorkingTreeStatus(workspace.worktreePath);
+        const workingTree = await gitOps.getWorkingTreeStatusAsync(workspace.worktreePath);
         if (workingTree.staged + workingTree.modified + workingTree.untracked === 0) {
             return c.json({ error: 'No uncommitted changes to commit' }, 400);
         }
@@ -4372,8 +4382,8 @@ app.post('/:id/open-pr', async (c) => {
             return c.json({ ok: true, prNumber, prUrl, messageSent: false });
         }
         // Build context and render the PR prompt template
-        const commits = gitOps.getCommitsBetween(worktreePath, workspace.sourceBranch, workspace.workingBranch);
-        const diffStats = gitOps.getDiffStatsBetween(worktreePath, workspace.sourceBranch, workspace.workingBranch);
+        const commits = await gitOps.getCommitsBetweenAsync(worktreePath, workspace.sourceBranch, workspace.workingBranch);
+        const diffStats = await gitOps.getDiffStatsBetweenAsync(worktreePath, workspace.sourceBranch, workspace.workingBranch);
         const tasks = workspaceService.listTasks(workspace.id);
         const rendered = renderPrTemplate(effective.prPromptTemplate, {
             workspace,

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

@@ -94,6 +94,8 @@ const TASK_UPDATED_TERMINAL_STATUS = {
 };
 export function createMapperState() {
     return {
+        childMessageOrigins: new Map(),
+        childToolOrigins: new Map(),
         sessionStartedEmitted: false,
         openMessages: new Map(),
         sawErrorResult: false,
@@ -147,6 +149,37 @@ function tryEmitQuotaError(state, events, message) {
  * `state` as needed.
  */
 export function mapSdkMessage(msg, state) {
+    const parsed = msg;
+    const parentId = typeof parsed.parent_tool_use_id === 'string' ? parsed.parent_tool_use_id : undefined;
+    const origin = parentId ? { kind: 'subagent', toolCallId: parentId } : undefined;
+    const streamed = parsed.event;
+    if (origin && streamed?.type === 'message_start' && streamed.message?.id) {
+        state.childMessageOrigins.set(streamed.message.id, origin);
+    }
+    const events = mapSdkMessagePayload(msg, state);
+    return events.map((event) => {
+        if (event.kind === 'message:text' || event.kind === 'message:thinking' || event.kind === 'message:end') {
+            const eventOrigin = origin ?? state.childMessageOrigins.get(event.messageId);
+            if (origin)
+                state.childMessageOrigins.set(event.messageId, origin);
+            if (event.kind === 'message:end')
+                state.childMessageOrigins.delete(event.messageId);
+            return eventOrigin ? { ...event, origin: eventOrigin } : event;
+        }
+        if (event.kind === 'tool:call') {
+            if (origin)
+                state.childToolOrigins.set(event.toolCallId, origin);
+            return origin ? { ...event, origin } : event;
+        }
+        if (event.kind === 'tool:result') {
+            const eventOrigin = origin ?? state.childToolOrigins.get(event.toolCallId);
+            state.childToolOrigins.delete(event.toolCallId);
+            return eventOrigin ? { ...event, origin: eventOrigin } : event;
+        }
+        return event;
+    });
+}
+function mapSdkMessagePayload(msg, state) {
     // Treat as a generic record — the SDK discriminated union is too broad to
     // narrow per branch here.
     const parsed = msg;

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

@@ -276,7 +276,16 @@ export function createCodexEngine() {
                 }
                 // Child output remains visible, but its failures/compaction/markers
                 // cannot control the parent session or its auto-loop lifecycle.
-                return map(state).filter((event) => event.kind !== 'error' && !event.kind.startsWith('session:'));
+                return map(state)
+                    .filter((event) => event.kind !== 'error' && !event.kind.startsWith('session:'))
+                    .map((event) => {
+                    const origin = { kind: 'subagent', threadId: notification.threadId };
+                    if (event.kind === 'message:text' || event.kind === 'message:thinking' || event.kind === 'message:end')
+                        return { ...event, origin };
+                    if (event.kind === 'tool:call' || event.kind === 'tool:result')
+                        return { ...event, origin };
+                    return event;
+                });
             };
             const itemKey = (threadId, turnId, itemId) => JSON.stringify([threadId, turnId, itemId]);
             const client = createAppServerClient({

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

@@ -134,6 +134,7 @@ export function handleItemStarted(item, state) {
         events.push({
             kind: 'subagent:progress',
             toolCallId,
+            threadIds: item.receiverThreadIds,
             status: 'running',
             description: item.prompt ?? item.tool,
             taskType: item.tool,
@@ -271,6 +272,7 @@ export function handleItemCompleted(item, state) {
         events.push({
             kind: 'subagent:progress',
             toolCallId,
+            threadIds: item.receiverThreadIds,
             status: hasActiveAgent ? 'running' : 'done',
             description: item.prompt ?? item.tool,
             taskType: item.tool,

package/dist/server/services/agent/integration-mcp.js

@@ -14,10 +14,11 @@ export function hasIntegrationMcpConfig(integration, selectedKey) {
     return Boolean(readClaudeMcpEntry((name) => key ? name === key : integration === 'notion' ? name === 'notion' : /sentry/i.test(name)));
 }
 /** Resolve at every launch/resume; never write credentials into a project file. */
-export function buildIntegrationMcpServers(settings, onUnavailable) {
+export function buildIntegrationMcpServers(settings, engineId, onUnavailable) {
     const servers = [];
-    // Fresh names avoid Codex recursively merging stale native config fields.
-    const launch = nanoid(12);
+    // Codex needs fresh names to avoid recursively merging stale native config.
+    // Claude needs stable tool names to preserve its prompt cache across resumes.
+    const launch = engineId === 'codex' ? nanoid(12) : 'managed';
     for (const integration of ['notion', 'sentry']) {
         if (!settings[`${integration}Enabled`])
             continue;

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

@@ -1385,7 +1385,7 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
     // enforce read-only plan mode here, not only through its prompt.
     const readOnly = getReviewReturn(workspaceId, agentSessionId) !== null;
     const unavailableIntegrations = [];
-    const integrationServers = buildIntegrationMcpServers(getGlobalSettings(), (name) => unavailableIntegrations.push(name));
+    const integrationServers = buildIntegrationMcpServers(getGlobalSettings(), engine.id, (name) => unavailableIntegrations.push(name));
     const options = {
         workspaceId,
         workingDir,

package/dist/server/services/agent/streaming-batcher.js

@@ -8,19 +8,30 @@ export function createStreamingBatcher(emit, options = {}) {
             return;
         clearTimeout(entry.timer);
         pending.delete(messageId);
-        emit({ kind: 'message:text', messageId, text: entry.text, streaming: true });
+        emit({
+            kind: 'message:text',
+            messageId,
+            text: entry.text,
+            streaming: true,
+            ...(entry.origin ? { origin: entry.origin } : {}),
+        });
     };
     return {
         push(event) {
             if (event.kind === 'message:text' && event.streaming) {
-                const entry = pending.get(event.messageId);
+                let entry = pending.get(event.messageId);
+                if (entry &&
+                    (entry.origin?.toolCallId !== event.origin?.toolCallId || entry.origin?.threadId !== event.origin?.threadId)) {
+                    flush(event.messageId);
+                    entry = undefined;
+                }
                 if (entry) {
                     entry.text += event.text;
                     return;
                 }
                 const timer = setTimeout(() => flush(event.messageId), windowMs);
                 timer.unref?.();
-                pending.set(event.messageId, { text: event.text, timer });
+                pending.set(event.messageId, { text: event.text, origin: event.origin, timer });
                 return;
             }
             if (event.kind === 'message:end')