dsh-plugin-teamflow 0.1.6 → 0.1.7

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 > 本插件首次公开发布版本为 **v0.1.0**；发布前的内部迭代（v0.3~v0.13）记录于 `AGENTS.md` §5，对外统一归到 v0.1.0。
 
+## [0.1.7] - 2026-09-11
+
+### 新增
+- **工作台产物一键预览**：任务卡详情里的「任务夹」现在按真实存在的产物列按钮（PRD / DESIGN / TECHNICAL / QA-REPORT / ACCEPTANCE / meta），点一下即在 DSH **右侧栏**打开预览（Markdown 由官方文档预览器接管）。地址由 host 用官方 `fileAddressFor` 生成（`dsh-resource://file/session/<id>/<相对路径>`）——客户端不拼地址、也不引宿主包进 client bundle；只列真实存在的文件（不出死按钮）；右侧栏服务缺失时静默降级
+- **产物交付（`present`）**：prd/tech/qa/acceptance 四个阶段被要求把任务夹产物交给官方 `present` 工具 → 用户在该会话得到「交付文件卡」（预览 / 默认程序打开 / 文件管理器定位）。诚实标注为 `[policy]` 增强项：文件仍是唯一事实源，缺文件依旧是硬失败；卡片渲染在**该子代理会话**的轮次尾部（主会话不显示）
+- **机械阶段推理强度降档（省 token）**：DeepSeek 路由默认 `reasoningEffort: high`，而推理 token **计入 output** 且**推理内容每个带推理回合原样回传**（同时抬高后续 input）。现对两处机械阶段下发 `low`——patch 档的「单点确认」与 `scaffold`（脚手架落地）；判据类阶段（PRD/设计/技术方案/QA/验收）保持宿主默认 `high`，**重试自动回升 `high`**（质量优先）。安全前提：先经 `llm.resolveModelInfo()` 探测该路由的 `reasoning.efforts`，只有声明支持才下发——宿主对不支持的值会 `UNSUPPORTED_REASONING_EFFORT` 硬失败且不降级；探测结果按 provider/model 缓存。阶段日志记录实际下发的档位
+
+### 修复
+- **token 计量改走官方 Session 投影（宿主弃用同步事件读取器）**：dsh 0.1.5-rc.2 起 `Session.eventAt()` / `snapshotEvents()` / `ownEvents()` 标记为 deprecated（存量可留、新调用禁止，宿主方向是不再把完整事件序列常驻内存）。计量来源改为**官方投影优先**——`ctx.sessionProjections.stateOf(session,'tokenUsage')` 取四桶（与宿主 token-meter 同一份 fold，重试替换语义更准）+ `'sessionStats'.steps` 取调用数，**零历史扫描**；投影缺失/无数据/读取异常时静默回退原事件扫描（最小 profile 与存量宿主不受影响，不虚报 0，不中断流水线）。`sessionProjections` 走可选 `ctx.inject`，不进 `static inject`——服务缺失时插件照常加载
+- **护栏适配官方通道（提醒 + 挂死检测）**：轻提醒从手写 `session.append('user/message')` + step/end flush 时序状态机，改为官方 `run.localAgent.inject()`（宿主在协议安全边界整批认领，旧注释声称的「会插进 tool_calls→tool_result 触发 400」不成立）；挂死检测从「多源取最长事件视图」长度启发式改为官方 **`subagentTiming` 投影**的 `active.through`（已提交事件时间，不受视图失明影响——上次 QA 误判 stalled 的根因）。长工具静默执行仍由 agent 活动守卫豁免；投影不可用时回退旧启发式。中止语义未变
+
+### 改进
+- **声明宿主兼容窗口**：`package.json` 新增 `engines.dsh: ">=0.1.5-rc.2 <0.2.0"` 与 `dsh.manifestVersion: 1`（dsh 0.1.5 起支持的公共 manifest 字段；当前宿主不校验，属作者声明）；README「版本锚定」段同步到 v0.1.5-rc.2，并记录本次兼容核对结论与两个待跟进项
+- **清理死注入**：`static inject` 长期硬注入 `tokenMeter` 却全仓从未使用 → 从 static inject / setRuntime / runtime 三处移除（假依赖会拖累插件的加载条件）
+- **工作区 key 文档纠偏**：`workspaceScopeOf` 的「优先用 DSH workspace UUID」分支**当前不可达**（宿主 `resolveByPath` 是异步、我们同步调用），实际生效的是路径派生 `slugPath(cwd)`；注释与 AGENTS.md 改为事实描述，真修（改异步 + 存储 key 迁移）列入 `docs/TODO.md` 待 v0.1.8
+
+### 已知待办
+- **护栏复读检测仍读已弃用的事件读取器**（提醒通道与挂死检测已改官方；复读需要流式文本内容）：官方替代是订阅 `'session/event'` post-commit 投递，需先定等价判据，见 `docs/TODO.md`（当前行为不变，存量调用被宿主明确允许）
+
 ## [0.1.6] - 2026-09-07
 
 ### 新增

package/README.md

@@ -119,15 +119,20 @@ dsh-plugin-teamflow/
 - Node.js ≥ 22.18；
 - 依赖宿主提供的 `@deepseek-ai/dsh-*` 与 `react`（peerDependencies，宿主注入，无需单独安装）。
 
-opencode### 版本锚定（dsh 宿主兼容性）
+### 版本锚定（dsh 宿主兼容性）
 
-本插件开发与验证基于 **dsh git master（2026-09-04，≈ 0.1.3-alpha.1 发布线）**；npm 侧最新发布线 `0.1.2-rc.1`（next tag；`latest` 标签滞后为 0.0.1-rc.1，勿以 latest 判断）。`peerDependencies` 保持 `*`（宿主注入，宽松兼容）。
+本插件开发与验证基于 **dsh v0.1.5-rc.2（2026-09-10，tag `dsh-v0.1.5-rc.2`）**；npm 侧 `next`=0.1.5-rc.2、`latest`=0.1.5-rc.1（`latest` 常滞后于 `next`，勿以 latest 判断发布线）。`peerDependencies` 保持 `*`（宿主注入，宽松兼容），并在 `package.json` 声明兼容窗口 **`engines.dsh: ">=0.1.5-rc.2 <0.2.0"`** 与 **`dsh.manifestVersion: 1`**——当前 dsh 不读取/校验这两个字段（源码内仅有类型声明），属作者声明性元数据。
 
