prts-terrarchive 0.2.1 → 0.2.3

package/src/index.js

@@ -30,17 +30,21 @@ import { createHash } from 'node:crypto'
 import { mkdir, realpath } from 'node:fs/promises'
 import { assertCorpusVersion, corpusVersionSnapshot,
   CorpusStore, documentGame, documentUid, naturalDocumentTitle, publicStoryStageCode,
-  publicStoryPart } from './store.js'
+  publicStoryPart, DATA_VERSION_REF_PATTERN, dataVersionMatches } from './store.js'
 import { readCurrentReleasePointer } from './installer.js'
 import { watchCurrentRelease } from './release-watch.js'
 import { END_FIELD_STORY_CONTENT_TYPES, executeRead, readContractFromCursor,
   normalizeReadRequest, projectReadPublic, renderRead } from './read.js'
 import { executeSearch, renderSearch } from './search.js'
+import { executeNavigation, NAVIGATION_DESCRIPTION, NAVIGATION_PARAMETERS, renderNavigation } from './navigation.js'
 import { executeI18n, I18N_DESCRIPTION, I18N_PARAMETERS, I18N_OUTPUT_SCHEMA, renderI18n } from './i18n.js'
 import { executeTimelineSearch, renderTimeline } from './timeline.js'
 import { AnonymousSessionProvider, CloudRetrievalClient, StaticTokenProvider,
   createAgentCloudClientRegistry,
-  cloudErrorResponse, readOrCreateClientId } from './cloud.js'
+  cloudFaultError, readOrCreateClientId } from './cloud.js'
+import { dropEmptyPlaceholders } from './tool-args.js'
+import { formatCitation, normalizeReadArguments, parseCitation, readTargets,
+  readTargetError, withReadGuidance } from './read-args.js'
 import { createSharedState } from './state.js'
 import { applyUi } from './ui.js'
 import { acquireInvestigationStore } from './investigation-store.js'
@@ -66,7 +70,6 @@ const storesByDirectory = new Map()
 
 const LOCAL_CORPUS_MISSING_MESSAGE =
   '本地数据包暂未安装，请提醒用户前往“设置 → 插件 → PRTS 语料”安装。'
-const DATA_VERSION_PATTERN = /^[0-9a-f]{64}$/
 
 function sameFilesystemPath(left, right) {
   return process.platform === 'win32'
@@ -110,35 +113,15 @@ async function requireLocalCorpus(store) {
   }
 }
 
-const READ_DESCRIPTION = [
-  '读取 PRTS.chat 本地资料。明日方舟关卡用 stage_code，只有多篇时才填 story_part；干员密录用 character_name + record_name + segment；角色资料用 character_name + material。',
-  '整个明日方舟活动用 activity_name + mode=activity，终末地任务用 collection_name + mode=collection；合集续页原样提交 page.continuation 的 position。其他资料使用完整 title。',
-  '搜索结果若给出 document_uid，说明标题或合集同名：它替代 title，读取时只提交 document_uid，不得同时提交 title；单篇可配 line 或 mode=document，所属合集可配 mode=activity/collection。',
-  'line 扩大单篇原文上下文，section 读取 Wiki 字段，mode=document 分页全文。所有续页都原样提交 page.continuation；旧会话里的 cursor 仅用于兼容。',
-  '引用原文使用“《篇章名》第 N 行”；同名结果保留工具给出的 document_uid 作为唯一定位器。不要使用内部代号、路径或自造篇章名。',
-].join(' ')
-
-const SEARCH_DESCRIPTION = [
-  '像 grep 一样搜索 PRTS.chat 本地语料；命中立即返回原行及上下各一行，并按文档归并。',
-  'query 使用短实体名、篇章展示名或原句片段；也可省略 query，仅按过滤条件列出资料入口。',
-  '角色个人页用 character_wiki；活动/密录整理页用 story_wiki；角色在单个活动中的辅助整理用 character_activity_wiki。wiki_sections 可精确限定相关活动、相关角色、剧情总结、角色剧情概括等标签字段。',
-  'literal 是默认连续字面匹配；只有特殊模式才使用受限 regex。新查询的下一页保留原搜索条件，并把返回的 next_after 原样放入 after；锚点由完整资料版本、资料类型与自然标题组成，不再暴露内部 cursor。旧会话的 cursor 链仅按返回的 next_cursor 继续。',
-].join(' ')
-
-const TIMELINE_DESCRIPTION = [
-  '按活动名、年份及自动展开的实体别名检索活动时间线（PRTS Wiki《泰拉年表》本地投影）。',
-  '人物放 entity_names 以自动裂变别名；结果只给时间、事件正文和“年表出处”标记，把标记原样传回 source_marker 可反查完整来源。',
-].join(' ')
-
-const CLOUD_SEARCH_DESCRIPTION = [
-  '用一次自然语言请求同时查询 PRTS.chat 云端的明日方舟与终末地图谱、档案、原文、自建 Wiki 和时间线组合索引；只有用户明确限定游戏时才使用 games 收窄。',
-  '返回末尾的「## 可读取原文」列出已映射到本地篇章的完整自然语言标题与行号；有同名消歧标记时按 document_uid + line 调用，否则按 title + line。',
-].join(' ')
-
-const CLOUD_INSPECT_DESCRIPTION = [
-  '按 section 和过滤条件读取最近一次云端检索状态（request_id 由运行时自动注入）。',
-  '用于定点读取回答材料、候选状态或诊断记录，并支持按 next_cursor 分页。',
-].join(' ')
+const READ_DESCRIPTION = '读取 PRTS.chat 本地资料，支持行号上下文、Wiki 字段和单篇/合集连续阅读。只选一种主定位方式；续页原样提交 page.continuation。最小 UID 全文调用：{"document_uid":"检索返回的 doc_ 定位","mode":"document"}；不要填写不适用的附属参数。'
+
+const SEARCH_DESCRIPTION = '搜索 PRTS.chat 本地语料，返回按文档归并的命中行及上下各一行；省略 query 可列目录。过滤数组内 OR、字段间 AND。终末地版本、最新主线与章节顺序先用 corpus_navigate 定位。'
+
+const TIMELINE_DESCRIPTION = '检索明日方舟活动时间线（PRTS Wiki《泰拉年表》），返回年份、事件与可反查的出处标记。'
+
+const CLOUD_SEARCH_DESCRIPTION = '用自然语言检索 PRTS.chat 云端图谱、档案、原文、Wiki 和时间线。返回的「可读取原文」定位可交给 corpus_read 核验。'
+
+const CLOUD_INSPECT_DESCRIPTION = '读取最近一次云端检索的回答材料、候选或诊断记录；request_id 由运行时注入。'
 
 const TOOL_GAME_LABELS = Object.freeze({ arknights: '明日方舟', endfield: '终末地' })
 
