@researai/deepscientist 1.5.13 → 1.5.15

package/src/deepscientist/bash_exec/service.py

@@ -3,9 +3,7 @@ from __future__ import annotations
 import json
 import os
 import re
-import shlex
 import shutil
-import signal
 import subprocess
 import sys
 import tempfile
@@ -17,7 +15,9 @@ from pathlib import Path
 from typing import Any
 
 from ..mcp.context import McpContext
+from ..process_control import is_process_alive, process_session_popen_kwargs, terminate_process_ids
 from ..shared import append_jsonl, ensure_dir, generate_id, iter_jsonl, read_json, read_jsonl, read_jsonl_tail, utc_now
+from .shells import build_exec_shell_launch, build_terminal_shell_launch
 from .runtime import TerminalRuntimeManager
 
 BASH_STATUS_MARKER_PREFIX = "__DS_BASH_STATUS__"
@@ -114,26 +114,6 @@ def _session_sort_key(session: dict[str, Any]) -> tuple[str, str]:
     )
 
 
-def _is_process_alive(pid: object) -> bool:
-    if not isinstance(pid, int) or pid <= 0:
-        return False
-    proc_stat_path = Path("/proc") / str(pid) / "stat"
-    if proc_stat_path.exists():
-        try:
-            parts = proc_stat_path.read_text(encoding="utf-8").split()
-        except OSError:
-            parts = []
-        if len(parts) >= 3 and parts[2] == "Z":
-            return False
-    try:
-        os.kill(pid, 0)
-    except ProcessLookupError:
-        return False
-    except PermissionError:
-        return True
-    return True
-
-
 def _parse_progress_marker(line: str) -> dict[str, Any] | None:
     if not line.startswith(BASH_PROGRESS_PREFIX):
         return None
@@ -518,20 +498,14 @@ class BashExecService:
                 return self._session_payload(quest_root, read_json(meta_path, meta) or meta)
         monitor_pid = meta.get("monitor_pid")
         process_pid = meta.get("process_pid")
-        if kind == "terminal" and _is_process_alive(process_pid):
-            process_group_id = meta.get("process_group_id")
-            if isinstance(process_group_id, int) and process_group_id > 0:
-                try:
-                    os.killpg(process_group_id, signal.SIGTERM)
-                except ProcessLookupError:
-                    pass
-            elif isinstance(process_pid, int) and process_pid > 0:
-                try:
-                    os.kill(process_pid, signal.SIGTERM)
-                except ProcessLookupError:
-                    pass
+        if kind == "terminal" and is_process_alive(process_pid):
+            terminate_process_ids(
+                process_pid=process_pid if isinstance(process_pid, int) else None,
+                process_group_id=meta.get("process_group_id") if isinstance(meta.get("process_group_id"), int) else None,
+                force=False,
+            )
             time.sleep(0.05)
-        if kind != "terminal" and (_is_process_alive(process_pid) or _is_process_alive(monitor_pid)):
+        if kind != "terminal" and (is_process_alive(process_pid) or is_process_alive(monitor_pid)):
             return self._session_payload(quest_root, meta)
         stop_reason = _normalize_string(meta.get("stop_reason"))
         meta["status"] = "terminated" if stop_reason else "failed"
@@ -566,6 +540,10 @@ class BashExecService:
         normalized_agent_instance_ids = {item for item in (agent_instance_ids or []) if item}
         normalized_agent_ids = {item for item in (agent_ids or []) if item}
         normalized_chat_session = _normalize_string(chat_session_id)
+        if normalized_status in {"running", "terminating"}:
+            summary = self.summary(quest_root)
+            if int(summary.get("running_count") or 0) <= 0:
+                return []
         sessions: list[dict[str, Any]] = []
         for bash_id in self._list_session_ids(quest_root):
             try:
@@ -717,18 +695,11 @@ class BashExecService:
         if runtime is not None:
             runtime.stop(reason=request_payload["reason"], force=bool(force))
         else:
-            process_group_id = meta.get("process_group_id")
-            process_pid = meta.get("process_pid")
-            if isinstance(process_group_id, int) and process_group_id > 0:
-                try:
-                    os.killpg(process_group_id, signal.SIGKILL if force else signal.SIGTERM)
-                except ProcessLookupError:
-                    pass
-            elif isinstance(process_pid, int) and process_pid > 0:
-                try:
-                    os.kill(process_pid, signal.SIGKILL if force else signal.SIGTERM)
-                except ProcessLookupError:
-                    pass
+            terminate_process_ids(
+                process_pid=meta.get("process_pid") if isinstance(meta.get("process_pid"), int) else None,
+                process_group_id=meta.get("process_group_id") if isinstance(meta.get("process_group_id"), int) else None,
+                force=bool(force),
+            )
         return self._session_payload(quest_root, meta)
 
     def _build_initial_meta(
@@ -737,6 +708,7 @@ class BashExecService:
         context: McpContext,
         bash_id: str,
         command: str,
+        launch_argv: list[str] | None,
         mode: str,
         cwd: Path,
         workdir_display: str,
@@ -744,6 +716,8 @@ class BashExecService:
         env_keys: list[str],
         comment: str | dict[str, Any] | None = None,
         kind: str = "exec",
+        shell_family: str | None = None,
+        shell_name: str | None = None,
     ) -> dict[str, Any]:
         quest_root = context.require_quest_root().resolve()
         session_id = _normalize_string(context.conversation_id) or f"quest:{context.quest_id or quest_root.name}"
@@ -766,6 +740,9 @@ class BashExecService:
             "stopped_by_user_id": None,
             "comment": comment,
             "command": command,
+            "launch_argv": list(launch_argv or []),
+            "shell_family": shell_family,
+            "shell_name": shell_name,
             "workdir": workdir_display,
             "cwd": str(cwd),
             "kind": kind,
@@ -808,7 +785,7 @@ class BashExecService:
                 stderr=monitor_log_handle,
                 cwd=str(quest_root),
                 env=monitor_env,
-                start_new_session=True,
+                **process_session_popen_kwargs(hide_window=True),
             )
         finally:
             monitor_log_handle.close()
@@ -833,10 +810,12 @@ class BashExecService:
         session_dir = self.session_dir(quest_root, bash_id)
         ensure_dir(session_dir)
         env_payload = {str(key): str(value) for key, value in (env or {}).items() if value is not None}
+        launch = build_exec_shell_launch(command)
         meta = self._build_initial_meta(
             context=context,
             bash_id=bash_id,
             command=command,
+            launch_argv=launch.argv,
             mode=mode,
             cwd=cwd,
             workdir_display=workdir_display,
@@ -844,6 +823,8 @@ class BashExecService:
             env_keys=sorted(env_payload),
             comment=comment,
             kind="exec",
+            shell_family=launch.family,
+            shell_name=launch.shell_name,
         )
         self.terminal_log_path(quest_root, bash_id).touch()
         self.log_path(quest_root, bash_id).touch()
@@ -880,10 +861,14 @@ class BashExecService:
         cwd: Path,
         workdir_display: str,
         command: str,
+        launch_argv: list[str] | None,
         source: str,
         conversation_id: str | None,
         user_id: str | None,
         env_keys: list[str],
+        shell_family: str | None = None,
+        shell_name: str | None = None,
+        transport_preference: str | None = None,
     ) -> dict[str, Any]:
         timestamp = utc_now()
         session_id = _normalize_string(conversation_id) or f"quest:{quest_id}:terminal"
@@ -903,6 +888,10 @@ class BashExecService:
             "stopped_by_user_id": None,
             "label": label,
             "command": command,
+            "launch_argv": list(launch_argv or []),
+            "shell_family": shell_family,
+            "shell_name": shell_name,
+            "transport_preference": transport_preference,
             "workdir": workdir_display,
             "cwd": str(cwd),
             "kind": "terminal",
@@ -984,29 +973,49 @@ class BashExecService:
             self.line_buffer_path(resolved_quest_root, bash_id),
             {"buffer": "", "updated_at": utc_now()},
         )
-        terminal_rc_path = self.terminal_rc_path(resolved_quest_root, bash_id)
-        terminal_rc_path.write_text(
-            "\n".join(
-                [
-                    "PS1='\\w$ '",
-                    "PS2='> '",
-                    'PROMPT_COMMAND=\'printf "__DS_TERMINAL_PROMPT__ cwd=%q ts=%s\\n" "$PWD" "$(date -u +%FT%TZ)" >> "${DS_TERMINAL_PROMPT_PATH}"\'',
-                    "bind 'set enable-bracketed-paste off' >/dev/null 2>&1 || true",
-                    "",
-                ]
-            ),
-            encoding="utf-8",
-        )
+        terminal_script_path = session_dir / ("terminal.ps1" if os.name == "nt" else "terminal.rc")
         stop_request = self.stop_request_path(resolved_quest_root, bash_id)
         if stop_request.exists():
             stop_request.unlink()
 
         env_payload = {
-            "TERM": "xterm-256color",
-            "COLORTERM": "truecolor",
             "DS_TERMINAL_PROMPT_PATH": str(self.prompt_events_path(resolved_quest_root, bash_id)),
         }
