lingagent 0.1.0__py3-none-any.whl

agent_harness/__init__.py

@@ -0,0 +1,300 @@
+"""Agent Harness — 用代码造一台会自己干活的 agent 机器。"""
+
+import time
+from pathlib import Path
+
+from . import tui
+from .assembly import (
+    POST_HOOKS,
+    PRE_HOOKS,
+    WORKSPACE,
+    build_session_tools,
+    build_system_prompt,
+    list_visible_sessions,
+    load_settings_and_llm,
+)
+from .guardrail import command_head
+from .compact import estimate_tokens
+from .shell import detect as detect_shell
+from .session import (
+    list_sessions,
+    list_trace_files,
+    load_session,
+    load_session_model,
+    new_session_id,
+    prune_empty_sessions,
+    save_messages,
+    save_session_model,
+    trace_path,
+)
+from .loop import agent_loop
+from .llm import Msg, DeepSeekLLM
+from .trace import Tracer, days_since_viewed, load_trace, mark_viewed
+from .weblaunch import WebRun, clear_state, ensure_web, stop_run, wait_until_idle
+
+def choose_session(workspace: Path, default_profile: str = "") -> tuple[str, list[Msg]]:
+    """列历史会话让用户选（分页，每页 10 条）；返回 (session_id, history)。
+
+    default_profile：没记过模型的会话会显示成「xxx（默认）」——它打开时确实会用这个，
+    写一根横杠等于让人以为「不知道用什么」，而其实答案明确。
+    """
+    if not tui.interactive():
+        return new_session_id(workspace), []          # 非终端（管道喂任务）：选择没意义，直接新会话
+    sessions = list_visible_sessions()
+    if not sessions:
+        return new_session_id(workspace), []          # 首次：开新会话
+
+    per_page = 10
+    page = 1
+    while True:
+        total_pages = (len(sessions) + per_page - 1) // per_page
+        page = min(page, total_pages)
+        chunk = sessions[(page - 1) * per_page: page * per_page]
+        rows = [
+            {
+                "time": time.strftime("%m-%d %H:%M", time.localtime(s["mtime"])),
+                "model": load_session_model(workspace, s["id"])
+                or (f"{default_profile}（默认）" if default_profile else "-"),
+                "preview": (s["first_user_msg"] or "(空会话)").replace("\n", " ")[:40],
+            }
+            for s in chunk
+        ]
+        tui.show_sessions(rows, page, total_pages, len(sessions))
+        try:
+            choice = input("选择> ").strip().lower()
+        except EOFError:                               # 终端读尽（Ctrl+Z 回车）——开新会话
+            return new_session_id(workspace), []
+        if choice in ("0", ""):
+            return new_session_id(workspace), []       # 新会话
+        if choice == "n" and page < total_pages:
+            page += 1
+        elif choice == "p" and page > 1:
+            page -= 1
+        elif choice.isdigit() and 1 <= int(choice) <= len(chunk):
+            s = chunk[int(choice) - 1]
+            return s["id"], load_session(workspace, s["id"])
+        else:
+            tui.show_note("没这个选项——按提示来", "warn")
+
+NUDGE_DAYS = 30  # 轨迹这么久没人看，就该考虑清掉或关掉
+
+# 审批「算放行」的返回值白名单。写成白名单而不是 `!= "deny"`：那是 fail-open——
+# 将来 show_approval 多返回一种结局（超时 / 界面出错），谁忘了改这行，它就变成"批准"。
+# 现在未知值一律按驳回走；驳回只会让命令不执行，误伤看得见，静默放行看不见。
+_APPROVED = ("approve", "always", "auto")
+
+
+def _is_approved(decision: str) -> bool:
+    return decision in _APPROVED
+
+
+def _trace_nudge(settings) -> None:
+    """轨迹堆着没人看时提醒一句（只提示：删/关都由人决定）。"""
+    if not settings.trace_enabled:
+        return
+    days = days_since_viewed()
+    if days is None:  # 从没看过：拿最早的轨迹文件当基准，别对新项目唠叨
+        files = list_trace_files(WORKSPACE)
+        if not files:
+            return
+        try:
+            days = (time.time() - min(f.stat().st_mtime for f in files)) / 86400
+        except OSError:
+            return
+    if days >= NUDGE_DAYS:
+        tui.show_note(
+            f"轨迹已 {int(days)} 天没打开过——清空间：uv run agent-harness --clean-trace 30；"
+            f"不需要就在配置里设 [trace] enabled = false",
+            "warn",
+        )
+
+
+def _let_web_finish(settings) -> None:
+    """关后端之前，等网页上正在跑的那一轮跑完。
+
+    不等的话那一轮会被拦腰砍断：工具可能正改文件、trace 停在半截、人在浏览器里等一个永远不来的
+    回复。等是有上限的（`[web] stop_wait`），Ctrl+C 可以当场不等。
+    """
+    if settings.web_stop_wait <= 0:
+        return
+
+    def on_wait(busy: int) -> None:
+        tui.console.print(
+            f"[dim]网页上还有 {busy} 轮在跑——等它写完再关"
+            f"（最多 {settings.web_stop_wait:g} 秒，Ctrl+C 直接关）[/]"
+        )
+
+    try:
+        wait_until_idle(settings.server_port, settings.web_stop_wait, on_wait=on_wait)
+    except KeyboardInterrupt:
+        tui.console.print("[dim]不等了，直接关[/]")
+
+
+def main() -> None:
+    import argparse
+
+    ap = argparse.ArgumentParser(description="Agent Harness CLI")
+    ap.add_argument("--model", help="模型 profile 名（配置 [models.*]；缺省用 default）")
+    ap.add_argument(
+        "--clean-trace", type=int, metavar="DAYS",
+        help="删掉 DAYS 天前的轨迹文件（0 = 全部），腾空间；不启动会话",
+    )
+    ap.add_argument(
+        "--stop-web", action="store_true",
+        help="结束占用网页端端口（后端 + 前端 dev server）的进程；不启动会话",
+    )
+    ap.add_argument(
+        "--init", action="store_true",
+        help="首启向导：交互式生成 ~/.agent-harness/config.toml；不启动会话",
+    )
+    args = ap.parse_args()
+
+    if args.init:  # 也不该要求 API key——它就是来写 key 的
+        from .config_wizard import run_init
+
+        raise SystemExit(run_init())
+
+    if args.stop_web:  # 也不该要求 API key
+        from .settings import load_settings
+        from .weblaunch import FRONTEND_PORT, stop_web  # 局部导入：这两个只在 --stop-web 时才需要
+
+        for line in stop_web([load_settings().server_port, FRONTEND_PORT]):
+            print(line)
+        clear_state()  # 记录里那些 pid 已经被上面收掉了，别留给下次启动去"认领"
+        return
+
+    if args.clean_trace is not None:  # 清理不该要求 API key
+        from .session import SESSION_ROOT
+        from .trace import clean_traces
+
+        n, freed = clean_traces(SESSION_ROOT, older_than_days=args.clean_trace)
+        print(f"清掉 {n} 个轨迹文件，释放 {freed / 1048576:.1f} MB")
+        return
+
+    base_prompt = build_system_prompt()
+    llm, settings = load_settings_and_llm(  # 可切换门面（流式）
+        base_prompt, args.model, on_notice=tui.show_notice,
+    )
+    # 本会话「不再问」的程序名（只在内存里，重启即忘——安全边界清楚）
+    session_allowed: set[str] = set()
+
+    def approver(cmd: str, reason: str) -> bool:
+        head = command_head(cmd)
+        if head and head in session_allowed:
+            tui.show_note(f"本会话已允许 {head}，直接执行")  # 留痕：不是静默放行
+            return True
+        decision = tui.show_approval(cmd, reason, timeout=settings.approval_timeout)
+        if decision == "auto":
+            # 自动批准也要留账：屏幕上那行会滚走，trace 才是事后能查的地方
+            tracer.emit("auto", command=cmd, reason=reason)
+        if decision == "always" and head:
+            session_allowed.add(head)
+            tui.show_note(f"本会话不再询问 {head}", "info")
+        return _is_approved(decision)
+
+    web = WebRun()
+    if settings.web_autostart and tui.interactive():  # 管道/脚本模式不拉网页端
+        web = ensure_web(settings.server_port, WORKSPACE)
+
+    prune_empty_sessions(WORKSPACE)  # 打扫：清掉「开了没聊」的空占位（不阻塞——顺手的事）
+    session_id, history = choose_session(WORKSPACE, settings.default_model)
+
+    # 底部显示上下文占比：分母是压缩阈值（同一个数，模型撞上去就会被压），
+    # 分子是「系统提示 + 历史」的字符当量。history 每轮会被替换成新列表，
+    # 闭包读的是那个变量本身，所以下一轮的数字自动是新的。
+    tui.set_context_probe(
+        lambda: (estimate_tokens(history) + len(base_prompt), settings.compact_threshold)
+    )
+    # 会话级模型（用户定）：打开哪个会话用它上次用的模型；--model 显式指定优先
+    saved = load_session_model(WORKSPACE, session_id)
+    if saved and saved not in settings.models:
+        tui.show_note(f"会话原用模型 {saved} 已不在配置里，回退默认", "warn")
+    target = args.model or (saved if saved in settings.models else None)
+    if target and target != llm.current_profile:
+        llm.switch(target)
+    if args.model:  # 显式指定 → 落账（这个会话从此认它）
+        save_session_model(WORKSPACE, session_id, llm.current_profile)
+    # S8：轨迹与 session 同目录同 id；关掉 [trace] enabled 就给空对象（不写盘）
+    tracer = Tracer(trace_path(WORKSPACE, session_id)) if settings.trace_enabled else Tracer()
+
+    def _notice(text: str, **fields) -> None:
+        """压缩这类提示：给人看一眼（流里一行），同时记进 trace（翻账时能看到）。"""
+        tui.show_notice(text)
+        tracer.emit("compact", text=text, **fields)
+
+    llm.set_notice(_notice)
+    session_tools = build_session_tools(  # S10：本会话工具表（带 spawn_subagent）
+        llm, base_prompt, approver=approver, tracer=tracer,
+        max_steps=settings.max_steps, on_hook=tui.show_hook,
+        allow_commands=settings.guardrail_allow,
+    )
+    tui.show_banner(session_id, len(history), llm.current, detect_shell().name)
+    if history:
+        tui.show_history(history)  # 恢复的会话：把历史渲染出来
+    tui.show_web_hint(web.started, web.warning, web.reaped, web.ui_port)  # 放历史之后，不用往上翻
+    _trace_nudge(settings)
+    try:
+        while True:
+            try:
+                goal = tui.ask().strip()
+            except EOFError:
+                break  # 输入读尽（管道喂完 / Ctrl+Z 回车）——收工退出，不是错误
+            if goal in ("exit", "quit"):
+                break
+            if goal == "/trace" or goal.startswith("/trace "):  # S8：轨迹时间线（只读投影）
+                recs = load_trace(trace_path(WORKSPACE, session_id))
+                mark_viewed()  # 体温计：这个功能还有人在用吗
+                arg = goal[len("/trace"):].strip()
+                if not arg:
+                    tui.show_trace(recs, session_id)      # 总览
+                elif arg.isdigit() and 1 <= int(arg) <= len(recs):
+                    tui.show_trace_event(recs[int(arg) - 1], int(arg))  # 钻取单条全文
+                else:
+                    tui.show_note(f"没有 #{arg} 这条事件（当前共 {len(recs)} 条）", "warn")
+                continue
+            if goal == "/model":  # 运行时切换模型（会话级——落盘，退出不丢）
+                tui.show_models(llm.profiles, llm.current_profile)
+                pick = tui.ask().strip()
+                if pick.isdigit() and 1 <= int(pick) <= len(llm.profiles):
+                    name = llm.profiles[int(pick) - 1]
+                    tui.show_note(f"已切换到 {llm.switch(name)}")
+                    save_session_model(WORKSPACE, session_id, name)  # 记在会话上，下次打开还认
+                elif pick:  # 空输入 = 取消（面板上写了）；打了别的东西 = 说清楚，别静默吞
+                    tui.show_note("没这个序号——按提示来", "warn")
+                continue
+            if not goal:
+                continue
+            tui.show_user(goal)
+            tui.begin_stream()
+            old_len = len(history)
+            try:
+                reply, history = agent_loop(
+                    goal, llm, session_tools, base_prompt,
+                    approver=approver, history=history,
+                    on_text=tui.stream_chunk, on_tool=tui.show_tool,
+                    on_reasoning=tui.reasoning_chunk,
+                    tracer=tracer,
+                    pre_hooks=PRE_HOOKS, post_hooks=POST_HOOKS,
+                    on_hook=tui.show_hook,
+                    max_steps=settings.max_steps,
+                    allow_commands=settings.guardrail_allow,
+                )
+            except KeyboardInterrupt:  # Ctrl+C：结束本轮，回到输入行（不是退出程序）
+                tui.end_stream()
+                tui.show_note("已中断本轮（这一轮的历史未落盘）", "warn")
+                continue
+            except Exception as e:  # 网络断了 / 模型报错 / 参数解析炸了——报一句，保住会话
+                # history 是被 agent_loop 换成新列表的（history + [...]），失败时原列表没被改写
+                tui.end_stream()
+                tui.show_note(f"本轮失败：{type(e).__name__}: {e}", "error")
+                continue
+            tui.end_stream()
+            save_messages(WORKSPACE, session_id, history[old_len:])
+    finally:
+        # 关 TUI 就连带收掉网页端：留着它们会变成孤儿，下次启动按端口判断会复用旧代码
+        # （2026-10-24 就是这么卡住的：新按钮点了没反应，8000 上还是上个世纪的进程）。
+        # 只收自己拉起的——端口上原有的可能是另一个 TUI 或用户自己在用，不动。
+        if web.procs and settings.web_stop_on_exit:
+            _let_web_finish(settings)  # 网页上还有一轮就先等它跑完，别拦腰砍断
+            tui.console.print(f"[dim]网页端已关闭：{'、'.join(stop_run(web))}[/]")
+            clear_state()

