@zhushanwen/pi-session-reader 0.6.0 → 0.6.1

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@zhushanwen/pi-session-reader",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "type": "module",
   "main": "index.ts",
-  "xyz-agent": {
+  "taiji": {
     "role": "universal"
   },
   "pi": {
@@ -16,12 +16,12 @@
     "pi-package"
   ],
   "dependencies": {
-    "@zhushanwen/pi-ext-guards": "0.4.0"
+    "@zhushanwen/pi-ext-guards": "0.4.1"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^4.1.9",
     "vitest": "^4.1.8",
-    "@zhushanwen/subagent-core": "0.10.1"
+    "@zhushanwen/subagent-core": "0.10.5"
   },
   "files": [
     "index.ts",

package/src/__tests__/cross-package-subagent-core.test.ts

@@ -20,20 +20,21 @@ import {
 } from '@zhushanwen/subagent-core/execution/assembly/path-encoding.ts'
 
 /**
- * W4 跨包集成测试（subagent-sync-collect v2 impl-plan W4 验收条款①，设计 §5 W4：
- * 「subagent-core 真实 tmpdir 产出磁盘状态 → session-reader result action sa- id 反查，
- * 不 mock manifest 写入」）。
+ * W4 跨包集成测试（[collect 退役] 改造保留：原「E1 落标出口产出 manifest」驱动面
+ * 随 sync 批机制删除，现行真实投影出口 = store 重建通道 rebuildIndexes——manifest
+ * 是可丢缓存，boot 全量腿按磁盘子文件锚幂等补缺）。「subagent-core 真实 tmpdir
+ * 产出磁盘状态 → session-reader result action sa- id 反查，不 mock manifest 写入」
+ * 的跨包契约保持不变。
  *
- * 与 result.test.ts 的分工：result.test.ts 的 fixture **手工预写** manifest（U6 时期
- * W3 投影代码尚不存在）；本文件 manifest 内容必须来自 v2 W3 的投影代码路径——
- * subagent-core 侧真实驱动 E1 崩溃恢复（kill -9 同构链路：真实 RecordStore 落盘
- * register/轮终 entry → initSession 内 orphan 覆写真实跑 → recoverSyncCollectBatch
- * 落标出口 appendBatchFinalizedEntry fire-and-forget 真写 records/<sa-id>.json），
- * session-reader 侧零 mock 读同一 tmpdir 断言反查闭环。
+ * 与 result.test.ts 的分工：result.test.ts 的 fixture **手工预写** manifest；本文件
+ * manifest 内容必须来自投影代码路径——subagent-core 侧真实驱动（真实 RecordStore
+ * 落盘 register/轮终 entry → initSession 内 orphan 覆写真实跑 → rebuildIndexes
+ * derivedManifestRecord 投影真写 records/<sa-id>.json），session-reader 侧零 mock
+ * 读同一 tmpdir 断言反查闭环。
  *
  * 构造形态取自 subagent-core sync-collect-recovery.test.ts 的 kill -9 同构主用例
- * （W1 领地，形态同构是 v1 教训「种子绕过真实链路 = 假绿」的执行）：子 session 文件
- * 在其基础上补 message entries（result action 的正文提取源）。
+ * （形态同构是 v1 教训「种子绕过真实链路 = 假绿」的执行）：子 session 文件在其
+ * 基础上补 message entries（result action 的正文提取源）。
  *
  * mock 面最小：仅构造 SubagentService 所需的最小 pi 形状（appendEntry 真写主文件，
  * 其余 no-op stub）——零 vi.mock、notifier/store/config 全真实实现，agentDir 全部
@@ -48,9 +49,9 @@ const ENV_KEYS_TO_STRIP = [
   'PI_SUBAGENT_DEPTH',
   'PI_SUBAGENT_ROOT_CWD',
   'PI_SUBAGENT_FORK_DEPTH',
-  'XYZ_SUBAGENT_RELAY_SOCKET',
-  'XYZ_SUBAGENT_RELAY_NODE',
-  'XYZ_SUBAGENT_RELAY_SCRIPT',
+  'TAIJI_SUBAGENT_RELAY_SOCKET',
+  'TAIJI_SUBAGENT_RELAY_NODE',
+  'TAIJI_SUBAGENT_RELAY_SCRIPT',
 ] as const
 
 const ROOT_SESSION = 'root-cross-pkg'
@@ -102,8 +103,6 @@ function memberRecord(overrides: Partial<SubagentRecord> & { id: string }): Suba
     result: undefined,
     error: undefined,
     sessionFile: undefined,
-    chatMode: false,
-    collectMode: 'sync',
     ...overrides,
   }
 }
@@ -118,7 +117,7 @@ interface MemberSeed {
   model: string
 }
 
-describe('跨包集成：subagent-core E1 落标 manifest → session-reader result 反查（W4）', () => {
+describe('跨包集成：subagent-core 重建 manifest → session-reader result 反查（W4）', () => {
   let agentDir: string
   let mainFile: string
   let services: SubagentService[]
@@ -224,21 +223,11 @@ describe('跨包集成：subagent-core E1 落标 manifest → session-reader res
     )
   }
 
-  /** 手写短轮询（真实 timers，vitest 4.1.8 vi.waitFor 对 falsy callback 不轮询——
-   *  subagent-core 同款纪律）：manifest 为 fire-and-forget 异步写，需轮询等落盘。 */
-  async function until(cond: () => boolean, timeoutMs = 3000): Promise<void> {
-    const start = Date.now()
-    while (!cond()) {
-      if (Date.now() - start > timeoutMs) {
-        throw new Error(`cross-pkg: condition not met within ${timeoutMs}ms`)
-      }
-      await new Promise((resolve) => setTimeout(resolve, 10))
-    }
-  }
-
-  /** 全链路驱动：种子 → 恢复 service（orphan 覆写）→ E1（落标出口真写 manifest）。
-   *  返回子 session 文件路径表。 */
-  async function driveSyncBatchRecovery(members: MemberSeed[]): Promise<Map<string, string>> {
+  /** 全链路驱动：种子 → 恢复 service（orphan 覆写）→ rebuildIndexes（现行 boot
+   *  全量重建通道——derivedManifestRecord 投影真写 manifest）。返回子 session 文件
+   *  路径表。[collect 退役] 原 E1 落标出口（recoverSyncCollectBatch →
+   *  appendBatchFinalizedEntry）随 sync 批机制删除。 */
+  async function driveManifestRebuild(members: MemberSeed[]): Promise<Map<string, string>> {
     const childFiles = new Map<string, string>()
     for (const m of members) {
       const childFile = writeChildSessionFile(m)
@@ -246,12 +235,15 @@ describe('跨包集成：subagent-core E1 落标 manifest → session-reader res
       seedRoundTerminalEntries(m, childFile)
     }
     const service = makeRecoveryService()
-    service.recoverSyncCollectBatch()
-    // E1 落标出口 appendBatchFinalizedEntry 的 manifest 是 fire-and-forget best-effort
-    // 写——轮询等全部成员 manifest 真实落盘（W3 投影代码路径的产物）。
-    await until(() =>
-      members.every((m) => fs.existsSync(path.join(getSubagentRecordsDir(agentDir, agentDir), `${m.id}.json`))),
-    )
+    service.rebuildIndexes()
+    // derivedManifestRecord 投影为同步落盘——全成员 manifest 即刻可见（W3 投影
+    // 代码路径的产物，非手工预写）。
+    for (const m of members) {
+      expect(
+        fs.existsSync(path.join(getSubagentRecordsDir(agentDir, agentDir), `${m.id}.json`)),
+        `manifest of ${m.id}`,
+      ).toBe(true)
+    }
     return childFiles
   }
 
@@ -263,12 +255,12 @@ describe('跨包集成：subagent-core E1 落标 manifest → session-reader res
       assistantParts: ['part one', 'part two'],
       model: 'prov/round-m',
     }
-    const childFiles = await driveSyncBatchRecovery([m])
+    const childFiles = await driveManifestRebuild([m])
 
-    // manifest 内容断言（W3 appendBatchFinalizedEntry 投影路径的产物，非手工预写）：
-    // sessionFile 来自 W1 投影扩展。[U2/U3 两态桥接] E1 落标成员经恢复链覆写后处于
-    // idle（重建单规则）/running 形态、无旧终态遗留位 → legacy status 如实投影
-    // "running"（batchManifestRecord 单点派生，session-reader 视角的活跃成员）。
+    // manifest 内容断言（rebuildIndexes → derivedManifestRecord 投影路径的产物，
+    // 非手工预写）：sessionFile 来自 W1 投影扩展。[U2/U3 两态桥接] 恢复链覆写后成员
+    // 处于 idle（重建单规则）、无旧终态遗留位 → legacy status 如实投影 "running"
+    //（legacyManifestStatusFields 单点派生，session-reader 视角的活跃成员）。
     const manifest = JSON.parse(
       fs.readFileSync(path.join(getSubagentRecordsDir(agentDir, agentDir), 'sa-cross-1.json'), 'utf-8'),
     ) as Record<string, unknown>
@@ -303,7 +295,7 @@ describe('跨包集成：subagent-core E1 落标 manifest → session-reader res
       { id: 'sa-cross-a', resultText: 'alpha final answer', assistantParts: ['alpha final answer'], model: 'prov/ma' },
       { id: 'sa-cross-b', resultText: 'beta final answer', assistantParts: ['beta final answer'], model: 'prov/mb' },
     ]
-    await driveSyncBatchRecovery(members)
+    await driveManifestRebuild(members)
 
     const r = await handleSessionRead({ action: 'result', session: 'sa-cross-a,sa-cross-b' }, { agentDir })
     const text = r.content[0]?.text ?? ''

package/src/__tests__/env.test.ts

@@ -1,9 +1,9 @@
 import { describe, it, expect } from 'vitest'
 import {
   detectEnvironment,
-  XYZ_AGENT_EXT_LOG_ENV,
+  TAIJI_AGENT_EXT_LOG_ENV,
   PI_CODING_AGENT_DIR_ENV,
-  XYZ_AGENT_DATA_DIR_ENV,
+  TAIJI_AGENT_DATA_DIR_ENV,
   type EnvironmentSignals,
 } from '../discovery/env.js'
 
@@ -22,54 +22,54 @@ function signals(overrides: Partial<EnvironmentSignals> = {}): EnvironmentSignal
 }
 
 describe('detectEnvironment 托管合取判定', () => {
-  it('双信号齐备 + B 后新布局 <dataDir>/agent → xyz-agent（packaged）', () => {
+  it('双信号齐备 + B 后新布局 <dataDir>/agent → taiji（packaged）', () => {
     const r = detectEnvironment(
       signals({
         env: {
-          [XYZ_AGENT_EXT_LOG_ENV]: '1',
-          [PI_CODING_AGENT_DIR_ENV]: '/Users/u/.xyz-agent/agent',
+          [TAIJI_AGENT_EXT_LOG_ENV]: '1',
+          [PI_CODING_AGENT_DIR_ENV]: '/Users/u/.taiji/agent',
         },
         bundleUrl:
           'file:///Applications/TaiJi.app/Contents/Resources/extensions/@zhushanwen/pi-session-reader/index.mjs',
       }),
     )
-    expect(r.kind).toBe('xyz-agent')
+    expect(r.kind).toBe('taiji')
     expect(r.distribution).toBe('packaged')
-    expect(r.dataDir).toBe('/Users/u/.xyz-agent')
+    expect(r.dataDir).toBe('/Users/u/.taiji')
   })
 
-  it('双信号齐备 + B 前旧布局 <dataDir>/pi/agent → xyz-agent（迁移窗口期双形态兼容）', () => {
+  it('双信号齐备 + B 前旧布局 <dataDir>/pi/agent → taiji（迁移窗口期双形态兼容）', () => {
     const r = detectEnvironment(
       signals({
         env: {
-          [XYZ_AGENT_EXT_LOG_ENV]: '1',
-          [PI_CODING_AGENT_DIR_ENV]: '/Users/u/.xyz-agent-dev/pi/agent',
+          [TAIJI_AGENT_EXT_LOG_ENV]: '1',
+          [PI_CODING_AGENT_DIR_ENV]: '/Users/u/.taiji-dev/pi/agent',
         },
-        bundleUrl: 'file:///Users/u/Code/xyz-agent/extensions/universal/session-reader/src/index.ts',
+        bundleUrl: 'file:///Users/u/Code/taiji/extensions/universal/session-reader/src/index.ts',
       }),
     )
-    expect(r.kind).toBe('xyz-agent')
+    expect(r.kind).toBe('taiji')
     expect(r.distribution).toBe('dev')
-    expect(r.dataDir).toBe('/Users/u/.xyz-agent-dev')
+    expect(r.dataDir).toBe('/Users/u/.taiji-dev')
   })
 
-  it('透传污染反例 1：仅 XYZ_AGENT_EXT_LOG=1（PI_CODING_AGENT_DIR 未设）→ standalone-pi，evidence 点名孤置信号', () => {
+  it('透传污染反例 1：仅 TAIJI_AGENT_EXT_LOG=1（PI_CODING_AGENT_DIR 未设）→ standalone-pi，evidence 点名孤置信号', () => {
     const r = detectEnvironment(
-      signals({ env: { [XYZ_AGENT_EXT_LOG_ENV]: '1' } }),
+      signals({ env: { [TAIJI_AGENT_EXT_LOG_ENV]: '1' } }),
     )
     expect(r.kind).toBe('standalone-pi')
     expect(r.dataDir).toBeUndefined()
     const joined = r.evidence.join('\n')
-    expect(joined).toContain(`${XYZ_AGENT_EXT_LOG_ENV}='1' → 命中`)
+    expect(joined).toContain(`${TAIJI_AGENT_EXT_LOG_ENV}='1' → 命中`)
     expect(joined).toContain('单独成立不合取')
-    expect(joined).toContain(XYZ_AGENT_EXT_LOG_ENV)
+    expect(joined).toContain(TAIJI_AGENT_EXT_LOG_ENV)
   })
 
-  it('透传污染反例 2：仅 XYZ_AGENT_EXT_LOG=1 且 PI_CODING_AGENT_DIR 为裸 pi 形态 → standalone-pi', () => {
+  it('透传污染反例 2：仅 TAIJI_AGENT_EXT_LOG=1 且 PI_CODING_AGENT_DIR 为裸 pi 形态 → standalone-pi', () => {
     const r = detectEnvironment(
       signals({
         env: {
-          [XYZ_AGENT_EXT_LOG_ENV]: '1',
+          [TAIJI_AGENT_EXT_LOG_ENV]: '1',
           [PI_CODING_AGENT_DIR_ENV]: '/home/u/.pi/agent',
         },
       }),
@@ -81,7 +81,7 @@ describe('detectEnvironment 托管合取判定', () => {
   it('透传污染反例 3：仅 PI_CODING_AGENT_DIR 形态匹配（EXT_LOG 未设）→ standalone-pi，evidence 点名孤置信号', () => {
     const r = detectEnvironment(
       signals({
-        env: { [PI_CODING_AGENT_DIR_ENV]: '/Users/u/.xyz-agent/agent' },
+        env: { [PI_CODING_AGENT_DIR_ENV]: '/Users/u/.taiji/agent' },
       }),
     )
     expect(r.kind).toBe('standalone-pi')
@@ -92,13 +92,13 @@ describe('detectEnvironment 托管合取判定', () => {
     expect(joined).toContain(PI_CODING_AGENT_DIR_ENV)
   })
 
-  it('XYZ_AGENT_EXT_LOG 非 1 值（如 0 / true）不构成命中', () => {
+  it('TAIJI_AGENT_EXT_LOG 非 1 值（如 0 / true）不构成命中', () => {
     for (const value of ['0', 'true', '']) {
       const r = detectEnvironment(
         signals({
           env: {
-            [XYZ_AGENT_EXT_LOG_ENV]: value,
-            [PI_CODING_AGENT_DIR_ENV]: '/Users/u/.xyz-agent/agent',
+            [TAIJI_AGENT_EXT_LOG_ENV]: value,
+            [PI_CODING_AGENT_DIR_ENV]: '/Users/u/.taiji/agent',
           },
         }),
       )
@@ -106,12 +106,12 @@ describe('detectEnvironment 托管合取判定', () => {
     }
   })
 
-  it('形态防误报：无点前缀 xyz-agent、嵌套浅段不匹配', () => {
-    for (const dir of ['/home/u/xyz-agent/agent', '/home/u/.xyz/agent', '/.pi/agent']) {
+  it('形态防误报：无点前缀 taiji、嵌套浅段不匹配', () => {
+    for (const dir of ['/home/u/taiji/agent', '/home/u/.foo/agent', '/.pi/agent']) {
       const r = detectEnvironment(
         signals({
           env: {
-            [XYZ_AGENT_EXT_LOG_ENV]: '1',
+            [TAIJI_AGENT_EXT_LOG_ENV]: '1',
             [PI_CODING_AGENT_DIR_ENV]: dir,
           },
         }),
@@ -144,8 +144,8 @@ describe('detectEnvironment distribution（bundle 路径三态）', () => {
 
   it('仓库路径（源码与 dev staged 资源根两种）→ dev，staged 根不被误判 packaged', () => {
     for (const url of [
-      'file:///Users/u/Code/xyz-agent/extensions/universal/session-reader/src/index.ts',
-      'file:///Users/u/Code/xyz-agent/apps/electron/resources/extensions/@zhushanwen/pi-session-reader/index.mjs',
+      'file:///Users/u/Code/taiji/extensions/universal/session-reader/src/index.ts',
+      'file:///Users/u/Code/taiji/apps/electron/resources/extensions/@zhushanwen/pi-session-reader/index.mjs',
     ]) {
       const r = detectEnvironment(signals({ bundleUrl: url }))
       expect(r.distribution, `${url} 应判 dev`).toBe('dev')
@@ -160,48 +160,48 @@ describe('detectEnvironment distribution（bundle 路径三态）', () => {
 })
 
 describe('detectEnvironment dataDir 推导', () => {
-  it('托管：XYZ_AGENT_DATA_DIR 优先于 PI_CODING_AGENT_DIR 剥层', () => {
+  it('托管：TAIJI_AGENT_DATA_DIR 优先于 PI_CODING_AGENT_DIR 剥层', () => {
     const r = detectEnvironment(
       signals({
         env: {
-          [XYZ_AGENT_EXT_LOG_ENV]: '1',
-          [PI_CODING_AGENT_DIR_ENV]: '/data/.xyz-agent/pi/agent',
-          [XYZ_AGENT_DATA_DIR_ENV]: '/data/.xyz-agent',
+          [TAIJI_AGENT_EXT_LOG_ENV]: '1',
+          [PI_CODING_AGENT_DIR_ENV]: '/data/.taiji/pi/agent',
+          [TAIJI_AGENT_DATA_DIR_ENV]: '/data/.taiji',
         },
       }),
     )
-    expect(r.kind).toBe('xyz-agent')
-    expect(r.dataDir).toBe('/data/.xyz-agent')
-    expect(r.evidence.join('\n')).toContain(`来源：${XYZ_AGENT_DATA_DIR_ENV}`)
+    expect(r.kind).toBe('taiji')
+    expect(r.dataDir).toBe('/data/.taiji')
+    expect(r.evidence.join('\n')).toContain(`来源：${TAIJI_AGENT_DATA_DIR_ENV}`)
   })
 
   it('托管：无 DATA_DIR 时按布局剥层——新布局剥一层、旧布局剥两层', () => {
     const newLayout = detectEnvironment(
       signals({
         env: {
-          [XYZ_AGENT_EXT_LOG_ENV]: '1',
-          [PI_CODING_AGENT_DIR_ENV]: '/data/.xyz-agent/agent',
+          [TAIJI_AGENT_EXT_LOG_ENV]: '1',
+          [PI_CODING_AGENT_DIR_ENV]: '/data/.taiji/agent',
         },
       }),
     )
-    expect(newLayout.dataDir).toBe('/data/.xyz-agent')
+    expect(newLayout.dataDir).toBe('/data/.taiji')
 
     const oldLayout = detectEnvironment(
       signals({
         env: {
-          [XYZ_AGENT_EXT_LOG_ENV]: '1',
-          [PI_CODING_AGENT_DIR_ENV]: '/data/.xyz-agent/pi/agent',
+          [TAIJI_AGENT_EXT_LOG_ENV]: '1',
+          [PI_CODING_AGENT_DIR_ENV]: '/data/.taiji/pi/agent',
         },
       }),
     )
-    expect(oldLayout.dataDir).toBe('/data/.xyz-agent')
+    expect(oldLayout.dataDir).toBe('/data/.taiji')
   })
 
-  it('standalone：即使 XYZ_AGENT_DATA_DIR 被设置也恒 undefined', () => {
+  it('standalone：即使 TAIJI_AGENT_DATA_DIR 被设置也恒 undefined', () => {
     const r = detectEnvironment(
       signals({
         env: {
-          [XYZ_AGENT_DATA_DIR_ENV]: '/data/.xyz-agent',
+          [TAIJI_AGENT_DATA_DIR_ENV]: '/data/.taiji',
         },
       }),
     )
@@ -215,15 +215,15 @@ describe('detectEnvironment evidence', () => {
     ['全信号缺失', signals({})],
     ['托管全信号', signals({
       env: {
-        [XYZ_AGENT_EXT_LOG_ENV]: '1',
-        [PI_CODING_AGENT_DIR_ENV]: '/data/.xyz-agent/agent',
-        [XYZ_AGENT_DATA_DIR_ENV]: '/data/.xyz-agent',
+        [TAIJI_AGENT_EXT_LOG_ENV]: '1',
+        [PI_CODING_AGENT_DIR_ENV]: '/data/.taiji/agent',
+        [TAIJI_AGENT_DATA_DIR_ENV]: '/data/.taiji',
       },
       bundleUrl:
         'file:///Applications/TaiJi.app/Contents/Resources/extensions/@zhushanwen/pi-session-reader/index.mjs',
     })],
-    ['EXT_LOG 孤置', signals({ env: { [XYZ_AGENT_EXT_LOG_ENV]: '1' } })],
-    ['agentDir 孤置', signals({ env: { [PI_CODING_AGENT_DIR_ENV]: '/data/.xyz-agent/agent' } })],
+    ['EXT_LOG 孤置', signals({ env: { [TAIJI_AGENT_EXT_LOG_ENV]: '1' } })],
+    ['agentDir 孤置', signals({ env: { [PI_CODING_AGENT_DIR_ENV]: '/data/.taiji/agent' } })],
     ['bundleUrl 缺失', signals({})],
   ]
 
@@ -238,20 +238,20 @@ describe('detectEnvironment evidence', () => {
     const r = detectEnvironment(
       signals({
         env: {
-          [XYZ_AGENT_EXT_LOG_ENV]: '0',
-          [PI_CODING_AGENT_DIR_ENV]: '/data/.xyz-agent/pi/agent',
+          [TAIJI_AGENT_EXT_LOG_ENV]: '0',
+          [PI_CODING_AGENT_DIR_ENV]: '/data/.taiji/pi/agent',
         },
-        agentDir: '/data/.xyz-agent/pi/agent',
+        agentDir: '/data/.taiji/pi/agent',
       }),
     )
     const joined = r.evidence.join('\n')
     // 未命中信号：原文 + 未命中注记
-    expect(joined).toContain(`${XYZ_AGENT_EXT_LOG_ENV}='0' → 未命中`)
+    expect(joined).toContain(`${TAIJI_AGENT_EXT_LOG_ENV}='0' → 未命中`)
     // 命中信号：原文 + 匹配注记
-    expect(joined).toContain(`${PI_CODING_AGENT_DIR_ENV}='/data/.xyz-agent/pi/agent'`)
+    expect(joined).toContain(`${PI_CODING_AGENT_DIR_ENV}='/data/.taiji/pi/agent'`)
     expect(joined).toContain('形态匹配')
     // 第三条输入：agentDir 透传记录
-    expect(joined).toContain(`agentDir='/data/.xyz-agent/pi/agent'`)
+    expect(joined).toContain(`agentDir='/data/.taiji/pi/agent'`)
     // 判定结论行
     expect(joined).toContain('standalone-pi')
   })

package/src/__tests__/find.test.ts

@@ -578,7 +578,7 @@ describe('findSessions', () => {
 describe('u11 标题元数据（metadataProvider 注入，§6.6）', () => {
   let root: string
   let agentDir: string
-  /** 平铺 main 根（xyz-agent 形态：session 直在 sessions/ 下，[default] 根无子目录） */
+  /** 平铺 main 根（taiji 形态：session 直在 sessions/ 下，[default] 根无子目录） */
   let flatMain: string
   /** legacy 根（dirname(agentDir)/sessions） */
   let legacyDir: string

package/src/__tests__/index.test.ts

@@ -169,7 +169,7 @@ describe('sessionReaderExtension - execute 信号包采集（U3：ctx 全形态
   })
 
   it('u11：execute 构造 metadataProvider 接 SessionManager.listAll——keyword 标题命中端到端', async () => {
-    // fixture：平铺 main 根（xyz-agent 形态），session 首消息不含 query，标题经 mock listAll 注入
+    // fixture：平铺 main 根（taiji 形态），session 首消息不含 query，标题经 mock listAll 注入
     const tmp = await mkdtemp(join(tmpdir(), 'index-u11-'))
     try {
       const agentDir = join(tmp, 'agent')

package/src/__tests__/real-data.ts

@@ -1,5 +1,6 @@
 import { existsSync } from 'node:fs'
 import { execSync } from 'node:child_process'
+import { homedir } from 'node:os'
 import { join } from 'node:path'
 
 /**
@@ -13,8 +14,8 @@ import { join } from 'node:path'
  * 本文件无 .test.ts 后缀，vitest include 只收集 `src/__tests__/` 下以 .test.ts 结尾的文件，不收集本文件。
  */
 
-/** 真实 pi agent 目录（本机），用于集成测试。 */
-export const REAL_AGENT_DIR = '/Users/zhushanwen/.pi/agent'
+/** 真实 pi agent 目录（pi 官方家目录布局，随宿主 homedir 推导），用于集成测试。 */
+export const REAL_AGENT_DIR = join(homedir(), '.pi', 'agent')
 
 /**
  * 全量扫描类真实数据用例的统一超时标定（90s）。
@@ -31,13 +32,25 @@ export const E6 = '019e6c96-0a0c-74b8-a73f-d1854d88e2a7'
 /** 真实 fork 家族根（fork 子代 019fe632，隔代 subagent 019fe635 挂在 019fe632 下）。 */
 export const FAM = '019fe620-8ae1-78a7-b76a-43a1ba4cc3c7'
 
-/** E6 的完整文件路径（parser/turns/render 直接 parseSessionFile 用）。 */
-export const REAL_SESSION = join(
-  REAL_AGENT_DIR,
-  'sessions',
-  '--Users-zhushanwen-Code-xyz-agent-workspace-feat-plugin-arch-3--',
-  `2026-05-28T03-17-12-844Z_${E6}.jsonl`,
-)
+/**
+ * E6 的完整文件路径（parser/turns/render 直接 parseSessionFile 用）。
+ * 按 sid 运行时定位而非硬编码宿主 workspace 目录名：真实文件挂在哪个 slug 目录随采集机器而异，
+ * 硬编码会绑死本机路径形态；定位不到时回落相对布局，由下方 HAS_REAL_SESSION 守卫 skip。
+ */
+export const REAL_SESSION = (() => {
+  const fallback = join(REAL_AGENT_DIR, 'sessions', `2026-05-28T03-17-12-844Z_${E6}.jsonl`)
+  if (!existsSync(REAL_AGENT_DIR)) return fallback
+  try {
+    return (
+      execSync(
+        `find ${REAL_AGENT_DIR}/sessions -name '*${E6}*' -name '*.jsonl' ! -name '*.finalized' 2>/dev/null | head -1`,
+        { encoding: 'utf8' },
+      ).trim() || fallback
+    )
+  } catch {
+    return fallback
+  }
+})()
 
 /** 同步探测真实 session 文件是否存在（不存在则 skip，避免在无该数据的机器上硬失败）。 */
 export function hasRealSession(sid: string): boolean {

package/src/__tests__/roots.test.ts

@@ -214,7 +214,7 @@ const HOST_CASES: HostCase[] = [
     },
   },
   {
-    name: 'xyz-agent：live=根本身（RPC 覆盖态），default 去重，legacy 残留与 subagent 独立列出',
+    name: 'taiji：live=根本身（RPC 覆盖态），default 去重，legacy 残留与 subagent 独立列出',
     async build(tmp) {
       const dataDir = join(tmp, 'data')
       const agentDir = join(dataDir, 'agent')

package/src/__tests__/subagents.test.ts

@@ -10,16 +10,13 @@ import {
   extractSessionIdFromFilename,
   type RecordManifest,
 } from '../discovery/subagents.js'
-import { REAL_DATA_TIMEOUT_MS } from './real-data.js'
+import { REAL_AGENT_DIR, REAL_DATA_TIMEOUT_MS } from './real-data.js'
 
 // ---- fixture 常量（uuid 特征，满足 extractSessionIdFromFilename + 互不为子串）----
 const ROOT = '0aaaaaaa-bbbb-7ccc-dddd-000000000001'
 const FORK = '0aaaaaaa-bbbb-7ccc-dddd-000000000002'
 const SUB_REAL = '0aaaaaaa-bbbb-7ccc-dddd-000000000003'
 
-/** 真实 pi agent 目录（本机），用于集成测试。 */
-const REAL_AGENT_DIR = '/Users/zhushanwen/.pi/agent'
-
 // 同步探测真实 session 是否存在（不存在则 skip，避免在无该数据的机器上硬失败）
 function hasRealSession(sid: string): boolean {
   try {

package/src/__tests__/tool-handler.test.ts

@@ -30,11 +30,20 @@ import {
   hasRealSession,
 } from './real-data.js'
 
+// fs-guard：TC6 的「~ 前缀展开」语义需要 homedir，但真实 homedir 根在白名单外（禁止向用户
+// 主目录散落文件）。vi.mock 把 homedir 指到用例内 mkdtemp 的 tmp；fakeHome 未注入时回落真实值，
+// real-data.ts 模块初始化时推导 REAL_AGENT_DIR 不受影响（模块初始化先于任何用例执行）。
+const homeState = vi.hoisted(() => ({ fakeHome: undefined as string | undefined }))
+vi.mock('node:os', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('node:os')>()
+  return { ...actual, homedir: () => homeState.fakeHome ?? actual.homedir() }
+})
+
 /**
  * M3 tool-handler 集成测试。
  *
  * 测试框架 vitest（禁止 node:test/tsx）。直接调 handleSessionRead（纯逻辑，agentDir 注入），
- * 传真实 `/Users/zhushanwen/.pi/agent` 作 agentDir——用本机真实历史 session 数据，无需 mock。
+ * 传真实 `~/.pi/agent` 作 agentDir——用本机真实历史 session 数据，无需 mock。
  *
  * 覆盖全 11 action 主路径 + F1(find 零匹配)/F4(turn 越界)/F5(缺参)/resolveSessionId 片段等价，
  * 以及 u8 doctor / u9 归一化 / u10 find 分组 / u11 metadataProvider 缓存 / u12 跨会话检索（各见对应 describe）。
@@ -95,14 +104,21 @@ describe.skipIf(!HAS_REAL)('handleSessionRead', () => {
   })
 
   it('6. export outline materializes a .md file', async () => {
-    const r = await handleSessionRead(
-      { action: 'export', session: E6, format: 'outline' },
-      { agentDir: REAL },
-    )
-    const d = r.details as { path: string; sizeBytes: number }
-    expect(d.path).toMatch(/\.md$/)
-    expect(existsSync(d.path)).toBe(true)
-    expect(d.sizeBytes).toBeGreaterThan(0)
+    // fs-guard：export 写目标 = <agentDir>/tmp/，agentDir 传 REAL 会 mkdir 真实 ~/.pi/agent/tmp
+    // （白名单外）。读侧经 liveSessionDir=[live] 根仍扫真实数据，写侧落 mkdtemp tmp 自建自删。
+    const dir = await mkdtemp(join(tmpdir(), 'tool-handler-export-'))
+    try {
+      const r = await handleSessionRead(
+        { action: 'export', session: E6, format: 'outline' },
+        { agentDir: dir, liveSessionDir: join(REAL, 'sessions') },
+      )
+      const d = r.details as { path: string; sizeBytes: number }
+      expect(d.path).toMatch(/\.md$/)
+      expect(existsSync(d.path)).toBe(true)
+      expect(d.sizeBytes).toBeGreaterThan(0)
+    } finally {
+      await rm(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 })
+    }
   })
 
   // w1 合并 subagent 候选后，本机 subagent task 文本（含本用例 query 字符串本身，因当前
@@ -643,7 +659,7 @@ describe('extract commits 双路径（fixture：git-cmd 主路径 + commit-conte
         message: {
           role: 'assistant',
           content: [
-            { type: 'toolCall', id: 'tc-read-1', name: 'read', arguments: { path: '/tmp/log.txt' } },
+            { type: 'toolCall', id: 'tc-read-1', name: 'read', arguments: { path: join(tmpdir(), 'log.txt') } },
           ],
         },
       }),
@@ -667,7 +683,7 @@ describe('extract commits 双路径（fixture：git-cmd 主路径 + commit-conte
         message: {
           role: 'assistant',
           content: [
-            { type: 'toolCall', id: 'tc-read-2', name: 'read', arguments: { path: '/tmp/out.txt' } },
+            { type: 'toolCall', id: 'tc-read-2', name: 'read', arguments: { path: join(tmpdir(), 'out.txt') } },
           ],
         },
       }),
@@ -724,7 +740,7 @@ describe('extract commits 双路径（fixture：git-cmd 主路径 + commit-conte
         message: {
           role: 'assistant',
           content: [
-            { type: 'toolCall', id: 'tc-read-1', name: 'read', arguments: { path: '/tmp/deploy.txt' } },
+            { type: 'toolCall', id: 'tc-read-1', name: 'read', arguments: { path: join(tmpdir(), 'deploy.txt') } },
           ],
         },
       }),
@@ -933,24 +949,33 @@ describe('resolveSessionId ① 绝对路径形态（w2 TC2-TC6）', () => {
   })
 
   it('TC6: ~ 前缀展开到 homedir（文件实际在 homedir 下）', async () => {
-    const home = homedir()
-    const tmpUnderHome = await mkdtemp(join(home, '.sr-w2-test-'))
+    // fs-guard：真实 homedir 根在白名单外（禁止在用户主目录根散落 .sr-w2-test-*）——
+    // homedir 经文件头 vi.mock 指到 mkdtemp tmp（白名单内），「~ 前缀展开」断言语义不变
+    const fakeHome = await mkdtemp(join(tmpdir(), 'tool-handler-tc6-home-'))
+    homeState.fakeHome = fakeHome
     try {
-      const fileId = '019e6c96-dddd-eeee-ffff-0000000006c1'
-      const sessionFile = join(tmpUnderHome, 's.jsonl')
-      await writeFile(
-        sessionFile,
-        JSON.stringify({ type: 'session', id: fileId, cwd: '/demo' }) + '\n',
-      )
-      // ~/开头的相对 homedir 路径
-      const tildePath = '~/' + sessionFile.slice(home.length + 1)
-      const r = await handleSessionRead(
-        { action: 'export', session: tildePath, format: 'outline' },
-        { agentDir: dir },
-      )
-      expect((r.details as { path: string }).path).toContain(fileId)
+      const home = homedir()
+      const tmpUnderHome = await mkdtemp(join(home, '.sr-w2-test-'))
+      try {
+        const fileId = '019e6c96-dddd-eeee-ffff-0000000006c1'
+        const sessionFile = join(tmpUnderHome, 's.jsonl')
+        await writeFile(
+          sessionFile,
+          JSON.stringify({ type: 'session', id: fileId, cwd: '/demo' }) + '\n',
+        )
+        // ~/开头的相对 homedir 路径
+        const tildePath = '~/' + sessionFile.slice(home.length + 1)
+        const r = await handleSessionRead(
+          { action: 'export', session: tildePath, format: 'outline' },
+          { agentDir: dir },
+        )
+        expect((r.details as { path: string }).path).toContain(fileId)
+      } finally {
+        await rm(tmpUnderHome, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 })
+      }
     } finally {
-      await rm(tmpUnderHome, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 })
+      homeState.fakeHome = undefined
+      await rm(fakeHome, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 })
     }
   })
 })
@@ -1801,8 +1826,8 @@ describe('doctor action（u8：环境判定 + 根表 + 告警 + 残留 glob）',
   }
 
   /**
-   * xyz-agent 形态四根 fixture：dataDir 目录名带 .xyz-agent 前缀（detectEnvironment 的
-   * PI_CODING_AGENT_DIR 形态判据 `<*>/.xyz-agent*\/agent` 可命中，托管判定走正态）。
+   * taiji 形态四根 fixture：dataDir 目录名带 .taiji 前缀（detectEnvironment 的
+   * PI_CODING_AGENT_DIR 形态判据 `<*>/.taiji*\/agent` 可命中，托管判定走正态）。
    * live=agent/sessions 与 default 同字面路径（default 去重）、legacy 独立非空、subagent 独立。
    */
   async function buildFourRootFixture(): Promise<{
@@ -1810,7 +1835,7 @@ describe('doctor action（u8：环境判定 + 根表 + 告警 + 残留 glob）',
     agentDir: string
     signals: SessionReadSignals
   }> {
-    const dataDir = join(tmp, '.xyz-agent-fixture')
+    const dataDir = join(tmp, '.taiji-fixture')
     const agentDir = join(dataDir, 'agent')
     await writeJsonl(join(agentDir, 'sessions', SLUG, 'a.jsonl'), 'aaaaaaaa')
     await writeJsonl(join(agentDir, 'sessions', SLUG, 'b.jsonl'), 'bbbbbbbb')
@@ -1823,9 +1848,9 @@ describe('doctor action（u8：环境判定 + 根表 + 告警 + 残留 glob）',
         agentDir,
         liveSessionDir: join(agentDir, 'sessions'),
         env: {
-          XYZ_AGENT_EXT_LOG: '1',
+          TAIJI_AGENT_EXT_LOG: '1',
           PI_CODING_AGENT_DIR: agentDir,
-          XYZ_AGENT_DATA_DIR: dataDir,
+          TAIJI_AGENT_DATA_DIR: dataDir,
         },
       },
     }
@@ -1843,8 +1868,8 @@ describe('doctor action（u8：环境判定 + 根表 + 告警 + 残留 glob）',
     const r = await handleSessionRead({ action: 'doctor' }, signals)
     const text = r.content[0].text
 
-    // 环境判定行：双信号合取 → xyz-agent（托管）+ 数据目录 + evidence 正态
-    expect(text).toContain('环境判定：xyz-agent（托管）')
+    // 环境判定行：双信号合取 → taiji（托管）+ 数据目录 + evidence 正态
+    expect(text).toContain('环境判定：taiji（托管）')
     expect(text).toContain(`数据目录：${dataDir}`)
     expect(text).toContain('依据：')
     expect(text).toContain(`PI_CODING_AGENT_DIR='${agentDir}' → 形态匹配`)
@@ -1887,7 +1912,7 @@ describe('doctor action（u8：环境判定 + 根表 + 告警 + 残留 glob）',
     const { signals } = await buildFourRootFixture()
     const positive = await handleSessionRead({ action: 'doctor' }, signals)
     expect(positive.content[0].text).toContain(
-      `告警：[legacy] 根 ${join(tmp, '.xyz-agent-fixture', 'sessions')} 非空（1 文件）`,
+      `告警：[legacy] 根 ${join(tmp, '.taiji-fixture', 'sessions')} 非空（1 文件）`,
     )
 
     // 反态：legacy 目录不存在
@@ -1908,43 +1933,6 @@ describe('doctor action（u8：环境判定 + 根表 + 告警 + 残留 glob）',
     expect(deduped.content[0].text).toContain('已去重')
   })
 
-  it('独立 glob 残留探测：pi/ 含 agent|sessions 形态列出 + 迁移指引；pi.backup-v2-* 备份列出；基点 = dirname(agentDir)', async () => {
-    const dataDir = join(tmp, 'data')
-    const agentDir = join(dataDir, 'agent')
-    await writeJsonl(join(agentDir, 'sessions', SLUG, 'a.jsonl'))
-    // 未迁移旧布局 pi/（含 agent/ 形态）
-    await mkdir(join(dataDir, 'pi', 'agent'), { recursive: true })
-    await writeJsonl(join(dataDir, 'pi', 'agent', 'sessions', 'old.jsonl'), 'old-id')
-    // 迁移备份（含 sessions/ 形态——备份即原 pi/ 改名）
-    const backup = join(dataDir, 'pi.backup-v2-1725900000000')
-    await mkdir(join(backup, 'sessions'), { recursive: true })
-    await writeJsonl(join(backup, 'sessions', 'bak.jsonl'), 'bak-id')
-
-    const r = await handleSessionRead({ action: 'doctor' }, { agentDir })
-    const text = r.content[0].text
-    expect(text).toContain(`旧布局残留探测（基点 ${dataDir}）`)
-    expect(text).toContain(`  - ${join(dataDir, 'pi')}（未迁移旧布局 pi/）`)
-    expect(text).toContain(`  - ${backup}（迁移备份 pi.backup-v2-*）`)
-    // 同一迁移指引（§6.11：doctor 与 u14b 启动探测同指引）
-    expect(text).toContain('👉 关闭应用后运行 scripts/migrate-pi-layout-v2.mjs 完成迁移。')
-
-    const d = r.details as DoctorDetails
-    expect(d.globBase).toBe(dataDir)
-    expect(d.leftovers.map((l) => l.kind).sort()).toEqual(['backup', 'unmigrated'])
-  })
-
-  it('残留探测反态：pi/ 空壳（无 agent|sessions 子目录）不报——防纯 pi 宿主 ~/.pi/pi/ 误报（§6.11 v9.1）', async () => {
-    const dataDir = join(tmp, 'data')
-    const agentDir = join(dataDir, 'agent')
-    await writeJsonl(join(agentDir, 'sessions', SLUG, 'a.jsonl'))
-    // 纯 pi 宿主下任意来源的 pi/ 目录：只有无关子目录，无 agent/ 与 sessions/ 形态
-    await mkdir(join(dataDir, 'pi', 'extensions'), { recursive: true })
-
-    const r = await handleSessionRead({ action: 'doctor' }, { agentDir })
-    expect(r.content[0].text).not.toContain('旧布局残留')
-    expect((r.details as DoctorDetails).leftovers).toEqual([])
-  })
-
   it('subagent 根默认不扫（只列路径与可扫性）；includeSubagents:true 才扫出文件数（§6.3）', async () => {
     const { agentDir, signals } = await buildFourRootFixture()
 
@@ -1995,7 +1983,7 @@ describe('doctor action（u8：环境判定 + 根表 + 告警 + 残留 glob）',
     const r = await handleSessionRead({ action: 'doctor' }, { agentDir })
     const text = r.content[0].text
     expect(text).toContain('环境判定：standalone-pi · 发行形态：未知（不猜）')
-    expect(text).toContain('XYZ_AGENT_EXT_LOG=<未设置> → 未命中')
+    expect(text).toContain('TAIJI_AGENT_EXT_LOG=<未设置> → 未命中')
     expect(text).toContain('会话根（按优先级）')
     expect(text).toContain('[default]')
     expect(text).toContain(
@@ -2003,13 +1991,12 @@ describe('doctor action（u8：环境判定 + 根表 + 告警 + 残留 glob）',
     )
   })
 
-  it('空 agentDir 防御：无根表、诊断「无候选根」，残留探测不触发（不扫 cwd 相对路径）', async () => {
+  it('空 agentDir 防御：无根表、诊断「无候选根」（不扫 cwd 相对路径）', async () => {
     const r = await handleSessionRead({ action: 'doctor' }, { agentDir: '' })
     const text = r.content[0].text
     expect(text).toContain('诊断：无候选根')
     expect(text).not.toContain('[default]')
     expect((r.details as DoctorDetails).roots).toEqual([])
-    expect((r.details as DoctorDetails).leftovers).toEqual([])
   })
 })
 
@@ -2641,7 +2628,7 @@ describe('E1 find 单次根解析（探针 P1：resolveSessionRoots 恰 1 次）
 // ============================================================
 describe('u11 metadataProvider 注入 + TTL 缓存（fixture，§6.6）', () => {
   let tmp: string
-  /** 平铺 main 根（xyz-agent 形态），同时作 liveSessionDir（与 [default] 根同字面路径） */
+  /** 平铺 main 根（taiji 形态），同时作 liveSessionDir（与 [default] 根同字面路径） */
   let flatMain: string
 
   async function writeSession(

package/src/core/render.ts

@@ -1,4 +1,5 @@
 import type { Entry } from './parser.js'
+import { BYTES_PER_KB } from './units.js'
 import { extractToolCalls, formatToolCallSummary, type ToolCallInfo } from './toolcall.js'
 import type { Turn } from './turns.js'
 import type { TreeView } from './tree.js'
@@ -7,8 +8,6 @@ import type { TreeView } from './tree.js'
 // 模块常量（渲染口径：截断宽度 / 换算基数 / 降级档位）
 // ---------------------------------------------------------------------------
 
-/** bytes→KB 换算基数（omitted 字节 / read 结果规模的 KB 显示）。 */
-const BYTES_PER_KB = 1024
 /** userBrief 截断字符数（TurnBrief.userBrief 文档口径「截 60 字符」）。 */
 const USER_BRIEF_MAX_CHARS = 60
 /** assistantBrief 截断字符数（TurnBrief.assistantBrief 文档口径「截 80 字符」）。 */

package/src/core/toolcall.ts

@@ -9,6 +9,7 @@
  *   parser.ts 已 additive 透出这两个字段，O2/O3 据此精确关联取参数。
  */
 import type { Entry } from './parser.js'
+import { BYTES_PER_KB } from './units.js'
 
 // ---------------------------------------------------------------------------
 // 模块常量（参数摘要的截断宽度 / 换算基数）
@@ -20,8 +21,6 @@ const BASH_CMD_MAX_CHARS = 60
 const SUBAGENT_TASK_MAX_CHARS = 40
 /** 未知工具 arguments JSON 摘要截断字符数。 */
 const ARGS_JSON_MAX_CHARS = 50
-/** bytes→KB 换算基数（write content 的 KB 显示）。 */
-const BYTES_PER_KB = 1024
 
 /** 单次工具调用信息（从 assistant content 的 toolCall block 提取）。 */
 export interface ToolCallInfo {

package/src/core/units.ts

@@ -0,0 +1,14 @@
+/**
+ * 字节量纲换算基数（本包内 KB/MB 换算的唯一来源）。
+ *
+ * 本包是独立 npm 发布的 pi extension（仅依赖 pi-ext-guards），不 import taiji 内部
+ * workspace 包（@taiji/shared 的 BYTES_PER_MB 单点不含本包）——量纲基数本地定义，
+ * 数值对齐由注释锚定（1MB = 1024×1024）。三个消费域（render 的 omitted 标记 /
+ * toolcall 的 write 摘要 / search-across 的预算与人性化格式化）共用本单点，
+ * 避免同值常量在本包内多份分裂。
+ */
+
+/** bytes→KB 换算基数（omitted 字节 / read 结果规模 / write content 的 KB 显示）。 */
+export const BYTES_PER_KB = 1024
+/** bytes→MB 换算基数（跨会话检索预算与人性化格式化）。 */
+export const BYTES_PER_MB = BYTES_PER_KB * BYTES_PER_KB

package/src/discovery/env.ts

@@ -12,35 +12,35 @@ import { dirname } from 'node:path'
  * 齐备），不 import roots.ts 的信号类型，避免并行单元耦合；接线层分别组装两种信号包。
  *
  * 信号可靠性依据（design §4.4 活体实测表，非推断）：
- * - XYZ_AGENT_EXT_LOG 单独使用可靠性「中」——runtime 无条件注入，但
- *   ENV_WHITELIST_PREFIXES 含裸 `XYZ_` 前缀，用户 shell 里的同名变量会透传进任何进程；
+ * - TAIJI_AGENT_EXT_LOG 单独使用可靠性「中」——runtime 无条件注入，但
+ *   ENV_WHITELIST_PREFIXES 含裸 `TAIJI_` 前缀，用户 shell 里的同名变量会透传进任何进程；
  * - PI_CODING_AGENT_DIR 单独使用可靠性「中」——pi 原生变量，裸 pi 用户也可能自设，
- *   但其值形态是 xyz-agent 专属约定：`<*>/.xyz-agent*` 目录后接 `/agent`；
- * - XYZ_AGENT_PACKAGED **不可用**——在 SPAWN_ENV_OUTBOUND_DENY_LIST 被剥除
+ *   但其值形态是 taiji 专属约定：`<*>/.taiji*` 目录后接 `/agent`；
+ * - TAIJI_AGENT_PACKAGED **不可用**——在 SPAWN_ENV_OUTBOUND_DENY_LIST 被剥除
  *  （§4.4 在案结论），故不引入该信号，防后人重蹈。
  * 因此托管判定必须是双信号合取：任一信号单独成立只判 standalone-pi，
  * 透传/自设污染提示写入 evidence。
  */
 
-/** xyz-agent 托管信号 1：runtime 无条件注入的 extension 日志开关（恒 '1'） */
-export const XYZ_AGENT_EXT_LOG_ENV = 'XYZ_AGENT_EXT_LOG'
-/** xyz-agent 托管信号 2：pi agentDir 注入变量；其**值形态**是 xyz-agent 专属约定 */
+/** taiji 托管信号 1：runtime 无条件注入的 extension 日志开关（恒 '1'） */
+export const TAIJI_AGENT_EXT_LOG_ENV = 'TAIJI_AGENT_EXT_LOG'
+/** taiji 托管信号 2：pi agentDir 注入变量；其**值形态**是 taiji 专属约定 */
 export const PI_CODING_AGENT_DIR_ENV = 'PI_CODING_AGENT_DIR'
 /** 数据目录推导首选：runtime getDataDir() 的权威注入值 */
-export const XYZ_AGENT_DATA_DIR_ENV = 'XYZ_AGENT_DATA_DIR'
+export const TAIJI_AGENT_DATA_DIR_ENV = 'TAIJI_AGENT_DATA_DIR'
 
 /** 托管信号 1 的唯一合法值（注释「托管语义恒为 '1'」） */
 const EXT_LOG_MANAGED_VALUE = '1'
 
-// xyz-agent agentDir 值形态（§6.2 双形态兼容——迁移窗口期 B 前后两种布局并存）：
-// - B 后新布局：`<*>/.xyz-agent*` 目录后接 `/agent`（一层）
-// - B 前旧布局：`<*>/.xyz-agent*` 目录后接 `/pi/agent`（两层）
-// `.xyz-agent*` = 以 `.xyz-agent` 开头的目录段（prod `.xyz-agent` / dev `.xyz-agent-dev`）。
-// 三条正则都要求匹配到路径末尾（`$`），调用前输入先经 normalizeXyzPath 剥尾斜杠。
+// taiji agentDir 值形态（§6.2 双形态兼容——迁移窗口期 B 前后两种布局并存）：
+// - B 后新布局：`<*>/.taiji*` 目录后接 `/agent`（一层）
+// - B 前旧布局：`<*>/.taiji*` 目录后接 `/pi/agent`（两层）
+// `.taiji*` = 以 `.taiji` 开头的目录段（prod `.taiji` / dev `.taiji-dev`）。
+// 三条正则都要求匹配到路径末尾（`$`），调用前输入先经 normalizeTaijiPath 剥尾斜杠。
 // （用行注释：形态文本含星号斜杠序列，写进块注释会提前终止注释。）
-const AGENT_DIR_SHAPE_ANY = /(^|\/)\.xyz-agent[^/]*\/(pi\/)?agent$/
-const AGENT_DIR_SHAPE_OLD = /(^|\/)\.xyz-agent[^/]*\/pi\/agent$/
-const AGENT_DIR_SHAPE_NEW = /(^|\/)\.xyz-agent[^/]*\/agent$/
+const AGENT_DIR_SHAPE_ANY = /(^|\/)\.taiji[^/]*\/(pi\/)?agent$/
+const AGENT_DIR_SHAPE_OLD = /(^|\/)\.taiji[^/]*\/pi\/agent$/
+const AGENT_DIR_SHAPE_NEW = /(^|\/)\.taiji[^/]*\/agent$/
 
 /**
  * 打包形态判据（§6.2：bundle 路径判发行形态；无法判定 → null 不猜）。
@@ -56,7 +56,7 @@ const MACOS_PACKAGED_PATTERN = /\.app\/Contents\/Resources\/extensions\//
 const REPO_STAGED_PATTERN = /(^|\/)apps\/electron\/resources\/extensions\//
 const WIN_LINUX_PACKAGED_PATTERN = /(^|\/)resources\/extensions\//
 
-export type EnvironmentKind = 'xyz-agent' | 'standalone-pi'
+export type EnvironmentKind = 'taiji' | 'standalone-pi'
 export type Distribution = 'packaged' | 'dev' | null
 
 export interface EnvironmentSignals {
@@ -71,19 +71,19 @@ export interface EnvironmentSignals {
 export interface DetectedEnvironment {
   kind: EnvironmentKind
   distribution: Distribution
-  /** 托管时的 xyz-agent 数据目录；standalone-pi 恒 undefined */
+  /** 托管时的 taiji 数据目录；standalone-pi 恒 undefined */
   dataDir?: string
   /** 每条命中/未命中信号的原文 + 判定依据，恒非空（§6.2：判定可被证据推翻，非黑盒断言） */
   evidence: string[]
 }
 
 /** 形态匹配前的归一化：Windows 分隔符 → `/`，剥尾部斜杠 */
-function normalizeXyzPath(p: string): string {
+function normalizeTaijiPath(p: string): string {
   return p.replace(/\\/g, '/').replace(/\/+$/, '')
 }
 
-function matchesXyzAgentAgentDir(value: string): boolean {
-  return AGENT_DIR_SHAPE_ANY.test(normalizeXyzPath(value))
+function matchesTaijiAgentDir(value: string): boolean {
+  return AGENT_DIR_SHAPE_ANY.test(normalizeTaijiPath(value))
 }
 
 /** distribution 判定，判定行写入 evidence */
@@ -110,19 +110,19 @@ function detectDistribution(bundleUrl: string | undefined, evidence: string[]):
 }
 
 /**
- * 托管时的数据目录推导：XYZ_AGENT_DATA_DIR 优先（runtime 注入的权威值，与
+ * 托管时的数据目录推导：TAIJI_AGENT_DATA_DIR 优先（runtime 注入的权威值，与
  * getDataDir() 同源），缺失时按布局形态从 PI_CODING_AGENT_DIR 剥层。来源写入 evidence。
  */
 function deriveDataDir(env: Record<string, string | undefined>, evidence: string[]): string | undefined {
-  const dataDirEnv = env[XYZ_AGENT_DATA_DIR_ENV]
+  const dataDirEnv = env[TAIJI_AGENT_DATA_DIR_ENV]
   if (dataDirEnv) {
-    evidence.push(`数据目录：'${dataDirEnv}'（来源：${XYZ_AGENT_DATA_DIR_ENV}）`)
+    evidence.push(`数据目录：'${dataDirEnv}'（来源：${TAIJI_AGENT_DATA_DIR_ENV}）`)
     return dataDirEnv
   }
   const agentDirEnv = env[PI_CODING_AGENT_DIR_ENV]
   if (agentDirEnv) {
-    const normalized = normalizeXyzPath(agentDirEnv)
-    // 旧形态更长，先判：`.xyz-agent*/pi/agent` → 剥 pi/agent 两层
+    const normalized = normalizeTaijiPath(agentDirEnv)
+    // 旧形态更长，先判：`.taiji*/pi/agent` → 剥 pi/agent 两层
     if (AGENT_DIR_SHAPE_OLD.test(normalized)) {
       const dataDir = dirname(dirname(normalized))
       evidence.push(`数据目录：'${dataDir}'（来源：${PI_CODING_AGENT_DIR_ENV} 剥 pi/agent 两层，B 前旧布局）`)
@@ -134,7 +134,7 @@ function deriveDataDir(env: Record<string, string | undefined>, evidence: string
       return dataDir
     }
   }
-  evidence.push(`数据目录：无法推导（${XYZ_AGENT_DATA_DIR_ENV} 未设置且 ${PI_CODING_AGENT_DIR_ENV} 形态不可剥层）`)
+  evidence.push(`数据目录：无法推导（${TAIJI_AGENT_DATA_DIR_ENV} 未设置且 ${PI_CODING_AGENT_DIR_ENV} 形态不可剥层）`)
   return undefined
 }
 
@@ -146,16 +146,16 @@ function pushExtLogEvidence(
 ): void {
   evidence.push(
     extLogHit
-      ? `${XYZ_AGENT_EXT_LOG_ENV}='${extLog}' → 命中`
-      : `${XYZ_AGENT_EXT_LOG_ENV}=${extLog === undefined ? '<未设置>' : `'${extLog}'`} → 未命中（要求值为 '1'）`,
+      ? `${TAIJI_AGENT_EXT_LOG_ENV}='${extLog}' → 命中`
+      : `${TAIJI_AGENT_EXT_LOG_ENV}=${extLog === undefined ? '<未设置>' : `'${extLog}'`} → 未命中（要求值为 '1'）`,
   )
 }
 
-/** 信号 2 的形态标注（§6.2 双形态兼容：B 前旧布局 / B 后新布局 / 非 xyz-agent 形态）。 */
+/** 信号 2 的形态标注（§6.2 双形态兼容：B 前旧布局 / B 后新布局 / 非 taiji 形态）。 */
 function describeAgentDirShape(normalized: string): string {
   if (AGENT_DIR_SHAPE_OLD.test(normalized)) return 'B 前旧布局 pi/agent'
   if (AGENT_DIR_SHAPE_NEW.test(normalized)) return 'B 后新布局 agent'
-  return '非 xyz-agent 形态'
+  return '非 taiji 形态'
 }
 
 /** 信号 2 evidence 行（未设置 → 未命中；有值 → 形态匹配与否 + 形态标注）。 */
@@ -168,19 +168,19 @@ function pushAgentDirEvidence(
     evidence.push(`${PI_CODING_AGENT_DIR_ENV}=<未设置> → 未命中`)
     return
   }
-  const shape = describeAgentDirShape(normalizeXyzPath(agentDirEnv))
+  const shape = describeAgentDirShape(normalizeTaijiPath(agentDirEnv))
   evidence.push(
-    `${PI_CODING_AGENT_DIR_ENV}='${agentDirEnv}' → ${agentDirHit ? `形态匹配（${shape}）` : `形态不匹配（${shape}，要求 <*>/.xyz-agent*/agent）`}`,
+    `${PI_CODING_AGENT_DIR_ENV}='${agentDirEnv}' → ${agentDirHit ? `形态匹配（${shape}）` : `形态不匹配（${shape}，要求 <*>/.taiji*/agent）`}`,
   )
 }
 
 /** 判定行：托管（双信号合取成立）/ standalone-pi（孤置信号点名，提示透传/自设污染）。 */
 function judgedEvidenceLine(extLogHit: boolean, agentDirHit: boolean): string {
   if (extLogHit && agentDirHit) {
-    return `判定：xyz-agent 托管（${XYZ_AGENT_EXT_LOG_ENV}='1' 且 ${PI_CODING_AGENT_DIR_ENV} 形态匹配，双信号合取成立）`
+    return `判定：taiji 托管（${TAIJI_AGENT_EXT_LOG_ENV}='1' 且 ${PI_CODING_AGENT_DIR_ENV} 形态匹配，双信号合取成立）`
   }
   const orphaned: string[] = []
-  if (extLogHit) orphaned.push(XYZ_AGENT_EXT_LOG_ENV)
+  if (extLogHit) orphaned.push(TAIJI_AGENT_EXT_LOG_ENV)
   if (agentDirHit) orphaned.push(PI_CODING_AGENT_DIR_ENV)
   const orphanNote =
     orphaned.length > 0
@@ -192,8 +192,8 @@ function judgedEvidenceLine(extLogHit: boolean, agentDirHit: boolean): string {
 /**
  * 判定当前宿主环境（design §6.2）。
  *
- * 托管（xyz-agent）= 合取：`XYZ_AGENT_EXT_LOG === '1'` **且** `PI_CODING_AGENT_DIR`
- * 值匹配 xyz-agent 形态（`<*>/.xyz-agent*` 目录后接 `/agent`；B 前旧布局接
+ * 托管（taiji）= 合取：`TAIJI_AGENT_EXT_LOG === '1'` **且** `PI_CODING_AGENT_DIR`
+ * 值匹配 taiji 形态（`<*>/.taiji*` 目录后接 `/agent`；B 前旧布局接
  * `/pi/agent` 同样接受）。任一信号单独成立 → standalone-pi，evidence 点名孤置
  * 信号（透传污染提示）。
  * evidence 恒非空：每条命中/未命中信号的原文都在列，让 agent 能核对并推翻判定。
@@ -205,19 +205,19 @@ export function detectEnvironment(signals: EnvironmentSignals): DetectedEnvironm
   const evidence: string[] = []
   const { env } = signals
 
-  // 信号 1：XYZ_AGENT_EXT_LOG === '1'
-  const extLog = env[XYZ_AGENT_EXT_LOG_ENV]
+  // 信号 1：TAIJI_AGENT_EXT_LOG === '1'
+  const extLog = env[TAIJI_AGENT_EXT_LOG_ENV]
   const extLogHit = extLog === EXT_LOG_MANAGED_VALUE
   pushExtLogEvidence(evidence, extLog, extLogHit)
 
   // 信号 2：PI_CODING_AGENT_DIR 值形态
   const agentDirEnv = env[PI_CODING_AGENT_DIR_ENV]
-  const agentDirHit = agentDirEnv !== undefined && matchesXyzAgentAgentDir(agentDirEnv)
+  const agentDirHit = agentDirEnv !== undefined && matchesTaijiAgentDir(agentDirEnv)
   pushAgentDirEvidence(evidence, agentDirEnv, agentDirHit)
   evidence.push(`agentDir='${signals.agentDir}' → pi getAgentDir() 透传记录`)
 
   const managed = extLogHit && agentDirHit
-  const kind: EnvironmentKind = managed ? 'xyz-agent' : 'standalone-pi'
+  const kind: EnvironmentKind = managed ? 'taiji' : 'standalone-pi'
   evidence.push(judgedEvidenceLine(extLogHit, agentDirHit))
 
   const distribution = detectDistribution(signals.bundleUrl, evidence)

package/src/discovery/find.ts

@@ -327,7 +327,7 @@ function isFlatRoot(root: SessionRoot): boolean {
  * 加载标题元数据索引（u11）。仅 keyword 路径调用（惰性触发：uuid 精确/归一化两级零命中
  * 且 query 非纯 hex 才到达此处，§6.6 调用策略 ①）。
  *
- * 窄化目标（策略 ②，按序）：未剥层 liveSessionDir 本身（xyz-agent 下即平铺主根；纯 pi 下
+ * 窄化目标（策略 ②，按序）：未剥层 liveSessionDir 本身（taiji 下即平铺主根；纯 pi 下
  * 即当前 cwd 目录，小）+ 实扫结果无子目录的候选根。两条 guard：
  * - 仅对存在的根/目录调用（root.exists / stat liveSessionDir），且永传非空串——pi 的
  *   listAll 对空串 falsy 走默认全盘分支（数千项 / 秒级，hash-provider.ts 空参灾难先例）；

package/src/discovery/roots.ts

@@ -24,7 +24,7 @@ import { performance } from 'node:perf_hooks'
 
 /** 发现层信号包（index.ts 采集，全部可降级；本模块只消费不采集） */
 export interface SessionRootSignals {
-  /** pi agent 数据目录（两宿主均成立；B 后 xyz-agent = `<dataDir>/agent`） */
+  /** pi agent 数据目录（两宿主均成立；B 后 taiji = `<dataDir>/agent`） */
   agentDir: string
   /**
    * 宿主已解析的 live session 目录（`ctx.sessionManager.getSessionDir()`，§6.1 信号 1）。
@@ -66,7 +66,7 @@ const SUBAGENTS_DIRNAME = 'subagents'
 
 /**
  * `[live]` 规范化（§6.1/§7B 要点 3）：`getSessionDir()` 在纯 pi 返回按 cwd 编码的子目录
- *（`<agentDir>/sessions/--Users-x--`），在 xyz-agent 覆盖态返回根本身。判据：basename
+ *（`<agentDir>/sessions/--Users-x--`），在 taiji 覆盖态返回根本身。判据：basename
  * 匹配 encodeCwd 形态（`--` 开头 `--` 结尾，实证见 `~/.pi/agent/sessions/` 全部子目录
  * 与 real-data.ts）则取 dirname，否则取自身。
  */

package/src/doctor.ts

@@ -2,13 +2,10 @@
  * doctor action（u8：design 2026-09-10 §6.2/§6.3/§6.4/§7B 要点 2/4/5/8 + §6.11 U14b 段）。
  *
  * 从 tool-handler.ts 机械提取（max-lines 拆分轮，零行为变更）：环境判定 + 根表渲染 +
- * 旧布局残留 glob 探测。SessionReadSignals（u3 信号包超集）在域内定义，tool-handler
+ * SessionReadSignals（u3 信号包超集）在域内定义，tool-handler
  * re-export 供 index.ts 生产消费。原 u8 的扫描缓存机已删除（ext-simplify-04 U3）：
  * 每次调用实扫，无缓存命中语义；TTL/mtime 判定随 metadata 缓存留在 tool-handler 侧。
  */
-import { existsSync } from 'node:fs'
-import { readdir } from 'node:fs/promises'
-import { join, dirname } from 'node:path'
 import { detectEnvironment, type DetectedEnvironment } from './discovery/env.js'
 import { resolveSessionRoots, type SessionRoot, type SessionRootSignals } from './discovery/roots.js'
 import type { SessionReadParams, ToolResult } from './tool-handler.js'
@@ -29,52 +26,8 @@ export interface SessionReadSignals extends SessionRootSignals {
 /** doctor 根表来源标签列宽（最长 `[subagent]` 10 字符 + 1 对齐间距，§5.1 表格形态）。 */
 const DOCTOR_ROOT_LABEL_PAD = 11
 
-/** 旧布局残留条目（§6.11 U14b doctor 侧独立 glob 探测）。 */
-/** 旧布局残留探测单条命中（doctor 与 u14b 启动探测同源判据，§6.11）。 */
-export interface PiLayoutLeftover {
-  path: string
-  kind: 'backup' | 'unmigrated'
-}
-
 /**
- * 旧布局残留独立 glob 探测（§6.11 v9.1）。基点 = dirname(agentDir)（xyz-agent 下 =
- * `<dataDir>`，纯 pi 下 = `~/.pi`）；`pi/`（未迁移）与 `pi.backup-v2-` 前缀目录（迁移备份）
- * 都不在任何候选根推导式内（[legacy] 够不到带时间戳的备份名与 pi/ 层），故须独立探测。
- *
- * 形态判据（与 u14b 启动探测 / u14a 脚本 0a 同源）：目录下含 `agent/` 或 `sessions/`
- * 子目录才算残留——防纯 pi 宿主下任意来源的 `~/.pi/pi/` 目录误报。读探测，每次现查
- * 不入缓存（两次 readdir 成本可忽略，缓存只服务扫盘贵的根）。
- *
- * 迁移期支持（A4 登记）：本探测服务于 v2 布局迁移窗口，全量迁移确认后可整段删除。
- */
-async function detectPiLayoutLeftovers(
-  agentDir: string,
-): Promise<{ base: string; hits: PiLayoutLeftover[] }> {
-  const base = dirname(agentDir)
-  if (agentDir.length === 0) return { base, hits: [] }
-  let names: string[]
-  try {
-    names = (await readdir(base, { withFileTypes: true }))
-      .filter((e) => e.isDirectory())
-      .map((e) => e.name)
-  } catch {
-    return { base, hits: [] }
-  }
-  const hits: PiLayoutLeftover[] = []
-  for (const name of names) {
-    const isUnmigrated = name === 'pi'
-    const isBackup = name.startsWith('pi.backup-v2-')
-    if (!isUnmigrated && !isBackup) continue
-    const dir = join(base, name)
-    // 形态判据：含 agent/ 或 sessions/ 子目录（迁移备份必含其一——备份即原 pi/ 改名）
-    if (!existsSync(join(dir, 'agent')) && !existsSync(join(dir, 'sessions'))) continue
-    hits.push({ path: dir, kind: isBackup ? 'backup' : 'unmigrated' })
-  }
-  return { base, hits }
-}
-
-/**
- * doctor：环境判定 + 根表 + 事实型诊断 + legacy 非空告警 + 旧布局残留探测。
+ * doctor：环境判定 + 根表 + 事实型诊断 + legacy 非空告警。
  *
  * 诊断结论只陈述事实（「最高优先级 main 根 N 文件」），禁止「真的没有 session」类
  * 归因断言（§7B 要点 5 / §3.3 教训）；env/bundleUrl 信号缺失时环境判定按降级输出，
@@ -94,8 +47,7 @@ export async function doDoctor(
     // 才扫。无缓存——每次实扫（原缓存机已删，ext-simplify-04 U3，§7B 要点 8 新态）。
     subagents: params.includeSubagents === true ? 'scan' : 'stat',
   })
-  const leftovers = await detectPiLayoutLeftovers(signals.agentDir)
-  return renderDoctor(roots, environment, leftovers)
+  return renderDoctor(roots, environment)
 }
 
 /**
@@ -105,24 +57,21 @@ export async function doDoctor(
 export interface DoctorDetails {
   environment: DetectedEnvironment
   roots: SessionRoot[]
-  leftovers: PiLayoutLeftover[]
-  globBase: string
 }
 
 /**
  * 渲染 doctor 输出（§5.1 形态）：环境判定 + evidence + 会话根表（来源标签/路径/存在/
- * 文件数/扫描耗时/去重注记）+ 事实型诊断 + legacy 非空告警 + 旧布局残留（命中才出现）。
+ * 文件数/扫描耗时/去重注记）+ 事实型诊断 + legacy 非空告警。
  */
 function renderDoctor(
   roots: SessionRoot[],
   environment: DetectedEnvironment,
-  leftovers: { base: string; hits: PiLayoutLeftover[] },
 ): ToolResult {
   const lines: string[] = []
 
   // 环境判定行 + evidence（§6.2：判定可被证据推翻，非黑盒断言；evidence 恒非空）
   lines.push(
-    `环境判定：${environment.kind === 'xyz-agent' ? 'xyz-agent（托管）' : 'standalone-pi'}` +
+    `环境判定：${environment.kind === 'taiji' ? 'taiji（托管）' : 'standalone-pi'}` +
       ` · 发行形态：${environment.distribution ?? '未知（不猜）'}`,
   )
   if (environment.dataDir !== undefined) lines.push(`数据目录：${environment.dataDir}`)
@@ -172,25 +121,11 @@ function renderDoctor(
     )
   }
 
-  // 旧布局残留（§6.11：命中才列，附同一迁移指引）
-  if (leftovers.hits.length > 0) {
-    lines.push('')
-    lines.push(`旧布局残留探测（基点 ${leftovers.base}）：`)
-    for (const h of leftovers.hits) {
-      lines.push(
-        `  - ${h.path}（${h.kind === 'backup' ? '迁移备份 pi.backup-v2-*' : '未迁移旧布局 pi/'}）`,
-      )
-    }
-    lines.push('  👉 关闭应用后运行 scripts/migrate-pi-layout-v2.mjs 完成迁移。')
-  }
-
   return {
     content: [{ type: 'text', text: lines.join('\n') }],
     details: {
       environment,
       roots,
-      leftovers: leftovers.hits,
-      globBase: leftovers.base,
     } satisfies DoctorDetails,
   }
 }

package/src/index.ts

@@ -157,7 +157,7 @@ const guidelines = [
   "workflow action to see workflow run overviews (status/budget/steps). Each step's call sessionId can jump to outline/detail for deep reading.",
   "result action to fetch a subagent's final result text (same content as its completion notice): session takes a single sa-id/uuid/path or a comma-separated batch of at most 10; optional limit caps chars per item (default 8000, truncated items carry a pointer to the full file).",
   'Errors carry a 👉 recovery hint—follow it to retry in one step.',
-  'Unsure about the host environment (pure pi vs xyz-agent) or where session roots live? Run action:"doctor" first—it prints the detected environment and every candidate session root.',
+  'Unsure about the host environment (pure pi vs taiji) or where session roots live? Run action:"doctor" first—it prints the detected environment and every candidate session root.',
 ]
 
 // ---- 工具 description（design §3.4，照搬措辞）----
@@ -231,7 +231,7 @@ export default function sessionReaderExtension(pi: ExtensionAPI): void {
 
   // ── M4 TUI 层（design §1 + §3.3 D-3/D-4 + 附录 P-hash-trigger）──────────
   // # 引用补全 provider + /session-pick 命令（命令名避开 pi 内置 /session 冲突）。仅 ctx.mode === 'tui' 注册：RPC 模式
-  // （xyz-agent 子进程）不用 pi TUI editor / slash 命令，加载即跳过。
+  // （taiji 子进程）不用 pi TUI editor / slash 命令，加载即跳过。
   //
   // addAutocompleteProvider 挂在 ctx.ui（非 ExtensionAPI），setup 入口无 ctx，
   // 只能在 event handler 里拿——session_start 是最早且每 session 触发的 event。

package/src/result-action.ts

@@ -1,5 +1,5 @@
 /**
- * result action（subagent-sync-collect U6：design subagent-sync-collect.md §3.1.3）。
+ * result action。
  *
  * 从 tool-handler.ts 机械提取（max-lines 拆分轮）：纯移动零行为变更。纯函数 helper
  *（err/stripHash/requireStr/SESSION_ID_PREFIX_LEN）直接 import 自 handler-utils

package/src/search-across.ts

@@ -16,6 +16,7 @@ import {
 import { parseSessionFile } from './core/parser.js'
 import { segmentTurns, type Turn } from './core/turns.js'
 import { buildTreeView } from './core/tree.js'
+import { BYTES_PER_KB, BYTES_PER_MB } from './core/units.js'
 import { err, pad } from './handler-utils.js'
 import type { SessionReadSignals } from './doctor.js'
 import type { SessionReadParams, ToolResult } from './tool-handler.js'
@@ -163,10 +164,6 @@ export function formatSearchText(
  */
 export const MULTI_SEARCH_MAX_SESSIONS = 10
 
-/** 字节展示/预算换算基数（人话格式化与预算常量共用同一量纲）。 */
-const BYTES_PER_KB = 1024
-const BYTES_PER_MB = BYTES_PER_KB * BYTES_PER_KB
-
 /** 跨会话单次检索的预算 MB 数（§8.2 V8 字节上限的量纲；换算见 SEARCH_SCAN_BYTE_BUDGET）。 */
 const SEARCH_SCAN_BUDGET_MB = 64
 

package/vitest.config.ts

@@ -1,11 +1,9 @@
 import path from 'node:path'
 
-import { defineConfig } from 'vitest/config'
+import { taijiTestConfig } from '../../../test-guard/factory.ts'
 
-export default defineConfig({
+export default taijiTestConfig({
   test: {
-    reporters: ['default', 'junit'],
-    outputFile: { junit: './test-results/vitest-junit.xml' },
     include: ['src/__tests__/**/*.test.ts'],
   },
   resolve: {