devchain-cli 0.12.4 → 0.13.0

package/dist/server/modules/sessions/services/sessions.service.js

@@ -16,720 +16,40 @@ exports.SessionsService = void 0;
 const common_1 = require("@nestjs/common");
 const promises_1 = require("fs/promises");
 const error_types_1 = require("../../../common/errors/error-types");
-const confirmed_delivery_helper_1 = require("../../terminal/services/confirmed-delivery.helper");
-const core_1 = require("@nestjs/core");
-const crypto_1 = require("crypto");
+const terminal_io_service_1 = require("../../terminal/services/terminal-io/terminal-io.service");
 const logger_1 = require("../../../common/logging/logger");
-const tmux_service_1 = require("../../terminal/services/tmux.service");
-const terminal_send_coordinator_service_1 = require("../../terminal/services/terminal-send-coordinator.service");
 const pty_service_1 = require("../../terminal/services/pty.service");
 const preflight_service_1 = require("../../core/services/preflight.service");
-const provider_mcp_ensure_service_1 = require("../../core/services/provider-mcp-ensure.service");
+const provider_mcp_ensure_service_1 = require("../../providers/services/provider-mcp-ensure.service");
 const storage_interface_1 = require("../../storage/interfaces/storage.interface");
 const db_provider_1 = require("../../storage/db/db.provider");
 const better_sqlite3_1 = require("drizzle-orm/better-sqlite3");
-const profile_options_1 = require("../utils/profile-options");
-const env_builder_1 = require("../utils/env-builder");
-const template_renderer_1 = require("../utils/template-renderer");
-const claude_config_1 = require("../utils/claude-config");
+const sqlite_raw_1 = require("../../storage/db/sqlite-raw");
+const transaction_runner_1 = require("../../storage/db/transaction-runner");
+const terminal_session_registry_1 = require("../../terminal/services/terminal-session/terminal-session-registry");
+const agent_presence_aggregator_1 = require("./agent-presence-aggregator");
 const events_service_1 = require("../../events/services/events.service");
-const terminal_gateway_1 = require("../../terminal/gateways/terminal.gateway");
 const session_coordinator_service_1 = require("./session-coordinator.service");
 const hooks_config_service_1 = require("../../hooks/services/hooks-config.service");
 const provider_adapter_factory_1 = require("../../providers/adapters/provider-adapter.factory");
-const teams_service_1 = require("../../teams/services/teams.service");
-const env_config_1 = require("../../../common/config/env.config");
-const host_helpers_1 = require("../../../common/config/host-helpers");
 const logger = (0, logger_1.createLogger)('SessionsService');
