briefloop 0.27.0__tar.gz → 0.27.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: briefloop
-Version: 0.27.0
+Version: 0.27.1
 Summary: Local multi-runtime agent workbench for sourced briefings, independent review and skill learning
 Author: Stahl-G
 License-Expression: MIT
@@ -327,7 +327,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.27.1}/README.md

@@ -287,7 +287,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.27.1}/pyproject.toml

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

briefloop-0.27.1/src/briefloop/__init__.py

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

{briefloop-0.27.0 → briefloop-0.27.1}/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.27.1}/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.27.1}/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.27.1}/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.27.1}/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.27.1}/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.27.1/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}

briefloop-0.27.1/src/briefloop/finding_anchors.py

@@ -0,0 +1,56 @@
+"""Deterministic finding locations, not semantic or factual verification."""
+from .document_model import citation_label_text, document_markdown, markdown_document, source_ids
+from .evidence import blocks
+
+
+def _passages(document):
+    numbers={sid:str(i) for i,sid in enumerate(source_ids(document),1)}
+    def inline(node,mode):
+        kind=node.get('type');attrs=node.get('attrs',{})
+        def citation(sid):
+            return '['+('@'+sid if mode=='stored' else sid if mode=='packet' else numbers[sid])+']'
+        if kind=='citation':return citation(attrs['sourceId'])
+        if kind=='text':
+            text=node.get('text','')
+            if mode=='packet':return text  # packet_views._inline preserves link labels.
+            for mark in node.get('marks',[]):
+                href=mark.get('attrs',{}).get('href','')
+                if href.startswith('#source-'):
+                    return citation_label_text(text)+citation(href[8:])
+            return text
+        if kind=='hardBreak':return ' '
+        if kind=='image':
+            text=attrs.get('caption') or attrs.get('alt') or attrs.get('src','')
+            return '[图：'+text+']' if mode=='packet' else text
+        return ''.join(inline(child,mode) for child in node.get('content',[]))
+    def walk(node,parents):
+        identity=node.get('attrs',{}).get('blockId')
+        scope=parents|({identity} if identity else set())
+        if node.get('type') in ('paragraph','heading','codeBlock','image'):
+            for mode in ('stored','packet','reader'):
+                yield scope,' '.join(inline(node,mode).split())
+            yield scope,' '.join(document_markdown({'type':'doc','content':[node]}).split())
+            return
+        # Containers are not passages: joining cells or paragraphs could invent
+        # a quotation that no reader sees as continuous text.
+        for child in node.get('content',[]):yield from walk(child,scope)
+    return list(walk(document,set()))
+
+
+def validate_findings(document,findings,*,reader_preview=''):
+    """Check only new, supplied anchors; omitted text and history stay valid."""
+    passages=_passages(document);known=set(blocks(document))
+    preview=None
+    for index,finding in enumerate(findings):
+        value=finding.model_dump() if hasattr(finding,'model_dump') else finding
+        if value.get('response_to'):continue  # A corrected historical quote may be gone.
+        selected=set(value.get('block_ids') or [])
+        if selected-known:raise ValueError(f'findings[{index}].block_ids 引用了本版不存在的正文块')
+        quote=' '.join(str(value.get('report_quote') or '').split())
+        if not quote:continue  # Missing-content findings need not invent a quotation.
+        if any(quote in text for scope,text in passages if not selected or scope&selected):continue
+        if not selected and reader_preview:
+            if preview is None:preview=_passages(markdown_document(reader_preview))
+            if any(quote in text for _,text in preview):continue
+        raise ValueError(f'findings[{index}].report_quote 无法在本版指定正文位置连续定位；'
+                         '请复制实际原文，不拼接省略片段；缺失内容可省略 report_quote 并说明要求')

{briefloop-0.27.0 → briefloop-0.27.1}/src/briefloop/industry_data.py

