briefloop 0.27.0__tar.gz → 0.28.0__tar.gz

{briefloop-0.27.0 → briefloop-0.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: briefloop
-Version: 0.27.0
+Version: 0.28.0
 Summary: Local multi-runtime agent workbench for sourced briefings, independent review and skill learning
 Author: Stahl-G
 License-Expression: MIT
@@ -286,6 +286,8 @@ briefloop external --workspace "/absolute/workspace" request --file request.json
 
 详见 [外部 Agent 调用文档](docs/WorkBuddy外部入口.md)、[随包 Skill 与请求示例](src/briefloop/skill_assets/briefloop-external/SKILL.md)；官网提供 [调用指南](https://briefloop.ai/docs/external-agent.html)。
 
+下一版增加本机 stdio MCP 服务：客户端执行 `briefloop mcp --workspace "/absolute/workspace"`，即可发现与 external 相同的报告工具。启动时固定工作区路径和身份；不启动后台服务、不新增网络监听。配置示例、工具参数及异步查询方式见 [MCP 调用说明](docs/WorkBuddy外部入口.md#本机-stdio-mcp)。
+
 会议纪要内容方法：选择内置纪要模板即可建议相应用途，输入本次会议转写或笔记，整理决议、待办和未定事项。见 [会议纪要说明与合成材料](docs/会议纪要.md)。
 
 证券研究方法提供事件点评、公司研究和行业跟踪，按来源区分实际、预测与估值假设，使用有依据的数据生成图表。见 [证券研究说明与合成材料](docs/证券研究.md)。
@@ -327,7 +329,7 @@ npm test
 
 Reviewer 使用本任务固定核查包，在独立会话中返回结构化发现及处理说明的复核结果。设置可选**普通审阅**（默认）或**严格审阅**：普通模式通过 Codex、OpenCode 1.x/2.x 或 BriefLoop Agent 的实际只读通道执行，不承诺宿主自动加载的全局/项目上下文完全隔离；严格模式额外强制包内读取，目前由 BriefLoop Agent 的专用核查工具提供。选择严格模式不会自动降级或更换执行后端。两种模式使用相同的事实、证据及交付检查，新任务冻结实际模式，历史未记录模式的审阅不被补标为严格。
 
-工作稿Word下载保持可用。“正式交付”另行检查当前版本的独立审阅、重要主张及必答内容、核心未核验、重大未决发现和冲突；高分不能抵消阻断项。审计包单独导出，逐来源选择原件、摘录或仅定位，缺省仅定位；离线校验为结构与一致性检查，不是事实真伪自动证明。旧正式件保留，更正或后续更新另建版本。
+独立审阅可在任一执行引擎上运行：Codex、OpenCode 与内置引擎强制只读；Claude、Antigravity 等 CLI 宿主无法由 BriefLoop 关闭自带工具，审阅改用其原生权限运行，记录上标明“未强制只读”并列出宿主报告的工具使用。严格审阅仍只在内置引擎上执行。工作稿Word下载保持可用。“正式交付”另行检查当前版本的独立审阅、重要主张及必答内容、核心未核验、重大未决发现和冲突；高分不能抵消阻断项。审计包单独导出，逐来源选择原件、摘录或仅定位，缺省仅定位；离线校验为结构与一致性检查，不是事实真伪自动证明。旧正式件保留，更正或后续更新另建版本。
 
 存在受限来源时，无法逐来源归属的审阅、回应、历史与内部研究自由文本会明确省略；包中保留身份、状态、定位和获准的证据片段。正式报告本身仍随包提供。旧版受限包需重新导出以应用完整权限投影，旧版全原件包继续支持下载和离线校验。
 

{briefloop-0.27.0 → briefloop-0.28.0}/README.md

@@ -246,6 +246,8 @@ briefloop external --workspace "/absolute/workspace" request --file request.json
 
 详见 [外部 Agent 调用文档](docs/WorkBuddy外部入口.md)、[随包 Skill 与请求示例](src/briefloop/skill_assets/briefloop-external/SKILL.md)；官网提供 [调用指南](https://briefloop.ai/docs/external-agent.html)。
 
+下一版增加本机 stdio MCP 服务：客户端执行 `briefloop mcp --workspace "/absolute/workspace"`，即可发现与 external 相同的报告工具。启动时固定工作区路径和身份；不启动后台服务、不新增网络监听。配置示例、工具参数及异步查询方式见 [MCP 调用说明](docs/WorkBuddy外部入口.md#本机-stdio-mcp)。
+
 会议纪要内容方法：选择内置纪要模板即可建议相应用途，输入本次会议转写或笔记，整理决议、待办和未定事项。见 [会议纪要说明与合成材料](docs/会议纪要.md)。
 
 证券研究方法提供事件点评、公司研究和行业跟踪，按来源区分实际、预测与估值假设，使用有依据的数据生成图表。见 [证券研究说明与合成材料](docs/证券研究.md)。
@@ -287,7 +289,7 @@ npm test
 
 Reviewer 使用本任务固定核查包，在独立会话中返回结构化发现及处理说明的复核结果。设置可选**普通审阅**（默认）或**严格审阅**：普通模式通过 Codex、OpenCode 1.x/2.x 或 BriefLoop Agent 的实际只读通道执行，不承诺宿主自动加载的全局/项目上下文完全隔离；严格模式额外强制包内读取，目前由 BriefLoop Agent 的专用核查工具提供。选择严格模式不会自动降级或更换执行后端。两种模式使用相同的事实、证据及交付检查，新任务冻结实际模式，历史未记录模式的审阅不被补标为严格。
 
-工作稿Word下载保持可用。“正式交付”另行检查当前版本的独立审阅、重要主张及必答内容、核心未核验、重大未决发现和冲突；高分不能抵消阻断项。审计包单独导出，逐来源选择原件、摘录或仅定位，缺省仅定位；离线校验为结构与一致性检查，不是事实真伪自动证明。旧正式件保留，更正或后续更新另建版本。
+独立审阅可在任一执行引擎上运行：Codex、OpenCode 与内置引擎强制只读；Claude、Antigravity 等 CLI 宿主无法由 BriefLoop 关闭自带工具，审阅改用其原生权限运行，记录上标明“未强制只读”并列出宿主报告的工具使用。严格审阅仍只在内置引擎上执行。工作稿Word下载保持可用。“正式交付”另行检查当前版本的独立审阅、重要主张及必答内容、核心未核验、重大未决发现和冲突；高分不能抵消阻断项。审计包单独导出，逐来源选择原件、摘录或仅定位，缺省仅定位；离线校验为结构与一致性检查，不是事实真伪自动证明。旧正式件保留，更正或后续更新另建版本。
 
 存在受限来源时，无法逐来源归属的审阅、回应、历史与内部研究自由文本会明确省略；包中保留身份、状态、定位和获准的证据片段。正式报告本身仍随包提供。旧版受限包需重新导出以应用完整权限投影，旧版全原件包继续支持下载和离线校验。
 

{briefloop-0.27.0 → briefloop-0.28.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "briefloop"
-version = "0.27.0"
+version = "0.28.0"
 description = "Local multi-runtime agent workbench for sourced briefings, independent review and skill learning"
 readme = "README.md"
 requires-python = ">=3.11"

briefloop-0.28.0/src/briefloop/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.28.0"

{briefloop-0.27.0 → briefloop-0.28.0}/src/briefloop/bridge_harness.py

@@ -1,4 +1,4 @@
-from .execution_records import sanitize
+from .execution_records import sanitize, public_tool_name
 """Native CLI transports projected into the existing ChatStore, not another agent loop."""
 import base64
 import hashlib
@@ -239,7 +239,7 @@ class BridgeHarness(OpencodeHarness):
                 elif kind=='tool':
                     key=event.get('id') or uid('tool');tools[key]={**tools.get(key,{}),**event}
                     tool=tools[key];complete=tool.get('status') in ('completed','failed','error')
-                    item={'id':key,'type':'runtime_tool','tool':tool.get('name','工具'),'status':tool.get('status','running'),
+                    item={'id':key,'type':'runtime_tool','tool':public_tool_name(tool.get('name')),'status':tool.get('status','running'),
                           'input':sanitize(tool.get('input')), 'output':sanitize(tool.get('output'))}
                     self.chat.event(sid,'item/completed' if complete else 'item/started',{'item':item,'turnId':mid})
                     if complete:

{briefloop-0.27.0 → briefloop-0.28.0}/src/briefloop/chat_store.py

@@ -138,6 +138,11 @@ class ChatStore:
                         event['data']['tokenUsage']=project_usage(event['seq'],event['data'])
         if not private:
             for message in messages:message.pop('prompt',None)
+            from .execution_records import public_tool_name
+            for event in events:
+                item = event['data'].get('item') if isinstance(event['data'], dict) else None
+                if isinstance(item, dict) and item.get('type') == 'runtime_tool':
+                    item['tool'] = public_tool_name(item.get('tool'))
         if not reasoning:
             for message in messages:message.pop('reasoning',None)
         return {'session':session,'messages':messages,'events':events,'requests':requests,'token_usage':token_usage}

{briefloop-0.27.0 → briefloop-0.28.0}/src/briefloop/chat_tools.py

@@ -13,6 +13,15 @@ def _notify_owner(request):
     """Conversation that owns a task started from chat; never guessed."""
     return request.get('session_id') or os.environ.get('BRIEFLOOP_CHAT_SESSION') or None
 
+def _session_backend(store, session_id):
+    if not session_id:
+        return None
+    rows = store.rows('SELECT runtime FROM chat_sessions WHERE id=?', (session_id,))
+    try:
+        return json.loads(rows[0]['runtime']).get('backend') if rows else None
+    except (TypeError, ValueError):
+        return None
+
 WORKSPACE_ACTIONS = (
     'capabilities','source_snapshot','source_change','source_impacts','refresh_source',
     'set_reader_contract','conflict_create','conflict_response','review_response','review_status',
@@ -20,7 +29,7 @@ WORKSPACE_ACTIONS = (
     'revise_document','templates','workflows','template_rebuild','template_import','import_word_revision',
     'company_review_complete','company_read','company_config','company_update','company_resolve',
     'profile_read','profile_update',
-    'freeze_research_plan','research_status','begin_research_round','finish_research_round',
+    'freeze_research_plan','research_status','begin_research_round','finish_research_round','set_scout_tasks',
     'reconciliation_candidates','reconciliation_save','reconciliation_read',
     'export_word','inspect','generate','assess','comment','learn',
 )
@@ -143,6 +152,15 @@ def workspace_action(store, request):
     if action=='research_status':
         from .research_plan import status
         return status(store,request['run_id'])
+    if action=='set_scout_tasks':
+        from .scout_coverage import declare, update
+        if 'scout_tasks' in request:
+            result=declare(store,request['run_id'],request['scout_tasks'],round_id=request.get('round_id'))
+        if 'scout_outcomes' in request:
+            result=update(store,request['run_id'],request['scout_outcomes'],round_id=request.get('round_id'))
+        if 'scout_tasks' not in request and 'scout_outcomes' not in request:
+            raise ValueError('需要 scout_tasks 或 scout_outcomes')
+        return result
     if action=='freeze_research_plan':
         from .research_plan import freeze
         return freeze(store,request['run_id'],preset=request.get('preset'),structure=request.get('structure'))
@@ -151,7 +169,8 @@ def workspace_action(store, request):
         return begin_round(store,request['run_id'],target_gap_ids=request.get('target_gap_ids'),tasks=request.get('tasks'),job_id=request.get('job_id'))
     if action=='finish_research_round':
         from .research_plan import finish_round
-        return finish_round(store,request['run_id'],round_id=request.get('round_id'),gaps=request.get('gaps'),summary=request.get('summary',''),gap_updates=request.get('gap_updates'),job_id=request.get('job_id'))
+        return finish_round(store,request['run_id'],round_id=request.get('round_id'),gaps=request.get('gaps'),summary=request.get('summary',''),gap_updates=request.get('gap_updates'),job_id=request.get('job_id'),
+                            continue_research=request.get('continue_research') is True,early_stop_reason=str(request.get('early_stop_reason') or ''),scout_outcomes=request.get('scout_outcomes'))
     if action=='reconciliation_candidates':
         from .reconciliation import candidates
         return candidates(store,request['run_id'])
@@ -186,7 +205,12 @@ def workspace_action(store, request):
         runtime_payload={}
         if request.get('runtime'):
             from .backends import validate_backend
-            backend=validate_backend(request['runtime'].get('agent_backend',store.settings().get('agent_backend','codex')))
+            # A model name only means something on its own engine. Without an explicit
+            # engine, use the engine of the conversation that sent this model, never the
+            # workspace default (a Claude chat once produced "Antigravity · opus").
+            backend=request['runtime'].get('agent_backend') or _session_backend(store,_notify_owner(request)) \
+                or store.settings().get('agent_backend','codex')
+            backend=validate_backend(backend)
             settings=Settings.model_validate({**store.settings(),**request['runtime'],'agent_backend':backend})
             runtime_payload={'runtime':runtime_fields(settings.model_dump(),backend),'agent_backend':backend}
         run=store.create_run(requirements.model_dump(),source_ids,research_protocol="quality_v1",
@@ -261,8 +285,9 @@ def chat_instructions(store, runtime, *, internal=False, allow_web=False, backen
                 subagent_note=(OPENCODE_V2_SUBAGENT+'优先不传 model override，继承当前已冻结模型和推理档位；不要启动嵌套模型 CLI。'
                     '宿主 question 工具不可用；需要澄清时直接在聊天回复中提问，用户下一条消息会继续本任务。')
     else:
-        request_runtime={'model':runtime['model'],'reasoning_effort':runtime.get('effort'),
+        request_runtime={'agent_backend':backend,'model':runtime['model'],'reasoning_effort':runtime.get('effort'),
                          'model_provider':runtime.get('model_provider')}
+        if backend=='codex':request_runtime['service_tier']=runtime.get('service_tier')
         runtime_json=json.dumps(request_runtime,ensure_ascii=False)
         runtime_label=runtime.get('effort') if runtime.get('effort') is not None else '不指定（provider 默认）'
         provider_label=runtime.get('model_provider') or f'沿用本机 {BACKEND_LABELS[backend]} 配置'
@@ -301,9 +326,10 @@ def chat_instructions(store, runtime, *, internal=False, allow_web=False, backen
 - {{"action":"profile_read"}}：读取本工作区基础设定（称呼、公司/组织、岗位等）。
 - {{"action":"profile_update","profile":{{"name":"称呼","organization":"公司/组织","role":"岗位","location":"城市","focus":"主要工作","report_types":"常做报告"}}}}：按上文约定保存用户主动提供或任务确有必要的基础信息；只写用户明确说过的内容，不猜、不编造，也不把这些当作报告证据。
 - {{"action":"research_status","run_id":"真实run ID"}}：读取该任务冻结的研究计划、轮次与用量。
+- {{"action":"set_scout_tasks","run_id":"真实run ID","scout_tasks":[{{"slot_id":"scout-1","assignment":"明确研究方向","result_file":"本轮结果绝对路径"}}]}}：派发前登记完整承诺分工，与 plan.json.scout_tasks 相同；空计划明确写 []。预分配槽位不是承诺。分工不可静默删除；可追加新分工。实际派发后可用同 action 的 scout_outcomes=[{{"slot_id":"scout-1","status":"dispatched","reason":"真实子任务句柄"}}] 记录派发。join-scouts 自动接纳有效结果。
 - {{"action":"freeze_research_plan","run_id":"真实run ID","preset":"quick|standard|deep","structure":{{"breadth":6,"depth":2,"parallel":2}}}}：在第一次受控联网前冻结研究计划。预算只读取任务已授权的额度，不能借冻结扩大额度或替换模型/搜索源；相同内容重复提交幂等，不同内容会被拒绝。
 - {{"action":"begin_research_round","run_id":"真实run ID","target_gap_ids":["真实gap ID"],"tasks":[{{"slot_id":"scout-1"}}]}}：在当前轮已结束、且未超过 depth 上限时开始下一轮；必须引用前轮真实缺口 ID。
-- {{"action":"finish_research_round","run_id":"真实run ID","gaps":[{{"description":"真实缺口","source_ids":[],"related_claim_ids":[],"requirement_ids":[]}}],"summary":"本轮结论"}}：结束当前轮并生成真实 gap ID；可选 gap_updates 明确变更已登记缺口状态，每项 gap_id/status(open|partial|resolved)/reason/evidence（source_id/locator/excerpt，partial/resolved 至少一条，open 可为空），partial 另填 remaining_question；covered 不会关闭缺口。之后才能 begin 下一轮。
+- {{"action":"finish_research_round","run_id":"真实run ID","gaps":[{{"description":"真实缺口","source_ids":[],"related_claim_ids":[],"requirement_ids":[]}}],"summary":"本轮结论"}}：结束当前轮并生成真实 gap ID；每个已承诺 Scout 分工须已 join，或在 scout_outcomes 中明确 slot_id、status=failed|skipped、reason，保留未检范围；不必用满槽位、预算或后续轮次。可选 gap_updates 明确变更已登记缺口状态，每项 gap_id/status(open|partial|resolved)/reason/evidence（source_id/locator/excerpt，partial/resolved 至少一条，open 可为空），partial 另填 remaining_question；covered 不会关闭缺口。还要继续检索时带 "continue_research":true；只完成第 1 轮且受控搜索额度用了不到一半就结束研究时，必须带 "early_stop_reason" 说明为何已覆盖本期重要事件，否则会被拒绝。之后才能 begin 下一轮。
 - {{"action":"reconciliation_candidates","run_id":"真实run ID"}}：读取本任务冻结的候选清单（来源与来源陈述），用于写作前对照。
 - {{"action":"reconciliation_save","run_id":"真实run ID","reconciliation":{{"status":"complete|partial|not_applicable|failed","examined_claim_ids":[],"unexamined_claim_ids":[],"relations":[{{"member_claim_ids":["真实claim ID","真实claim ID"],"relation":"compatible|different_scope|temporal_sequence|correction|supersession|republication|attributed_difference|contradiction|unknown","scope":"","basis_span_ids":[],"reason":"","proposed_treatment":"","affected_requirement_ids":[]}}],"open_questions":[],"coverage_notes":""}}}}：保存写作前对照快照。必须用 examined ∪ unexamined 明确覆盖候选清单全部来源陈述；关系必须引用真实来源陈述；不判定真假，只登记依据与建议写法。重复相同内容幂等。
 - {{"action":"reconciliation_read","run_id":"真实run ID","reconciliation_id":"真实对照ID"}}：读取对照快照；输入变化时返回 stale 标记。
@@ -311,7 +337,7 @@ def chat_instructions(store, runtime, *, internal=False, allow_web=False, backen
 - {{"action":"templates"}}：读取可选模板。用户要求上传材料用作主模板时用 {{"action":"template_import","source_id":"DOCX来源ID"}} 启动一次准备；准备完成后 generate.requirements.template_id 选择具体版本。需要重新准备已有模板版式时，用 {{"action":"template_rebuild","template_id":"已有模板ID"}} 从保留原件创建新模板版本；原模板和已绑定稿件保持不变，新任务选择返回的新模板ID。
 - {{"action":"read_report","version_id":"稿件ID"}}：读取富文档 JSON、引用和已存正文的 length_stats；revise_document 回执也给出保存后的确定性计数。按 count/rule 核对原始要求、读者约定及当前反馈，不估算字数；over_limit 只比较结构化 max_words，不表示已满足全部篇幅要求。用户明确要求修改内容/章节/图表时，将修改后的 JSON 保存到工作区文件，再用 {{"action":"revise_document","base_version":"刚读取版本ID","document_file":"工作区内JSON绝对路径"}} 保存新版本，不覆盖用户并发编辑。可选 citations 完整替换引用列表（source_id/locator/excerpt，schema 见 capabilities），省略则保留；只修改引用也保存新版本，定位描述不表示已独立核验。
 - {{"action":"import_word_revision","base_version":"用户指定基础版本","source_id":"DOCX来源ID"}}：导入用户修改的 Word。返回 needs_alignment 时先核对原件和基础版本，向用户说明对齐问题；仅按用户明确选择提供 accept_unaligned=true。用户希望更新模板时另用 template_import 并提供 parent_id。
-- {{"action":"generate","requirements":{{"title":"标题","objective":"用户目的","audience":"读者","language":"zh|en","extent":"compact|balanced|detailed","research_tier":"quick|standard|deep","allow_web":{str(bool(allow_web)).lower()},"period":"时间范围"}},"source_ids":["真实来源ID"],"runtime":{runtime_json}}}：正式生成可在页面编辑的简报。language 是报告正文语言（默认 zh）；用户要英文报告时写 en，不传 target_words 时篇幅按英文词数默认。research_tier 是研究深度档位（默认 standard）：quick 单轮检索，deep 预排 4 轮迭代研究；按用户明确要求选，用户未提就不写该字段。
+- {{"action":"generate","requirements":{{"title":"标题","objective":"用户目的","audience":"读者","language":"zh|en","extent":"compact|balanced|detailed","research_tier":"quick|standard|deep","allow_web":{str(bool(allow_web)).lower()},"period":"时间范围"}},"source_ids":["真实来源ID"],"runtime":{runtime_json}}}：正式生成可在页面编辑的简报。language 是报告正文语言（默认 zh）；用户要英文报告时写 en，不传 target_words 时篇幅按英文词数默认。research_tier 是研究深度档位（默认 standard）：quick 单轮检索，deep 预排 4 轮迭代研究；按用户明确要求选，用户未提就不写该字段。scout_limit 是本报告最多可同时派发的 Scout 数（1–16），在提交前按信息量决定：一周左右约 4，月报约 8，跨多个行业或市场的大型报告可到 12–16；不写时系统按期间自动设定（月报 8，其余沿用工作区设置）。
 提交 generate 时，必须把本轮已经确认的 key_questions、writing_preferences、章节、期间和篇幅完整写进 requirements，不能只传标题摘要。用户给出的执行约束同样在提交前冻结：target_minutes 是软目标；hard_timeout_minutes=0 表示不设硬截止；research_budget 包含 search_requests、candidate_urls、source_pages；search_policy 沿用已授权设置。不得说“后台稍后配置”而遗漏已指定的额度。并行数要求写入 writing_preferences，供主 Agent 冻结研究计划时选择 structure.parallel；不改变共享预算。提交回执中的实际冻结值与用户要求不一致时明确说明，不宣称已应用。
 - {{"action":"assess","version_id":"真实简报版本ID"}}：为已有稿件安排评分。
 - {{"action":"comment","version_id":"真实简报版本ID","text":"用户反馈"}}：记录用户明确提出的反馈。页面自动学习开启时，保存反馈可能稍后自动触发学习，要如实告知。

{briefloop-0.27.0 → briefloop-0.28.0}/src/briefloop/cli.py

@@ -51,6 +51,8 @@ def main():
     er.add_argument('--file',required=True,help='UTF-8 JSON 请求文件')
     ed=es.add_parser('download',help='下载指定已完成导出任务的Word，不覆盖不同内容的文件')
     ed.add_argument('--job',required=True);ed.add_argument('--output',required=True)
+    mcp=sub.add_parser('mcp',help='stdio MCP 服务；只连接用户选定的现有本机工作区')
+    mcp.add_argument('--workspace',required=True,help='已选择工作区的绝对路径；不自动创建或启动服务')
     tool=sub.add_parser('tool',help='agent 使用的来源工具')
     tool.add_argument('--workspace',required=True)
     ts=tool.add_subparsers(dest='tool',required=True)
@@ -136,6 +138,12 @@ def main():
             print(json.dumps(result,ensure_ascii=False))
         except (OSError,ValueError,KeyError,http.client.HTTPException) as exc:
             p.exit(2,json.dumps({'status':'error','message':sanitize(str(exc))},ensure_ascii=False)+'\n')
+    elif a.command=='mcp':
+        from .external_mcp import serve as serve_mcp
+        try:serve_mcp(a.workspace)
+        except ValueError as exc:
+            from .execution_records import sanitize
+            p.exit(2,sanitize(str(exc))+'\n')
     elif a.command=='serve':
         from .server import serve
         serve(a.workspace,a.port,paused=a.paused,backend=a.backend)

{briefloop-0.27.0 → briefloop-0.28.0}/src/briefloop/deliverable_spec.py

@@ -212,8 +212,10 @@ def instructions(spec, role='analyst', *, include_spec=True):
 
 def research_record(store, brief):
     detail = json.loads(brief['detail']); refs = detail.get('citations', [])
+    from .plain_isolation import public_notes
+    notes = public_notes(detail.get('research_notes', []))
     return {'version_id': brief['id'], 'brief_hash': brief['hash'],
-            'notes': detail.get('research_notes', []), 'gaps': detail.get('gaps', []),
+            'notes': notes, 'gaps': detail.get('gaps', []),
             'citations': [{**ref, 'source_name': store.one('sources', ref['source_id'])['name']} for ref in refs],
             'assessments': [json.loads(x['data']) for x in store.rows('SELECT data FROM assessments WHERE version_id=? ORDER BY rowid DESC', (brief['id'],))]}
 

{briefloop-0.27.0 → briefloop-0.28.0}/src/briefloop/execution_records.py

@@ -15,6 +15,23 @@ _SECRET_HEADER=re.compile(r'''(?im)(?<![\w-])((?:proxy[-_])?authorization|(?:set
 _SECRET_ENV=re.compile(r'''(?ix)(["']?\b(?:[a-z0-9]+_)*(?:authorization|cookie)["']?\s*=\s*)(?:\[credential[ ]omitted\]|"[^"\n]*"|'[^'\n]*'|[^\s,;&}\]]+)''')
 _PRIVATE_KEY=re.compile(r'-----BEGIN (?:[A-Z ]+)?PRIVATE KEY-----.*?-----END (?:[A-Z ]+)?PRIVATE KEY-----',re.S)
 
+# ACP "names" can be entire commands, paths or arbitrary host descriptions.
+# Only exact known identifiers belong in compact public tool summaries.
+_PUBLIC_TOOLS = frozenset('''Read Write Edit MultiEdit Bash Glob Grep LS NotebookEdit TodoWrite Task Agent WebFetch WebSearch
+read write edit bash glob grep find ls task subagent shell search_web web_search webfetch websearch
+read_file write_file edit_file list_directory read_many_files execute_command run_command
+commandExecution command_execution fileChange mcpToolCall dynamicToolCall collabAgentToolCall
+collab_tool_call imageView webSearch runtime_tool opencode_tool subagent_activity'''.split())
+_OTHER_TOOL = '其他宿主工具'
+
+
+def public_tool_name(value):
+    return value if isinstance(value, str) and value in _PUBLIC_TOOLS else _OTHER_TOOL
+
+
+def public_tool_names(values):
+    return sorted({public_tool_name(value) for value in values}) if isinstance(values, list) else []
+
 
 def _secret_field(key, value):
     name = re.sub(r'([a-z0-9])([A-Z])', r'\1_\2', str(key)).lower()

{briefloop-0.27.0 → briefloop-0.28.0}/src/briefloop/external_client.py

@@ -10,6 +10,13 @@ from urllib.parse import urlsplit, urlencode
 from .workspaces import _workspace_id, _validated_info, _alive, _read_api
 
 
+class RequestError(ValueError):
+    """HTTP status without reflecting the server's possibly input-bearing error."""
+    def __init__(self, status):
+        self.status = status
+        super().__init__(f'外部请求失败 (HTTP {status})')
+
+
 def discover(workspace):
     root = Path(workspace).expanduser().resolve()
     wid = _workspace_id(root) if root.is_dir() else None
@@ -22,13 +29,19 @@ def discover(workspace):
     if urlsplit(info['url']).hostname != '127.0.0.1':
         return {**result, 'status': 'service_unavailable', 'message': '工作区未使用受支持的本地服务地址'}
     try:
+        caps = _read_api(info['url'], '/api/external/capabilities')
+        if caps.get('protocol') != 1:
+            return {**result, 'status': 'unsupported', 'message': '此版本未提供外部任务接口'}
+        service_path = caps.get('workspace_path')
+        if (not isinstance(service_path, str) or not Path(service_path).is_absolute()
+                or Path(service_path).resolve() != root or caps.get('workspace_id') != wid):
+            return {**result, 'status': 'identity_changed', 'message': '服务与选定工作区的路径或身份不匹配，未连接'}
+        # Verify only the narrow identity response before reading runtime/task
+        # state or obtaining a session token from a possibly copied service URL.
         runtime = _read_api(info['url'], '/api/runtime')
         status = _read_api(info['url'], '/api/service-status')
-        caps = _read_api(info['url'], '/api/external/capabilities')
         if runtime.get('server_pid') != info['pid'] or status.get('pid') != info['pid'] or status.get('workspace_id') != wid:
             return {**result, 'status': 'identity_changed', 'message': '服务与工作区身份不匹配，未连接'}
-        if caps.get('protocol') != 1:
-            return {**result, 'status': 'unsupported', 'message': '此版本未提供外部任务接口'}
         ready = bool(runtime.get('worker_alive')) and not status.get('draining')
         return {**result, 'url': info['url'], 'pid': info['pid'], 'ready': ready,
                 'status': 'ready' if ready else 'not_ready', 'capabilities': caps}
@@ -60,7 +73,7 @@ class Client:
                 raise ValueError('响应过大；请通过 BriefLoop 页面读取报告')
             value = json.loads(data)
             if response.status != 200:
-                raise ValueError(value.get('error', '外部请求失败') + f' (HTTP {response.status})')
+                raise RequestError(response.status)
             return value
         finally:
             connection.close()

briefloop-0.28.0/src/briefloop/external_mcp.py

@@ -0,0 +1,177 @@
+"""Stdio MCP adapter to the existing, authenticated local external client.
+
+No Store, Worker, credentials, model calls or HTTP listener live in this process.
+The selected canonical path and durable workspace identity cannot be changed by
+tool arguments or by replacing the workspace while a client is connected.
+"""
+import http.client
+import json
+from pathlib import Path
+
+import anyio
+from jsonschema import Draft202012Validator
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+from mcp.types import CallToolResult, ListToolsResult, TextContent, Tool, ToolAnnotations
+
+from . import __version__
+from .external_client import Client, RequestError, discover
+from .external_requests import FIELDS, MUTATIONS
+from .workspaces import _workspace_id
+
+
+ID = {'type': 'string', 'minLength': 1}
+REQUEST_ID = {'type': 'string', 'pattern': r'^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$'}
+PROPERTIES = {
+    'source_id': ID, 'job_id': ID, 'version_id': ID, 'base_version': ID,
+    'requirements': {'type': 'object'}, 'editor_document': {'type': 'object'},
+    'source_ids': {'type': 'array', 'items': ID},
+}
+DESCRIPTIONS = {
+    'discover': '检查启动时选定工作区的现有服务和能力；不创建或启动服务。',
+    'inspect': '列出选定工作区最近 100 个来源和 20 个稿件；返回真实 ID。',
+    'source': '读取指定来源正文和出处。source_id 必须来自该工作区。',
+    'submit': '提交报告，立即返回 job_id/run_id；用 query 查进度。沿用工作区模型、企业背景与需求规则。每次新写操作使用稳定 request_id；响应丢失仅重发原 ID 和原内容。',
+    'query': '查询原 job_id 的实际状态、安全错误、版本和 Word 文件可用性；不重建失败任务。latest_version_id 可来自后续修订。',
+    'read': '读取精确 version_id 的 Markdown 和完整 editor_document。',
+    'revise': '保存 base_version 的完整 editor_document 为新版本，保留图表、引用和未修改节点；已有新版本时报冲突。用稳定 request_id 重试原内容。',
+    'export': '排队生成明确 version_id 的 Word 工作稿，立即返回 job_id；query 至 artifact_available=true 后 download。不代表正式交付审核通过。用稳定 request_id 重试原内容。',
+    'download': '将已完成导出 job_id 的 Word 保存到明确 output 文件路径；父目录须已存在。校验 SHA256、复用相同文件，不覆盖不同内容，不重新排队。',
+}
+
+
+class WorkspaceUnavailable(ValueError):
+    pass
+
+
+def failure(code, message):
+    return {'status': 'error', 'code': code, 'message': message}
+
+
+def request_failure(status):
+    if status == 409:
+        return failure('conflict', '稿件已有更新或 request_id 已用于不同内容；请核对原请求，并重新读取最新版本后合并修订')
+    if status == 400:
+        return failure('invalid_request', '请求参数或报告配置不符合要求；请检查需求、来源 ID、完整富文档及工作区设置')
+    if status == 403:
+        return failure('access_denied', '本地服务拒绝鉴权；请重新连接用户选定的工作区')
+    if status == 503:
+        return failure('service_unavailable', '本地服务尚未就绪或正在停止接收任务；请查询原任务，不自动重建')
+    return failure('request_failed', '本地服务请求失败；写操作结果可能未知，请保留原 request_id 和原内容重试')
+
+
+def tools():
+    catalog = []
+    for action, description in DESCRIPTIONS.items():
+        if action == 'download':
+            properties = {'job_id': ID, 'output': {'type': 'string', 'minLength': 1}}
+            required = list(properties)
+        else:
+            fields = FIELDS.get(action, set())
+            properties = {field: PROPERTIES[field] for field in sorted(fields)}
+            required = sorted(fields - ({'source_ids'} if action == 'submit' else set()))
+            if action in MUTATIONS:
+                properties['request_id'] = REQUEST_ID
+                required.append('request_id')
+        catalog.append(Tool(
+            name='briefloop_' + action, description=description,
+            input_schema={'type': 'object', 'properties': properties,
+                          'required': required, 'additionalProperties': False},
+            annotations=ToolAnnotations(
+                read_only_hint=action not in MUTATIONS | {'download'},
+                destructive_hint=False, idempotent_hint=True,
+                # Only submit can invoke models or research outside this
+                # workspace. Revise saves as author=agent, without learning.
+                open_world_hint=action == 'submit',
+            ),
+        ))
+    return catalog
+
+
+class WorkspaceAdapter:
+    def __init__(self, workspace):
+        path = Path(workspace).expanduser()
+        if not path.is_absolute():
+            raise ValueError('--workspace 必须是用户选定工作区的绝对路径')
+        self.root = path.resolve()
+        self.workspace_id = _workspace_id(self.root) if self.root.is_dir() else None
+
+    def discovery(self):
+        info = discover(self.root)
+        if info.get('workspace_id') != self.workspace_id:
+            return {'path': str(self.root), 'workspace_id': self.workspace_id,
+                    'ready': False, 'status': 'identity_changed',
+                    'message': '工作区身份已变化；请重新启动 MCP 连接到用户选择的工作区'}
+        return info
+
+    def invoke(self, action, arguments):
+        if action == 'discover':
+            return self.discovery()
+        if not self.workspace_id:
+            raise WorkspaceUnavailable()
+        try:
+            client = Client(self.root)
+        except ValueError:
+            raise WorkspaceUnavailable() from None
+        if client.info['workspace_id'] != self.workspace_id:
+            raise WorkspaceUnavailable()
+        if action == 'download':
+            return client.download(arguments['job_id'], arguments['output'])
+        return client.request({'action': action, 'workspace_id': self.workspace_id, **arguments})
+
+
+def create_server(workspace):
+    adapter = WorkspaceAdapter(workspace)
+    catalog = tools()
+    validators = {tool.name: Draft202012Validator(tool.input_schema) for tool in catalog}
+    limiter = anyio.CapacityLimiter(4)
+
+    async def list_tools(context, params):
+        return ListToolsResult(tools=catalog)
+
+    async def call_tool(context, params):
+        arguments = params.arguments if params.arguments is not None else {}
+        validator = validators.get(params.name)
+        # Never echo invalid arguments (which may contain credential-shaped
+        # values), validation traces or internal exception details to clients.
+        if validator is None:
+            value = failure('unknown_tool', '未知 BriefLoop 工具')
+            failed = True
+        elif not validator.is_valid(arguments):
+            value = failure('invalid_arguments', '工具参数不符合公布的 schema；不得传入其他工作区或服务地址')
+            failed = True
+        else:
+            try:
+                action = params.name.removeprefix('briefloop_')
+                value = await anyio.to_thread.run_sync(adapter.invoke, action, arguments, limiter=limiter)
+                failed = False
+            except WorkspaceUnavailable:
+                value = failure('workspace_unavailable', '选定工作区服务尚未就绪，或服务路径/身份不匹配；请在 BriefLoop 打开用户选定的工作区后重新连接')
+                failed = True
+            except RequestError as exc:
+                value = request_failure(exc.status)
+                failed = True
+            except (OSError, http.client.HTTPException):
+                value = failure('local_io_failed', '本地服务通信或文件操作失败；写操作结果可能未知，请使用原 request_id 和原内容重试')
+                failed = True
+            except (ValueError, KeyError):
+                value = failure('invalid_request', '请求、完整富文档或下载目标不符合要求；请检查指定 ID、父目录及目标文件，不覆盖不同内容')
+                failed = True
+            except Exception:
+                value = failure('request_failed', '本地外部请求失败；写操作结果可能未知，请用原 request_id 和原内容重试，勿新建任务')
+                failed = True
+        return CallToolResult(content=[TextContent(type='text', text=json.dumps(value, ensure_ascii=False))],
+                              structured_content=value, is_error=failed)
+
+    return Server('BriefLoop', version=__version__, on_list_tools=list_tools, on_call_tool=call_tool,
+                  instructions='仅操作启动时用户选定的本机工作区。先 discover 确认 ready，再 inspect/source。写操作保留原 request_id 与完整请求；submit/export 返回 job_id 后查询，不等待模型生成。修订先读取精确版本、保留完整富文档；Word 是指定版本的工作稿。MCP 取消或断开不取消已接收的后台任务；重连后查询原任务。')
+
+
+def serve(workspace):
+    server = create_server(workspace)
+
+    async def run():
+        async with stdio_server() as (read, write):
+            await server.run(read, write, server.create_initialization_options())
+
+    anyio.run(run)

{briefloop-0.27.0 → briefloop-0.28.0}/src/briefloop/external_requests.py

@@ -51,9 +51,10 @@ class _RequestStore(Store):
         return [dict(row) for row in self.connection.execute(query, args)]
 
 
-def capabilities():
+def capabilities(store):
     return {'protocol': 1, 'actions': list(FIELDS), 'request_id_required': sorted(MUTATIONS),
-            'export_kind': 'working_draft', 'starts_service': False}
+            'export_kind': 'working_draft', 'starts_service': False,
+            'workspace_path': str(store.root.resolve()), 'workspace_id': store.meta('workspace_id')}
 
 
 def _operation(store, action, body):

{briefloop-0.27.0 → briefloop-0.28.0}/src/briefloop/fast_reports.py

@@ -55,8 +55,18 @@ def _plain_turn(worker, job, folder, prompt, *, phase=None):
     (folder / 'packet').mkdir(exist_ok=True)
     task = {**job, 'allow_web': False, 'plain_output': 'response.txt', 'plain_phase':phase, 'input_source_ids': [],
             'native_packet': {'role': 'quick_writer', 'run_id': json.loads(job['payload'])['run_id']}}
-    return worker.runtime.execute(task, prompt, folder,
-                                  resume_on_complete=int(json.loads(job['payload']).get('attempt',1))>1)
+    result = worker.runtime.execute(task, prompt, folder,
+                                    resume_on_complete=int(json.loads(job['payload']).get('attempt',1))>1)
+    from . import plain_isolation
+    isolation = plain_isolation.record(json.loads(job['payload']).get('agent_backend', 'codex'), folder)
+    worker.store.event(job['id'], 'plain_isolation', {'phase': phase or folder.name, **isolation,
+                                                       'message': plain_isolation.summary(isolation)})
+    return result
+
+
+def _isolation(folder):
+    path = folder / 'isolation.json'
+    return json.loads(path.read_text(encoding='utf-8')) if path.exists() else None
 
 
 def _response(folder):
@@ -126,6 +136,10 @@ def generate(worker, job):
         data = {'title': req['title'], 'editor_document': markdown_document(text),
                 'citations': [{'source_id': aliases[a]['source_id']} for a in sorted(cited)],
                 'research_notes': [{'kind': 'fast_draft', 'summary': '一轮聚焦检索后根据已读取原文写作；未做完整事实核查，依据定位与评价在后台继续。' if research else '直接依据已有材料写作；未联网补搜，依据定位与评价在后台继续。'}]}
+        isolation = _isolation(folder / 'fast-writing')
+        if isolation:
+            from .plain_isolation import summary
+            data['research_notes'].append({'kind': 'fast_isolation', 'summary': summary(isolation), **isolation})
         if research:
             data['research_notes'].append({'kind':'fast_web_gaps','summary':'本次搜索与读取记录','gaps':research['gaps'],'reading_notices':research.get('notices',[]),
                                            'questions_before_reading':research.get('questions_before_reading',[])})
@@ -159,7 +173,8 @@ def enrich(worker, job, brief, folder):
         raise Conflict('材料与快速写作时的原文不同，请使用当前材料新建任务。')
     phase = folder / 'evidence'
     prompt = ('核对已保存报告，为重要结论补原文定位。不要改写正文，不搜索、不调用工具、不生成新的报告。'
-              '只返回一个 JSON 对象，包含 citations 数组及 number_bindings 数组；没有可定位依据时留空，不猜测。'
+              '只返回一个 JSON 对象，包含 citations、number_bindings 和 unsupported 三个数组；没有可定位依据时留空，不猜测。'
+              'unsupported 列出正文中在全部来源里找不到依据的重要结论，每条给 report_quote（正文连续原句）和 reason；不要因措辞概括而列入。'
               '每条 citation 使用 source_id（下方来源别名，如 S1）、report_quote（正文连续原句）、excerpt（连续逐字原文）。'
               'report_quote 必须能在报告正文中逐字找到；摘录应包含对应的主体、期间、单位及限定条件，不能用同来源的无关段落充数。'
               '无需猜行号；同一摘录在来源中重复时提供更长的唯一摘录。来源标题及相邻上下文由程序从冻结原文补入。'
@@ -212,8 +227,19 @@ def enrich(worker, job, brief, folder):
     details = {key:value for key,value in json.loads(brief['detail']).items() if key in BriefDraft.model_fields}
     details['citations'] = citations + [c for c in details.get('citations', []) if c['source_id'] not in {r['source_id'] for r in citations}]
     details['number_bindings'] = numbers
+    # Claims the materials do not cover. Mostly a slip in an enforced turn; in an
+    # observed turn it is where outside information the CLI brought in shows up.
+    unsupported = [{'report_quote': item['report_quote'], 'reason': str(item.get('reason', ''))[:500]}
+                   for item in (data.get('unsupported') if isinstance(data.get('unsupported'), list) else [])[:30]
+                   if isinstance(item, dict) and isinstance(item.get('report_quote'), str)
+                   and item['report_quote'].strip() and item['report_quote'] in brief['markdown']]
     details.setdefault('research_notes', []).append({'kind': 'fast_evidence', 'summary': '逐字定位已检查；支持关系仍需评价。', 'rejected': rejected})
-    (phase / 'admission.json').write_text(dump({'citations': citations, 'number_bindings': numbers, 'rejected': rejected}), encoding='utf-8')
+    if unsupported:
+        details['research_notes'].append({'kind': 'fast_unsupported', 'summary': '以下结论在所选材料中找不到原文依据，需核实或删除。', 'items': unsupported})
+        store.event(job['id'], 'fast_unsupported', {'version_id': brief['id'], 'count': len(unsupported),
+                                                    'message': f'{len(unsupported)} 条结论在所选材料中找不到原文依据，已单独列出。'})
+    (phase / 'admission.json').write_text(dump({'citations': citations, 'number_bindings': numbers, 'rejected': rejected,
+                                                'unsupported': unsupported}), encoding='utf-8')
     if worker.runtime.cancelled.is_set() or worker.stopping.is_set():
         raise InterruptedError('依据补全已停止，初稿和结果保留。')
     from .draft_completion import verify_input

briefloop-0.28.0/src/briefloop/feedback_view.py

@@ -0,0 +1,12 @@
+"""Bounded feedback history with persisted job status and workspace-wide counts."""
+
+
+def snapshot(store):
+    # batch_id is the learning job's primary key, not a position in recent jobs.
+    # At most 100 indexed joins; never scan/parse job payloads per feedback item.
+    items = store.rows("SELECT f.*, j.status AS learning_status FROM feedback f "
+                       "LEFT JOIN jobs j ON j.id=f.batch_id AND j.kind='learn' "
+                       "ORDER BY f.rowid DESC LIMIT 100")
+    counts = store.rows("SELECT count(*) AS total, "
+                        "count(CASE WHEN batch_id IS NULL THEN 1 END) AS pending FROM feedback")[0]
+    return {'feedback': items, 'feedback_summary': counts}