Drop bang-only enter alias

Add short enter aliases for Slack input
Separate input from enter submission in Slack bridge
2026-02-17 06:02:09 +09:00 · 2026-02-17 06:00:34 +09:00 · 2026-02-17 05:55:49 +09:00 · 2026-02-17 05:46:43 +09:00 · 2026-02-17 05:35:51 +09:00 · 2026-02-17 05:34:26 +09:00
14 changed files with 1199 additions and 74 deletions
--- a/.env.example
+++ b/.env.example
@@ -6,10 +6,18 @@ SLACK_APP_TOKEN=xapp-your-app-token
 SLACK_ALLOWED_USER_ID=U0XXXXXXXXX
 SLACK_ALLOWED_CHANNEL_ID=C0XXXXXXXXX

-# PTY 설정
-DEFAULT_SHELL=claude
+# PTY / tmux 연결 설정
+TMUX_SESSION_NAME=claude
+CODEX_TMUX_SESSION_NAME=codex
 PTY_READ_TIMEOUT=5

 # 출력 버퍼 설정
 OUTPUT_BUFFER_INTERVAL=2.0
+OUTPUT_SETTLE_SECONDS=4.0
+OUTPUT_FLUSH_INTERVAL_SECONDS=15.0
 MAX_MESSAGE_LENGTH=3000
+
+# 상태 보고 / 재연결 설정
+RECONNECT_DELAY_SECONDS=5.0
+OUTPUT_IDLE_REPORT_SECONDS=120
+INPUT_IDLE_REPORT_SECONDS=300
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -42,3 +42,42 @@ Current git history is minimal (`Initial commit`), so enforce clear conventions
 ## Security & Configuration Tips
 Do not commit secrets. Copy `.env.example` to `.env` locally.  
 Restrict Slack access with `SLACK_ALLOWED_USER_ID` and `SLACK_ALLOWED_CHANNEL_ID` before running in shared workspaces.