@@ -50,6 +50,8 @@ def prepare_report_data(payload):
             elif not row.comparable: reason='尚未确认产品、地区、期间及口径可比'
             elif row.previous_unit is None or row.previous_tax_basis is None or row.previous_category is None: reason='缺少比较值单位、税口径或数据类别'
             elif row.previous_unit!=row.unit or row.previous_tax_basis!=row.tax_basis or row.previous_category!=row.category: reason='比较口径不一致'
+            elif row.category!='actual' and row.previous_as_of is None: reason='比较预测、指引或一致预期缺少取得数据的截至日 previous_as_of'
+            elif row.category!='actual' and row.previous_date==row.current_date and row.previous_as_of>row.as_of: reason='同一目标期的比较值数据截至日晚于本期数据截至日，不能按先后版本计算'
             elif row.comparison=='pct' and row.previous==0: reason='比较值为零，不能计算百分比'
             elif row.comparison=='bp' and row.unit not in ('%','percent'): reason='基点变化要求输入为百分数（例如 4.5 表示 4.5%）'
             else:

{briefloop-0.27.0 → briefloop-0.27.1}/src/briefloop/interactive_runtime.py

@@ -84,6 +84,13 @@ class InteractiveRuntime:
         self.session_id = None
         self.session_backend = None
 
+    @staticmethod
+    def _cwd(job, backend, folder):
+        if not job.get('plain_output'):
+            return folder
+        from .plain_isolation import working_directory
+        return working_directory(backend, folder)
+
     def _harness_for(self, backend):
         from .backends import validate_backend
         try:
@@ -171,12 +178,18 @@ class InteractiveRuntime:
         runtime = {'model': configured['model'],
                    'effort': configured.get('reasoning_effort', configured.get('effort'))}
         if job.get('plain_output'):
-            runtime.update(permission='read-only')
+            from . import plain_isolation
+            runtime.update(plain_isolation.runtime(backend))
         if job.get('readonly_output'):
-            from .review_capability import require_for_review
+            from .review_capability import require_for_review, review_isolation
             review_mode=payload.get('review_mode','standard')
             require_for_review(backend,review_mode)
-            runtime.update(permission='read-only',review_root=str((folder/'packet').resolve()),review_mode=review_mode)
+            if job['readonly_output']=='review.json' and review_isolation(backend,review_mode)=='observed':
+                # The host cannot be made read-only; it reviews on its own permissions
+                # and the review record carries that label and its reported tool use.
+                runtime.update(review_mode=review_mode)
+            else:
+                runtime.update(permission='read-only',review_root=str((folder/'packet').resolve()),review_mode=review_mode)
             if job.get('review_id'):runtime['review_id']=job['review_id']
         if backend == 'briefloop-native' and not job.get('native_packet') and not job.get('readonly_output'):
             from .native_orchestrator import prepare
@@ -240,7 +253,7 @@ class InteractiveRuntime:
             evaluation_title={'pairwise':'Evaluator · 比较','triage':'Evaluator · 改动分类'}.get(job.get('evaluation_mode'),'Evaluator · 评分')
             title = {'evaluator': evaluation_title, 'scorer': 'Evaluator · 评分', 'assessor': 'Evaluator · 比较', 'maintainer': '整理反馈经验', 'proposer': '提出技能改进'}.get(job.get('runtime_role'))
             title = title or task_label(job['kind'], '简报任务')
-            session = harness.create_session(title, runtime, folder)
+            session = harness.create_session(title, runtime, self._cwd(job, backend, folder))
             binding = {'job_id': job['id'], 'session_id': session['id'], 'runtime': runtime,
                        'backend': backend, 'message_id': None, 'history': []}
             _write(marker, binding)
@@ -254,7 +267,7 @@ class InteractiveRuntime:
             # An explicit job resume may need another turn, but must not undo a
             # user's archive/delete choice. Completed cached turns bypass this.
             old_sid=binding['session_id']
-            session=harness.create_session('恢复简报任务',runtime,folder)
+            session=harness.create_session('恢复简报任务',runtime,self._cwd(job,backend,folder))
             binding.setdefault('previous_session_ids',[]).append(old_sid)
             binding['session_id']=session['id']
             if binding.get('message_id'):binding.setdefault('history',[]).append(binding['message_id'])
