argo-search 2.9.7 → 2.9.9

package/sub-skills/local-seek/references/rg-recipes.md

@@ -1,96 +0,0 @@
-# rg 分场景配方
-
-统一入口 `seek.py` 已覆盖多数场景，以下配方用于非常规操作或手动微调。
-所有命令均尊重 .gitignore，自动排除 node_modules 等（见 config/domains.yaml）。
-
-## 基础
-
-```bash
-# 全文搜（当前目录）
-rg "关键词"
-
-# 指定目录
-rg "关键词" ~/notes
-
-# 忽略大小写
-rg -i "keyword"
-
-# 正则
-rg "func[0-9]+\(" src/
-
-# 固定字符串（避免正则转义，含特殊字符时用）
-rg -F "a.b[c]" .
-```
-
-## 定位类
-
-```bash
-# 只看文件名（最省 token，先看分布）
-rg -l "关键词" .
-rg --files-with-matches "关键词" .
-
-# 每文件命中数（先数后看）
-rg --count-matches "关键词" .
-
-# 只看行号不输出内容
-rg -l --line-number "关键词" .
-```
-
-## 上下文类
-
-```bash
-# 前后 N 行
-rg -C 2 "关键词" .
-rg -A 3 "关键词" .   # 只后文
-rg -B 1 "关键词" .   # 只前文
-
-# 输出到文件避免刷屏（超大批量时）
-rg "关键词" . > /tmp/rg_out.txt
-```
-
-## 类型过滤
-
-```bash
-# 按扩展名
-rg -g "*.py" "关键词" .
-rg -g "*.{py,ts,js}" "关键词" .
-
-# 排除
-rg -g "!test_*" "关键词" .
-rg -g "!*.min.js" "关键词" .
-```
-
-## 常用语义场景
-
-```bash
-# 函数/类定义在哪
-rg -n "def handle_request|class AuthService" src/
-# 跨语言：rg "function (getUser|setUser)" .
-
-# 跨文件引用（谁在调用某函数）
-rg "send_email\(" .
-
-# TODO/FIXME 盘点
-rg -n "TODO|FIXME|HACK" --type-add 'todo:*.{py,js,ts,go,rs}' -t todo .
-
-# 只搜中文
-rg -n "[\u4e00-\u9fff]" .
-
-# 找 JSON/YAML 里的键
-rg -n '"max_results"' config/
-
-# 日志排查（最近日志）
-rg "ERROR|panic" --glob "*.log" .
-```
-
-## 性能
-
-- 大仓库先 `--count` 或 `-l`，避免输出千行
-- 指定 `-g` 类型或目录，rg 只扫必要范围
-- 超过 30s 无结果：换词或换 mdfind（--spotlight），不要重复等待
-- rg 退出码：0=有匹配，1=无匹配，2=报错。脚本已处理，手动用时注意
-
-## 非代码文件（可选扩展）
-
-rga（ripgrep-all）未安装时可临时用 mdfind 覆盖 PDF/Office 场景；
-若常搜这类文件，装 rga：`brew install ripgrep-all`

package/sub-skills/local-seek/references/strategies.md