+
+## Git & Gitea Workflow Notes
+Use `tea` (Gitea CLI), not `gh`.
+
+Hard rule:
+- Never implement changes, stage files, or commit on `main`.
+- Always create/use a feature branch first, and merge via PR.
+
+- Check login:
+  - `tea login ls`
+  - `tea whoami`
+- Create/update feature branch:
+  - `git checkout -b <branch>` (or `git checkout <branch>`)
+  - `git add <files>`
+  - `git commit -m "<message>"`
+- Push to Gitea:
+  - Normal: `git push -u origin <branch>`
+  - If HTTP username prompt fails in this environment, use the token from `~/.config/tea/config.yml`:
+    - `TOKEN=$(sed -n 's/^[[:space:]]*token: //p' ~/.config/tea/config.yml | head -n1)`
+    - `git push "http://agentson:${TOKEN}@localhost:3000/jihoson/LazyEnter.git" <branch>`
+- After token-based push, ensure tracking is on `origin/<branch>` (not token URL):
+  - `git fetch origin <branch>:refs/remotes/origin/<branch>`
+  - `git branch --set-upstream-to=origin/<branch> <branch>`
+- Create PR on Gitea:
+  - `tea pr create --base main --head <branch> --title "<title>" --description "<body>"`
+  - If PR body includes backticks (`` ` ``), slash commands, or markdown that can be shell-expanded, do not pass it directly in double quotes.
+  - Preferred safe flow:
+    - `cat > /tmp/pr_body.md <<'EOF'` ... `EOF`
+    - `tea pr create --base main --head <branch> --title "<title>" --description "$(cat /tmp/pr_body.md)"`
+  - If the body is malformed after creation, patch it with API:
+    - `tea api -X PATCH repos/{owner}/{repo}/pulls/<number> -F body=@/tmp/pr_body.md`
+- Sync local main:
+  - `git checkout main`
+  - `git pull --ff-only`
+  - When user confirms the PR is merged, always run this sync immediately to keep local `main` up to date before any next task.
+
+Safety:
+- Do not commit or print tokens in logs/docs.
+- Keep unrelated local files (for example `uv.lock`) out of PRs unless intentionally changed.
--- a/README.md
+++ b/README.md
@@ -1,15 +1,18 @@
 # LazyEnter

 소파에서 엔터나 치자.  
-로컬 PC의 Claude Code CLI 세션을 Slack Socket Mode로 중계해 모바일에서도 원격으로 입력/승인을 처리하는 브릿지입니다.
+로컬 PC의 Claude/Codex CLI 세션을 Slack Socket Mode로 중계해 모바일에서도 원격으로 입력/승인을 처리하는 브릿지입니다.

 ## 동작 방식

-1. Slack에서 `/start-claude` 실행
-2. 로컬에서 `claude` 프로세스(기본값)가 PTY로 시작됨
-3. Slack 채널 메시지가 CLI 입력으로 전달됨
-4. CLI 출력이 Slack으로 다시 전송됨
-5. `/stop-claude`로 세션 종료
+1. 로컬에서 Claude 또는 Codex를 tmux 세션으로 미리 실행
+   - Claude: `tmux new -s claude claude`
+   - Codex: `tmux new -s codex codex`
+2. Slack에서 `/start-claude` 또는 `/start-codex` 실행
+3. 브릿지가 기존 tmux 세션에 attach
+4. Slack 채널 메시지가 CLI 입력으로 전달됨 (기본: 엔터 미포함)
+5. CLI 출력이 Slack으로 다시 전송됨
+6. `/stop-claude`로 브릿지 연결 해제 (tmux 세션은 유지)

 ## 빠른 시작

@@ -34,10 +37,18 @@ cp .env.example .env
 - `SLACK_ALLOWED_CHANNEL_ID`

 선택 환경 변수:
- `DEFAULT_SHELL` (기본: `claude`)
+- `TMUX_SESSION_NAME` (기본: `claude`, `/start-claude` 대상)
+- `CODEX_TMUX_SESSION_NAME` (기본: `codex`, `/start-codex` 대상)
 - `PTY_READ_TIMEOUT` (기본: `5`)
 - `OUTPUT_BUFFER_INTERVAL` (기본: `2.0`)
+- `OUTPUT_SETTLE_SECONDS` (기본: `4.0`, 출력이 잠잠해진 뒤 전송 대기 시간)
+- `OUTPUT_FLUSH_INTERVAL_SECONDS` (기본: `15.0`, 출력이 계속 이어질 때 강제 전송 주기)
 - `MAX_MESSAGE_LENGTH` (기본: `3000`)
+- `RECONNECT_DELAY_SECONDS` (기본: `5.0`, Socket Mode 재연결 대기 시간)
+- `OUTPUT_IDLE_REPORT_SECONDS` (기본: `120`, 출력 정지 보고 임계값)
+- `INPUT_IDLE_REPORT_SECONDS` (기본: `300`, 입력 정지 보고 임계값)
+
+`SLACK_ALLOWED_USER_ID`, `SLACK_ALLOWED_CHANNEL_ID`가 비어 있으면 실행이 중단됩니다.

 ## Slack 앱 설정

@@ -46,10 +57,22 @@ cp .env.example .env
 - Slash Commands 생성:
  - `/start-claude`
  - `/stop-claude`
+  - `/start-codex`
+  - `/stop-codex`
 - 앱을 워크스페이스에 설치 후 토큰을 `.env`에 반영

 ## 실행

+먼저 로컬에서 원하는 tmux 세션을 실행:
+
+```bash
+tmux new -s claude claude
+# 또는
+tmux new -s codex codex
+```
+
+그 다음 브릿지 실행:
+
 ```bash
 lazy-enter
 # 또는
@@ -57,9 +80,10 @@ python -m lazy_enter
 ```

 실행 후 Slack의 허용된 채널에서:
- `/start-claude`: 세션 시작
- 일반 메시지 전송: Claude CLI로 입력 전달
- `/stop-claude`: 세션 종료
+- `/start-claude`, `/start-codex`: 기존 세션에 연결
+- 일반 메시지 전송: 현재 연결된 CLI(Claude/Codex)로 입력만 전달 (엔터 미포함)
+- `!e`, `!enter` 전송: 엔터 키만 전달 (현재 프롬프트 제출)
+- `/stop-claude`, `/stop-codex`: 브릿지 연결 해제 (세션 유지)

 ## 테스트 및 품질 점검

--- a/src/lazy_enter/init.py
+++ b/src/lazy_enter/init.py
@@ -1,3 +1,3 @@
-"""LazyEnter - Slack을 통한 Claude Code 원격 제어 브릿지."""
+"""LazyEnter - Slack을 통한 Claude/Codex 원격 제어 브릿지."""

 __version__ = "0.1.0"
--- a/src/lazy_enter/main.py
+++ b/src/lazy_enter/main.py
@@ -1,10 +1,20 @@
 """CLI 엔트리포인트."""

+import sys
+
 from lazy_enter.bridge import Bridge
+from lazy_enter.config import Config


 def main() -> None:
-    bridge = Bridge()
+    config = Config()
+    try:
+        config.validate_required_settings()
+    except ValueError as exc:
+        print(f"[LazyEnter] 설정 오류: {exc}", file=sys.stderr)
+        raise SystemExit(1) from exc
+
+    bridge = Bridge(config)
    bridge.run()


--- a/src/lazy_enter/bridge.py
+++ b/src/lazy_enter/bridge.py
@@ -3,10 +3,12 @@
 from __future__ import annotations

 import logging
+import re
 import threading
 import time

 from lazy_enter.config import Config
+from lazy_enter.output_filter import clean_terminal_output
 from lazy_enter.pty_manager import PtyManager
 from lazy_enter.slack_handler import SlackHandler

@@ -16,6 +18,8 @@ logger = logging.getLogger(__name__)
 class Bridge:
    """Slack ↔ CLI 프로세스 간의 중계기."""

+    ENTER_COMMANDS = {"!e", "!enter"}
+
    def __init__(self, config: Config | None = None) -> None:
        self.config = config or Config()
        self.slack = SlackHandler(self.config)
@@ -23,73 +27,311 @@ class Bridge:
        self._output_thread: threading.Thread | None = None
        self._running = False
        self._channel: str = self.config.allowed_channel_id
+        self._active_target: str | None = None
+        self._last_sent_output: str = ""
+        self._last_sent_fingerprint: str | None = None
+        self._last_input_at = time.monotonic()
+        self._last_output_at = time.monotonic()
+        self._output_buffer_started_at: float | None = None
+        self._input_idle_reported = False
+        self._output_idle_reported = False

        self.slack.on_message(self._handle_message)
        self.slack.on_command(self._handle_command)

    def _handle_message(self, text: str, channel: str) -> None:
        """Slack 메시지를 PTY 프로세스로 전달한다."""
-        if self.pty and self.pty.is_alive:
-            self.pty.send(text)
-            logger.info("입력 전달: %s", text)
-        else:
-            self.slack.send_message(channel, ":warning: 실행 중인 세션이 없습니다.")
+        if not self.pty or not self.pty.is_alive:
+            self.slack.send_message(channel, ":warning: 연결된 세션이 없습니다.")
+            return

-    def _handle_command(self, command: str, channel: str) -> None:
+        if text.strip().lower() in self.ENTER_COMMANDS:
+            self.pty.send_enter()
+            self._last_sent_output = ""
+            self._last_sent_fingerprint = None
+            self._last_input_at = time.monotonic()
+            self._input_idle_reported = False
+            logger.info("엔터 입력 전달")
+            return
+
+        if self._is_blocked_input(text):
+            self.slack.send_message(
+                channel, ":no_entry: 차단된 명령 패턴이 감지되었습니다."
+            )
+            return
+
+        self.pty.send(text)
+        # 입력 이후 출력은 동일 문자열이어도 한 번 더 전달한다.
+        self._last_sent_output = ""
+        self._last_sent_fingerprint = None
+        self._last_input_at = time.monotonic()
+        self._input_idle_reported = False
+        logger.info("입력 전달(엔터 미포함): %s", text)
+
+    @staticmethod
+    def _is_blocked_input(text: str) -> bool:
+        """치명적 쉘 명령 패턴을 단순 차단한다."""
+        normalized = re.sub(r"\s+", " ", text.lower()).strip()
+        blocked_patterns = (
+            "rm -rf /",
+            "rm -rf /*",
+            "mkfs",
+            ":(){:|:&};:",
+            "shutdown -h",
+            "reboot",
+            "poweroff",
+        )
+        return any(pattern in normalized for pattern in blocked_patterns)
+
+    @staticmethod
+    def _display_name(target: str) -> str:
+        if target == "codex":
+            return "Codex"
+        return "Claude"
+
+    def _session_name_for_target(self, target: str) -> str:
+        if target == "codex":
+            return self.config.codex_tmux_session_name
+        return self.config.tmux_session_name
+
+    def _handle_command(self, action: str, target: str, channel: str) -> None:
        """슬래시 커맨드를 처리한다."""
-        if command == "start":
-            self._start_session(channel)
-        elif command == "stop":
+        if target not in {"claude", "codex"}:
+            self.slack.send_message(channel, ":warning: 지원하지 않는 대상입니다.")
+            return
+
+        if action == "start":
+            self._start_session(channel, target)
+        elif action == "stop":
            self._stop_session(channel)

-    def _start_session(self, channel: str) -> None:
-        """Claude Code 세션을 시작한다."""
+    def _start_session(self, channel: str, target: str) -> None:
+        """지정한 대상의 tmux 세션에 연결한다."""
        if self.pty and self.pty.is_alive:
            self.slack.send_message(
-                channel, ":information_source: 이미 세션이 실행 중입니다."
+                channel, ":information_source: 이미 세션에 연결되어 있습니다."
            )
            return

        self._channel = channel
-        self.pty = PtyManager(self.config.default_shell)
+        self._active_target = target
+        self._last_sent_output = ""
+        self._last_sent_fingerprint = None
+        self.pty = PtyManager(
+            self._session_name_for_target(target),
+            cli_name=target,
+        )
+        try:
            self.pty.start()
+        except RuntimeError as exc:
+            self.pty = None
+            self.slack.send_message(channel, f":warning: {exc}")
+            return
+
        self._running = True
+        self._last_input_at = time.monotonic()
+        self._last_output_at = time.monotonic()
+        self._output_buffer_started_at = None
+        self._input_idle_reported = False
+        self._output_idle_reported = False
        self._output_thread = threading.Thread(target=self._poll_output, daemon=True)
        self._output_thread.start()

-        self.slack.send_message(channel, ":rocket: Claude Code 세션이 시작되었습니다.")
+        display_name = self._display_name(target)
+        self.slack.send_message(
+            channel, f":link: {display_name} 세션에 연결되었습니다."
+        )

    def _stop_session(self, channel: str) -> None:
-        """Claude Code 세션을 종료한다."""
+        """브릿지 연결만 해제한다."""
        self._running = False
        if self.pty:
            self.pty.stop()
            self.pty = None
-        self.slack.send_message(channel, ":stop_sign: 세션이 종료되었습니다.")
+        self._active_target = None
+        self._last_sent_output = ""
+        self._last_sent_fingerprint = None
+        self._output_buffer_started_at = None
+        self.slack.send_message(channel, ":electric_plug: 세션 연결이 해제되었습니다.")

    def _poll_output(self) -> None:
        """PTY 출력을 주기적으로 읽어 Slack으로 전송한다."""
        buffer = ""
        while self._running and self.pty and self.pty.is_alive:
-            output = self.pty.read_output(timeout=self.config.pty_read_timeout)
-            if output:
-                buffer += output
-
-            if buffer:
-                # 메시지 길이 제한 적용
-                message = buffer[: self.config.max_message_length]
-                if len(buffer) > self.config.max_message_length:
-                    message += "\n... (truncated)"
-                self.slack.send_message(self._channel, f"```\n{message}\n```")
+            now = time.monotonic()
+            if buffer and self._should_flush_output_buffer(now):
+                self._send_output_chunks(buffer)
                buffer = ""
+                self._output_buffer_started_at = None
+
+            read_timeout = self._next_read_timeout(now, has_buffer=bool(buffer))
+            output = self.pty.read_output(timeout=read_timeout)
+            now = time.monotonic()
+            if output:
+                cleaned = clean_terminal_output(output)
+                if cleaned:
+                    buffer += f"{cleaned}\n"
+                    self._last_output_at = now
+                    if self._output_buffer_started_at is None:
+                        self._output_buffer_started_at = now
+                    self._output_idle_reported = False
+
+            if buffer and self._should_flush_output_buffer(now):
+                self._send_output_chunks(buffer)
+                buffer = ""
+                self._output_buffer_started_at = None
+
+            output_idle = now - self._last_output_at
+            if (
+                self.config.output_idle_report_seconds > 0
+                and not self._output_idle_reported
+                and output_idle >= self.config.output_idle_report_seconds
+            ):
+                self.slack.send_message(
+                    self._channel,
+                    (
+                        f":hourglass_flowing_sand: 출력이 {int(output_idle)}초 동안 "
+                        "없습니다. 세션 상태를 확인해주세요."
+                    ),
+                )
+                self._output_idle_reported = True
+
+            input_idle = now - self._last_input_at
+            if (
+                self.config.input_idle_report_seconds > 0
+                and not self._input_idle_reported
+                and input_idle >= self.config.input_idle_report_seconds
+            ):
+                self.slack.send_message(
+                    self._channel,
+                    f":information_source: 입력이 {int(input_idle)}초 동안 없습니다.",
+                )
+                self._input_idle_reported = True

            time.sleep(self.config.output_buffer_interval)

        if not self._running:
+            self._output_buffer_started_at = None
            return

-        # 프로세스가 예기치 않게 종료된 경우
-        self.slack.send_message(self._channel, ":warning: 프로세스가 종료되었습니다.")
+        if buffer:
+            self._send_output_chunks(buffer)
+            self._output_buffer_started_at = None
+
+        # attach 프로세스가 예기치 않게 종료된 경우
+        self.slack.send_message(self._channel, ":warning: 세션 연결이 종료되었습니다.")
+
+    def _next_read_timeout(self, now: float, has_buffer: bool) -> float:
+        """다음 PTY 읽기 타임아웃을 계산한다."""
+        base_timeout = max(0.0, float(self.config.pty_read_timeout))
+        if not has_buffer:
+            return base_timeout
+
+        deadline = self._next_output_flush_deadline()
+        if deadline is None:
+            return base_timeout
+
+        remaining = max(0.0, deadline - now)
+        return min(base_timeout, remaining)
+
+    def _next_output_flush_deadline(self) -> float | None:
+        """버퍼 flush의 가장 이른 데드라인을 반환한다."""
+        deadlines: list[float] = []
+        settle_seconds = max(0.0, self.config.output_settle_seconds)
+        if settle_seconds > 0:
+            deadlines.append(self._last_output_at + settle_seconds)
+
+        flush_interval_seconds = max(0.0, self.config.output_flush_interval_seconds)
+        if self._output_buffer_started_at is not None:
+            if flush_interval_seconds == 0:
+                return self._output_buffer_started_at
+            deadlines.append(self._output_buffer_started_at + flush_interval_seconds)
+
+        if not deadlines:
+            return None
+        return min(deadlines)
+
+    def _should_flush_output_buffer(self, now: float) -> bool:
+        """버퍼를 Slack으로 전송할 시점을 계산한다."""
+        deadline = self._next_output_flush_deadline()
+        return deadline is not None and now >= deadline
+
+    @staticmethod
+    def _split_message(text: str, max_length: int) -> list[str]:
+        """긴 텍스트를 메시지 길이 제한에 맞게 분할한다."""
+        if max_length <= 0:
+            return [text] if text else []
+
+        lines = text.splitlines(keepends=True)
+        chunks: list[str] = []
+        current = ""
+
+        def flush() -> None:
+            nonlocal current
+            if current:
+                chunks.append(current)
+            current = ""
+
+        for line in lines:
+            if len(line) > max_length:
+                flush()
+                start = 0
+                while start < len(line):
+                    piece = line[start : start + max_length]
+                    chunks.append(piece)
+                    start += max_length
+                continue
+
+            if len(current) + len(line) > max_length:
+                flush()
+            current += line
+
+        flush()
+        return chunks
+
+    def _send_output_chunks(self, text: str) -> None:
+        """출력을 잘라서 Slack으로 순차 전송한다."""
+        chunks = self._split_message(text, self.config.max_message_length)
+        snapshot = "\n\x00".join(chunks)
+        fingerprint = self._output_fingerprint(snapshot)
+        if not chunks:
+            return
+        if (
+            self._last_sent_fingerprint is not None
+            and fingerprint == self._last_sent_fingerprint
+        ):
+            return
+
+        for chunk in chunks:
+            if chunk.endswith("\n"):
+                message = f"```\n{chunk}```"
+            else:
+                message = f"```\n{chunk}\n```"
+            self.slack.send_message(self._channel, message)
+        self._last_sent_output = snapshot
+        self._last_sent_fingerprint = fingerprint
+
+    @staticmethod
+    def _output_fingerprint(text: str) -> str:
+        """중복 전송 억제를 위한 정규화 지문을 생성한다."""
+        normalized_lines: list[str] = []
+        for raw_line in text.splitlines():
+            line = raw_line.rstrip()
+            if not line.strip():
+                continue
+
+            # tmux 상태줄의 시계/날짜 라인은 프레임마다 변할 수 있어 제외한다.
+            if re.fullmatch(
+                (
+                    r'\s*\w*odex\]\s+\d+:[^\[]*'
+                    r'\[\d+,\d+\]\s+".+"\s+\d{2}:\d{2}\s+\d{2}-[A-Za-z]{3}-\d{2}'
+                ),
+                line,
+            ):
+                continue
+
+            normalized_lines.append(line)
+        return "\n".join(normalized_lines)

    def run(self) -> None:
        """브릿지를 시작한다."""
--- a/src/lazy_enter/config.py
+++ b/src/lazy_enter/config.py
@@ -18,10 +18,38 @@ class Config:
    allowed_user_id: str = os.getenv("SLACK_ALLOWED_USER_ID", "")
    allowed_channel_id: str = os.getenv("SLACK_ALLOWED_CHANNEL_ID", "")

-    # PTY
-    default_shell: str = os.getenv("DEFAULT_SHELL", "claude")
+    # PTY / tmux attach
+    tmux_session_name: str = os.getenv("TMUX_SESSION_NAME", "claude")
+    codex_tmux_session_name: str = os.getenv("CODEX_TMUX_SESSION_NAME", "codex")
    pty_read_timeout: int = int(os.getenv("PTY_READ_TIMEOUT", "5"))

    # Buffer
    output_buffer_interval: float = float(os.getenv("OUTPUT_BUFFER_INTERVAL", "2.0"))
+    output_settle_seconds: float = float(os.getenv("OUTPUT_SETTLE_SECONDS", "4.0"))
+    output_flush_interval_seconds: float = float(
+        os.getenv("OUTPUT_FLUSH_INTERVAL_SECONDS", "15.0")
+    )
    max_message_length: int = int(os.getenv("MAX_MESSAGE_LENGTH", "3000"))
+
+    # Status reporting / reconnect
+    reconnect_delay_seconds: float = float(os.getenv("RECONNECT_DELAY_SECONDS", "5.0"))
+    output_idle_report_seconds: int = int(
+        os.getenv("OUTPUT_IDLE_REPORT_SECONDS", "120")
+    )
+    input_idle_report_seconds: int = int(os.getenv("INPUT_IDLE_REPORT_SECONDS", "300"))
+
+    def validate_required_settings(self) -> None:
+        """필수 설정값 누락 여부를 검증한다."""
+        missing: list[str] = []
+        if not self.slack_bot_token:
+            missing.append("SLACK_BOT_TOKEN")
+        if not self.slack_app_token:
+            missing.append("SLACK_APP_TOKEN")
+        if not self.allowed_user_id:
+            missing.append("SLACK_ALLOWED_USER_ID")
+        if not self.allowed_channel_id:
+            missing.append("SLACK_ALLOWED_CHANNEL_ID")
+
+        if missing:
+            joined = ", ".join(missing)
+            raise ValueError(f"필수 환경 변수가 누락되었습니다: {joined}")
--- a/src/lazy_enter/output_filter.py
+++ b/src/lazy_enter/output_filter.py
@@ -0,0 +1,81 @@
+"""PTY 출력에서 터미널 제어 시퀀스를 제거한다."""
+
+from __future__ import annotations
+
+import re
+
+# ANSI CSI / OSC / DCS / 단일 ESC 시퀀스를 폭넓게 제거한다.
+_ANSI_ESCAPE_RE = re.compile(
+    r"(?:\x1B\[[0-?]*[ -/]*[@-~])"
+    r"|(?:\x1B\][^\x1B\x07]*(?:\x07|\x1B\\))"
+    r"|(?:\x1BP[^\x1B]*(?:\x1B\\))"
+    r"|(?:\x1B[@-_])"
+)
+
+# ESC 문자가 유실된 상태로 남는 CSI 토큰(예: [38;2;153;153;153m) 제거.
+_BROKEN_CSI_RE = re.compile(r"\[(?:[0-9;<=>?]|(?:\d+;))*\d*[A-Za-z]")
+
+# ESC(B 같은 문자셋 지정 시퀀스가 ESC 유실 후 남긴 토큰 제거.
+_BROKEN_CHARSET_RE = re.compile(r"[\(\)][B0]")
+
+# C0 제어문자 중 개행/탭/캐리지리턴을 제외하고 제거.
+_CONTROL_RE = re.compile(r"[\x00-\x08\x0B-\x1F\x7F]")
+
+_CODEX_TUI_LINE_PATTERNS = (
+    re.compile(r"openai codex", re.IGNORECASE),
+    re.compile(r"/model to change", re.IGNORECASE),
+    re.compile(r"^\s*[|│]\s*model:", re.IGNORECASE),
+    re.compile(r"^\s*[|│]\s*directory:", re.IGNORECASE),
+    re.compile(r"^\s*tip:\s*new\s+codex", re.IGNORECASE),
+    re.compile(r"find and fix a bug in @filename", re.IGNORECASE),
+    re.compile(r"\?\s*for shortcuts", re.IGNORECASE),
+    re.compile(r"\bcontext left\b", re.IGNORECASE),
+    re.compile(r"^\s*\w*odex\]\s+\d+:", re.IGNORECASE),
+)
+
+
+def _is_box_border_line(line: str) -> bool:
+    stripped = line.strip()
+    if not stripped:
+        return False
+    # ESC(B 유실 잔재가 앞에 붙는 경우(예: =╭────╮)도 border로 본다.
+    stripped = stripped.lstrip("= ")
+    return all(ch in "╭╮╰╯─│┌┐└┘├┤┬┴┼" for ch in stripped)
+
+
+def _is_box_empty_line(line: str) -> bool:
+    stripped = line.strip()
+    if not stripped:
+        return False
+    return bool(re.fullmatch(r"[│|]\s+[│|]", stripped))
+
+
+def _is_noise_line(line: str) -> bool:
+    if _is_box_border_line(line):
+        return True
+    if _is_box_empty_line(line):
+        return True
+    return any(pattern.search(line) for pattern in _CODEX_TUI_LINE_PATTERNS)
+
+
+def clean_terminal_output(text: str) -> str:
+    """Slack 전송용 텍스트를 정리한다."""
+    cleaned = _ANSI_ESCAPE_RE.sub("", text)
+    cleaned = _BROKEN_CSI_RE.sub("", cleaned)
+    cleaned = _BROKEN_CHARSET_RE.sub("", cleaned)
+    cleaned = cleaned.replace("\r", "")
+    cleaned = _CONTROL_RE.sub("", cleaned)
+
+    lines: list[str] = []
+    for raw_line in cleaned.splitlines():
+        line = raw_line.rstrip()
+        if not line:
+            continue
+        if _is_noise_line(line):
+            continue
+        if lines and lines[-1] == line:
+            continue
+        lines.append(line)
+
+    compact = "\n".join(lines).strip()
+    return compact
--- a/src/lazy_enter/pty_manager.py
+++ b/src/lazy_enter/pty_manager.py
@@ -1,8 +1,9 @@
-"""pexpect 기반 PTY 프로세스 관리."""
+"""기존 tmux 세션에 attach하여 CLI 입출력을 중계한다."""

 from __future__ import annotations

 import logging
+import subprocess

 import pexpect

@@ -10,34 +11,58 @@ logger = logging.getLogger(__name__)


 class PtyManager:
-    """가상 터미널에서 CLI 프로세스를 생성하고 입출력을 제어한다."""
+    """기존 tmux 세션에 attach하고 입출력을 제어한다."""

-    def __init__(self, command: str = "claude") -> None:
-        self.command = command
+    def __init__(self, session_name: str = "claude", cli_name: str = "claude") -> None:
+        self.session_name = session_name
+        self.cli_name = cli_name
        self._process: pexpect.spawn | None = None

    @property
    def is_alive(self) -> bool:
        return self._process is not None and self._process.isalive()

+    def _ensure_session_exists(self) -> None:
+        """attach 대상 tmux 세션 존재 여부를 검증한다."""
+        result = subprocess.run(
+            ["tmux", "has-session", "-t", self.session_name],
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            raise RuntimeError(
+                "tmux 세션이 없습니다. 먼저 실행하세요: "
+                f"tmux new -s {self.session_name} {self.cli_name}"
+            )
+
    def start(self) -> None:
-        """프로세스를 시작한다."""
-        logger.info("프로세스 시작: %s", self.command)
+        """기존 tmux 세션에 attach한다."""
+        self._ensure_session_exists()
+        logger.info("tmux 세션 attach: %s", self.session_name)
        self._process = pexpect.spawn(
-            self.command,
+            "tmux",
+            ["attach-session", "-t", self.session_name],
            encoding="utf-8",
            timeout=None,
        )

-    def send(self, text: str) -> None:
+    def send(self, text: str, submit: bool = False) -> None:
        """프로세스에 텍스트 입력을 전달한다."""
        if not self.is_alive:
            raise RuntimeError("프로세스가 실행 중이 아닙니다.")
        assert self._process is not None
        logger.debug("입력 전송: %s", text)
+        if submit:
            self._process.sendline(text)
+            return
+        self._process.send(text)

-    def read_output(self, timeout: int = 5) -> str:
+    def send_enter(self) -> None:
+        """엔터 키 입력만 전송한다."""
+        self.send("", submit=True)
+
+    def read_output(self, timeout: float = 5) -> str:
        """프로세스의 출력을 읽는다."""
        if not self.is_alive:
            raise RuntimeError("프로세스가 실행 중이 아닙니다.")
@@ -49,8 +74,8 @@ class PtyManager:
        return self._process.before or ""

    def stop(self) -> None:
-        """프로세스를 종료한다."""
+        """attach 연결만 종료한다(원격 세션은 유지)."""
        if self._process is not None:
-            logger.info("프로세스 종료")
+            logger.info("tmux attach 종료")
            self._process.close(force=True)
            self._process = None
--- a/src/lazy_enter/slack_handler.py
+++ b/src/lazy_enter/slack_handler.py
@@ -3,6 +3,8 @@
 from __future__ import annotations

 import logging
+import time
+from collections.abc import Callable

 from slack_bolt import App
 from slack_bolt.adapter.socket_mode import SocketModeHandler
@@ -19,9 +21,10 @@ class SlackHandler:
    def __init__(self, config: Config) -> None:
        self.config = config
        self.app = App(token=config.slack_bot_token)
-        self._handler = SocketModeHandler(self.app, config.slack_app_token)
-        self._on_message_callback: callable | None = None
-        self._on_command_callback: callable | None = None
+        self._handler: SocketModeHandler | None = None
+        self._stop_requested = False
+        self._on_message_callback: Callable[[str, str], None] | None = None
+        self._on_command_callback: Callable[[str, str, str], None] | None = None

        self._register_listeners()

@@ -44,7 +47,7 @@ class SlackHandler:
        """Slack 이벤트 리스너를 등록한다."""

        @self.app.event("message")
-        def handle_message(event: dict, say: callable) -> None:
+        def handle_message(event: dict, say: Callable[..., None]) -> None:
            user_id = event.get("user", "")
            channel_id = event.get("channel", "")
            text = event.get("text", "")
@@ -56,7 +59,7 @@ class SlackHandler:
                self._on_message_callback(text, channel_id)

        @self.app.command("/start-claude")
-        def handle_start(ack: callable, body: dict) -> None:
+        def handle_start_claude(ack: Callable[..., None], body: dict) -> None:
            ack()
            user_id = body.get("user_id", "")
            channel_id = body.get("channel_id", "")
@@ -65,10 +68,10 @@ class SlackHandler:
                return

            if self._on_command_callback:
-                self._on_command_callback("start", channel_id)
+                self._on_command_callback("start", "claude", channel_id)

        @self.app.command("/stop-claude")
-        def handle_stop(ack: callable, body: dict) -> None:
+        def handle_stop_claude(ack: Callable[..., None], body: dict) -> None:
            ack()
            user_id = body.get("user_id", "")
            channel_id = body.get("channel_id", "")
@@ -77,13 +80,37 @@ class SlackHandler:
                return

            if self._on_command_callback:
-                self._on_command_callback("stop", channel_id)
+                self._on_command_callback("stop", "claude", channel_id)

-    def on_message(self, callback: callable) -> None:
+        @self.app.command("/start-codex")
+        def handle_start_codex(ack: Callable[..., None], body: dict) -> None:
+            ack()
+            user_id = body.get("user_id", "")
+            channel_id = body.get("channel_id", "")
+
+            if not self._is_authorized(user_id, channel_id):
+                return
+
+            if self._on_command_callback:
+                self._on_command_callback("start", "codex", channel_id)
+
+        @self.app.command("/stop-codex")
+        def handle_stop_codex(ack: Callable[..., None], body: dict) -> None:
+            ack()
+            user_id = body.get("user_id", "")
+            channel_id = body.get("channel_id", "")
+
+            if not self._is_authorized(user_id, channel_id):
+                return
+
+            if self._on_command_callback:
+                self._on_command_callback("stop", "codex", channel_id)
+
+    def on_message(self, callback: Callable[[str, str], None]) -> None:
        """메시지 수신 콜백을 등록한다."""
        self._on_message_callback = callback

-    def on_command(self, callback: callable) -> None:
+    def on_command(self, callback: Callable[[str, str, str], None]) -> None:
        """슬래시 커맨드 콜백을 등록한다."""
        self._on_command_callback = callback

@@ -98,11 +125,31 @@ class SlackHandler:
        )

    def start(self) -> None:
-        """Socket Mode 핸들러를 시작한다."""
+        """Socket Mode 핸들러를 시작한다. 연결이 끊기면 재연결한다."""
+        self._stop_requested = False
        logger.info("Slack Socket Mode 시작")
+
+        while not self._stop_requested:
+            try:
+                self._handler = SocketModeHandler(self.app, self.config.slack_app_token)
                self._handler.start()
+            except Exception:
+                if self._stop_requested:
+                    break
+                logger.exception("Socket Mode 연결이 종료되었습니다.")
+
+            if self._stop_requested:
+                break
+
+            logger.warning(
+                "Socket Mode 재연결 시도 (%s초 후)",
+                self.config.reconnect_delay_seconds,
+            )
+            time.sleep(self.config.reconnect_delay_seconds)

    def stop(self) -> None:
        """Socket Mode 핸들러를 종료한다."""
        logger.info("Slack Socket Mode 종료")
+        self._stop_requested = True
+        if self._handler is not None:
            self._handler.close()
--- a/tests/test_bridge.py
+++ b/tests/test_bridge.py
@@ -0,0 +1,444 @@
+"""Bridge 명령 라우팅 테스트."""
+
+from __future__ import annotations
+
+import sys
+import types
+
+slack_bolt = types.ModuleType("slack_bolt")
+slack_bolt.App = object
+socket_mode = types.ModuleType("slack_bolt.adapter.socket_mode")
+socket_mode.SocketModeHandler = object
+slack_sdk = types.ModuleType("slack_sdk")
+slack_sdk.WebClient = object
+sys.modules.setdefault("slack_bolt", slack_bolt)
+sys.modules.setdefault("slack_bolt.adapter.socket_mode", socket_mode)
+sys.modules.setdefault("slack_sdk", slack_sdk)
+
+
+class FakeSlackHandler:
+    def __init__(self, _config) -> None:
+        self.message_callback = None
+        self.command_callback = None
+        self.sent_messages: list[tuple[str, str]] = []
+
+    def on_message(self, callback) -> None:
+        self.message_callback = callback
+
+    def on_command(self, callback) -> None:
+        self.command_callback = callback
+
+    def send_message(self, channel: str, text: str) -> None:
+        self.sent_messages.append((channel, text))
+
+    def start(self) -> None:
+        return None
+
+    def stop(self) -> None:
+        return None
+
+
+class FakePtyManager:
+    instances: list[FakePtyManager] = []
+
+    def __init__(self, session_name: str, cli_name: str = "claude") -> None:
+        self.session_name = session_name
+        self.cli_name = cli_name
+        self._alive = False
+        self.sent_inputs: list[str] = []
+        self.enter_count = 0
+        FakePtyManager.instances.append(self)
+
+    @property
+    def is_alive(self) -> bool:
+        return self._alive
+
+    def start(self) -> None:
+        self._alive = True
+
+    def stop(self) -> None:
+        self._alive = False
+
+    def send(self, text: str) -> None:
+        self.sent_inputs.append(text)
+
+    def send_enter(self) -> None:
+        self.enter_count += 1
+
+    def read_output(self, timeout: float = 5) -> str:
+        return ""
+
+
+def _make_bridge(monkeypatch):
+    from lazy_enter.bridge import Bridge
+    from lazy_enter.config import Config
+
+    monkeypatch.setattr("lazy_enter.bridge.SlackHandler", FakeSlackHandler)
+    monkeypatch.setattr("lazy_enter.bridge.PtyManager", FakePtyManager)
+    config = Config()
+    config.tmux_session_name = "claude-room"
+    config.codex_tmux_session_name = "codex-room"
+    return Bridge(config)
+
+
+def test_start_claude_routes_to_claude_session(monkeypatch) -> None:
+    FakePtyManager.instances.clear()
+    bridge = _make_bridge(monkeypatch)
+
+    bridge._handle_command("start", "claude", "C1")
+
+    assert FakePtyManager.instances[-1].session_name == "claude-room"
+    assert FakePtyManager.instances[-1].cli_name == "claude"
+    assert bridge.slack.sent_messages[-1] == (
+        "C1",
+        ":link: Claude 세션에 연결되었습니다.",
+    )
+
+
+def test_start_codex_routes_to_codex_session(monkeypatch) -> None:
+    FakePtyManager.instances.clear()
+    bridge = _make_bridge(monkeypatch)
+
+    bridge._handle_command("start", "codex", "C1")
+
+    assert FakePtyManager.instances[-1].session_name == "codex-room"
+    assert FakePtyManager.instances[-1].cli_name == "codex"
+    assert bridge.slack.sent_messages[-1] == (
+        "C1",
+        ":link: Codex 세션에 연결되었습니다.",
+    )
+
+
+def test_start_session_resets_output_dedup_state(monkeypatch) -> None:
+    FakePtyManager.instances.clear()
+    bridge = _make_bridge(monkeypatch)
+    bridge._last_sent_output = "stale"
+    bridge._last_sent_fingerprint = "stale-fp"
+
+    bridge._handle_command("start", "codex", "C1")
+
+    assert bridge._last_sent_output == ""
+    assert bridge._last_sent_fingerprint is None
+
+
+def test_unknown_target_is_rejected(monkeypatch) -> None:
+    bridge = _make_bridge(monkeypatch)
+
+    bridge._handle_command("start", "unknown", "C1")
+
+    assert bridge.slack.sent_messages[-1] == (
+        "C1",
+        ":warning: 지원하지 않는 대상입니다.",
+    )
+
+
+def test_handle_message_resets_last_sent_output_after_input(monkeypatch) -> None:
+    FakePtyManager.instances.clear()
+    bridge = _make_bridge(monkeypatch)
+
+    bridge._handle_command("start", "codex", "C1")
+    pty = FakePtyManager.instances[-1]
+    bridge._last_sent_output = "previous output"
+
+    bridge._handle_message("status", "C1")
+
+    assert pty.sent_inputs[-1] == "status"
+    assert bridge._last_sent_output == ""
+    assert bridge._last_sent_fingerprint is None
+
+
+def test_handle_message_enter_command_sends_enter_only(monkeypatch) -> None:
+    FakePtyManager.instances.clear()
+    bridge = _make_bridge(monkeypatch)
+
+    bridge._handle_command("start", "codex", "C1")
+    pty = FakePtyManager.instances[-1]
+
+    bridge._handle_message("!enter", "C1")
+
+    assert pty.sent_inputs == []
+    assert pty.enter_count == 1
+
+
+def test_handle_message_short_enter_alias_sends_enter_only(monkeypatch) -> None:
+    FakePtyManager.instances.clear()
+    bridge = _make_bridge(monkeypatch)
+
+    bridge._handle_command("start", "codex", "C1")
+    pty = FakePtyManager.instances[-1]
+
+    bridge._handle_message("!e", "C1")
+
+    assert pty.sent_inputs == []
+    assert pty.enter_count == 1
+
+
+def test_handle_message_bang_is_plain_input(monkeypatch) -> None:
+    FakePtyManager.instances.clear()
+    bridge = _make_bridge(monkeypatch)
+
+    bridge._handle_command("start", "codex", "C1")
+    pty = FakePtyManager.instances[-1]
+
+    bridge._handle_message("!", "C1")
+
+    assert pty.sent_inputs == ["!"]
+    assert pty.enter_count == 0
+
+
+def test_split_message_preserves_all_content(monkeypatch) -> None:
+    bridge = _make_bridge(monkeypatch)
+    chunks = bridge._split_message("line1\nline2\nline3", max_length=7)
+    assert "".join(chunks) == "line1\nline2\nline3"
+
+
+def test_split_message_preserves_trailing_whitespace_and_blank_line(
+    monkeypatch,
+) -> None:
+    bridge = _make_bridge(monkeypatch)
+    text = "ab  \n\ncd  "
+    chunks = bridge._split_message(text, max_length=4)
+    assert "".join(chunks) == text
+
+
+def test_send_output_chunks_sends_multiple_messages(monkeypatch) -> None:
+    bridge = _make_bridge(monkeypatch)
+    bridge._channel = "C1"
+    bridge._send_output_chunks("1234567890")
+
+    assert bridge.slack.sent_messages == [
+        ("C1", "```\n1234567890\n```"),
+    ]
+
+    bridge.config.max_message_length = 4
+    bridge.slack.sent_messages.clear()
+    bridge._send_output_chunks("abcdefghij")
+    assert bridge.slack.sent_messages == [
+        ("C1", "```\nabcd\n```"),
+        ("C1", "```\nefgh\n```"),
+        ("C1", "```\nij\n```"),
+    ]
+
+
+def test_send_output_chunks_skips_duplicate_snapshot(monkeypatch) -> None:
+    bridge = _make_bridge(monkeypatch)
+    bridge._channel = "C1"
+    bridge.config.max_message_length = 4
+
+    bridge._send_output_chunks("abcdefghij")
+    first = list(bridge.slack.sent_messages)
+
+    bridge._send_output_chunks("abcdefghij")
+    assert bridge.slack.sent_messages == first
+
+
+def test_send_output_chunks_skips_duplicate_with_volatile_status_line(
+    monkeypatch,
+) -> None:
+    bridge = _make_bridge(monkeypatch)
+    bridge._channel = "C1"
+    bridge.config.max_message_length = 1000
+
+    first_output = (
+        "Would you like to make the following edits?\n"
+        "src/main.py (+68 -1)\n"
+        'odex] 0:node* [0,0] "jihoson-home" 05:12 17-Feb-26\n'
+        "Press enter to confirm or esc to cancel\n"
+    )
+    second_output = (
+        "Would you like to make the following edits?\n"
+        "src/main.py (+68 -1)\n"
+        'odex] 0:node* [0,0] "jihoson-home" 05:13 17-Feb-26\n'
+        "Press enter to confirm or esc to cancel\n"
+    )
+
+    bridge._send_output_chunks(first_output)
+    first = list(bridge.slack.sent_messages)
+
+    bridge._send_output_chunks(second_output)
+    assert bridge.slack.sent_messages == first
+
+
+def test_send_output_chunks_sends_first_when_fingerprint_is_empty(monkeypatch) -> None:
+    bridge = _make_bridge(monkeypatch)
+    bridge._channel = "C1"
+    volatile_only = 'odex] 0:node* [0,0] "jihoson-home" 05:12 17-Feb-26\n'
+
+    bridge._send_output_chunks(volatile_only)
+    assert bridge.slack.sent_messages == [("C1", f"```\n{volatile_only.rstrip()}\n```")]
+
+    bridge._send_output_chunks(volatile_only)
+    assert bridge.slack.sent_messages == [("C1", f"```\n{volatile_only.rstrip()}\n```")]
+
+
+def test_send_output_chunks_keeps_non_tmux_timestamp_lines(monkeypatch) -> None:
+    bridge = _make_bridge(monkeypatch)
+    bridge._channel = "C1"
+    bridge.config.max_message_length = 1000
+
+    first_output = (
+        "report generated at 05:12 17-Feb-26\n"
+        "count=10\n"
+    )
+    second_output = (
+        "report generated at 05:13 17-Feb-26\n"
+        "count=10\n"
+    )
+
+    bridge._send_output_chunks(first_output)
+    bridge._send_output_chunks(second_output)
+
+    assert bridge.slack.sent_messages == [
+        ("C1", f"```\n{first_output.rstrip()}\n```"),
+        ("C1", f"```\n{second_output.rstrip()}\n```"),
+    ]
+
+
+def test_send_output_chunks_preserves_whitespace_signals(monkeypatch) -> None:
+    bridge = _make_bridge(monkeypatch)
+    bridge._channel = "C1"
+    bridge.config.max_message_length = 1000
+
+    first_output = "def f():\n    return 1\n"
+    second_output = "def f():\n  return 1\n"
+
+    bridge._send_output_chunks(first_output)
+    bridge._send_output_chunks(second_output)
+
+    assert bridge.slack.sent_messages == [
+        ("C1", f"```\n{first_output.rstrip()}\n```"),
+        ("C1", f"```\n{second_output.rstrip()}\n```"),
+    ]
+
+
+def test_send_output_chunks_keeps_standalone_time_lines(monkeypatch) -> None:
+    bridge = _make_bridge(monkeypatch)
+    bridge._channel = "C1"
+    bridge.config.max_message_length = 1000
+
+    bridge._send_output_chunks("[5:12 AM]\n")
+    bridge._send_output_chunks("[5:13 AM]\n")
+
+    assert bridge.slack.sent_messages == [
+        ("C1", "```\n[5:12 AM]\n```"),
+        ("C1", "```\n[5:13 AM]\n```"),
+    ]
+
+
+def test_send_output_chunks_keeps_non_tmux_status_like_lines(monkeypatch) -> None:
+    bridge = _make_bridge(monkeypatch)
+    bridge._channel = "C1"
+    bridge.config.max_message_length = 1000
+
+    first_output = '[2,3] "job-runner" 05:12 17-Feb-26\n'
+    second_output = '[2,3] "job-runner" 05:13 17-Feb-26\n'
+
+    bridge._send_output_chunks(first_output)
+    bridge._send_output_chunks(second_output)
+
+    assert bridge.slack.sent_messages == [
+        ("C1", "```\n[2,3] \"job-runner\" 05:12 17-Feb-26\n```"),
+        ("C1", "```\n[2,3] \"job-runner\" 05:13 17-Feb-26\n```"),
+    ]
+
+
+def test_should_flush_output_buffer_when_settled(monkeypatch) -> None:
+    bridge = _make_bridge(monkeypatch)
+    bridge.config.output_settle_seconds = 4.0
+    bridge.config.output_flush_interval_seconds = 15.0
+    bridge._last_output_at = 10.0
+    bridge._output_buffer_started_at = 2.0
+
+    assert bridge._should_flush_output_buffer(14.1) is True
+
+
+def test_should_flush_output_buffer_when_flush_interval_elapsed(monkeypatch) -> None:
+    bridge = _make_bridge(monkeypatch)
+    bridge.config.output_settle_seconds = 4.0
+    bridge.config.output_flush_interval_seconds = 15.0
+    bridge._last_output_at = 20.0
+    bridge._output_buffer_started_at = 2.0
+
+    assert bridge._should_flush_output_buffer(17.1) is True
+
+
+def test_should_flush_output_buffer_false_during_active_stream(monkeypatch) -> None:
+    bridge = _make_bridge(monkeypatch)
+    bridge.config.output_settle_seconds = 4.0
+    bridge.config.output_flush_interval_seconds = 15.0
+    bridge._last_output_at = 19.0
+    bridge._output_buffer_started_at = 10.0
+
+    assert bridge._should_flush_output_buffer(20.0) is False
+
+
+def test_poll_output_skips_final_flush_after_intentional_stop(monkeypatch) -> None:
+    bridge = _make_bridge(monkeypatch)
+    bridge._channel = "C1"
+    bridge.config.output_settle_seconds = 9999.0
+    bridge.config.output_flush_interval_seconds = 9999.0
+    bridge.config.output_buffer_interval = 0.0
+
+    pty = FakePtyManager("codex-room", cli_name="codex")
+    pty._alive = True
+    bridge.pty = pty
+    bridge._running = True
+
+    sent_buffers: list[str] = []
+    monkeypatch.setattr(bridge, "_send_output_chunks", sent_buffers.append)
+
+    def _read_output(timeout: float = 5) -> str:
+        bridge._running = False
+        return "planning update"
+
+    monkeypatch.setattr(pty, "read_output", _read_output)
+    bridge._poll_output()
+
+    assert sent_buffers == []
+
+
+def test_next_read_timeout_is_capped_by_flush_deadline(monkeypatch) -> None:
+    bridge = _make_bridge(monkeypatch)
+    bridge.config.pty_read_timeout = 5
+    bridge.config.output_settle_seconds = 4.0
+    bridge.config.output_flush_interval_seconds = 15.0
+    bridge._last_output_at = 100.0
+    bridge._output_buffer_started_at = 95.0
+
+    timeout = bridge._next_read_timeout(103.6, has_buffer=True)
+    assert 0.39 <= timeout <= 0.41
+
+
+def test_poll_output_uses_shorter_timeout_near_settle_deadline(monkeypatch) -> None:
+    bridge = _make_bridge(monkeypatch)
+    bridge._channel = "C1"
+    bridge.config.pty_read_timeout = 5
+    bridge.config.output_settle_seconds = 4.0
+    bridge.config.output_flush_interval_seconds = 15.0
+    bridge.config.output_buffer_interval = 0.0
+    bridge.config.output_idle_report_seconds = 0
+    bridge.config.input_idle_report_seconds = 0
+
+    pty = FakePtyManager("codex-room", cli_name="codex")
+    pty._alive = True
+    bridge.pty = pty
+    bridge._running = True
+
+    observed_timeouts: list[float] = []
+    call_count = 0
+
+    def _read_output(timeout: float = 5) -> str:
+        nonlocal call_count
+        observed_timeouts.append(timeout)
+        if call_count == 0:
+            call_count += 1
+            return "first chunk"
+        bridge._running = False
+        return ""
+
+    monkeypatch.setattr(pty, "read_output", _read_output)
+    bridge._poll_output()
+
+    assert len(observed_timeouts) == 2
+    assert observed_timeouts[0] == 5
+    assert 0.0 <= observed_timeouts[1] < 5
--- a/tests/test_config.py
+++ b/tests/test_config.py
@@ -1,11 +1,40 @@
 """Config 테스트."""