@@ -187,34 +170,34 @@ const stringList = (description) => ({ type: 'array', items: { type: 'string' },
 const SEARCH_PARAMETERS = {
   type: 'object', additionalProperties: false,
   properties: {
-    cursor: { type: 'string', description: '仅兼容旧会话：单独提交旧 next_cursor；新搜索使用 after' },
-    query: { type: 'string', description: '短搜索词：实体名、篇章展示名、活动名或原句片段；不要直接提交整句研究问题' },
+    cursor: { type: 'string', description: '旧会话 next_cursor，单独提交；新查询用 after' },
+    query: { type: 'string', description: '短实体名、标题或原句片段；完整研究问题用 cloud_search' },
     resource_types: { type: 'array', items: { type: 'string', enum: RESOURCE_TYPES },
-      description: '资料类型；character_bundle 可一次查看角色档案、模组、语音和密录' },
+      description: '资料类型；character_bundle 聚合角色资料' },
     games: { type: 'array', items: { type: 'string', enum: ['arknights', 'endfield'] },
-      description: '可选游戏过滤；省略时在同一次调用中同时检索明日方舟与终末地' },
+      description: '游戏范围；省略时查询全部启用游戏' },
     content_types: { type: 'array', items: { type: 'string', enum: CONTENT_TYPES },
-      description: '统一内容形式，例如 dialogue、cutscene、radio、sns_chat；两款游戏使用相同参数' },
-    collection_names: stringList('上级资料集合展示名；明日方舟活动与终末地任务都使用此字段'),
-    character_names: stringList('角色展示名，如“凯尔希”'),
-    story_names: stringList('剧情篇章的展示名，如“晶簇之内”；不要填写内部 story_id 或路径'),
-    activity_names: stringList('活动展示名'),
+      description: '内容形式' },
+    collection_names: stringList('活动或任务等上级集合展示名'),
+    character_names: stringList('资料归属角色的展示名'),
+    story_names: stringList('单关/单篇剧情名，如“鳞的记忆”；活动名不要填这里，改用 activity_names'),
+    activity_names: stringList('活动或主线章节名，如“昨日海”'),
     wiki_sections: { type: 'array', items: { type: 'string', enum: WIKI_SECTION_VALUES },
-      description: 'Wiki 标签字段，可与资料类型、角色、活动和 query 组合；角色页常用相关活动/相关角色/剧情高光，活动页常用剧情总结/关键人物/角色剧情概括' },
+      description: '限定 Wiki 标签字段' },
     entity_names: stringList('只返回出现指定实体的行'),
-    speakers: stringList('结构化说话人展示名，只匹配亲口台词；适合查某人亲口说过什么'),
+    speakers: stringList('说话人展示名，仅匹配亲口台词；自动展开已登记别名'),
     match_mode: { type: 'string', enum: ['literal', 'regex'],
-      description: '默认 literal 连续字面匹配；除非必须，不使用受限 regex' },
+      description: '默认 literal 连续字面匹配；regex 为受限正则' },
     context_terms: { type: 'array', items: { type: 'string' },
-      description: '要求命中附近同时出现的语境词（最多 8 个）' },
+      description: '强约束：每个词都须出现在命中行前后 3 行内（非整篇共现），最多 8 个；不确定时省略' },
     after: { type: 'object', additionalProperties: false,
-      description: '版本绑定的下一页锚点；与原 query 和过滤条件一起原样提交上次返回的 next_after',
+      description: '原样复制 page.next_after，保留原 query 和过滤条件；切版后重新搜索',
       required: ['data_version', 'resource_type', 'title', 'position'], properties: {
         data_version: { type: 'string',
-          description: '上一页所用资料包的完整 SHA-256 版本；版本切换后必须重新搜索' },
+          description: '上一页的完整 SHA-256 资料版本' },
         resource_type: { type: 'string', enum: RESOURCE_TYPES },
-        title: { type: 'string', description: '上一页扫描到的资料自然标题' },
-        position: { type: 'integer', description: '该标题在当前资料版本中的顺序位置（0..10000000）' },
+        title: { type: 'string' },
+        position: { type: 'integer' },
       } },
   },
 }
@@ -244,6 +227,7 @@ const SEARCH_OUTPUT_SCHEMA = {
             line_start: { type: 'integer' }, line_end: { type: 'integer' },
             match_kind: { type: 'string' }, evidence_kind: { type: 'string' },
             citation: { type: 'string' },
+            citation_handle: { type: 'string' },
             excerpt: { type: 'array', items: { type: 'object', additionalProperties: false,
               required: ['line', 'role', 'line_type', 'speaker', 'text', 'truncated'],
               properties: { line: { type: 'integer' },
@@ -279,6 +263,13 @@ const SEARCH_OUTPUT_SCHEMA = {
           } }, { type: 'null' }] } } },
     truncated: { type: 'boolean' },
     truncation_reasons: { type: 'array', items: { type: 'string' } },