@@ -1,52 +0,0 @@
-# 渐进式策略与 token 纪律
-
-本 skill 的核心不是「更快地搜索」，而是「用最少的 token 拿到答案」。
-工具输出就是压缩结果，模型不该有探索成本。
-
-## 三层渐进（永远按此顺序）
-
-```
-L1 定位      seek.py "词" --count / --filename
-             → 输出「文件:命中数」或文件路径列表，每行 < 80 字符
-             ↓ 从中挑出最相关的 1-3 个文件
-L2 上下文    seek.py "词" --context 2 --path <该文件所在目录>
-             → 输出「路径:行号:命中行 ± 2 行」
-             ↓ 确定要精读的段落
-L3 精读      read_file 该文件，用行号偏移局部读取
-```
-
-任何一步已经能回答用户，就停。不要为完整性多搜。
-
-## 搜索范围扩大的顺序（先窄后宽）
-
-1. 当前目录 + 默认排除（最常命中）
-2. `--path` 扩大到知识域（~/notes、~/Documents 等，见 domains.yaml）
-3. `--spotlight` 全盘兜底
-
-禁止跳级：用户问「找代码里某个函数」却直接 mdfind 全盘，浪费且不准。
-
-## 输出量控制
-
-| 手段 | 效果 |
-|------|------|
-| `--max 20` | 截断结果数，防止刷屏 |
-| `--count` | 只报分布，不报内容 |
-| `--type py,ts` | 只扫目标类型 |
-| `--context 0`（默认） | 不输出上下文行 |
-| `-l` 手动模式 | 只列文件名 |
-
-## 常见失败与换词策略
-
-| 现象 | 处理 |
-|------|------|
-| 无匹配 | 换同义词/拆词/去掉修饰词，重试 1 次后换工具 |
-| 命中过多 | 加 `--type` / `--max` / 更具体的关键词（加引号做短语匹配） |
-| 结果太泛 | 指定目录缩小范围 |
-| 搜代码但命中注释/文档 | 换更精确的符号名或结构模式 |
-| Spotlight 搜不到 | 确认目录已索引；退回 rg + 明确 --path |
-
-## 与 Argo 的分工
-
-- 用户要「网上查」→ argo（联网）
-- 用户要「本地找/搜我的文件」→ local-seek
-- 混合需求（如「查网上的同时翻本地笔记」）→ 并行调用，互不干扰

package/sub-skills/local-seek/references/structural-search.md

@@ -1,59 +0,0 @@
-# 结构搜索手册（--structural）
-
-按「语义」而非「字符串」检索代码模式：找裸 except、空 catch、装饰函数这类
-「看着就知道有问题/有特征」的结构。零安装实现：rg -U 多行匹配 + 语言感知
-pattern，本机装 ast-grep 后可升级为 AST 精确匹配（见文末）。
-
-## 用法
-
-```bash
-# 按语义名或中文别名检索，输出同普通搜索（路径:行号:片段）
-python3 ~/.agents/skills/argo/sub-skills/local-seek/scripts/seek.py "裸except" --structural
-python3 ~/.agents/skills/argo/sub-skills/local-seek/scripts/seek.py "empty-catch" --structural --path ~/repo
-python3 ~/.agents/skills/argo/sub-skills/local-seek/scripts/seek.py "函数定义" --structural --path ~/repo --type py
-python3 ~/.agents/skills/argo/sub-skills/local-seek/scripts/seek.py "不存在语义" --structural   # 报可用列表
-```
-
-查询词可写语义名（empty-catch）或任意中文别名（空catch、裸异常），大小写不敏感。
-
-## 内置规则
-
-| 语义名 | 中文别名 | 查什么 | 覆盖语言 |
-|--------|---------|--------|---------|
-| empty-catch | 空catch、空捕获、空异常处理 | `catch (...) {}` 空体 | js/jsx/ts/tsx |
-| bare-except | 裸except、无类型except | `except:` 无异常类型 | py |
-| unwrapped-error | 错误未包装、裸return err | `return err` 直接返回错误 | go |
-| decorated-fn | 装饰函数、装饰器函数 | 带 `@decorator` 的函数定义 | py |
-| function-def | 函数定义、找函数 | 函数定义行 | py/js/ts/go/rs |
-| class-def | 类定义、找类 | 类/结构体定义行 | py/js/ts/go/java |
-
-## 实现说明
-
-- 每条规则 = 若干 (扩展名集合, 正则) 对，逐语言跑 `rg -U -i --line-number`。
-- `-U` 启用多行模式，decorated-fn 才能跨行匹配 `@装饰器\n def`。
-- 语言无命中（rg 退出码 1）静默跳过，不报错。
-- 与正文搜索共用排除规则（domains.yaml + --exclude）。
-- 局限：正则近似，非真实 AST。缩进风格怪异的代码、嵌套场景可能漏报；
-  `catch {}` 内只有注释也算空体（正则按字面空体判断）。
-
-## 扩展新规则
-
-在 seek.py 的 `STRUCTURAL_RULES` 字典追加一条：
-
-```python
-"todo-count": {
-    "aliases": ("待办统计", "todo盘点"),
-    "patterns": [
-        (("py", "js", "ts"), r"TODO|FIXME|HACK"),
-    ],
-},
-```
-
-规则键即语义名，aliases 提供中文入口，patterns 按语言给正则。
-加完跑 `python3 scripts/eval_seek.py` 确认无回归，再补一条结构用例。
-
-## 升级路径（装 ast-grep 后）
-
-ast-grep 能精确匹配 AST 节点（真·空 catch 块、未捕获的裸 except），
-消除正则的漏报误报。届时在 structural_search 里检测 `sg` 命令存在则优先
-AST，缺失时回落当前 rg -U 实现，行为对调用方透明。