-2026-09-04 兼容性核对（dsh 0.1.3-alpha.1）：session 持久化 v2（write-lease/JSONL 快照/版本化导出）、attachment/file-upload 收口、Windows 子进程隐藏、workspace 全限定路径硬化——**全部兼容，插件无需调整**。
+2026-09-10 兼容性核对（dsh 0.1.5-rc.2）：插件面板 Slot（原 `conversation` 根 slot → `main` 下的 `conversation` key）、会话格式 V3 + Session 生命周期（`SessionHandle`、异步 `agentLoop.create()`、会话锁）、`ctx.agent` 移除与 Inbox 类型化、SDK/Headless/ACP 默认工具调整、subprocess handle 去除 pid——**插件全部兼容**（未使用被改动的接口；`conversation.view` / `conversation.input.right` 声明未变，slot 树无删除）。其中一项需要跟进：
+
+- **Session 同步事件读取器已弃用**（`session.eventAt()` / `snapshotEvents()` / `ownEvents()`，宿主 2026-09-09 起「存量可留、新调用禁止」，方向是不再把完整事件序列常驻内存）：**token 计量已改为官方 Session 投影优先**（`ctx.sessionProjections.stateOf(session,'tokenUsage')` 取四桶 + `'sessionStats'.steps` 取调用数），事件扫描降级为无投影宿主的回退；**护栏的提醒通道已改官方 `Agent.inject()`、挂死判据已改用官方 `subagentTiming` 投影的 `active.through`**（长工具静默仍由 agent 活动守卫豁免），只剩**复读检测**仍在读事件（需要流式文本内容，官方替代＝订阅 `'session/event'` post-commit 投递，需先定等价判据，见 `docs/TODO.md`）。
+
+2026-09-04 核对（dsh 0.1.3-alpha.1）：session 持久化 v2（write-lease/JSONL 快照/版本化导出）、attachment/file-upload 收口、Windows 子进程隐藏、workspace 全限定路径硬化——全部兼容，插件无需调整。
 
 插件侧契约约束（dsh 升级后若行为异常先核对本段；锚定版本变更会在此更新）：
-- 插件注入的 session 事件（`tool-workflow/agent-start`、`user/message` 带 `source.kind='plugin'`）均在 released 词表内；**未来新增自定义事件类型须带 `ignorable: true`**，已知类型载荷不加 released 词表外键；
-- `@deepseek-ai/dsh-client-modules` 自 0.1.2-rc.1 起替代 `@deepseek-ai/dsh-client-runtime`（后者已从 monorepo 移除）。
+- 插件注入的 session 事件（`tool-workflow/agent-start`、`user/message` 带 `source.kind='plugin'`）均在宿主 `known-event-types` 词表内；**未来新增自定义事件类型须带 `ignorable: true`**，已知类型载荷不加词表外键；
+- `@deepseek-ai/dsh-client-modules` 自 0.1.2-rc.1 起替代 `@deepseek-ai/dsh-client-runtime`（后者已从 monorepo 移除）；
+- 计量读的是**宿主投影 key**（`tokenUsage` / `sessionStats`）而非插件自有格式：宿主若改 key 或 state 版本，此段与 `host/core/metering.ts` 同步更新。
 
 ## 安装（对使用者）
 

package/lib/client.js

@@ -1392,7 +1392,7 @@ window.__ModuleLoader__.load({
 				sessions
 			}) : null);
 		}
-		function BoardPanel({ backlog, api, onRefresh, sessionId, onShowRun }) {
+		function BoardPanel({ backlog, api, onRefresh, sessionId, onShowRun, openArtifact }) {
 			const [drag, setDrag] = react.default.useState(null);
 			const [over, setOver] = react.default.useState(null);
 			const [det, setDet] = react.default.useState(null);
@@ -1682,7 +1682,8 @@ window.__ModuleLoader__.load({
 			}), det ? h(ItemDetailDrawer, {
 				det,
 				onClose: () => setDet(null),
-				onShowRun
+				onShowRun,
+				openArtifact
 			}) : null);
 		}
 		function fmtAt(ts) {
@@ -1691,7 +1692,7 @@ window.__ModuleLoader__.load({
 				minute: "2-digit"
 			}) : "—";
 		}
