@xopcai/xopc 0.0.180 → 0.0.188

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

@@ -1,34 +1,42 @@
 import { runSqliteWriteTransaction } from "../../../storage/sqlite/transaction.js";
+import { getDreamingRun, listDreamingDecisions, listDreamingRuns } from "../../../storage/sqlite/dreaming-repository.js";
 import { getUserClaim, linkUserClaimMemoryRecord, listUserClaimEvidence, listUserClaimStatsBySource, listUserClaims, removeUserClaimEvidenceForSource, setUserClaimDecision } from "../../../storage/sqlite/user-claims-repository.js";
 import { listConnectorLearningJobs } from "../../../storage/sqlite/connector-learning-repository.js";
+import { setInteractionState } from "../../../storage/sqlite/interaction-state-repository.js";
 import { getRelationshipSettings, updateRelationshipSettings } from "../../../storage/sqlite/relationship-settings-repository.js";
-import { deleteMemoryRecord, getMemoryRecord, listMemoryRecords, upsertMemoryRecord } from "../../../storage/sqlite/memory-records-repository.js";
+import { deleteMemoryRecord, getMemoryRecord, getMemoryTurnFeedback, listMemoryRecords, listMemorySignals, setMemoryTurnFeedback, upsertMemoryRecord } from "../../../storage/sqlite/memory-records-repository.js";
 import { listKnowledgeSourceItems, listKnowledgeSyncRuns } from "../../../storage/sqlite/knowledge-repository.js";
-import { getConnectorConnection, listConnectorConnections } from "../../../storage/sqlite/connector-repository.js";
+import { listConnectorConnections } from "../../../storage/sqlite/connector-repository.js";
+import { getConnectorAccount } from "../../../storage/sqlite/connector-account-repository.js";
 import { USER_TRUST_LEVELS, isUserTrustLevel } from "../../../user-context/trust-policy.js";
 import { getUserTrustPolicy, setUserTrustPolicy } from "../../../storage/sqlite/user-trust-repository.js";
 import { decideMemoryReferenceConsent, listMemoryReferenceConsents, revokeMemoryReferenceConsent } from "../../../storage/sqlite/memory-reference-consent-repository.js";
 import { getUserProfilePromptState, setUserProfilePromptState } from "../../../storage/sqlite/user-profile-setup-repository.js";
 import "../../../storage/sqlite/index.js";
-import { UserContextConfigSchema, init_config } from "../../../user-context/config.js";
+import { DreamingSettingsSchema, UserContextConfigSchema, init_config } from "../../../user-context/config.js";
 import { init_agent_scope, resolveDefaultAgentId } from "../../../agent/agent-scope.js";
-import { GoalService } from "../../../goals/goal-service.js";
-import "../../../goals/index.js";
+import { TaskRepository } from "../../../tasks/task-repository.js";
 import { revokeComposioConnection } from "../../../connectors/composio.js";
 import { listConnectorCatalog } from "../../../connectors/catalog.js";
+import { nextDreamingRunTimes } from "../../../agent/memory/dreaming/schedule.js";
+import { resolveDreamingSettings } from "../../../agent/memory/dreaming/config.js";
 import { readUserProfileFile, writeUserProfileFile } from "../../agents-admin.js";
-import { OutcomeExecutionService } from "../../../work/outcome-execution-service.js";
-import { defineOutcomeContract } from "../../../work/outcome-contract-definition.js";
-import "../../../work/index.js";
+import { TaskApplicationService } from "../../../tasks/task-application-service.js";
+import { defineTaskContract } from "../../../tasks/task-contract-definition.js";
+import "../../../tasks/index.js";
 import { nextMemoryReviewAt, resolveMemoryStability } from "../../../agent/memory/lifecycle.js";
+import { isUserContextMemoryKind, isUserContextRecord, projectPersonalContextSources, projectUserContextRecord, recordsDerivedFromPersonalContextSource } from "../../../user-context/projection.js";
 import { PERSONAL_PLAYBOOK_DISABLED_TAG, PERSONAL_PLAYBOOK_ORDER_PREFIX, PERSONAL_PLAYBOOK_RULE_TAG, patchPersonalPlaybookContextTags, personalPlaybookContext } from "../../../user-context/personal-playbook.js";