package/sub-skills/local-seek/tests/test_content_rank.py

@@ -1,222 +0,0 @@
-#!/usr/bin/env python3
-"""tests/test_content_rank.py — 内容 BM25F 重排 + fzf V2 评分契约（2026-10-07 方案甲）。
-
-守四类不变式：
-  A. 重排闸门：逃生门/正则查询/count/context 一律保持 (路径,行号) 原序
-  B. 重排质量：文件名命中 > 纯行命中；多词全覆盖 > 单词擦边；噪声档
-     分层在重排后依然成立（真源在前）
-  C. 确定性：打分只依赖内容，发射序打乱输出逐位一致（2026-10-06 契约延续）
-  D. fzf V2：边界/驼峰/连续/gap 惩罚的相对次序与 fzf 口径一致，全等最优
-
-打桩纪律：unittest.mock.patch.object（自动恢复）——直接给 s.run 赋值且
-不恢复会把同进程后续测试的真实 rg 顶掉（2026-10-06 实锤教训，见
-test_determinism_20261006.py 模块头）。
-"""
-
-from __future__ import annotations
-
-import subprocess
-import sys
-import unittest
-from pathlib import Path
-from unittest.mock import patch
-
-ROOT = Path(__file__).resolve().parent.parent
-sys.path.insert(0, str(ROOT / "scripts"))
-
-import seek as s  # noqa: E402
-import seek_rank as r  # noqa: E402
-
-
-def _proc(stdout: str, rc: int = 0) -> subprocess.CompletedProcess:
-    return subprocess.CompletedProcess(args=[], returncode=rc,
-                                       stdout=stdout, stderr="")
-
-
-class TestRerankGate(unittest.TestCase):
-    """A. 闸门：不该重排的场景必须保持 (路径,行号) 原序。"""
-
-    ROWS = [
-        ("b/beta.py", 5, "alpha"),
-        ("a/alpha.py", 9, "alpha"),
-        ("c/gamma.md", 1, "alpha"),
-    ]
-
-    def _search(self, raw_query, fixed=True, ctx=0, count=False):
-        with patch.object(s, "run", return_value=_proc("a/x.py:1:hit\n")):
-            # 直接对池行调用重排闸门（不走 rg，隔离网络与文件系统）
-            return s._rerank_content(list(self.ROWS), raw_query, ctx, count, fixed)
-
-    def test_escape_hatch_restores_order(self):
-        import os
-        old = os.environ.pop("ARGO_SEEK_CONTENT_RERANK", None)
-        os.environ["ARGO_SEEK_CONTENT_RERANK"] = "0"
-        try:
-            self.assertEqual(self._search("alpha"), self.ROWS)
-        finally:
-            os.environ.pop("ARGO_SEEK_CONTENT_RERANK", None)
-            if old is not None:
-                os.environ["ARGO_SEEK_CONTENT_RERANK"] = old
-
-    def test_regex_query_not_reranked(self):
-        # fixed=False（正则/PCRE2）：词元切分只会产生碎片，闸门必须放行原序
-        self.assertEqual(self._search(r"\d{4}", fixed=False), self.ROWS)
-
-    def test_count_and_context_not_reranked(self):
-        self.assertEqual(self._search("alpha", count=True), self.ROWS)
-        self.assertEqual(self._search("alpha", ctx=3), self.ROWS)
-
-    def test_no_token_query_not_reranked(self):
-        self.assertEqual(self._search("!!!"), self.ROWS)
-
-
-class TestRerankQuality(unittest.TestCase):
-    """B. 重排质量：相关度次序的三条核心判据。"""
-
-    def test_filename_match_beats_content_only(self):
-        rows = [
-            ("docs/notes.md", 12, "支持噪声档降权的说明文字。"),
-            ("src/noise_tier.py", 3, "placeholder"),
-            ("src/other.py", 8, "噪声相关但文件无关。"),
-        ]
-        out = r.rank_rows(rows, "noise_tier")
-        self.assertEqual(out[0][0], "src/noise_tier.py")
-
-    def test_multi_token_coverage_beats_partial(self):
-        rows = [
-            ("a/one.md", 1, "只提到缓存一个词。"),
-            ("b/both.md", 2, "语义缓存与 minhash 软命中都在这行。"),
-        ]
-        out = r.rank_rows(rows, "语义缓存 minhash")
-        self.assertEqual(out[0][0], "b/both.md")
-
-    def test_verbatim_phrase_beats_bigram_scatter(self):
-        # 二元组分不清「噪声档的实现行」与「只有噪声二字的无关行」：
-        # 逐字短语加成必须把前者顶上去
-        rows = [
-            ("a/x.md", 1, "设备噪声很大。"),
-            ("b/y.py", 2, "噪声档的阈值定义在此。"),
-        ]
-        out = r.rank_rows(rows, "噪声档")
-        self.assertEqual(out[0][0], "b/y.py")
-
-    def test_ties_break_by_path_line(self):
-        rows = [("b.py", 2, "same"), ("a.py", 9, "same"), ("a.py", 1, "same")]
-        out = r.rank_rows(rows, "same")
-        self.assertEqual([(p, l) for p, l, _ in out],
-                         [("a.py", 1), ("a.py", 9), ("b.py", 2)])
-
-    def test_noise_floor_after_rerank(self):
-        # 重排改变池内次序后，噪声档分层（真源在前）必须依然成立——
-        # 分层发生在 rg_search 的 _apply_noise_floor（重排之后），走全链路验证
-        rows = [
-            "tmp/x.py:1:noise tier keyword",
-            "src/y.py:2:noise tier keyword here",
-        ]
-        with patch.object(s, "run", return_value=_proc("\n".join(rows) + "\n")):
-            out, err = s.rg_search(["noise"], ".", [], [], 0, False, 5,
-                                   fixed=True, raw_query="noise tier keyword")
-        self.assertIsNone(err)
-        self.assertTrue(out, "真源行不应消失")
-        self.assertTrue(out[0][0].startswith("src/"),
-                        f"真源应排最前，实际: {out[0][0]}")
-
-
-class TestRerankDeterminism(unittest.TestCase):
-    """C. 确定性：打平发射序（2026-10-06 契约在重排开启下延续）。"""
-
-    def test_output_independent_of_emission_order(self):
-        rows = [f"src/f{i:03d}.py:{j + 1}:alpha beta hit {i}-{j}"
-                for i in range(40) for j in range(1)]
-        with patch.object(s, "run", return_value=_proc("\n".join(rows) + "\n")):
-            a, err = s.rg_search(["alpha"], ".", [], [], 0, False, 5,
-                                 fixed=True, raw_query="alpha beta")
-            import random
-            shuffled = rows[:]
-            random.Random(7).shuffle(shuffled)
-            with patch.object(s, "run", return_value=_proc("\n".join(shuffled) + "\n")):
-                b, err2 = s.rg_search(["alpha"], ".", [], [], 0, False, 5,
-                                      fixed=True, raw_query="alpha beta")
-        self.assertIsNone(err)
-        self.assertIsNone(err2)
-        self.assertEqual(a, b)
-
-
-class TestFzfV2(unittest.TestCase):
-    """D. fzf FuzzyMatchV2 口径。"""
-
-    def test_no_match_is_zero(self):
-        self.assertEqual(s._fzf_score("zzz.txt", "rep"), 0)
-
-    def test_smart_case(self):
-        self.assertGreater(s._fzf_score("Report_v2.md", "report"), 0)
-        # 模式带大写 → 区分大小写：R 匹配、r 不配
-        self.assertEqual(s._fzf_score("report.md", "R"), 0)
-
-    def test_boundary_beats_midword(self):
-        # bar 在 foo_bar（词边界）> xbarx（词中）
-        self.assertGreater(s._fzf_score("foo_bar.py", "bar"),
-                           s._fzf_score("xbarx.py", "bar"))
-
-    def test_consecutive_beats_gappy(self):
-        self.assertGreater(s._fzf_score("xabc.md", "abc"),
-                           s._fzf_score("axbxc.md", "abc"))
-
-    def test_camel_bonus(self):
-        self.assertGreater(s._fzf_score("parseHTTPResponse.py", "hr"), 0)
-
-    def test_dp_optimal_alignment(self):
-        # xaabc 搜 ab：DP 应发现「跳过词首 a、取边界 b」的对齐优于顺位连打
-        # （顺位贪心：a@1 + b@4 有 gap；最优：a@1 + b@4 不如 a@3?——此处锚定
-        # 已知反超事实：xaabc 的分必须高于等长无边界对照 axbxc 的同模式分）
-        self.assertGreater(s._fzf_score("xaabc", "ab"),
-                           s._fzf_score("axbxc", "ab"))
-
-    def test_exact_beats_partial(self):
-        self.assertGreater(s._fzf_score("seek.py", "seek.py"),
-                           s._fzf_score("seek_helper.py", "seek.py"))
-
-    def test_exact_case_beats_icase(self):
-        self.assertGreaterEqual(s._fzf_score("Seek.py", "seek.py"),
-                                s._fzf_score("seek.py", "seek.py")
-                                )  # 全等大写版含 case bonus，不小于纯 icase
-
-
-class TestFrecencyWiring(unittest.TestCase):
-    """frecency 默认关闭：不启用时不产生任何行为差异。"""
-
-    def test_disabled_by_default(self):
-        import os
-        old = os.environ.pop("ARGO_SEEK_FRECENCY", None)
-        try:
-            import seek_frecency
-            self.assertFalse(seek_frecency.enabled())
-            self.assertEqual(seek_frecency.boost("/any/path"), 0.0)
-        finally:
-            if old is not None:
-                os.environ["ARGO_SEEK_FRECENCY"] = old
-
-    def test_boost_and_record_roundtrip(self):
-        import os
-        import tempfile
-        old_flag = os.environ.pop("ARGO_SEEK_FRECENCY", None)
-        old_db = os.environ.pop("ARGO_SEEK_FRECENCY_DB", None)
-        with tempfile.TemporaryDirectory() as td:
-            os.environ["ARGO_SEEK_FRECENCY"] = "1"
-            os.environ["ARGO_SEEK_FRECENCY_DB"] = str(Path(td) / "f.json")
-            try:
-                import seek_frecency
-                seek_frecency.record(["/a/b.py", "/c/d.py"])
-                self.assertGreater(seek_frecency.boost("/a/b.py"), 0.0)
-                self.assertEqual(seek_frecency.boost("/z/missing.py"), 0.0)
-            finally:
-                os.environ.pop("ARGO_SEEK_FRECENCY", None)
-                os.environ.pop("ARGO_SEEK_FRECENCY_DB", None)
-                if old_flag is not None:
-                    os.environ["ARGO_SEEK_FRECENCY"] = old_flag
-                if old_db is not None:
-                    os.environ["ARGO_SEEK_FRECENCY_DB"] = old_db
-
-
-if __name__ == "__main__":
-    unittest.main()