+    scope: { type: 'object', additionalProperties: false,
+      required: ['documents', 'lines'], properties: {
+        documents: { type: 'integer' }, lines: { type: 'integer' },
+      } },
+    by_game: { type: 'object', additionalProperties: false, properties: {
+      arknights: { type: 'integer' }, endfield: { type: 'integer' },
+    } },
     warnings: { type: 'array', items: { type: 'object', additionalProperties: false,
       required: ['code', 'game', 'message'], properties: {
         code: { type: 'string' }, game: { type: 'string', enum: ['arknights', 'endfield'] },
@@ -296,34 +287,39 @@ const SEARCH_OUTPUT_SCHEMA = {
 const READ_PARAMETERS = {
   type: 'object',
   properties: {
-    title: { type: 'string', description: '未使用其他定位器时，填写资料完整展示标题；不得与 document_uid 同时提交' },
+    title: { type: 'string', description: '展示标题（可省略分隔符与 Wiki 序号后缀，找不到会列出候选）；与 document_uid 互斥；可配 line、section 或 mode=document，单独提供时从第 1 行读全文' },
     document_uid: { type: 'string',
-      description: '仅在搜索结果提示同名歧义时原样复制 doc_ 开头的稳定定位；它替代 title，不得与 title 同时提交；可配合 mode=activity/collection 选择所属合集' },
-    stage_code: { type: 'string', description: '明日方舟游戏内关卡代号，如 15-17、GT-3、TW-ST-1' },
-    story_part: { type: 'string', enum: ['before', 'after', 'story'],
-      description: '关卡存在多篇剧情时用于消歧：before=行动前，after=行动后，story=纯剧情/幕间；单篇关卡可省略' },
+      description: '仅复制搜索返回的 doc_ 开头同名消歧定位，替代 title；不能填展示标题，标题请用 title；可配合集 mode' },
+    stage_code: { type: 'string', description: '明日方舟关卡代号，如 15-17、TW-ST-1' },
+    story_part: { type: 'string', enum: ['', 'before', 'after', 'story'],
+      description: '空或省略=不适用；依赖 stage_code，多篇时消歧：before=行动前，after=行动后，story=幕间；单篇可省略' },
     character_name: { type: 'string', description: '角色展示名；与 record_name 或 material 配合' },
-    record_name: { type: 'string', description: '明日方舟干员密录名称；多段密录再提供 segment' },
-    segment: { type: 'integer', description: '干员密录段号，如 1、2' },
-    material: { type: 'string', enum: ['profile', 'module', 'voice', 'skin', 'recruitment', 'potential'],
-      description: '角色资料类别；profile=档案、module=模组、voice=语音、skin=时装' },
-    game: { type: 'string', enum: ['arknights', 'endfield'],
-      description: '角色资料在双模块同名时用于消歧；其他定位器不要填写' },
-    activity_name: { type: 'string', description: '明日方舟活动展示名；按活动连续阅读全部剧情' },
-    collection_name: { type: 'string', description: '终末地任务或剧情集合展示名；跨碎片连续阅读' },
+    record_name: { type: 'string', description: '干员密录名；须配 character_name，多段时加 segment' },
+    segment: { type: 'integer', description: '依赖 record_name 的密录段号，从 1 开始；其他定位请省略' },
+    material: { type: 'string', enum: ['', 'profile', 'module', 'voice', 'skin', 'recruitment', 'potential'],
+      description: '空或省略=不适用；依赖 character_name，读官方角色资料：档案/模组/语音/时装/招聘合同/信物。两款游戏通用（终末地如 {"character_name":"管理员","material":"profile"}）；活动、组织等实体资料用搜索返回的 title 读取' },
+    game: { type: 'string', enum: ['', 'arknights', 'endfield'],
+      description: '空或省略=不适用；依赖 character_name+material，仅角色资料同名时限定游戏' },
+    activity_name: { type: 'string', description: '明日方舟活动展示名，配 mode=activity' },
+    collection_name: { type: 'string', description: '终末地任务集合展示名，配 mode=collection' },
     content_types: { type: 'array', items: { type: 'string', enum: END_FIELD_STORY_CONTENT_TYPES },
-      description: '终末地集合可选内容形式过滤；续页时原样保留' },
-    line: { type: 'integer', description: 'around 的中心官方行号；与 mode=document 同用时表示续读起始行' },
-    position: { type: 'integer', description: '活动/任务连续阅读的下一位置；只从 page.continuation 原样复制' },
-    mode: { type: 'string', enum: ['document', 'activity', 'collection'],
-      description: '单篇全文用 document；活动用 activity；终末地任务集合用 collection。title 不会自动推断，必须配 line、section 或 mode=document；document_uid、关卡、密录和角色资料可自动推断单篇全文' },
-    section: { type: 'string', enum: WIKI_SECTION_VALUES, description: '读取 Wiki 标签字段' },
-    before: { type: 'integer', description: 'around 前文行数，默认 3，上限 100' },
-    after: { type: 'integer', description: 'around 后文行数，默认 3，上限 100' },
-    cursor: { type: 'string', description: '仅兼容旧会话中的不透明游标；新调用应原样提交上次结果的 page.continuation' },
-    data_version: { type: 'string', description: '续页时原样提交 page.continuation.data_version，防止版本切换后混读' },
-    max_lines: { type: 'integer', description: '最多返回行数，默认 100，上限 500；只限制输出量，不能代替 line、section 或 mode' },
-    max_chars: { type: 'integer', description: '最多返回字符数，默认 12000，上限 100000；只限制输出量，不能代替 line、section 或 mode' },
+      description: '终末地集合的内容形式过滤；续页保留' },
+    line: { type: 'integer', description: '上下文中心行号（around 模式，默认前后各 3 行）；mode=document 不接受 line，连续读取请用 start_line' },
+    start_line: { type: 'integer', description: '连续读取的起始行号，仅配 mode=document；page.continuation 里的续页参数就是它' },
+    position: { type: 'integer', description: '合集续读位置，从 page.continuation 复制' },
+    mode: { type: 'string', enum: ['', 'document', 'activity', 'collection'],
+      description: '空或省略=不适用；document=单篇全文，activity=活动，collection=任务集合；document_uid、关卡、密录和角色资料默认单篇全文；显式 mode=document 全文优先于合法 section，并返回提示' },
+    section: { type: 'string', enum: ['', ...WIKI_SECTION_VALUES], description: '空或省略=不适用；配 title 或 document_uid 读取 Wiki 标签字段；并非每篇都有全部字段，不确定时用 mode=document；显式全文优先于合法 section，并返回提示' },
+    before: { type: 'integer', description: '前文行数，默认 3，上限 100' },
+    after: { type: 'integer', description: '后文行数，默认 3，上限 100' },
+    cursor: { type: 'string', description: '仅兼容旧会话游标' },
+    data_version: { type: 'string', description: '续页调用给出的短版本号；可省略' },
+    max_lines: { type: 'integer', description: '输出行数上限，默认 100，最大 500' },
+    max_chars: { type: 'integer', description: '输出字符上限，默认 12000，最大 100000' },
+    citation: { type: 'string',
+      description: '检索结果给出的「句柄」，形如 doc_xxxxxxxxxxxxxxxx#L123 或 #L120-135；与 title/document_uid/line 等定位参数互斥，用于回到原文某几行' },
+    reuse: { type: 'boolean',
+      description: '默认 true：跳过"上文已可见"的行，只返回新增行。长会话或上文被压缩/折叠后看不到原文时传 false，强制重发本页全文' },
   },
   additionalProperties: false,
 }
@@ -389,7 +385,8 @@ const READ_OUTPUT_SCHEMA = {
             activity_name: { type: 'string' }, collection_name: { type: 'string' },
             content_types: { type: 'array', items: { type: 'string', enum: END_FIELD_STORY_CONTENT_TYPES } },
             mode: { type: 'string', enum: ['document', 'activity', 'collection'] },
-            line: { type: 'integer' }, position: { type: 'integer' }, data_version: { type: 'string' },
+            start_line: { type: 'integer' }, position: { type: 'integer' },
+            data_version: { type: 'string' },
           } }, { type: 'null' }] } } },
   },
 }
@@ -403,7 +400,7 @@ function projectReadToolValue(response, store) {
         && store.requiresDocumentUid?.(response.document?.document_id)) {
       projected.page.continuation = {
         document_uid: documentUid(response.document.document_id), mode: 'document',
-        line: continuation.line, data_version: continuation.data_version,
+        start_line: continuation.start_line, data_version: continuation.data_version,
       }
     }
     const uniqueStage = continuation.stage_code && continuation.story_part
@@ -416,7 +413,7 @@ function projectReadToolValue(response, store) {
         && (continuation.stage_code || continuation.record_name || continuation.material)
         && !uniqueStage && !uniqueRecord && !uniqueMaterial) {
       projected.page.continuation = {
-        title: projected.primary.title, mode: 'document', line: continuation.line,
+        title: projected.primary.title, mode: 'document', start_line: continuation.start_line,
         data_version: continuation.data_version,
       }
     }
