codebuff-agent 2.1.74__py3-none-any.whl

jupyter_ext/agent/codex_slash.py

@@ -0,0 +1,685 @@
+"""codex 모드의 슬래시 명령 (이슈 #121).
+
+codex CLI 의 `/` 명령 중 **SaaS 형태에서만 뜻이 있는 것**(로그인·사용량·피드백
+업로드·플러그인·앱·IDE 연동)을 뺀 나머지를 codex app-server RPC 에 잇는다.
+`CODEX_COMMANDS` 가 자동완성과 디스패치의 단일 정본이다 — 두 곳에 목록을 두면
+한쪽에만 명령이 생겨 "보이는데 안 되는" 명령이 조용히 생긴다.
+
+턴을 여는 명령(`/compact`·`/review`)과 여는 척만 하는 명령(`/init` — 프롬프트로
+바뀌어 보통 턴이 된다)을 빼면 나머지는 **턴을 열지 않는다.** 토큰을 쓰지 않고,
+거부 응답(`-32601` 등)이 와도 세션을 닫지 않는다.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any, AsyncIterator, Dict, List, Optional, Tuple
+
+from . import codex_hooks, codex_threads
+from .codex_bridge import (
+    CodexError,
+    CodexRejected,
+    CodexSession,
+    SseEvent,
+    _mask,
+)
+
+
+def _entry(cmd_id: str, description: str, *, only_start: bool = True) -> Dict[str, Any]:
+    # 모양은 `ContextAutocompleteHandler` 의 providers 항목과 같다. 인자를 받아도
+    # `requires_arg` 는 False — True 면 라벨에 콜론이 붙는다(/review 와 같은 정책).
+    return {
+        "id": cmd_id,
+        "description": description,
+        "requires_arg": False,
+        "only_start": only_start,
+    }
+
+
+CODEX_COMMANDS: Dict[str, Dict[str, Any]] = {
+    c["id"]: c
+    for c in (
+        _entry("/new", "새 codex 스레드로 시작 (/reset 과 같음)"),
+        _entry("/compact", "지금까지의 대화를 요약해 컨텍스트를 줄임"),
+        _entry(
+            "/review",
+            "codex 코드리뷰. 예: /review, /review base main, "
+            "/review commit <sha>, /review <지시문>",
+        ),
+        _entry("/model", "모델 목록·변경. 예: /model, /model <id> [effort]"),
+        _entry("/status", "현재 codex 세션의 모델·스레드·권한"),
+        _entry("/mcp", "codex 에 연결된 MCP 서버 상태"),
+        _entry("/skills", "이 작업공간에서 codex 가 쓰는 스킬 목록"),
+        _entry("/hooks", "이 작업공간에서 codex 가 쓰는 훅 목록"),
+        _entry("/diff", "작업공간의 git 변경 (pod 에서 실행)"),
+        _entry("/init", "작업공간을 살펴 AGENTS.md 지시문 초안을 만듦"),
+        _entry("/resume", "내가 연 codex 스레드를 골라 이어 붙임"),
+        _entry("/fork", "지금 대화를 문맥째 새 스레드로 갈라 이어 감"),
+        _entry("/side", "곁가지 대화 — 문맥째 갈라 묻고 /resume 으로 돌아옴"),
+        _entry("/rename", "지금 스레드 이름 바꾸기. 예: /rename 결제 리팩터링"),
+        _entry("/archive", "지금 스레드를 보관하고 새 스레드로 시작"),
+        _entry("/delete", "지금 스레드를 지움 — /delete confirm 으로 실행"),
+    )
+}
+
+#: `/compact` 가 끝나기를 기다리는 한도. 압축은 모델을 한 번 부르는 턴이다.
+COMPACT_DEADLINE_S = 180.0
+
+_INIT_PROMPT = (
+    "이 작업공간을 살펴보고, 앞으로 이 프로젝트에서 일할 에이전트가 따라야 할 규칙을 "
+    "작업공간 루트의 `AGENTS.md` 에 써 줘. 빌드·테스트 명령, 디렉터리 구조, 코드 "
+    "스타일, 하지 말아야 할 것을 짧게 정리한다. 이미 `AGENTS.md` 가 있으면 먼저 "
+    "읽고 빠진 것만 보탠다. 파일은 도구로 읽고 쓴다."
+)
+
+
+def parse(text: str) -> Optional[Tuple[str, str]]:
+    """`/<명령> <인자>` 를 (명령, 인자) 로. codex 명령이 아니면 None."""
+    stripped = (text or "").strip()
+    if not stripped.startswith("/"):
+        return None
+    # 프론트(`codexCommandName`)와 같이 어떤 공백이든 이름을 끝낸다 — 줄바꿈 뒤
+    # 인자가 이름에 붙으면 명령이 아니라 보통 턴으로 새어 나간다
+    name, *rest = stripped.split(None, 1)
+    if name not in CODEX_COMMANDS:
+        return None
+    return name, (rest[0] if rest else "").strip()
+
+
+def prompt_for(name: str, arg: str) -> Optional[str]:
+    """보통 턴으로 바뀌는 명령이면 그 프롬프트. `/init` 만 그렇다."""
+    if name == "/init":
+        return f"{_INIT_PROMPT}\n\n{arg}".strip() if arg else _INIT_PROMPT
+    return None
+
+
+# --- 디스패치 ---
+
+
+def _say(text: str) -> SseEvent:
+    return (None, {"content": text})
+
+
+def _fail(text: str) -> SseEvent:
+    return (None, {"error": text})
+
+
+async def dispatch(
+    session: CodexSession, name: str, arg: str
+) -> AsyncIterator[SseEvent]:
+    """슬래시 명령 하나를 실행한다. 항상 종료 이벤트로 끝난다."""
+    turn = _TURN_COMMANDS.get(name)
+    if turn is not None:
+        # 턴을 여는 명령은 세션이 종료 이벤트까지 낸다. `/review` 는 턴 전에 git 으로
+        # diff 를 만드는데, 그동안에도 `busy` 여야 다른 요청이 같은 소켓을 읽지 않는다
+        with session.occupied():
+            async for event in turn(session, arg):
+                yield event
+        return
+    local = _LOCAL_COMMANDS[name]
+    with session.occupied():
+        try:
+            async for event in local(session, arg):
+                yield event
+        except CodexRejected as e:
+            yield _fail(str(e))
+        except CodexError as e:
+            # 연결·핸드셰이크 실패 — 세션은 이미 쓸 수 없다
+            await session.close()
+            yield _fail(str(e))
+    yield ("complete", {"thread_id": session.thread_id})
+
+
+async def _status(session: CodexSession, arg: str) -> AsyncIterator[SseEvent]:
+    info = session.thread_info
+    lines = ["**codex 세션**", ""]
+    if not session.started:
+        lines.append("- 스레드: 아직 없음 (첫 메시지나 스레드가 필요한 명령에서 열림)")
+    else:
+        thread = info.get("thread") or {}
+        lines.append(f"- 스레드: `{session.codex_thread_id}`")
+        if thread.get("name"):
+            lines.append(f"- 이름: {thread['name']}")
+        lines.append(f"- 모델: {info.get('model') or '?'}")
+        if info.get("reasoningEffort"):
+            lines.append(f"- effort: {info['reasoningEffort']}")
+    if session.model_override:
+        effort = (
+            f" · effort {session.effort_override}" if session.effort_override else ""
+        )
+        lines.append(
+            f"- 다음 턴 모델: {session.model_override}{effort} (/model 로 고름)"
+        )
+    lines.append(f"- 권한 모드: {session.permission_mode}")
+    lines.append(f"- 작업공간: `{session.workspace_root}`")
+    yield _say("\n".join(lines))
+
+
+async def _model(session: CodexSession, arg: str) -> AsyncIterator[SseEvent]:
+    await session.ensure_open()
+    models = (await session.call("model/list", {})).get("data") or []
+    if not arg:
+        lines = ["**codex 모델**", ""]
+        for m in models:
+            if m.get("hidden"):
+                continue
+            marks = []
+            if m.get("isDefault"):
+                marks.append("기본")
+            if m.get("id") == session.model_override:
+                marks.append("선택됨")
+            efforts = ", ".join(
+                str(e.get("reasoningEffort"))
+                for e in m.get("supportedReasoningEfforts") or []
+            )
+            mark = f" ({', '.join(marks)})" if marks else ""
+            lines.append(
+                f"- `{m.get('id')}`{mark} — {m.get('displayName') or ''}"
+                + (f" · effort: {efforts}" if efforts else "")
+            )
+        lines += ["", "바꾸려면 `/model <id> [effort]`"]
+        yield _say("\n".join(lines))
+        return
+
+    parts = arg.split()
+    model_id = parts[0]
+    effort = parts[1] if len(parts) > 1 else None
+    found = next((m for m in models if m.get("id") == model_id), None)
+    if found is None:
+        yield _fail(
+            f"모델 목록에 없는 id 입니다: {model_id} — `/model` 로 목록을 봅니다."
+        )
+        return
+    supported = [
+        str(e.get("reasoningEffort"))
+        for e in found.get("supportedReasoningEfforts") or []
+    ]
+    if effort is not None and effort not in supported:
+        yield _fail(
+            f"{model_id} 가 지원하지 않는 effort 입니다: {effort} (가능: {', '.join(supported)})"
+        )
+        return
+    session.set_model(model_id, effort)
+    suffix = f" · effort {effort}" if effort else ""
+    yield _say(f"다음 턴부터 `{model_id}`{suffix} 로 답합니다.")
+
+
+async def _mcp(session: CodexSession, arg: str) -> AsyncIterator[SseEvent]:
+    await session.ensure_open()
+    result = await session.call("mcpServerStatus/list", {})
+    servers = result.get("data") or []
+    if not servers:
+        yield _say("codex 에 연결된 MCP 서버가 없습니다.")
+        return
+    lines = ["**codex MCP 서버**", ""]
+    for srv in servers:
+        tools = srv.get("tools") or {}
+        state = srv.get("runtimeStatus") or "?"
+        lines.append(
+            f"- `{srv.get('name')}` — {state} · 도구 {len(tools)} · 인증 {srv.get('authStatus') or '?'}"
+        )
+        if srv.get("toolsError"):
+            lines.append(f"  - 도구 목록 오류: {srv['toolsError']}")
+    if result.get("nextCursor"):
+        lines.append("- (더 있음)")
+    yield _say("\n".join(lines))
+
+
+async def _skills(session: CodexSession, arg: str) -> AsyncIterator[SseEvent]:
+    await session.ensure_open()
+    entries = (
+        await session.call("skills/list", {"cwds": [session.workspace_root]})
+    ).get("data") or []
+    skills = [s for e in entries for s in e.get("skills") or []]
+    errs = [x for e in entries for x in e.get("errors") or []]
+    lines = []
+    if not skills:
+        lines.append("이 작업공간에서 codex 가 쓰는 스킬이 없습니다.")
+    else:
+        lines += ["**codex 스킬**", ""]
+        for s in skills:
+            off = "" if s.get("enabled", True) else " (꺼짐)"
+            desc = s.get("shortDescription") or s.get("description") or ""
+            lines.append(f"- `{s.get('name')}`{off} [{s.get('scope')}] — {desc}")
+    for x in errs:
+        lines.append(f"- 읽기 오류 `{x.get('path')}`: {x.get('message')}")
+    yield _say("\n".join(lines))
+
+
+async def _hooks(session: CodexSession, arg: str) -> AsyncIterator[SseEvent]:
+    await session.ensure_open()
+    entries = (
+        await session.call("hooks/list", {"cwds": [session.workspace_root]})
+    ).get("data") or []
+    hooks = [h for e in entries for h in e.get("hooks") or []]
+    notes = [
+        x for e in entries for x in (e.get("errors") or []) + (e.get("warnings") or [])
+    ]
+    lines = []
+    if not hooks:
+        lines.append("이 작업공간에서 codex 가 쓰는 훅이 없습니다.")
+    else:
+        lines += ["**codex 훅**", ""]
+        for h in hooks:
+            off = "" if h.get("enabled", True) else " (꺼짐)"
+            lines.append(
+                f"- {h.get('eventName')}{off} — `{h.get('sourcePath')}` [{h.get('trustStatus')}]"
+            )
+    for x in notes:
+        lines.append(f"- {x.get('message') if isinstance(x, dict) else x}")
+    lines += ["", *_pod_hook_lines(session)]
+    yield _say("\n".join(lines))
+
+
+def _pod_hook_lines(session: CodexSession) -> List[str]:
+    """pod 가 대신 돌리는 hook 목록 (이슈 #145, `codex_hooks`)."""
+    errors: List[str] = []
+    hooks = codex_hooks.discover(session.workspace_root, errors)
+    ask = session.permission_mode == "ask"
+    lines = ["**pod 가 도는 훅** (PostToolUse — 파일 수정·셸은 pod 에서 일어난다)", ""]
+    for h in hooks:
+        label = {"builtin": "내장", "repo": "저장소", "user": "사용자"}[h.scope]
+        where = h.source if h.scope == "builtin" else f"`{h.source}`"
+        skip = " — ask 모드라 건너뜀" if ask and h.scope == "repo" else ""
+        lines.append(f"- [{label}] matcher `{h.matcher or '*'}` — {where}{skip}")
+    lines += [f"- {e}" for e in errors]
+    return lines
+
+
+#: `/diff` 가 화면에 싣는 diff 상한 — 넘으면 줄 경계에서 자르고 잘랐다고 적는다.
+_DIFF_MAX_CHARS = 60000
+
+#: `/review` 가 codex 에 보내는 diff 상한. `_READ_FILE_MAX_CHARS`(64,000) 와 같은 급이다
+#: — 리뷰 모드에는 도구가 없어서, 잘린 뒷부분은 모델이 따로 읽을 길이 없다.
+REVIEW_DIFF_MAX_CHARS = 60000
+
+_GIT_TIMEOUT_S = 30.0
+
+
+class _GitError(Exception):
+    """git 을 못 돌렸거나 사람이 고칠 입력(없는 ref 등)."""
+
+
+async def _git(root: str, *args: str, ok: Tuple[int, ...] = (0,)) -> str:
+    """git 을 argv 로 실행한다 — 셸을 거치지 않고 stderr 는 따로 받는다.
+
+    `_stream_command`(execute_command 도구)를 쓰지 않는 이유: 셸 문자열이라 사용자가
+    준 ref 가 셸·옵션으로 해석될 수 있고, 출력 가운데를 잘라 diff 가 깨진다.
+    """
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            "git",
+            "-C",
+            root,
+            *args,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+    except OSError as e:
+        raise _GitError(f"git 을 실행하지 못했습니다: {e}") from e
+    try:
+        out, err = await asyncio.wait_for(proc.communicate(), _GIT_TIMEOUT_S)
+    except asyncio.TimeoutError:
+        proc.kill()
+        await proc.wait()
+        raise _GitError(f"git 이 {_GIT_TIMEOUT_S:.0f}초 안에 끝나지 않았습니다.")
+    if proc.returncode not in ok:
+        raise _GitError(
+            _first_line(err.decode("utf-8", "replace"))
+            or f"git 이 실패했습니다 (rc={proc.returncode})."
+        )
+    return out.decode("utf-8", "replace")
+
+
+def _cut(text: str, limit: int) -> Tuple[str, bool]:
+    """`limit` 자 안에서 마지막 줄바꿈까지만 남긴다. 줄 가운데를 자르면 diff 가 깨진다."""
+    if len(text) <= limit:
+        return text, False
+    head = text[:limit]
+    return head[: max(head.rfind("\n"), 0)], True
+
+
+async def workspace_diff(root: str) -> Tuple[str, bool]:
+    """작업공간 git 변경을 마크다운(상태 목록 + ```diff 펜스)으로 만든다.
+
+    codex 모드 `/diff` 와 langchain 모드 `GET /codebuff/git/diff` 가 같이 쓴다 (이슈 #147).
+    두 번째 값은 git 을 읽었는지 — False 면 첫 값은 사람이 읽을 오류 문장이다.
+    """
+    # 한글 경로가 "\355\225\234" 8진수로 나오지 않게 한다
+    quote = ("-c", "core.quotePath=false")
+    try:
+        changes = (await _git(root, *quote, "status", "--short")).rstrip()
+    except _GitError as e:
+        return f"git 변경을 읽지 못했습니다: {e}", False
+    if not changes:
+        return "작업공간에 git 변경이 없습니다.", True
+    try:
+        body = await _git(root, *quote, "diff", "HEAD", "--no-color", "--no-ext-diff")
+    except _GitError:
+        # 커밋이 하나도 없으면 HEAD 가 없다 — 스테이징된 것만 보인다
+        try:
+            body = await _git(
+                root, *quote, "diff", "--cached", "--no-color", "--no-ext-diff"
+            )
+        except _GitError:
+            body = ""
+    body, was_cut = _cut(body.rstrip(), _DIFF_MAX_CHARS)
+    parts = ["**작업공간 변경**", "", "```", changes, "```"]
+    if body:
+        parts += ["", "```diff", body, "```"]
+    if was_cut:
+        parts += ["", f"(diff 가 길어 앞 {_DIFF_MAX_CHARS:,}자 안쪽만 보입니다)"]
+    return "\n".join(parts), True
+
+
+async def _diff(session: CodexSession, arg: str) -> AsyncIterator[SseEvent]:
+    text, ok = await workspace_diff(session.workspace_root)
+    yield _say(text) if ok else _fail(text)
+
+
+def _first_line(text: Any) -> str:
+    for line in str(text or "").splitlines():
+        if line.strip():
+            return line.strip()
+    return ""
+
+
+async def _commit_of(root: str, ref: str) -> str:
+    """사용자가 준 ref 를 커밋 sha 로. `--end-of-options` 라 `--output=…` 도 ref 로 읽힌다."""
+    try:
+        return (
+            await _git(
+                root,
+                "rev-parse",
+                "--verify",
+                "--quiet",
+                "--end-of-options",
+                ref + "^{commit}",
+            )
+        ).strip()
+    except _GitError:
+        raise _GitError(f"커밋을 찾지 못했습니다: {ref}")
+
+
+async def _uncommitted(root: str) -> str:
+    """HEAD 대비 변경 + 추적하지 않는 파일. 추적 안 한 파일은 `/dev/null` 과 비교한다."""
+    try:
+        await _git(root, "rev-parse", "--verify", "--quiet", "HEAD")
+    except _GitError:
+        raise _GitError(
+            "커밋이 하나도 없는 저장소라 비교할 기준이 없습니다. 첫 커밋 뒤에 다시 부르세요."
+        )
+    parts = [await _git(root, "diff", "HEAD", "--no-color", "--no-ext-diff")]
+    size = len(parts[0])
+    listed = await _git(root, "ls-files", "--others", "--exclude-standard", "-z")
+    for path in filter(None, listed.split("\0")):
+        if size > REVIEW_DIFF_MAX_CHARS:
+            break  # 어차피 잘릴 뒷부분을 만들려고 git 을 더 부르지 않는다
+        # 다르면 rc 1 이다
+        one = await _git(
+            root, "diff", "--no-index", "--no-color", "--", "/dev/null", path, ok=(0, 1)
+        )
+        parts.append(one)
+        size += len(one)
+    return "".join(parts)
+
+
+# 기본 지시문의 관점별 지침은 셀 코드리뷰와 같은 키다 (이슈 #218). 셀 리뷰 전용 형식인
+# `review_summary_prompt`(셀별 전체 개선 코드)는 diff 리뷰에 맞지 않아 쓰지 않는다.
+_REVIEW_SECTION_KEYS = (
+    "review_security_prompt",
+    "review_performance_prompt",
+    "review_quality_prompt",
+)
+# diff 리뷰의 출력 형식 — 키의 형식 예시는 셀 번호로 되어 있다
+_REVIEW_HEAD = (
+    "아래 변경을 코드리뷰해 줘. 버그·경계값·빠진 테스트를 포함해 심각한 것부터 짚고, "
+    "지적마다 셀 번호 대신 파일과 줄을 적어 줘. "
+    "관점별 지침은 다음과 같다."
+)
+
+
+def _review_default_focus(root: str) -> str:
+    """인자 없는 `/review` 의 지시문 — 코드리뷰 키로 만들고 `{{RESOURCE_CONTEXT}}` 를 채운다."""
+    from codebuff_core.managers.config_manager import prompt_value
+
+    from ..http_handlers import _inject_resource_context
+
+    sections = [prompt_value(key) for key in _REVIEW_SECTION_KEYS]
+    text = (
+        "\n\n".join([_REVIEW_HEAD, *sections])
+        + "\n"
+        + prompt_value("review_rules_prompt")
+    )
+    return _inject_resource_context(text, {"server_root_dir": root})
+
+
+async def _review(session: CodexSession, arg: str) -> AsyncIterator[SseEvent]:
+    """`review/start` 를 **custom 대상 + inline** 으로 보낸다.
+
+    리뷰 모드에서는 dynamic tool 이 불리지 않고(실측 0회), codex 서버는 작업공간과 다른
+    파일시스템에 있다. 그래서 `uncommittedChanges`·`baseBranch`·`commit` 대상을 codex 에
+    맡기지 않고, 재료(diff)를 pod 에서 만들어 지시문에 싣는다.
+    """
+    root = session.workspace_root
+    word, _, rest = arg.partition(" ")
+    rest = rest.strip()
+    focus = ""
+    try:
+        if word in ("base", "commit"):
+            if not rest:
+                raise _GitError(
+                    f"사용법: /review {word} <{'브랜치' if word == 'base' else 'sha'}>"
+                )
+            sha = await _commit_of(root, rest)
+            if word == "base":
+                label = f"`{rest}` 브랜치에서 갈라진 뒤의 변경 (merge-base..HEAD)"
+                body = await _git(
+                    root, "diff", "--no-color", "--no-ext-diff", f"{sha}...HEAD"
+                )
+            else:
+                title = (await _git(root, "log", "-1", "--format=%s", sha)).strip()
+                label = f"커밋 `{sha[:12]}` {title}"
+                body = await _git(
+                    root, "show", "--no-color", "--no-ext-diff", "--format=", sha
+                )
+        else:
+            label = "커밋하지 않은 변경 (HEAD 대비, 추적하지 않는 파일 포함)"
+            body = await _uncommitted(root)
+            if arg:
+                focus = arg
+    except _GitError as e:
+        yield _fail(f"리뷰할 변경을 만들지 못했습니다: {e}")
+        yield ("complete", {"thread_id": session.thread_id})
+        return
+
+    body, was_cut = _cut(body.rstrip(), REVIEW_DIFF_MAX_CHARS)
+    if not focus:
+        if not body:
+            yield _say(f"리뷰할 변경이 없습니다 — {label}.")
+            yield ("complete", {"thread_id": session.thread_id})
+            return
+        focus = _review_default_focus(root)
+
+    lines = [focus, "", f"대상: {label}"]
+    if body:
+        lines += ["", "```diff", body, "```"]
+    else:
+        lines += ["", "(미커밋 변경 없음 — 위 지시만 보고 답한다)"]
+    if was_cut:
+        lines += [
+            "",
+            f"(diff 가 {REVIEW_DIFF_MAX_CHARS:,}자를 넘어 줄 경계에서 잘랐다. "
+            "뒷부분은 보지 못했다고 리뷰에 밝혀 줘.)",
+        ]
+    try:
+        await session.ensure_open()
+    except CodexError as e:
+        await session.close()
+        yield _fail(str(e))
+        yield ("complete", {"thread_id": session.thread_id})
+        return
+    yield (None, {"status": "코드리뷰"})
+    async for event in session.run_request(
+        "review/start",
+        {
+            # diff·지시문이 pod 밖으로 나간다 — `run()` 의 프롬프트와 같은 관문을 지난다
+            "target": {"type": "custom", "instructions": _mask("\n".join(lines))[0]},
+            "delivery": "inline",
+        },
+    ):
+        yield event
+
+
+async def _compact(session: CodexSession, arg: str) -> AsyncIterator[SseEvent]:
+    if not session.started:
+        yield _say("압축할 대화가 없습니다. 먼저 메시지를 보내 주세요.")
+        yield ("complete", {"thread_id": session.thread_id})
+        return
+    yield (None, {"status": "컨텍스트 압축"})
+    async for event in session.run_request(
+        "thread/compact/start", {}, deadline_s=COMPACT_DEADLINE_S
+    ):
+        yield event
+
+
+# --- 스레드 관리 — 목록의 정본은 `codex_threads` (codex 의 thread/list 는 남의 것도 준다) ---
+
+
+def _thread_line(thread: Dict[str, Any]) -> str:
+    name = thread.get("name") or _first_line(thread.get("preview")) or "(이름 없음)"
+    return f"`{thread.get('id')}` {name}"
+
+
+async def _resume(session: CodexSession, arg: str) -> AsyncIterator[SseEvent]:
+    if arg:
+        if codex_threads.find(arg) is None:
+            yield _fail(
+                f"이 사용자가 연 스레드가 아닙니다: {arg} — `/resume` 으로 목록을 봅니다."
+            )
+            return
+        result = await session.switch_thread(arg)
+        thread = result.get("thread") or {}
+        yield _say(f"스레드 {_thread_line(thread)} 에 이어 붙었습니다.")
+        return
+
+    entries = [t for t in codex_threads.load() if not t.get("archived")]
+    entries = entries[: codex_threads.LIST_LIMIT]
+    if not entries:
+        yield _say("이어 붙일 codex 스레드가 없습니다. 첫 메시지를 보내면 생깁니다.")
+        return
+    await session.ensure_connected()
+    rows = []
+    for entry in entries:
+        row: Dict[str, Any] = {
+            "id": entry["id"],
+            "kind": entry.get("kind") or "start",
+            "createdAt": entry.get("createdAt"),
+            "current": entry["id"] == session.codex_thread_id,
+        }
+        try:
+            thread = (
+                await session.call(
+                    "thread/read", {"threadId": entry["id"], "includeTurns": False}
+                )
+            ).get("thread") or {}
+        except CodexRejected as e:
+            # 서버에서 지워졌거나 아직 기록이 없는 스레드 — 목록에는 두고 고르지 못하게 한다
+            row["error"] = str(e)
+        else:
+            row["name"] = thread.get("name") or ""
+            row["preview"] = _first_line(thread.get("preview"))
+            row["updatedAt"] = thread.get("updatedAt")
+        rows.append(row)
+    yield ("codex_threads", {"threads": rows})
+
+
+async def _fork(session: CodexSession, arg: str) -> AsyncIterator[SseEvent]:
+    async for event in _branch(session, "fork"):
+        yield event
+
+
+async def _side(session: CodexSession, arg: str) -> AsyncIterator[SseEvent]:
+    async for event in _branch(session, "side"):
+        yield event
+
+
+async def _branch(session: CodexSession, kind: str) -> AsyncIterator[SseEvent]:
+    if not session.started:
+        yield _say("가를 대화가 없습니다. 먼저 메시지를 보내 주세요.")
+        return
+    parent = session.codex_thread_id
+    result = await session.fork_thread(kind)
+    new_id = (result.get("thread") or {}).get("id")
+    if kind == "side":
+        yield _say(
+            f"곁가지 스레드 `{new_id}` 로 옮겼습니다. 지금까지의 문맥을 그대로 봅니다. "
+            f"끝나면 `/resume {parent}` 로 원래 스레드에 돌아갑니다."
+        )
+    else:
+        yield _say(
+            f"스레드를 갈랐습니다: 새 스레드 `{new_id}` 에서 이어 갑니다. "
+            f"원래 스레드는 `/resume {parent}` 로 돌아갈 수 있습니다."
+        )
+
+
+async def _rename(session: CodexSession, arg: str) -> AsyncIterator[SseEvent]:
+    if not arg:
+        yield _fail("사용법: /rename <이름>")
+        return
+    if not session.started:
+        yield _say("이름을 붙일 스레드가 없습니다. 먼저 메시지를 보내 주세요.")
+        return
+    tid = session.codex_thread_id
+    await session.call("thread/name/set", {"threadId": tid, "name": _mask(arg)[0]})
+    codex_threads.update(tid, name=arg)
+    yield _say(f"스레드 `{tid}` 의 이름을 '{arg}' 로 바꿨습니다.")
+
+
+async def _archive(session: CodexSession, arg: str) -> AsyncIterator[SseEvent]:
+    if not session.started:
+        yield _say("보관할 스레드가 없습니다.")
+        return
+    tid = session.codex_thread_id
+    await session.call("thread/archive", {"threadId": tid})
+    codex_threads.update(tid, archived=True)
+    session.leave_thread()
+    yield _say(f"스레드 `{tid}` 를 보관했습니다. 다음 메시지는 새 스레드로 시작합니다.")
+
+
+async def _delete(session: CodexSession, arg: str) -> AsyncIterator[SseEvent]:
+    if not session.started:
+        yield _say("지울 스레드가 없습니다.")
+        return
+    tid = session.codex_thread_id
+    if arg != "confirm":
+        yield _say(
+            f"스레드 `{tid}` 를 codex 에서 지웁니다. 되돌릴 수 없습니다 — "
+            "실행하려면 `/delete confirm` 을 보냅니다."
+        )
+        return
+    await session.call("thread/delete", {"threadId": tid})
+    codex_threads.forget(tid)
+    session.leave_thread()
+    yield _say(f"스레드 `{tid}` 를 지웠습니다. 다음 메시지는 새 스레드로 시작합니다.")
+
+
+_LOCAL_COMMANDS = {
+    "/status": _status,
+    "/model": _model,
+    "/mcp": _mcp,
+    "/skills": _skills,
+    "/hooks": _hooks,
+    "/diff": _diff,
+    "/resume": _resume,
+    "/fork": _fork,
+    "/side": _side,
+    "/rename": _rename,
+    "/archive": _archive,
+    "/delete": _delete,
+}
+
+_TURN_COMMANDS = {
+    "/compact": _compact,
+    "/review": _review,
+}