package/sub-skills/local-seek/tests/test_determinism_20261006.py

@@ -1,145 +0,0 @@
-#!/usr/bin/env python3
-"""tests/test_determinism_20261006.py — 宽查询输出确定性回归（方案一，2026-10-06）。
-
-守 v1.4.1 审计遗留的定性修复：
-  1. rg 并行遍历发射序不定 →「先到先得」截断拿到任意的 cap 条，同查询
-     两次跑结果集与排序都不同。修复后有界堆按 (路径,行号,内容) 选池，
-     **同一命中集无论以什么顺序发射，输出逐条一致**。
-  2. count 模式并列计数按路径升序决出稳定次序。
-  3. grep 兜底路径同款语义。
-  4. 锁定 ja/ko 2-gram 既有行为（CJK_RE 覆盖假名/谚文——2026-10-06 实测
-     已支持，修正审计记忆里「无分词只能整词匹配」的过时记录）。
-
-打桩纪律：一律 unittest.mock.patch.object（自动恢复）。首版直接给
-s.run 赋值且不恢复，把同进程后续测试的真实 rg 全部替换成假输出——
-套件 9 红的根因（2026-10-06 实锤，教训记录在此防再犯）。
-"""
-
-from __future__ import annotations
-
-import subprocess
-import sys
-import unittest
-from pathlib import Path
-from unittest.mock import patch
-
-ROOT = Path(__file__).resolve().parent.parent
-sys.path.insert(0, str(ROOT / "scripts"))
-
-import seek as s  # noqa: E402
-
-
-def _proc(stdout: str, rc: int = 0) -> subprocess.CompletedProcess:
-    return subprocess.CompletedProcess(args=[], returncode=rc,
-                                       stdout=stdout, stderr="")
-
-
-def _matches(n_files: int, lines_per: int = 1) -> list[str]:
-    """n_files 个文件的 rg 命中行（路径 f{i:03d}.py 保证字典序可控）。"""
-    out = []
-    for i in range(n_files):
-        for j in range(lines_per):
-            out.append(f"src/f{i:03d}.py:{j + 1}:hit {i}-{j}")
-    return out
-
-
-class RgBodyDeterminism(unittest.TestCase):
-    """rg 主体路径：池子选择与发射序无关。"""
-
-    def test_output_independent_of_emission_order(self):
-        rows = _matches(40)
-        # max_results=5 → cap = max(5, min(20, 400)) = 20：命中 40 > cap，
-        # 池子选择真正发生截断
-        for drop_noise in (True, False):
-            with self.subTest(drop_noise=drop_noise):
-                with patch.object(s, "run",
-                                  return_value=_proc("\n".join(rows) + "\n")):
-                    a, err = s.rg_search(["q"], ".", [], [], 0, False, 5,
-                                         fixed=True, drop_noise=drop_noise)
-                with patch.object(s, "run",
-                                  return_value=_proc(
-                                      "\n".join(reversed(rows)) + "\n")):
-                    b, err2 = s.rg_search(["q"], ".", [], [], 0, False, 5,
-                                          fixed=True, drop_noise=drop_noise)
-                self.assertIsNone(err)
-                self.assertIsNone(err2)
-                self.assertEqual(a, b, "同一命中集、不同发射序 → 输出必须一致")
-
-    def test_pool_is_path_smallest_and_sorted(self):
-        rows = _matches(40)
-        with patch.object(s, "run",
-                          return_value=_proc("\n".join(rows) + "\n")):
-            out, err = s.rg_search(["q"], ".", [], [], 0, False, 5,
-                                   fixed=True, drop_noise=False)
-        self.assertIsNone(err)
-        self.assertEqual([r[0] for r in out],
-                         [f"src/f{i:03d}.py" for i in range(5)])
-        self.assertEqual(len(out), 5)
-
-    def test_noise_floor_layering_deterministic(self):
-        """clean 在前 noisy 在后的分层语义在确定池子上仍然成立。"""
-        rows = (["src/clean_{:03d}.py:1:hit".format(i) for i in range(30)]
-                + ["src/repos/lib_{:03d}.py:1:hit".format(i) for i in range(30)])
-        outs = []
-        for order in (rows, list(reversed(rows))):
-            with patch.object(s, "run",
-                              return_value=_proc("\n".join(order) + "\n")):
-                out, err = s.rg_search(["q"], ".", [], [], 0, False, 5,
-                                       fixed=True, drop_noise=True)
-            self.assertIsNone(err)
-            outs.append(out)
-        self.assertEqual(outs[0], outs[1])
-        self.assertTrue(all("/repos/" not in r[0] for r in outs[0]),
-                        "clean 够数时噪声档不得混入")
-
-
-class CountTieDeterminism(unittest.TestCase):
-    def test_equal_counts_sorted_by_path(self):
-        rows = ["src/b.py:5", "src/a.py:5", "src/c.py:2"]
-        with patch.object(s, "run",
-                          return_value=_proc("\n".join(rows) + "\n")):
-            out, err = s.rg_search(["q"], ".", [], [], 0, True, 10,
-                                   fixed=True, drop_noise=False)
-        self.assertIsNone(err)
-        self.assertEqual([r[0] for r in out],
-                         ["src/a.py", "src/b.py", "src/c.py"])
-
-
-class GrepFallbackDeterminism(unittest.TestCase):
-    def test_body_and_count_deterministic(self):
-        rows = _matches(40)
-        for order in (rows, list(reversed(rows))):
-            with patch.object(s, "run",
-                              return_value=_proc("\n".join(order) + "\n")):
-                body, err = s.grep_search("grep", ["q"], ".", [], [], 0,
-                                          False, 5, fixed=True)
-            self.assertIsNone(err)
-            self.assertEqual([r[0] for r in body],
-                             [f"src/f{i:03d}.py" for i in range(5)])
-        cnt_rows = ["src/b.py:5", "src/a.py:5"]
-        with patch.object(s, "run",
-                          return_value=_proc("\n".join(cnt_rows) + "\n")):
-            cnt, err = s.grep_search("grep", ["q"], ".", [], [], 0,
-                                     True, 10, fixed=True)
-        self.assertIsNone(err)
-        self.assertEqual([r[0] for r in cnt], ["src/a.py", "src/b.py"])
-
-
-class JaKoBigramLocked(unittest.TestCase):
-    """锁定既有行为（实测于 2026-10-06）：CJK_RE 已覆盖假名/谚文。"""
-
-    def test_japanese_compound_gets_bigrams(self):
-        pats, literal = s.build_patterns("プロンプトエンジニアリング入門")
-        self.assertIn("プロンプトエンジニアリング入門", pats)  # 整词
-        self.assertIn("プロ", pats)                            # 首个 2-gram
-        self.assertTrue(literal)
-
-    def test_korean_spaced_words_and_compound(self):
-        pats, _ = s.build_patterns("프로프트 검색 설정")
-        self.assertIn("프로프트", pats)   # 复合词整词
-        self.assertIn("프로", pats)       # 复合词 2-gram
-        self.assertIn("검색", pats)       # 空格分隔词保持整词
-
-
-if __name__ == "__main__":
-    unittest.main()