+import { createManualUnderstanding } from "../../../user-context/manual-understanding.js";
+import { resolveDreamingAgentScope } from "../../../agent/memory/dreaming/scope.js";
+import { runDreamingPhase } from "../../../agent/memory/dreaming/runner.js";
 import { listConnectorInstances } from "../../../connectors/instances.js";
 import { uninstallConnector } from "../../../connectors/install.js";
 import { renderUserClaim } from "../../../knowledge/connected-understanding-pipeline.js";
-import { isUserContextMemoryKind, isUserContextRecord, projectPersonalContextSources, projectUserContextRecord, recordsDerivedFromPersonalContextSource } from "../../../user-context/projection.js";
 import { prepareUserContextImport } from "../../../user-context/import.js";
 import { buildUserProfileSetup, parseUserProfileMarkdown, patchUserProfileMarkdown } from "../../../user-context/profile.js";
-import { buildGoalSourceRecommendations } from "../../../user-context/source-recommendations.js";
+import { buildTaskSourceRecommendations } from "../../../user-context/source-recommendations.js";
+import { randomUUID } from "node:crypto";
 //#region src/gateway/hono/routes/you.ts
 init_agent_scope();
 init_config();
@@ -37,6 +45,15 @@ const VISIBLE_STATUSES = new Set([
 	"candidate",
 	"needs_review"
 ]);
