decorated-pi 0.2.2 → 0.4.0

package/extensions/smart-at.ts

@@ -1,175 +1,381 @@
 /**
  * Smart @ - 高速文件搜索自动补全
  *
+ * 设计:
+ *   1. 缓存生命周期绑定用户交互: 触发 @ 时收集+缓存, 选择/取消时清除
+ *   2. 收集时预计算路径惩罚(路径固有,跟 query 无关)
+ *   3. 惩罚分级消费: 每个文件只命中最高级别的一档惩罚,不叠加
+ *   4. 搜索时只算匹配分, 总分 = 匹配分 + 惩罚分
+ *
+ * 候选收集:
+ *   - Git 仓库: git ls-files 列出文件, 从文件路径推导目录
+ *   - 非 Git 仓库: fd 列出文件和目录
+ *
+ * 惩罚来源:
+ *   - Git 仓库: .gitignore 规则(动态) + 静态规则
+ *   - 非 Git 仓库: 仅静态规则
+ *
+ * 惩罚分级(从高到低,首次命中即消费,不叠加):
+ *   Tier 1 (-400): 匹配 .gitignore 规则(仅 git 仓库)
+ *   Tier 2 (-300): 在 .* 或 __* 目录下
+ *   Tier 3 (-200): 在已知噪音目录下(build/dist/coverage 等)
+ *   Tier 4 (-150~-80): 坏扩展名(二进制/编译产物/媒体文件)
+ *   Base (always): -depth*30 - name.length
+ *
+ * 匹配:
+ *   - 大小写敏感
+ *   - 目录优先
+ *
  * 【重要】applyCompletion / shouldTriggerFileCompletion 必须用 .bind(orig)
- * 不能用箭头函数!Pi editor 会做原型检查,新函数导致扩展崩溃。
+ * 不能用箭头函数! Pi editor 会做原型检查,新函数导致扩展崩溃。
  */
 
 import { spawnSync } from "child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 // ═══════════════════════════════════════════════════════════
-// 文件列表(缓存 10s,maxBuffer 防 ENOBUFS)
+// 类型
+// ═══════════════════════════════════════════════════════════
+
+type PenaltyTier = 0 | 1 | 2 | 3 | 4;
+
+interface FileCandidate {
+  path: string;       // 相对路径 "extensions/lsp/tools.ts"
+  name: string;       // 文件名 "tools.ts"
+  isDir: boolean;
+  tier: PenaltyTier;  // 语义分级,用于空查询过滤
+  penalty: number;    // 预计算: tierPenalty + basePenalty
+}
+
+// ═══════════════════════════════════════════════════════════
+// 硬排除 & 惩罚规则
 // ═══════════════════════════════════════════════════════════
 
