@xopcai/xopc 0.0.81 → 0.0.83

package/dist/src/agent/service.js

@@ -1,23 +1,17 @@
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
 import { init_agent_scope, resolveAgentHomeDir, resolveAgentProfileDir, resolveDefaultAgentId } from "./agent-scope.js";
 import { getAgentDefaultModelRef, init_schema } from "../config/schema.js";
 import { applyConfigOverrides } from "../config/runtime-overrides.js";
-import { init_session_key, parseSessionKey } from "../routing/session-key.js";
 import { extractProfileAgentId, resolveEffectiveAgentProfileForSession } from "../config/agent-profile.js";
-import { runWithLogContext, updateAsyncLogContext } from "../utils/logger/context.js";
-import { createLogger } from "../utils/logger/index.js";
-import { init_logger } from "../utils/logger.js";
 import { extractTextContent } from "./context/workspace.js";
 import { onSessionTranscriptUpdate } from "../session/transcript-events.js";
 import { AgentManager } from "./agent-manager.js";
-import { MessageBusShutdownError } from "../infra/bus/queue.js";
-import "../infra/bus/index.js";
 import { persistInboundAttachmentsToWorkspace } from "../channels/attachments/inbound-persist.js";
 import { maybeAutoTitleSessionStore } from "../session/session-title.js";
 import { SessionStore } from "../session/store.js";
 import { SessionConfigStore } from "../session/config-store.js";
-import { normalizeReasoningLevel, normalizeThinkLevel } from "./transcript/thinking-types.js";
-import { resolveEffectiveReasoningLevel, resolveEffectiveThinkingLevel } from "../session/thinking-resolve.js";
-import { effectiveWorkspacePathForSession, normalizeWorkingDirectoryInput } from "../session/session-workspace.js";
+import { effectiveWorkspacePathForSession } from "../session/session-workspace.js";
 import "../session/index.js";
 import { ExtensionHookRunner } from "../extensions/hooks.js";
 import "../extensions/index.js";
@@ -42,43 +36,43 @@ import { CompactionLifecycleHandler } from "./lifecycle/handlers/compaction.js";
 import { MessageRouter } from "./messaging/message-router.js";
 import { CommandHandler } from "./messaging/command-handler.js";
 import { StreamManager } from "./messaging/stream-manager.js";
+import { OutboundCoordinator } from "./messaging/outbound-coordinator.js";
 import "./messaging/index.js";
+import { InboundLoop } from "./inbound/inbound-loop.js";
+import { TurnDispatcher } from "./inbound/turn-dispatcher.js";
 import { SessionContextManager } from "./session/session-context.js";
 import { SessionLifecycleManager } from "./session/session-lifecycle.js";
+import { SessionStateBag } from "./session/session-state-bag.js";
+import { SessionConfigService } from "./session/session-config-service.js";
+import { SessionHydrator } from "./session/session-hydrator.js";
+import { SessionInspector } from "./session/session-inspector.js";
 import "./session/index.js";
-import { inboundMessageLogRequestId } from "./service-inbound-utils.js";
 import { AgentOrchestrator } from "./orchestration/agent-orchestrator.js";
 import { AgentEventHandler } from "./orchestration/agent-event-handler.js";
 import "./orchestration/index.js";
 import { FeedbackCoordinator } from "./feedback/feedback-coordinator.js";
 import "./feedback/index.js";
-import { runProcessDirectStreaming } from "./service/process-direct-streaming.js";
-import { handlePersistentGoalPostTurn } from "./goals/post-turn.js";
+import { PersistentGoalService } from "./goals/persistent-goal-service.js";
 import { reconcileManagedDreamingCronJobs } from "./service/reconcile-dreaming-cron.js";
 import { parseOutboundSessionKey } from "./service/parse-outbound-session-key.js";
-import { runBtwQuery } from "./service/btw-query.js";
-import { formatSessionContextReport } from "./service/session-context-report.js";
-import { buildDirectUserMessageContent } from "./service/build-direct-message-content.js";
-import { maybeEmitWebchatTts } from "./service/webchat-tts.js";
-import { runProcessDirect } from "./service/process-direct-one-shot.js";
-import { shouldSilence } from "../heartbeat/tokens.js";
-import { createTypingController } from "./lifecycle/typing.js";
 import { cleanTrailingErrors } from "./memory/message-sanitizer.js";
 import { tryApplySessionTranscriptHygiene } from "./transcript/transcript-hygiene.js";
-import { join } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
-import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
 //#region src/agent/service.ts
 init_schema();
 init_logger();