agent_harness/__main__.py

@@ -0,0 +1,4 @@
+from . import main
+
+if __name__ == "__main__":
+    main()

agent_harness/assembly.py

@@ -0,0 +1,159 @@
+"""装配层：公共装配（system prompt / 工作目录 / 工具注册表）——CLI 与 Web 服务共用。"""
+
+from pathlib import Path
+
+from .config import load_rules
+from .guardrail import safe_tool
+from .hooks import forbid_env_writes
+from .sensors import run_tests
+from .subagent import make_spawn_tool
+from .tools import edit_file, read_file, run_shell, task_output, task_stop, write_file
+
+# 极简取向：只写「模型猜不出来的事实」和「必须遵守的几条」。
+# 不写动机、不写解释、不写"你应该尽量"——每句都要能改变一次具体动作，否则删。
+# 工具细节交给 schema（模型看的是那份），项目规矩交给 AGENTS.md（拼在下面）。
+SYSTEM_PROMPT = (
+    "你是 agent-harness，一个 coding agent，工作目录是项目根。规则只看下方 AGENTS.md (若没有该文件则忽略)\n\n"
+    "shell 是 bash（Windows 上 Git Bash）：用 ls / cat / rm，没有 dir / type / del；"
+    "路径写相对路径；同名命令先 `command -v` 确认，拿不准就用最保守的写法。\n\n"
+    "- 读用 read_file；改用 edit_file；整篇重写才用 write_file（覆盖全文）。\n"
+    "- 改完必须 run_tests 跑到绿——没验证不算完成。\n"
+    "- 其他命令用 run_shell；会改文件、执行程序或判不出的会先问你。\n"
+    "- 不会自己结束的命令（dev server / watch）加 background=true，用完 task_stop。\n"
+    "- 不出项目目录。\n\n"
+    "做完直接给结论，不再调工具。"
+)
+
+WORKSPACE = Path.cwd()  # 工作目录 = 项目根
+
+# 策略名单（S9）：加策略只往这里塞函数——loop 一个字不动
+PRE_HOOKS = [forbid_env_writes]
+POST_HOOKS: list = []  # 后钩子（观察类）——v1 空名单
+
+tools = {
+    "read_file": safe_tool(read_file, WORKSPACE),
+    "write_file": safe_tool(write_file, WORKSPACE),
+    "edit_file": safe_tool(edit_file, WORKSPACE),
+    "run_shell": run_shell,  # shell 不包——命令危险面归 H 护栏管
+    "task_output": task_output,  # 后台任务：看输出
+    "task_stop": task_stop,  # 后台任务：停止
+    "run_tests": run_tests,  # pytest 判红绿
+}
+
+
+def build_session_tools(llm, system_prompt: str, approver=None, tracer=None,
+                        max_steps: int | None = None, on_hook=None,
+                        should_stop=None, allow_commands=()) -> dict:
+    """每个会话的工具表：基础工具 + spawn_subagent（闭包持有该会话的装配）。
+
+    模型 / 审批 / trace 都是会话级的——所以 spawn 不能一次性注册进模块级 tools。
+    """
+    session_tools = dict(tools)
+    session_tools["spawn_subagent"] = make_spawn_tool(
+        llm=llm,
+        tools=tools,
+        system_prompt=system_prompt,
+        approver=approver,
+        tracer=tracer,
+        pre_hooks=PRE_HOOKS,
+        post_hooks=POST_HOOKS,
+        depth=0,
+        max_steps=max_steps,
+        on_hook=on_hook,
+        should_stop=should_stop,
+        allow_commands=allow_commands,
+    )
+    return session_tools
+
+
+def build_system_prompt() -> str:
+    """基础 prompt + 规则文件（每次装配时拼最新）。"""
+    return SYSTEM_PROMPT + "\n\n" + load_rules(WORKSPACE)
+
+
+def list_visible_sessions() -> list[dict]:
+    """列可展示的历史会话（跳过没聊过的空会话占位）——CLI 与 Web 共用。"""
+    from .session import list_sessions
+
+    return [s for s in list_sessions(WORKSPACE) if s["first_user_msg"]]
+
+
+class SwitchableLLM:
+    """可运行时切换的模型门面（对主循环透明——接口与 LLM 一致）。
+
+    /model 换的是内部持有的适配器实例；history、会话全不受影响。
+    """
+
+    def __init__(self, system_prompt: str, settings, name: str | None = None, on_notice=None):
+        self._sp = system_prompt
+        self._settings = settings
+        self._on_notice = on_notice
+        self._name = name or settings.default_model
+        self._inner = self._build(self._name)
+
+    def _build(self, name: str):
+        from .llm import DeepSeekLLM
+
+        p = self._settings.model(name)
+        return DeepSeekLLM(
+            self._sp,
+            model=p.name,
+            base_url=p.base_url,
+            api_key_env=p.api_key_env,
+            api_key=p.api_key,
+            temperature=p.temperature,
+            compact_threshold=self._settings.compact_threshold,
+            keep_last=self._settings.keep_last,
+            snip_keep_groups=self._settings.snip_keep_groups,
+            thinking=p.thinking,
+            reasoning_effort=p.reasoning_effort,
+            strip_think_tags=p.strip_think_tags,
+            on_notice=self._on_notice,  # 换模型后新的适配器也带着这个提示口
+        )
+
+    def set_notice(self, fn) -> None:
+        """换提示口（新建的适配器会带着它，见 _build）。"""
+        self._on_notice = fn
+        self._inner.set_notice(fn)
+
+    def switch(self, name: str) -> str:
+        """切到某个 profile——返回实际模型名（供界面提示）。名字未知抛 KeyError。"""
+        if name not in self._settings.models:
+            raise KeyError(name)
+        self._name = name
+        self._inner = self._build(name)
+        return self.current
+
+    @property
+    def current(self) -> str:
+        """当前实际模型名（如 deepseek-v4-pro）。"""
+        return self._settings.model(self._name).name
+
+    @property
+    def current_profile(self) -> str:
+        """当前 profile 名（如 flash）。"""
+        return self._name
+
+    @property
+    def profiles(self) -> list[str]:
+        return list(self._settings.models)
+
+    def __call__(self, messages, tools, on_text=None, on_reasoning=None, system_prompt=None):
+        return self._inner(
+            messages, tools, on_text=on_text, on_reasoning=on_reasoning,
+            system_prompt=system_prompt,
+        )
+
+
+def load_settings_and_llm(system_prompt: str, model_name: str | None = None, on_notice=None):
+    """按 ~/.agent_harness.toml 构造可切换模型门面——返回 (llm, settings)。
+
+    model_name：初始 profile（None = 配置的 default）。
+    """
+    from .settings import load_settings
+
+    s = load_settings()
+    if model_name and model_name not in s.models:
+        # fail fast：名字打错就当场说，别静默回退到别的模型
+        raise SystemExit(f"未知模型 profile：{model_name}（可用：{', '.join(s.models)}）")
+    return SwitchableLLM(system_prompt, s, model_name, on_notice=on_notice), s

