@xopcai/xopc 0.0.158 → 0.0.160

package/dist/src/gateway/chat-stream/thinking-delta-coalescer.js

@@ -0,0 +1,103 @@
+//#region src/gateway/chat-stream/thinking-delta-coalescer.ts
+const DEFAULT_WINDOW_MS = 24;
+const DEFAULT_MAX_CHARS = 256;
+function isThinkingDelta(event) {
+	return event.type === "thinking_delta";
+}
+function belongsToSameThinkingStream(left, right) {
+	return left.runId === right.runId && left.sessionKey === right.sessionKey && left.payload.messageId === right.payload.messageId;
+}
+function mergeThinkingDelta(left, right) {
+	return {
+		...left,
+		payload: {
+			...left.payload,
+			delta: left.payload.delta + right.payload.delta
+		}
+	};
+}
+async function nextBeforeDeadline(next, deadlineAt) {
+	let timer;
+	try {
+		return await Promise.race([next.then((result) => ({
+			kind: "next",
+			result
+		})), new Promise((resolve) => {
+			timer = setTimeout(() => resolve({ kind: "timeout" }), Math.max(0, deadlineAt - Date.now()));
+		})]);
+	} finally {
+		if (timer !== void 0) clearTimeout(timer);
+	}
+}
+async function* coalesceThinkingDeltas(source, options = {}) {
+	const windowMs = options.windowMs ?? DEFAULT_WINDOW_MS;
+	const maxChars = options.maxChars ?? DEFAULT_MAX_CHARS;
+	if (!Number.isFinite(windowMs) || windowMs <= 0) throw new Error("thinking delta coalescer windowMs must be greater than zero");
+	if (!Number.isInteger(maxChars) || maxChars <= 0) throw new Error("thinking delta coalescer maxChars must be a positive integer");
+	const iterator = source[Symbol.asyncIterator]();
+	let next = iterator.next();
+	let pending;
+	let deadlineAt = 0;
+	try {
+		while (true) {
+			if (!pending) {
+				const result = await next;
+				if (result.done) break;
+				next = iterator.next();
+				if (!isThinkingDelta(result.value)) {
+					yield result.value;
+					continue;
+				}
+				pending = result.value;
+				deadlineAt = Date.now() + windowMs;
+				if (pending.payload.delta.length >= maxChars) {
+					yield pending;
+					pending = void 0;
+				}
+				continue;
+			}
+			const outcome = await nextBeforeDeadline(next, deadlineAt);
+			if (outcome.kind === "timeout") {
+				yield pending;
+				pending = void 0;
+				continue;
+			}
+			const result = outcome.result;
+			if (result.done) {
+				yield pending;
+				pending = void 0;
+				break;
+			}
+			next = iterator.next();
+			const event = result.value;
+			if (!isThinkingDelta(event) || !belongsToSameThinkingStream(pending, event)) {
+				yield pending;
+				pending = void 0;
+				if (isThinkingDelta(event)) {
+					pending = event;
+					deadlineAt = Date.now() + windowMs;
+					if (pending.payload.delta.length >= maxChars) {
+						yield pending;
+						pending = void 0;
+					}
+				} else yield event;
+				continue;
+			}
+			pending = mergeThinkingDelta(pending, event);
+			if (pending.payload.delta.length >= maxChars) {
+				yield pending;
+				pending = void 0;
+			}
+		}
+	} catch (error) {
+		if (pending) {
+			yield pending;
+			pending = void 0;
+		}
+		throw error;
+	} finally {
+		await iterator.return?.();
+	}
+}
+//#endregion
+export { coalesceThinkingDeltas };

package/dist/src/gateway/hono/routes/home.js

@@ -3,6 +3,10 @@ import "../../../storage/sqlite/index.js";
 import { GoalService } from "../../../goals/goal-service.js";
 import "../../../goals/index.js";
 import { listGatewayAgents } from "../../agents-admin.js";