+import pytest
+
 from lazy_enter.config import Config


 def test_config_defaults():
    config = Config()
-    assert config.default_shell == "claude"
+    assert config.tmux_session_name == "claude"
+    assert config.codex_tmux_session_name == "codex"
    assert config.pty_read_timeout == 5
    assert config.output_buffer_interval == 2.0
+    assert config.output_settle_seconds == 4.0
+    assert config.output_flush_interval_seconds == 15.0
    assert config.max_message_length == 3000
+    assert config.reconnect_delay_seconds == 5.0
+    assert config.output_idle_report_seconds == 120
+    assert config.input_idle_report_seconds == 300
+
+
+def test_validate_required_settings_missing() -> None:
+    config = Config()
+    config.slack_bot_token = ""
+    config.slack_app_token = ""
+    config.allowed_user_id = ""
+    config.allowed_channel_id = ""
+
+    with pytest.raises(ValueError):
+        config.validate_required_settings()
+
+
+def test_validate_required_settings_ok() -> None:
+    config = Config()
+    config.slack_bot_token = "xoxb-test"
+    config.slack_app_token = "xapp-test"
+    config.allowed_user_id = "U000"
+    config.allowed_channel_id = "C000"
+
+    config.validate_required_settings()
--- a/tests/test_output_filter.py
+++ b/tests/test_output_filter.py
@@ -0,0 +1,43 @@
+"""output_filter 모듈 테스트."""
+
+from lazy_enter.output_filter import clean_terminal_output
+
+
+def test_clean_terminal_output_removes_ansi_sequences():
+    raw = "\x1b[?2004h\x1b[38;2;153;153;153mClaude Code\x1b[39m"
+    assert clean_terminal_output(raw) == "Claude Code"
+
+
+def test_clean_terminal_output_removes_broken_csi_tokens():
+    raw = "[?2004h[38;2;153;153;153mhello[39m"
+    assert clean_terminal_output(raw) == "hello"
+
+
+def test_clean_terminal_output_preserves_plain_text():
+    raw = "line1\nline2"
+    assert clean_terminal_output(raw) == "line1\nline2"
+
+
+def test_clean_terminal_output_removes_broken_charset_tokens():
+    raw = "=(Bhello(B"
+    assert clean_terminal_output(raw) == "=hello"
+
+
+def test_clean_terminal_output_filters_codex_tui_redraw_noise():
+    raw = """=(B╭─────────────────────────────────────────────╮(B
+│ >_ OpenAI Codex (v0.101.0)                  │(B
+│ model:     gpt-5.3-codex   /model to change │(B
+│ directory: ~/repos/The-Ouroboros            │(B
+╰─────────────────────────────────────────────╯(B
+Tip: New Codex is included in your plan for free
+› Find and fix a bug in @filename
+? for shortcuts
+100% context left
+Assistant: 작업을 시작합니다.
+"""
+    assert clean_terminal_output(raw) == "Assistant: 작업을 시작합니다."
+
+
+def test_clean_terminal_output_removes_box_empty_line_noise():
+    raw = "│                                             │\n› Explain this codebase\n"
+    assert clean_terminal_output(raw) == "› Explain this codebase"
--- a/tests/test_pty_manager.py
+++ b/tests/test_pty_manager.py
@@ -1,16 +1,121 @@
 """PtyManager 테스트."""