-let cachedDirs: string[] = [];
-let cachedFiles: string[] = [];
-let cacheTime = 0;
-let cacheCwd = "";
+/** 硬排除: 不枚举其子文件/子目录,但目录本身保留为候选 */
+const HARD_EXCLUDE_DIRS = new Set(["node_modules", ".git", ".pnpm", ".svn"]);
+
+/** Tier 3: 已知噪音目录(不以 . 开头,但通常是构建产物) */
+const BAD_DIRS = new Set(["build", "dist", "coverage", "out", "target"]);
+
+/** Tier 4: 扩展名惩罚(值为负数) */
+const EXT_PENALTY: Record<string, number> = {
+  o: -150, obj: -150, a: -150, so: -150, dll: -150, exe: -150,
+  wasm: -150, class: -120, pyc: -120,
+  bmp: -100, png: -100, jpg: -100, gif: -100, ico: -100, svg: -80,
+  mp3: -100, wav: -100, mp4: -100, avi: -100,
+  pdf: -100, zip: -100, tar: -100, gz: -100,
+  lock: -80,
+};
+
+// ═══════════════════════════════════════════════════════════
+// 惩罚预计算(分级消费,首次命中即停)
+// ═══════════════════════════════════════════════════════════
+
+interface PenaltyMeta {
+  tier: PenaltyTier;
+  penalty: number;
+}
+
+function computePenaltyMeta(filePath: string, isDir: boolean, gitIgnored: boolean): PenaltyMeta {
+  const parts = filePath.replace(/\/$/, "").split("/");
+  const name = parts[parts.length - 1] || filePath;
+  const ext = (!isDir && name.includes(".")) ? (name.split(".").pop()?.toLowerCase() || "") : "";
+  const depth = parts.length;
 
-function getFileAndDirList(cwd: string): { dirs: string[]; files: string[] } {
-  const now = Date.now();
-  if (cacheCwd === cwd && now - cacheTime < 10000) return { dirs: cachedDirs, files: cachedFiles };
+  // 文件: 检查父目录段; 目录: 检查所有段(含自身)
+  const dirSegments = isDir ? parts : parts.slice(0, -1);
+
+  let tier: PenaltyTier = 0;
+  let tierPenalty = 0;
+
+  if (gitIgnored) {
+    tier = 1;
+    tierPenalty = -400;
+  } else if (dirSegments.some(d => d.startsWith(".") || d.startsWith("__"))) {
+    tier = 2;
+    tierPenalty = -300;
+  } else if (dirSegments.some(d => BAD_DIRS.has(d))) {
+    tier = 3;
+    tierPenalty = -200;
+  } else if (!isDir && (EXT_PENALTY[ext] ?? 0) < 0) {
+    tier = 4;
+    tierPenalty = EXT_PENALTY[ext]!;
+  }
+
+  const basePenalty = -(depth * 30) - name.length;
+  return { tier, penalty: tierPenalty + basePenalty };
+}
+
+function computePenalty(filePath: string, isDir: boolean, gitIgnored: boolean): number {
+  return computePenaltyMeta(filePath, isDir, gitIgnored).penalty;
+}
+
+// ═══════════════════════════════════════════════════════════
+// 候选收集
+// ═══════════════════════════════════════════════════════════
+
+const SPAWN_OPTS = { timeout: 5000, encoding: "utf-8" as const, maxBuffer: 10 * 1024 * 1024 };
+
+function collectCandidates(cwd: string): FileCandidate[] {
+  const candidates: FileCandidate[] = [];
+
+  // 判断路径是否为硬排除目录的子项(不含硬排除目录本身)
+  const isChildOfHardExclude = (p: string): boolean => {
+    const parts = p.replace(/\/$/, "").split("/");
+    for (let i = 0; i < parts.length - 1; i++) {
+      if (HARD_EXCLUDE_DIRS.has(parts[i]!)) return true;
+    }
+    return false;
+  };
+
+  const opts = { ...SPAWN_OPTS, cwd };
+
+  // ── 检测是否 git 仓库 ──
+  const isGit = spawnSync("git", ["rev-parse", "--is-inside-work-tree"], opts).status === 0;
+
+  if (isGit) {
+    collectGit(candidates, opts, isChildOfHardExclude);
+  } else {
+    collectFd(candidates, cwd, isChildOfHardExclude);
+  }
+
+  return candidates;
+}
 
-  let dirs: string[] = [];
-  let files: string[] = [];
-  const opts = { timeout: 5000, encoding: "utf-8" as const, maxBuffer: 10 * 1024 * 1024, cwd };
+/** Git 仓库: git ls-files 列出文件, 从文件路径推导目录 */
+function collectGit(
+  candidates: FileCandidate[],
+  opts: { timeout: number; encoding: "utf-8"; maxBuffer: number; cwd: string },
+  isChildOfHardExclude: (p: string) => boolean,
+) {
+  // 可见文件(tracked + untracked 非 ignored)
+  const r1 = spawnSync("git", ["ls-files", "--cached", "--others", "--exclude-standard"], opts);
+  const visibleFiles = (r1.status === 0 && r1.stdout)
+    ? r1.stdout.trim().split("\n").filter(Boolean)
+    : [];
 
-  // 去掉 cwd 前缀和 ./ 前缀,转相对路径
+  // ignored 项(目录优先聚合)
+  const r2 = spawnSync(
+    "git",
+    ["ls-files", "--others", "--ignored", "--exclude-standard", "--directory", "--no-empty-directory"],
+    opts,
+  );
+  const ignoredDirs = new Set<string>();
+  const ignoredFiles: string[] = [];
+  if (r2.status === 0 && r2.stdout) {
+    for (const raw of r2.stdout.trim().split("\n").filter(Boolean)) {
+      const entry = raw.replace(/^\.\//,  "");
+      if (isChildOfHardExclude(entry)) continue;
+      if (entry.endsWith("/")) {
+        ignoredDirs.add(entry.replace(/\/$/, ""));
+      } else {
+        ignoredFiles.push(entry);
+      }
+    }
+  }
+
+  const hasIgnoredAncestor = (p: string): boolean => {
+    const parts = p.split("/");
+    let current = "";
+    for (let i = 0; i < parts.length - 1; i++) {
+      current = current ? `${current}/${parts[i]}` : parts[i]!;
+      if (ignoredDirs.has(current)) return true;
+    }
+    return false;
+  };
+
+  const ignoredFileSet = new Set(ignoredFiles);
+
+  // ── 可见文件 → 候选 ──
+  const dirSet = new Set<string>();
+  for (const f of visibleFiles) {
+    if (isChildOfHardExclude(f)) continue;
+    const name = f.split("/").pop() || f;
+    const meta = computePenaltyMeta(f, false, false);
+    candidates.push({ path: f, name, isDir: false, tier: meta.tier, penalty: meta.penalty });
+    // 推导目录
+    const parts = f.split("/");
+    let current = "";
+    for (let i = 0; i < parts.length - 1; i++) {
+      current = current ? `${current}/${parts[i]}` : parts[i]!;
+      dirSet.add(current);
+    }
+  }
+
+  // ── ignored 文件 → 候选 ──
+  for (const f of ignoredFiles) {
+    const name = f.split("/").pop() || f;
+    const meta = computePenaltyMeta(f, false, true);
+    candidates.push({ path: f, name, isDir: false, tier: meta.tier, penalty: meta.penalty });
+  }
+
+  // ── 推导的可见目录 → 候选 ──
+  for (const d of dirSet) {
+    const name = d.split("/").pop() || d;
+    const meta = computePenaltyMeta(d, true, false);
+    candidates.push({ path: d + "/", name, isDir: true, tier: meta.tier, penalty: meta.penalty });
+  }
+
+  // ── ignored 目录 → 候选 ──
+  for (const d of ignoredDirs) {
+    const name = d.split("/").pop() || d;
+    const meta = computePenaltyMeta(d, true, true);
+    candidates.push({ path: d + "/", name, isDir: true, tier: meta.tier, penalty: meta.penalty });
+  }
+
+  // ── 硬排除目录本身 → 候选(仅存在时加入) ──
+  for (const hd of HARD_EXCLUDE_DIRS) {
+    if (!existsSync(join(opts.cwd, hd))) continue;
+    const meta = computePenaltyMeta(hd, true, false);
+    candidates.push({ path: hd + "/", name: hd, isDir: true, tier: meta.tier, penalty: meta.penalty });
+  }
+}
+
+/** 非 Git 仓库: fd 列出文件和目录, 仅用静态规则惩罚 */
+function collectFd(
+  candidates: FileCandidate[],
+  cwd: string,
+  isChildOfHardExclude: (p: string) => boolean,
+) {
   const rel = (s: string) => {
     let r = s.startsWith(cwd + "/") ? s.slice(cwd.length + 1) : s;
     return r.startsWith("./") ? r.slice(2) : r;
   };
 
-  // 1. git ls-files (returns relative paths)
-  const git = spawnSync("git", ["rev-parse", "--is-inside-work-tree"], opts);
-  if (git.status === 0) {
-    const r = spawnSync("git", ["ls-files", "--cached", "--others", "--exclude-standard"], opts);
-    if (r.status === 0 && r.stdout) files = r.stdout.trim().split("\n").filter(Boolean);
+  const fdExcludes = [...HARD_EXCLUDE_DIRS].flatMap(d => ["--exclude", d]);
+  const fdOpts = { ...SPAWN_OPTS, cwd: undefined as string | undefined };
+
+  // 文件(排除硬排除目录的子文件)
+  const r1 = spawnSync("fd", ["--type", "f", "--hidden", "--no-ignore", ...fdExcludes, ".", cwd], fdOpts);
+  if (r1.status === 0 && r1.stdout) {
+    for (const raw of r1.stdout.trim().split("\n").filter(Boolean)) {
+      const f = rel(raw);
+      const name = f.split("/").pop() || f;
+      const meta = computePenaltyMeta(f, false, false);
+      candidates.push({ path: f, name, isDir: false, tier: meta.tier, penalty: meta.penalty });
+    }
   }
 
-  // 2. fd (returns absolute paths when given absolute path)
-  if (!files.length) {
-    const fdFiles = spawnSync("fd", ["--type", "f", "--hidden", ".", cwd], { ...opts, cwd: undefined });
-    if (fdFiles.status === 0 && fdFiles.stdout) files = fdFiles.stdout.trim().split("\n").filter(Boolean).map(rel);
+  // 目录(排除硬排除目录的子目录)
+  const r2 = spawnSync("fd", ["--type", "d", "--hidden", "--no-ignore", ...fdExcludes, ".", cwd], fdOpts);
+  if (r2.status === 0 && r2.stdout) {
+    for (const raw of r2.stdout.trim().split("\n").filter(Boolean)) {
+      const d = rel(raw).replace(/\/$/, "");
+      const name = d.split("/").pop() || d;
+      const meta = computePenaltyMeta(d, true, false);
+      candidates.push({ path: d + "/", name, isDir: true, tier: meta.tier, penalty: meta.penalty });
+    }
   }
-  const fdDirs = spawnSync("fd", ["--type", "d", "--hidden", ".", cwd], { ...opts, cwd: undefined });
-  if (fdDirs.status === 0 && fdDirs.stdout) dirs = fdDirs.stdout.trim().split("\n").filter(Boolean).map(rel);
 
-  cachedDirs = dirs;
-  cachedFiles = files;
-  cacheTime = Date.now();
-  cacheCwd = cwd;
-  return { dirs, files };
+  // 硬排除目录本身 → 候选(仅存在时加入)
+  for (const hd of HARD_EXCLUDE_DIRS) {
+    if (!existsSync(join(cwd, hd))) continue;
+    const meta = computePenaltyMeta(hd, true, false);
+    candidates.push({ path: hd + "/", name: hd, isDir: true, tier: meta.tier, penalty: meta.penalty });
+  }
 }
 
 // ═══════════════════════════════════════════════════════════
-// 评分
+// 匹配评分(query 相关,大小写敏感)
 // ═══════════════════════════════════════════════════════════
 
-const EXT_PENALTY: Record<string, number> = {
-  o: -500, obj: -500, a: -500, so: -500, dll: -500, exe: -500,
-  wasm: -500, class: -400, pyc: -400,
-  bmp: -200, png: -200, jpg: -200, gif: -200, ico: -200, svg: -100,
-  mp3: -200, wav: -200, mp4: -200, avi: -200,
-  pdf: -200, zip: -200, tar: -200, gz: -200,
-  lock: -100, json: 0, yml: 0, yaml: 0, toml: 0,
-};
-
-const BAD_DIRS = ["node_modules", ".obj", "build", "dist"];
-
-// 真模糊匹配（字符可以不连续）
+/** 模糊匹配(大小写敏感,字符可以不连续) */
 function fuzzyScore(text: string, query: string): number {
-  const t = text.toLowerCase(), q = query.toLowerCase();
   let qi = 0, firstMatch = -1, lastMatch = -1;
-  for (let ti = 0; ti < t.length && qi < q.length; ti++) {
-    if (t[ti] === q[qi]) {
+  for (let ti = 0; ti < text.length && qi < query.length; ti++) {
+    if (text[ti] === query[qi]) {
       if (firstMatch < 0) firstMatch = ti;
       lastMatch = ti;
       qi++;
     }
   }
-  if (qi < q.length) return 0;
-  const span = lastMatch - firstMatch + 1;  // 匹配跨度
-  const totalLen = t.length;
-  // 跨度小 + 文件名短 = 高分
-  return Math.max(10, 200 - span * 3 - totalLen);
+  if (qi < query.length) return 0;
+  const span = lastMatch - firstMatch + 1;
+  return Math.max(10, 200 - span * 3 - text.length);
 }
 
-function scoreFile(file: string, query: string, isDir = false): number {
-  const cleaned = isDir ? file.replace(/\/$/, "") : file;
-  const parts = cleaned.split("/");
-  const name = parts[parts.length - 1] || cleaned;
+/** 计算单个候选对 query 的匹配分(大小写敏感) */
+function computeMatchScore(candidate: FileCandidate, query: string): number {
+  const { path: filePath, name, isDir } = candidate;
   const stem = name.replace(/\.[^.]+$/, "");
-  const ext = name.includes(".") ? name.split(".").pop()?.toLowerCase() || "" : "";
-  const q = query.toLowerCase();
-  const nl = name.toLowerCase();
-  const sl = stem.toLowerCase();
-  const depth = parts.length;
-  const inDir = parts.slice(0, -1).some((d) => d.toLowerCase().includes(q));
+  const parts = filePath.replace(/\/$/, "").split("/");
+  const inDir = parts.slice(0, -1).some(d => d.includes(query));
 
   let s = 0;
-  if (sl === q) s = isDir ? 980 : 950;
-  else if (nl.startsWith(q + ".") || nl.startsWith(q + "_") || nl.startsWith(q + "/")) s = 900;
-  else if (nl.startsWith(q)) s = 800;
-  else if (nl.includes(q)) s = 500;
-  else if (file.toLowerCase().includes(q)) s = 100;
-  else {
-    // 模糊匹配仅限文件名(全路径太松)
-    s = fuzzyScore(nl, q);
-  }
+
+  // 大小写敏感匹配
+  if (stem === query)                                                       s = isDir ? 1500 : 1050;
+  else if (name.startsWith(query + ".") || name.startsWith(query + "_"))    s = 1000;
+  else if (name.startsWith(query))                                          s = 900;
+  else if (name.includes(query))                                            s = 600;
+  else if (filePath.includes(query))                                        s = 300;
+  else                                                                      s = fuzzyScore(name, query);
+
   if (!s) return 0;
 
-  // 目录加成(+500,确保匹配目录排第一)
-  if (isDir) s += 500;
-  // 扩展名奖惩
-  if (!isDir) s += EXT_PENALTY[ext] ?? 0;
-  // 隐藏目录 / 缓存目录 / __pycache__ 类目录 降权
-  const inBadDir = parts.some((d) => d.startsWith(".") || d.startsWith("__") || BAD_DIRS.includes(d));
-  if (inBadDir) s -= 200;
-  if (inDir) s += 300;
+  // 目录轻微加成(tiebreaker,不碾压深度)
+  if (isDir) s += 100;
+
+  // 父目录命中加成
+  if (inDir) s += 50;
 
-  return s * 3 - name.length - depth * 2;
+  return s;
 }
 
 // ═══════════════════════════════════════════════════════════
-// 搜索
+// 搜索(匹配分 + 惩罚分 = 总分排序)
 // ═══════════════════════════════════════════════════════════
 
-function smartSearch(dirs: string[], files: string[], query: string): string[] {
+function smartSearch(candidates: FileCandidate[], query: string): string[] {
+  // 空查询: 按 tier 语义过滤, 隐藏 Tier 1/2
   if (!query) {
-    // 无查询:排除隐藏目录和隐藏目录下的所有文件
-    const isHidden = (p: string) => p.split("/").some((s) => s.startsWith(".") || s.startsWith("__"));
-    return [
-      ...dirs.filter((d) => !isHidden(d)).slice(0, 10),
-      ...files.filter((f) => !isHidden(f)).slice(0, 10),
-    ];
+    const visible = candidates.filter(c => c.tier === 0 || c.tier === 3 || c.tier === 4);
+    return visible
+      .sort((a, b) => {
+        // 目录优先
+        if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
+        return b.penalty - a.penalty || a.path.localeCompare(b.path);
+      })
+      .slice(0, 20)
+      .map(c => c.path);
   }
-  const tokens = query.toLowerCase().split(/\s+/).filter(Boolean);
 
-  // 合并打分(隐藏目录降权但可见)
-  const scored = [
-    ...dirs.map((d) => ({ path: d.endsWith("/") ? d : d + "/", s: scoreFile(d, tokens[0]!, true) })),
-    ...files.map((f) => ({ path: f, s: scoreFile(f, tokens[0]!, false) })),
-  ].filter((x) => x.s > 0);
+  const tokens = query.split(/\s+/).filter(Boolean);
 
   if (tokens.length === 1) {
+    const scored = candidates
+      .map(c => {
+        const matchScore = computeMatchScore(c, tokens[0]!);
+        return { path: c.path, total: matchScore + c.penalty, matchScore };
+      })
+      .filter(x => x.matchScore > 0);
+
     return scored
-      .sort((a, b) => b.s - a.s || a.path.localeCompare(b.path))
+      .sort((a, b) => b.total - a.total || a.path.localeCompare(b.path))
       .slice(0, 20)
-      .map((x) => x.path);
+      .map(x => x.path);
   }
 
-  // 多词 OR
+  // 多词: 各 token 独立搜索取 union
   const seen = new Set<string>();
-  const all = [
-    ...dirs.map((d) => ({ path: d.endsWith("/") ? d : d + "/", isDir: true })),
-    ...files.map((f) => ({ path: f, isDir: false })),
-  ];
   for (const t of tokens) {
-    for (const { path: p } of all
-      .map(({ path, isDir }) => ({ path, s: scoreFile(path, t, isDir) }))
-      .filter((x) => x.s > 0)
-      .sort((a, b) => b.s - a.s)
-      .slice(0, 20)) {
-      seen.add(p);
-    }
+    const scored = candidates
+      .map(c => {
+        const matchScore = computeMatchScore(c, t);
+        return { path: c.path, total: matchScore + c.penalty, matchScore };
+      })
+      .filter(x => x.matchScore > 0)
+      .sort((a, b) => b.total - a.total)
+      .slice(0, 20);
+    for (const { path } of scored) seen.add(path);
   }
   return [...seen].slice(0, 20);
 }
 
 // ═══════════════════════════════════════════════════════════
-// @ 前缀
+// @ 前缀检测
 // ═══════════════════════════════════════════════════════════
 
 function atPrefix(text: string): string | null {
@@ -182,6 +388,16 @@ function atPrefix(text: string): string | null {
   return null;
 }
 
+// 测试导出: 仅暴露纯逻辑
+export const __smartAtTest = {
+  computePenaltyMeta,
+  computePenalty,
+  fuzzyScore,
+  computeMatchScore,
+  smartSearch,
+  atPrefix,
+};
+
 // ═══════════════════════════════════════════════════════════
 // 入口
 // ═══════════════════════════════════════════════════════════
@@ -190,23 +406,35 @@ export function setupSmartAt(pi: ExtensionAPI) {
   pi.on("session_start", (_e: any, ctx: any) => {
     const cwd = String(ctx.cwd || "").trim();
 
+    let cache: FileCandidate[] | null = null;
+
+    function getOrBuildCache(): FileCandidate[] {
+      if (!cache) cache = collectCandidates(cwd);
+      return cache;
+    }
+
+    function clearCache() {
+      cache = null;
+    }
+
     ctx.ui.addAutocompleteProvider((orig: any) => ({
       getSuggestions: (lines: any, cl: any, cc: any, opts: any) => {
         const prefix = atPrefix((lines[cl] || "").slice(0, cc));
         if (!prefix) {
+          clearCache();
           ctx.ui.setWidget("smart-at", undefined);
           return orig.getSuggestions(lines, cl, cc, opts);
         }
 
-        const { dirs, files } = getFileAndDirList(cwd);
-        const results = smartSearch(dirs, files, prefix.slice(1));
+        const candidates = getOrBuildCache();
+        const results = smartSearch(candidates, prefix.slice(1));
 
         if (!results.length) {
           ctx.ui.setWidget("smart-at", undefined);
           return null;
         }
 
-        ctx.ui.setWidget("smart-at", ["powered by decorated-pi"]);
+        ctx.ui.setWidget("smart-at", ["\x1b[2mpowered by decorated-pi\x1b[0m"]);
         return Promise.resolve({
           items: results.map((f: string) => ({
             value: "@" + f,
@@ -216,8 +444,8 @@ export function setupSmartAt(pi: ExtensionAPI) {
           prefix,
         });
       },
-      // ⚠️ 必须 .bind(orig)
       applyCompletion: (...args: any[]) => {
+        clearCache();
         ctx.ui.setWidget("smart-at", undefined);
         return orig.applyCompletion.apply(orig, args);
       },

package/extensions/subdir-agents.ts

@@ -4,29 +4,49 @@
  * 当 agent 读取或编辑子目录中的文件时，自动发现该目录及父目录中的 AGENTS.md/CLAUDE.md，
  * 将其内容注入到 tool result 中。
  *
- * 状态通过 pi.appendEntry() 持久化到 session JSONL 文件中，resume 时自动恢复。
+ * 状态通过 pi.appendEntry() 持久化到 session JSONL 文件中，resume / reload 时恢复。
+ * compaction 视为上下文边界：仅恢复当前 branch 上最后一个 compaction 之后的已加载状态。
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { dirname, resolve, relative, join } from "node:path";
+import { dirname, resolve, relative, join, normalize } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 
 const CUSTOM_TYPE = "decorated-pi.subdir-agents";
 const AGENTS_NAMES = ["AGENTS.md", "AGENTS.MD", "CLAUDE.md", "CLAUDE.MD"];
 
+interface SessionLikeEntry {
+  type: string;
+  customType?: string;
+  data?: unknown;
+}
+
 const discovered = new Set<string>();
 const pendingPaths = new Map<string, string>();
 let sessionCwd = process.cwd();
 
-function restoreFromSession(ctx: { cwd: string; sessionManager: { getEntries: () => Array<{ type: string; customType?: string; data?: unknown }> } }) {
+function normalizeAbsPath(cwd: string, p: string): string {
+  return normalize(resolve(cwd, p));
+}
+
+function lastCompactionIndex(entries: SessionLikeEntry[]): number {
+  for (let i = entries.length - 1; i >= 0; i--) {
+    if (entries[i]?.type === "compaction") return i;
+  }
+  return -1;
+}
+
+function restoreFromBranch(ctx: { cwd: string; sessionManager: { getBranch: () => Array<SessionLikeEntry> } }) {
   discovered.clear();
-  for (const entry of ctx.sessionManager.getEntries()) {
-    if (entry.type === "custom" && entry.customType === CUSTOM_TYPE) {
-      const paths = entry.data as string[] | undefined;
-      if (paths) {
-        for (const p of paths) {
-          discovered.add(resolve(ctx.cwd, p));
-        }
+  const branch = ctx.sessionManager.getBranch();
+  const start = lastCompactionIndex(branch) + 1;
+  for (const entry of branch.slice(start)) {
+    if (entry.type !== "custom" || entry.customType !== CUSTOM_TYPE) continue;
+    const paths = entry.data as string[] | undefined;
+    if (!Array.isArray(paths)) continue;
+    for (const p of paths) {
+      if (typeof p === "string" && p.trim()) {
+        discovered.add(normalizeAbsPath(ctx.cwd, p));
       }
     }
   }
@@ -34,7 +54,7 @@ function restoreFromSession(ctx: { cwd: string; sessionManager: { getEntries: ()
 
 function findNewAgents(filePath: string, cwd: string): Array<{ path: string; content: string }> {
   const resolvedCwd = resolve(cwd);
-  let dir = dirname(resolve(filePath));
+  let dir = dirname(resolve(cwd, filePath));
   const results: Array<{ path: string; content: string }> = [];
 
   while (true) {
@@ -42,7 +62,7 @@ function findNewAgents(filePath: string, cwd: string): Array<{ path: string; con
     if (rel === "" || rel.startsWith("..")) break;
 
     for (const name of AGENTS_NAMES) {
-      const agentsPath = join(dir, name);
+      const agentsPath = normalize(join(dir, name));
       if (existsSync(agentsPath) && !discovered.has(agentsPath)) {
         try {
           const content = readFileSync(agentsPath, "utf-8");
@@ -65,10 +85,20 @@ function findNewAgents(filePath: string, cwd: string): Array<{ path: string; con
   return results.reverse();
 }
 
+export const __subdirAgentsTest = {
+  restoreFromBranch,
+  findNewAgents,
+};
+
 export function setupSubdirAgents(pi: ExtensionAPI) {
   pi.on("session_start", (_event, ctx) => {
     sessionCwd = ctx.cwd;
-    restoreFromSession(ctx);
+    restoreFromBranch(ctx);
+  });
+
+  pi.on("session_compact", () => {
+    discovered.clear();
+    pendingPaths.clear();
   });
 
   pi.on("tool_call", (event) => {