-const BOOT_ID = (0, crypto_1.randomUUID)();
-function isUniqueConstraintError(error) {
-    return (typeof error === 'object' &&
-        error !== null &&
-        'code' in error &&
-        (error.code === 'SQLITE_CONSTRAINT' ||
-            error.code === 'SQLITE_CONSTRAINT_UNIQUE' ||
-            (typeof error.code === 'number' && error.code === 19)));
-}
-const MAX_INITIAL_PROMPT_LENGTH = 4000;
-const MAX_INITIAL_PROMPT_LINES = 80;
-const DEFAULT_INITIAL_PROMPT_TEMPLATE = 'Session {session_id} started for agent {agent_name} on project {project_name} using profile {profile_name}.';
 let SessionsService = class SessionsService {
-    constructor(db, storage, tmuxService, sendCoordinator, ptyService, preflightService, mcpEnsureService, sessionCoordinator, hooksConfigService, providerAdapterFactory, moduleRef) {
+    constructor(db, storage, terminalIO, ptyService, preflightService, mcpEnsureService, sessionCoordinator, hooksConfigService, providerAdapterFactory, eventsService, terminalSessionRegistry) {
         this.db = db;
         this.storage = storage;
-        this.tmuxService = tmuxService;
-        this.sendCoordinator = sendCoordinator;
+        this.terminalIO = terminalIO;
         this.ptyService = ptyService;
         this.preflightService = preflightService;
         this.mcpEnsureService = mcpEnsureService;
         this.sessionCoordinator = sessionCoordinator;
         this.hooksConfigService = hooksConfigService;
         this.providerAdapterFactory = providerAdapterFactory;
-        this.moduleRef = moduleRef;
-        this.sqlite = this.db.session?.client ?? this.db;
+        this.eventsService = eventsService;
+        this.terminalSessionRegistry = terminalSessionRegistry;
+        this.sqlite = (0, sqlite_raw_1.getRawSqliteClient)(this.db);
+        this.txRunner = new transaction_runner_1.TransactionRunner(this.sqlite);
         logger.info('SessionsService initialized');
     }
-    async resolveLaunchTarget(params) {
-        const { agentId, projectId, epicId } = params;
-        const agent = await this.storage.getAgent(agentId);
-        const project = await this.storage.getProject(projectId);
-        if (agent.projectId !== projectId) {
-            throw new error_types_1.ValidationError(`Agent ${agentId} does not belong to project ${projectId}.`, {
-                agentId,
-                agentProjectId: agent.projectId,
-                requestedProjectId: projectId,
-            });
-        }
-        const epic = epicId ? await this.storage.getEpic(epicId) : null;
-        const profile = await this.storage.getAgentProfile(agent.profileId);
-        let provider;
-        let options;
-        let configEnv = null;
-        if (agent.providerConfigId) {
-            const config = await this.storage.getProfileProviderConfig(agent.providerConfigId);
-            provider = await this.storage.getProvider(config.providerId);
-            options = config.options;
-            configEnv = config.env;
-            logger.info({ agentId, configId: config.id, providerId: provider.id }, 'Resolved provider via config');
-        }
-        else {
-            const configs = await this.storage.listProfileProviderConfigsByProfile(profile.id);
-            if (configs.length > 0) {
-                const firstConfig = configs[0];
-                provider = await this.storage.getProvider(firstConfig.providerId);
-                options = firstConfig.options;
-                configEnv = firstConfig.env;
-                logger.info({ agentId, profileId: profile.id, configId: firstConfig.id, providerId: provider.id }, 'Resolved provider via first profile config (no providerConfigId set on agent)');
-            }
-            else {
-                throw new error_types_1.ValidationError(`Profile ${profile.id} has no provider configs - cannot launch session`);
-            }
-        }
-        return { agent, project, epic, profile, provider, options, configEnv };
-    }
-    verifyProviderBinary(provider) {
-        if (!provider.binPath) {
-            throw new error_types_1.ValidationError(`Provider ${provider.name} is missing a binary path. Set the path before launching sessions.`, {
-                code: 'PROVIDER_BINARY_NOT_FOUND',
-                providerId: provider.id,
-                providerName: provider.name,
-            });
-        }
-    }
-    composeLaunchEnv(params) {
-        const { sessionId, tmuxSessionName, projectId, agentId, provider, configEnv, optionArgs } = params;
-        const providerEnv = provider.env ?? {};
-        const mergedBaseEnv = { ...providerEnv, ...(configEnv ?? {}) };
-        let envVars = Object.keys(mergedBaseEnv).length > 0 ? mergedBaseEnv : null;
-        let processedOptionArgs = optionArgs;
-        if (provider.name.toLowerCase() === 'claude') {
-            const env = (0, env_config_1.getEnvConfig)();
-            const devchainEnv = {
-                DEVCHAIN_API_URL: (0, host_helpers_1.getRuntimeInternalBaseUrl)(env),
-                DEVCHAIN_PROJECT_ID: projectId,
-                DEVCHAIN_AGENT_ID: agentId,
-                DEVCHAIN_SESSION_ID: sessionId,
-                DEVCHAIN_TMUX_SESSION_NAME: tmuxSessionName,
-            };
-            if (provider.oneMillionContextEnabled) {
-                processedOptionArgs = (0, profile_options_1.rewriteModelTo1m)(processedOptionArgs);
-            }
-            const modelStr = (0, profile_options_1.extractModelFromArgs)(processedOptionArgs);
-            const family = modelStr ? (0, profile_options_1.detectClaudeModelFamily)(modelStr) : null;
-            if (provider.oneMillionContextEnabled &&
-                family === 'opus' &&
-                provider.autoCompactThreshold1m != null) {
-                devchainEnv.CLAUDE_AUTOCOMPACT_PCT_OVERRIDE = String(provider.autoCompactThreshold1m);
-            }
-            else if (provider.autoCompactThreshold != null) {
-                devchainEnv.CLAUDE_AUTOCOMPACT_PCT_OVERRIDE = String(provider.autoCompactThreshold);
-            }
-            envVars = { ...devchainEnv, ...providerEnv, ...(configEnv ?? {}) };
-            delete envVars.CLAUDE_CODE_DISABLE_1M_CONTEXT;
-        }
-        return { envVars, processedOptionArgs };
-    }
-    async ensureMcpConfig(provider, projectRootPath) {
-        let preflightResult = await this.preflightService.runChecks(projectRootPath);
-        let providerCheck = preflightResult.providers?.find((p) => p.id === provider.id);
-        if (providerCheck?.mcpStatus && providerCheck.mcpStatus !== 'pass') {
-            logger.info({
-                providerId: provider.id,
-                providerName: provider.name,
-                mcpStatus: providerCheck.mcpStatus,
-            }, 'MCP not configured, attempting auto-ensure');
-            const ensureResult = await this.mcpEnsureService.ensureMcp(provider, projectRootPath);
-            if (ensureResult.success) {
-                logger.info({ providerId: provider.id, action: ensureResult.action }, 'MCP auto-configured successfully');
-                if (ensureResult.warnings?.length) {
-                    for (const w of ensureResult.warnings) {
-                        logger.warn({ providerId: provider.id, ...w }, 'MCP ensure warning');
-                    }
-                }
-                preflightResult = await this.preflightService.runChecks(projectRootPath);
-                providerCheck = preflightResult.providers?.find((p) => p.id === provider.id);
-            }
-            else {
-                logger.warn({ providerId: provider.id, message: ensureResult.message }, 'MCP auto-ensure failed');
-            }
-            if (providerCheck?.mcpStatus && providerCheck.mcpStatus !== 'pass') {
-                throw new error_types_1.ValidationError('Provider MCP is not configured', {
-                    code: 'MCP_NOT_CONFIGURED',
-                    providerId: provider.id,
-                    providerName: provider.name,
-                    mcpStatus: providerCheck.mcpStatus,
-                    mcpMessage: providerCheck.mcpMessage,
-                });
-            }
-        }
-        else if (provider.name.toLowerCase() === 'gemini' && projectRootPath) {
-            await this.mcpEnsureService.ensureMcp(provider, projectRootPath);
-        }
-        return preflightResult;
-    }
-    async setupHooksConfig(provider, projectRootPath) {
-        if (provider.name.toLowerCase() !== 'claude')
-            return;
-        try {
-            await this.hooksConfigService.ensureHooksConfig(projectRootPath);
-            logger.info({ projectRootPath }, 'Hooks config ensured for Claude provider');
-        }
-        catch (error) {
-            logger.warn({ error }, 'Failed to ensure hooks config (non-fatal)');
-        }
-    }
-    async launchSession(data) {
-        const { epicId, agentId, projectId, options: launchOptions } = data;
-        const silent = launchOptions?.silent === true;
-        return this.sessionCoordinator.withAgentLock(agentId, async () => {
-            logger.info({ epicId, agentId, projectId }, 'Launching session');
-            const existingSession = this.getActiveSessionForAgent(agentId);
-            if (existingSession) {
-                const tmuxAlive = existingSession.tmuxSessionId
-                    ? await this.tmuxService.hasSession(existingSession.tmuxSessionId)
-                    : false;
-                if (tmuxAlive) {
-                    logger.info({ agentId, existingSessionId: existingSession.id }, 'Agent already has active session with live tmux, returning existing session (idempotent)');
-                    const agent = await this.storage.getAgent(agentId);
-                    const project = await this.storage.getProject(agent.projectId);
-                    const epic = existingSession.epicId
-                        ? await this.storage.getEpic(existingSession.epicId).catch(() => null)
-                        : null;
-                    return {
-                        ...existingSession,
-                        epic: epic
-                            ? {
-                                id: epic.id,
-                                title: epic.title,
-                                projectId: epic.projectId,
-                            }
-                            : null,
-                        agent: {
-                            id: agent.id,
-                            name: agent.name,
-                            profileId: agent.profileId,
-                        },
-                        project: {
-                            id: project.id,
-                            name: project.name,
-                            rootPath: project.rootPath,
-                        },
-                    };
-                }
-                logger.warn({
-                    agentId,
-                    orphanedSessionId: existingSession.id,
-                    tmuxSessionId: existingSession.tmuxSessionId,
-                }, 'Found orphaned session (tmux gone), marking as stopped before continuing');
-                this.sqlite
-                    .prepare(`
-            UPDATE sessions
-            SET status = 'stopped', ended_at = ?, updated_at = ?
-            WHERE id = ?
-          `)
-                    .run(new Date().toISOString(), new Date().toISOString(), existingSession.id);
-                logger.info({ agentId }, 'Orphaned session cleaned up, proceeding to create new session');
-            }
-            const { agent, project, epic, profile, provider, options, configEnv } = await this.resolveLaunchTarget({ agentId, projectId, epicId });
-            if (provider.name.toLowerCase() === 'claude') {
-                const { autoCompactEnabled, configState } = await (0, claude_config_1.checkClaudeAutoCompact)();
-                if (!autoCompactEnabled && configState !== 'malformed') {
-                    this.getTerminalGateway().broadcastEvent('system', 'session_recommendation', {
-                        reason: 'claude_auto_compact_disabled',
-                        agentId,
-                        agentName: agent.name,
-                        providerId: provider.id,
-                        providerName: provider.name,
-                        silent,
-                        bootId: BOOT_ID,
-                    });
-                }
-            }
-            const preflightResult = await this.ensureMcpConfig(provider, project.rootPath);
-            await this.setupHooksConfig(provider, project.rootPath);
-            if (preflightResult.overall === 'fail') {
-                const failedChecks = preflightResult.checks
-                    .filter((c) => c.status === 'fail')
-                    .map((c) => `${c.name}: ${c.message}`)
-                    .join('; ');
-                throw new error_types_1.ValidationError('Preflight checks failed', {
-                    failedChecks,
-                    projectId,
-                });
-            }
-            const sessionId = (0, crypto_1.randomUUID)();
-            const now = new Date().toISOString();
-            const projectSlug = project.name
-                .toLowerCase()
-                .replace(/[^a-z0-9]+/g, '-')
-                .replace(/(^-|-$)/g, '');
-            const epicSegment = epicId ?? 'independent';
-            const tmuxSessionName = this.tmuxService.createSessionName(projectSlug, epicSegment, agentId, sessionId);
-            await this.tmuxService.createSession(tmuxSessionName, project.rootPath);
-            await this.tmuxService.setAlternateScreenOff(tmuxSessionName);
-            this.tmuxService.startHealthCheck(tmuxSessionName, sessionId);
-            this.verifyProviderBinary(provider);
-            let optionArgs = [];
-            try {
-                optionArgs = (0, profile_options_1.parseProfileOptions)(options);
-            }
-            catch (error) {
-                if (error instanceof profile_options_1.ProfileOptionsError) {
-                    throw new error_types_1.ValidationError(error.message, {
-                        profileId: profile.id,
-                        profileName: profile.name,
-                    });
-                }
-                throw error;
-            }
-            if (agent.modelOverride) {
-                optionArgs = (0, profile_options_1.injectModelOverride)(optionArgs, agent.modelOverride);
-            }
-            const { envVars, processedOptionArgs } = this.composeLaunchEnv({
-                sessionId,
-                tmuxSessionName,
-                projectId,
-                agentId,
-                provider,
-                configEnv,
-                optionArgs,
-            });
-            optionArgs = processedOptionArgs;
-            let launchArgv = optionArgs;
-            try {
-                const launchAdapter = this.providerAdapterFactory.getAdapter(provider.name);
-                launchArgv = launchAdapter.buildLaunchArgs({
-                    mode: 'new',
-                    profileOptionArgs: optionArgs,
-                }).argv;
-            }
-            catch {
-            }
-            let commandArgs;
-            try {
-                commandArgs = (0, env_builder_1.buildSessionCommand)(envVars, provider.binPath, launchArgv);
-            }
-            catch (error) {
-                if (error instanceof env_builder_1.EnvBuilderError) {
-                    throw new error_types_1.ValidationError(error.message, {
-                        agentId,
-                        providerConfigId: agent.providerConfigId,
-                    });
-                }
-                throw error;
-            }
-            try {
-                this.sqlite
-                    .prepare(`
-          INSERT INTO sessions (id, epic_id, agent_id, tmux_session_id, status, started_at, provider_name_at_launch, created_at, updated_at)
-          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-        `)
-                    .run(sessionId, epicId ?? null, agentId, tmuxSessionName, 'running', now, provider.name.toLowerCase(), now, now);
-                logger.info({ sessionId, tmuxSessionName }, 'Session created in database');
-            }
-            catch (error) {
-                if (isUniqueConstraintError(error)) {
-                    logger.warn({ agentId, tmuxSessionName, error }, 'Unique constraint violation - cleaning up orphaned tmux session and returning existing session');
-                    try {
-                        await this.tmuxService.destroySession(tmuxSessionName);
-                        logger.info({ tmuxSessionName }, 'Cleaned up orphaned tmux session');
-                    }
-                    catch (tmuxError) {
-                        logger.warn({ tmuxError, tmuxSessionName }, 'Failed to cleanup orphaned tmux session');
-                    }
-                    const existingSession = this.getActiveSessionForAgent(agentId);
-                    if (existingSession) {
-                        logger.info({ agentId, existingSessionId: existingSession.id }, 'Returning existing running session after constraint violation');
-                        const existingAgent = await this.storage.getAgent(agentId);
-                        const existingProject = await this.storage.getProject(projectId);
-                        const existingEpic = existingSession.epicId
-                            ? await this.storage.getEpic(existingSession.epicId).catch(() => null)
-                            : null;
-                        return {
-                            ...existingSession,
-                            epic: existingEpic
-                                ? {
-                                    id: existingEpic.id,
-                                    title: existingEpic.title,
-                                    projectId: existingEpic.projectId,
-                                }
-                                : null,
-                            agent: {
-                                id: existingAgent.id,
-                                name: existingAgent.name,
-                                profileId: existingAgent.profileId,
-                            },
-                            project: {
-                                id: existingProject.id,
-                                name: existingProject.name,
-                                rootPath: existingProject.rootPath,
-                            },
-                        };
-                    }
-                    throw error;
-                }
-                throw error;
-            }
-            logger.info({ sessionId, provider: provider.name, commandArgs, hasEnvVars: !!envVars }, 'Launching agent with provider binary');
-            try {
-                await this.tmuxService.sendCommandArgs(tmuxSessionName, commandArgs);
-            }
-            catch (error) {
-                this.sqlite.prepare('DELETE FROM sessions WHERE id = ?').run(sessionId);
-                logger.warn({ sessionId, error: String(error) }, 'CLI launch failed, cleaned up session row');
-                try {
-                    await this.tmuxService.destroySession(tmuxSessionName);
-                }
-                catch (tmuxError) {
-                    logger.warn({ tmuxError, tmuxSessionName }, 'Failed to cleanup tmux session after CLI launch failure');
-                }
-                throw error;
-            }
-            const launchTimestamp = Date.now();
-            const { ready, elapsedMs } = await this.tmuxService.waitForOutput(tmuxSessionName, {
-                pollIntervalMs: 500,
-                timeoutMs: 30_000,
-                settleMs: 1_000,
-            });
-            if (!ready) {
-                logger.warn({ sessionId, tmuxSessionName, elapsedMs }, 'CLI output detection timed out, proceeding anyway');
-            }
-            const MIN_LAUNCH_DELAY_MS = 7_000;
-            const elapsed = Date.now() - launchTimestamp;
-            if (elapsed < MIN_LAUNCH_DELAY_MS) {
-                const remaining = MIN_LAUNCH_DELAY_MS - elapsed;
-                logger.debug({ sessionId, elapsed, remaining }, 'Waiting for minimum launch delay before initial prompt paste');
-                await new Promise((resolve) => setTimeout(resolve, remaining));
-            }
-            let launchHandshake;
-            try {
-                const adapter = this.providerAdapterFactory.getAdapter(provider.name);
-                launchHandshake = adapter.launchInitialPromptBehavior;
-                logger.debug({
-                    sessionId,
-                    providerName: provider.name,
-                    hasHandshake: !!launchHandshake,
-                    preKeys: launchHandshake?.preKeys,
-                    preDelayMs: launchHandshake?.preDelayMs,
-                }, 'Resolved provider launch handshake metadata');
-            }
-            catch (adapterError) {
-                logger.debug({ sessionId, providerName: provider.name, error: String(adapterError) }, 'No adapter found for provider, skipping launch handshake');
-            }
-            try {
-                await this.renderAndPasteInitialPrompt({
-                    sessionId,
-                    tmuxSessionName,
-                    agentId,
-                    project: { id: project.id, name: project.name },
-                    agent,
-                    epic,
-                    profile,
-                    provider,
-                    launchHandshake,
-                });
-            }
-            catch (promptError) {
-                logger.warn({ sessionId, error: String(promptError) }, 'Initial prompt submit failed, session continues');
-            }
-            await this.ptyService.startStreaming(sessionId, tmuxSessionName);
-            await this.getEventsService().publish('session.started', {
-                sessionId,
-                epicId: epicId ?? null,
-                agentId,
-                tmuxSessionName,
-            });
-            try {
-                this.getTerminalGateway().broadcastEvent(`agent/${agentId}`, 'presence', {
-                    online: true,
-                    sessionId,
-                    agentId,
-                });
-            }
-            catch (error) {
-                logger.warn({ error, agentId, sessionId }, 'Failed to broadcast presence update');
-            }
-            return {
-                id: sessionId,
-                epicId: epicId ?? null,
-                agentId,
-                tmuxSessionId: tmuxSessionName,
-                status: 'running',
-                startedAt: now,
-                endedAt: null,
-                transcriptPath: null,
-                createdAt: now,
-                updatedAt: now,
-                epic: epic
-                    ? {
-                        id: epic.id,
-                        title: epic.title,
-                        projectId: epic.projectId,
-                    }
-                    : null,
-                agent: {
-                    id: agent.id,
-                    name: agent.name,
-                    profileId: agent.profileId,
-                },
-                project: {
-                    id: project.id,
-                    name: project.name,
-                    rootPath: project.rootPath,
-                },
-            };
-        });
-    }
-    async restoreSession(sessionId, projectId) {
-        const source = this.sqlite
-            .prepare(`SELECT id, epic_id, agent_id, tmux_session_id, status, started_at, ended_at,
-                transcript_path, provider_session_id, provider_name_at_launch, created_at, updated_at
-         FROM sessions WHERE id = ?`)
-            .get(sessionId);
-        if (!source) {
-            throw new common_1.NotFoundException('Session not found');
-        }
-        const sourceAgent = await this.storage.getAgent(source.agent_id);
-        if (sourceAgent.projectId !== projectId) {
-            throw new common_1.ForbiddenException('PROJECT_MISMATCH');
-        }
-        if (source.status !== 'stopped' && source.status !== 'failed') {
-            throw new common_1.ConflictException({
-                message: 'Session is not in a restorable state',
-                code: 'INVALID_SESSION_STATE',
-            });
-        }
-        if (!source.provider_session_id) {
-            throw new common_1.ConflictException({
-                message: 'Session has no provider session ID',
-                code: 'NO_PROVIDER_SESSION_ID',
-            });
-        }
-        const { provider: currentProvider } = await this.resolveLaunchTarget({
-            agentId: source.agent_id,
-            projectId,
-            epicId: source.epic_id,
-        });
-        if (source.provider_name_at_launch &&
-            currentProvider.name.toLowerCase() !== source.provider_name_at_launch.toLowerCase()) {
-            throw new common_1.ConflictException({
-                message: 'Current provider differs from launch-time provider',
-                code: 'PROVIDER_MISMATCH',
-            });
-        }
-        return this.sessionCoordinator.withAgentLock(source.agent_id, async () => {
-            const lockedSource = this.sqlite
-                .prepare(`SELECT id, epic_id, agent_id, tmux_session_id, status, started_at, ended_at,
-                  transcript_path, provider_session_id, provider_name_at_launch, created_at, updated_at
-           FROM sessions WHERE id = ?`)
-                .get(sessionId);
-            if (!lockedSource) {
-                throw new common_1.NotFoundException('Session not found');
-            }
-            if (lockedSource.status !== 'stopped' && lockedSource.status !== 'failed') {
-                throw new common_1.ConflictException({
-                    message: 'Session is not in a restorable state',
-                    code: 'INVALID_SESSION_STATE',
-                });
-            }
-            if (!lockedSource.provider_session_id) {
-                throw new common_1.ConflictException({
-                    message: 'Session has no provider session ID',
-                    code: 'NO_PROVIDER_SESSION_ID',
-                });
-            }
-            if (lockedSource.provider_name_at_launch &&
-                currentProvider.name.toLowerCase() !== lockedSource.provider_name_at_launch.toLowerCase()) {
-                throw new common_1.ConflictException({
-                    message: 'Current provider differs from launch-time provider',
-                    code: 'PROVIDER_MISMATCH',
-                });
-            }
-            const existingRunning = this.getActiveSessionForAgent(lockedSource.agent_id);
-            if (existingRunning) {
-                throw new common_1.ConflictException({
-                    message: 'Agent already has a running session',
-                    code: 'INVALID_SESSION_STATE',
-                });
-            }
-            const prior = {
-                status: lockedSource.status,
-                ended_at: lockedSource.ended_at,
-                tmux_session_id: lockedSource.tmux_session_id,
-            };
-            const { agent, project, epic, profile, provider, options, configEnv } = await this.resolveLaunchTarget({
-                agentId: lockedSource.agent_id,
-                projectId,
-                epicId: lockedSource.epic_id,
-            });
-            this.verifyProviderBinary(provider);
-            if (lockedSource.provider_name_at_launch &&
-                provider.name.toLowerCase() !== lockedSource.provider_name_at_launch.toLowerCase()) {
-                throw new common_1.ConflictException({
-                    message: 'Current provider differs from launch-time provider',
-                    code: 'PROVIDER_MISMATCH',
-                });
-            }
-            let optionArgs = [];
-            try {
-                optionArgs = (0, profile_options_1.parseProfileOptions)(options);
-            }
-            catch (error) {
-                if (error instanceof profile_options_1.ProfileOptionsError) {
-                    throw new error_types_1.ValidationError(error.message, {
-                        profileId: profile.id,
-                        profileName: profile.name,
-                    });
-                }
-                throw error;
-            }
-            if (agent.modelOverride) {
-                optionArgs = (0, profile_options_1.injectModelOverride)(optionArgs, agent.modelOverride);
-            }
-            const projectSlug = project.name
-                .toLowerCase()
-                .replace(/[^a-z0-9]+/g, '-')
-                .replace(/(^-|-$)/g, '');
-            const epicSegment = lockedSource.epic_id ?? 'independent';
-            const tmuxSessionName = this.tmuxService.createSessionName(projectSlug, epicSegment, agent.id, lockedSource.id);
-            const { envVars, processedOptionArgs } = this.composeLaunchEnv({
-                sessionId: lockedSource.id,
-                tmuxSessionName,
-                projectId,
-                agentId: agent.id,
-                provider,
-                configEnv,
-                optionArgs,
-            });
-            optionArgs = processedOptionArgs;
-            const adapter = this.providerAdapterFactory.getAdapter(provider.name);
-            const launchArgv = adapter.buildLaunchArgs({
-                mode: 'restore',
-                providerSessionId: lockedSource.provider_session_id,
-                profileOptionArgs: optionArgs,
-            }).argv;
-            if (!launchArgv.includes(lockedSource.provider_session_id)) {
-                throw new error_types_1.ValidationError('Restore argv does not include provider session ID — adapter contract violation', {
-                    code: 'RESTORE_ARGS_UNAVAILABLE',
-                    providerName: provider.name,
-                    providerSessionId: lockedSource.provider_session_id,
-                });
-            }
-            let commandArgs;
-            try {
-                commandArgs = (0, env_builder_1.buildSessionCommand)(envVars, provider.binPath, launchArgv);
-            }
-            catch (error) {
-                if (error instanceof env_builder_1.EnvBuilderError) {
-                    throw new error_types_1.ValidationError(error.message, {
-                        agentId: agent.id,
-                        providerConfigId: agent.providerConfigId,
-                    });
-                }
-                throw error;
-            }
-            const now = new Date().toISOString();
-            this.sqlite
-                .prepare(`UPDATE sessions
-           SET status = 'running', tmux_session_id = ?, ended_at = NULL,
-               last_activity_at = ?, updated_at = ?
-           WHERE id = ?`)
-                .run(tmuxSessionName, now, now, lockedSource.id);
-            try {
-                await this.tmuxService.createSession(tmuxSessionName, project.rootPath);
-            }
-            catch (tmuxError) {
-                this.sqlite
-                    .prepare(`UPDATE sessions
-             SET status = ?, ended_at = ?, tmux_session_id = ?, updated_at = ?
-             WHERE id = ?`)
-                    .run(prior.status, prior.ended_at, prior.tmux_session_id, now, lockedSource.id);
-                logger.error({ sessionId: lockedSource.id, error: String(tmuxError) }, 'Restore failed: tmux creation error — rolled back');
-                throw new common_1.InternalServerErrorException('RESTORE_FAILED');
-            }
-            await this.tmuxService.setAlternateScreenOff(tmuxSessionName);
-            this.tmuxService.startHealthCheck(tmuxSessionName, lockedSource.id);
-            try {
-                await this.tmuxService.sendCommandArgs(tmuxSessionName, commandArgs);
-            }
-            catch (sendError) {
-                this.sqlite
-                    .prepare(`UPDATE sessions
-             SET status = ?, ended_at = ?, tmux_session_id = ?, updated_at = ?
-             WHERE id = ?`)
-                    .run(prior.status, prior.ended_at, prior.tmux_session_id, now, lockedSource.id);
-                try {
-                    await this.tmuxService.destroySession(tmuxSessionName);
-                }
-                catch (destroyErr) {
-                    logger.warn({ tmuxSessionName, error: String(destroyErr) }, 'Failed to destroy tmux session during restore rollback');
-                }
-                logger.error({ sessionId: lockedSource.id, error: String(sendError) }, 'Restore failed: CLI launch error — rolled back');
-                throw new common_1.InternalServerErrorException('RESTORE_FAILED');
-            }
-            await this.ptyService.startStreaming(lockedSource.id, tmuxSessionName);
-            await this.getEventsService().publish('session.restored', {
-                sessionId: lockedSource.id,
-                epicId: lockedSource.epic_id,
-                agentId: agent.id,
-                tmuxSessionName,
-            });
-            if (lockedSource.transcript_path) {
-                await this.getEventsService().publish('session.transcript.discovered', {
-                    sessionId: lockedSource.id,
-                    agentId: agent.id,
-                    projectId,
-                    transcriptPath: lockedSource.transcript_path,
-                    providerName: provider.name.toLowerCase(),
-                });
-            }
-            try {
-                this.getTerminalGateway().broadcastEvent(`agent/${agent.id}`, 'presence', {
-                    online: true,
-                    sessionId: lockedSource.id,
-                    agentId: agent.id,
-                });
-            }
-            catch (error) {
-                logger.warn({ error, agentId: agent.id }, 'Failed to broadcast presence after restore');
-            }
-            return {
-                id: lockedSource.id,
-                epicId: lockedSource.epic_id,
-                agentId: agent.id,
-                tmuxSessionId: tmuxSessionName,
-                status: 'running',
-                startedAt: lockedSource.started_at,
-                endedAt: null,
-                transcriptPath: lockedSource.transcript_path,
-                createdAt: lockedSource.created_at,
-                updatedAt: now,
-                epic: epic ? { id: epic.id, title: epic.title, projectId: epic.projectId } : null,
-                agent: { id: agent.id, name: agent.name, profileId: agent.profileId },
-                project: { id: project.id, name: project.name, rootPath: project.rootPath },
-            };
-        });
-    }
     async terminateSession(sessionId) {
         logger.info({ sessionId }, 'Terminating session');
         const session = this.getSession(sessionId);
@@ -742,10 +62,11 @@ let SessionsService = class SessionsService {
             return;
         }
         this.ptyService.stopStreaming(sessionId);
+        this.terminalSessionRegistry.dispose(sessionId);
         if (session.tmuxSessionId) {
-            const sessionExists = await this.tmuxService.hasSession(session.tmuxSessionId);
+            const sessionExists = await this.terminalIO.sessionExists({ name: session.tmuxSessionId });
             if (sessionExists) {
-                await this.tmuxService.destroySession(session.tmuxSessionId);
+                await this.terminalIO.destroySession({ name: session.tmuxSessionId });
             }
             else {
                 logger.warn({ sessionId, tmuxSessionId: session.tmuxSessionId }, 'Tmux session already gone, cleaning up database record');
@@ -770,13 +91,13 @@ let SessionsService = class SessionsService {
     `)
             .run('stopped', now, sizeBytes, now, sessionId);
         logger.info({ sessionId }, 'Session terminated');
-        await this.getEventsService().publish('session.stopped', { sessionId });
+        await this.eventsService.publish('session.stopped', { sessionId });
         if (session.agentId) {
             try {
-                this.getTerminalGateway().broadcastEvent(`agent/${session.agentId}`, 'presence', {
+                await this.eventsService.publish('session.presence.changed', {
+                    agentId: session.agentId,
                     online: false,
                     sessionId: null,
-                    agentId: session.agentId,
                 });
             }
             catch (error) {
@@ -791,7 +112,7 @@ let SessionsService = class SessionsService {
         }
         const clampedLimit = Math.min(Math.max(1, limit), 100);
         const sortExpr = `COALESCE(last_activity_at, ended_at, started_at)`;
-        const selectCols = `id, provider_session_id, provider_name_at_launch, status, started_at, ended_at, last_activity_at, size_bytes, transcript_path`;
+        const selectCols = `id, provider_session_id, provider_name_at_launch, status, started_at, ended_at, last_activity_at, size_bytes, transcript_path, name`;
         const baseStatus = `status IN ('stopped','failed')`;
         const { cnt: total } = this.sqlite
             .prepare(`SELECT COUNT(*) as cnt FROM sessions WHERE agent_id = ? AND ${baseStatus}`)
@@ -857,13 +178,53 @@ let SessionsService = class SessionsService {
             lastActivityAt: row.last_activity_at,
             sizeBytes: row.size_bytes,
             transcriptAvailable: row.transcript_path !== null,
+            name: row.name ?? null,
         }));
         return { items, nextCursor, hasMore, total };
     }
+    lookupRunningSessionMeta(sessionId) {
+        const row = this.sqlite
+            .prepare(`SELECT tmux_session_id, provider_name_at_launch
+         FROM sessions
+         WHERE id = ? AND status = 'running'`)
+            .get(sessionId);
+        if (!row || !row.tmux_session_id || !row.provider_name_at_launch)
+            return null;
+        return {
+            tmuxSessionName: row.tmux_session_id,
+            providerName: row.provider_name_at_launch,
+        };
+    }
+    shouldNormalizeLfFor(sessionId) {
+        const meta = this.lookupRunningSessionMeta(sessionId);
+        if (!meta)
+            return true;
+        try {
+            const adapter = this.providerAdapterFactory.getAdapter(meta.providerName);
+            return !adapter.terminalOutputBehavior?.rawLineEndings;
+        }
+        catch {
+            return true;
+        }
+    }
+    listRunningSessionMetas() {
+        const rows = this.sqlite
+            .prepare(`SELECT id, tmux_session_id, provider_name_at_launch
+         FROM sessions
+         WHERE status = 'running'`)
+            .all();
+        return rows
+            .filter((r) => r.tmux_session_id && r.provider_name_at_launch)
+            .map((r) => ({
+            sessionId: r.id,
+            tmuxSessionName: r.tmux_session_id,
+            providerName: r.provider_name_at_launch,
+        }));
+    }
     getSession(sessionId) {
         const row = this.sqlite
             .prepare(`
-      SELECT id, epic_id, agent_id, tmux_session_id, status, started_at, ended_at, last_activity_at, activity_state, busy_since, transcript_path, created_at, updated_at
+      SELECT id, epic_id, agent_id, tmux_session_id, status, started_at, ended_at, last_activity_at, activity_state, busy_since, transcript_path, name, created_at, updated_at
       FROM sessions
       WHERE id = ?
     `)
@@ -884,6 +245,7 @@ let SessionsService = class SessionsService {
             activityState: row.activity_state ?? null,
             busySince: row.busy_since ?? null,
             transcriptPath: row.transcript_path ?? null,
+            name: row.name ?? null,
             createdAt: row.created_at,
             updatedAt: row.updated_at,
         };
@@ -891,7 +253,7 @@ let SessionsService = class SessionsService {
     async listActiveSessions(projectId, allowedAgentIds) {
         const rows = this.sqlite
             .prepare(`
-      SELECT id, epic_id, agent_id, tmux_session_id, status, started_at, ended_at, last_activity_at, activity_state, busy_since, transcript_path, created_at, updated_at
+      SELECT id, epic_id, agent_id, tmux_session_id, status, started_at, ended_at, last_activity_at, activity_state, busy_since, transcript_path, name, created_at, updated_at
       FROM sessions
       WHERE status = 'running'
       ORDER BY started_at DESC
@@ -900,7 +262,7 @@ let SessionsService = class SessionsService {
         const now = new Date().toISOString();
         for (const row of rows) {
             if (row.tmux_session_id) {
-                const exists = await this.tmuxService.hasSession(row.tmux_session_id);
+                const exists = await this.terminalIO.sessionExists({ name: row.tmux_session_id });
                 if (!exists) {
                     logger.warn({ sessionId: row.id, tmuxSessionId: row.tmux_session_id }, 'Detected orphaned session, marking as stopped');
                     this.sqlite
@@ -929,6 +291,7 @@ let SessionsService = class SessionsService {
             activityState: row.activity_state ?? null,
             busySince: row.busy_since ?? null,
             transcriptPath: row.transcript_path ?? null,
+            name: row.name ?? null,
             createdAt: row.created_at,
             updatedAt: row.updated_at,
         }));
@@ -947,7 +310,7 @@ let SessionsService = class SessionsService {
             .prepare(`
         SELECT id, epic_id, agent_id, tmux_session_id, status,
                started_at, ended_at, last_activity_at, activity_state,
-               busy_since, transcript_path,
+               busy_since, transcript_path, name,
                created_at, updated_at
         FROM sessions
         WHERE status = 'running' AND agent_id = ?
@@ -970,6 +333,7 @@ let SessionsService = class SessionsService {
             activityState: row.activity_state ?? null,
             busySince: row.busy_since ?? null,
             transcriptPath: row.transcript_path ?? null,
+            name: row.name ?? null,
             createdAt: row.created_at,
             updatedAt: row.updated_at,
         };
@@ -979,7 +343,7 @@ let SessionsService = class SessionsService {
             .prepare(`
         SELECT s.id, s.epic_id, s.agent_id, s.tmux_session_id, s.status,
                s.started_at, s.ended_at, s.last_activity_at, s.activity_state,
-               s.busy_since, s.transcript_path,
+               s.busy_since, s.transcript_path, s.name,
                s.created_at, s.updated_at
         FROM sessions s
         JOIN agents a ON s.agent_id = a.id
@@ -999,10 +363,18 @@ let SessionsService = class SessionsService {
             activityState: row.activity_state ?? null,
             busySince: row.busy_since ?? null,
             transcriptPath: row.transcript_path ?? null,
+            name: row.name ?? null,
             createdAt: row.created_at,
             updatedAt: row.updated_at,
         }));
     }
+    markSessionFailed(sessionId, reason) {
+        logger.warn({ sessionId, reason }, 'Marking session as failed due to dead tmux');
+        const now = new Date().toISOString();
+        this.sqlite
+            .prepare(`UPDATE sessions SET status = 'failed', ended_at = ?, updated_at = ? WHERE id = ? AND status = 'running'`)
+            .run(now, now, sessionId);
+    }
     async getAgentPresence(projectId) {
         let allowedAgentIds;
         if (projectId) {
@@ -1010,15 +382,20 @@ let SessionsService = class SessionsService {
             allowedAgentIds = new Set(agents.items.map((agent) => agent.id));
         }
         const activeSessions = await this.listActiveSessions(projectId, allowedAgentIds);
+        const sessionAgentMappings = activeSessions
+            .filter((s) => s.agentId)
+            .map((s) => ({ sessionId: s.id, agentId: s.agentId }));
+        const aggregated = (0, agent_presence_aggregator_1.aggregatePresence)(this.terminalSessionRegistry, sessionAgentMappings, allowedAgentIds);
         const presenceMap = new Map();
         for (const session of activeSessions) {
             if (session.agentId) {
+                const agg = aggregated.get(session.agentId);
                 presenceMap.set(session.agentId, {
                     online: true,
                     sessionId: session.id,
-                    activityState: session.activityState ?? null,
-                    lastActivityAt: session.lastActivityAt ?? null,
-                    busySince: session.busySince ?? null,
+                    activityState: agg?.activityState ?? session.activityState ?? null,
+                    lastActivityAt: agg?.lastActivityAt ?? session.lastActivityAt ?? null,
+                    busySince: agg?.busySince ?? session.busySince ?? null,
                     currentActivityTitle: this.getCurrentActivityTitle(session.agentId, projectId),
                 });
             }
@@ -1047,6 +424,40 @@ let SessionsService = class SessionsService {
                 .get(agentId);
         return row?.title ?? null;
     }
+    updateName(sessionId, name) {
+        const trimmed = name?.trim() || null;
+        if (trimmed !== null && trimmed.length > 120) {
+            throw new error_types_1.ValidationError('Session name must be 120 characters or fewer', {
+                sessionId,
+                length: trimmed.length,
+            });
+        }
+        const now = new Date().toISOString();
+        const result = this.sqlite
+            .prepare(`UPDATE sessions SET name = ?, updated_at = ? WHERE id = ?`)
+            .run(trimmed, now, sessionId);
+        if (result.changes === 0) {
+            throw new error_types_1.NotFoundError('Session', sessionId);
+        }
+        const updated = this.getSession(sessionId);
+        if (!updated) {
+            throw new error_types_1.NotFoundError('Session', sessionId);
+        }
+        return updated;
+    }
+    hardDeleteRecord(sessionId) {
+        const session = this.getSession(sessionId);
+        if (session?.status === 'running') {
+            throw new error_types_1.ValidationError('Cannot delete a running session', { sessionId });
+        }
+        return this.txRunner.runImmediate(() => {
+            this.sqlite
+                .prepare('DELETE FROM chat_thread_session_invites WHERE session_id = ?')
+                .run(sessionId);
+            const result = this.sqlite.prepare('DELETE FROM sessions WHERE id = ?').run(sessionId);
+            return { deleted: result.changes > 0 };
+        });
+    }
     async injectTextIntoSession(sessionId, text) {
         const session = this.getSession(sessionId);
         if (!session) {
@@ -1068,156 +479,39 @@ let SessionsService = class SessionsService {
         const postPasteDelayMs = agentId
             ? await this.providerAdapterFactory.getPostPasteDelayMsForAgent(agentId)
             : undefined;
-        const result = await (0, confirmed_delivery_helper_1.deliverWithConfirmation)(this.tmuxService, this.sendCoordinator, {
-            tmuxSessionId: session.tmuxSessionId,
-            text,
-            submitKeys: ['Enter'],
+        if (!agentId) {
+            const result = await this.terminalIO.deliverImmediate({ name: session.tmuxSessionId }, text, {
+                submitKeys: ['Enter'],
+                postPasteDelayMs,
+            });
+            return { confirmed: result.confirmed, method: result.method };
+        }
+        const result = await this.terminalIO.deliver({ name: session.tmuxSessionId }, text, {
             agentId,
+            submitKeys: ['Enter'],
             postPasteDelayMs,
         });
         return { confirmed: result.confirmed, method: result.method };
     }
-    async renderAndPasteInitialPrompt(params) {
-        const { sessionId, tmuxSessionName, agentId, project, agent, epic, profile, provider, launchHandshake, } = params;
-        const teams = await this.loadTeamsForAgentOrEmpty(agentId);
-        const context = (0, template_renderer_1.buildInitialPromptContext)({
-            agent: { name: agent.name, id: agentId },
-            project,
-            epic,
-            profile,
-            provider,
-            sessionId,
-            teams,
-        });
-        const defaultRendered = this.normalizeInitialPromptContent((0, template_renderer_1.renderInitialPromptTemplate)(DEFAULT_INITIAL_PROMPT_TEMPLATE, context));
-        let promptTitle;
-        let rendered = defaultRendered;
-        let initialPrompt = null;
-        try {
-            const viaStorage = await this.storage.getInitialSessionPrompt(project.id);
-            if (viaStorage) {
-                initialPrompt = {
-                    id: viaStorage.id,
-                    title: viaStorage.title,
-                    content: viaStorage.content,
-                };
-                logger.debug({ sessionId, promptId: viaStorage.id, source: 'storage.getInitialSessionPrompt' }, 'Resolved initial session prompt via storage');
-            }
-        }
-        catch (error) {
-            logger.warn({ error }, 'Storage getInitialSessionPrompt failed; will try raw settings fallback');
-        }
-        if (!initialPrompt) {
-            logger.debug({ sessionId, source: 'storage.getInitialSessionPrompt' }, 'No initial session prompt resolved via storage');
-        }
-        if (initialPrompt?.content) {
-            promptTitle = initialPrompt.title;
-            const candidate = this.normalizeInitialPromptContent((0, template_renderer_1.renderInitialPromptTemplate)(initialPrompt.content, context));
-            if (candidate) {
-                rendered = candidate;
-            }
-            else {
-                logger.warn({ sessionId, promptId: initialPrompt.id }, 'Initial session prompt rendered to empty content; using default template');
-            }
-        }
-        if (!this.isInitialPromptWithinLimits(rendered)) {
-            logger.warn({
-                sessionId,
-                length: rendered.length,
-                lines: this.countInitialPromptLines(rendered),
-            }, 'Initial session prompt exceeded limits; falling back to default template');
-            rendered = defaultRendered;
-            promptTitle = undefined;
-        }
-        if (!promptTitle) {
-            logger.debug({ sessionId, source: 'default_template' }, 'Using default initial session prompt');
-        }
-        await this.sendCoordinator.ensureAgentGap(agentId, 1000);
-        await this.tmuxService.pasteAndSubmit(tmuxSessionName, rendered, {
-            bracketed: true,
-            submitKeys: ['Enter'],
-            delayMs: 250,
-            preKeys: launchHandshake?.preKeys,
-            preDelayMs: launchHandshake?.preDelayMs,
-        });
-        logger.debug({
-            sessionId,
-            provider: provider.name,
-            submitKeys: ['Enter'],
-            bracketedPaste: true,
-            preKeys: launchHandshake?.preKeys,
-            preDelayMs: launchHandshake?.preDelayMs,
-        }, 'Submitted initial prompt');
-        logger.info({ sessionId, promptTitle }, 'Initial session prompt pasted');
-    }
-    normalizeInitialPromptContent(content) {
-        if (!content) {
-            return '';
-        }
-        return content.replace(/\r\n/g, '\n').trimEnd();
-    }
-    countInitialPromptLines(content) {
-        if (!content) {
-            return 0;
-        }
-        return content.split('\n').length;
-    }
-    isInitialPromptWithinLimits(content) {
-        return (content.length <= MAX_INITIAL_PROMPT_LENGTH &&
-            this.countInitialPromptLines(content) <= MAX_INITIAL_PROMPT_LINES);
-    }
-    getTerminalGateway() {
-        if (!this.terminalGatewayRef) {
-            this.terminalGatewayRef = this.moduleRef.get(terminal_gateway_1.TerminalGateway, { strict: false });
-            if (!this.terminalGatewayRef) {
-                throw new Error('TerminalGateway is not available in the current module context');
-            }
-        }
-        return this.terminalGatewayRef;
-    }
-    getEventsService() {
-        if (!this.eventsServiceRef) {
-            this.eventsServiceRef = this.moduleRef.get(events_service_1.EventsService, { strict: false });
-            if (!this.eventsServiceRef) {
-                throw new Error('EventsService is not available in the current module context');
-            }
-        }
-        return this.eventsServiceRef;
-    }
-    async loadTeamsForAgentOrEmpty(agentId) {
-        if (!agentId)
-            return [];
-        try {
-            const teamsService = this.moduleRef.get(teams_service_1.TeamsService, { strict: false });
-            if (!teamsService || typeof teamsService.listTeamsByAgent !== 'function') {
-                return [];
-            }
-            return await teamsService.listTeamsByAgent(agentId);
-        }
-        catch (error) {
-            logger.warn({ error, agentId }, 'Failed to load teams for initial prompt; defaulting to teamless context');
-            return [];
-        }
-    }
 };
 exports.SessionsService = SessionsService;
 exports.SessionsService = SessionsService = __decorate([
     (0, common_1.Injectable)(),
     __param(0, (0, common_1.Inject)(db_provider_1.DB_CONNECTION)),
     __param(1, (0, common_1.Inject)(storage_interface_1.STORAGE_SERVICE)),
-    __param(2, (0, common_1.Inject)((0, common_1.forwardRef)(() => tmux_service_1.TmuxService))),
-    __param(3, (0, common_1.Inject)((0, common_1.forwardRef)(() => terminal_send_coordinator_service_1.TerminalSendCoordinatorService))),
-    __param(4, (0, common_1.Inject)((0, common_1.forwardRef)(() => pty_service_1.PtyService))),
-    __param(5, (0, common_1.Inject)((0, common_1.forwardRef)(() => preflight_service_1.PreflightService))),
-    __param(6, (0, common_1.Inject)((0, common_1.forwardRef)(() => provider_mcp_ensure_service_1.ProviderMcpEnsureService))),
-    __metadata("design:paramtypes", [better_sqlite3_1.BetterSQLite3Database, Object, tmux_service_1.TmuxService,
-        terminal_send_coordinator_service_1.TerminalSendCoordinatorService,
+    __param(2, (0, common_1.Inject)((0, common_1.forwardRef)(() => terminal_io_service_1.TerminalIOService))),
+    __param(3, (0, common_1.Inject)((0, common_1.forwardRef)(() => pty_service_1.PtyService))),
+    __param(4, (0, common_1.Inject)((0, common_1.forwardRef)(() => preflight_service_1.PreflightService))),
+    __param(9, (0, common_1.Inject)((0, common_1.forwardRef)(() => events_service_1.EventsService))),
+    __param(10, (0, common_1.Inject)((0, common_1.forwardRef)(() => terminal_session_registry_1.TerminalSessionRegistry))),
+    __metadata("design:paramtypes", [better_sqlite3_1.BetterSQLite3Database, Object, terminal_io_service_1.TerminalIOService,
         pty_service_1.PtyService,
         preflight_service_1.PreflightService,
         provider_mcp_ensure_service_1.ProviderMcpEnsureService,
         session_coordinator_service_1.SessionCoordinatorService,
         hooks_config_service_1.HooksConfigService,
         provider_adapter_factory_1.ProviderAdapterFactory,
-        core_1.ModuleRef])
+        events_service_1.EventsService,
+        terminal_session_registry_1.TerminalSessionRegistry])
 ], SessionsService);
 //# sourceMappingURL=sessions.service.js.map