langchain-agentx-python 1.0.2__py3-none-any.whl → 1.0.4__py3-none-any.whl

langchain_agentx/__init__.py

@@ -11,7 +11,7 @@ from langchain_agentx import create_loop_agent
 ```
 """
 
-__version__ = "1.0.2"
+__version__ = "1.0.4"
 
 from .loop import (  # noqa: F401
     create_loop_agent,

langchain_agentx/loop/graph/factory.py

@@ -1346,9 +1346,7 @@ class LoopGraphBuilder:
                 hint = skill_prefetch_provider._build_listing_hint(scope=skill_init_scope)
                 if hint is None:
                     return {}
-                # 对齐 CC：skill_listing 是 UserMessage，不是 SystemMessage
-                # CC src/utils/messages.ts: createUserMessage({ isMeta: true, ... })
-                # CC 中包裹在 <system-reminder> 中，但 role 是 "user"
+                # skill_listing 以 HumanMessage 注入（非 SystemMessage），与 CC role=user 对齐
                 return {"messages": [HumanMessage(content=f"[skill_listing] {hint.summary}")]}
 
             graph_inner.add_node(

langchain_agentx/task_runtime/tasklist/store.py

@@ -27,8 +27,10 @@ from __future__ import annotations
 
 import asyncio
 import json
+from collections.abc import Coroutine
+from concurrent.futures import ThreadPoolExecutor
 from pathlib import Path
-from typing import Optional
+from typing import Any, Callable, Optional, TypeVar
 
 from langchain_agentx.workspace import ResolvedAgentStateConfig
 from langchain_agentx.workspace.resolver import resolve_agent_state_config
@@ -491,6 +493,18 @@ def with_lock(lock, func):
 
 # ── 同步包装器（供同步工具使用）───────────────────────────────────────
 
+_T = TypeVar("_T")
+_ASYNC_RUNNER = ThreadPoolExecutor(max_workers=1, thread_name_prefix="taskstore-sync")
+
+
+def _run_async(coro_factory: Callable[[], Coroutine[Any, Any, _T]]) -> _T:
+    """在同步上下文中执行协程；若已有 running loop 则在线程内 asyncio.run。"""
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(coro_factory())
+    return _ASYNC_RUNNER.submit(lambda: asyncio.run(coro_factory())).result()
+
 
 class TaskStoreSync:
     """TaskStore 的同步包装器。
@@ -523,32 +537,32 @@ class TaskStoreSync:
 
     def create_task(self, data: TaskCreate) -> str:
         """创建任务（同步）。"""
-        return asyncio.run(self._get_store().create_task(data))
+        return _run_async(lambda: self._get_store().create_task(data))
 
     def get_task(self, task_id: str) -> Task | None:
         """获取任务（同步）。"""
-        return asyncio.run(self._get_store().get_task(task_id))
+        return _run_async(lambda: self._get_store().get_task(task_id))
 
     def update_task(self, task_id: str, data: TaskUpdate) -> Task:
         """更新任务（同步）。"""
-        return asyncio.run(self._get_store().update_task(task_id, data))
+        return _run_async(lambda: self._get_store().update_task(task_id, data))
 
     def delete_task(self, task_id: str) -> bool:
         """删除任务（同步）。"""
-        return asyncio.run(self._get_store().delete_task(task_id))
+        return _run_async(lambda: self._get_store().delete_task(task_id))
 
     def list_tasks(self, filters: TaskFilters | None = None) -> list[Task]:
         """列出任务（同步）。"""
-        return asyncio.run(self._get_store().list_tasks(filters))
+        return _run_async(lambda: self._get_store().list_tasks(filters))
 
     def task_exists(self, task_id: str) -> bool:
         """检查任务是否存在（同步）。"""
-        return asyncio.run(self._get_store().task_exists(task_id))
+        return _run_async(lambda: self._get_store().task_exists(task_id))
 
     def block_task(self, from_id: str, to_id: str) -> bool:
         """建立任务依赖关系（同步）。"""
-        return asyncio.run(self._get_store().block_task(from_id, to_id))
+        return _run_async(lambda: self._get_store().block_task(from_id, to_id))
 
     def reset_task_list(self) -> None:
         """重置任务列表（同步）。"""
-        asyncio.run(self._get_store().reset_task_list())
+        _run_async(lambda: self._get_store().reset_task_list())

langchain_agentx/tool_runtime/adapter.py

@@ -154,6 +154,8 @@ class LangChainAdapter:
         # 如果 loop_config 存在但 workspace_root 仍为 None，默认使用当前工作目录
         if loop_config is not None and workspace_root is None:
             workspace_root = str(Path.cwd())
+        if workspace_root is not None:
+            workspace_root = str(workspace_root)
 
         # agent_home_segment：优先从新嵌套结构获取，再回退到直接字段，再回退到旧字段
         agent_home_segment = None

langchain_agentx/tool_runtime/auto_mode/allowlist.py

@@ -34,7 +34,6 @@ class SafeToolAllowlist:
                                 TaskUpdate / TaskStop / TaskOutput
         - UI / 计划态：AskUserQuestion / EnterPlanMode / ExitPlanMode
         - Skill 加载（无副作用）：Skill
-        - UserMessage（带外通信）
 
     注意：
         Edit / Write 不进默认白名单，走 acceptEdits fast-path（L2，待实现）。
@@ -60,8 +59,6 @@ class SafeToolAllowlist:
         "ExitPlanMode",
         # Skill 加载（无副作用）
         "Skill",
-        # UserMessage（带外通信）
-        "UserMessage",
     })
 
     def __init__(self, extra: Iterable[str] | None = None):

langchain_agentx/tool_runtime/execution/callback_bridge.py

@@ -174,11 +174,9 @@ class ToolExecutionCallbackBridge:
 
     @staticmethod
     def _resolve_run_id(tool_call_id: str) -> uuid.UUID:
-        if tool_call_id:
-            try:
-                return uuid.UUID(tool_call_id)
-            except ValueError:
-                pass
+        # 不复用 LLM tool_call_id（常为 UUID）：与 LangGraph astream_events 的 run_map
+        # 键冲突时会出现 on_tool_end 已 pop、on_tool_error KeyError。
+        _ = tool_call_id
         return uuid.uuid4()
 
 

langchain_agentx/tool_runtime/execution/engine.py

@@ -606,11 +606,15 @@ class RuntimeToolExecutionEngine:
         override = getattr(store, "cwd_override", None)
         if not isinstance(override, str) or not override.strip():
             return
-        candidate = Path(override)
-        if candidate.is_dir():
+        from langchain_agentx.utils.windows_paths import normalize_subprocess_cwd
+
+        normalized = normalize_subprocess_cwd(override)
+        if normalized and Path(normalized).is_dir():
+            if normalized != override and hasattr(store, "set_cwd"):
+                store.set_cwd(normalized)
             return
         if hasattr(store, "set_cwd"):
-            store.set_cwd(workspace_root)
+            store.set_cwd(str(workspace_root))
 
     def _unknown_tool_envelope(self, tool_name: str) -> ToolResultEnvelope:
         return ToolResultEnvelope(

langchain_agentx/tool_runtime/loop_loader.py

@@ -82,8 +82,6 @@ class LoopLoader:
         from langchain_agentx.tools.task_get.tool import TaskGetRuntimeTool
         from langchain_agentx.tools.task_list.tool import TaskListRuntimeTool
         from langchain_agentx.tools.task_update.tool import TaskUpdateRuntimeTool
-        # UserMessageTool 暂时移除（待稳定后可能完全删除）
-        # from langchain_agentx.tools.user_message import UserMessageTool
         from langchain_agentx.tools.webfetch import loader as webfetch_loader
         from langchain_agentx.tools.websearch import loader as websearch_loader
         from langchain_agentx.tools.write import WriteRuntimeTool
@@ -136,8 +134,6 @@ class LoopLoader:
             )
         )
         self.register(BashRuntimeTool(state_bridge=shared_bridge))
-        # UserMessageTool 暂时移除（待稳定后可能完全删除）
-        # self.register(UserMessageTool())
         self.register(AskUserQuestionTool())
         self.register(TaskListRuntimeTool(config=cfg))
         self.register(TaskGetRuntimeTool(config=cfg))

langchain_agentx/tool_runtime/models.py

@@ -116,11 +116,11 @@ class ToolExecutionContext:
     cancel_event: threading.Event | None = None
     """可选；由 ``RunnableConfig.configurable[\"cancel_event\"]`` 注入。set 后 Grep/Glob 应中断 rg。"""
     tool_config_path: str | None = None
-    """可选；`LangChainAdapter` 由 workspace 解析的 `tool_runtime_config.json` 绝对路径（UserMessage v2+）。"""
+    """可选；`LangChainAdapter` 由 workspace 解析的 `tool_runtime_config.json` 绝对路径。"""
     channels: set[str] | None = None
     """可选；当前激活渠道（如 ``{"cli"}`` / ``{"discord"}``），供 AskUserQuestion 等工具禁用无 TUI 场景。"""
     trace_collector: Any | None = None
-    """可选；来自 graph state / configurable 的 `TraceCollector`，供 pipeline 发 `user_message_send`。"""
+    """可选；来自 graph state / configurable 的 `TraceCollector`，供 pipeline 发分析事件。"""
     trace_emit_session_id: str | None = None
     """可选；`emit_event(session_id=...)` 用，与 Trace 会话键（常为 `_run_id`）对齐。"""
     question_preview_format: Literal["markdown", "html"] | None = None

langchain_agentx/tool_runtime/pipeline.py

@@ -30,9 +30,8 @@ runtime/pipeline.py — 工具执行管道与输出大小管控
         IdenticalCallMemo；命中则直接返回带 Hint 的 ToolResultEnvelope（不执行 invoke），
         作为“软提示防重复”策略的执行层硬约束替代。
 
-    UserMessage v2：
-        `truncate_if_needed` 之后对 `user_message` 发 `user_message_send`；
-        对 `AskUserQuestion` 发 `ask_user_question_completed`（`_emit_post_invoke_analytics`）。
+    AskUserQuestion：
+        `truncate_if_needed` 之后发 `ask_user_question_completed`（`_emit_post_invoke_analytics`）。
 """
 
 from __future__ import annotations
@@ -119,76 +118,6 @@ def _as_run_result(
     )
 
 
-_USER_MESSAGE_TOOL_NAME = "user_message"
-
-
-def _emit_user_message_analytics(
-    *,
-    tool: RuntimeTool,
-    parsed_data: dict[str, Any],
-    envelope: ToolResultEnvelope,
-    ctx: ToolExecutionContext,
-) -> None:
-    """
-    对齐 CC `tengu_brief_send` 的 `user_message_send` 分析事件（设计 §2.3 / §3.4.6）。
-
-    当前裁剪范围：
-        仅 `tool.name == user_message` 且 `envelope.status == ok`；依赖 `ctx.trace_collector`
-        与 `ctx.trace_emit_session_id`；异常吞掉不向上抛。
-    """
-    if tool.name != _USER_MESSAGE_TOOL_NAME:
-        return
-    if envelope.status != "ok":
-        return
-    collector = ctx.trace_collector
-    session_id = ctx.trace_emit_session_id
-    if collector is None or not isinstance(session_id, str) or not session_id.strip():
-        return
-    try:
-        has_fn = getattr(collector, "has_session", None)
-        if callable(has_fn) and not has_fn(session_id):
-            return
-    except Exception:
-        return
-
-    raw_attachments = parsed_data.get("attachments")
-    if isinstance(raw_attachments, list):
-        attachment_count = len(raw_attachments)
-    else:
-        attachment_count = 0
-    has_attachments = attachment_count > 0
-
-    raw_msg = parsed_data.get("message")
-    message_length = len(raw_msg) if isinstance(raw_msg, str) else 0
-
-    meta = envelope.meta or {}
-    truncated = bool(envelope.truncated) or bool(meta.get("truncated"))
-
-    status_val = parsed_data.get("status", "normal")
-    if status_val not in ("normal", "proactive"):
-        status_val = "normal"
-
-    payload: dict[str, Any] = {
-        "has_attachments": has_attachments,
-        "attachment_count": attachment_count,
-        "status": status_val,
-        "message_length": message_length,
-        "truncated": truncated,
-    }
-
-    try:
-        emit_fn = getattr(collector, "emit_event", None)
-        if not callable(emit_fn):
-            return
-        emit_fn(
-            session_id=session_id,
-            event_type="user_message_send",
-            payload=payload,
-        )
-    except Exception as exc:
-        logger.debug("user_message_send emit skipped: %s", exc)
-
-
 _ASK_USER_QUESTION_TOOL_NAME = "AskUserQuestion"
 
 
@@ -290,9 +219,6 @@ def _emit_post_invoke_analytics(
     envelope: ToolResultEnvelope,
     ctx: ToolExecutionContext,
 ) -> None:
-    _emit_user_message_analytics(
-        tool=tool, parsed_data=parsed_data, envelope=envelope, ctx=ctx
-    )
     _emit_ask_user_question_analytics(
         tool=tool, parsed_data=parsed_data, envelope=envelope, ctx=ctx
     )
@@ -351,9 +277,17 @@ class ToolOutputManager:
         self,
         max_result_size_chars: int = DEFAULT_MAX_CHARS,
         overflow_dir: str = OVERFLOW_DIR,
+        storage_presenter: Any | None = None,
     ) -> None:
         self._max_chars = max_result_size_chars
         self._overflow_dir = overflow_dir
+        if storage_presenter is None:
+            from langchain_agentx.utils.tool_result_storage import (
+                ToolResultStoragePresenter,
+            )
+
+            storage_presenter = ToolResultStoragePresenter()
+        self._storage = storage_presenter
 
     def truncate_if_needed(
         self,
@@ -376,28 +310,36 @@ class ToolOutputManager:
         if len(text) <= max_chars:
             return envelope
 
-        # 超限：持久化完整内容
+        # 超限：持久化完整内容（对齐 CC buildLargeToolResultMessage）
         overflow_path = self._persist(text, tool_call_id)
-
-        # 截断 payload
-        truncated_text = text[:max_chars]
+        from langchain_agentx.utils.tool_result_storage import PersistedToolResult
+
+        preview, has_more = self._storage.generate_preview(text, max_chars)
+        persisted = PersistedToolResult(
+            filepath=overflow_path,
+            original_size=len(text),
+            preview=preview,
+            has_more=has_more,
+        )
+        model_overflow_path = self._storage.model_overflow_path(overflow_path)
+        truncated_payload = self._storage.build_large_tool_result_message(persisted)
         truncated_summary = (
             envelope.summary
             + f"\n[Output truncated at {max_chars} chars."
-            + f" Full result saved to: {overflow_path}]"
+            + self._storage.build_truncation_summary_suffix(overflow_path)
         )
 
         return ToolResultEnvelope(
             status=envelope.status,
             tool_name=envelope.tool_name,
             summary=truncated_summary,
-            payload=truncated_text,
+            payload=truncated_payload,
             artifacts=envelope.artifacts,
             hints=envelope.hints,
             meta=envelope.meta,
             error=envelope.error,
             truncated=True,
-            overflow_file=overflow_path,
+            overflow_file=model_overflow_path,
         )
 
     def _envelope_to_text(self, envelope: ToolResultEnvelope) -> str:

langchain_agentx/tools/__init__.py

@@ -6,7 +6,6 @@
     P2（已完成）：GrepRuntimeTool / GlobRuntimeTool — 只读搜索工具
     P3（进行中）：WriteRuntimeTool；EditRuntimeTool — Phase 6 单测 + ``tools/`` 回归已跑通（需 ToolStateBridge + 先 Read）
     P4（已完成）：BashRuntimeTool
-    # P1 用户交互（已移除）：UserMessageTool — 用户可见消息（CC BriefTool，因不确定性问题已移除）
 """
 
 from .agent import AgentRuntimeTool
@@ -18,9 +17,6 @@ from .skill import SkillRuntimeTool
 from .edit import EditRuntimeTool
 from .write import WriteRuntimeTool
 
-# UserMessageTool 暂时移除（待稳定后可能完全删除）
-# from .user_message import UserMessageTool
-
 __all__ = [
     "ReadRuntimeTool",
     "AgentRuntimeTool",
@@ -30,6 +26,4 @@ __all__ = [
     "SkillRuntimeTool",
     "WriteRuntimeTool",
     "EditRuntimeTool",
-    # "UserMessageTool",  # 暂时移除
 ]
-

langchain_agentx/tools/agent/cwd_resolution.py

@@ -45,7 +45,7 @@ class AgentToolCwdResolution:
                 "Agent cwd expansion requires workspace_root; "
                 "set workspace_root in AgentLoopConfig.workspace.workspace_root."
             )
-        from langchain_agentx.utils.cwd import expand_path
+        from langchain_agentx.utils.path import expand_path
 
         normalized = normalize_user_path_string_for_expand(raw.strip())
         return expand_path(normalized, base_dir=workspace_root)
@@ -61,8 +61,10 @@ class AgentToolCwdResolution:
 
         if workspace_root:
             try:
-                root = Path(workspace_root).expanduser().resolve()
-                candidate = Path(absolute).expanduser().resolve()
+                from langchain_agentx.utils.path import expand_path
+
+                root = Path(expand_path(workspace_root))
+                candidate = Path(expand_path(absolute))
             except OSError as exc:
                 return f"cwd 无法解析到 workspace 内：{exc}"
             if not _path_is_descendant(candidate, root):

langchain_agentx/tools/bash/backend.py

@@ -46,6 +46,7 @@ from .cwd_reporter import (
     BashCwdReporter,
     bash_single_quoted,
     native_path_for_bash_redirect,
+    normalize_subprocess_cwd,
     read_cwd_file,
 )
 from .sandbox_decision import BashSandboxDecision
@@ -90,30 +91,32 @@ def extract_cwd_warning(stderr: str) -> tuple[str, str | None]:
     return cleaned_stderr, cwd_warning
 
 
-def _cwd_invalid_reason(cwd: str | None) -> str | None:
+def _cwd_invalid_reason(cwd: str | os.PathLike[str] | None) -> str | None:
     """返回 cwd 不可用于 subprocess 的原因；None 表示可用（含 cwd is None）。"""
     if cwd is None:
         return None
-    if not cwd.strip():
+    normalized = normalize_subprocess_cwd(cwd)
+    if normalized is None:
         return "empty path"
-    if not os.path.exists(cwd):
+    if not os.path.exists(normalized):
         return "does not exist"
-    if not os.path.isdir(cwd):
+    if not os.path.isdir(normalized):
         return "not a directory"
     return None
 
 
-def _pick_cwd_fallback(fallback: str | None) -> str | None:
+def _pick_cwd_fallback(fallback: str | os.PathLike[str] | None) -> str | None:
     """选择可 spawn 的回退目录（fail-closed：仅 fallback，不用进程 cwd / ~）。"""
-    if fallback and _cwd_invalid_reason(fallback) is None:
-        return os.path.realpath(fallback)
+    normalized = normalize_subprocess_cwd(fallback)
+    if normalized and _cwd_invalid_reason(normalized) is None:
+        return os.path.realpath(normalized)
     return None
 
 
 def _prepare_spawn_cwd(
-    cwd: str | None,
+    cwd: str | os.PathLike[str] | None,
     *,
-    fallback: str | None,
+    fallback: str | os.PathLike[str] | None,
 ) -> tuple[str | None, str]:
     """
     spawn 前解析 cwd：无效时 fail-closed 回退到 fallback，并生成 CC 风格 stderr 前缀。
@@ -121,9 +124,10 @@ def _prepare_spawn_cwd(
     Returns:
         (effective_cwd, stderr_prefix) — stderr_prefix 形如 ``Shell cwd was reset to ...\\n``
     """
-    reason = _cwd_invalid_reason(cwd)
+    normalized_cwd = normalize_subprocess_cwd(cwd) if cwd is not None else None
+    reason = _cwd_invalid_reason(normalized_cwd)
     if reason is None:
-        return cwd, ""
+        return normalized_cwd, ""
     reset_to = _pick_cwd_fallback(fallback)
     if reset_to is None:
         detail = f"previous cwd invalid: {cwd}: {reason}" if cwd else f"cwd invalid: {reason}"
@@ -1274,10 +1278,14 @@ class BashBackend:
     @staticmethod
     def _build_stream_wrapper(command: str) -> str:
         marker = "__AGENTX_STREAM_CWD__"
+        if sys.platform == "win32":
+            pwd_expr = '$(cygpath -m "$PWD" 2>/dev/null || printf %s "$PWD")'
+        else:
+            pwd_expr = '"$PWD"'
         return (
             f"{command}\n"
             "__EC=$?\n"
-            f'printf "\\n{marker}%s\\n" "$PWD"\n'
+            f'printf "\\n{marker}%s\\n" {pwd_expr}\n'
             "exit $__EC"
         )
 
@@ -1437,7 +1445,8 @@ class BashBackend:
             before, _, after = merged.rpartition(marker)
             # 末尾的 cwd 标记不再作为 chunk 内容处理
             cleaned = before
-            cwd_after = after.strip().splitlines()[0] if after.strip() else None
+            raw_cwd = after.strip().splitlines()[0] if after.strip() else None
+            cwd_after = normalize_subprocess_cwd(raw_cwd)
             if cleaned != merged:
                 # 让上游获得去 marker 后的稳定输出
                 pass
@@ -1696,8 +1705,7 @@ def _read_fd_safe(fd: int) -> str | None:
             if not chunk:
                 break
             data += chunk
-        result = data.decode("utf-8", errors="replace").strip()
-        return result if result else None
+        return normalize_subprocess_cwd(data.decode("utf-8", errors="replace"))
     except OSError:
         return None
 
@@ -1723,7 +1731,7 @@ def _extract_cwd_from_output(raw_output: str) -> tuple[str, str | None]:
     for line in lines:
         stripped = line.rstrip("\n").rstrip("\r")
         if stripped.startswith(_CWD_SENTINEL):
-            cwd_after = stripped[len(_CWD_SENTINEL):]
+            cwd_after = normalize_subprocess_cwd(stripped[len(_CWD_SENTINEL) :])
         else:
             clean_lines.append(line)
 

langchain_agentx/tools/bash/bash_hardening.py

@@ -608,9 +608,9 @@ class BashGitSecurityChecker:
 
     @staticmethod
     def _resolve_path(raw_path: str, cwd: str) -> str:
-        expanded = os.path.expanduser(raw_path.strip("\"'"))
-        absolute = expanded if os.path.isabs(expanded) else os.path.join(cwd, expanded)
-        return os.path.realpath(absolute)
+        from langchain_agentx.utils.tool_paths import default_tool_paths
+
+        return default_tool_paths().resolve_path_in_cwd(raw_path, cwd)
 
     @staticmethod
     def _is_git_internal_path(path: str) -> bool:

langchain_agentx/tools/bash/boundary_check.py

@@ -99,7 +99,9 @@ class BashBoundaryChecker:
             return Path(cwd)
         target = parts[0]
         if target == "~" or target.startswith("~/"):
-            return Path(os.path.expanduser(target)).resolve()
+            from langchain_agentx.utils.path import expand_path
+
+            return Path(expand_path(target)).resolve()
         p = Path(target)
         if p.is_absolute():
             return p.resolve()

langchain_agentx/tools/bash/cwd_reporter.py

@@ -6,56 +6,42 @@ cwd_reporter.py — Bash 执行后 cwd 回传（Unix fd3 / Windows 临时文件
     Windows 用 **临时文件 + `pwd -P`**（禁止 pass_fds），与 CC `bashProvider` 双轨语义对齐。
 
 链路位置：
-    仅被 `backend.py` 调用；不读工具入参、不碰权限链。
+    仅被 `backend.py` 调用；路径转换统一委托 ``langchain_agentx.utils.windows_paths``。
 
 当前裁剪范围：
-    不处理流式 `_stream_execute_raw_iter`；不处理沙箱 backend 内部；UNC 临时目录尽力而为
-   （`native_path_for_bash_redirect` 覆盖常见 `//server/share` 形态）。
-
-设计 SSOT：
-    docs/design-docs/tool-design/bash-tool-cross-platform.md（Phase 2）
+    不处理流式 `_stream_execute_raw_iter`；不处理沙箱 backend 内部。
 """
 
 from __future__ import annotations
 
-import os
 from pathlib import Path
 
+from langchain_agentx.utils.windows_paths import (
+    native_path_for_bash_redirect,
+    normalize_subprocess_cwd,
+    posix_path_to_windows_path,
+    windows_path_to_posix_path,
+)
+
+# 向后兼容：历史测试/集成从本模块 import 转换函数
+__all__ = [
+    "BashCwdReporter",
+    "bash_single_quoted",
+    "native_path_for_bash_redirect",
+    "normalize_subprocess_cwd",
+    "posix_path_to_windows_path",
+    "read_cwd_file",
+    "windows_path_to_posix_path",
+]
+
 
 def bash_single_quoted(s: str) -> str:
     """Bash 单引号字面量（可嵌入 `pwd -P >| ...` 等）。"""
     return "'" + s.replace("'", "'\\''") + "'"
 
 
-def native_path_for_bash_redirect(win_native: str) -> str:
-    """
-    将 **本机绝对路径** 转为 Git Bash / MSYS 下用于重定向的 POSIX 形态。
-
-    - `C:\\Users\\x` → `/c/Users/x`
-    - `\\\\server\\share\\a` → `//server/share/a`
-    - 长路径前缀 `\\\\?\\` 会剥离后再转换（尽力而为）。
-    """
-    p = Path(win_native).resolve()
-    s = os.fspath(p)
-    norm = s.replace("/", "\\")
-    if norm.startswith("\\\\?\\"):
-        norm = norm[4:]
-        if norm.upper().startswith("UNC\\"):
-            norm = "\\" + norm[3:]
-    if norm.startswith("\\\\"):
-        body = norm[2:].replace("\\", "/").strip("/")
-        return "//" + body if body else "//"
-    if len(norm) >= 2 and norm[1] == ":":
-        letter = norm[0].lower()
-        tail = norm[2:].replace("\\", "/")
-        if not tail.startswith("/"):
-            tail = "/" + tail.lstrip("/")
-        return f"/{letter}{tail}"
-    return norm.replace("\\", "/")
-
-
 def read_cwd_file(native_path: str) -> str | None:
-    """读取 `pwd -P` 写入的临时文件，返回最后一行非空 cwd，失败为 None。"""
+    """读取 `pwd -P` 写入的临时文件，返回最后一行非空 cwd（本机路径），失败为 None。"""
     try:
         raw = Path(native_path).read_text(encoding="utf-8", errors="replace").strip()
     except OSError:
@@ -63,7 +49,9 @@ def read_cwd_file(native_path: str) -> str | None:
     if not raw:
         return None
     lines = [ln.strip() for ln in raw.splitlines() if ln.strip()]
-    return lines[-1] if lines else None
+    if not lines:
+        return None
+    return normalize_subprocess_cwd(lines[-1])
 
 
 class BashCwdReporter:

langchain_agentx/tools/bash/limits.py

@@ -39,13 +39,19 @@ SLEEP_BLOCK_THRESHOLD_SEC = int(os.getenv("BASH_TOOL_SLEEP_BLOCK_SEC", "30"))
 # 后台任务
 # ---------------------------------------------------------------------------
 
-BACKGROUND_TASK_OUTPUT_DIR = os.path.expanduser(
-    os.getenv(
-        "BASH_TOOL_BACKGROUND_OUTPUT_DIR",
-        "~/.cache/langchain_agentx/tasks",
+def _resolve_background_task_output_dir() -> str:
+    from langchain_agentx.utils.path import expand_path
+
+    return expand_path(
+        os.getenv(
+            "BASH_TOOL_BACKGROUND_OUTPUT_DIR",
+            "~/.cache/langchain_agentx/tasks",
+        )
     )
-)
-"""后台任务输出目录。"""
+
+
+BACKGROUND_TASK_OUTPUT_DIR = _resolve_background_task_output_dir()
+"""后台任务输出目录（``expand_path`` 展开 ~）。"""
 
 AUTO_BACKGROUND_ENABLED = os.getenv("BASH_TOOL_AUTO_BACKGROUND_ENABLED", "1") == "1"
 """是否开启自动后台化策略。"""