-init_session_key();
 init_agent_scope();
 const log = createLogger("AgentService");
 var AgentService = class {
+	/**
+	* Persistent transcript + session-metadata store. Public so the gateway/TUI
+	* can read sessions, delete them, etc. without forcing every CRUD-style
+	* operation through a delegation method on `AgentService`.
+	*/
 	sessionStore;
 	sessionConfigStore;
 	hookRunner;
-	running = false;
 	agentId;
 	workspaceDir;
 	channelManagerRef = null;
@@ -100,25 +94,59 @@ var AgentService = class {
 	messageRouter;
 	commandHandler;
 	streamManager;
+	/**
+	* Outbound pipeline: typing controller, silence guard, final response publish,
+	* extension `message_sending`/`message_sent` hooks, post-turn `webchat_turn_complete`
+	* event. Public so the gateway / channels can drive it directly.
+	*/
+	outboundCoordinator;
+	inboundLoop;
+	/**
+	* Direct-turn entry points: `processDirect` (one-shot), `processDirectStreaming`
+	* (SSE generator), webchat steering and SSE injection. Public so the gateway,
+	* TUI, CLI, and cron jobs do not need to thread every call through `AgentService`.
+	*/
+	turnDispatcher;
+	/**
+	* `/goal` runtime: continuation scheduling, persistent-goal API factory,
+	* stream-outcome state, post-turn verdict. Public so the gateway can wire
+	* the webchat continuation scheduler and read stream outcomes directly.
+	*/
+	persistentGoals;
+	/**
+	* Per-session config writes (model / thinking / reasoning / working directory).
+	* Public so REST endpoints and CLI flows can hit it without going through a
+	* monolithic patch entrypoint on `AgentService`.
+	*/
+	sessionConfig;
+	/**
+	* Hydration — read persisted per-session config and apply it to the runtime
+	* (AgentManager / ModelManager). The mirror image of `sessionConfig`: writes
+	* go through `sessionConfig`, reads-into-runtime go through `sessionHydrator`.
+	*/
+	sessionHydrator;
+	/**
+	* Read-only introspection (compaction, /context report, /btw, contextUsage,
+	* agentConfig view). Public so REST endpoints and CLI flows can query a
+	* session's view without going through delegating methods on `AgentService`.
+	*/
+	sessionInspector;
 	sessionContextManager;
 	sessionLifecycleManager;
 	agentOrchestrator;
 	agentEventHandler;
 	feedbackCoordinator;
 	agentManager;
-	/** Webchat SSE queue pushers for `clarify_request` and similar mid-turn UI events. */
-	webchatSseEnqueueBySession = /* @__PURE__ */ new Map();
-	embeddedStreamTextBySession = /* @__PURE__ */ new Map();
-	lastAssistantPlainTextBySession = /* @__PURE__ */ new Map();
-	/** Gateway: drain `processDirectStreaming` for webchat continuations (Hermes FIFO-style). */
-	persistentGoalWebchatContinuationScheduler;
-	directStreamOutcomeBySession = /* @__PURE__ */ new Map();
-	/** Concurrent inbound / direct-stream turns per session (Hermes-style /goal mid-flight guard). */
-	inboundTurnDepthBySession = /* @__PURE__ */ new Map();
+	/**
+	* Unified per-session state container (replaces six ad-hoc Maps). Owns webchat
+	* publishers, last assistant text, embedded stream buffer, persistent-goal stream
+	* outcomes, concurrent-turn depth, and event-listener unsubscribers; runs a TTL
+	* sweep for slots that have no explicit owner.
+	*/
+	sessionState = new SessionStateBag();
 	/** Gateway: notify UI after direct `SessionStore.updateMetadata` (no SessionManager emit). */
 	onSessionMetadataUpdated;
 	onSessionTranscriptUpdated;
-	sessionUnsubscribers = /* @__PURE__ */ new Map();
 	effectiveAppConfig() {
 		const base = this.config.config;
 		return base ? applyConfigOverrides(base) : void 0;
@@ -196,8 +224,13 @@ var AgentService = class {
 			selfVerifyMiddleware: this.selfVerifyMiddleware,
 			systemReminder: this.systemReminder,
 			toolUsageAnalyzer: this.toolUsageAnalyzer,
-			errorPatternMatcher: this.errorPatternMatcher,
-			modelManager: this.modelManager
+			errorPatternMatcher: this.errorPatternMatcher
+		});
+		this.sessionHydrator = new SessionHydrator({
+			sessionConfigStore: this.sessionConfigStore,
+			agentManager: this.agentManager,
+			modelManager: this.modelManager,
+			getConfig: () => this.effectiveAppConfig()
 		});
 		this.agentOrchestrator = new AgentOrchestrator({
 			agentManager: this.agentManager,
@@ -206,7 +239,7 @@ var AgentService = class {
 			eventHandler: this.agentEventHandler,
 			feedbackCoordinator: this.feedbackCoordinator,
 			sessionConfigStore: this.sessionConfigStore,
-			hydrateSessionWorkspaceFromStore: (sessionKey) => this.hydrateSessionWorkspaceFromStore(sessionKey),
+			sessionHydrator: this.sessionHydrator,
 			getConfig: () => this.effectiveAppConfig(),
 			getThinkingDefault: () => this.effectiveAppConfig()?.agents?.defaults?.thinkingDefault,
 			getThinkingDefaultForSession: (sessionKey) => this.agentManager.getThinkingDefaultForSession(sessionKey),
@@ -218,14 +251,13 @@ var AgentService = class {
 				const ctx = this.sessionContextManager.getContext();
 				if (!ctx || ctx.sessionKey !== sessionKey) return;
 				if (event.type === "token") {
-					const next = (this.embeddedStreamTextBySession.get(sessionKey) ?? "") + event.content;
-					this.embeddedStreamTextBySession.set(sessionKey, next);
+					const next = this.sessionState.appendEmbeddedStreamText(sessionKey, event.content);
 					this.streamManager.update(next);
 				}
 			},
 			onEmbeddedTurnComplete: (sessionKey, text) => {
-				if (text?.trim()) this.lastAssistantPlainTextBySession.set(sessionKey, text.trim());
-				this.embeddedStreamTextBySession.delete(sessionKey);
+				if (text) this.sessionState.setLastAssistantText(sessionKey, text);
+				this.sessionState.clearEmbeddedStreamText(sessionKey);
 			}
 		});
 		this.messageRouter = new MessageRouter();
@@ -234,7 +266,7 @@ var AgentService = class {
 			bus,
 			sessionStore: this.sessionStore,
 			sessionConfigStore: this.sessionConfigStore,
-			getPersistentGoalApisForCommand: (routing) => this.getPersistentGoalApisForCommand(routing),
+			getPersistentGoalApisForCommand: (routing) => this.persistentGoals.buildApisForRouting(routing),
 			applySessionThinkingLevel: (sessionKey, level) => {
 				this.agentManager.setThinkingLevel(sessionKey, level);
 			},
@@ -247,11 +279,93 @@ var AgentService = class {
 				await this.streamManager.abort();
 				this.agentOrchestrator.abort(sessionKey);
 			},
-			compactSession: (sessionKey, options) => this.compactSession(sessionKey, options),
-			btwQuery: (sessionKey, question) => this.btwQuery(sessionKey, question),
-			getSessionContextReport: (sessionKey, mode) => this.getSessionContextReport(sessionKey, mode)
+			compactSession: (sessionKey, options) => this.sessionInspector.compact(sessionKey, options),
+			btwQuery: (sessionKey, question) => this.sessionInspector.btwQuery(sessionKey, question),
+			getSessionContextReport: (sessionKey, mode) => this.sessionInspector.report(sessionKey, mode)
 		});
 		this.sessionLifecycleManager = new SessionLifecycleManager(this.sessionStore, this.sessionTracker, this.lifecycleManager);
+		this.persistentGoals = new PersistentGoalService({
+			bus,
+			sessionStore: this.sessionStore,
+			modelManager: this.modelManager,
+			sessionState: this.sessionState,
+			getConfig: () => this.effectiveAppConfig(),
+			getResolvedWorkspaceForSession: (sk) => this.agentManager.getResolvedWorkspaceForSession(sk),
+			onSessionMetadataUpdated: this.onSessionMetadataUpdated,
+			notifyWebchatTranscriptAppend: (sk, text) => this.turnDispatcher.notifyWebchatTranscriptAppend(sk, text)
+		});
+		this.sessionConfig = new SessionConfigService({
+			sessionStore: this.sessionStore,
+			sessionConfigStore: this.sessionConfigStore,
+			modelManager: this.modelManager,
+			agentManager: this.agentManager,
+			getConfig: () => this.effectiveAppConfig()
+		});
+		this.sessionInspector = new SessionInspector({
+			sessionStore: this.sessionStore,
+			sessionConfigStore: this.sessionConfigStore,
+			modelManager: this.modelManager,
+			agentManager: this.agentManager,
+			sessionHydrator: this.sessionHydrator,
+			getConfig: () => this.effectiveAppConfig(),
+			getContextWindow: () => this.getContextWindow()
+		});
+		this.outboundCoordinator = new OutboundCoordinator({
+			bus,
+			hookHandler: this.hookHandler,
+			streamManager: this.streamManager,
+			getConfig: () => this.effectiveAppConfig(),
+			getLastAssistantPlainText: (sk) => this.getLastAssistantPlainText(sk),
+			runPersistentGoalPostTurn: (payload) => this.persistentGoals.runPostTurn(payload)
+		});
+		this.turnDispatcher = new TurnDispatcher({
+			log,
+			agentManager: this.agentManager,
+			sessionStore: this.sessionStore,
+			modelManager: this.modelManager,
+			sessionConfigStore: this.sessionConfigStore,
+			sessionState: this.sessionState,
+			commandHandler: this.commandHandler,
+			getConfig: () => this.effectiveAppConfig(),
+			requireConfig: () => {
+				const c = this.config.config;
+				if (!c) throw new Error("AgentService requires config.config");
+				return c;
+			},
+			parseSessionKey: (sk) => this.parseSessionKey(sk),
+			initSessionContext: (sk, channel, chatId) => this.initSessionContext(sk, channel, chatId),
+			sessionHydrator: this.sessionHydrator,
+			attachmentRootsForSession: (sk) => this.attachmentRootsForSession(sk),
+			prepareInboundAttachments: (sk, att) => this.prepareInboundAttachments(sk, att),
+			enqueueMaybeAutoTitleAfterPersist: (sk) => this.enqueueMaybeAutoTitleAfterPersist(sk),
+			endDirectRequestContext: () => this.endDirectRequestContext(),
+			onSessionTranscriptUpdated: this.onSessionTranscriptUpdated
+		});
+		this.inboundLoop = new InboundLoop({
+			log,
+			agentId: this.agentId,
+			bus,
+			hookHandler: this.hookHandler,
+			messageRouter: this.messageRouter,
+			commandHandler: this.commandHandler,
+			sessionContextManager: this.sessionContextManager,
+			feedbackCoordinator: this.feedbackCoordinator,
+			agentManager: this.agentManager,
+			sessionLifecycleManager: this.sessionLifecycleManager,
+			agentOrchestrator: this.agentOrchestrator,
+			outboundCoordinator: this.outboundCoordinator,
+			streamManager: this.streamManager,
+			sessionState: this.sessionState,
+			sessionStore: this.sessionStore,
+			modelManager: this.modelManager,
+			setupSessionEventHandling: (sk) => this.setupSessionEventHandling(sk),
+			sessionHydrator: this.sessionHydrator,
+			getLastAssistantPlainText: (sk) => this.getLastAssistantPlainText(sk),
+			checkAndCompact: (sk, msgs) => this.checkAndCompact(sk, msgs),
+			enqueueMaybeAutoTitleAfterPersist: (sk) => this.enqueueMaybeAutoTitleAfterPersist(sk),
+			getConfig: () => this.effectiveAppConfig(),
+			setStreamHandle: (handle) => this.setStreamHandle(handle)
+		});
 		if (!!!process.env.ELECTRON_RUN_AS_NODE) {
 			process.on("SIGINT", () => this.dispose());
 			process.on("SIGTERM", () => this.dispose());
@@ -364,6 +478,7 @@ var AgentService = class {
 	setChannelManager(channelManager) {
 		this.modelManager.setChannelManager(channelManager);
 		this.channelManagerRef = channelManager;
+		this.inboundLoop.setChannelManager(channelManager);
 	}
 	/**
 	* Apply config after save or hot reload so the default model updates without restarting the gateway.
@@ -397,22 +512,12 @@ var AgentService = class {
 		if (this.agentManager.setModelForSession(sessionKey, modelId)) this.sessionTracker.touchSession(sessionKey);
 		return true;
 	}
-	async clearSessionModelOverride(sessionKey) {
-		this.modelManager.clearSessionModelOverride(sessionKey);
-		await this.sessionConfigStore.update(sessionKey, { modelOverride: void 0 });
-		const agent = this.agentManager.getAgent(sessionKey);
-		if (agent) await this.modelManager.applyModelForSession(agent, sessionKey);
-	}
 	/**
 	* Clears per-session model override so the next turn uses the configured agent default
 	* (e.g. cron isolated job with no explicit model).
 	*/
 	async resetSessionModelToAgentDefault(sessionKey) {
-		await this.clearSessionModelOverride(sessionKey);
-	}
-	async hydrateSessionModelFromStore(sessionKey) {
-		const cfg = await this.sessionConfigStore.get(sessionKey);
-		if (cfg?.modelOverride) await this.modelManager.switchModelForSession(sessionKey, cfg.modelOverride);
+		await this.sessionConfig.clearModelOverride(sessionKey);
 	}
 	setStreamHandle(handle) {
 		this.streamManager.setHandle(handle);
@@ -424,145 +529,18 @@ var AgentService = class {
 	}
 	/** Last assistant visible plain text for a session (e.g. after a webchat stream). */
 	getLastAssistantPlainText(sessionKey) {
-		return this.lastAssistantPlainTextBySession.get(sessionKey) ?? this.agentManager.getLastAssistantContent(sessionKey) ?? "";
-	}
-	/** Gateway only: webchat continuations bypass the bus and reuse `runGatewayAgent`. */
-	setPersistentGoalWebchatContinuationScheduler(fn) {
-		this.persistentGoalWebchatContinuationScheduler = fn;
+		return this.sessionState.getLastAssistantText(sessionKey) ?? this.agentManager.getLastAssistantContent(sessionKey) ?? "";
 	}
 	beginInboundTurn(sessionKey) {
-		this.inboundTurnDepthBySession.set(sessionKey, (this.inboundTurnDepthBySession.get(sessionKey) ?? 0) + 1);
+		this.sessionState.beginInboundTurn(sessionKey);
 	}
 	endInboundTurn(sessionKey) {
-		const n = (this.inboundTurnDepthBySession.get(sessionKey) ?? 1) - 1;
-		if (n <= 0) this.inboundTurnDepthBySession.delete(sessionKey);
-		else this.inboundTurnDepthBySession.set(sessionKey, n);
+		this.sessionState.endInboundTurn(sessionKey);
 	}
 	getInboundTurnDepth(sessionKey) {
-		return this.inboundTurnDepthBySession.get(sessionKey) ?? 0;
-	}
-	schedulePersistentGoalContinuation(sessionKey, message, routing) {
-		if (parseSessionKey(sessionKey)?.source === "webchat" && this.persistentGoalWebchatContinuationScheduler) {
-			this.persistentGoalWebchatContinuationScheduler(sessionKey, message);
-			return;
-		}
-		queueMicrotask(() => {
-			this.bus.publishInbound({
-				channel: routing.channel,
-				chat_id: routing.chatId,
-				sender_id: "persistent-goal",
-				content: message,
-				metadata: {
-					sessionKey,
-					...routing.inboundMetadata
-				}
-			}).catch((err) => {
-				log.warn({
-					err,
-					sessionKey
-				}, "Persistent goal: publishInbound failed");
-			});
-		});
-	}
-	getPersistentGoalApisForCommand(routing) {
-		return {
-			getSessionMetadata: (k) => this.sessionStore.getMetadata(k),
-			updateSessionMetadata: async (k, u) => {
-				await this.sessionStore.updateMetadata(k, u);
-				this.onSessionMetadataUpdated?.(k);
-			},
-			loadMessages: (k) => this.sessionStore.loadMessages(k),
-			saveMessages: (k, m) => this.sessionStore.saveMessages(k, m),
-			appendAssistantReceipt: async (k, text) => {
-				const trimmed = text.trim();
-				if (!trimmed) return;
-				const { absPath } = await this.sessionStore.resolveTranscriptPath(k);
-				const workspaceDir = this.agentManager.getResolvedWorkspaceForSession(k);
-				const { appendPiTranscriptMessage } = await import("../session/parity/jsonl-transcript-io.js");
-				await appendPiTranscriptMessage({
-					absPath,
-					cwd: workspaceDir,
-					message: {
-						role: "assistant",
-						content: [{
-							type: "text",
-							text: trimmed
-						}],
-						timestamp: Date.now()
-					},
-					sessionKey: k
-				});
-				this.notifyWebchatTranscriptAppend(k, trimmed);
-			},
-			scheduleContinuation: (sk, msg) => {
-				this.schedulePersistentGoalContinuation(sk, msg, {
-					channel: routing.channel,
-					chatId: routing.chatId,
-					inboundMetadata: routing.inboundMetadata
-				});
-			},
-			inboundConcurrentDepth: (sk) => this.getInboundTurnDepth(sk)
-		};
-	}
-	recordPersistentGoalStreamOutcome(sessionKey, outcome) {
-		this.directStreamOutcomeBySession.set(sessionKey, outcome);
-	}
-	takePersistentGoalStreamOutcome(sessionKey) {
-		const v = this.directStreamOutcomeBySession.get(sessionKey);
-		this.directStreamOutcomeBySession.delete(sessionKey);
-		return v;
-	}
-	/**
-	* After any assistant-visible turn (webchat direct stream or bus-driven channels): extension hook + built-in `/goal` post-turn.
-	*/
-	async emitSessionTurnComplete(payload) {
-		await this.hookHandler.triggerWithSessionKey(payload.sessionKey, "webchat_turn_complete", {
-			sessionKey: payload.sessionKey,
-			channel: payload.channel,
-			chatId: payload.chatId,
-			inboundUserText: payload.inboundUserText,
-			assistantPlainText: payload.assistantPlainText,
-			aborted: payload.aborted,
-			...payload.streamError !== void 0 ? { streamError: payload.streamError } : {}
-		});
-		const apis = this.getPersistentGoalApisForCommand({
-			sessionKey: payload.sessionKey,
-			channel: payload.channel,
-			chatId: payload.chatId,
-			inboundMetadata: payload.outboundMetadata
-		});
-		const publishVerdict = !(parseSessionKey(payload.sessionKey)?.source === "webchat") && payload.channel !== "cli" ? async (text) => {
-			await this.bus.publishOutbound({
-				channel: payload.channel,
-				chat_id: payload.chatId,
-				content: text,
-				type: "message",
-				metadata: {
-					accountId: payload.outboundMetadata?.accountId,
-					threadId: payload.outboundMetadata?.threadId
-				}
-			});
-		} : void 0;
-		let runtimeSessionModelRef;
-		try {
-			runtimeSessionModelRef = this.modelManager.getModelForSession(payload.sessionKey);
-		} catch {
-			runtimeSessionModelRef = void 0;
-		}
-		await handlePersistentGoalPostTurn({
-			apis,
-			sessionKey: payload.sessionKey,
-			assistantPlainText: payload.assistantPlainText,
-			aborted: payload.aborted,
-			...payload.streamError !== void 0 ? { streamError: payload.streamError } : {},
-			skipPersistentGoalPostTurn: payload.skipPersistentGoalPostTurn ?? false,
-			config: this.effectiveAppConfig(),
-			runtimeSessionModelRef,
-			publishVerdictToChannel: publishVerdict
-		});
+		return this.sessionState.getInboundTurnDepth(sessionKey);
 	}
 	async start() {
-		this.running = true;
 		await this.sessionConfigStore.initialize();
 		await this.hookHandler.trigger("gateway_start", {
 			port: 0,
@@ -576,27 +554,10 @@ var AgentService = class {
 			}, `Dreaming cron reconcile failed: ${em}`);
 		});
 		log.debug("Agent service started");
-		await this.hookHandler.trigger("session_start", { sessionId: this.agentId });
-		while (this.running) try {
-			const msg = await this.bus.consumeInbound();
-			await this.handleInboundMessage(msg);
-		} catch (error) {
-			if (error instanceof MessageBusShutdownError) break;
-			const em = error instanceof Error ? error.message : String(error);
-			log.error({
-				err: error,
-				errorMessage: em,
-				phase: "inbound_consume"
-			}, `Agent loop failed (will retry in 1s): ${em}`);
-			await new Promise((resolve) => setTimeout(resolve, 1e3));
-		}
-		await this.hookHandler.trigger("session_end", {
-			sessionId: this.agentId,
-			messageCount: 0
-		});
+		await this.inboundLoop.start();
 	}
 	stop() {
-		this.running = false;
+		this.inboundLoop.stop();
 		this.agentManager.dispose();
 		this.dispose();
 		this.hookHandler.trigger("gateway_stop", { reason: "stopped" });
@@ -671,7 +632,7 @@ var AgentService = class {
 			channel,
 			chatId
 		});
-		this.sessionContextManager.setContext(context);
+		this.sessionContextManager.enter(context);
 		this.feedbackCoordinator.setContext(context);
 		this.agentManager.getOrCreateAgent(sessionKey);
 		this.setupSessionEventHandling(sessionKey);
@@ -686,43 +647,19 @@ var AgentService = class {
 		return persistInboundAttachmentsToWorkspace(resolveAgentHomeDir(cfg, extractProfileAgentId(sessionKey, cfg)), sessionKey, attachments);
 	}
 	endDirectRequestContext() {
-		this.sessionContextManager.clearContext();
 		this.feedbackCoordinator.clearContext();
 		this.contextMiddleware.onResponse();
 	}
-	/** Full session snapshot (metadata + API-shaped messages), e.g. embedded TUI history. */
-	async loadSessionDetail(sessionKey) {
-		return this.sessionStore.get(sessionKey);
-	}
-	/** Session list for TUI picker (embedded / local). */
-	async listSessionsForUi(limit = 200) {
-		return (await this.sessionStore.list({
-			limit,
-			sortBy: "updatedAt",
-			sortOrder: "desc"
-		})).items;
-	}
-	async deleteSessionKey(key) {
-		return this.sessionStore.deleteSession(key);
-	}
-	async renameSessionKey(key, name) {
-		await this.sessionStore.updateMetadata(key, { name: name.trim() });
-	}
+	/**
+	* Reset a session's transcript and drop the in-memory agent so the next turn
+	* reloads from disk. Combines two collaborators (sessionStore + agentManager)
+	* so it stays on `AgentService`; pure sessionStore reads should use
+	* `agentService.sessionStore.*` directly.
+	*/
 	async clearSessionMessages(key) {
 		await this.sessionStore.saveMessages(key, []);
 		this.agentManager.removeAgent(key);
 	}
-	async compactSession(sessionKey, options) {
-		const messages = await this.sessionStore.load(sessionKey);
-		const contextWindow = this.getContextWindow();
-		const result = await this.sessionStore.compact(sessionKey, messages, contextWindow, options?.instructions, options?.force ?? true);
-		if (result.compacted) this.agentManager.removeAgent(sessionKey);
-		log.info({
-			sessionKey,
-			result
-		}, "Manual compaction complete");
-		return result;
-	}
 	/**
 	* Drop in-memory agent so the next turn reloads transcript from disk (e.g. after checkpoint restore).
 	*/
@@ -730,234 +667,15 @@ var AgentService = class {
 		this.agentManager.removeAgent(sessionKey);
 	}
 	/**
-	* One-shot LLM answer for /btw: uses transcript as background only; does not persist to session.
-	*/
-	async btwQuery(sessionKey, question) {
-		return runBtwQuery({
-			sessionKey,
-			question,
-			sessionStore: this.sessionStore,
-			modelForSession: this.modelManager.getModelForSession(sessionKey),
-			log
-		});
-	}
-	/** Markdown or JSON summary for /context (prompt assembly is approximated from config + transcript stats). */
-	async getSessionContextReport(sessionKey, mode) {
-		const messages = await this.sessionStore.load(sessionKey);
-		const cw = this.getContextWindow();
-		const stats = this.getSessionStats(sessionKey, messages);
-		const cfg = this.effectiveAppConfig() ?? this.config.config;
-		const model = this.modelManager.getModelForSession(sessionKey);
-		const workspace = effectiveWorkspacePathForSession(cfg, sessionKey, await this.sessionConfigStore.get(sessionKey));
-		const estTokens = await this.sessionStore.estimateTokenUsage(sessionKey, messages);
-		const profile = resolveEffectiveAgentProfileForSession(cfg, sessionKey);
-		const defaults = cfg.agents?.defaults;
-		const compaction = defaults?.compaction;
-		const tools = defaults?.tools;
-		const toolsSummary = tools && typeof tools === "object" ? Object.entries(tools).filter(([, v]) => v === true).map(([k]) => k).slice(0, 16).join(", ") || "(none explicitly true)" : "(see agents.defaults.tools in config)";
-		return formatSessionContextReport({
-			sessionKey,
-			mode,
-			model,
-			workspacePath: workspace,
-			agentId: profile.agentId,
-			messageCount: messages.length,
-			contextWindowNominal: cw,
-			estimatedTranscriptTokens: estTokens,
-			thinkingDefault: defaults?.thinkingDefault,
-			reasoningDefault: defaults?.reasoningDefault,
-			verboseDefault: defaults?.verboseDefault,
-			compaction,
-			toolsFlagsSummary: toolsSummary,
-			windowStats: stats.windowStats,
-			compactionRunStats: stats.compactionStats
-		});
-	}
-	getSessionStats(sessionKey, messages) {
-		return {
-			windowStats: this.sessionStore.getWindowStats(messages),
-			compactionStats: this.sessionStore.getCompactionStats(sessionKey),
-			tokenEstimate: this.sessionStore.estimateTokenUsage(sessionKey, messages)
-		};
-	}
-	/** Rough context usage for TUI footer (estimated tokens vs nominal budget). */
-	async getSessionContextUsage(sessionKey) {
-		const messages = await this.sessionStore.load(sessionKey);
-		const contextWindow = this.getContextWindow();
-		const estimatedTokens = await this.sessionStore.estimateTokenUsage(sessionKey, messages);
-		return {
-			estimatedTokens,
-			contextWindow,
-			usagePercent: contextWindow > 0 ? Math.min(100, Math.round(estimatedTokens / contextWindow * 100)) : null
-		};
-	}
-	async applyResolvedThinkingLevel(sessionKey, requestOverride) {
-		const def = this.effectiveAppConfig()?.agents?.defaults?.thinkingDefault;
-		const level = await resolveEffectiveThinkingLevel(this.sessionConfigStore, sessionKey, requestOverride, def);
-		this.agentManager.setThinkingLevel(sessionKey, level);
-	}
-	/** Resolved thinking level and effective model ref for a session (Web UI). */
-	async getSessionAgentConfig(sessionKey) {
-		await this.hydrateSessionModelFromStore(sessionKey);
-		const cfg = this.effectiveAppConfig();
-		const sc = await this.sessionConfigStore.get(sessionKey);
-		const profileModelRef = resolveEffectiveAgentProfileForSession(cfg, sessionKey).primaryModelRef?.trim();
-		if (profileModelRef) this.modelManager.setSessionProfileDefault(sessionKey, profileModelRef);
-		const defThink = cfg.agents?.defaults?.thinkingDefault ?? "medium";
-		const level = await resolveEffectiveThinkingLevel(this.sessionConfigStore, sessionKey, null, defThink);
-		const defReason = cfg.agents?.defaults?.reasoningDefault ?? "stream";
-		const reasoningLevel = await resolveEffectiveReasoningLevel(this.sessionConfigStore, sessionKey, defReason);
-		return {
-			thinkingLevel: level,
-			model: this.modelManager.getModelForSession(sessionKey),
-			reasoningLevel,
-			effectiveWorkspacePath: effectiveWorkspacePathForSession(cfg, sessionKey, sc),
-			workingDirectoryLocked: Boolean(sc?.workingDirectoryOverride?.trim())
-		};
-	}
-	/**
 	* Load session working directory override into AgentManager, ensure directory exists.
 	* Call before AgentManager.getOrCreateAgent for this session.
 	*/
-	async hydrateSessionWorkspaceFromStore(sessionKey) {
-		const cfg = this.config.config;
-		if (!cfg) return;
-		const loaded = await this.sessionConfigStore.get(sessionKey);
-		if (loaded?.workingDirectoryOverride?.trim()) {
-			const wdStored = normalizeWorkingDirectoryInput(loaded.workingDirectoryOverride);
-			if (wdStored.ok) this.agentManager.setSessionWorkspaceOverride(sessionKey, wdStored.path);
-			else {
-				log.warn({ sessionKey }, "Invalid stored workingDirectoryOverride; ignoring");
-				this.agentManager.setSessionWorkspaceOverride(sessionKey, null);
-			}
-		} else this.agentManager.setSessionWorkspaceOverride(sessionKey, null);
-		await mkdir(effectiveWorkspacePathForSession(cfg, sessionKey, loaded), { recursive: true });
-	}
-	/**
-	* Sync persisted session workspace override for an isolated cron run (runs may change when the job is edited).
-	* Omit or pass empty `workingDirectory` to use the effective agent default workspace for this session key.
-	*/
-	async applyCronJobWorkingDirectory(sessionKey, workingDirectory) {
-		const raw = workingDirectory?.trim();
-		if (raw) {
-			const wdNorm = normalizeWorkingDirectoryInput(raw);
-			if (wdNorm.ok === false) {
-				log.warn({
-					sessionKey,
-					error: wdNorm.error
-				}, "Cron job working directory invalid; using agent default");
-				await this.clearCronSessionWorkingDirectoryOverride(sessionKey);
-				return;
-			}
-			await mkdir(wdNorm.path, { recursive: true });
-			await this.sessionConfigStore.update(sessionKey, { workingDirectoryOverride: wdNorm.path });
-			this.agentManager.setSessionWorkspaceOverride(sessionKey, wdNorm.path);
-			return;
-		}
-		await this.clearCronSessionWorkingDirectoryOverride(sessionKey);
-	}
-	async clearCronSessionWorkingDirectoryOverride(sessionKey) {
-		const existing = await this.sessionConfigStore.get(sessionKey);
-		if (existing?.workingDirectoryOverride) {
-			const { workingDirectoryOverride: _removed, ...rest } = existing;
-			await this.sessionConfigStore.set(sessionKey, rest);
-		}
-		this.agentManager.setSessionWorkspaceOverride(sessionKey, null);
-	}
 	/** Workspace root for UI file tree / editor (same as agent tools after hydration). */
 	async getEffectiveWorkspacePathForSession(sessionKey) {
-		await this.hydrateSessionWorkspaceFromStore(sessionKey);
+		await this.sessionHydrator.workspace(sessionKey);
 		const cfg = this.config.config;
 		return effectiveWorkspacePathForSession(cfg, sessionKey, await this.sessionConfigStore.get(sessionKey));
 	}
-	async patchSessionAgentConfig(sessionKey, partial) {
-		if (partial.model !== void 0) if (partial.model === null || partial.model === "") await this.clearSessionModelOverride(sessionKey);
-		else {
-			if (!await this.modelManager.switchModelForSession(sessionKey, partial.model)) return {
-				ok: false,
-				error: "Invalid model"
-			};
-			await this.sessionConfigStore.update(sessionKey, { modelOverride: partial.model });
-			this.agentManager.setModelForSession(sessionKey, partial.model);
-		}
-		if (partial.thinkingLevel !== void 0) {
-			const normalized = normalizeThinkLevel(partial.thinkingLevel);
-			if (!normalized) return {
-				ok: false,
-				error: "Invalid thinking level"
-			};
-			await this.sessionConfigStore.update(sessionKey, { thinkingLevel: normalized });
-			this.agentManager.setThinkingLevel(sessionKey, normalized);
-		}
-		if (partial.reasoningLevel !== void 0) {
-			const normalized = normalizeReasoningLevel(partial.reasoningLevel);
-			if (!normalized) return {
-				ok: false,
-				error: "Invalid reasoning level"
-			};
-			await this.sessionConfigStore.update(sessionKey, { reasoningLevel: normalized });
-		}
-		if (partial.workingDirectory !== void 0) {
-			if (!this.config.config) return {
-				ok: false,
-				error: "Config not loaded"
-			};
-			const existingRaw = (await this.sessionConfigStore.get(sessionKey))?.workingDirectoryOverride?.trim();
-			const incoming = partial.workingDirectory.trim();
-			if ((await this.sessionStore.load(sessionKey)).length > 0) {
-				if (!incoming) return {
-					ok: false,
-					error: "workingDirectory is empty"
-				};
-				if (!existingRaw) return {
-					ok: false,
-					error: "Working directory can only be set before the first message in this conversation"
-				};
-				const prev = normalizeWorkingDirectoryInput(existingRaw);
-				const next = normalizeWorkingDirectoryInput(incoming);
-				if (prev.ok && next.ok && prev.path === next.path) {} else return {
-					ok: false,
-					error: "Working directory is already set for this session"
-				};
-			} else {
-				if (!incoming) return {
-					ok: false,
-					error: "workingDirectory is empty"
-				};
-				const wdNorm = normalizeWorkingDirectoryInput(incoming);
-				switch (wdNorm.ok) {
-					case true:
-						if (existingRaw) {
-							const prev = normalizeWorkingDirectoryInput(existingRaw);
-							if (prev.ok && prev.path === wdNorm.path) break;
-						}
-						await mkdir(wdNorm.path, { recursive: true });
-						await this.sessionConfigStore.update(sessionKey, { workingDirectoryOverride: wdNorm.path });
-						this.agentManager.setSessionWorkspaceOverride(sessionKey, wdNorm.path);
-						this.agentManager.removeAgent(sessionKey);
-						break;
-					case false: return {
-						ok: false,
-						error: wdNorm.error
-					};
-					default: return {
-						ok: false,
-						error: "Invalid working directory"
-					};
-				}
-			}
-		}
-		return { ok: true };
-	}
-	async *processDirectStreaming(content, sessionKey = "cli:direct", attachments, thinking, options) {
-		yield* runProcessDirectStreaming(this.createProcessDirectStreamingDeps(), {
-			content,
-			sessionKey,
-			attachments,
-			thinking,
-			signal: options?.signal
-		});
-	}
 	/**
 	* Best-effort timezone resolution for webchat envelope timestamps.
 	* Reads `USER.md` under the agent `profile/` directory and extracts a `Timezone:` line.
@@ -974,310 +692,15 @@ var AgentService = class {
 			return;
 		}
 	}
-	createProcessDirectStreamingDeps() {
-		return {
-			log,
-			parseSessionKey: (sk) => this.parseSessionKey(sk),
-			initDirectStreamingSession: (sk, channel, chatId) => this.initSessionContext(sk, channel, chatId),
-			registerWebchatSsePublisher: (sk, publisher) => {
-				this.webchatSseEnqueueBySession.set(sk, publisher);
-			},
-			unregisterWebchatSsePublisher: (sk) => {
-				this.webchatSseEnqueueBySession.delete(sk);
-			},
-			agentManager: this.agentManager,
-			hydrateSessionWorkspaceFromStore: (sk) => this.hydrateSessionWorkspaceFromStore(sk),
-			hydrateSessionModelFromStore: (sk) => this.hydrateSessionModelFromStore(sk),
-			sessionStore: this.sessionStore,
-			modelManager: this.modelManager,
-			applyResolvedThinkingLevel: (sk, t) => this.applyResolvedThinkingLevel(sk, t),
-			getConfig: () => this.effectiveAppConfig(),
-			sessionConfigStore: this.sessionConfigStore,
-			attachmentRootsForSession: (sk) => this.attachmentRootsForSession(sk),
-			commandHandler: this.commandHandler,
-			prepareInboundAttachments: (sk, att) => this.prepareInboundAttachments(sk, att),
-			buildMessageContent: (text, prepared, sk) => buildDirectUserMessageContent({
-				content: text,
-				attachments: prepared,
-				sessionKey: sk,
-				config: this.config.config,
-				agentManager: this.agentManager,
-				modelManager: this.modelManager
-			}),
-			recordPersistentGoalStreamOutcome: (sk, o) => this.recordPersistentGoalStreamOutcome(sk, o),
-			onTurnComplete: (sk, text) => {
-				if (text?.trim()) this.lastAssistantPlainTextBySession.set(sk, text.trim());
-				this.enqueueMaybeAutoTitleAfterPersist(sk);
-			},
-			reloadWebchatTranscript: (sk) => {
-				this.onSessionTranscriptUpdated?.(sk);
-			},
-			maybeEmitWebchatTts: (sk, hadVoice) => maybeEmitWebchatTts({
-				config: this.config.config,
-				agentManager: this.agentManager,
-				sessionStore: this.sessionStore,
-				log
-			}, sk, hadVoice),
-			endDirectRequestContext: () => this.endDirectRequestContext()
-		};
-	}
-	/**
-	* Inject an SSE event into an in-flight webchat stream (same queue as tokens/tools).
-	*/
-	enqueueWebchatSseEvent(sessionKey, event) {
-		const pub = this.webchatSseEnqueueBySession.get(sessionKey);
-		if (pub) pub(event);
-	}
-	/** Push assistant text to an in-flight webchat stream and notify gateway listeners. */
-	notifyWebchatTranscriptAppend(sessionKey, assistantText) {
-		const trimmed = assistantText.trim();
-		if (trimmed) this.enqueueWebchatSseEvent(sessionKey, {
-			type: "token",
-			content: trimmed
-		});
-		this.onSessionTranscriptUpdated?.(sessionKey);
-	}
-	/**
-	* Queue a steering user message into pi-agent's in-flight run (delivered after current tool work, before the next LLM call).
-	* See `Agent.steer` in `@earendil-works/pi-agent-core`.
-	*/
-	async steerWebchatSession(sessionKey, text) {
-		const trimmed = text.trim();
-		if (!trimmed) return false;
-		try {
-			const { queueEmbeddedSteer } = await import("./embedded/runs.js");
-			return await queueEmbeddedSteer(sessionKey, trimmed);
-		} catch (err) {
-			log.warn({
-				err,
-				sessionKey
-			}, "steerWebchatSession failed");
-			return false;
-		}
-	}
-	createRunProcessDirectDeps() {
-		const cfg = this.config.config;
-		if (!cfg) throw new Error("AgentService requires config.config");
-		return {
-			log,
-			config: cfg,
-			parseSessionKey: (sk) => this.parseSessionKey(sk),
-			initSessionContext: (sk, channel, chatId) => {
-				this.initSessionContext(sk, channel, chatId);
-			},
-			hydrateSessionWorkspaceFromStore: (sk) => this.hydrateSessionWorkspaceFromStore(sk),
-			hydrateSessionModelFromStore: (sk) => this.hydrateSessionModelFromStore(sk),
-			agentManager: this.agentManager,
-			sessionStore: this.sessionStore,
-			modelManager: this.modelManager,
-			applyResolvedThinkingLevel: (sk, t) => this.applyResolvedThinkingLevel(sk, t),
-			prepareInboundAttachments: (sk, att) => this.prepareInboundAttachments(sk, att),
-			commandHandler: this.commandHandler,
-			onTurnComplete: (sk, text) => {
-				if (text?.trim()) this.lastAssistantPlainTextBySession.set(sk, text.trim());
-				this.enqueueMaybeAutoTitleAfterPersist(sk);
-			},
-			endDirectRequestContext: () => this.endDirectRequestContext()
-		};
-	}
-	async processDirect(content, sessionKey = "cli:direct", attachments, thinking) {
-		return runProcessDirect(this.createRunProcessDirectDeps(), {
-			content,
-			sessionKey,
-			attachments,
-			thinking
-		});
-	}
-	async handleInboundMessage(msg) {
-		await runWithLogContext({ requestId: inboundMessageLogRequestId(msg) }, async () => {
-			const { context, isCommand, command, commandArgs } = await this.messageRouter.routeMessage(msg);
-			const sessionContext = {
-				sessionKey: context.sessionKey,
-				channel: context.channel,
-				chatId: context.chatId,
-				senderId: context.senderId || "",
-				isGroup: context.isGroup || false,
-				metadata: { transcribedVoice: msg.metadata?.transcribedVoice === true }
-			};
-			updateAsyncLogContext({ sessionId: sessionContext.sessionKey });
-			this.sessionContextManager.setContext(sessionContext);
-			this.feedbackCoordinator.setContext(sessionContext);
-			this.agentManager.getOrCreateAgent(sessionContext.sessionKey);
-			this.setupSessionEventHandling(sessionContext.sessionKey);
-			await this.sessionLifecycleManager.startSession(sessionContext);
-			/** Declared on the function so `finally` can clear typing after outbound (TTS + send). */
-			let typingController = null;
-			let inboundTurnArmed = false;
-			let busProcessFailed;
-			try {
-				if (msg.channel === "system") {
-					await this.handleSystemMessage(msg, sessionContext);
-					return;
-				}
-				if (this.channelManagerRef && msg.channel !== "cli") await this.channelManagerRef.dispatchInboundMessageAction(msg);
-				if (isCommand && command) {
-					if (await this.commandHandler.executeCommand(command, commandArgs || "", {
-						sessionKey: sessionContext.sessionKey,
-						channel: sessionContext.channel,
-						chatId: sessionContext.chatId,
-						senderId: sessionContext.senderId,
-						isGroup: sessionContext.isGroup,
-						inboundMetadata: msg.metadata
-					})) return;
-				}
-				if (msg.channel !== "cli") {
-					typingController = createTypingController({
-						intervalSeconds: 5,
-						onStart: async () => {
-							await this.bus.publishOutbound({
-								channel: msg.channel,
-								chat_id: msg.chat_id,
-								content: "",
-								type: "typing_on",
-								metadata: {
-									accountId: msg.metadata?.accountId,
-									threadId: msg.metadata?.threadId,
-									sessionWebhook: msg.metadata?.sessionWebhook,
-									conversationId: msg.metadata?.conversationId
-								}
-							});
-						},
-						onStop: async () => {
-							await this.bus.publishOutbound({
-								channel: msg.channel,
-								chat_id: msg.chat_id,
-								content: "",
-								type: "typing_off",
-								metadata: {
-									accountId: msg.metadata?.accountId,
-									threadId: msg.metadata?.threadId,
-									sessionWebhook: msg.metadata?.sessionWebhook,
-									conversationId: msg.metadata?.conversationId
-								}
-							});
-						}
-					});
-					typingController.start();
-				}
-				if (this.channelManagerRef && msg.channel !== "cli") {
-					const meta = msg.metadata;
-					const streamHandle = this.channelManagerRef.startStream(msg.channel, msg.chat_id, meta?.accountId, {
-						threadId: meta?.threadId,
-						replyToMessageId: meta?.messageId
-					});
-					if (streamHandle) this.setStreamHandle(streamHandle);
-				}
-				this.beginInboundTurn(sessionContext.sessionKey);
-				inboundTurnArmed = true;
-				try {
-					await this.agentOrchestrator.process(msg, sessionContext);
-				} catch (procErr) {
-					busProcessFailed = procErr instanceof Error ? procErr.message : String(procErr);
-					throw procErr;
-				}
-			} finally {
-				await this.sessionLifecycleManager.endSession(sessionContext);
-				await this.streamManager.end();
-				try {
-					await this.sendFinalResponse(msg, sessionContext);
-				} finally {
-					await typingController?.stop();
-				}
-				if (inboundTurnArmed) {
-					const meta = msg.metadata;
-					const assistantPlainText = this.getLastAssistantPlainText(sessionContext.sessionKey) ?? "";
-					try {
-						await this.emitSessionTurnComplete({
-							sessionKey: sessionContext.sessionKey,
-							channel: sessionContext.channel,
-							chatId: sessionContext.chatId,
-							inboundUserText: msg.content,
-							assistantPlainText,
-							aborted: false,
-							...busProcessFailed !== void 0 ? { streamError: busProcessFailed } : {},
-							skipPersistentGoalPostTurn: false,
-							outboundMetadata: {
-								accountId: meta?.accountId,
-								threadId: meta?.threadId
-							}
-						});
-					} catch (turnErr) {
-						const em = turnErr instanceof Error ? turnErr.message : String(turnErr);
-						log.warn({
-							err: turnErr,
-							sessionKey: sessionContext.sessionKey
-						}, `Session turn complete failed: ${em}`);
-					}
-					this.endInboundTurn(sessionContext.sessionKey);
-				}
-				this.feedbackCoordinator.endTask();
-				this.sessionContextManager.clearContext();
-				this.feedbackCoordinator.clearContext();
-			}
-		});
-	}
-	async handleSystemMessage(msg, context) {
-		log.debug({ sessionKey: context.sessionKey }, "Processing system message");
-		await this.hydrateSessionWorkspaceFromStore(context.sessionKey);
-		await this.hydrateSessionModelFromStore(context.sessionKey);
-		const messages = await this.sessionStore.load(context.sessionKey);
-		await this.checkAndCompact(context.sessionKey, messages);
-		const systemMessage = {
-			role: "user",
-			content: [{
-				type: "text",
-				text: `[System: ${msg.sender_id}] ${msg.content}`
-			}],
-			timestamp: Date.now()
-		};
-		try {
-			const { runEmbeddedTurnForSession } = await import("./embedded/run-for-session.js");
-			const finalContent = (await runEmbeddedTurnForSession({
-				sessionKey: context.sessionKey,
-				userMessage: systemMessage,
-				sessionStore: this.sessionStore,
-				agentManager: this.agentManager,
-				modelManager: this.modelManager,
-				getConfig: () => this.effectiveAppConfig()
-			})).lastAssistantText ?? this.getLastAssistantPlainText(context.sessionKey);
-			if (finalContent) {
-				this.lastAssistantPlainTextBySession.set(context.sessionKey, finalContent);
-				const hookResult = await this.hookHandler.runMessageSending(context.chatId, finalContent, context.channel);
-				if (hookResult.send) await this.bus.publishOutbound({
-					channel: context.channel,
-					chat_id: context.chatId,
-					content: hookResult.content || finalContent,
-					type: "message"
-				});
-			}
-			this.enqueueMaybeAutoTitleAfterPersist(context.sessionKey);
-		} catch (error) {
-			const em = error instanceof Error ? error.message : String(error);
-			log.error({
-				err: error,
-				errorMessage: em,
-				sessionKey: context.sessionKey,
-				channel: context.channel,
-				chatId: context.chatId,
-				senderId: msg.sender_id
-			}, `System message handling failed: ${em}`);
-			await this.bus.publishOutbound({
-				channel: context.channel,
-				chat_id: context.chatId,
-				content: "❌ An error occurred while processing the system message.",
-				type: "message"
-			});
-		}
-	}
 	/**
 	* Setup event handling for a specific session
 	*/
 	setupSessionEventHandling(sessionKey) {
-		if (this.sessionUnsubscribers.has(sessionKey)) return;
+		if (this.sessionState.hasSessionEventUnsubscriber(sessionKey)) return;
 		const unsubscribe = this.agentManager.subscribeToSession(sessionKey, (event) => {
 			this.handleSessionEvent(sessionKey, event);
 		});
-		if (unsubscribe) this.sessionUnsubscribers.set(sessionKey, unsubscribe);
+		if (unsubscribe) this.sessionState.setSessionEventUnsubscriber(sessionKey, unsubscribe);
 	}
 	/**
 	* Handle events from a specific session's agent
@@ -1324,41 +747,9 @@ var AgentService = class {
 		const defaults = this.config.agentDefaults || this.config.config?.agents?.defaults;
 		return defaults?.maxTokens ? defaults.maxTokens * 4 : 128e3;
 	}
-	async sendFinalResponse(msg, sessionContext) {
-		if (this.streamManager.consumeSkipFinalOutbound()) return;
-		const finalContent = this.getLastAssistantPlainText(sessionContext.sessionKey);
-		if (!finalContent?.trim()) return;
-		if (shouldSilence(finalContent, this.config.config?.gateway?.heartbeat?.ackMaxChars ?? 300) || finalContent.trim() === "NO_REPLY") {
-			log.debug({ sessionKey: sessionContext.sessionKey }, "Silent reply — skipping outbound");
-			return;
-		}
-		const hookResult = await this.hookHandler.runMessageSending(sessionContext.chatId, finalContent, sessionContext.channel);
-		if (!hookResult.send) return;
-		await this.bus.publishOutbound({
-			channel: sessionContext.channel,
-			chat_id: sessionContext.chatId,
-			content: hookResult.content || finalContent,
-			type: "message",
-			metadata: {
-				accountId: msg.metadata?.accountId,
-				threadId: msg.metadata?.threadId,
-				transcribedVoice: sessionContext.metadata?.transcribedVoice,
-				sessionWebhook: msg.metadata?.sessionWebhook,
-				conversationId: msg.metadata?.conversationId
-			}
-		});
-	}
-	/** Extension hooks for ChannelManager outbound pipeline (Gateway). */
-	async invokeOutboundMessageSending(to, content, channel) {
-		return this.hookHandler.runMessageSending(to, content, channel);
-	}
-	async invokeOutboundMessageSent(to, content, success, error, channel) {
-		return this.hookHandler.runMessageSent(to, content, success, error, channel);
-	}
 	dispose() {
 		this.sessionTracker.dispose();
-		for (const unsubscribe of this.sessionUnsubscribers.values()) unsubscribe();
-		this.sessionUnsubscribers.clear();
+		this.sessionState.disposeAll();
 		this.agentManager.dispose();
 	}
 };