@@ -474,12 +471,12 @@ function readPresentationMeta(_args, value) {
 const TIMELINE_PARAMETERS = {
   type: 'object', additionalProperties: false,
   properties: {
-    query: { type: 'string', description: '可选的事件正文短语（≤200 字符）。人物应优先放入 entity_names 以自动展开别名' },
-    activity_names: { type: 'array', items: { type: 'string' }, description: '活动展示名，例如“孤星”（≤20 项）' },
-    entity_names: { type: 'array', items: { type: 'string' }, description: '角色或实体展示名；工具会用别名图鉴自动裂变后检索（≤20 项）' },
-    year_start: { type: 'integer', description: '起始年份（含）；可单独使用' },
-    year_end: { type: 'integer', description: '结束年份（含）；可单独使用' },
-    source_marker: { type: 'string', description: '反查模式：原样复制时间线结果方括号内的年表出处标记（年表出处:tle_ 开头）' },
+    query: { type: 'string', description: '事件正文短语，最多 200 字符' },
+    activity_names: { type: 'array', items: { type: 'string' }, description: '活动展示名，最多 20 项' },
+    entity_names: { type: 'array', items: { type: 'string' }, description: '实体展示名，自动展开别名，最多 20 项' },
+    year_start: { type: 'integer', description: '起始年份，含边界' },
+    year_end: { type: 'integer', description: '结束年份，含边界' },
+    source_marker: { type: 'string', description: '反查来源时复制返回的年表出处标记' },
     max_results: { type: 'integer', description: '最多返回事件数，默认 20，上限 100' },
   },
 }
@@ -487,66 +484,131 @@ const TIMELINE_PARAMETERS = {
 const CLOUD_SEARCH_PARAMETERS = {
   type: 'object', additionalProperties: false, required: ['query'],
   properties: {
-    query: { type: 'string', description: '改写为语义完整、适合向量检索的自然语言' },
+    query: { type: 'string', description: '包含主体、事件和所求关系的完整问题' },
     games: { type: 'array', items: { type: 'string', enum: ['arknights', 'endfield'] },
-      description: '可选游戏范围；省略时同一次调用同时检索明日方舟与终末地' },
+      description: '游戏范围；省略时查询全部启用游戏' },
     depth: { type: 'string', enum: ['fast', 'standard', 'deep'],
-      description: '兼容字段；不会改变云端主站的检索路由。回答深度由 Agent 自己的运行模式控制，通常省略' },
+      description: '兼容字段，不改变检索路线；通常省略' },
     evidence_policy: { type: 'string', enum: ['mixed', 'original_only'],
-      description: 'mixed=完整复用 PRTS.chat 主站检索、审核与 Cleaner；original_only=只运行官方剧情原文向量路线' },
+      description: '默认 mixed 混合检索，通常省略；original_only 仅检索官方剧情原文' },
     options: {
       type: 'object', additionalProperties: false,
-      description: '通常省略。只有用户记得一句原文大意且措辞可能不准时，选择官方剧情单句向量路线',
       properties: {
         search_intent: {
           type: 'string', enum: ['single_sentence_search'],
-          description: '只检索官方剧情单句向量表，并执行原有 LLM 验证；其他问题使用默认主站路线',
+          description: '仅用于凭记忆找某一句官方原文出处；会关闭档案/Wiki/图谱/年表，只检索原文。综合分析、人物关系等问题不要填写',
         },
       },
     },
   },
 }
 
+// 与后端 models/schemas.py SourceType、models/retrieval.py CandidateStatus 保持一致。
+const CLOUD_SOURCE_TYPES = ['entity_profile', 'entity_attachment', 'graph_entity', 'graph_relation',
+  'graph_event', 'csv_archive', 'csv_activity', 'csv_record', 'vector_original', 'vector_scene',
+  'vector_wiki', 'entity_attribute', 'travel_notes', 'classic_hit', 'timeline']
+const CLOUD_CANDIDATE_STATUSES = ['retrieved', 'kept', 'filtered', 'discarded', 'error']
+
+// 从 1 开始计数的整数字段：0 只可能是占位，按“省略”处理。
+const TIMELINE_ZERO_FIELDS = ['max_results']
+const CLOUD_INSPECT_ZERO_FIELDS = ['limit', 'event_sequence_from', 'event_sequence_to', 'content_max_chars']
+
+// 只接受最无歧义的形式（T 分隔、Z 或 ±HH:MM 时区），避免本地放行而后端 422。
+const AWARE_ISO_DATETIME = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:\d{2})$/u
+
+/** cloud_inspect 本地预检：把后端 422 会拒绝的常见误用提前转成可执行的提示。 */
+function validateCloudInspectArgs(args) {
+  for (const field of ['event_time_from', 'event_time_to']) {
+    if (args[field] !== undefined && !AWARE_ISO_DATETIME.test(String(args[field]).trim())) {
+      throw Object.assign(new Error(`${field} 必须是带时区的 ISO 8601 时间，例如 2025-01-01T08:00:00+08:00；不需要按时间过滤时请省略该字段`),
+        { code: 'INVALID_REQUEST', retryable: false })
+    }
+  }
+  for (const field of ['event_sequence_from', 'event_sequence_to', 'limit', 'cursor', 'content_max_chars']) {
+    if (args[field] !== undefined && (!Number.isInteger(args[field]) || args[field] < (field === 'cursor' ? 0 : 1))) {
+      throw Object.assign(new Error(`${field} 必须是${field === 'cursor' ? '非负' : '正'}整数；不需要时请省略该字段`),
+        { code: 'INVALID_REQUEST', retryable: false })
+    }
+  }
+}
+
 const CLOUD_INSPECT_PARAMETERS = {
   type: 'object', additionalProperties: false,
-  description: '查看最近一次云端检索的指定区段；request_id 由运行时自动注入',
   properties: {
     games: { type: 'array', items: { type: 'string', enum: ['arknights', 'endfield'] },
-      description: '只查看指定游戏的候选、来源或事件；省略时查看联合状态' },
+      description: '游戏过滤；省略时查看全部启用游戏' },
     section: { type: 'string', enum: ['summary', 'candidates', 'selected_sources', 'events', 'trace_steps', 'answer_context'],
       description: '默认 summary' },
-    cursor: { type: 'integer', description: '分页游标：原样复制上次返回的 next_cursor' },
-    limit: { type: 'integer', description: '本页条数' },
-    channels: stringList('按渠道过滤（candidates/events）'),
-    query_variants: stringList('按查询变体过滤'),
-    retrievers: stringList('按检索器过滤'),
-    source_types: { type: 'array', items: { type: 'string' }, description: '按来源类型过滤' },
-    statuses: { type: 'array', items: { type: 'string' }, description: '按候选状态过滤' },
-    stages: stringList('按处理阶段过滤'),
-    candidate_ids: stringList('按候选 ID 精确过滤'),
-    evidence_ids: stringList('按证据 ID 精确过滤'),
-    event_sequence_from: { type: 'integer', description: '事件序号下界（含）' },
-    event_sequence_to: { type: 'integer', description: '事件序号上界（含）' },
-    event_time_from: { type: 'string', description: '事件时间下界' },
-    event_time_to: { type: 'string', description: '事件时间上界' },
+    cursor: { type: 'integer', description: '续页时复制返回的 next_cursor；首页省略' },
+    limit: { type: 'integer', description: '本页条数 1–200；通常省略' },
+    channels: stringList('按渠道过滤（candidates/events）；通常省略'),
+    query_variants: stringList('按查询变体过滤；通常省略'),
+    retrievers: stringList('按检索器过滤；通常省略'),
+    source_types: { type: 'array', items: { type: 'string', enum: CLOUD_SOURCE_TYPES },
+      description: '按来源类型过滤；通常省略' },
+    statuses: { type: 'array', items: { type: 'string', enum: CLOUD_CANDIDATE_STATUSES },
+      description: '按候选状态过滤；通常省略' },
+    stages: stringList('按处理阶段过滤；通常省略'),
+    event_sequence_from: { type: 'integer', description: '仅 section=events：事件序号下界（含），从 1 开始' },
+    event_sequence_to: { type: 'integer', description: '仅 section=events：事件序号上界（含），从 1 开始' },
+    event_time_from: { type: 'string', description: '仅 section=events：带时区的 ISO 8601 时间，如 2025-01-01T08:00:00+08:00' },
+    event_time_to: { type: 'string', description: '仅 section=events：带时区的 ISO 8601 时间' },
     content_mode: { type: 'string', enum: ['none', 'preview', 'full'],
-      description: 'none 只取结构字段；preview 返回受限正文；full 返回该页完整正文' },
-    content_max_chars: { type: 'integer', description: '正文字符上限' },
+      description: 'none=无正文，preview=摘要（默认），full=本页全文' },
+    content_max_chars: { type: 'integer', description: '正文字符上限 100–100000；通常省略' },
   },
 }
 
 /** ---- 模型扁平参数 → 版本化 wire contract ---- */
 
 /** corpus_read：将模型使用的自然定位器转换为版本化读取契约。 */