-		function ItemDetailDrawer({ det, onClose, onShowRun }) {
+		function ItemDetailDrawer({ det, onClose, onShowRun, openArtifact }) {
 			const d = det && det.data;
 			const loading = det && det.loading;
 			const err = det && det.err;
@@ -1950,7 +1951,30 @@ window.__ModuleLoader__.load({
 					borderRadius: 8,
 					padding: "7px 10px",
 					wordBreak: "break-all"
-				} }, d.runDocs + "/")) : null,
+				} }, d.runDocs + "/"), Array.isArray(d.artifacts) && d.artifacts.length > 0 ? h("div", { style: {
+					display: "flex",
+					flexWrap: "wrap",
+					gap: 6,
+					marginTop: 1
+				} }, d.artifacts.map((a) => h("button", {
+					key: a.name,
+					onClick: () => {
+						if (openArtifact) openArtifact(a.address, a.name);
+					},
+					title: `在右侧栏预览 ${d.runDocs}/${a.name}`,
+					style: {
+						fontSize: 10.5,
+						fontWeight: 600,
+						padding: "3px 9px",
+						borderRadius: 6,
+						cursor: "pointer",
+						lineHeight: "16px",
+						border: `1px solid color-mix(in srgb, ${T.brand} 38%, transparent)`,
+						background: `color-mix(in srgb, ${T.brand} 10%, transparent)`,
+						color: T.brand,
+						whiteSpace: "nowrap"
+					}
+				}, `📄 ${String(a.name).replace(/\.md$/, "")}`))) : null) : null,
 				kind === "task" && d.usage ? h("div", { style: {
 					display: "flex",
 					flexDirection: "column",
@@ -2518,6 +2542,7 @@ window.__ModuleLoader__.load({
 				api,
 				onRefresh: refresh,
 				sessionId: props.sessionId,
+				openArtifact: props.openArtifact,
 				onShowRun: (rid) => {
 					setTab("pipeline");
 					setRunId(rid);
@@ -2536,6 +2561,18 @@ window.__ModuleLoader__.load({
 		async function apply(ctx) {
 			await ctx.remote.$mount(TEAMFLOW_REMOTE_CONTRIBUTION);
 			const teamflow = ctx.get("remote.teamflow");
+			const openArtifact = (address, name) => {
+				try {
+					const sidebarRight = ctx.get("sidebarRight");
+					if (!sidebarRight || typeof sidebarRight.openResource !== "function") {
+						console.warn("[teamflow] 右侧栏服务不可用，无法预览产物", name);
+						return;
+					}
+					sidebarRight.openResource(address);
+				} catch (e) {
+					console.warn("[teamflow] 打开产物失败", name, e && e.message);
+				}
+			};
 			ctx.slots.inject("conversation.view", () => ctx.slots.register({
 				name: "conversation.view",
 				id: "teamflow",
@@ -2544,7 +2581,8 @@ window.__ModuleLoader__.load({
 				inject: (sessionId) => ({
 					sessionId,
 					remote: teamflow,
-					sessions: ctx.get("sessions")
+					sessions: ctx.get("sessions"),
+					openArtifact
 				})
 			}, TeamFlowView));
 			ctx.slots.inject("conversation.input.right", () => ctx.slots.register({

package/lib/host.mjs

@@ -4,11 +4,21 @@ import { TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
 import { parameterSchemaSpecToJsonSchema } from "@deepseek-ai/dsh-tools";
 import { dirname, join } from "node:path";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { fileAddressFor } from "@deepseek-ai/dsh-util-workspace-path";
 import { execFileSync } from "node:child_process";
 //#region host/constants.ts
 /** 单阶段 token 熔断预算（官方口径总消耗：input+cacheRead+cacheWrite+output 累计）。 */
 const STAGE_TOKEN_BUDGET = 6e4;
+/** 任务夹产物展示顺序（ADR-0008）：工作台只列其中**真实存在**的文件，按此顺序出「一键右侧栏预览」按钮。 */
+const TEAMFLOW_ARTIFACT_ORDER = [
+	"PRD.md",
+	"DESIGN.md",
+	"TECHNICAL.md",
+	"QA-REPORT.md",
+	"ACCEPTANCE.md",
+	"meta.json"
+];
 /** 护栏轮询间隔 ms。 */
 const GUARD_POLL_MS = 15e3;
 /** 挂死判定：连续这么久没有任何新会话事件（provider 挂起/静默死亡）→ stalled（走预算门转人工）。 */
@@ -471,20 +481,27 @@ function extractBlueprint(text) {
 //#region host/core/context.ts
 /**
 * dsh-plugin-teamflow core — 运行期共享状态（进程单例）。
-* - runtime（agents/subagents/tokenMeter/workspaceRegistry/agentDefaultModel）：由 index=TeamflowService 的 static inject 注入（setRuntime）。
+* - runtime（agents/subagents/workspaceRegistry/agentDefaultModel/llm）：由 index=TeamflowService 的 static inject 注入（setRuntime）。
 * - runs/inFlight/activeProducts：流水线运行期 Map（跨 runner/pipeline/report/服务共享）。
 * 这是 ADR-0004「共享状态」在编排层的落点：共享对象集中、单向被 core 各模块 import（不反向）。
 */
 /** 子代理/计量等宿主能力（由 TeamflowService 装配时 setRuntime 注入）。字段为鸭子类型：消费方自行窄化。 */
 const runtime = {};
-function setRuntime(agents, subagents, tokenMeter, workspaceRegistry, agentDefaultModel, llm) {
+function setRuntime(agents, subagents, workspaceRegistry, agentDefaultModel, llm) {
 	runtime.agents = agents;
 	runtime.subagents = subagents;
-	runtime.tokenMeter = tokenMeter;
 	runtime.workspaceRegistry = workspaceRegistry;
 	runtime.agentDefaultModel = agentDefaultModel;
 	runtime.llm = llm;
 }
+/**
+* 可选能力：官方 Session 投影注册表（ctx.sessionProjections，dsh-session-projection）。
+* 单独 setter 而非并入 setRuntime——它是**可选**依赖：用 ctx.inject 在服务可用时注册，
+* 未挂载（最小 profile）时计量自动回退事件扫描，插件照常加载。
+*/
+function setSessionProjections(projections) {
+	runtime.sessionProjections = projections;
+}
 /** 运行期 run 注册表（runId → Journal）。 */
 const runs = /* @__PURE__ */ new Map();
 /** 进行中的 stage 注册表（runId → { run, stage }），供取消/完成清理。 */
@@ -530,15 +547,19 @@ async function currentModelSupportsVision(provider, model) {
 /**
 * 从发起会话推导工作区作用域。
 *
-* 优先级：
-* 1. workspaceRegistry.resolveByPath(cwd) → 用 workspace.id（UUID，稳定）作 projectKey
-* 2. 回退到 session cwd 的 basename + 短 hash（兼容无 workspaceRegistry 的场景）
+* 优先级（**实际生效的只有第 2 条**）：
+* 1. workspaceRegistry.resolveByPath(cwd) → 用 workspace.id（UUID）作 projectKey
+*    —— ⚠️ **当前不可达**：宿主 `resolveByPath` 是 `async`（返回 Promise，见
+*    `packages/workspace/workspace/src/index.ts`），本函数同步调用 → `ws.id` 恒为 undefined，
+*    永远落到第 2 条。分支保留是为将来迁移（需 await + 存储 key 迁移，见 docs/TODO.md）。
+* 2. session cwd 的 basename + 短 hash（`slugPath`）—— **当前实际使用的 key**
 * 3. 兜底 'default'
 *
 * projectKey 用于 $DSH_HOME/teamflow/<projectKey>/ 目录，要求：
-* - 同一 workspace 永远解析到同一个 key（UUID 天然满足）
-* - 不同 workspace 即使 basename 相同也不碰撞（UUID 天然满足）
+* - 同一路径永远解析到同一个 key（sha1 派生，满足）
+* - 不同 cwd 即使 basename 相同也不碰撞（hash 参与，满足）
 * - 目录名安全（只含 [a-zA-Z0-9_-]）
+* ⚠️ 代价：key 绑定**路径字符串**，同一工作区换个写法（盘符大小写/软链/尾斜杠）会得到不同 key。
 */
 function workspaceScopeOf(agent) {
 	const session = agent?.session;
@@ -1254,7 +1275,63 @@ function runSanityCheck(path) {
 //#endregion
 //#region host/core/metering.ts
 /**
-* 采集子代理会话事件（多源回退——2026-09-07 实锤 r38 usage 全空）：
+* dsh-plugin-teamflow core — token 计量（官方口径）。
+* 依赖：types.ts、context.ts（runtime.sessionProjections）。
+*
+* 口径与模型 provider 账单一致（模型无关）：
+*  - input      : 输入（缓存未命中）
+*  - cacheRead  : 输入（缓存命中）
+*  - cacheWrite : 输入写入缓存
+*  - output     : 输出
+*  billed input = input + cacheRead + cacheWrite。
+* 缓存命中率 = cacheRead / (input + cacheRead)。
+*
+* 来源优先级（2026-09-10 适配 dsh 0.1.5-rc.2）：
+*  1) **官方 Session 投影**（首选）：`ctx.sessionProjections.stateOf(session,'tokenUsage')` 取四桶 +
+*     `'sessionStats'` 取调用数——零历史扫描，且与官方 token-meter 同一份 fold（不再自行复刻口径）。
+*  2) **事件扫描回退**（存量路径）：宿主未挂载投影（最小 profile/未来移除）或投影无 provider usage 时，
+*     沿用 events → snapshotEvents() → ownEvents() 多源回退。宿主自 2026-09-09 起把这三个同步历史读取器
+*     标记为 deprecated（存量可留、新调用禁止），本路径仅为无投影宿主保底，不再扩展（见 docs/TODO.md）。
+*/
+/** 投影字段读数（宽进严出：非法/非正一律 0，不虚报）。 */
+function countOf(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+/**
+* 投影路径（官方口径首选）：
+*  - `tokenUsage`（dsh-token-meter 注册，stateVersion 2）→ totals 四桶：与官方同一份 fold，
+*    `assistant/attempt` 内嵌 stream usage 同样计入、`llm/retry-started` 会先关掉被替换的重试槽位
+*    ——比旧事件扫描（只认 assistant/message）更准，重试不重复计。
+*  - `sessionStats`（dsh-session-stats 注册）steps → 调用数（一个 step = 一次模型请求；
+*    旧扫描按 assistant/message 的 turn.step 去重，语义等价）。
+* 返回 null = 投影不可用或该会话无 provider usage —— 交给事件扫描回退（不虚报 0）。
+*/
+function projectedUsageOf(run) {
+	try {
+		const projections = runtime.sessionProjections;
+		if (!projections || typeof projections.stateOf !== "function") return null;
+		const session = run && run.localAgent ? run.localAgent.session : null;
+		if (!session) return null;
+		const usage = projections.stateOf(session, "tokenUsage");
+		const totals = usage && usage.totals;
+		if (!totals) return null;
+		const buckets = {
+			input: countOf(totals.uncachedInputTokens),
+			cacheRead: countOf(totals.cacheReadTokens),
+			cacheWrite: countOf(totals.cacheWriteTokens),
+			output: countOf(totals.outputTokens),
+			calls: 0
+		};
+		if (totalTokensOf(buckets) <= 0) return null;
+		const stats = projections.stateOf(session, "sessionStats");
+		buckets.calls = countOf(stats && stats.steps) || 1;
+		return buckets;
+	} catch (e) {
+		return null;
+	}
+}
+/**
+* 采集子代理会话事件（存量回退路径——2026-09-07 实锤 r38 usage 全空）：
 * 宿主新版 Session（session v2）已无 `events` 属性/getter（仅私有 eventsSnapshot 缓存 +
 * 官方 snapshotEvents()/ownEvents() 方法），旧实现读 session.events = undefined → usage 全 null。
 * 回退链（与 guard.eventsOf 同款语义）：events（老宿主快照，兼容）→ snapshotEvents()（官方完整日志）
@@ -1302,9 +1379,16 @@ function usageOfEvent(e) {
 }
 /**
 * 累计子代理会话中所有 LLM 调用的真实 usage（官方三桶 + 调用数）。
-* 返回 null 表示拿不到 usage（会话未暴露 events / 无数据）。
+* 来源优先级：官方 Session 投影（首选，零历史扫描）→ 事件扫描（无投影宿主的存量回退）。
+* 返回 null 表示两条路径都拿不到 usage（会话未暴露投影与事件 / 无数据）。
 */
 function accumulateSessionUsage(run) {
+	const projected = projectedUsageOf(run);
+	if (projected) return projected;
+	return scannedUsageOf(run);
+}
+/** 事件扫描回退（投影未挂载/无数据时使用；沿用 2026-09-07 的多源回退语义，不改行为）。 */
+function scannedUsageOf(run) {
 	const events = sessionEventsOf(run);
 	if (events.length === 0) return null;
 	const buckets = {
@@ -1353,8 +1437,12 @@ function totalTokensOf(usage) {
 *     ⚠️ 状态判定（实锤 run tf-mte906e9）：大文件 read-edit 循环是正常模式——模型反复 read 同一大文件
 *     （每次 edit 后内容已变，必须重读确认）、输出高度相似的「读后分析」，逐字片段在 400 条窗口内
 *     可累积 ≥12 次——伴随 edit/write 变更调用时只记录观察，不中止（否则大文件修改任务全被误杀）。
-*  B. 挂死检测：连续 GUARD_SILENCE_MS 一个新事件都没有（provider 层挂起/连接静默死亡）
+*  B. 挂死检测：连续 GUARD_SILENCE_MS 没有**任何已提交事件**（provider 层挂起/连接静默死亡）
 *     → outcome='stalled'（走正常预算门 → 熔断转人工，不自动重试烧钱）。
+*     2026-09-10：时间来源改为**官方 `subagentTiming` 投影**（`active.through` = 该投影 cut 上
+*     最新事件时间，由宿主在已提交事件上折叠）——不再依赖「三源取最长视图」的长度启发式
+*     （r1 QA 误判的根因就是那个视图会失明）；投影不可用时回退旧启发式。长工具静默执行
+*     （跑 12 分钟测试无输出）仍由 agent 活动守卫豁免，不做误杀。
 *  C. 空转检测：会话仍在产出事件，但连续 GUARD_NO_TOOL_MS 没有任何工具调用
 *    （纯推理打转/改写式循环；正常 agent 每分钟都在调工具）→ outcome='stalled'。
 *    兜底关系：复读判定放宽后，edit 后陷入死循环的漏网场景由 C（长时间无工具调用）兜住。
@@ -1414,36 +1502,54 @@ function eventsOf(run) {
 function normalizeFragment(s) {
 	return String(s || "").toLowerCase().replace(/[^a-z0-9\u4e00-\u9fa5]+/g, "");
 }
-/** 观测→执行闭环：向运行中的子代理注入轻提醒（不打断，下一轮 step 可见）。
-* 通道：subagents.start 句柄无 inject——用 DSH 官方 session.append('user/message')（in-process driver 同款用法）。
-* ⚠️ 安全窗口（实锤 tf-mtcnejqj）：绝不能插在 assistant(tool_calls) → tool/result 之间——
-* provider 校验「tool 消息必须响应前序 tool_calls」，插入 user 消息会 400 invalid_request_error。
-* 因此只入队（pendingInjects），在观察到 step/end（该 step 的 tool/result 已写入）后统一 flush。 */
-function injectReminder(run, text) {
-	const queue = run;
+/**
+* 官方 `subagentTiming` 投影读数（挂死检测首选源，2026-09-10 改）。
+* 形状 `{settledMs, active?:{since, through}}`——`through` 是该投影 cut 上**最新事件时间**，
+* 由宿主在已提交事件上折叠，不受 session.events 快照失明影响（r1 QA 误判根因）。
+* 返回 null = 投影不可用（未挂载 / 该子代理无 descriptor）→ 回退事件数增长启发式。
+*/
+function timingOf(run) {
 	try {
-		if (!Array.isArray(queue.__teamflowPending)) queue.__teamflowPending = [];
-		queue.__teamflowPending.push(text);
-	} catch (e) {}
+		const projections = runtime.sessionProjections;
+		if (!projections || typeof projections.stateOf !== "function") return null;
+		const local = run && run.localAgent;
+		const session = local && local.session;
+		if (!session) return null;
+		const timing = projections.stateOf(session, "subagentTiming");
+		if (!timing || typeof timing !== "object") return null;
+		const through = timing.active && timing.active.through;
+		return { activeThrough: typeof through === "number" && Number.isFinite(through) ? through : void 0 };
+	} catch (e) {
+		return null;
+	}
 }
-function flushReminders(run) {
+/** 观测→执行闭环：向运行中的子代理注入轻提醒（不打断，下一 step 可见）。
+*
+* 通道（2026-09-10 改）：`run.localAgent.inject()` —— 宿主官方 Agent 通道。next-step 队列由
+* agent loop 在 `preStep` 内、tool/result 之后整批认领，因此**不存在**「插进
+* assistant(tool_calls) → tool/result 之间触发 provider 400」的窗口；旧实现「先入队
+* `__teamflowPending`、观察到 step/end 再 session.append」的时序状态机整体删除。
+* （旧注释「subagents.start 句柄无 inject」是错的：`run.localAgent` 是活 Agent，
+* 有 `inject/steer/followup` —— `packages/core/agent/src/runtime-types.ts`。）
+*
+* 语义：`inject` 是 best-effort（可能晚一个 step），且不唤醒 idle driver——提醒只用于
+* 「仍在跑的 agent」；退化中止仍走 fire()/dispose()，不改为 steer 纠偏（后者是独立课题）。 */
+function injectReminder(run, text) {
 	try {
-		const queue = run.__teamflowPending;
-		if (!queue || queue.length === 0) return;
-		const local = run.localAgent;
-		if (!local || typeof local.session?.append !== "function") return;
-		for (const text of queue.splice(0)) local.session.append("user/message", {
-			id: crypto.randomUUID(),
-			role: "user",
+		const agent = run && run.localAgent;
+		if (!agent || typeof agent.inject !== "function") return;
+		agent.inject(createUserMessage({
 			content: [{
 				type: "text",
 				text
 			}],
 			source: {
 				kind: "plugin",
-				plugin: "teamflow"
+				plugin: "dsh-plugin-teamflow",
+				form: "notice",
+				summary: "护栏轻提醒"
 			}
-		}, { surfaceOp: "append" });
+		}));
 	} catch (e) {}
 }
 /**
@@ -1485,31 +1591,37 @@ function startStageGuard(opts) {
 		stage.guardReason = reason;
 		stage.guardOutcome = outcome;
 		if (outcome === "stalled") try {
-			const local = run.localAgent;
-			const session = local && local.session;
-			const lens = [];
-			if (session) {
-				try {
-					const r = session.events;
-					lens.push(`events=${Array.isArray(r) ? r.length : typeof r === "function" ? r().length : "?"}`);
-				} catch (e) {
-					lens.push("events=err");
-				}
-				try {
-					lens.push(`snap=${typeof session.snapshotEvents === "function" ? session.snapshotEvents().length : "-"}`);
-				} catch (e) {
-					lens.push("snap=err");
-				}
-				try {
-					lens.push(`own=${typeof session.ownEvents === "function" ? session.ownEvents().length : "-"}`);
-				} catch (e) {
-					lens.push("own=err");
+			const timing = timingOf(run);
+			let detail;
+			if (timing) detail = `subagentTiming.through=${timing.activeThrough === void 0 ? "（无 open turn）" : timing.activeThrough}`;
+			else {
+				const local = run.localAgent;
+				const session = local && local.session;
+				const lens = [];
+				if (session) {
+					try {
+						const r = session.events;
+						lens.push(`events=${Array.isArray(r) ? r.length : typeof r === "function" ? r().length : "?"}`);
+					} catch (e) {
+						lens.push("events=err");
+					}
+					try {
+						lens.push(`snap=${typeof session.snapshotEvents === "function" ? session.snapshotEvents().length : "-"}`);
+					} catch (e) {
+						lens.push("snap=err");
+					}
+					try {
+						lens.push(`own=${typeof session.ownEvents === "function" ? session.ownEvents().length : "-"}`);
+					} catch (e) {
+						lens.push("own=err");
+					}
 				}
+				detail = `投影不可用，回退事件视图：${lens.join(" / ") || "session 不可访问"}`;
 			}
 			journal.logs.push({
 				t: Date.now(),
 				level: "warn",
-				message: `${label} 挂死诊断：${lens.join(" / ") || "session 不可访问"}`
+				message: `${label} 挂死诊断：${detail}`
 			});
 		} catch (e) {}
 		try {
@@ -1567,7 +1679,6 @@ function startStageGuard(opts) {
 					}
 				}
 				observeToolCalls(newEvents);
-				if (newEvents.some((ev) => ev?.type === "step/end")) flushReminders(run);
 				processed = events.length;
 			}
 			for (const ev of events.slice(-200)) {
@@ -1581,7 +1692,28 @@ function startStageGuard(opts) {
 					break;
 				}
 			}
-			if (events.length !== lastEventCount) {
+			const timing = timingOf(run);
+			if (timing) {
+				if (timing.activeThrough === void 0) lastGrowthAt = Date.now();
+				else if (Date.now() - timing.activeThrough > 6e5) {
+					if (lastMutationAt > 0 && isAgentBusy(run)) {
+						if (!busyWarned) {
+							busyWarned = true;
+							try {
+								journal.logs.push({
+									t: Date.now(),
+									level: "warn",
+									message: `${label} 已提交事件静默（subagentTiming.through ${Math.round((Date.now() - timing.activeThrough) / 1e3)}s 未推进）但 agent 仍活动——视为长工具执行而非挂死，继续观察`
+								});
+							} catch (e) {}
+						}
+						lastGrowthAt = Date.now();
+					} else {
+						fire(`挂死（${Math.round(GUARD_SILENCE_MS / 6e4)} 分钟无任何已提交事件，来源：subagentTiming 投影）`, "stalled");
+						return;
+					}
+				} else lastGrowthAt = Date.now();
+			} else if (events.length !== lastEventCount) {
 				lastEventCount = events.length;
 				lastGrowthAt = Date.now();
 			} else if (Date.now() - lastGrowthAt > 6e5) {
@@ -1644,6 +1776,45 @@ function startStageGuard(opts) {
 * dsh-plugin-teamflow core — 子代理执行器（并发池 / 单阶段运行 / 重试与熔断）。
 * 依赖：util/constants/types + core(context/metering)。
 */
+/**
+* 推理强度能力探测（缓存，2026-09-11）：只有宿主明确声明该路由支持某档位才下发。
+* 宿主对**不支持的值硬失败且不降级**（`UNSUPPORTED_REASONING_EFFORT`），所以宁可不下发。
+* 返回 null = 探测不可用（老宿主/未声明容量）→ 调用方一律不下发，保持宿主默认。
+*/
+const effortSupportCache = /* @__PURE__ */ new Map();
+async function supportedEfforts(route) {
+	if (!route.provider || !route.model) return null;
+	const llm = runtime.llm;
+	if (!llm || typeof llm.resolveModelInfo !== "function") return null;
+	const key = `${route.provider}/${route.model || ""}`;
+	if (effortSupportCache.has(key)) return effortSupportCache.get(key) || null;
+	let out = null;
+	try {
+		const info = await llm.resolveModelInfo(route.provider, route.model);
+		const efforts = info && info.reasoning && info.reasoning.efforts;
+		if (Array.isArray(efforts)) out = efforts.map((e) => typeof e === "string" ? e : e && typeof e === "object" && typeof e.id === "string" ? e.id : null).filter((x) => typeof x === "string" && x.length > 0);
+	} catch (e) {
+		out = null;
+	}
+	effortSupportCache.set(key, out);
+	return out;
+}
+/**
+* 解析本阶段要下发的推理强度：
+* - 阶段未要求降档（effortHint 空）→ 不传，宿主默认（DeepSeek high）
+* - 第 1 次尝试用 hint；**重试回升 'high'**（质量优先，ADR-0006）
+* - 只有探测到该路由支持该档位才返回，否则不传（防 `UNSUPPORTED_REASONING_EFFORT` 硬失败）
+* - 未下发时返回原因文本 → 调用方记 warn（这类静默失败必须可见，见 2026-09-11 实锤）
+*/
+async function resolveStageEffort(route, attempt, effortHint) {
+	const base = effortHint && String(effortHint).trim() ? String(effortHint).trim() : null;
+	if (!base) return {};
+	const wanted = attempt > 1 ? "high" : base;
+	const supported = await supportedEfforts(route);
+	if (!supported) return { skip: `路由 ${route.provider || "?"}/${route.model || "?"} 未声明 reasoning.efforts（或探测不可用）` };
+	if (supported.indexOf(wanted) === -1) return { skip: `路由不支持 ${wanted}（可用：${supported.join("/") || "无"}）` };
+	return { effort: wanted };
+}
 /** 并发池：按 max 个 worker 消费 items，返回同序结果。 */
 async function runPool(items, max, fn) {
 	const results = new Array(items.length);
@@ -1702,7 +1873,7 @@ function resolveChildRoute(parent) {
 	return out;
 }
 /** 运行单个阶段子代理：执行 + 产出实质校验 + token 双口径计量 + stage 状态流转。 */
-async function runAgent(journal, parent, label, phase, prompt, signal, taskKey) {
+async function runAgent(journal, parent, label, phase, prompt, signal, taskKey, attempt = 1, effortHint) {
 	const maxSeq = journal.stages.length ? Math.max(...journal.stages.map((s) => s.seq)) : 0;
 	let stageText = null;
 	const stage = {
@@ -1726,11 +1897,24 @@ async function runAgent(journal, parent, label, phase, prompt, signal, taskKey)
 	let cancelGuard = null;
 	try {
 		const route = resolveChildRoute(parent);
-		const agentOptions = route.provider || route.model ? {
+		const eff = await resolveStageEffort(route, attempt, effortHint);
+		const effort = eff.effort;
+		const agentOptions = route.provider || route.model || effort ? {
 			...route.provider ? { provider: route.provider } : {},
 			...route.model ? { model: route.model } : {},
-			...route.maxTokens ? { maxTokens: route.maxTokens } : {}
+			...route.maxTokens ? { maxTokens: route.maxTokens } : {},
+			...effort ? { reasoningEffort: effort } : {}
 		} : void 0;
+		if (effort && !journal.cancelled) journal.logs.push({
+			t: Date.now(),
+			level: "info",
+			message: `${label} 推理强度：${effort}${attempt > 1 ? "（重试回升）" : "（机械阶段降档）"}`
+		});
+		else if (eff.skip && !journal.cancelled) journal.logs.push({
+			t: Date.now(),
+			level: "warn",
+			message: `${label} 推理强度未降档：${eff.skip}——保持宿主默认`
+		});
 		run = await runtime.subagents.start(providerName(), {
 			label,
 			prompt: [{
@@ -1845,8 +2029,9 @@ async function runAgent(journal, parent, label, phase, prompt, signal, taskKey)
 		} catch (e2) {}
 	}
 }
-/** 单阶段重试 + token 熔断（官方口径：input+cacheRead+cacheWrite+output 累计）。 */
-async function withRetry(journal, parent, label, phase, prompt, signal, taskKey) {
+/** 单阶段重试 + token 熔断（官方口径：input+cacheRead+cacheWrite+output 累计）。
+* `effortHint`：机械阶段的推理强度降档提示（第 1 次尝试生效，重试自动回升 high，见 resolveStageEffort）。 */
+async function withRetry(journal, parent, label, phase, prompt, signal, taskKey, effortHint) {
 	let attempts = 0;
 	let stageTokens = 0;
 	let lastStage = null;
@@ -1855,7 +2040,7 @@ async function withRetry(journal, parent, label, phase, prompt, signal, taskKey)
 		const labelNow = attempt > 1 ? `${label}（第 ${attempt} 次重试）` : label;
 		const promptNow = attempt > 1 && lastStage ? prompt + buildRetryDiagnostic(attempt, lastStage) : prompt;
 		const beforeLen = journal.stages.length;
-		const result = await runAgent(journal, parent, labelNow, phase, promptNow, signal, taskKey);
+		const result = await runAgent(journal, parent, labelNow, phase, promptNow, signal, taskKey, attempt, effortHint);
 		lastStage = journal.stages[beforeLen] || null;
 		if (lastStage && lastStage.phase === phase) stageTokens += totalTokensOf(lastStage.usage);
 		if (result) return {
@@ -2249,6 +2434,16 @@ function headTailClip(text, head, tail) {
 	if (s.length <= head + tail) return s;
 	return s.slice(0, head) + "\n...\n[CHANGED SECTION]\n" + s.slice(-tail);
 }
+/**
+* 产物交付 · policy（2026-09-11）：把任务夹产物交给官方的 `present` 工具，用户在该会话里得到
+* 「交付文件卡」（预览 / 默认程序打开 / 文件管理器定位）。
+* 诚实机制说明：present 是**模型工具**，host 不强制（没调用只是少一张卡，产物文件仍是唯一交付物）；
+* 卡片渲染在**本子代理会话**的轮次尾部（宿主 ui-deliverables 挂 conversation.chat.turnTail），
+* 主会话不显示——所以它是增强项，工作台侧的「📄 产物」按钮才是主路径。
+*/
+const ARTIFACT_DELIVERY = (runDocs) => `[Artifact delivery · policy] After the deliverable file exists (and before your final reply, before the state block), call the \`present\` tool so the user gets a delivery card (preview / open in default app / reveal in file manager):
+   present({ files: [{ path: "${runDocs}/<your deliverable>.md", description: "<one-line what it is>" }] })
+   Present ONLY user-facing deliverables (≤4 files, e.g. PRD.md / TECHNICAL.md / QA-REPORT.md / ACCEPTANCE.md) — never scratch files, temp scripts or command logs. This is additive: the file stays the single source of truth, and a missing file is still a hard failure.`;
 const TOKEN_HYGIENE = (runId) => `[TOKEN HYGIENE · policy] Context is expensive. Budget discipline below — host enforcement is warn + live reminder only (never interrupts), follow it as self-discipline:
 - [File scope] Whole-file read is allowed ONLY for target files explicitly listed in the task spec. To understand other files' interfaces, use grep for keywords (do not read whole files). Never whole-file read source files outside the task scope.
 - [No duplicate reads] Same file: read ≤1 times. To verify a change, grep the change point instead of re-reading the whole file.
@@ -2283,6 +2478,7 @@ ${requirement}
 4. Output the full PRD (Markdown): background & goals, user stories (each with testable acceptance criteria), scope & non-goals, interaction flow summary, priority (P0/P1/P2), dependencies & risks, milestone suggestions. ACs must be testable/quantifiable; prefer precision & brevity. **No revision table, no version fields like「版本：vX.Y / 状态：进行中」** (the folder IS the archive; its name carries the identity).
 5. [Memory write-back · convention changes ONLY] Update docs/teamflow/memory.md ONLY if this requirement introduces new team conventions / tech-stack decisions (replace the same-topic line, idempotent, no changelog-style appending); otherwise do not touch memory.
 6. [Engineering actions carried verbatim] Engineering instructions in the raw requirement (create/switch branch, commit, tag...) MUST be preserved verbatim into the "工程约束" section of the PRD: specify the action, timing, and baseline (e.g. "branch from latest main, then implement"). If the workspace already has uncommitted changes, note how to handle them. Never silently drop or reword engineering instructions.
+${ARTIFACT_DELIVERY(RUN(state))}
 7. [State] End with a state block (phase="prd"): summary covers the AC highlights + one-sentence product semantics; extra contains { "acIndex": {...}, "summary": "<product one-liner>", "techStack": "..." }.${STATE_BLOCK_INSTRUCTION}`;
 const designPrompt = (prd, root, runId, state) => `You are a senior UI/UX designer. The current workspace IS the target project.
 ${productCtx(root)}${stateSliceFor(state, "design")}
@@ -2339,6 +2535,7 @@ ${JSON.stringify(tasks)}
    - modules: per touched file — responsibility + deps + assembly order + **architecture rationale (why)**.
    - tasks: parallelizable tasks split by file boundary (disjoint files → parallel); merge or sequence where dependencies/conflicts exist.
    - If you find duplication or a module that should be extracted (e.g. unified storage wrapper), add it to modules with the why.
+${ARTIFACT_DELIVERY(RUN(state))}
 6. [State] End with a state block (phase="tech"), extra = { "verifyScripts": [...], "modules": {"/file": "contract or one-liner"} }, summary = key architecture/contract decisions.${STATE_BLOCK_INSTRUCTION}`;
 /**
 * 架构师 prompt（M1「认知前置 + 架构落地」）：全模式启用，轻量版（lite/tech/patch）只产架构蓝图 JSON，
@@ -2417,6 +2614,7 @@ ${clip(devSummary, 15e3)}
    | 编号 | 严重级(P0/P1/P2/P3) | 功能模块 | 复现步骤 | 期望行为 | 实际行为 | 关联验收项 |
    If no defects: explicitly output 「未发现缺陷」.
 7. Chinese Markdown, concrete & executable; write the **complete** report to ${RUN(state)}/QA-REPORT.md (write once, tight body) — **this file IS the deliverable**: scope & environment, cases & results (pass/fail/blocked), 人工补测清单, defect table (if any), conclusion (whether acceptance-ready). [Boundary] only under ${TF_DOCS}/.
+${ARTIFACT_DELIVERY(RUN(state))}
 8. [State] End with a state block (phase="qa"), summary = test conclusion / blocked items, extra = { "verifyScripts": [...] }.${STATE_BLOCK_INSTRUCTION}`;
 /** QA 打回后的开发修复 prompt：确认缺陷是否属实 → 修复 → 复验交接（QA→dev 打回闭环用）。 */
 const qaFixPrompt = (defects, qa, tech, prd, root, runId, state) => `You are a senior full-stack engineer. The QA report points out several defects — **confirm each one** and fix them, then hand back for QA re-verification.
@@ -2459,6 +2657,7 @@ ${vision ? "[Visual re-check] If QA saved screenshots under the task folder, spo
 3. [Not-applicable judgment] If the PRD/tech-change/confirm doc already states「需求与现状不符」, or the dev result is explicitly「无需改动」, the verdict must be **「📝 需求不适用」** with reasons — do NOT mark ✅ 通过 just for "no defects".
 4. [Acceptance report · HOST-ENFORCED] Write the **complete** report to ${RUN(state)}/ACCEPTANCE.md (write once) — **this file IS the deliverable**: verdict line, per-criterion check table, opinions & leftovers. **The verdict line MUST be the LAST line of the file, verbatim one of: 验收结论：✅ 通过 / 验收结论：⚠️ 有条件通过 / 验收结论：❌ 不通过 / 验收结论：📝 需求不适用** — the host parses ONLY this line; missing it = contract violation → the run stops for human review; missing file = hard failure (needs-human, pipeline stops). [Memory write-back · convention changes ONLY] Update docs/teamflow/memory.md only if this requirement introduces new conventions/tech-stack decisions, or the 已知待办 list changes (same-topic line replace, idempotent, no changelog appending); otherwise don't touch memory. [Boundary] only under ${TF_DOCS}/; never modify AGENTS.md beyond the <!-- teamflow --> managed zone.
 5. Chinese Markdown.
+${ARTIFACT_DELIVERY(RUN(state))}
 6. [State] End with a state block (phase="acceptance"), summary = acceptance conclusion, verdict = "accepted/rework/reject/needs-human", extra.done = confirmation of this delivery.${STATE_BLOCK_INSTRUCTION}`;
 /** 需求分诊模型 prompt（模型驱动 triage；供 core/triage.runTriage 使用）。 */
 const TRIAGE_PROMPT = (requirement, opts, pre, retryHint) => `You are a senior research-dev triage analyst. Do ONE thing: analyze which pipeline mode this dev requirement fits, then give the conclusion. No code, no scope speculation.
@@ -3208,7 +3407,7 @@ async function executePipeline(journal, parent, requirement, options, signal, re
 				label: "产品经理 · 梳理 PRD",
 				fn: prdPrompt
 			};
-			const prdR = await withRetry(journal, parent, pForm.label, "prd", pForm.fn(requirement, root, journal.id, state), signal);
+			const prdR = await withRetry(journal, parent, pForm.label, "prd", pForm.fn(requirement, root, journal.id, state), signal, void 0, options.mode === "patch" ? "low" : null);
 			if (!prdR.text) throw stageFailError("prd", prdR);
 			prd = prdR.text;
 			timeline.prd = prd;
@@ -3249,7 +3448,7 @@ async function executePipeline(journal, parent, requirement, options, signal, re
 					level: "phase",
 					message: "进入阶段：架构规划"
 				});
-				const scR = await withRetry(journal, parent, "架构师 · 脚手架规划与落地", "scaffold", scaffoldPrompt(requirement, design, root, journal.id, state), signal);
+				const scR = await withRetry(journal, parent, "架构师 · 脚手架规划与落地", "scaffold", scaffoldPrompt(requirement, design, root, journal.id, state), signal, void 0, "low");
 				if (!scR.text) throw stageFailError("scaffold", scR);
 				scaffold = scR.text;
 				timeline.scaffold = scaffold;
@@ -4667,14 +4866,16 @@ var TeamflowService = class extends TypertRemoteService {
 	static inject = [
 		"agents",
 		"subagents",
-		"tokenMeter",
 		"typert",
 		"tools",
 		"llm"
 	];
 	constructor(ctx) {
 		super(ctx, "teamflow");
-		setRuntime(ctx.get("agents"), ctx.get("subagents"), ctx.get("tokenMeter"), ctx.get("workspaceRegistry"), ctx.get("agentDefaultModel"), ctx.get("llm"));
+		setRuntime(ctx.get("agents"), ctx.get("subagents"), ctx.get("workspaceRegistry"), ctx.get("agentDefaultModel"), ctx.get("llm"));
+		ctx.inject(["sessionProjections"], (projectionCtx) => {
+			setSessionProjections(projectionCtx.get("sessionProjections"));
+		});
 		loadActiveTeams();
 		let interruptedCount = 0;
 		try {
@@ -4789,10 +4990,14 @@ var TeamflowService = class extends TypertRemoteService {
 		if (!item) return null;
 		const reqId = k === "req" ? item.id : item.reqId || null;
 		let runDocs = null;
+		let runDocsRoot = null;
 		let runInfo = null;
 		for (const j of runsFor(sc.projectKey)) {
 			if (j.reqId !== reqId) continue;
-			if (j.runDocs && !runDocs) runDocs = j.runDocs;
+			if (j.runDocs && !runDocs) {
+				runDocs = j.runDocs;
+				runDocsRoot = j.workspacePath || null;
+			}
 			if (!runInfo) runInfo = {
 				runId: j.id,
 				status: j.status,
@@ -4801,6 +5006,17 @@ var TeamflowService = class extends TypertRemoteService {
 				endedAt: j.endedAt || null
 			};
 		}
+		const runArtifacts = [];
+		if (runDocs && runDocsRoot && typeof sessionId === "string" && sessionId) try {
+			const present = new Set(readdirSync(join(runDocsRoot, runDocs)));
+			for (const name of TEAMFLOW_ARTIFACT_ORDER) {
+				if (!present.has(name)) continue;
+				runArtifacts.push({
+					name,
+					address: fileAddressFor(sessionId, void 0, `${runDocs}/${name}`)
+				});
+			}
+		} catch (e) {}
 		const byRole = item.byRole || null;
 		let subtasks = [];
 		let bugs = [];
@@ -4870,6 +5086,7 @@ var TeamflowService = class extends TypertRemoteService {
 			byRole: k === "task" ? byRole : null,
 			reqId: reqId || null,
 			runDocs,
+			artifacts: runArtifacts,
 			runInfo,
 			subtasks,
 			bugs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-teamflow",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "TeamFlow 团队研发流水线（TypeScript）：需求→PRD→设计→架构→技术方案→并行开发→QA→验收；backlog 持久化 + 断点续跑 + 完成汇报 + 防假交付；Web 团队工作台（conversation.view tab + 拖拽看板）",
   "type": "module",
   "main": "./lib/host.mjs",
@@ -13,9 +13,11 @@
     "./package.json": "./package.json"
   },
   "engines": {
-    "node": ">=22.18"
+    "node": ">=22.18",
+    "dsh": ">=0.1.5-rc.2 <0.2.0"
   },
   "dsh": {
+    "manifestVersion": 1,
     "bundle": {
       "patch": "./cordis.patch.yml"
     },
@@ -73,7 +75,8 @@
     "@deepseek-ai/dsh-client-ui-conversation": "*",
     "@deepseek-ai/dsh-llm": "*",
     "@deepseek-ai/dsh-tools": "*",
-    "@deepseek-ai/dsh-typert-protocol": "*"
+    "@deepseek-ai/dsh-typert-protocol": "*",
+    "@deepseek-ai/dsh-util-workspace-path": "*"
   },
   "peerDependenciesMeta": {
     "@deepseek-ai/dsh-base": {
@@ -97,6 +100,9 @@
     "@deepseek-ai/dsh-typert-protocol": {
       "optional": true
     },
+    "@deepseek-ai/dsh-util-workspace-path": {
+      "optional": true
+    },
     "react": {
       "optional": true
     }