remote-coder 0.5.0__tar.gz → 0.5.1__tar.gz

{remote_coder-0.5.0 → remote_coder-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remote-coder
-Version: 0.5.0
+Version: 0.5.1
 Summary: Telegram-based remote AI coding automation server
 Author: Remote AI Coder contributors
 License:                                  Apache License

{remote_coder-0.5.0 → remote_coder-0.5.1}/app/__init__.py

@@ -1,3 +1,3 @@
 """Remote AI Coder application package."""
 
-__version__ = "0.5.0"
+__version__ = "0.5.1"

{remote_coder-0.5.0 → remote_coder-0.5.1}/app/ai/base.py

@@ -80,6 +80,7 @@ class RunnerInput:
     mode: JobMode = JobMode.AGENT
     session_id: str | None = None
     resume_token: str | None = None
+    native_resume_cwd_stable: bool = True
 
 
 @dataclass

{remote_coder-0.5.0 → remote_coder-0.5.1}/app/ai/claude.py

@@ -12,13 +12,20 @@ class ClaudeRunner(BaseCliRunner):
         self, runner_input: RunnerInput, before: dict[str, float]
     ) -> str | None:
         # Claude owns its session id deterministically (we pass --session-id/--resume).
-        return runner_input.resume_token or runner_input.session_id
+        return self._effective_resume_token(runner_input) or runner_input.session_id
+
+    @staticmethod
+    def _effective_resume_token(runner_input: RunnerInput) -> str | None:
+        if not runner_input.native_resume_cwd_stable:
+            return None
+        return runner_input.resume_token
 
     def build_argv(self, runner_input: RunnerInput) -> list[str]:
         prompt = instruction_for_runner_mode(runner_input.instruction, runner_input.mode)
         argv = ["claude", "-p", prompt, "--dangerously-skip-permissions"]
-        if runner_input.resume_token:
-            argv.extend(["--resume", runner_input.resume_token])
+        resume_token = self._effective_resume_token(runner_input)
+        if resume_token:
+            argv.extend(["--resume", resume_token])
         elif runner_input.session_id:
             argv.extend(["--session-id", runner_input.session_id])
         if runner_input.model_id:

{remote_coder-0.5.0 → remote_coder-0.5.1}/app/jobs/execution_pipeline.py

@@ -96,6 +96,7 @@ def run_job(manager, job_id: str) -> Job:
                     mode=job.request.mode,
                     session_id=job.request.session_id,
                     resume_token=job.request.resume_session_token,
+                    native_resume_cwd_stable=not created_worktree_for_job,
                 )
             )
         finally:

{remote_coder-0.5.0 → remote_coder-0.5.1}/app/jobs/fix_pipeline.py

@@ -92,6 +92,7 @@ def run_fix_job(manager, job_id: str) -> Job:
                     mode=JobMode.AGENT,
                     session_id=job.request.session_id,
                     resume_token=job.request.resume_session_token,
+                    native_resume_cwd_stable=not created_worktree_for_job,
                 )
             )
         finally:

{remote_coder-0.5.0 → remote_coder-0.5.1}/app/jobs/heartbeat.py

@@ -8,33 +8,42 @@ from app.jobs.schemas import Job
 from app.telegram.notifier import Notifier, build_job_accepted_message, build_job_heartbeat_message
 
 
+class HeartbeatHandle:
+    def __init__(self, stop_event: threading.Event, thread: threading.Thread | None) -> None:
+        self._stop = stop_event
+        self._thread = thread
+
+    def set(self) -> None:
+        # Stop the heartbeat and wait for any in-flight edit so the caller's next
+        # edit (send_job_result) wins the race for the same message_id.
+        self._stop.set()
+        if self._thread is not None:
+            self._thread.join(timeout=15)
+
+
 def start_heartbeat(
     *,
     job: Job,
     notifier_resolver: Callable[[str], Notifier],
     interval_seconds: float,
-) -> threading.Event:
+) -> HeartbeatHandle:
     # Periodically edit the "Job accepted" message so a long run shows live progress.
     # No-op when there is no message to edit (e.g. notifier returned no id).
     stop = threading.Event()
     if job.accepted_message_id is None:
-        return stop
+        return HeartbeatHandle(stop, None)
     notifier = notifier_resolver(job.request.project)
     chat_id = job.request.chat_id
     message_id = job.accepted_message_id
     started = datetime.now(UTC)
-    accepted_text, stop_buttons = build_job_accepted_message(job)
-    edited = threading.Event()
+    _, stop_buttons = build_job_accepted_message(job)
 
     def _beat() -> None:
         while not stop.wait(interval_seconds):
             elapsed_minutes = int((datetime.now(UTC) - started).total_seconds() // 60)
             text = build_job_heartbeat_message(job, elapsed_minutes)
             notifier.edit_message(chat_id, message_id, text, stop_buttons)
-            edited.set()
-        if edited.is_set():
-            # Restore the original accepted body without the now-useless Stop button.
-            notifier.edit_message(chat_id, message_id, accepted_text, [])
 
-    threading.Thread(target=_beat, daemon=True).start()
-    return stop
+    thread = threading.Thread(target=_beat, daemon=True)
+    thread.start()
+    return HeartbeatHandle(stop, thread)

{remote_coder-0.5.0 → remote_coder-0.5.1}/app/jobs/manager.py

@@ -20,7 +20,7 @@ from app.jobs.fix_support import (
     list_fix_candidates,
     resolve_fix_target_job,
 )
-from app.jobs.heartbeat import start_heartbeat
+from app.jobs.heartbeat import HeartbeatHandle, start_heartbeat
 from app.jobs.plan_decisions import PlanDecisionQuestion
 from app.jobs.result_writer import (
     make_output_summary,
@@ -37,6 +37,19 @@ from app.telegram.notifier import Notifier
 
 _joblog = EventLogger("app.jobs.lifecycle", "job.lifecycle")
 
+# Telegram only allows reactions from a fixed allow-list of emoji, so map the job
+# lifecycle onto values from https://core.telegram.org/bots/api#reactiontypeemoji.
+_REACTION_QUEUED = "👀"
+_REACTION_SUCCEEDED = "🎉"
+_REACTION_FAILED = "💔"
+_REACTION_CANCELLED = "🤝"
+
+_TERMINAL_REACTION_BY_STATUS = {
+    "succeeded": _REACTION_SUCCEEDED,
+    "failed": _REACTION_FAILED,
+    "cancelled": _REACTION_CANCELLED,
+}
+
 
 class JobManager:
     def __init__(
@@ -73,7 +86,7 @@ class JobManager:
     def _notifier_for(self, project: str) -> Notifier:
         return self._notifier_resolver(project)
 
-    def _start_heartbeat(self, job: Job) -> threading.Event:
+    def _start_heartbeat(self, job: Job) -> HeartbeatHandle:
         return start_heartbeat(
             job=job,
             notifier_resolver=self._notifier_for,
@@ -104,6 +117,21 @@ class JobManager:
             self._notifier_for(job.request.project).send_job_result(job)
         )
         self._job_store.update(job)
+        self._react(job.request, _TERMINAL_REACTION_BY_STATUS.get(job.status.value))
+
+    def _react(self, request: JobRequest, emoji: str | None) -> None:
+        if request.message_id is None or emoji is None:
+            return
+        try:
+            self._notifier_for(request.project).set_reaction(
+                request.chat_id, request.message_id, emoji
+            )
+        except Exception:  # pylint: disable=broad-except
+            _joblog.exception(
+                "set_reaction failed",
+                chat_id=request.chat_id,
+                project=request.project,
+            )
 
     def submit(self, request: JobRequest) -> Job:
         job = Job(id=request.job_id or self._make_job_id(), request=request)
@@ -120,6 +148,7 @@ class JobManager:
         if accepted_message_id is not None:
             job.accepted_message_id = accepted_message_id
             self._job_store.update(job)
+        self._react(request, _REACTION_QUEUED)
         return job
 
     def cancel(self, job_id: str) -> bool:
@@ -218,6 +247,7 @@ class JobManager:
         if accepted_message_id is not None:
             job.accepted_message_id = accepted_message_id
             self._job_store.update(job)
+        self._react(request, _REACTION_QUEUED)
         with self._project_lock(request.project):
             return self._run_fix(job.id)
 

{remote_coder-0.5.0 → remote_coder-0.5.1}/app/main.py

@@ -1,7 +1,7 @@
 import asyncio
 import logging
 import time
-from contextlib import asynccontextmanager
+from contextlib import asynccontextmanager, suppress
 from dataclasses import replace
 
 from fastapi import FastAPI, Request
@@ -137,9 +137,8 @@ webhook_registrar = (
     else None
 )
 
-@asynccontextmanager
-async def lifespan(_app: FastAPI):
-    instances = bot_instance_manager.list_all()
+
+def _run_startup_side_effects(instances: list[BotInstance], adv: AdvancedSettings) -> None:
     startup_chat_total = sum(len(inst.auth_service.allowed_chat_ids) for inst in instances)
     _systemlog.info(
         "lifespan startup notifying allowed chats count=%d projects=%d default_model=%s",
@@ -147,9 +146,7 @@ async def lifespan(_app: FastAPI):
         len(project_registry.list_projects()),
         ModelName.CLAUDE.value,
     )
-    adv = advanced_settings_store.get()
-    await asyncio.to_thread(
-        run_startup_project_pulls,
+    run_startup_project_pulls(
         pull_projects_on_server_startup_enabled=adv.pull_projects_on_server_startup_enabled,
         project_registry=project_registry,
         git_service=git_service,
@@ -178,7 +175,28 @@ async def lifespan(_app: FastAPI):
                     _systemlog.info("startup notification sent", chat_id=chat_id)
             except Exception:
                 _systemlog.exception("startup notification failed", chat_id=chat_id)
+
+
+async def _run_startup_side_effects_in_background(
+    instances: list[BotInstance], adv: AdvancedSettings
+) -> None:
+    try:
+        await asyncio.to_thread(_run_startup_side_effects, instances, adv)
+    except Exception:
+        _systemlog.exception("startup side effects failed")
+
+
+@asynccontextmanager
+async def lifespan(_app: FastAPI):
+    instances = bot_instance_manager.list_all()
+    startup_task = asyncio.create_task(
+        _run_startup_side_effects_in_background(instances, advanced_settings_store.get())
+    )
     yield
+    if not startup_task.done():
+        startup_task.cancel()
+    with suppress(asyncio.CancelledError):
+        await startup_task
     shutdown_instances = bot_instance_manager.list_all()
     shutdown_chat_total = sum(len(inst.auth_service.allowed_chat_ids) for inst in shutdown_instances)
     _systemlog.info("lifespan shutdown notifying allowed chats count=%d", shutdown_chat_total)

{remote_coder-0.5.0 → remote_coder-0.5.1}/app/monitoring/git.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from pathlib import Path
 
 from app.git.service import GitWorktreeService
+from app.telegram.lists import render_labeled_list
 
 
 TELEGRAM_SAFE_LEN = 3800
@@ -24,16 +25,19 @@ def format_branch_monitor(
     except RuntimeError as exc:
         return f"/monitor branch failed: {exc}"
 
-    header = (
-        f"Branch monitor\n"
-        f"Project: {project_name}\n"
-        f"root: {root}\n"
-        f"Remote: {remote}\n"
-        f"Current checkout: {current}\n"
-        f"Local branches: {local_n}\n"
-        f"{remote} remote-tracking branches: {remote_n}\n\n"
+    summary_rows = [
+        ("Project", project_name),
+        ("root", str(root)),
+        ("Remote", remote),
+        ("Current checkout", current),
+        ("Local branches", str(local_n)),
+        ("Remote-tracking branches", str(remote_n)),
+    ]
+    header = "Branch monitor\n" + render_labeled_list(summary_rows) + "\n\n"
+    body = (
+        f"Local branches\n{_render_text_list(local_block)}\n\n"
+        f"Remote branches\n{_render_text_list(remote_block)}"
     )
-    body = f"[Local]\n{local_block}\n\n[{remote} remote]\n{remote_block}"
     text = header + body
     if len(text) > max_len:
         text = text[:max_len].rstrip() + "\n\n...(truncated for message length)"
@@ -87,17 +91,31 @@ def format_worktree_monitor(
     if len(entries) > max_detail:
         extra = f"\n...({len(entries) - max_detail} more omitted)"
 
+    summary_rows = [
+        ("Project", project_name),
+        ("root", str(root)),
+        ("Managed base directory", str(managed_base)),
+        ("Total worktrees", str(len(entries))),
+        ("Detached worktrees", str(detached_n)),
+        ("Managed candidates", str(managed_n)),
+    ]
     lines = [
         "Worktree monitor",
-        f"Project: {project_name}",
-        f"root: {root}",
-        f"Managed base directory (worktree_base): {managed_base}",
-        f"Total worktrees: {len(entries)}",
-        f"Detached worktrees: {detached_n}",
-        f"Managed candidates (remote-*, base, _rebase_ops): {managed_n}",
+        render_labeled_list(summary_rows),
         "",
-        "[Entries]",
+        "Worktree entries",
         *detail_lines,
         extra,
     ]
     return "\n".join(lines).strip()
+
+
+def _render_text_list(text: str) -> str:
+    items: list[str] = []
+    for raw in text.splitlines():
+        item = raw.strip()
+        if item.startswith("* "):
+            item = item[2:]
+        if item:
+            items.append(f"- {item}")
+    return "\n".join(items)

remote_coder-0.5.1/app/monitoring/memory.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from app.telegram.conversation import ConversationDbChatStats
+from app.telegram.lists import render_labeled_list
+
+
+def format_memory_monitor(stats: ConversationDbChatStats, project: str, chat_id: int) -> str:
+    size_kb = stats.db_size_bytes / 1024.0 if stats.db_size_bytes else 0.0
+    summary_rows: list[tuple[str, str]] = [
+        ("Project", project),
+        ("chat_id", str(chat_id)),
+        ("DB path", str(stats.db_path)),
+        ("DB exists", "yes" if stats.db_exists else "no"),
+        ("DB size", f"{size_kb:.2f} KiB ({stats.db_size_bytes} bytes)"),
+        ("Rows for this chat", str(stats.total_rows)),
+        ("Sessions", str(stats.session_count)),
+    ]
+    if stats.rows_by_role:
+        role_rows = [(role, str(count)) for role, count in sorted(stats.rows_by_role.items())]
+    else:
+        role_rows = [("(none)", "0")]
+    return "\n".join(
+        [
+            "Memory (SQLite)",
+            render_labeled_list(summary_rows),
+            "",
+            "Rows by role",
+            render_labeled_list(role_rows),
+        ]
+    )

{remote_coder-0.5.0 → remote_coder-0.5.1}/app/telegram/commands/base.py

@@ -12,6 +12,7 @@ from app.projects.registry import ProjectRegistry
 from app.telegram.confirmations import InMemoryConfirmationStore, PendingConfirmation
 from app.telegram.conversation import SQLiteConversationStore
 from app.telegram.model_preferences import InMemoryModelPreferenceStore, ModelPreference
+from app.telegram.lists import render_command_list
 
 if TYPE_CHECKING:
     from app.admin.advanced_settings import FileAdvancedSettingsStore
@@ -54,6 +55,7 @@ MODEL_USAGE = "<claude|codex|gemini>"
 class InlineButton:
     label: str
     callback_data: str
+    style: str | None = None
 
 
 @dataclass
@@ -69,13 +71,30 @@ def _help_response_skips_notifier_body_i18n(message_text: str) -> bool:
     return False
 
 
+_HELP_COMMAND_ROWS: tuple[tuple[str, str, str], ...] = (
+    ("/model", "<claude|codex|gemini>", "Change the default model"),
+    ("/status", "<job_id>", "Check job status"),
+    ("/branch", "[name]", "Show or switch branches"),
+    ("/pull", "", "Pull remote branch updates"),
+    ("/rebase", "[branch]", "Rebase a branch"),
+    ("/pr", "[branch]", "Open a GitHub PR"),
+    ("/monitor", "<scope>", "Monitoring"),
+    ("/clear", "<branch|worktrees|memory>", "Cleanup (confirmation)"),
+    ("/reports", "[count]", "Conversation memory report"),
+    ("/init", "", "Reset this chat's settings"),
+    ("/stop", "<job_id>", "Stop a running job"),
+    ("/fix", "", "Fix linked job commit"),
+    ("/start", "", "Inline menu"),
+)
+
+
 HELP_TEXT = "\n".join(
     [
-        "Help",
+        "🧭 Help",
         "",
         "Send work requests as regular messages.",
         "",
-        "Options",
+        "⚙️ Options",
         "- model:",
         "- branch:",
         "- no commit",
@@ -84,31 +103,21 @@ HELP_TEXT = "\n".join(
         "- fix: <natural language> or /fix - fix mode (reply to a job result; amends that commit)",
         "- Korean aliases 계획:, 질문:, and 수정: instead of plan:/ask:/fix: (colons `:` or full-width `：` allowed)",
         "",
-        "Commands:",
-        "- /model <claude|codex|gemini>: Change the default model",
-        "- /status <job_id>: Check job status",
-        "- /branch [name]: Show or switch branches",
-        "- /pull: Pull all remote branch updates",
-        "- /rebase [branch]: Rebase a branch",
-        "- /pr [branch]: Open a GitHub PR for a branch",
-        "- /monitor <model|memory|branch|worktrees|code|project>: Monitoring",
-        "- /clear <branch|worktrees|memory>: Cleanup (confirmation required)",
-        "- /reports [count]: Conversation memory report",
-        "- /init: Reset this chat's settings",
-        "- /stop <job_id>: Stop a running job",
-        "- /fix: Fix the linked job commit (reply to a job result first)",
-        "- /start: Inline menu",
+        "📋 Commands",
+        render_command_list(_HELP_COMMAND_ROWS),
+        "",
+        "💡 Tip: Reply to a job result and send `fix: ...` to amend that commit.",
     ]
 )
 
 HELP_AGENT_TOPIC = "\n".join(
     [
-        "AGENTS mode (agent)",
+        "🤖 AGENTS mode (agent)",
         "",
         "Natural-language coding tasks. The agent can modify code in the current project; when there are "
         "changes it can create or update a branch, commit, and push.",
         "",
-        "Examples",
+        "💡 Examples",
         "- fix the login validation bug",
         "- model: codex branch: remote-auth strengthen tests",
         "- no commit just verify the doc wording",
@@ -119,12 +128,12 @@ HELP_AGENT_TOPIC = "\n".join(
 
 HELP_PLAN_TOPIC = "\n".join(
     [
-        "Plan mode (plan)",
+        "📐 Plan mode (plan)",
         "",
         "Receive change plans only; no code edits. Like agent mode, a job is accepted after confirmation "
         "(`y`/`Y` or inline buttons).",
         "",
-        "Examples",
+        "💡 Examples",
         "- plan: summarize the login validation flow",
         "- /plan model: codex list only API boundary risks",
         "- 계획：refactor steps (full-width colon)",
@@ -135,12 +144,12 @@ HELP_PLAN_TOPIC = "\n".join(
 
 HELP_ASK_TOPIC = "\n".join(
     [
-        "Ask mode (ask)",
+        "❓ Ask mode (ask)",
         "",
         "Answer questions using the repository; no code edits, commits, or pushes. Jobs are accepted like "
         "agent mode after confirmation (`y`/`Y` or inline buttons).",
         "",
-        "Examples",
+        "💡 Examples",
         "- ask: how do I run pytest in this project?",
         "- /ask explain JobManager.run stages",
         "- 질문：what this error line means",
@@ -151,12 +160,12 @@ HELP_ASK_TOPIC = "\n".join(
 
 HELP_FIX_TOPIC = "\n".join(
     [
-        "Fix mode (fix)",
+        "🔧 Fix mode (fix)",
         "",
         "Apply follow-up fixes on top of a previous succeeded job. Reply to a job result, then use "
         "fix: or /fix. The agent amends the existing commit and pushes with --force-with-lease.",
         "",
-        "Examples",
+        "💡 Examples",
         "- (reply to job result) fix: add missing tests",
         "- (reply to job result) /fix then send the fix instruction",
         "- (reply to job result) 수정：로그인 검증 버그도 고쳐줘",

{remote_coder-0.5.0 → remote_coder-0.5.1}/app/telegram/commands/status.py

@@ -188,11 +188,11 @@ class StatusCommand(TelegramCommand):
         rows: list[list[InlineButton]] = []
         status = job.status.value
         if status in ("running", "queued"):
-            rows.append([InlineButton("Stop", f"/stop {job.id}")])
+            rows.append([InlineButton("Stop", f"/stop {job.id}", style="danger")])
         elif status == "succeeded" and job.branch:
             actions: list[InlineButton] = []
             if job.commit_hash:
-                actions.append(InlineButton("Open PR", f"/pr {job.branch}"))
+                actions.append(InlineButton("Open PR", f"/pr {job.branch}", style="primary"))
             actions.append(InlineButton("Rebase", f"/rebase {job.branch}"))
             rows.append(actions)
         return with_nav_row(rows, back_to="/status")

{remote_coder-0.5.0 → remote_coder-0.5.1}/app/telegram/commands/system.py

@@ -11,7 +11,6 @@ from app.telegram.commands.base import (
     InlineButton,
     TelegramCommand,
     TelegramMessage,
-    _button_rows,
     _cmd_evt,
     effective_model_for_chat,
     effective_project_name_for_chat,
@@ -42,30 +41,35 @@ class StartCommand(TelegramCommand):
                 return topic_text
         project_name = effective_project_name_for_chat(ctx, message.chat_id)
         if not project_name:
-            return f"{self._ready_line()}\n\nWelcome to Remote AI Coder."
+            return (
+                f"{self._ready_line()}\n\n"
+                "Welcome to Remote AI Coder.\n"
+                "Send a coding request or tap Help to start."
+            )
         entry = ctx.project_registry.get(project_name)
         if not entry:
             return (
                 f"{self._ready_line()}\n\n"
-                "Welcome to Remote AI Coder.\n"
                 f"- Project: {project_name} (not registered)"
             )
+        if not entry.enabled:
+            return (
+                f"{self._ready_line()}\n\n"
+                f"- Project: {entry.name} (disabled)"
+            )
         try:
             current_branch = ctx.git_service.get_current_branch(entry.root_path)
         except RuntimeError:
             current_branch = "(check failed)"
-        state = "enabled" if entry.enabled else "disabled"
         return "\n".join(
             [
                 self._ready_line(),
                 "",
-                "Welcome to Remote AI Coder.",
                 f"- Project: {entry.name}",
-                f"- root_path: {entry.root_path}",
-                f"- default_model: {entry.default_model.value}",
-                f"- current_branch: {current_branch}",
-                f"- worktree_base_dir: {entry.worktree_base_dir}",
-                f"- enabled: {state}",
+                f"- Model: {entry.default_model.value}",
+                f"- Branch: {current_branch}",
+                "",
+                "Send a coding request or tap Help to start.",
             ]
         )
 
@@ -138,25 +142,7 @@ class HelpCommand(TelegramCommand):
         message: TelegramMessage | None = None,
         ctx: CommandContext | None = None,
     ) -> list[list[InlineButton]] | None:
-        if self._registry is None:
-            return None
-        tokens = message.text.strip().split() if message else []
-        if len(tokens) >= 2:
-            topic = tokens[1].lower()
-            if topic in ("agent", "agents", "plan", "ask", "fix"):
-                return with_nav_row(None, back_to="/help")
-            subcmd = self._registry.get("/" + tokens[1])
-            if subcmd is not None:
-                sub_buttons = subcmd.get_inline_buttons(None, ctx) or []
-                return with_nav_row(sub_buttons, back_to="/help")
-        menu_cmds = [
-            cmd for name, cmd in self._registry.items()
-            if name not in ("/help", "/start") and cmd.menu_text
-        ]
-        if not menu_cmds:
-            return None
-        buttons = [InlineButton(cmd.name[1:], f"/help {cmd.name[1:]}") for cmd in menu_cmds]
-        return with_nav_row(_button_rows(buttons, per_row=2))
+        return None
 
 
 class InitCommand(TelegramCommand):

{remote_coder-0.5.0 → remote_coder-0.5.1}/app/telegram/formatting.py

@@ -13,12 +13,26 @@ _SECTION_HEADINGS = frozenset(
     {
         "Options",
         "옵션",
+        "⚙️ Options",
+        "⚙️ 옵션",
         "Commands:",
         "명령어 목록:",
+        "📋 Commands",
+        "📋 명령어 목록",
+        "Rows by role",
+        "역할별 행 수",
+        "Local branches",
+        "로컬 브랜치",
+        "Remote branches",
+        "원격 브랜치",
+        "Worktree entries",
+        "Worktree 항목",
         "Usage",
         "사용법",
         "Examples",
         "예시",
+        "💡 Examples",
+        "💡 예시",
         "Prerequisites",
         "전제조건",
         "AI response:",
@@ -46,12 +60,17 @@ _BODY_MARKERS = frozenset(
 _CODE_VALUE_LINE = re.compile(
     r"^(?P<prefix>\s*-\s*(?:Job ID|Session ID|Branch|Commit|Log path|브랜치|커밋|로그 경로)\s*:\s*)(?P<value>\S.*?)\s*$"
 )
+_COMMAND_LIST_LINE = re.compile(r"^\s*-\s+(?P<command>/\S+(?:\s+\S.*)?)\s*$")
 
 
 def _utf16_units(text: str) -> int:
     return len(text.encode("utf-16-le")) // 2
 
 
+def prepare_outgoing(text: str) -> tuple[str, list[dict[str, int | str]]]:
+    return text, build_message_entities(text)
+
+
 def build_message_entities(text: str) -> list[dict[str, int | str]]:
     """Compute BotFather-like entities (bold title/headings, code values)."""
     lines = text.split("\n")
@@ -77,14 +96,25 @@ def build_message_entities(text: str) -> list[dict[str, int | str]]:
                 if stripped in _BODY_MARKERS:
                     body_started = True
             else:
-                match = _CODE_VALUE_LINE.match(line)
-                if match is not None and not match.group("value").startswith("("):
+                command_match = _COMMAND_LIST_LINE.match(line)
+                if command_match is not None:
+                    command = command_match.group("command")
                     entities.append(
                         {
                             "type": "code",
-                            "offset": offset + _utf16_units(match.group("prefix")),
-                            "length": _utf16_units(match.group("value")),
+                            "offset": offset + _utf16_units(line[: command_match.start("command")]),
+                            "length": _utf16_units(command),
                         }
                     )
+                else:
+                    value_match = _CODE_VALUE_LINE.match(line)
+                    if value_match is not None and not value_match.group("value").startswith("("):
+                        entities.append(
+                            {
+                                "type": "code",
+                                "offset": offset + _utf16_units(value_match.group("prefix")),
+                                "length": _utf16_units(value_match.group("value")),
+                            }
+                        )
         offset += line_units + 1
     return entities