+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import pytest
+
 from lazy_enter.pty_manager import PtyManager


+class FakeSpawn:
+    def __init__(self, *_args: object, **_kwargs: object) -> None:
+        self.before = ""
+        self._alive = True
+        self.sent: list[str] = []
+        self.sentline: list[str] = []
+
+    def isalive(self) -> bool:
+        return self._alive
+
+    def sendline(self, _text: str) -> None:
+        self.sentline.append(_text)
+        return None
+
+    def send(self, _text: str) -> None:
+        self.sent.append(_text)
+        return None
+
+    def expect(self, *_args: object, **_kwargs: object) -> None:
+        return None
+
+    def close(self, force: bool = False) -> None:
+        assert force is True
+        self._alive = False
+
+
 def test_initial_state():
-    pty = PtyManager("echo hello")
+    pty = PtyManager("claude")
    assert not pty.is_alive


-def test_start_and_stop():
-    pty = PtyManager("cat")
+def test_start_raises_when_tmux_session_missing(monkeypatch: pytest.MonkeyPatch):
+    def fake_run(
+        cmd: Sequence[str],
+        check: bool,
+        capture_output: bool,
+        text: bool,
+    ):
+        assert list(cmd) == ["tmux", "has-session", "-t", "claude"]
+        assert check is False
+        assert capture_output is True
+        assert text is True
+
+        class Result:
+            returncode = 1
+
+        return Result()
+
+    monkeypatch.setattr("lazy_enter.pty_manager.subprocess.run", fake_run)
+
+    pty = PtyManager("claude")
+    with pytest.raises(RuntimeError):
+        pty.start()
+
+
+def test_start_and_stop_attach(monkeypatch: pytest.MonkeyPatch):
+    def fake_run(
+        _cmd: Sequence[str],
+        check: bool,
+        capture_output: bool,
+        text: bool,
+    ):
+        assert check is False
+        assert capture_output is True
+        assert text is True
+
+        class Result:
+            returncode = 0
+
+        return Result()
+
+    monkeypatch.setattr("lazy_enter.pty_manager.subprocess.run", fake_run)
+    monkeypatch.setattr("lazy_enter.pty_manager.pexpect.spawn", FakeSpawn)
+
+    pty = PtyManager("claude")
    pty.start()
    assert pty.is_alive
