@deadragdoll/tellymcp 0.0.9 → 0.0.11

package/dist/services/features/telegram-mcp/src/features/session-context/model/sessionContextService.js

@@ -1,20 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SessionContextService = void 0;
+const ptyRegistry_1 = require("../../../shared/integrations/terminal/ptyRegistry");
 const redactSecrets_1 = require("../../../shared/lib/redact-secrets/redactSecrets");
 class SessionContextService {
     sessionStore;
     bindingStore;
     logger;
     projectIdentityResolver;
-    constructor(sessionStore, bindingStore, logger, projectIdentityResolver) {
+    remoteConsoleInvoker;
+    constructor(sessionStore, bindingStore, logger, projectIdentityResolver, remoteConsoleInvoker) {
         this.sessionStore = sessionStore;
         this.bindingStore = bindingStore;
         this.logger = logger;
         this.projectIdentityResolver = projectIdentityResolver;
+        this.remoteConsoleInvoker = remoteConsoleInvoker;
     }
     async setContext(input) {
         const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const remote = await this.remoteConsoleInvoker?.invokeForRelaySession(resolved.sessionId, "telegramMcp.sessionContext.setContextRemote", input);
+        if (remote) {
+            return remote;
+        }
         const updatedAt = new Date().toISOString();
         const existing = await this.sessionStore.getSession(resolved.sessionId);
         const binding = await this.bindingStore.getBinding(resolved.sessionId);
@@ -28,9 +35,6 @@ class SessionContextService {
                         ? { label: existing.label }
                         : {}),
             ...(existing?.cwd ? { cwd: existing.cwd } : { cwd: resolved.cwd }),
-            ...(existing?.linkedSessionId
-                ? { linkedSessionId: existing.linkedSessionId }
-                : {}),
             ...(existing?.activeProjectUuid
                 ? { activeProjectUuid: existing.activeProjectUuid }
                 : {}),
@@ -58,22 +62,9 @@ class SessionContextService {
                 : existing?.risks
                     ? { risks: existing.risks }
                     : {}),
-            ...(existing?.tmuxSessionName
-                ? { tmuxSessionName: existing.tmuxSessionName }
-                : {}),
-            ...(existing?.tmuxWindowName
-                ? { tmuxWindowName: existing.tmuxWindowName }
-                : {}),
-            ...(typeof existing?.tmuxWindowIndex === "number"
-                ? { tmuxWindowIndex: existing.tmuxWindowIndex }
-                : {}),
-            ...(existing?.tmuxPaneId ? { tmuxPaneId: existing.tmuxPaneId } : {}),
-            ...(typeof existing?.tmuxPaneIndex === "number"
-                ? { tmuxPaneIndex: existing.tmuxPaneIndex }
-                : {}),
-            ...(existing?.tmuxTarget ? { tmuxTarget: existing.tmuxTarget } : {}),
-            ...(existing?.lastTmuxNudgeAt
-                ? { lastTmuxNudgeAt: existing.lastTmuxNudgeAt }
+            ...(existing?.terminalTarget ? { terminalTarget: existing.terminalTarget } : {}),
+            ...(existing?.lastTerminalNudgeAt
+                ? { lastTerminalNudgeAt: existing.lastTerminalNudgeAt }
                 : {}),
             ...(existing?.lastSeenToolsHash
                 ? { lastSeenToolsHash: existing.lastSeenToolsHash }
@@ -107,6 +98,10 @@ class SessionContextService {
     }
     async renameSession(input) {
         const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const remote = await this.remoteConsoleInvoker?.invokeForRelaySession(resolved.sessionId, "telegramMcp.sessionContext.renameSessionRemote", input);
+        if (remote) {
+            return remote;
+        }
         const existing = await this.sessionStore.getSession(resolved.sessionId);
         const updatedAt = new Date().toISOString();
         const label = (0, redactSecrets_1.redactSecrets)(input.title);
@@ -114,9 +109,6 @@ class SessionContextService {
             sessionId: resolved.sessionId,
             label,
             ...(existing?.cwd ? { cwd: existing.cwd } : { cwd: resolved.cwd }),
-            ...(existing?.linkedSessionId
-                ? { linkedSessionId: existing.linkedSessionId }
-                : {}),
             ...(existing?.activeProjectUuid
                 ? { activeProjectUuid: existing.activeProjectUuid }
                 : {}),
@@ -128,22 +120,9 @@ class SessionContextService {
             ...(existing?.files ? { files: existing.files } : {}),
             ...(existing?.decisions ? { decisions: existing.decisions } : {}),
             ...(existing?.risks ? { risks: existing.risks } : {}),
-            ...(existing?.tmuxSessionName
-                ? { tmuxSessionName: existing.tmuxSessionName }
-                : {}),
-            ...(existing?.tmuxWindowName
-                ? { tmuxWindowName: existing.tmuxWindowName }
-                : {}),
-            ...(typeof existing?.tmuxWindowIndex === "number"
-                ? { tmuxWindowIndex: existing.tmuxWindowIndex }
-                : {}),
-            ...(existing?.tmuxPaneId ? { tmuxPaneId: existing.tmuxPaneId } : {}),
-            ...(typeof existing?.tmuxPaneIndex === "number"
-                ? { tmuxPaneIndex: existing.tmuxPaneIndex }
-                : {}),
-            ...(existing?.tmuxTarget ? { tmuxTarget: existing.tmuxTarget } : {}),
-            ...(existing?.lastTmuxNudgeAt
-                ? { lastTmuxNudgeAt: existing.lastTmuxNudgeAt }
+            ...(existing?.terminalTarget ? { terminalTarget: existing.terminalTarget } : {}),
+            ...(existing?.lastTerminalNudgeAt
+                ? { lastTerminalNudgeAt: existing.lastTerminalNudgeAt }
                 : {}),
             ...(existing?.lastSeenToolsHash
                 ? { lastSeenToolsHash: existing.lastSeenToolsHash }
@@ -172,11 +151,12 @@ class SessionContextService {
     }
     async getContext(input) {
         const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const remote = await this.remoteConsoleInvoker?.invokeForRelaySession(resolved.sessionId, "telegramMcp.sessionContext.getContextRemote", input);
+        if (remote) {
+            return remote;
+        }
         const session = await this.sessionStore.getSession(resolved.sessionId);
         const binding = await this.bindingStore.getBinding(resolved.sessionId);
-        const linkedSession = session?.linkedSessionId
-            ? await this.sessionStore.getSession(session.linkedSessionId)
-            : null;
         this.logger.debug("Session context requested", {
             sessionId: resolved.sessionId,
             sessionIdDerived: resolved.sessionIdDerived,
@@ -184,12 +164,12 @@ class SessionContextService {
             hasBinding: Boolean(binding),
         });
         const statusMessage = binding
-            ? session?.tmuxTarget
-                ? "Telegram pairing is active for this session. A tmux target is configured, so ordinary Telegram messages can wake the agent through tmux nudges."
-                : "Telegram pairing is active for this session. No tmux target is configured, so inbox handling requires passive MCP checks."
+            ? session?.terminalTarget
+                ? "Gateway console binding is active for this session. A terminal target is configured, so ordinary Telegram messages can wake the agent through terminal nudges."
+                : "Gateway console binding is active for this session. No terminal target is configured, so inbox handling requires passive MCP checks."
             : session
-                ? "Session metadata exists, but Telegram pairing is not active."
-                : "Session metadata and Telegram pairing are both absent.";
+                ? "Session metadata exists, but no gateway console binding is active."
+                : "Session metadata and gateway console binding are both absent.";
         return {
             session_id: resolved.sessionId,
             exists: Boolean(session),
@@ -200,12 +180,6 @@ class SessionContextService {
                     context: {
                         ...(session.label ? { session_label: session.label } : {}),
                         ...(session.cwd ? { cwd: session.cwd } : {}),
-                        ...(session.linkedSessionId
-                            ? { linked_session_id: session.linkedSessionId }
-                            : {}),
-                        ...(linkedSession?.label
-                            ? { linked_session_label: linkedSession.label }
-                            : {}),
                         ...(session.activeProjectUuid
                             ? { active_project_uuid: session.activeProjectUuid }
                             : {}),
@@ -235,28 +209,13 @@ class SessionContextService {
                 : {}),
             ...(session
                 ? {
-                    tmux: {
-                        configured: Boolean(session.tmuxTarget),
-                        ...(session.tmuxSessionName
-                            ? { tmux_session_name: session.tmuxSessionName }
-                            : {}),
-                        ...(session.tmuxWindowName
-                            ? { tmux_window_name: session.tmuxWindowName }
-                            : {}),
-                        ...(typeof session.tmuxWindowIndex === "number"
-                            ? { tmux_window_index: session.tmuxWindowIndex }
-                            : {}),
-                        ...(session.tmuxPaneId
-                            ? { tmux_pane_id: session.tmuxPaneId }
+                    terminal: {
+                        configured: Boolean(session.terminalTarget),
+                        ...(session.terminalTarget
+                            ? { terminal_target: session.terminalTarget }
                             : {}),
-                        ...(typeof session.tmuxPaneIndex === "number"
-                            ? { tmux_pane_index: session.tmuxPaneIndex }
-                            : {}),
-                        ...(session.tmuxTarget
-                            ? { tmux_target: session.tmuxTarget }
-                            : {}),
-                        ...(session.lastTmuxNudgeAt
-                            ? { last_nudge_at: session.lastTmuxNudgeAt }
+                        ...(session.lastTerminalNudgeAt
+                            ? { last_nudge_at: session.lastTerminalNudgeAt }
                             : {}),
                     },
                 }
@@ -265,14 +224,22 @@ class SessionContextService {
     }
     async clearContext(input) {
         const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const remote = await this.remoteConsoleInvoker?.invokeForRelaySession(resolved.sessionId, "telegramMcp.sessionContext.clearContextRemote", input);
+        if (remote) {
+            return remote;
+        }
         const existing = await this.sessionStore.getSession(resolved.sessionId);
+        const existingTarget = existing?.terminalTarget;
+        if (existingTarget && (0, ptyRegistry_1.isPtyTarget)(existingTarget)) {
+            (0, ptyRegistry_1.stopPtyTarget)(existingTarget);
+        }
         await this.sessionStore.clearSession(resolved.sessionId);
         await this.bindingStore.clearBinding(resolved.sessionId);
         this.projectIdentityResolver.removeSessionMarker(existing?.cwd || resolved.cwd);
         this.logger.info("Session context cleared", {
             sessionId: resolved.sessionId,
             sessionIdDerived: resolved.sessionIdDerived,
-            clearedPairing: true,
+            clearedTelegramRoute: true,
         });
         return {
             cleared: true,
@@ -280,130 +247,5 @@ class SessionContextService {
             cleared_pairing: true,
         };
     }
-    async setTmuxTarget(input) {
-        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
-        const existing = await this.sessionStore.getSession(resolved.sessionId);
-        const updatedAt = new Date().toISOString();
-        const sanitizedTarget = (0, redactSecrets_1.redactSecrets)(input.tmux_target);
-        const sanitizedSessionName = input.tmux_session_name
-            ? (0, redactSecrets_1.redactSecrets)(input.tmux_session_name)
-            : existing?.tmuxSessionName;
-        const sanitizedWindowName = input.tmux_window_name
-            ? (0, redactSecrets_1.redactSecrets)(input.tmux_window_name)
-            : existing?.tmuxWindowName;
-        const sanitizedPaneId = input.tmux_pane_id
-            ? (0, redactSecrets_1.redactSecrets)(input.tmux_pane_id)
-            : existing?.tmuxPaneId;
-        await this.sessionStore.setSession({
-            sessionId: resolved.sessionId,
-            ...(existing?.label
-                ? { label: existing.label }
-                : resolved.sessionLabel
-                    ? { label: (0, redactSecrets_1.redactSecrets)(resolved.sessionLabel) }
-                    : {}),
-            ...(existing?.cwd ? { cwd: existing.cwd } : { cwd: resolved.cwd }),
-            ...(existing?.linkedSessionId
-                ? { linkedSessionId: existing.linkedSessionId }
-                : {}),
-            ...(existing?.activeProjectUuid
-                ? { activeProjectUuid: existing.activeProjectUuid }
-                : {}),
-            ...(existing?.activeProjectName
-                ? { activeProjectName: existing.activeProjectName }
-                : {}),
-            ...(existing?.task ? { task: existing.task } : {}),
-            ...(existing?.summary ? { summary: existing.summary } : {}),
-            ...(existing?.files ? { files: existing.files } : {}),
-            ...(existing?.decisions ? { decisions: existing.decisions } : {}),
-            ...(existing?.risks ? { risks: existing.risks } : {}),
-            ...(sanitizedSessionName
-                ? { tmuxSessionName: sanitizedSessionName }
-                : {}),
-            ...(sanitizedWindowName ? { tmuxWindowName: sanitizedWindowName } : {}),
-            ...(typeof input.tmux_window_index === "number"
-                ? { tmuxWindowIndex: input.tmux_window_index }
-                : typeof existing?.tmuxWindowIndex === "number"
-                    ? { tmuxWindowIndex: existing.tmuxWindowIndex }
-                    : {}),
-            ...(sanitizedPaneId ? { tmuxPaneId: sanitizedPaneId } : {}),
-            ...(typeof input.tmux_pane_index === "number"
-                ? { tmuxPaneIndex: input.tmux_pane_index }
-                : typeof existing?.tmuxPaneIndex === "number"
-                    ? { tmuxPaneIndex: existing.tmuxPaneIndex }
-                    : {}),
-            tmuxTarget: sanitizedTarget,
-            ...(existing?.lastTmuxNudgeAt
-                ? { lastTmuxNudgeAt: existing.lastTmuxNudgeAt }
-                : {}),
-            updatedAt,
-        });
-        this.projectIdentityResolver.persistSessionMarker({
-            cwd: resolved.cwd,
-            sessionId: resolved.sessionId,
-            sessionLabel: existing?.label || resolved.sessionLabel,
-        });
-        this.logger.info("Session tmux target saved", {
-            sessionId: resolved.sessionId,
-            sessionIdDerived: resolved.sessionIdDerived,
-            tmuxSessionName: sanitizedSessionName,
-            tmuxWindowName: sanitizedWindowName,
-            tmuxWindowIndex: input.tmux_window_index,
-            tmuxPaneId: sanitizedPaneId,
-            tmuxPaneIndex: input.tmux_pane_index,
-            tmuxTarget: sanitizedTarget,
-        });
-        return {
-            session_id: resolved.sessionId,
-            tmux_target: sanitizedTarget,
-            ...(sanitizedSessionName
-                ? { tmux_session_name: sanitizedSessionName }
-                : {}),
-            ...(sanitizedWindowName
-                ? { tmux_window_name: sanitizedWindowName }
-                : {}),
-            ...(typeof input.tmux_window_index === "number"
-                ? { tmux_window_index: input.tmux_window_index }
-                : {}),
-            ...(sanitizedPaneId ? { tmux_pane_id: sanitizedPaneId } : {}),
-            ...(typeof input.tmux_pane_index === "number"
-                ? { tmux_pane_index: input.tmux_pane_index }
-                : {}),
-            status_message: "tmux target saved for this session. For a paired session, the service can now nudge this tmux pane when a new non-reply Telegram message is stored in inbox.",
-        };
-    }
-    async getTmuxTarget(input) {
-        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
-        const session = await this.sessionStore.getSession(resolved.sessionId);
-        const configured = Boolean(session?.tmuxTarget);
-        this.logger.debug("Session tmux target requested", {
-            sessionId: resolved.sessionId,
-            sessionIdDerived: resolved.sessionIdDerived,
-            configured,
-        });
-        return {
-            session_id: resolved.sessionId,
-            configured,
-            ...(session?.tmuxTarget ? { tmux_target: session.tmuxTarget } : {}),
-            ...(session?.tmuxSessionName
-                ? { tmux_session_name: session.tmuxSessionName }
-                : {}),
-            ...(session?.tmuxWindowName
-                ? { tmux_window_name: session.tmuxWindowName }
-                : {}),
-            ...(typeof session?.tmuxWindowIndex === "number"
-                ? { tmux_window_index: session.tmuxWindowIndex }
-                : {}),
-            ...(session?.tmuxPaneId ? { tmux_pane_id: session.tmuxPaneId } : {}),
-            ...(typeof session?.tmuxPaneIndex === "number"
-                ? { tmux_pane_index: session.tmuxPaneIndex }
-                : {}),
-            ...(session?.lastTmuxNudgeAt
-                ? { last_nudge_at: session.lastTmuxNudgeAt }
-                : {}),
-            status_message: configured
-                ? "tmux target is configured for this session."
-                : "tmux target is not configured for this session.",
-        };
-    }
 }
 exports.SessionContextService = SessionContextService;

package/dist/services/features/telegram-mcp/src/features/session-context/model/setSessionContextTool.js

@@ -18,7 +18,7 @@ class SetSessionContextTool {
     register(server) {
         server.registerTool("set_session_context", {
             title: "Set Session Context",
-            description: "Save compact reusable context for the session: current task, summary, decisions, files, and risks. Use this to leave a short durable working state for later Telegram-driven continuation.",
+            description: "Save compact reusable context for the current console: current task, summary, decisions, files, and risks. Use this to leave a short durable working state for later gateway-routed continuation.",
             inputSchema: schema_1.setSessionContextInputSchema,
             outputSchema: schema_1.setSessionContextOutputSchema,
         }, async (args) => {

package/dist/services/features/telegram-mcp/src/features/terminal-buffer/model/terminalBufferService.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerminalBufferService = void 0;
+const relay_1 = require("../../../app/webapp/relay");
+const client_1 = require("../../../shared/integrations/terminal/client");
+const transportUtils_1 = require("../../../shared/integrations/telegram/transportUtils");
+class TerminalBufferService {
+    config;
+    sessionStore;
+    logger;
+    projectIdentityResolver;
+    remoteConsoleInvoker;
+    constructor(config, sessionStore, logger, projectIdentityResolver, remoteConsoleInvoker) {
+        this.config = config;
+        this.sessionStore = sessionStore;
+        this.logger = logger;
+        this.projectIdentityResolver = projectIdentityResolver;
+        this.remoteConsoleInvoker = remoteConsoleInvoker;
+    }
+    async captureBuffer(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const remote = await this.remoteConsoleInvoker?.invokeForRelaySession(resolved.sessionId, "telegramMcp.terminalBuffer.captureBufferRemote", input);
+        if (remote) {
+            return remote;
+        }
+        const session = await this.sessionStore.getSession(resolved.sessionId);
+        const target = session?.terminalTarget?.trim();
+        if (!target) {
+            throw new Error("terminal target is not configured for this session");
+        }
+        const paneStart = await this.resolveCaptureStart(target, input.scope);
+        const stdout = await (0, client_1.captureTerminalPaneRange)(this.config.terminal, target, paneStart, false);
+        const capturedAt = new Date().toISOString();
+        const scopeDescription = this.describeCaptureScope(input.scope);
+        const titleBase = session?.label ?? resolved.sessionLabel ?? resolved.sessionId;
+        const filenameBase = (0, transportUtils_1.slugifyFilenamePart)(titleBase) || "session-buffer";
+        const timestamp = capturedAt.replace(/[:.]/g, "-");
+        const filename = `${filenameBase}-${timestamp}.md`;
+        const markdownContent = [
+            "# Terminal Buffer",
+            "",
+            `- Session: ${session?.label ?? resolved.sessionLabel ?? resolved.sessionId}`,
+            `- Session ID: ${resolved.sessionId}`,
+            `- terminal target: ${target}`,
+            `- Capture scope: ${scopeDescription}`,
+            `- Captured at: ${capturedAt}`,
+            "",
+            "```text",
+            stdout.replaceAll("\u0000", ""),
+            "```",
+            "",
+        ].join("\n");
+        this.logger.info("Terminal buffer captured", {
+            sessionId: resolved.sessionId,
+            terminalTarget: target,
+            captureMode: input.scope.mode,
+            scopeDescription,
+            isRelay: Boolean((0, relay_1.parseLiveRelaySessionId)(resolved.sessionId)),
+        });
+        return {
+            session_id: resolved.sessionId,
+            ...(session?.label ?? resolved.sessionLabel
+                ? { session_label: session?.label ?? resolved.sessionLabel }
+                : {}),
+            terminal_target: target,
+            filename,
+            markdown_content: markdownContent,
+            capture_mode: input.scope.mode,
+            scope_description: scopeDescription,
+        };
+    }
+    async resolveCaptureStart(target, scope) {
+        if (scope.mode === "full") {
+            return "-";
+        }
+        if (scope.mode === "lines") {
+            return `-${scope.lines}`;
+        }
+        const height = await (0, client_1.getTerminalWindowHeight)(this.config.terminal, target);
+        if (typeof height !== "number" || height <= 0) {
+            return `-${this.config.terminal.captureLines}`;
+        }
+        return `-${height}`;
+    }
+    describeCaptureScope(scope) {
+        switch (scope.mode) {
+            case "visible":
+                return "visible pane";
+            case "lines":
+                return `last ${scope.lines} lines`;
+            case "full":
+                return "full history";
+        }
+    }
+}
+exports.TerminalBufferService = TerminalBufferService;

package/dist/services/features/telegram-mcp/src/features/terminal-input/model/terminalInputService.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerminalInputService = void 0;
+const client_1 = require("../../../shared/integrations/terminal/client");
+function buildSubmittedText(input) {
+    const text = input.text.trim();
+    const attachments = (input.attachments ?? []).filter((item) => typeof item === "string" && item.trim().length > 0);
+    if (attachments.length === 0) {
+        return text;
+    }
+    return `${text} [attachments saved: ${attachments.join(", ")}]`.trim();
+}
+class TerminalInputService {
+    config;
+    sessionStore;
+    logger;
+    constructor(config, sessionStore, logger) {
+        this.config = config;
+        this.sessionStore = sessionStore;
+        this.logger = logger;
+    }
+    async submitHumanMessage(input) {
+        const sessionId = input.session_id.trim();
+        if (!sessionId) {
+            throw new Error("session_id is required");
+        }
+        const session = await this.sessionStore.getSession(sessionId);
+        const terminalTarget = (0, client_1.ensureTerminalTargetForSession)(this.config.terminal, {
+            sessionId,
+            ...(typeof session?.cwd === "string" ? { cwd: session.cwd } : {}),
+            ...(typeof session?.terminalTarget === "string"
+                ? { target: session.terminalTarget }
+                : {}),
+        });
+        if (!terminalTarget) {
+            throw new Error("terminal target is not configured for this console");
+        }
+        const submittedText = buildSubmittedText(input);
+        if (!submittedText) {
+            throw new Error("text is required");
+        }
+        if (!session || session.terminalTarget !== terminalTarget) {
+            await this.sessionStore.setSession({
+                sessionId,
+                ...(typeof session?.label === "string" ? { label: session.label } : {}),
+                ...(typeof session?.cwd === "string" ? { cwd: session.cwd } : {}),
+                ...(typeof session?.activeProjectUuid === "string"
+                    ? { activeProjectUuid: session.activeProjectUuid }
+                    : {}),
+                ...(typeof session?.activeProjectName === "string"
+                    ? { activeProjectName: session.activeProjectName }
+                    : {}),
+                ...(typeof session?.task === "string" ? { task: session.task } : {}),
+                ...(typeof session?.summary === "string"
+                    ? { summary: session.summary }
+                    : {}),
+                ...(Array.isArray(session?.files) ? { files: session.files } : {}),
+                ...(Array.isArray(session?.decisions)
+                    ? { decisions: session.decisions }
+                    : {}),
+                ...(Array.isArray(session?.risks) ? { risks: session.risks } : {}),
+                terminalTarget: terminalTarget,
+                ...(typeof session?.lastTerminalNudgeAt === "string"
+                    ? { lastTerminalNudgeAt: session.lastTerminalNudgeAt }
+                    : {}),
+                ...(typeof session?.lastSeenToolsHash === "string"
+                    ? { lastSeenToolsHash: session.lastSeenToolsHash }
+                    : {}),
+                ...(typeof session?.lastNotifiedToolsHash === "string"
+                    ? { lastNotifiedToolsHash: session.lastNotifiedToolsHash }
+                    : {}),
+                updatedAt: new Date().toISOString(),
+            });
+        }
+        this.logger.info("Submitting direct human terminal message", {
+            sessionId,
+            terminalTarget,
+            sourceLabel: input.source_label,
+            attachmentCount: input.attachments?.length ?? 0,
+            textLength: submittedText.length,
+        });
+        await (0, client_1.sendTerminalLiteralLine)(this.config.terminal, terminalTarget, submittedText);
+        this.logger.info("Direct human terminal message submitted", {
+            sessionId,
+            terminalTarget,
+            sourceLabel: input.source_label,
+            attachmentCount: input.attachments?.length ?? 0,
+        });
+        return {
+            ok: true,
+            session_id: sessionId,
+            terminal_target: terminalTarget,
+            submitted_text: submittedText,
+        };
+    }
+}
+exports.TerminalInputService = TerminalInputService;