@@ -375,7 +388,7 @@ class InteractiveRuntime:
                     if status in ('interrupted', 'cancelled'):
                         raise InterruptedError('会话已中断，已生成内容保留，可恢复')
                     if status != 'completed':
-                        raise RuntimeError('Agent 执行失败；详情保存在会话与任务日志')
+                        raise RuntimeError(tracker.failure_message or 'Agent 执行失败；详情保存在会话与任务日志')
                     return result
                 minutes = timing['hard_timeout_minutes']
                 if minutes > 0 and time.monotonic() - started > minutes * 60:

{briefloop-0.27.0 → briefloop-0.27.1}/src/briefloop/learning.py

@@ -308,9 +308,12 @@ def _generate_trial(store,job,case,skill,folder,tag):
     trial_payload=json.loads(trial['payload'])
     for key in ('runtime','role_models','agent_backend','max_parallel'):
         if trial_payload.get(key)!=conditions[key]:raise ValueError('保存的学习宿主或模型条件不一致')
-    worker=Worker(store)
-    # Shared runtime ensures Stop cancels the current trial rather than an unrelated child.
-    worker.runtime=job['_runtime']
+    worker=job.get('_worker')
+    if worker is None:
+        worker=Worker(store)
+        worker.runtime=job['_runtime']
+    # Production reuses the owner, including its session budget, cancellation
+    # and Store wakeup callback; a new Worker would silently bypass that budget.
     if trial['status']!='complete':
         try:
             value=worker.generate(trial,score=False);value['learning_conditions']=conditions
@@ -526,7 +529,8 @@ def _baseline_for_attempt(store, case, learning_payload):
     return None
 
 
-def learn(store,runtime,job):
+def learn(store,runtime,job,*,worker=None):
+    if worker is not None:job={**job,'_worker':worker}
     payload=json.loads(job['payload'])
     if payload.get('reader_id'):
         raise InterruptedError('读者专属学习链暂不启用；原反馈与任务进度保留，等待共享适用条件验收')

briefloop-0.27.1/src/briefloop/model_budget.py

@@ -0,0 +1,56 @@
+"""One workspace-wide ceiling on concurrent agent sessions (#728).
+
+Report, review and main-lane dispatch each had their own limit, so the real
+peak was reports x (1 + Scouts) + reviews + 1. Dispatch now reserves sessions
+here first. A report reserves itself plus one Scout; before its research starts
+it may grow up to the Scout count it wants, limited by what is still free.
+
+A review that belongs to a running report uses that report's reservation: the
+report waits for it, so charging it again could leave both waiting forever.
+"""
+import threading
+
+
+class ModelBudget:
+    def __init__(self, limit):
+        self._limit = limit
+        self._lock = threading.Lock()
+        self._held = {}
+        self.peak = 0
+
+    @property
+    def limit(self):
+        return max(1, int(self._limit()))
+
+    def free(self):
+        with self._lock:
+            return self.limit - sum(self._held.values())
+
+    def reserve(self, key, count):
+        """Hold `count` sessions for `key` if they are all free; False otherwise."""
+        with self._lock:
+            if self.limit - sum(self._held.values()) < count:
+                return False
+            self._held[key] = self._held.get(key, 0) + count
+            self.peak = max(self.peak, sum(self._held.values()))
+            return True
+
+    def grow(self, key, want):
+        """Raise `key` towards `want` total sessions; returns what it now holds."""
+        with self._lock:
+            held = self._held.get(key, 0)
+            extra = max(0, min(want - held, self.limit - sum(self._held.values())))
+            if extra:
+                self._held[key] = held + extra
+                self.peak = max(self.peak, sum(self._held.values()))
+            return held + extra
+
+    def release(self, key):
+        with self._lock:
+            self._held.pop(key, None)
+
+    def snapshot(self):
+        with self._lock:
+            used = sum(self._held.values())
+            return {'limit': self.limit, 'in_use': used, 'free': self.limit - used,
+                    'peak': self.peak, 'held': dict(self._held)}