+import { listFocusCalendarSignals } from "../../../proactive/calendar-signals.js";
+import { FocusService } from "../../../proactive/focus-service.js";
+import { listProactiveInsights } from "../../../proactive/insight-repository.js";
+import "../../../proactive/index.js";
 import { WorkItemService } from "../../../work-items/work-item-service.js";
 import "../../../work-items/index.js";
 import { getTunnelService } from "../../../tunnel/tunnel-service.js";
@@ -155,6 +159,7 @@ function buildHomeBriefing(input) {
 function registerHomeRoutes(authenticated, deps) {
 	const { service } = deps;
 	const goals = new GoalService();
+	const focuses = new FocusService(service.automationServiceInstance);
 	authenticated.get("/api/home", async (c) => {
 		const notes = service.notesServiceInstance;
 		const sessions = service.sessions;
@@ -165,7 +170,8 @@ function registerHomeRoutes(authenticated, deps) {
 		const health = service.getHealth();
 		const workItems = new WorkItemService();
 		const nowMs = Date.now();
-		const [recentlyOpened, inbox, pendingTasks, recentSessions, workflowRuns, automations, automationRuns, projects, allWorkItems, activeGoals, connectorApprovals] = await Promise.all([
+		const focusViews = focuses.list();
+		const [recentlyOpened, inbox, pendingTasks, recentSessions, workflowRuns, automations, automationRuns, projects, allWorkItems, activeGoals, connectorApprovals, proactiveInsights, calendarSignals] = await Promise.all([
 			notes.listNotes({
 				sortBy: "lastOpenedAt",
 				sortOrder: "desc",
@@ -204,7 +210,12 @@ function registerHomeRoutes(authenticated, deps) {
 				principalId: "local-owner",
 				status: "pending",
 				limit: 100
-			}))
+			})),
+			Promise.resolve(listProactiveInsights({
+				status: ["unread"],
+				limit: 10
+			})),
+			Promise.resolve(listFocusCalendarSignals(focusViews, nowMs))
 		]);
 		const projectsById = new Map(projects.items.map((project) => [project.id, project]));
 		const activeWorkItems = allWorkItems.items.filter((item) => item.status !== "done" && item.status !== "cancelled").sort((left, right) => {
@@ -338,6 +349,8 @@ function registerHomeRoutes(authenticated, deps) {
 			},
 			briefing,
 			decisions,
+			proactiveInsights,
+			calendarSignals,
 			work: {
 				attentionCount: activeWorkItems.filter((item) => workItemAttentionRank(item, nowMs) < 3).length,
 				overdueCount: activeWorkItems.filter((item) => item.dueAt != null && item.dueAt < nowMs).length,

package/dist/src/gateway/hono/routes/work-discovery.js

@@ -1,6 +1,10 @@
 import { getAgentDefaultModelRef, init_schema } from "../../../config/schema.js";
 import { init_providers, resolveModel } from "../../../providers/index.js";
 import { isLocalModelBaseUrl } from "../../../providers/model-call.js";
+import { listFocusCalendarSignals } from "../../../proactive/calendar-signals.js";
+import { FocusService } from "../../../proactive/focus-service.js";
+import { claimProactiveInsightApproval, getProactiveInsight, setProactiveInsightStatus } from "../../../proactive/insight-repository.js";
+import "../../../proactive/index.js";
 import { previewWorkDiscoveryRoot } from "../../../work-discovery/probe.js";
 import { WorkDiscoveryService } from "../../../work-discovery/service.js";
 //#region src/gateway/hono/routes/work-discovery.ts
@@ -26,6 +30,7 @@ function stringField(body, field) {
 }
 function registerWorkDiscoveryRoutes(authenticated, deps) {
 	const service = workDiscoveryService(deps);
+	const focuses = new FocusService(deps.service.automationServiceInstance);
 	const limited = deps.strictRateLimitMiddleware;
 	authenticated.get("/api/onboarding/work-discovery", (c) => c.json({
 		enabled: service.isEnabled(),
@@ -77,6 +82,178 @@ function registerWorkDiscoveryRoutes(authenticated, deps) {
 			}, 400);
 		}
 	});
+	authenticated.post("/api/work-discovery/candidates", limited, async (c) => {
+		if (!service.isEnabled()) return c.json({
+			ok: false,
+			error: "Work discovery is disabled"
+		}, 404);
+		try {
+			const candidates = await service.discoverCandidates(c.req.raw.signal);
+			return c.json({
+				ok: true,
+				candidates
+			});
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 500);
+		}
+	});
+	authenticated.get("/api/work-discovery/sources/directories", (c) => c.json({
+		ok: true,
+		sources: service.listDirectorySources()
+	}));
+	authenticated.post("/api/work-discovery/sources/directories", limited, async (c) => {
+		const rootPath = stringField(await c.req.json().catch(() => null), "rootPath");
+		if (!rootPath) return c.json({
+			ok: false,
+			error: "Missing rootPath"
+		}, 400);
+		try {
+			const source = await service.grantDirectorySource(rootPath);
+			return c.json({
+				ok: true,
+				source
+			}, 201);
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 400);
+		}
+	});
+	authenticated.delete("/api/work-discovery/sources/directories/:sourceId", limited, (c) => {
+		const source = service.revokeDirectorySource(c.req.param("sourceId"));
+		return source ? c.json({
+			ok: true,
+			source
+		}) : c.json({
+			ok: false,
+			error: "Source not found"
+		}, 404);
+	});
+	authenticated.post("/api/work-discovery/sources/directories/:sourceId/runs", limited, async (c) => {
+		const idempotencyKey = stringField(await c.req.json().catch(() => null), "idempotencyKey");
+		if (!idempotencyKey) return c.json({
+			ok: false,
+			error: "Missing idempotencyKey"
+		}, 400);
+		try {
+			const run = await service.rescanDirectorySource({
+				id: c.req.param("sourceId"),
+				idempotencyKey
+			});
+			return c.json({
+				ok: true,
+				run
+			}, 202);
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 400);
+		}
+	});
+	authenticated.post("/api/work-discovery/sources/directories/check", limited, async (c) => {
+		return c.json({
+			ok: true,
+			checks: await service.checkDirectorySources()
+		});
+	});
+	authenticated.post("/api/work-discovery/sources/directories/:sourceId/refresh-if-changed", limited, async (c) => {
+		const idempotencyKey = stringField(await c.req.json().catch(() => null), "idempotencyKey");
+		if (!idempotencyKey) return c.json({
+			ok: false,
+			error: "Missing idempotencyKey"
+		}, 400);
+		try {
+			const result = await service.refreshDirectorySourceIfChanged({
+				id: c.req.param("sourceId"),
+				idempotencyKey
+			});
+			return c.json({
+				ok: true,
+				...result
+			}, result.changed ? 202 : 200);
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 400);
+		}
+	});
+	authenticated.post("/api/work-discovery/personal-context/import", limited, async (c) => {
+		if (!service.isEnabled()) return c.json({
+			ok: false,
+			error: "Work discovery is disabled"
+		}, 404);
+		const body = await c.req.json().catch(() => null);
+		const items = body && typeof body === "object" && Array.isArray(body.items) ? body.items.slice(0, 150) : [];
+		const runId = stringField(body, "runId");
+		if (!items.length) return c.json({
+			ok: false,
+			error: "No personal context was provided"
+		}, 400);
+		try {
+			const result = await service.importPersonalContext(items, c.req.raw.signal, runId || void 0);
+			return c.json({
+				ok: true,
+				...result
+			}, 201);
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 400);
+		}
+	});
+	authenticated.post("/api/work-discovery/personal-context/profile", limited, async (c) => {
+		const body = await c.req.json().catch(() => null);
+		const decisions = (body && typeof body === "object" && Array.isArray(body.decisions) ? body.decisions : []).flatMap((value) => {
+			if (!value || typeof value !== "object") return [];
+			const item = value;
+			const memoryRecordId = typeof item.memoryRecordId === "string" ? item.memoryRecordId.trim() : "";
+			const status = item.status === "accepted" || item.status === "edited" || item.status === "rejected" ? item.status : void 0;
+			if (!memoryRecordId || !status) return [];
+			return [{
+				memoryRecordId,
+				status,
+				...typeof item.statement === "string" ? { statement: item.statement } : {}
+			}];
+		}).slice(0, 10);
+		if (!decisions.length) return c.json({
+			ok: false,
+			error: "At least one valid decision is required"
+		}, 400);
+		return c.json({
+			ok: true,
+			decisions: service.updatePersonalContextProfile({ decisions })
+		});
+	});
+	authenticated.post("/api/work-discovery/quick-runs", limited, async (c) => {
+		if (!service.isEnabled()) return c.json({
+			ok: false,
+			error: "Work discovery is disabled"
+		}, 404);
+		const idempotencyKey = stringField(await c.req.json().catch(() => null), "idempotencyKey");
+		if (!idempotencyKey) return c.json({
+			ok: false,
+			error: "Missing idempotencyKey"
+		}, 400);
+		try {
+			const run = await service.startQuickRun({ idempotencyKey });
+			return c.json({
+				ok: true,
+				run
+			}, 202);
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 400);
+		}
+	});
 	authenticated.post("/api/work-discovery/runs", limited, async (c) => {
 		if (!service.isEnabled()) return c.json({
 			ok: false,
@@ -117,6 +294,250 @@ function registerWorkDiscoveryRoutes(authenticated, deps) {
 			error: "Run not found"
 		}, 404);
 	});
+	authenticated.get("/api/work-discovery/runs/:runId/investigation", (c) => {
+		const result = service.getInvestigation(c.req.param("runId"));
+		return result ? c.json({
+			ok: true,
+			...result
+		}) : c.json({
+			ok: false,
+			error: "Investigation not found"
+		}, 404);
+	});
+	authenticated.get("/api/work-understanding/threads", (c) => {
+		const projectId = c.req.query("projectId")?.trim();
+		const limit = Number(c.req.query("limit"));
+		return c.json({
+			ok: true,
+			threads: service.listWorkThreads({
+				...projectId ? { projectId } : {},
+				...Number.isFinite(limit) ? { limit } : {}
+			})
+		});
+	});
+	authenticated.get("/api/work-understanding/metrics", (c) => c.json({
+		ok: true,
+		metrics: service.getUnderstandingMetrics()
+	}));
+	authenticated.get("/api/work-understanding/sources/:sourceId/lineage", (c) => {
+		const lineage = service.getSourceLineage(c.req.param("sourceId"));
+		return lineage ? c.json({
+			ok: true,
+			lineage
+		}) : c.json({
+			ok: false,
+			error: "Source not found"
+		}, 404);
+	});
+	authenticated.delete("/api/work-understanding/sources/:sourceId/derived-data", limited, (c) => {
+		const deleted = service.deleteSourceDerivedData(c.req.param("sourceId"));
+		return deleted ? c.json({
+			ok: true,
+			deleted
+		}) : c.json({
+			ok: false,
+			error: "Source not found"
+		}, 404);
+	});
+	authenticated.get("/api/work-understanding/threads/:threadId", (c) => {
+		const thread = service.getWorkThread(c.req.param("threadId"));
+		return thread ? c.json({
+			ok: true,
+			thread
+		}) : c.json({
+			ok: false,
+			error: "Work thread not found"
+		}, 404);
+	});
+	authenticated.patch("/api/work-understanding/threads/:threadId", limited, async (c) => {
+		const body = await c.req.json().catch(() => null);
+		const decision = stringField(body, "decision");
+		if (![
+			"confirmed",
+			"corrected",
+			"rejected",
+			"paused",
+			"completed"
+		].includes(decision)) return c.json({
+			ok: false,
+			error: "Invalid work thread decision"
+		}, 400);
+		const thread = service.updateWorkThread({
+			id: c.req.param("threadId"),
+			decision,
+			...stringField(body, "correctedTitle") ? { correctedTitle: stringField(body, "correctedTitle") } : {},
+			...stringField(body, "correctedSummary") ? { correctedSummary: stringField(body, "correctedSummary") } : {}
+		});
+		return thread ? c.json({
+			ok: true,
+			thread
+		}) : c.json({
+			ok: false,
+			error: "Work thread not found"
+		}, 404);
+	});
+	authenticated.get("/api/focuses", (c) => {
+		return c.json({
+			ok: true,
+			focuses: focuses.list({ includeUnreviewed: c.req.query("includeUnreviewed") === "true" })
+		});
+	});
+	authenticated.post("/api/focuses/:focusId/confirm", limited, (c) => {
+		const focus = focuses.confirm(c.req.param("focusId"));
+		return focus ? c.json({
+			ok: true,
+			focus
+		}) : c.json({
+			ok: false,
+			error: "Focus not found"
+		}, 404);
+	});
+	authenticated.post("/api/focuses/:focusId/watches/trial", limited, async (c) => {
+		const requestedKind = stringField(await c.req.json().catch(() => null), "kind");
+		const kind = [
+			"progress",
+			"staleness",
+			"deadline",
+			"intelligence"
+		].includes(requestedKind) ? requestedKind : void 0;
+		try {
+			const result = await focuses.activateTrial({
+				threadId: c.req.param("focusId"),
+				...kind ? { kind } : {}
+			});
+			return c.json({
+				ok: true,
+				...result
+			}, 201);
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 400);
+		}
+	});
+	authenticated.post("/api/focuses/:focusId/watches/:watchId/pause", limited, async (c) => {
+		const watch = focuses.list({ includeUnreviewed: true }).find((item) => item.id === c.req.param("focusId"))?.watches.find((item) => item.id === c.req.param("watchId"));
+		if (!watch) return c.json({
+			ok: false,
+			error: "Watch not found"
+		}, 404);
+		const paused = await focuses.pauseWatch(watch.id);
+		return c.json({
+			ok: true,
+			watch: paused
+		});
+	});
+	authenticated.patch("/api/proactive/insights/:insightId", limited, async (c) => {
+		const requested = stringField(await c.req.json().catch(() => null), "status");
+		const status = requested === "read" || requested === "dismissed" ? requested : void 0;
+		if (!status) return c.json({
+			ok: false,
+			error: "Status must be read or dismissed"
+		}, 400);
+		const insight = setProactiveInsightStatus(c.req.param("insightId"), status, Date.now(), "unread");
+		if (!insight) return c.json({
+			ok: false,
+			error: "Insight was already handled or not found"
+		}, 409);
+		if (status === "dismissed") await focuses.recordInsightFeedback(insight.watchId, false);
+		return c.json({
+			ok: true,
+			insight
+		});
+	});
+	authenticated.post("/api/proactive/insights/:insightId/approve", limited, async (c) => {
+		const insight = getProactiveInsight(c.req.param("insightId"));
+		if (!insight) return c.json({
+			ok: false,
+			error: "Insight not found"
+		}, 404);
+		if (insight.status !== "unread") return c.json({
+			ok: false,
+			error: `Insight is ${insight.status}`
+		}, 409);
+		const focus = focuses.list({ includeUnreviewed: true }).find((item) => item.watches.some((watch) => watch.id === insight.watchId));
+		if (!focus) return c.json({
+			ok: false,
+			error: "Focus not found"
+		}, 404);
+		if (!claimProactiveInsightApproval(insight.id)) return c.json({
+			ok: false,
+			error: "Insight was already handled"
+		}, 409);
+		let automationId;
+		try {
+			const automation = await deps.service.automationServiceInstance.create({
+				name: `Investigate: ${insight.title}`.slice(0, 200),
+				description: `User-approved read-only proposal from proactive insight ${insight.id}.`,
+				...focus.projectIds[0] ? { projectId: focus.projectIds[0] } : {},
+				trigger: { kind: "manual" },
+				action: {
+					kind: "agent",
+					instruction: [
+						"The user approved this evidence-backed proposal for read-only investigation and preparation.",
+						`Focus: ${focus.title}`,
+						`Observed change: ${insight.summary}`,
+						`Why it matters: ${insight.whyItMatters}`,
+						`Approved next step: ${insight.nextAction}`,
+						`Evidence: ${JSON.stringify(insight.evidence)}`,
+						"Investigate or prepare the requested material. Return a concise result with evidence. Do not modify files or external systems."
+					].join("\n"),
+					timeoutSeconds: 300
+				},
+				safety: { mode: "suggest_only" },
+				afterRun: { kind: "none" },
+				reliability: {
+					timeoutSeconds: 300,
+					disableAfterConsecutiveFailures: 1
+				}
+			});
+			automationId = automation.id;
+			const run = await deps.service.automationServiceInstance.runNow(automation.id);
+			await focuses.recordInsightFeedback(insight.watchId, true);
+			return c.json({
+				ok: true,
+				automationId: automation.id,
+				runId: run.id
+			}, 202);
+		} catch (error) {
+			if (automationId) await deps.service.automationServiceInstance.remove(automationId);
+			setProactiveInsightStatus(insight.id, "unread", Date.now(), "approved");
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 500);
+		}
+	});
+	authenticated.post("/api/focuses/:focusId/calendar/:signalId/prepare", limited, async (c) => {
+		const focus = focuses.list().find((item) => item.id === c.req.param("focusId"));
+		if (!focus) return c.json({
+			ok: false,
+			error: "Focus not found"
+		}, 404);
+		const signal = listFocusCalendarSignals([focus]).find((item) => item.id === c.req.param("signalId"));
+		if (!signal) return c.json({
+			ok: false,
+			error: "Calendar event not found"
+		}, 404);
+		const eventContext = `${signal.title} at ${new Date(signal.startsAt).toISOString()}`;
+		try {
+			const result = await focuses.activateTrial({
+				threadId: focus.id,
+				kind: "deadline",
+				eventContext
+			});
+			return c.json({
+				ok: true,
+				...result
+			});
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 500);
+		}
+	});
 	authenticated.post("/api/work-discovery/runs/:runId/cancel", (c) => {
 		const run = service.cancelRun(c.req.param("runId"));
 		return run ? c.json({
@@ -169,6 +590,36 @@ function registerWorkDiscoveryRoutes(authenticated, deps) {
 			}, 400);
 		}
 	});