+/** modelReadToContract 推断出的默认值说明；契约对象本身不允许携带额外字段。 */
+const contractNotes = new WeakMap()
+
+function withContractNote(contract, notes) {
+  if (notes.length) contractNotes.set(contract, notes.join('\n'))
+  return contract
+}
+
+/**
+ * 明日方舟“活动”（activity_name）与终末地“任务集合”（collection_name）是同一种连续
+ * 阅读入口，只是两款游戏的叫法不同。字段填反时，若名称只在另一款游戏中存在，就按
+ * 实际资料改道并说明，而不是报“找不到”。
+ */
+function streamExists(lookup) {
+  try { return lookup().length > 0 } catch { return true }
+}
+function rerouteStreamLocator(args, store, enabledGames, notes) {
+  const swap = (from, to, mode, game) => {
+    const name = String(args[from] ?? '').trim()
+    if (!name || args[to] !== undefined || args.document_uid !== undefined || !enabledGames.includes(game)) return null
+    const own = from === 'activity_name'
+      ? enabledGames.includes('arknights') && streamExists(() => store.activityStoryDocuments({ activityName: name }))
+      : enabledGames.includes('endfield') && streamExists(() => store.endfieldCollectionDocuments({ collectionName: name }))
+    if (own) return null
+    const other = to === 'collection_name'
+      ? streamExists(() => store.endfieldCollectionDocuments({ collectionName: name }))
+      : streamExists(() => store.activityStoryDocuments({ activityName: name }))
+    if (!other) return null
+    const { [from]: _drop, ...rest } = args
+    notes.push(`定位改道：“${name}”是${game === 'endfield' ? '终末地任务集合' : '明日方舟活动'}，已按 ${to}+mode="${mode}" 读取。`)
+    return { ...rest, [to]: name, ...(args.mode !== undefined ? { mode } : {}) }
+  }
+  return swap('activity_name', 'collection_name', 'collection', 'endfield')
+    || swap('collection_name', 'activity_name', 'activity', 'arknights')
+    || args
+}
+
 async function modelReadToContract(args = {}, store, enabledGames = ['arknights', 'endfield']) {
+  const notes = []
   if (!args || typeof args !== 'object' || Array.isArray(args)) {
     throw Object.assign(new Error('读取参数必须是对象'), { code: 'INVALID_REQUEST' })
   }
   let expectedDataVersion
   if (args.data_version !== undefined) {
     expectedDataVersion = String(args.data_version)
-    if (!DATA_VERSION_PATTERN.test(expectedDataVersion)) {
-      throw Object.assign(new Error('data_version 必须是续页结果给出的 64 位小写 SHA-256'),
+    if (!DATA_VERSION_REF_PATTERN.test(expectedDataVersion)) {
+      throw Object.assign(new Error('data_version 必须是续页结果给出的资料版本（至少 8 位小写十六进制，可省略）'),
         { code: 'INVALID_REQUEST' })
     }
   }
@@ -612,24 +674,66 @@ async function modelReadToContract(args = {}, store, enabledGames = ['arknights'
   }
   const allowed = new Set(['title', 'document_uid', 'stage_code', 'story_part', 'character_name', 'record_name',
     'segment', 'material', 'game', 'activity_name', 'collection_name', 'content_types',
-    'line', 'position', 'mode', 'section', 'before', 'after', 'max_lines', 'max_chars',
-    'data_version'])
+    'line', 'start_line', 'position', 'mode', 'section', 'before', 'after', 'max_lines', 'max_chars',
+    'reuse', 'citation', 'data_version'])
   if (Object.keys(args).some((key) => !allowed.has(key))) {
     throw Object.assign(new Error('corpus_read 包含不支持的参数'), { code: 'INVALID_REQUEST' })
   }
+  args = rerouteStreamLocator(args, store, enabledGames, notes)
+
+  // 句柄是检索结果发出的重新取用凭据：展开成 document_uid + 起始行 + 行数，
+  // 不让 Agent 为了拿 uid 先跑一次搜索。
+  if (args.citation !== undefined) {
+    const parsed = parseCitation(args.citation)
+    if (!parsed) {
+      throw Object.assign(new Error(
+        'citation 格式应为 doc_<16位定位>#L<行号> 或 doc_<16位定位>#L<起始行>-<结束行>；请原样复制检索结果里的「句柄」。',
+      ), { code: 'INVALID_REQUEST' })
+    }
+    const conflicts = ['title', 'document_uid', 'line', 'start_line', 'stage_code', 'story_part',
+      'activity_name', 'collection_name', 'character_name', 'record_name', 'material']
+      .filter((key) => args[key] !== undefined)
+    if (conflicts.length) {
+      throw Object.assign(new Error(
+        `citation 已包含篇章与行号，不能再与 ${conflicts.join('、')} 同时提交。`,
+      ), { code: 'INVALID_REQUEST' })
+    }
+    delete args.citation
+    args.document_uid = parsed.documentUid
+    args.mode = 'document'
+    args.start_line = parsed.startLine
+    args.max_lines = parsed.endLine - parsed.startLine + 1
+  }
 
   const hasTitle = args.title !== undefined
   const hasDocumentUid = args.document_uid !== undefined
-  const hasStageLocator = args.stage_code !== undefined || args.story_part !== undefined
-  const hasRecordLocator = args.record_name !== undefined || args.segment !== undefined
-  const hasMaterialLocator = args.material !== undefined
+  const hasStageLocator = args.stage_code !== undefined
+  const hasRecordLocator = args.record_name !== undefined
+  const hasMaterialLocator = args.character_name !== undefined && args.material !== undefined
   const hasActivityLocator = args.activity_name !== undefined
   const hasCollectionLocator = args.collection_name !== undefined
-  const locatorCount = [hasTitle, hasDocumentUid, hasStageLocator, hasRecordLocator, hasMaterialLocator,
-    hasActivityLocator, hasCollectionLocator].filter(Boolean).length
+  const locatorCount = readTargets(args).length
   if (locatorCount !== 1) {
+    throw Object.assign(new Error(readTargetError(args)), { code: 'INVALID_REQUEST' })
+  }
+  if (args.story_part !== undefined && !hasStageLocator) {
+    throw Object.assign(new Error('附属参数 story_part 依赖 stage_code；关卡读取请仅提交 {"stage_code":"15-17","story_part":"after"}，其他定位请省略 story_part'),
+      { code: 'INVALID_REQUEST' })
+  }
+  if (args.segment !== undefined && !hasRecordLocator) {
+    throw Object.assign(new Error('附属参数 segment 依赖 record_name；密录读取请仅提交 {"character_name":"角色名","record_name":"密录名","segment":1}，其他定位请省略 segment'),
+      { code: 'INVALID_REQUEST' })
+  }
+  if (args.material !== undefined && args.character_name === undefined) {
+    throw Object.assign(new Error('附属参数 material 依赖 character_name；角色资料读取请仅提交 {"character_name":"角色名","material":"profile"}，其他定位请省略 material'),
+      { code: 'INVALID_REQUEST' })
+  }
+  // Validate before either the single-document or collection lookup, so a
+  // display title in this field is not mistaken for missing corpus data.
+  if (hasDocumentUid && (typeof args.document_uid !== 'string'
+      || !/^doc_[A-Za-z0-9_-]{16}$/u.test(args.document_uid.trim()))) {
     throw Object.assign(new Error(
-      '必须且只能提供一种定位方式：title、document_uid、stage_code、角色密录、角色资料、activity_name 或 collection_name；document_uid 会替代 title，不要同时提交二者',
+      'document_uid 必须是检索结果返回的 doc_ 定位（doc_ 后为 16 位字母、数字、_ 或 -），不能填写展示标题；展示标题请改填 title，例如 {"title":"完整展示标题","mode":"document"}。不要同时提交 title 和 document_uid。',
     ), { code: 'INVALID_REQUEST' })
   }
   if (args.character_name !== undefined && !hasRecordLocator && !hasMaterialLocator) {
@@ -660,8 +764,11 @@ async function modelReadToContract(args = {}, store, enabledGames = ['arknights'
     const expectedMode = hasActivityLocator ? 'activity'
       : hasCollectionLocator ? 'collection' : args.mode
     if (args.mode !== undefined && args.mode !== expectedMode) {
-      throw Object.assign(new Error(`${hasActivityLocator ? 'activity_name' : 'collection_name'} 必须使用 mode="${expectedMode}"`),
-        { code: 'INVALID_REQUEST' })
+      if (uidStreamMode || args.mode !== (expectedMode === 'activity' ? 'collection' : 'activity')) {
+        throw Object.assign(new Error(`${hasActivityLocator ? 'activity_name' : 'collection_name'} 必须使用 mode="${expectedMode}"`),
+          { code: 'INVALID_REQUEST' })
+      }
+      notes.push(`读取方式：${hasActivityLocator ? 'activity_name' : 'collection_name'} 对应 mode="${expectedMode}"，已自动改用。`)
     }
     if (args.line !== undefined || args.section !== undefined || args.before !== undefined
         || args.after !== undefined) {
@@ -702,7 +809,7 @@ async function modelReadToContract(args = {}, store, enabledGames = ['arknights'
     } catch (error) {
       throw Object.assign(new Error(error.message), { code: error.code || 'DOCUMENT_AMBIGUOUS' })
     }
-    return {
+    return withContractNote({
       locator: hasDocumentUid ? { document_uid: String(args.document_uid).trim() }
         : { [hasActivityLocator ? 'activity_name' : 'collection_name']: name },
       selection: { mode: expectedMode, cursor: null,
@@ -711,7 +818,7 @@ async function modelReadToContract(args = {}, store, enabledGames = ['arknights'
       ...(expectedDataVersion ? { expected_data_version: expectedDataVersion } : {}),
       limits: { ...(args.max_lines !== undefined ? { max_lines: args.max_lines } : {}),
         ...(args.max_chars !== undefined ? { max_chars: args.max_chars } : {}) },
-    }
+    }, notes)
   }
 
   let locator
@@ -738,8 +845,35 @@ async function modelReadToContract(args = {}, store, enabledGames = ['arknights'
     try {
       record = await store.getDocumentByStoryStage(stageCode, storyPart)
     } catch (error) {
-      throw Object.assign(new Error(error.message),
-        { code: error.code || 'DOCUMENT_AMBIGUOUS' })
+      // 同一关卡有行动前/行动后两篇时，未指定 story_part 默认先读行动前，
+      // 并提示另一篇的读法，而不是直接报错让调用方重试。
+      let fallback = null
+      if (!storyPart && error.code === 'DOCUMENT_AMBIGUOUS') {
+        for (const part of ['before', 'story', 'after']) {
+          try {
+            fallback = await store.getDocumentByStoryStage(stageCode, part)
+          } catch {
+            fallback = null
+          }
+          if (fallback) {
+            const others = []
+            for (const other of ['before', 'after', 'story'].filter((item) => item !== part)) {
+              try {
+                if (await store.getDocumentByStoryStage(stageCode, other)) others.push(other)
+              } catch { /* 其余部分仍有歧义时不提示 */ }
+            }
+            const labels = { before: '行动前', after: '行动后', story: '纯剧情/幕间' }
+            notes.push(`关卡定位：${stageCode} 有多篇剧情，未指定 story_part，已默认读取${labels[part]}。`
+              + (others.length ? `另有${others.map((item) => `${labels[item]}（story_part="${item}"）`).join('、')}。` : ''))
+            break
+          }
+        }
+      }
+      if (!fallback) {
+        throw Object.assign(new Error(error.message),
+          { code: error.code || 'DOCUMENT_AMBIGUOUS' })
+      }
+      record = fallback
     }
     if (!record) {
       const partLabel = storyPart
@@ -805,15 +939,24 @@ async function modelReadToContract(args = {}, store, enabledGames = ['arknights'
     if (!title) throw Object.assign(new Error('title 不能为空'), { code: 'INVALID_REQUEST' })
     const record = await store.getDocumentByTitle(title)
     requireEnabled(record)
+    if (record) {
+      const resolvedTitle = naturalDocumentTitle(record.record.document)
+      const exact = (store.naturalTitleIndex?.get(title)?.length || store.titleIndex?.get(title)?.length)
+      if (!exact && resolvedTitle && resolvedTitle !== title) {
+        notes.push(`标题匹配：未找到完全一致的标题，已按宽松匹配读取《${resolvedTitle}》。`)
+      }
+    }
     locator = { display_title: title }
   }
   const section = String(args.section ?? '').trim()
-  if (section && !hasTitle) {
-    throw Object.assign(new Error('section 只能与 title 定位器一起使用'), { code: 'INVALID_REQUEST' })
+  if (section && !hasTitle && !hasDocumentUid) {
+    throw Object.assign(new Error('section 只能与 title 或 document_uid 定位器一起使用'), { code: 'INVALID_REQUEST' })
   }
   const naturalDocumentLocator = hasDocumentUid || hasStageLocator || hasRecordLocator || hasMaterialLocator
+  // 只给 title 时默认从头读全文（受 max_lines/max_chars 限制并给出续页），
+  // 与关卡/密录/角色资料等其他直达定位保持一致。
   const mode = args.mode || (section ? 'section' : Number.isInteger(args.line) ? 'around'
-    : naturalDocumentLocator ? 'document' : '')
+    : naturalDocumentLocator || hasTitle ? 'document' : '')
   if (!mode) throw Object.assign(new Error(
     '请提供 line、section 或 mode="document"；max_lines/max_chars 只限制输出量，不能代替读取方式',
   ), { code: 'INVALID_REQUEST' })
@@ -830,34 +973,42 @@ async function modelReadToContract(args = {}, store, enabledGames = ['arknights'
   if (section && mode !== 'section') {
     throw Object.assign(new Error('section 只能与 mode=section 一起使用'), { code: 'INVALID_REQUEST' })
   }
+  // line 只表示"中心行"（around ±3）。它与全文起点共用过同一字段，导致照着续读提示
+  // 传 line 时落回 ±3 窗口、永远前进不到下一页；这里把歧义变成显式失败。
+  // 例外：line=1 与"从第 1 行读起"同义，是客户端补齐默认值时常见的无害占位，放行。
+  if (mode === 'document' && args.line !== undefined && Number(args.line) > 1) {
+    throw Object.assign(new Error(
+      'mode="document" 不接受 line（line 是上下文中心行号，around 模式默认前后各 3 行）。'
+      + `连续读取请改用 start_line，例如 ${JSON.stringify({ start_line: args.line, mode: 'document' })}。`,
+    ), { code: 'INVALID_REQUEST' })
+  }
+  if (mode !== 'document' && args.start_line !== undefined) {
+    throw Object.assign(new Error(
+      'start_line 只用于 mode="document" 的连续读取；查看某一行上下文请改用 line（around 模式）。',
+    ), { code: 'INVALID_REQUEST' })
+  }
   const selection = mode === 'document'
-    ? { mode, cursor: null, ...(args.line !== undefined ? { start_line: args.line } : {}) }
+    ? { mode, cursor: null, ...(args.start_line !== undefined ? { start_line: args.start_line } : {}) }
     : mode === 'section'
           ? { mode, section }
         : { mode: 'around', center_line: args.line,
           ...(args.before !== undefined ? { before_lines: args.before } : {}),
           ...(args.after !== undefined ? { after_lines: args.after } : {}) }
-  return {
+  return withContractNote({
     locator, selection,
     ...(expectedDataVersion ? { expected_data_version: expectedDataVersion } : {}),
     limits: { ...(args.max_lines !== undefined ? { max_lines: args.max_lines } : {}),
       ...(args.max_chars !== undefined ? { max_chars: args.max_chars } : {}) },
-  }
+  }, notes)
 }
 
 /** ---- 云端渲染（output.render 用，压缩为模型可读文本） ---- */
 
-function renderCloudSearch(_args, value) {
-  if (value.status === 'error') {
-    return [{ type: 'text', text: `[cloud_search:error] ${value.error.code}: ${value.error.message}` }]
-  }
-  return [{ type: 'text', text: projectCloudSearch(value) }]
+function renderCloudSearch(args, value) {
+  return [{ type: 'text', text: projectCloudSearch(value, { args }) }]
 }
 
 function renderCloudInspect(_args, value) {
-  if (value.status === 'error') {
-    return [{ type: 'text', text: `[cloud_inspect:error] ${value.error.code}: ${value.error.message}` }]
-  }
   return [{ type: 'text', text: JSON.stringify(projectCloudInspect(value)) }]
 }
 
@@ -868,7 +1019,7 @@ function renderCloudInspect(_args, value) {
  * @param {{
  *   releasesDir?: string,
  *   cacheShards?: number,
- *   uiSkin?: 'harness' | 'prts-agent',
+ *   uiSkin?: 'harness' | 'prts-agent' | 'endfield-aic' | 'rhine-lab',
  *   download?: { order?: ('modelscope'|'site')[], siteBaseUrl?: string },
  *   cloud?: { baseUrl?: string, game?: 'arknights' | 'endfield', userId?: string, token?: string, timeoutMs?: number, maxResponseBytes?: number },
  * }} [config]
@@ -958,6 +1109,25 @@ export async function apply(ctx, config = {}) {
     installArchivePtcReceipts(toolCtx, readPresentationMeta)
     // Host 的 preset 准入已经完成初始化；工具挂载不再触发下载或全量扫描。
     applyEntityRecognition(toolCtx, store, shared)
+    tools.register({
+      name: 'corpus_navigate',
+      description: NAVIGATION_DESCRIPTION,
+      parameters: NAVIGATION_PARAMETERS,
+      output: { schema: { type: 'object', additionalProperties: true }, render: renderNavigation },
+      timeoutMs: 60_000,
+      isConcurrencySafe: () => true,
+      presentCall: (args) => ({ card: 'generic', kind: 'search',
+        title: `终末地主线导航 · ${compactToolTitle(args?.query || '主线目录')}` }),
+      execute: async (rawArgs, exec) => {
+        await requireLocalCorpus(store)
+        const response = await executeNavigation(store, dropEmptyPlaceholders(rawArgs), {
+          signal: exec?.signal, allowedGames: shared.effective().enabledGames,
+        })
+        if (response.error) throw Object.assign(new Error(response.error.message), response.error)
+        return response
+      },
+    })
+
     tools.register({
       name: 'corpus_search',
       description: SEARCH_DESCRIPTION,
@@ -967,10 +1137,11 @@ export async function apply(ctx, config = {}) {
       isConcurrencySafe: () => true,
       presentCall: (args) => searchCallView('PRTS 本地资料', args,
         shared.effective().enabledGames),
-      execute: async (args, exec) => {
+      execute: async (rawArgs, exec) => {
         await requireLocalCorpus(store)
+        const args = dropEmptyPlaceholders(rawArgs)
         const snapshot = corpusVersionSnapshot(store)
-        const evidenceState = evidenceStates.forExecution(exec, store.dataVersion)
+        const evidenceState = evidenceStates.forExecution(exec, store.scopeFingerprint ?? store.dataVersion)
         const completedSearchCalls = evidenceState.completedSearchCalls
         const callId = String(exec?.callId || '')
         // 先做对象校验再做幂等哈希：JSON.stringify(undefined) 返回 undefined，
@@ -993,10 +1164,9 @@ export async function apply(ctx, config = {}) {
         const requestHash = createHash('sha256').update(JSON.stringify(scopedArgs)).digest('hex')
         if (callId && completedSearchCalls.has(callId)) {
           const cached = completedSearchCalls.get(callId)
-          if (cached.requestHash !== requestHash) return {
-            contract_version: 'prts-corpus-tools-v1', status: 'error', request_id: callId,
-            data_version: store.dataVersion ?? null,
-            error: { code: 'INVALID_REQUEST', message: 'callId 已绑定到另一个搜索请求', retryable: false },
+          if (cached.requestHash !== requestHash) {
+            throw Object.assign(new Error('callId 已绑定到另一个搜索请求'),
+              { code: 'INVALID_REQUEST', retryable: false })
           }
           assertCorpusVersion(store, snapshot)
           const replay = structuredClone(cached.response)
@@ -1032,23 +1202,29 @@ export async function apply(ctx, config = {}) {
       // 模型调用顺序独占执行并逐个提交结果。
       isConcurrencySafe: () => false,
       presentCall: (args) => readCallView(args, shared.effective().enabledGames),
-      execute: async (args, exec) => {
+      execute: async (rawArgs, exec) => {
         await requireLocalCorpus(store)
+        let { args, guidance: argumentGuidance } = normalizeReadArguments(rawArgs,
+          { sections: WIKI_SECTION_VALUES })
         const snapshot = corpusVersionSnapshot(store)
-        const evidenceState = evidenceStates.forExecution(exec, store.dataVersion)
+        const evidenceState = evidenceStates.forExecution(exec, store.scopeFingerprint ?? store.dataVersion)
         let contract
         try {
           contract = await modelReadToContract(args, store, shared.effective().enabledGames)
           assertCorpusVersion(store, snapshot)
+          const inferred = contractNotes.get(contract)
+          if (inferred) argumentGuidance = [argumentGuidance, inferred].filter(Boolean).join('\n')
         } catch (error) {
           assertCorpusVersion(store, snapshot)
           throw Object.assign(new Error(error.message),
             { code: error.code || 'INVALID_REQUEST', retryable: error.retryable ?? false })
         }
-        if (contract.expected_data_version !== undefined
-            && contract.expected_data_version !== store.dataVersion) {
-          throw Object.assign(new Error('续页所属资料版本与当前激活版本不一致，请重新读取'),
-            { code: 'PACKAGE_VERSION_MISMATCH', retryable: true })
+        if (contract.expected_data_version !== undefined) {
+          if (!dataVersionMatches(contract.expected_data_version, store.dataVersion)) {
+            throw Object.assign(new Error('续页所属资料版本与当前激活版本不一致，请重新读取'),
+              { code: 'PACKAGE_VERSION_MISMATCH', retryable: true })
+          }
+          contract.expected_data_version = store.dataVersion
         }
         // 证据覆盖按 Harness Agent 隔离；模型不感知 intent_id。
         contract.intent_id = evidenceState.intentId
@@ -1056,12 +1232,14 @@ export async function apply(ctx, config = {}) {
         normalizeReadRequest(contract)
         const requested = await resolveReadWindow(store, contract)
         assertCorpusVersion(store, snapshot)
-        const visibleResults = visibleToolResults(exec?.agent)
+        // reuse:false 时不参与"上文已可见"的判定：宿主 surface 与模型实际收到的内容
+        // 一旦不一致（外部压缩、跨请求折叠），去重就会静默少给行，宁可重发。
+        const visibleResults = args.reuse === false ? new Map() : visibleToolResults(exec?.agent)
         if (coveredRead(evidenceState, requested, visibleResults)) {
           const replay = replayCoveredRead(evidenceState, requested, contract)
           if (replay) {
             assertCorpusVersion(store, snapshot)
-            return projectReadToolValue(replay, store)
+            return withReadGuidance(projectReadToolValue(replay, store), argumentGuidance)
           }
         }
         const response = await executeRead(store, contract, { signal: exec?.signal })
@@ -1073,7 +1251,7 @@ export async function apply(ctx, config = {}) {
         }, visibleResults) : null
         const delivered = reuseReadCoverage(response, coveragePlan)
         rememberRead(evidenceState, delivered, { callId: String(exec?.callId || ''), store })
-        return projectReadToolValue(delivered, store)
+        return withReadGuidance(projectReadToolValue(delivered, store), argumentGuidance)
       },
     })
 
@@ -1112,7 +1290,8 @@ export async function apply(ctx, config = {}) {
           throw Object.assign(new Error('明日方舟资料当前未启用'), { code: 'INVALID_REQUEST' })
         }
         const snapshot = corpusVersionSnapshot(store)
-        const response = await executeTimelineSearch(store, args, { signal: exec?.signal })
+        const response = await executeTimelineSearch(store,
+          dropEmptyPlaceholders(args, { zeroFields: TIMELINE_ZERO_FIELDS }), { signal: exec?.signal })
         assertCorpusVersion(store, snapshot)
         return rememberArchivePresentation(response, timelineArchivePresentation(response))
       },
@@ -1146,9 +1325,10 @@ export async function apply(ctx, config = {}) {
         timeoutMs: 180_000,
         isConcurrencySafe: () => true,
         presentCall: (args) => searchCallView('PRTS 云端资料', args, c.enabledGames),
-        execute: async (args, exec) => {
+        execute: async (rawArgs, exec) => {
           try {
-            const evidenceState = evidenceStates.forExecution(exec, store.dataVersion)
+            const args = dropEmptyPlaceholders(rawArgs)
+            const evidenceState = evidenceStates.forExecution(exec, store.scopeFingerprint ?? store.dataVersion)
             const cloud = cloudClients.forExecution(exec)
             await cloud.capabilities({ signal: exec?.signal })
             const requestedGames = Array.isArray(args.games) ? args.games : c.enabledGames
@@ -1164,7 +1344,8 @@ export async function apply(ctx, config = {}) {
             rememberCloudMappings(evidenceState, enriched)
             return rememberArchivePresentation(enriched, cloudArchivePresentation(enriched, { dataVersion }))
           } catch (error) {
-            return cloudErrorResponse(error)
+            // 抛出交给宿主标记 isError，让 Agent 明确知道本次调用失败。
+            throw cloudFaultError(error, 'cloud_search')
           }
         },
       })
@@ -1180,9 +1361,11 @@ export async function apply(ctx, config = {}) {
         presentCall: (args) => ({ card: 'generic',
           title: `查看 PRTS 云端检索详情 · ${presentedGames(args, c.enabledGames)}`,
           kind: 'read', rawInput: compactToolTitle(args?.section || 'summary') }),
-        execute: async (args, exec) => {
+        execute: async (rawArgs, exec) => {
           try {
-            const evidenceState = evidenceStates.forExecution(exec, store.dataVersion)
+            const args = dropEmptyPlaceholders(rawArgs, { zeroFields: CLOUD_INSPECT_ZERO_FIELDS })
+            validateCloudInspectArgs(args)
+            const evidenceState = evidenceStates.forExecution(exec, store.scopeFingerprint ?? store.dataVersion)
             const cloud = cloudClients.forExecution(exec)
             await cloud.capabilities({ signal: exec?.signal })
             const payload = { ...args,
@@ -1195,7 +1378,7 @@ export async function apply(ctx, config = {}) {
               inspect: true, dataVersion: store.dataVersion,
             }))
           } catch (error) {
-            return cloudErrorResponse(error)
+            throw cloudFaultError(error, 'cloud_inspect')
           }
         },
       })
@@ -1217,7 +1400,7 @@ export async function apply(ctx, config = {}) {
     const handle = acquireInvestigationStore(investigationCtx.storageDomain)
     shared.investigations = handle.service
     investigationCtx.effect(() => () => { if (shared.investigations === handle.service) shared.investigations = null; return handle.release() }, 'prts: investigations')
-    if (enableTools) await investigationCtx.inject(['tools', 'systemPrompt'], toolCtx => mountInvestigationTools(toolCtx, handle.service))
+    if (enableTools) await investigationCtx.inject(['tools', 'systemPrompt'], toolCtx => mountInvestigationTools(toolCtx, handle.service, shared))
   })
   if (enableTools) await ctx.inject(['tools', 'systemPrompt'], async toolCtx => {
     mountWebGuidance(toolCtx)
@@ -1233,7 +1416,8 @@ export async function apply(ctx, config = {}) {
           storeEntry.releaseTimer = null
           try {
             const pointer = await readCurrentReleasePointer(releasesDir)
-            if (store.loaded && store.releaseId === pointer.release_id) return
+            if (store.loaded && store.releaseId === pointer.release_id
+                && store.installationId === (pointer.installation_id ?? null)) return
           } catch { /* 让 ready() 输出真实指针错误 */ }
           store.reset()
           prepareEntityRecognition(store).catch((error) => {