+const FEEDBACK_RATINGS = new Set([
+	"helpful",
+	"not_helpful",
+	"mixed",
+	"irrelevant",
+	"incorrect",
+	"outdated",
+	"sensitive"
+]);
 const ACTIONABLE_INSIGHT_KINDS = new Set([
 	"routine",
 	"commitment",
@@ -253,7 +270,7 @@ function editableRecord(recordId) {
 }
 function memoryRecordInput(record) {
 	return {
-		providerId: record.source.provider ?? "local",
+		providerId: record.providerId,
 		kind: record.kind,
 		userId: record.scope.userId,
 		sourceAgentId: record.provenance.sourceAgentId,
@@ -333,15 +350,13 @@ function registerYouRoutes(authenticated, deps) {
 			learningJobs: listConnectorLearningJobs({ limit: 500 }),
 			claimStatsBySource: listUserClaimStatsBySource()
 		});
-		const activeGoals = new GoalService().list({
-			agentId,
-			status: [
-				"active",
-				"paused",
-				"blocked",
-				"needs_input"
-			],
-			limit: 20
+		const activeTasks = new TaskRepository().list({ limit: 20 }).flatMap((task) => {
+			if (task.delegateAgentId !== agentId || task.phase === "closed") return [];
+			return [{
+				id: task.id,
+				title: task.title,
+				body: task.body
+			}];
 		});
 		return c.json({
 			scope: {
@@ -370,7 +385,7 @@ function registerYouRoutes(authenticated, deps) {
 			insights: buildInsightSuggestions(records),
 			playbooks: buildPersonalPlaybooks(allUserContextRecords),
 			sources,
-			sourceRecommendations: buildGoalSourceRecommendations(sourceDefinitions.filter((definition) => definition.capabilities.includes("context") || definition.capabilities.includes("memory_source")), new Set(sourceInstances.map((instance) => instance.connectorId)), activeGoals),
+			sourceRecommendations: buildTaskSourceRecommendations(sourceDefinitions, new Set(sourceInstances.map((instance) => instance.connectorId)), activeTasks),
 			controls: {
 				mode: config.userContext.memory.mode,
 				sensitiveWritePolicy: config.userContext.privacy.sensitiveWritePolicy
@@ -383,6 +398,156 @@ function registerYouRoutes(authenticated, deps) {
 			}
 		});
 	});
+	authenticated.get("/api/you/feedback/:turnId", (c) => {
+		const trace = getMemoryTurnFeedback(c.req.param("turnId"));
+		if (!trace) return c.json({ error: "Turn context not found" }, 404);
+		const personalContext = trace.selectedRecordIds.map((id) => getMemoryRecord(id)).filter((record) => Boolean(record) && isUserContextRecord(record)).map(projectUserContextRecord);
+		return c.json({
+			trace,
+			personalContext
+		});
+	});
+	authenticated.put("/api/you/feedback/:turnId", deps.strictRateLimitMiddleware, async (c) => {
+		const body = await c.req.json().catch(() => null);
+		if (!body || typeof body !== "object" || Array.isArray(body)) return c.json({ error: "Invalid feedback" }, 400);
+		const input = body;
+		if (typeof input.rating !== "string" || !FEEDBACK_RATINGS.has(input.rating)) return c.json({ error: "Invalid rating" }, 400);
+		const records = Array.isArray(input.records) ? input.records.flatMap((value) => {
+			if (!value || typeof value !== "object" || Array.isArray(value)) return [];
+			const item = value;
+			if (typeof item.recordId !== "string" || typeof item.rating !== "string" || !FEEDBACK_RATINGS.has(item.rating)) return [];
+			return [{
+				recordId: item.recordId,
+				rating: item.rating,
+				...typeof item.reasonCode === "string" ? { reasonCode: item.reasonCode } : {},
+				...typeof item.note === "string" ? { note: item.note } : {}
+			}];
+		}) : void 0;
+		const trace = setMemoryTurnFeedback({
+			turnId: c.req.param("turnId"),
+			rating: input.rating,
+			source: "user",
+			...typeof input.score === "number" ? { score: input.score } : {},
+			...typeof input.reasonCode === "string" ? { reasonCode: input.reasonCode } : {},
+			...typeof input.note === "string" ? { note: input.note } : {},
+			...records ? { records } : {}
+		});
+		if (!trace) return c.json({ error: "Turn context not found" }, 404);
+		if (trace.sessionKey && input.rating === "not_helpful" && input.reasonCode === "tone_mismatch") setInteractionState({
+			sessionKey: trace.sessionKey,
+			signal: {
+				supportNeed: "unknown",
+				confidence: 1,
+				source: "explicit",
+				repairStatus: "needed",
+				repairReason: "tone_mismatch"
+			}
+		});
+		const personalContext = trace.selectedRecordIds.map((id) => getMemoryRecord(id)).filter((record) => Boolean(record) && isUserContextRecord(record)).map(projectUserContextRecord);
+		return c.json({
+			trace,
+			personalContext
+		});
+	});
+	authenticated.get("/api/you/dreaming", (c) => {
+		const config = deps.service.currentConfig;
+		const scope = resolveDreamingAgentScope(config);
+		const settings = resolveDreamingSettings(config);
+		const signals = listMemorySignals({
+			workspaceId: scope.workspaceDir,
+			limit: 500
+		});
+		return c.json({
+			agentId: scope.agentId,
+			settings,
+			config: {
+				...scope.config,
+				phases: {
+					light: {
+						...scope.config.phases.light,
+						nextRunsAt: nextDreamingRunTimes(scope.config.phases.light.schedule, scope.config.timezone)
+					},
+					deep: {
+						...scope.config.phases.deep,
+						nextRunsAt: nextDreamingRunTimes(scope.config.phases.deep.schedule, scope.config.timezone)
+					},
+					rem: {
+						...scope.config.phases.rem,
+						nextRunsAt: nextDreamingRunTimes(scope.config.phases.rem.schedule, scope.config.timezone)
+					}
+				}
+			},
+			readiness: scope.readiness,
+			runs: listDreamingRuns({
+				agentId: scope.agentId,
+				limit: 50
+			}),
+			signalCount: signals.filter((signal) => signal.source === "dreaming").length
+		});
+	});
+	authenticated.put("/api/you/dreaming", deps.strictRateLimitMiddleware, async (c) => {
+		const config = deps.service.currentConfig;
+		const body = await c.req.json().catch(() => ({}));
+		const settings = DreamingSettingsSchema.safeParse(body);
+		if (!settings.success) return c.json({ error: settings.error.issues[0]?.message ?? "Invalid Dreaming settings" }, 400);
+		const currentPhases = config.userContext.dreaming.phases ?? {};
+		const parsed = UserContextConfigSchema.safeParse({
+			...config.userContext,
+			dreaming: {
+				...config.userContext.dreaming,
+				mode: settings.data.mode,
+				timezone: settings.data.timezone,
+				phases: {
+					light: {
+						...currentPhases.light,
+						...settings.data.phases.light
+					},
+					deep: {
+						...currentPhases.deep,
+						...settings.data.phases.deep
+					},
+					rem: {
+						...currentPhases.rem,
+						...settings.data.phases.rem
+					}
+				}
+			}
+		});
+		if (!parsed.success) return c.json({ error: parsed.error.issues[0]?.message ?? "Invalid Dreaming settings" }, 400);
+		const saved = await deps.service.saveConfig({
+			...config,
+			userContext: parsed.data
+		});
+		if (!saved.saved) return c.json({ error: saved.error ?? "save failed" }, 500);
+		const savedConfig = deps.service.currentConfig;
+		return c.json({ settings: resolveDreamingSettings(savedConfig) });
+	});
+	authenticated.get("/api/you/readiness", (c) => {
+		return c.json(resolveDreamingAgentScope(deps.service.currentConfig).readiness);
+	});
+	authenticated.post("/api/you/dreaming/runs", deps.strictRateLimitMiddleware, async (c) => {
+		const body = await c.req.json().catch(() => ({}));
+		const phase = body.phase === "light" || body.phase === "deep" || body.phase === "rem" ? body.phase : "deep";
+		try {
+			const result = await runDreamingPhase({
+				config: deps.service.currentConfig,
+				phase,
+				triggerKind: "manual"
+			});
+			return c.json(result);
+		} catch (error) {
+			return c.json({ error: error instanceof Error ? error.message : String(error) }, 400);
+		}
+	});
+	authenticated.get("/api/you/dreaming/runs/:runId", (c) => {
+		const scope = resolveDreamingAgentScope(deps.service.currentConfig);
+		const run = getDreamingRun(c.req.param("runId"));
+		if (!run || run.agentId !== scope.agentId || run.workspaceId !== scope.workspaceDir) return c.json({ error: "Dreaming run not found" }, 404);
+		return c.json({
+			run,
+			decisions: listDreamingDecisions(run.runId)
+		});
+	});
 	authenticated.patch("/api/you/relationship", deps.strictRateLimitMiddleware, async (c) => {
 		const body = await c.req.json().catch(() => null);
 		if (!body || typeof body !== "object" || Array.isArray(body)) return c.json({ error: "Invalid relationship settings" }, 400);
@@ -434,7 +599,7 @@ function registerYouRoutes(authenticated, deps) {
 				const candidate = renderUserClaim(updated);
 				const evidence = listUserClaimEvidence(updated.id);
 				const record = upsertMemoryRecord({
-					providerId: "connected-understanding",
+					providerId: "local",
 					kind: candidate.kind,
 					sourceAgentId: updated.agentId,
 					content: candidate.content,
@@ -539,38 +704,29 @@ function registerYouRoutes(authenticated, deps) {
 		const kind = isUserContextMemoryKind(body.kind) ? body.kind : void 0;
 		if (!content || content.length > 5e3) return c.json({ error: "Understanding content must be 1-5000 characters" }, 400);
 		if (!kind) return c.json({ error: "A valid user understanding kind is required" }, 400);
-		const duplicate = listAllUserContextRecords(ALL_MEMORY_STATUSES).filter(isUserContextRecord).find((record) => record.content.trim().toLocaleLowerCase() === content.toLocaleLowerCase());
-		if (duplicate) return c.json({
-			error: "This understanding already exists",
-			understanding: projectUserContextRecord(duplicate)
-		}, 409);
+		const scope = body.scope === "session" ? {
+			type: "session",
+			sessionKey: typeof body.sessionKey === "string" ? body.sessionKey.trim() : ""
+		} : body.scope === void 0 || body.scope === "global" ? { type: "global" } : null;
+		if (!scope || scope.type === "session" && !scope.sessionKey) return c.json({ error: "scope must be global or a session with sessionKey" }, 400);
 		const sensitivity = MEMORY_SENSITIVITIES.has(body.sensitivity) ? body.sensitivity : "normal";
 		const durability = MEMORY_DURABILITIES.has(body.durability) ? body.durability : "durable";
 		const disclosurePolicy = MEMORY_DISCLOSURE_POLICIES.has(body.disclosurePolicy) ? body.disclosurePolicy : "referenceable";
 		const config = deps.service.currentConfig;
-		const created = upsertMemoryRecord({
-			providerId: "local",
-			kind,
-			sourceAgentId: selectedAgentId(config),
+		const result = createManualUnderstanding({
+			agentId: selectedAgentId(config),
 			content,
-			source: {
-				provider: "local",
-				path: "you://manual"
-			},
-			confidence: 1,
-			tags: ["user-understanding", "explicit-user-memory"],
-			status: "active",
+			kind,
+			scope,
 			sensitivity,
-			explicitness: "explicit",
 			durability,
-			importance: .8,
-			disclosurePolicy,
-			reviewAfter: nextMemoryReviewAt({
-				durability,
-				explicitness: "explicit"
-			})
+			disclosurePolicy
 		});
-		return c.json({ understanding: projectUserContextRecord(created) }, 201);
+		if (!result.created) return c.json({
+			error: "This understanding already exists in the selected scope",
+			understanding: projectUserContextRecord(result.record)
+		}, 409);
+		return c.json({ understanding: projectUserContextRecord(result.record) }, 201);
 	});
 	authenticated.get("/api/you/understanding/:id/history", (c) => {
 		const all = listAllUserContextRecords(ALL_MEMORY_STATUSES).filter(isUserContextRecord);
@@ -852,37 +1008,48 @@ function registerYouRoutes(authenticated, deps) {
 		}
 		const title = existing.content.trim().split(/\r?\n/)[0].slice(0, 72);
 		const uiLocale = body.uiLocale === "zh" ? "zh" : "en";
-		const contract = defineOutcomeContract(title);
-		const goals = new GoalService();
-		const goal = new OutcomeExecutionService().create({
-			objective: contract.objective,
-			description: existing.content,
-			deliverables: contract.deliverables,
-			acceptanceCriteria: contract.acceptanceCriteria,
-			constraints: contract.constraints,
-			agentId: selectedAgentId(config),
+		const contract = defineTaskContract(title);
+		const created = new TaskApplicationService().create({
+			idempotencyKey: randomUUID(),
+			title,
+			body: existing.content,
 			priority: "normal",
-			uiLocale,
-			source: "api"
-		}).goal;
-		goals.setContextMessage({
-			goalId: goal.id,
-			text: existing.content
+			delegateAgentId: selectedAgentId(config),
+			locale: uiLocale,
+			contract: {
+				...contract,
+				acceptancePolicy: "verified_auto",
+				outputDestinations: []
+			},
+			dependencies: [],
+			context: [{
+				targetKind: "memory",
+				targetId: existing.id,
+				role: "input",
+				pinned: true,
+				retrievalPolicy: {},
+				metadata: {}
+			}],
+			authorityGrants: [],
+			activation: {
+				mode: "start",
+				executor: {
+					kind: "agent",
+					agentId: selectedAgentId(config)
+				}
+			}
 		});
-		let queued = false;
-		try {
-			deps.service.enqueueGoalRun(goal.id, { source: "api" });
-			queued = true;
-		} catch {
-			queued = false;
-		} finally {
-			preserveRecord(existing, { tags: [...new Set([...existing.tags ?? [], INSIGHT_ACCEPTED_TAG])] });
-		}
+		if (created.ok === false) return c.json({
+			ok: false,
+			error: created.reason
+		}, 409);
+		if (created.runId) deps.service.dispatchTaskRuns();
+		preserveRecord(existing, { tags: [...new Set([...existing.tags ?? [], INSIGHT_ACCEPTED_TAG])] });
 		return c.json({
 			ok: true,
-			status: queued ? "queued" : "saved",
-			goal: goals.get(goal.id),
-			href: `/work/${encodeURIComponent(goal.outcomeId)}`
+			status: created.runId ? "queued" : "saved",
+			taskId: created.model.task.id,
+			href: `/tasks/${encodeURIComponent(created.model.task.id)}`
 		});
 	});
 	authenticated.patch("/api/you/controls", deps.strictRateLimitMiddleware, async (c) => {
@@ -939,15 +1106,20 @@ function registerYouRoutes(authenticated, deps) {
 		const config = deps.service.currentConfig;
 		const instanceId = c.req.param("instanceId");
 		const installedInstances = listConnectorInstances(config);
-		const connection = getConnectorConnection(instanceId);
+		const account = getConnectorAccount(instanceId);
+		const accountConnections = account ? listConnectorConnections({
+			principalId: account.principalId,
+			connectorId: account.connectorId
+		}).filter((connection) => connection.accountId === account.id) : [];
 		const instance = installedInstances.find((item) => item.instanceId === instanceId);
-		const connectorId = connection?.connectorId ?? instance?.connectorId;
+		const connectorId = account?.connectorId ?? instance?.connectorId;
 		const definition = connectorId ? listConnectorCatalog().find((item) => item.id === connectorId) : void 0;
-		if (!instance && !connection || !definition || !definition.capabilities.some((capability) => capability === "context" || capability === "memory_source")) return c.json({ error: "Personal context source not found" }, 404);
+		if (!instance && !account || !definition || !definition.capabilities.some((capability) => capability === "context" || capability === "memory_source")) return c.json({ error: "Personal context source not found" }, 404);
 		const body = await c.req.json().catch(() => ({}));
-		if (typeof body.deleteDerivedUnderstanding !== "boolean") return c.json({ error: "deleteDerivedUnderstanding must be a boolean" }, 400);
+		const understandingPolicy = body.understandingPolicy === "keep" || body.understandingPolicy === "delete" ? body.understandingPolicy : void 0;
+		if (!understandingPolicy) return c.json({ error: "understandingPolicy must be keep or delete" }, 400);
 		try {
-			if (connection) await revokeComposioConnection(connection.id);
+			if (account) for (const connection of accountConnections.filter((candidate) => candidate.status !== "revoked")) await revokeComposioConnection(connection.id);
 			else if (instance) {
 				uninstallConnector(config, instance.instanceId);
 				const saved = await deps.service.saveConfig(config);
@@ -958,8 +1130,8 @@ function registerYouRoutes(authenticated, deps) {
 		}
 		let deletedUnderstandingCount = 0;
 		let deletedClaimCount = 0;
-		if (body.deleteDerivedUnderstanding) {
-			const sourceInstanceId = connection ? `composio:${connection.connectorId}:${connection.id}` : instanceId;
+		if (understandingPolicy === "delete") {
+			const sourceInstanceId = account ? `composio:${account.connectorId}:${account.id}` : instanceId;
 			const targets = recordsDerivedFromPersonalContextSource(listAllUserContextRecords(ALL_MEMORY_STATUSES), sourceInstanceId);
 			runSqliteWriteTransaction(() => {
 				const claimRemoval = removeUserClaimEvidenceForSource(sourceInstanceId);

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

@@ -6,21 +6,6 @@ export interface SSEHandlerConfig {
     service: GatewayService;
     maxSseConnections?: number;
 }
-/**
- * POST /api/agent — Send a message to the agent, stream response via SSE.
- *
- * Request body: { message, channel?, sessionKey, attachments? }
- * Accept: text/event-stream → SSE stream
- * Accept: application/json → wait for full response, return JSON
- *
- * SSE events follow XOPC Chat Stream Protocol v1:
- *   run_start, user_message, user_transcript, assistant_message_start,
- *   assistant_delta, thinking_delta, thinking_end, tool_start, tool_update,
- *   tool_end, review_start, review_delta, review_end, assistant_message_end,
- *   compaction, tts_audio, clarify_request,
- *   run_end, error.
- */
-export declare function createAgentSSEHandler(config: SSEHandlerConfig): (c: Context) => Promise<Response>;
 /**
  * POST /api/agent/resume — Re-attach to an in-progress agent run via SSE.
  *
@@ -28,7 +13,7 @@ export declare function createAgentSSEHandler(config: SSEHandlerConfig): (c: Con
  * 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.
+ * SSE events are the active run's retained and live stream events.
  */
 export declare function createAgentResumeHandler(config: SSEHandlerConfig): (c: Context) => Promise<Response>;
 /**

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

@@ -1,8 +1,6 @@
 import { updateAsyncLogContext } from "../../utils/logger/context.js";
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
-import { MAX_WEBCHAT_ATTACHMENT_FILE_BYTES } from "../chat-limits.js";
-import { resolveWebchatSessionKey } from "../resolve-webchat-session-key.js";
 import { stringifySSEData } from "./sse-json.js";
 import { streamSSE } from "hono/streaming";
 //#region src/gateway/hono/sse.ts
@@ -13,161 +11,6 @@ const activeConnections = /* @__PURE__ */ new Map();
 function closeAllEventStreams() {
 	for (const controller of activeConnections.values()) controller.abort();
 }
-function isValidAgentRequest(body) {
-	if (!body || typeof body !== "object") return false;
-	const b = body;
-	const hasMessage = typeof b.message === "string";
-	const hasAttachments = Array.isArray(b.attachments) && b.attachments.length > 0;
-	return hasMessage || hasAttachments;
-}
-/** Max base64 character length that can decode to `MAX_WEBCHAT_ATTACHMENT_FILE_BYTES`. */
-function maxBase64CharsForBinary(maxBinaryBytes) {
-	return 4 * Math.ceil(maxBinaryBytes / 3);
-}
-/**
-* POST /api/agent — Send a message to the agent, stream response via SSE.
-*
-* Request body: { message, channel?, sessionKey, attachments? }
-* Accept: text/event-stream → SSE stream
-* Accept: application/json → wait for full response, return JSON
-*
-* SSE events follow XOPC Chat Stream Protocol v1:
-*   run_start, user_message, user_transcript, assistant_message_start,
-*   assistant_delta, thinking_delta, thinking_end, tool_start, tool_update,
-*   tool_end, review_start, review_delta, review_end, assistant_message_end,
-*   compaction, tts_audio, clarify_request,
-*   run_end, error.
-*/
-function createAgentSSEHandler(config) {
-	const { service } = config;
-	return async (c) => {
-		const body = await c.req.json().catch(() => null);
-		if (!isValidAgentRequest(body)) return c.json({
-			ok: false,
-			error: {
-				code: "BAD_REQUEST",
-				message: "Missing required field: message or attachments"
-			}
-		}, 400);
-		const { message, channel = "webchat", attachments, thinking } = body;
-		const clientCreatedAtMs = typeof body.clientCreatedAtMs === "number" && Number.isFinite(body.clientCreatedAtMs) ? body.clientCreatedAtMs : void 0;
-		const resolved = resolveWebchatSessionKey({ sessionKey: typeof body.sessionKey === "string" ? body.sessionKey : void 0 });
-		if (resolved.ok === false) return c.json({
-			ok: false,
-			error: {
-				code: "BAD_REQUEST",
-				message: resolved.error
-			}
-		}, 400);
-		const chatId = resolved.sessionKey;
-		updateAsyncLogContext({ sessionKey: String(chatId) });
-		if (Array.isArray(attachments)) {
-			const maxDataChars = maxBase64CharsForBinary(MAX_WEBCHAT_ATTACHMENT_FILE_BYTES);
-			for (const a of attachments) {
-				if (!a || typeof a !== "object") continue;
-				const data = a.data;
-				if (typeof data === "string" && data.length > maxDataChars) return c.json({
-					ok: false,
-					error: {
-						code: "BAD_REQUEST",
-						message: `Attachment exceeds maximum size (${MAX_WEBCHAT_ATTACHMENT_FILE_BYTES} bytes)`
-					}
-				}, 400);
-			}
-		}
-		const wantSSE = (c.req.header("Accept") || "").includes("text/event-stream");
-		const clientAbort = new AbortController();
-		const raw = c.req.raw;
-		if (channel !== "webchat") if (raw.signal.aborted) clientAbort.abort();
-		else raw.signal.addEventListener("abort", () => clientAbort.abort(), { once: true });
-		if (!wantSSE) {
-			const jsonSessionKey = channel === "webchat" ? chatId : void 0;
-			const generator = service.runAgent(message, channel, chatId, attachments, thinking, {
-				signal: clientAbort.signal,
-				...clientCreatedAtMs !== void 0 ? { clientCreatedAtMs } : {}
-			});
-			try {
-				let finalResult;
-				const tokens = [];
-				while (true) {
-					const { done, value } = await generator.next();
-					if (done) {
-						finalResult = value;
-						break;
-					}
-					const chunk = value;
-					if (chunk.type === "assistant_delta" && typeof chunk.payload?.delta === "string") tokens.push(chunk.payload.delta);
-				}
-				return c.json({
-					ok: true,
-					payload: {
-						...finalResult,
-						content: tokens.join(""),
-						...jsonSessionKey !== void 0 ? {
-							sessionKey: jsonSessionKey,
-							key: jsonSessionKey
-						} : {}
-					}
-				});
-			} catch (error) {
-				const em = error instanceof Error ? error.message : String(error);
-				log.error({
-					err: error,
-					errorMessage: em,
-					phase: "gateway.agent_run",
-					sessionKey: jsonSessionKey,
-					channel
-				}, `Agent run failed (JSON mode): ${em}`);
-				return c.json({
-					ok: false,
-					error: {
-						code: "INTERNAL_ERROR",
-						message: error instanceof Error ? error.message : "Unknown error"
-					}
-				}, 500);
-			}
-		}
-		c.header("X-Accel-Buffering", "no");
-		return streamSSE(c, async (stream) => {
-			if (channel !== "webchat") stream.onAbort(() => {
-				clientAbort.abort();
-			});
-			const generator = service.runAgent(message, channel, chatId, attachments, thinking, {
-				signal: clientAbort.signal,
-				...clientCreatedAtMs !== void 0 ? { clientCreatedAtMs } : {}
-			});
-			let eventId = 0;
-			try {
-				while (true) {
-					const { done, value } = await generator.next();
-					if (done) break;
-					const chunk = value;
-					await stream.writeSSE({
-						id: typeof chunk.seq === "number" ? String(chunk.seq) : String(++eventId),
-						event: chunk.type || "message",
-						data: stringifySSEData(chunk)
-					});
-				}
-			} catch (error) {
-				log.error({ err: error }, "Agent run failed (SSE mode)");
-				await stream.writeSSE({
-					id: String(++eventId),
-					event: "error",
-					data: stringifySSEData({
-						type: "error",
-						runId: "unknown",
-						sessionKey: chatId,
-						timestamp: Date.now(),
-						payload: {
-							code: "INTERNAL_ERROR",
-							message: error instanceof Error ? error.message : "Unknown error"
-						}
-					})
-				});
-			}
-		});
-	};
-}
 /**
 * POST /api/agent/resume — Re-attach to an in-progress agent run via SSE.
 *
@@ -175,7 +18,7 @@ function createAgentSSEHandler(config) {
 * 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.
+* SSE events are the active run's retained and live stream events.
 */
 function createAgentResumeHandler(config) {
 	const { service } = config;
@@ -197,7 +40,7 @@ function createAgentResumeHandler(config) {
 				message: "Missing required field: runId"
 			}
 		}, 400);
-		if (!service.runRelay.hasRun(runId)) return c.json({
+		if (!service.agentRunner.runRelay.hasRun(runId)) return c.json({
 			ok: false,
 			error: {
 				code: "NOT_FOUND",
@@ -208,7 +51,7 @@ function createAgentResumeHandler(config) {
 		return streamSSE(c, async (stream) => {
 			let eventId = 0;
 			try {
-				for await (const event of service.runRelay.subscribe(runId)) await stream.writeSSE({
+				for await (const event of service.agentRunner.runRelay.subscribe(runId)) await stream.writeSSE({
 					id: typeof event.seq === "number" ? String(event.seq) : String(++eventId),
 					event: event.type || "message",
 					data: stringifySSEData(event)
@@ -361,4 +204,4 @@ function createEventsSSEHandler(config) {
 	};
 }
 //#endregion
-export { closeAllEventStreams, createAgentResumeHandler, createAgentSSEHandler, createEventsSSEHandler, createSendHandler };
+export { closeAllEventStreams, createAgentResumeHandler, createEventsSSEHandler, createSendHandler };