agent_harness/compact.py

@@ -0,0 +1,114 @@
+"""上下文压缩（Compress 策略）：投影式微压缩——不改 history，只压发给 API 的副本。
+
+设计定案（2026-09-22）：白名单判定 / 保留最近 N / 占位替换（结构不动·配对不破）/
+软估阈值触发。reactive 兜底在适配器层（后续接）。
+"""
+
+from dataclasses import replace
+
+from .messages import Msg
+
+# 大输出类工具——其 tool 结果可清理（write/edit/count 结果短，不清）
+COMPACTABLE = {"read_file", "run_shell", "run_tests"}
+
+KEEP_LAST = 5
+
+# 软阈值（字符数当量，约等于 token 数）——量级占位，真撞墙时按实测调
+DEFAULT_THRESHOLD = 70_000
+
+
+def estimate_tokens(messages: list[Msg]) -> int:
+    """粗估 token 数：字符数当量（中文≈1:1，英文保守高估）。不做精确 tokenizer。"""
+    total = 0
+    for m in messages:
+        total += len(m.content or "")
+        if m.tool_calls:
+            total += len(str(m.tool_calls))  # 结构本身也占量；str 兜底 pydantic 对象
+    return total
+
+
+def microcompact(messages: list[Msg], keep_last: int = KEEP_LAST) -> list[Msg]:
+    """投影式微压缩：最近 keep_last 条白名单工具结果保留，更早的 content 换占位。
+
+    role / tool_call_id / tool_calls 一字不动——配对不破（400 防线）。
+    返回新列表且不清的对象复用引用——原 messages 完全不受影响。
+    """
+    # 从后往前数白名单 tool 消息，超出的下标标记为「要清」
+    targets: set[int] = set()
+    seen = 0
+    for i in range(len(messages) - 1, -1, -1):
+        m = messages[i]
+        if m.role == "tool" and m.tool_name in COMPACTABLE:
+            seen += 1
+            if seen > keep_last:
+                targets.add(i)
+
+    if not targets:
+        return list(messages)  # 无需清理——返回浅壳（调用方照常使用）
+
+    out: list[Msg] = []
+    for i, m in enumerate(messages):
+        if i in targets:
+            # dataclasses.replace 产新对象——不动原 Msg（真投影）
+            out.append(
+                replace(m, content=f"[已清理：{m.tool_name} 的旧输出，{len(m.content or '')} 字符]")
+            )
+        else:
+            out.append(m)
+    return out
+
+
+def microcompact_if_needed(
+    messages: list[Msg], threshold: int = DEFAULT_THRESHOLD, keep_last: int = KEEP_LAST
+) -> list[Msg]:
+    """超阈值才压（软估）——否则原样返回。"""
+    if estimate_tokens(messages) <= threshold:
+        return messages
+    return microcompact(messages, keep_last)
+
+
+def snip(messages: list[Msg], keep_groups: int = 3) -> list[Msg]:
+    """激进档（reactive 用）：保首条 user + 最近 keep_groups 组，中间整段省略。
+
+    按「组」切（assistant[tool_calls] + 紧随 tool 消息 = 原子单位）——配对不破。
+    省略标记并入首条 user 的 content——不新增消息（避免连续同 role 的 provider 风险）。
+    """
+    # 划分组：带 tool_calls 的 assistant + 紧随的 tool 消息 = 一组；其余各自一组
+    groups: list[list[int]] = []
+    i = 0
+    while i < len(messages):
+        idxs = [i]
+        if messages[i].role == "assistant" and messages[i].tool_calls:
+            j = i + 1
+            while j < len(messages) and messages[j].role == "tool":
+                idxs.append(j)
+                j += 1
+            i = j
+        else:
+            i += 1
+        groups.append(idxs)
+
+    keep: set[int] = set(groups[0])  # 首组（含任务）
+    if keep_groups > 0:
+        for g in groups[-keep_groups:]:
+            keep.update(g)
+
+    kept = [m for idx, m in enumerate(messages) if idx in keep]
+    omitted = len(messages) - len(kept)
+    if omitted == 0:
+        return list(messages)
+
+    out: list[Msg] = []
+    marked = False
+    for m in kept:
+        if not marked and m.role == "user":
+            out.append(
+                replace(
+                    m,
+                    content=f"{m.content}\n\n[注：为压缩请求体积，已省略中间 {omitted} 条历史消息]",
+                )
+            )
+            marked = True
+        else:
+            out.append(m)
+    return out

agent_harness/config.py

@@ -0,0 +1,14 @@
+"""配置维：规则文件自动加载——声明式约束的机制化（不靠模型自觉读）。"""
+from pathlib import Path
+
+RULE_FILES = ("AGENTS.md",)    
+
+def load_rules(workspace: Path) -> str:
+    # 逐个读存在的规则文件 → 拼成一段文本；都没有 → 返回空串
+    parts: list[str] = []                          # ① 收集容器
+    for name in RULE_FILES:                        # ② 逐个文件名
+        p = workspace / name                       # ③ Path 的 / 拼路径
+        if p.exists():                             # ④ 存在才读
+            text = p.read_text(encoding="utf-8")
+            parts.append(f"# {name}\n\n{text}")    # ⑤ 带来源标题
+    return "\n\n".join(parts)                      # ⑥ 一次 join