+	authenticated.post("/api/work-discovery/runs/:runId/profile", limited, async (c) => {
+		const body = await c.req.json().catch(() => null);
+		const decisions = (body && typeof body === "object" && Array.isArray(body.decisions) ? body.decisions : []).flatMap((value) => {
+			if (!value || typeof value !== "object") return [];
+			const item = value;
+			const id = typeof item.id === "string" ? item.id.trim() : "";
+			const status = item.status === "accepted" || item.status === "edited" || item.status === "rejected" ? item.status : void 0;
+			if (!id || !status) return [];
+			return [{
+				id,
+				status,
+				...typeof item.statement === "string" ? { statement: item.statement } : {}
+			}];
+		}).slice(0, 10);
+		if (!decisions.length) return c.json({
+			ok: false,
+			error: "At least one valid decision is required"
+		}, 400);
+		const run = service.updateProfileCandidates({
+			runId: c.req.param("runId"),
+			decisions
+		});
+		return run ? c.json({
+			ok: true,
+			run
+		}) : c.json({
+			ok: false,
+			error: "Profile candidates not found"
+		}, 404);
+	});
 	authenticated.post("/api/work-discovery/runs/:runId/suggestions/:suggestionId/select", (c) => {
 		return service.selectSuggestion(c.req.param("runId"), c.req.param("suggestionId")) ? c.json({ ok: true }) : c.json({
 			ok: false,

package/dist/src/gateway/hono/sse.d.ts

@@ -23,7 +23,7 @@ export declare function createAgentSSEHandler(config: SSEHandlerConfig): (c: Con
  * POST /api/agent/resume — Re-attach to an in-progress agent run via SSE.
  *
  * Request body: { runId, sessionKey }
- * The relay replays all buffered events from the beginning and then live-tails
+ * The relay replays retained buffered events from the beginning and then live-tails
  * until the run completes.
  *
  * SSE events are identical to those from POST /api/agent.

package/dist/src/gateway/hono/sse.js

@@ -168,7 +168,7 @@ function createAgentSSEHandler(config) {
 * POST /api/agent/resume — Re-attach to an in-progress agent run via SSE.
 *
 * Request body: { runId, sessionKey }
-* The relay replays all buffered events from the beginning and then live-tails
+* The relay replays retained buffered events from the beginning and then live-tails
 * until the run completes.
 *
 * SSE events are identical to those from POST /api/agent.

package/dist/src/gateway/service/run-gateway-agent.js

@@ -7,6 +7,7 @@ import { shouldSkipWebchatInboundByAbortCutoff } from "../../session/abort-cutof
 import "../chat-limits.js";
 import { resolveWebchatSessionKey } from "../resolve-webchat-session-key.js";
 import { ChatStreamMapper } from "../chat-stream/mapper.js";
+import { coalesceThinkingDeltas } from "../chat-stream/thinking-delta-coalescer.js";
 import crypto from "crypto";
 //#region src/gateway/service/run-gateway-agent.ts
 init_logger();
@@ -90,7 +91,10 @@ async function* runGatewayAgent(deps, message, channel, chatId, attachments, thi
 					signal: mergedSignal,
 					runId
 				});
-				for await (const event of eventStream) yield* emitAndYield(mapper.map(event));
+				const mappedEvents = (async function* () {
+					for await (const event of eventStream) yield* mapper.map(event);
+				})();
+				for await (const event of coalesceThinkingDeltas(mappedEvents)) yield* emitAndYield([event]);
 				const endStatus = mergedSignal.aborted ? "cancelled" : "success";
 				const endSummary = mergedSignal.aborted ? "Interrupted" : "Message processed successfully";
 				yield* emitAndYield(mapper.end(endStatus, endSummary));

package/dist/src/gateway/service.d.ts

@@ -61,6 +61,7 @@ export declare class GatewayService {
     private connectedKnowledgeCoordinator;
     private stopAutomationProductEventBridge;
     private stopSessionTranscriptAutomationEvents;
+    private stopFocusTrialExpiryReconciler;
     /**
      * Webchat agent invocation surface (`runAgent`, `abortAgentRun`, `steer*`,
      * `submitClarifyResponse`, clarify-bridge dispatch). Owns the
@@ -267,6 +268,7 @@ export declare class GatewayService {
     processDirect(content: string, sessionKey?: string): Promise<string>;
     subscribe(sessionId: string, listener: (event: ServiceEvent) => Promise<void> | void): () => void;
     emit(type: string, payload: unknown): void;
+    private handleAutomationRunCompleted;
     private startAutomationProductEventBridge;
     /** Replay events since `lastEventId` for SSE reconnection. */
     getEventsSince(sessionId: string, lastEventId: string): ServiceEvent[];