-        command = f"exec bash --noprofile --rcfile {shlex.quote(str(terminal_rc_path))} -i"
+        if os.name != "nt":
+            terminal_script_path.write_text(
+                "\n".join(
+                    [
+                        "PS1='\\w$ '",
+                        "PS2='> '",
+                        'PROMPT_COMMAND=\'printf "__DS_TERMINAL_PROMPT__ cwd_b64=%s ts=%s\\n" "$(printf "%s" "$PWD" | base64 | tr -d "\\n")" "$(date -u +%FT%TZ)" >> "${DS_TERMINAL_PROMPT_PATH}"\'',
+                        "bind 'set enable-bracketed-paste off' >/dev/null 2>&1 || true",
+                        "",
+                    ]
+                ),
+                encoding="utf-8",
+            )
+            env_payload["TERM"] = "xterm-256color"
+            env_payload["COLORTERM"] = "truecolor"
+        else:
+            terminal_script_path.write_text(
+                "\n".join(
+                    [
+                        "$global:__dsPromptPath = $env:DS_TERMINAL_PROMPT_PATH",
+                        "function global:prompt {",
+                        "    $cwdBytes = [System.Text.Encoding]::UTF8.GetBytes((Get-Location).Path)",
+                        "    $cwdB64 = [Convert]::ToBase64String($cwdBytes)",
+                        '    $ts = [DateTime]::UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ")',
+                        '    Add-Content -LiteralPath $global:__dsPromptPath -Value "__DS_TERMINAL_PROMPT__ cwd_b64=$cwdB64 ts=$ts"',
+                        '    return "PS $((Get-Location).Path)> "',
+                        "}",
+                        "try { Set-PSReadLineOption -BellStyle None | Out-Null } catch {}",
+                        "",
+                    ]
+                ),
+                encoding="utf-8",
+            )
+        launch = build_terminal_shell_launch(terminal_script_path)
+        command = " ".join(launch.argv)
         resolved_label = _normalize_string(label) or previous_label
         meta = self._build_terminal_meta(
             quest_root=resolved_quest_root,
@@ -1016,10 +1025,14 @@ class BashExecService:
             cwd=target_cwd,
             workdir_display=workdir_display,
             command=command,
+            launch_argv=launch.argv,
             source=source,
             conversation_id=conversation_id,
             user_id=user_id,
             env_keys=sorted(env_payload),
+            shell_family=launch.family,
+            shell_name=launch.shell_name,
+            transport_preference="pipe" if os.name == "nt" else "pty",
         )
         self._write_meta(resolved_quest_root, bash_id, meta)
         append_jsonl(
@@ -1042,7 +1055,9 @@ class BashExecService:
             prompt_events_path=self.prompt_events_path(resolved_quest_root, bash_id),
             env_payload=env_payload,
             command=command,
+            launch_argv=launch.argv,
             cwd=target_cwd,
+            transport_preference="pipe" if os.name == "nt" else "pty",
         )
         meta["updated_at"] = utc_now()
         self._write_meta(resolved_quest_root, bash_id, meta)