+
    pty.stop()
    assert not pty.is_alive
+
+
+def test_send_and_send_enter_are_separated(monkeypatch: pytest.MonkeyPatch):
+    def fake_run(
+        _cmd: Sequence[str],
+        check: bool,
+        capture_output: bool,
+        text: bool,
+    ):
+        assert check is False
+        assert capture_output is True
+        assert text is True
+
+        class Result:
+            returncode = 0
+
+        return Result()
+
+    monkeypatch.setattr("lazy_enter.pty_manager.subprocess.run", fake_run)
+    monkeypatch.setattr("lazy_enter.pty_manager.pexpect.spawn", FakeSpawn)
+
+    pty = PtyManager("claude")
+    pty.start()
+    assert pty._process is not None
+
+    pty.send("status")
+    pty.send_enter()
+
+    assert pty._process.sent == ["status"]
+    assert pty._process.sentline == [""]
Author	SHA1	Message	Date
jihoson	6049ba7a8a	Drop bang-only enter alias	2026-02-17 06:02:09 +09:00
jihoson	b3ce2622e3	Add short enter aliases for Slack input	2026-02-17 06:00:34 +09:00
jihoson	271376a7da	Separate input from enter submission in Slack bridge	2026-02-17 05:55:49 +09:00
jihoson	51e63a0f85	Throttle and schedule buffered output delivery	2026-02-17 05:46:43 +09:00
jihoson	3effedf07d	Merge pull request 'Fix Slack output dedup and chunk forwarding' (#9 ) from fix/slack-input-drop-logs into main Reviewed-on: #9	2026-02-17 05:35:51 +09:00
jihoson	6747ab703a	Fix Slack output dedup and chunk forwarding	2026-02-17 05:34:26 +09:00
jihoson	cfbe781210	Merge pull request 'Filter Codex TUI redraw noise in Slack output' (#8 ) from fix/codex-tui-noise-filter into main Reviewed-on: #8	2026-02-17 04:45:45 +09:00
jihoson	c2fe922105	Filter Codex TUI redraw noise in Slack output	2026-02-17 04:44:53 +09:00
jihoson	0a49032f29	Merge pull request 'Document safer PR workflow rules' (#7 ) from chore/record-pr-workflow-safety into main Reviewed-on: #7	2026-02-17 04:31:22 +09:00
jihoson	cf1a6cb620	Resolve AGENTS.md merge conflict with main	2026-02-17 04:30:50 +09:00
jihoson	909ef08e37	Document safe PR body flow and post-merge main sync	2026-02-17 04:28:54 +09:00
jihoson	2fddb1ca24	Merge pull request 'Add Codex bridge target support' (#6 ) from feat/add-codex-bridge-support into main Reviewed-on: #6	2026-02-17 04:26:25 +09:00
jihoson	537839ba1a	Add Codex target commands and session routing	2026-02-17 04:24:07 +09:00
jihoson	96188680fb	Merge pull request 'Document Gitea workflow and forbid direct main commits' (#5 ) from chore/gitea-workflow-notes into main Reviewed-on: #5	2026-02-17 04:20:07 +09:00
jihoson	6a29c5f3dd	Enforce no-work-on-main rule for agents	2026-02-17 04:18:24 +09:00
jihoson	7d3540483b	Document Gitea workflow for future sessions	2026-02-17 04:16:34 +09:00
jihoson	fb7c25ec78	Merge pull request 'Attach bridge to existing tmux Claude session' (#4 ) from feat/tmux-attach-bridge into main Reviewed-on: #4	2026-02-17 04:06:53 +09:00
jihoson	b83929fac2	Attach to existing tmux Claude session	2026-02-17 04:04:28 +09:00
jihoson	e616bebdb9	Merge pull request 'Filter ANSI output before Slack forwarding' (#3 ) from fix/slack-ansi-filter into main Reviewed-on: #3	2026-02-17 03:53:08 +09:00
jihoson	8f8e63f56f	Merge remote-tracking branch 'origin/main' into fix/slack-ansi-filter # Conflicts: # src/lazy_enter/bridge.py	2026-02-17 03:52:12 +09:00
jihoson	df377cf2df	Filter ANSI output before Slack forwarding	2026-02-17 03:46:36 +09:00
jihoson	906022555a	Merge pull request 'Implement reconnect, idle reporting, and security hardening' (#2 ) from feat/remoteenter-hardening into main Reviewed-on: #2	2026-02-16 23:14:07 +09:00
jihoson	ebe7902362	Implement reconnect, idle reporting, and security hardening	2026-02-16 23:03:02 +09:00
jihoson	582c19bb50	Merge pull request 'Add contributor guide and README usage instructions' (#1 ) from docs/contributor-guide-and-readme into main Reviewed-on: #1	2026-02-16 22:52:20 +09:00