package/sub-skills/local-seek/tests/test_noise_tier.py

@@ -1,101 +0,0 @@
-#!/usr/bin/env python3
-"""噪声档降权的回归测试（2026-09-27 新增，方案 C3）。
-
-实测背景（Documents/GPT 搜 "import"，rg 61899 处命中）：
-    vendor/生成物/归档  7% + 测试/fixture/benchmark  27% + tmp/  7% = 41%
-搜代码时，四成命中是「不想看到的东西」。原来的 DEFAULT_EXCLUDES 挡掉了
-node_modules/dist 之类，但漏了三类最大的：repos/（克隆仓）、tests|fixtures|
-benchmark、tmp/。
-
-**为什么是降权不是排除**：排除 = 这些内容永远搜不到。搜「某个克隆仓里怎么
-写的」「我的测试怎么写的」是真实且常见的用法，排除会让工具在这些查询上
-直接回答「未找到匹配」——那比返回噪声更糟。降权 + 无命中自动回落，两者兼得。
-
-本文件锁定的性质：
-  1. 默认搜不到噪声档内容（降权生效）；
-  2. 噪声档独有内容**仍可达**（回落生效，不制造「明明有却搜不到」）；
-  3. --include-noise 显式关闭降权；
-  4. 回落不影响正常命中（有真源时不去噪声档白跑一趟）。
-"""
-from __future__ import annotations
-
-import os
-import subprocess
-import sys
-from pathlib import Path
-
-SEEK = Path(__file__).resolve().parent.parent / "scripts" / "seek.py"
-
-
-def _have(*tools) -> bool:
-    import shutil
-    return all(shutil.which(t) for t in tools)
-
-
-def _run(args, cwd):
-    return subprocess.run([sys.executable, str(SEEK)] + args, cwd=cwd,
-                          capture_output=True, text=True, timeout=120)
-
-
-def _make_tree(root: Path):
-    """构造一棵含「真实源」与「噪声档」两类内容的最小目录树。
-
-    标记词刻意选 `zzmarker_*`：pytest 的 tmp_path 目录名会带测试函数名
-    （如 `test_noise_tier_is_deprioritiz0`），若标记词是 `pytest` 之类，
-    路径本身就会命中，测试变成在验证「路径里有这个词」而非「噪声档降权」。
-    这是第一版用例写错的地方。
-    """
-    (root / "src").mkdir(parents=True)
-    (root / "src" / "app.py").write_text("import os\nimport sys\n", encoding="utf-8")
-    (root / "repos" / "thirdparty").mkdir(parents=True)
-    (root / "repos" / "thirdparty" / "lib.py").write_text(
-        "import zzzarker_clonelib\n", encoding="utf-8")
-    (root / "tests").mkdir()
-    (root / "tests" / "test_x.py").write_text(
-        "import zzzarker_fixture\n", encoding="utf-8")
-
-
-def test_noise_tier_is_deprioritized_and_reachable(tmp_path):
-    if not _have("rg"):
-        import pytest
-        pytest.skip("rg 未安装")
-    _make_tree(tmp_path)
-    proj = str(tmp_path)
-
-    # 噪声档独有内容：搜得到（相对根判定，本例的 tests/ 在根之下），
-    # 且**不触发**回落重搜——它本来就没被排除，只是被排到真源之后。
-    r = _run(["zzzarker_fixture", "--path", proj], tmp_path)
-    assert "test_x.py" in r.stdout, r.stdout
-    assert "噪声档" not in r.stdout, "没被排除就不该多跑一趟回落"
-
-    # 正常源：不受降权影响
-    r2 = _run(["import", "--path", proj], tmp_path)
-    assert "app.py" in r2.stdout, r2.stdout
-
-
-def test_deprioritized_means_source_wins(tmp_path):
-    """同一查询同时命中真源与噪声档时，真源必须排在前面。"""
-    if not _have("rg"):
-        import pytest
-        pytest.skip("rg 未安装")
-    (tmp_path / "src").mkdir()
-    (tmp_path / "src" / "real.py").write_text("import shared_token\n", encoding="utf-8")
-    (tmp_path / "repos").mkdir()
-    (tmp_path / "repos" / "copy.py").write_text("import shared_token\n", encoding="utf-8")
-    proj = str(tmp_path)
-
-    r = _run(["shared_token", "--path", proj, "--max", "1"], tmp_path)
-    assert "real.py" in r.stdout, r.stdout
-    assert "copy.py" not in r.stdout, r.stdout
-
-
-def test_include_noise_flag_is_explicit(tmp_path):
-    if not _have("rg"):
-        import pytest
-        pytest.skip("rg 未安装")
-    _make_tree(tmp_path)
-    proj = str(tmp_path)
-    r = _run(["zzzarker_fixture", "--path", proj, "--include-noise"], tmp_path)
-    assert "test_x.py" in r.stdout, r.stdout
-    # 显式开启时不应再回落（那会多跑一趟）
-    assert "噪声档" not in r.stdout, r.stdout