package/src/deepscientist/bash_exec/shells.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import os
+from pathlib import Path
+import shutil
+
+
+@dataclass(frozen=True)
+class ShellLaunchSpec:
+    argv: list[str]
+    family: str
+    shell_name: str
+
+
+def _resolve_windows_shell(*, interactive: bool) -> tuple[str, str]:
+    candidates: list[tuple[str, str]] = []
+    if not interactive:
+        candidates.extend(
+            [
+                ("bash.exe", "bash"),
+                ("bash", "bash"),
+            ]
+        )
+    candidates.extend(
+        [
+            ("pwsh", "powershell"),
+            ("powershell.exe", "powershell"),
+        ]
+    )
+    if not interactive:
+        candidates.append(("cmd.exe", "cmd"))
+    for binary, family in candidates:
+        resolved = shutil.which(binary)
+        if resolved:
+            return resolved, family
+    fallback = "cmd.exe" if not interactive else "powershell.exe"
+    return fallback, "cmd" if fallback == "cmd.exe" else "powershell"
+
+
+def build_exec_shell_launch(command: str) -> ShellLaunchSpec:
+    normalized = str(command or "").strip()
+    if os.name != "nt":
+        return ShellLaunchSpec(
+            argv=["bash", "-lc", normalized],
+            family="bash",
+            shell_name="bash",
+        )
+    binary, family = _resolve_windows_shell(interactive=False)
+    if family == "bash":
+        return ShellLaunchSpec(
+            argv=[binary, "-lc", normalized],
+            family=family,
+            shell_name=Path(binary).name,
+        )
+    if family == "cmd":
+        return ShellLaunchSpec(
+            argv=[binary, "/d", "/s", "/c", normalized],
+            family=family,
+            shell_name=Path(binary).name,
+        )
+    return ShellLaunchSpec(
+        argv=[binary, "-NoLogo", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", normalized],
+        family=family,
+        shell_name=Path(binary).name,
+    )
+
+
+def build_terminal_shell_launch(script_path: Path) -> ShellLaunchSpec:
+    if os.name != "nt":
+        return ShellLaunchSpec(
+            argv=["bash", "--noprofile", "--rcfile", str(script_path), "-i"],
+            family="bash",
+            shell_name="bash",
+        )
+    binary, family = _resolve_windows_shell(interactive=True)
+    if family == "powershell":
+        return ShellLaunchSpec(
+            argv=[binary, "-NoLogo", "-NoProfile", "-NoExit", "-ExecutionPolicy", "Bypass", "-File", str(script_path)],
+            family=family,
+            shell_name=Path(binary).name,
+        )
+    return ShellLaunchSpec(
+        argv=[binary, "/q", "/k", str(script_path)],
+        family=family,
+        shell_name=Path(binary).name,
+    )

package/src/deepscientist/bridges/connectors.py

@@ -18,8 +18,11 @@ from ..connector.weixin_support import (
     WEIXIN_UPLOAD_MEDIA_FILE,
     WEIXIN_UPLOAD_MEDIA_IMAGE,
     WEIXIN_UPLOAD_MEDIA_VIDEO,
+    clear_weixin_context_send_state,
     download_weixin_remote_attachment,
+    get_weixin_context_entry,
     get_weixin_context_token,
+    mark_weixin_context_stale,
     normalize_weixin_base_url,
     normalize_weixin_cdn_base_url,
     send_weixin_message,
@@ -558,10 +561,11 @@ class QQConnectorBridge(BaseConnectorBridge):
             connector_delivery = item.get("connector_delivery") if isinstance(item.get("connector_delivery"), dict) else {}
             qq_delivery = connector_delivery.get("qq") if isinstance(connector_delivery.get("qq"), dict) else {}
             media_kind = str(qq_delivery.get("media_kind") or "").strip().lower()
+            allow_internal_auto_media = bool(qq_delivery.get("allow_internal_auto_media"))
             if media_kind not in {"image", "file"}:
                 residual_items.append(item)
                 continue
-            if not native_enabled:
+            if not native_enabled and not allow_internal_auto_media:
                 issues.append(
                     {
                         "attachment_index": index,
@@ -781,7 +785,9 @@ class WeixinConnectorBridge(BaseConnectorBridge):
     name = "weixin"
     _MEDIA_ITEM_TYPES = {2, 4, 5}
     _MEDIA_SEND_INITIAL_DELAY_SECONDS = 0.8
-    _MEDIA_SEND_RETRY_DELAYS_SECONDS = (1.5, 3.0)
+    _TEXT_SEND_RETRY_DELAYS_SECONDS = (0.8, 1.5, 3.0)
+    _MEDIA_SEND_RETRY_DELAYS_SECONDS = (1.5, 3.0, 5.0)
+    _STALE_CONTEXT_SUPPRESSED_KINDS = {"progress", "milestone", "assistant", "summary", "ack"}
 
     def deliver(self, payload: dict[str, Any], config: dict[str, Any]) -> dict[str, Any] | None:
         return self.deliver_direct(payload, config)
@@ -800,14 +806,26 @@ class WeixinConnectorBridge(BaseConnectorBridge):
                 "error": "Weixin outbound target is empty.",
             }
         connector_root = self._connector_root(config)
+        kind = str(payload.get("kind") or "").strip().lower()
+        context_entry = get_weixin_context_entry(connector_root, to_user_id)
         context_token = get_weixin_context_token(connector_root, to_user_id)
         if not context_token:
+            if kind in self._STALE_CONTEXT_SUPPRESSED_KINDS:
+                return self._queued_context_wait_response(
+                    reason=f"Weixin context_token is missing for `{to_user_id}`. Waiting for the next inbound message.",
+                )
             return {
                 "ok": False,
                 "queued": False,
                 "transport": "weixin-ilink",
                 "error": f"Weixin context_token is missing for `{to_user_id}`. Wait for one inbound message first.",
             }
+        if bool(context_entry.get("stale_context")) and kind in self._STALE_CONTEXT_SUPPRESSED_KINDS:
+            stale_since = str(context_entry.get("stale_since") or "").strip()
+            warning = "Weixin outbound is paused until the next inbound message refreshes context_token."
+            if stale_since:
+                warning = f"{warning} stale_since={stale_since}"
+            return self._queued_context_wait_response(reason=warning)
 
         native_attachments, residual_attachments, warnings = self._partition_native_attachments(payload.get("attachments"))
         rendered_text = self.render_text(payload.get("text"), residual_attachments)
@@ -895,6 +913,20 @@ class WeixinConnectorBridge(BaseConnectorBridge):
             else:
                 warnings.append("Weixin outbound payload contained neither text nor sendable attachments.")
         except Exception as exc:
+            if "ret=-2" in str(exc or "").lower():
+                mark_weixin_context_stale(
+                    connector_root,
+                    user_id=to_user_id,
+                    error=str(exc),
+                    kind=kind or None,
+                )
+                if kind in self._STALE_CONTEXT_SUPPRESSED_KINDS:
+                    queued = self._queued_context_wait_response(
+                        reason="Weixin send hit stale context and was deferred until the next inbound refresh.",
+                    )
+                    queued["parts"] = parts
+                    queued["warnings"] = [*warnings, *(queued.get("warnings") or [])]
+                    return queued
             return {
                 "ok": False,
                 "queued": False,
@@ -909,6 +941,12 @@ class WeixinConnectorBridge(BaseConnectorBridge):
         error_messages = [str(item.get("error") or "").strip() for item in failed if str(item.get("error") or "").strip()]
         error_messages.extend(warnings)
         last_success = succeeded[-1] if succeeded else {}
+        if succeeded:
+            clear_weixin_context_send_state(
+                connector_root,
+                user_id=to_user_id,
+                kind=kind or None,
+            )
         return {
             "ok": bool(succeeded),
             "queued": False,
@@ -920,6 +958,17 @@ class WeixinConnectorBridge(BaseConnectorBridge):
             "error": "; ".join(error_messages) if error_messages else None,
         }
 
+    @staticmethod
+    def _queued_context_wait_response(*, reason: str) -> dict[str, Any]:
+        return {
+            "ok": False,
+            "queued": True,
+            "transport": "weixin-ilink",
+            "parts": [],
+            "warnings": [str(reason or "").strip()],
+            "error": None,
+        }
+
     @staticmethod
     def _partition_native_attachments(
         attachments: Any,

package/src/deepscientist/config/models.py

@@ -22,7 +22,7 @@ def config_filename(name: str) -> str:
 
 
 def default_system_enabled_connectors() -> dict[str, bool]:
-    return {name: name in {"qq", "weixin", "lingzhu"} for name in SYSTEM_CONNECTOR_NAMES}
+    return {name: name in {"qq", "weixin", "telegram", "feishu", "whatsapp", "lingzhu"} for name in SYSTEM_CONNECTOR_NAMES}
 
 
 def default_config(home: Path) -> dict:
@@ -98,8 +98,8 @@ def default_runners() -> dict:
             "profile": "",
             "model": "gpt-5.4",
             "model_reasoning_effort": "xhigh",
-            "approval_policy": "on-request",
-            "sandbox_mode": "workspace-write",
+            "approval_policy": "never",
+            "sandbox_mode": "danger-full-access",
             "retry_on_failure": True,
             "retry_max_attempts": 5,
             "retry_initial_backoff_sec": 10.0,
@@ -154,6 +154,9 @@ def default_connectors() -> dict:
             "transport": "ilink_long_poll",
             "bot_name": "DeepScientist",
             "command_prefix": "/",
+            "auto_send_main_experiment_png": True,
+            "stale_replay_latest_limit": 5,
+            "stale_replay_interval_seconds": 2.0,
             "base_url": "https://ilinkai.weixin.qq.com",
             "cdn_base_url": "https://novac2c.cdn.weixin.qq.com/c2c",
             "bot_type": "3",

package/src/deepscientist/config/service.py

@@ -48,6 +48,7 @@ from .models import (
     ConfigFileInfo,
     SYSTEM_CONNECTOR_NAMES,
     config_filename,
+    default_system_enabled_connectors,
     default_payload,
 )
 
@@ -112,8 +113,9 @@ class ConfigManager:
         config = self.load_runtime_config()
         connectors = config.get("connectors") if isinstance(config.get("connectors"), dict) else {}
         system_enabled = connectors.get("system_enabled") if isinstance(connectors.get("system_enabled"), dict) else {}
+        defaults = default_system_enabled_connectors()
         return {
-            name: self._coerce_bool(system_enabled.get(name), default=name in {"qq", "weixin"})
+            name: self._coerce_bool(system_enabled.get(name), default=defaults.get(name, False))
             for name in SYSTEM_CONNECTOR_NAMES
         }
 
@@ -1207,7 +1209,10 @@ Use **Test** when the file exposes runtime dependencies.
             env_key = str(key or "").strip()
             if not env_key or value is None:
                 continue
-            resolved[env_key] = str(value)
+            env_value = str(value)
+            if env_value == "":
+                continue
+            resolved[env_key] = env_value
         return resolved
 
     def _prepare_codex_probe_home(

package/src/deepscientist/connector/lingzhu_support.py

@@ -15,6 +15,9 @@ DEFAULT_LINGZHU_AGENT_ID = "main"
 DEFAULT_LINGZHU_SESSION_NAMESPACE = "lingzhu"
 DEFAULT_LINGZHU_TASK_PREFIX = "我现在的任务是"
 DEFAULT_LINGZHU_PASSIVE_CHAT_TYPE = "passive"
+_LINGZHU_COMMAND_PUNCTUATION = "：:，,。.;；!！?？、~～`'\"“”‘’（）()【】[]《》<>"
+_LINGZHU_COMMAND_PUNCT_TRANSLATION = str.maketrans({char: " " for char in _LINGZHU_COMMAND_PUNCTUATION})
+_LINGZHU_PREFIX_SEPARATORS_CLASS = re.escape(_LINGZHU_COMMAND_PUNCTUATION) + r"\s"
 
 _AUTH_AK_SEGMENTS = (8, 4, 4, 4, 12)
 _AUTH_AK_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789"
@@ -237,12 +240,28 @@ def lingzhu_extract_user_text(messages: Any) -> str:
     return "\n".join(parts).strip()
 
 
-def lingzhu_extract_task_text(text: Any) -> str | None:
+def lingzhu_normalize_command_text(text: Any) -> str:
     normalized = str(text or "").strip()
-    if not normalized.startswith(DEFAULT_LINGZHU_TASK_PREFIX):
+    if not normalized:
+        return ""
+    normalized = normalized.translate(_LINGZHU_COMMAND_PUNCT_TRANSLATION)
+    normalized = re.sub(r"\s+", " ", normalized)
+    return normalized.strip()
+
+
+def lingzhu_extract_task_text(text: Any) -> str | None:
+    raw_text = str(text or "").strip()
+    if not raw_text:
+        return None
+    prefix_pattern = r"^[{separators}]*{prefix}[{separators}]*".format(
+        separators=_LINGZHU_PREFIX_SEPARATORS_CLASS,
+        prefix="".join(f"{re.escape(char)}[{_LINGZHU_PREFIX_SEPARATORS_CLASS}]*" for char in DEFAULT_LINGZHU_TASK_PREFIX),
+    )
+    matched = re.match(prefix_pattern, raw_text)
+    if matched is None:
         return None
-    remainder = normalized[len(DEFAULT_LINGZHU_TASK_PREFIX) :].strip()
-    remainder = remainder.lstrip("：:，,。.;；!！?？ ")
+    remainder = raw_text[matched.end() :].strip()
+    remainder = remainder.lstrip(_LINGZHU_COMMAND_PUNCTUATION + " \t\r\n")
     return remainder or None