@tea-agent/loop-agent 0.36.3-beta.0 → 0.37.0

package/CHANGELOG.md

@@ -1,92 +1,93 @@
 # 更新日志
 
-## [0.36.3-beta.0] - 2026-08-16
+## [Unreleased]
 
-> 前端 DAG Mock 治理收紧（beta，发布到 `beta` dist-tag）。
-
-### 改进
-
-- 前端 DAG 的 Mock 策略约束注入设计评审链：`mockContextBlock`（含冻结 allowlist 的「HARD CONSTRAINT」与修复路径）现在也注入 `frontend-design-review-pi` / `frontend-plan-revision-pi` / `frontend-final-design-review-pi`，消除「design-review 按项目规范要求 native、但生成期 allowlist 冻结为 not-needed、prewrite 硬阻断」的策略断环——评审链会明确提示这是生成期契约缺口（需声明 `frontendMock.verifyCommands` 或 `policy: "required"` 后重新生成 DAG）
-- 前端任务生成期 Mock 预警：新增 `DagSpec.advisories`，任务源提到接口/API/Mock 但 auto 模式把策略收窄为 `not-needed` 时，`task advance` 的 `warnings` 会给出可操作提示（声明 `frontendMock.verifyCommands` 或 `policy: required` 后重新生成 DAG），把契约缺口提前到生成期暴露
-
-## [0.36.1] - 2026-08-16
+## [0.37.0] - 2026-08-16
 
 ### 新增
 
-- cooperative live DAG interrupt and recovery UX
+- markdown syntax highlight, math formulas and mermaid diagrams; operate entry lands on chat
+- label rerun titles with round number from -rN id suffix
+- enter-DAG action, artifact rail projection, zh changelog
+- surface compaction progress and timeline summary
+- floating auto-dismiss toasts replace in-flow error alerts
+- add running spinners to session titles and stop button
+- show context ratio, semantic cache icons, align process entry typography
+- show context usage and semantic cache labels in usage bar
+- stream live turn process in strict order
 
 ### 修复
 
-- move interrupt eligibility to observability to honor kernel import boundary
-- retry semantic intake across Pi tiers with 300s timeout
+- isolate interrupt kernel behind worker adapter
+- constrain session title width so hover tooltip engages
+- backfill operation link for semantic activity refs
+- fail fast on non-canonical newTask ids with suggested fix
+- accept projected references and normalize PRD headings
 
-## [0.36.1-beta.0] - 2026-08-16
+## [0.36.2] - 2026-08-16
 
-> 标准 DAG planner 输出超长紧凑重试（beta，发布到 `beta` dist-tag）。
-
-### 改进
-
-- 标准 DAG 的 planner 节点（`contract-pi` / `plan-pi`）输出超长（`output-too-large`）时自动紧凑重试：新增 `PLANNER_OUTPUT_LIMIT_RETRY_POLICY`（默认重试集合 + `output-too-large`），紧凑重试指令按节点类型区分——结构化契约节点只返回单个紧凑 JSON，普通计划节点返回最小计划（有序步骤、writeSet 边界、验证命令），并丢弃上游原文引用与长证据摘录
+### 修复
 
-## [0.35.4-beta.0] - 2026-08-15
+- exempt changelog history from task-pool-root scan
+- exempt gitignore managed-block doc references in task-pool-root check
 
-> frontend prewrite 阻断误路由修正 + Mock 契约文档落地（beta，发布到 `beta` dist-tag）。
+## [0.36.1] - 2026-08-16
 
-### 改进
+### 新增
 
-- prewrite 阻断导致的 writer `SKIPPED`（`skippedReason=frontend-prewrite-not-authorized`）失败路由从 `DependencyFailure`/`unblock dependency` 修正为 `ContractMismatch`/`fix-frontend-task-contract-and-regenerate-dag`；`dag report` / `dag doctor` 透传 `skippedReason`，对「Mock 策略契约缺陷需改 task.json + 重新生成 DAG」这类场景给出可操作建议，而非误导性的「解除依赖」
+- cooperative live DAG interrupt and recovery UX
 
-### 文档
+### 修复
 
-- `docs/templates/frontend-task-constraints.md` 的 Mock 约束从 TODO 改为可落地契约：要求从项目**探索**实际存在的确定性 Mock 验证命令（不硬编码命令名）并声明到 `task.json.frontendMock.verifyCommands`，说明生成期 `allowedMockStrategies` 来源、`mock-strategy-outside-allowed` 是生成期契约问题（修复 = 补契约 + 重新生成 DAG，plan-revision 无法修复）
-- `docs/runtime/frontend-implementation-workflow.md` 的 task.json 输入标准补充 Mock 契约声明、命令探索与失败恢复指引
+- move interrupt eligibility to observability to honor kernel import boundary
+- retry semantic intake across Pi tiers with 300s timeout
 
 ## [0.36.0] - 2026-08-15
 
 ### 新增
 
-- add task journey activity rail
-- harden Operator Chat DAG recovery
-- confirm session deletion inline
-- supervise long-running DAG operations
-- polish slash command card grid
-- localize generated runtime state
+- 新增任务旅程活动栏，把任务创建、人工门禁、多次运行、失败和恢复记录聚合在同一张卡片中
+- 强化 Operator Chat 的 DAG 恢复能力，运行失败后可以直接查看原因、恢复路径和后续动作
+- 会话删除改为列表行内二次确认，减少误删，也不再被浏览器原生弹窗打断
+- Operator Chat 可以持续监督长时间运行的 DAG，直到任务结束、失败或确实需要人工处理
+- 优化斜杠命令面板的卡片布局和键盘操作，在较小窗口中也能完整浏览和选择命令
+- 运行状态、恢复提示和关键操作文案统一为自然中文，减少内部状态码和生硬英文直接暴露给用户
 
 ### 修复
 
-- harden task advance supervision
-- runner heartbeat logs no longer wake operationWait; writers must use edit tools for markdown
-- require writer to sync catalog index companions in writeSet
-- accept zh-CN acceptance heading variants in PRD parse
-- writer must materialize plan and not claim blocked for untouched forbidden paths
-- parse dag report runs[] envelope in rerun eligibility
-- tell writers diff is measured from git status, not response text
-- allow custom operator tools in SDK session allowlist
-- fit slash palette to available height
-- close operator chat command gaps
+- 任务推进期间的监督更加可靠，减少因短暂静默或状态更新延迟造成的误判
+- 运行器心跳不再提前唤醒 `operationWait`；Markdown 写入统一使用安全编辑工具，降低误覆盖风险
+- 写入目录文档时必须同步更新对应索引，避免内容已经生成却无法从目录入口找到
+- PRD 验收标准支持更多常见中文标题写法，不再因括号、破折号或措辞差异漏掉验收条件
+- 要求执行节点真正生成计划文件；没有触碰禁写路径时，不再错误声称任务受阻
+- 恢复重跑可以正确读取 `dag report` 返回的运行列表，不再因为响应结构差异误判为不可恢复
+- 变更范围统一以 Git 工作区的真实差异为准，不再根据模型回复文字推测是否修改过文件
+- Operator 自定义工具可以正常进入 Pi SDK 会话，不再被工具白名单意外过滤
+- 斜杠命令面板会根据实际可用高度自动调整，不再被窗口边缘裁切
+- 补齐 Operator Chat 的本地命令处理、动态命令降级和错误提示等交互缺口
 
 ## [0.35.3] - 2026-08-15
 
 ### 新增
 
-- chat as default landing + analyze-skills-first new-task flow
-- guide plan verification targets to writeSet-internal files, command-level checks to static
-- console recovery display — surface frontend recovery lineage + outcome
-- frontend-implementation DAG phase 6 — recovery root manifest + statistics dedup
-- frontend-implementation DAG phase 5 — writer partial-write rollback + child recovery
-- frontend-implementation DAG phase 4 — writer transient rollback base
-- frontend-implementation DAG phase 3c — scheduler activation gate + recovery trigger
-- frontend-implementation DAG phase 3b — staged child-creation kernel
-- frontend-implementation DAG phase 3a — recovery state/result types + terminal recovery intent
-- producing-node contract self-check and run robustness hardening
-- frontend-implementation DAG phase 2 — unified writer helper + structured repair assessment
-- slim frontend-implementation DAG phase 1 — prewrite merge + writer admission gate
+- Console 默认进入「对话」页面；创建新任务时先分析需求和依赖，再进入正式任务流程
+- 计划中的文件验证会优先落到允许写入的范围内，命令级检查则使用稳定的静态验证入口
+- Recovery 页面新增恢复链路和最终结果展示，能够看清一次失败是如何被接管和收敛的
+- 前端实现 DAG 增加恢复根清单，并去除重复统计，恢复报告更清晰
+- 写入节点支持部分写入回滚和子任务恢复，局部失败不再轻易污染后续执行
+- 写入节点遇到短暂故障时可以回退到稳定基线，再决定重试或恢复
+- 调度器增加激活门禁和恢复触发条件，只有满足执行条件的子任务才会进入运行
+- 新增分阶段创建子任务的基础能力，为后续恢复和分批执行提供统一入口
+- 补齐恢复状态、恢复结果和终态恢复意图的数据结构，前后端对失败状态的理解保持一致
+- 产出节点新增契约自检，并强化长时间运行时的稳定性和异常收敛能力
+- 统一写入节点的公共辅助逻辑，修复判断改为结构化结果，不再依赖模糊文本
+- 精简前端实现 DAG 的第一阶段，在正式写入前完成结果合并和写入准入检查
 
 ### 修复
 
 - 规范证据面板不再单列 openspec，统一为「规范已读取/规范检索」
-- green full test suite — python3 fallback, build-stamp version normalization, DEP0205 suppression
-- update candidate-continuation fixtures for failureCode (rebase semantic fix)
+- 恢复全量测试稳定性：没有 `python3` 时自动使用可用 Python，统一构建版本格式，并处理 Node 弃用警告造成的干扰
+- 修正续跑候选测试数据，使 `failureCode` 与真实失败语义一致，避免变基后出现错误判断
 
 ## [0.35.2] - 2026-08-15
 

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "0.36.3-beta.0",
-  "gitSha": "5baa4176d2b96e68c61f759934c6582911b4a42a",
-  "builtAt": "2026-08-16T11:51:43.878Z"
+  "version": "0.37.0",
+  "gitSha": "7b2fcb1072e85a7dbe0d92311d4b457cc34e7735",
+  "builtAt": "2026-08-16T20:27:37.113Z"
 }

package/dist/task/contract/project.js

@@ -46,6 +46,10 @@ export function projectRequirementMarkdown(draft) {
             lines.push(`- ${item}`);
         }
     }
+    // References / Source Resolutions remain projected into 需求.md (durable
+    // provenance for human readers); the managed read-back validator accepts
+    // the projector's own canonical forms instead of rejecting them
+    // (2026-08-16 L1: writer/reader round-trip invariant).
     if (draft.sourceResolutions && draft.sourceResolutions.length > 0) {
         lines.push("", "## Source Resolutions", "");
         for (const res of draft.sourceResolutions) {

package/dist/task/source-prepare/completeness.js

@@ -68,6 +68,15 @@ export function listPrepareGaps(input) {
             level: "blocking",
             field: "objective",
             message: "requirement.objective is required",
+            details: { headingAliases: ["目标", "objective", "业务目标", "需求概述"] },
+            selfHealing: {
+                action: "reimport-prd",
+                steps: [
+                    "检查 PRD 是否含「## 目标」或「## Objective」章节；中文括号后缀（如「目标（概述）」）已被识别",
+                    "若确实缺失：补全 PRD 后重新 importPrd（同 taskId），advance 会自动重投影",
+                    "不要手改 source/需求.md（会触发 DIRTY_SOURCE）；不要在 PRD 目录生成 sidecar draft JSON",
+                ],
+            },
         });
     }
     if (draft.requirement.acceptanceCriteria.length === 0) {
@@ -76,6 +85,25 @@ export function listPrepareGaps(input) {
             level: "blocking",
             field: "acceptanceCriteria",
             message: "at least one acceptance criterion is required",
+            details: {
+                recognizedHeadings: [
+                    "验收标准",
+                    "acceptance criteria",
+                    "完成标准",
+                    "完成定义",
+                    "验收",
+                    "dod",
+                ],
+                note: "标题含括号/破折号后缀会被自动归一；AC 需为列表项（- / 1.）或 AC-NNN 标题/行内格式",
+            },
+            selfHealing: {
+                action: "reimport-prd",
+                steps: [
+                    "检查 PRD 验收章节标题（如「完成标准（验收）」已可识别）与列表格式：需为「- 项目」或「AC-001: 文本」",
+                    "格式修正后重新 importPrd（同 taskId）；advance 内置 semantic intake 兜底，文档语义完整时会自动结构化",
+                    "若 advance 已返回 SEMANTIC_INTAKE_FAILED：补全 PRD 后重试，不要手改 source/ 需求.md",
+                ],
+            },
         });
     }
     if (input.acceptanceConflicts && input.acceptanceConflicts.length > 0) {
@@ -188,6 +216,14 @@ export function listPrepareGaps(input) {
             code: "DIRTY_SOURCE",
             level: "blocking",
             message: "existing non-empty or externally-modified source refuses --apply; use show/diff/adopt/recover or --force-overwrite-source",
+            selfHealing: {
+                action: "adopt-contract",
+                steps: [
+                    "task status --json 读取 contract.observedCanonicalHash 与当前 revision",
+                    "若变更确属预期：task contract adopt --task <id> --expected-revision <n> --expected-observed-hash <hash> --request-id <id> --request-payload-sha256 <sha>",
+                    "若变更不是预期的：改 PRD 后重新 importPrd 走完整重投影；禁止手改 lifecycle.json / .transactions/ 绕过",
+                ],
+            },
         });
         risks.push({
             code: "DIRTY_SOURCE",

package/dist/task/source-prepare/parse-intent.js

@@ -44,15 +44,6 @@ function stripFencedAndComments(text) {
         .replace(/~~~[\s\S]*?~~~/g, "\n")
         .replace(/<!--[\s\S]*?-->/g, "\n");
 }
-function normalizeHeadingText(raw) {
-    return raw
-        .trim()
-        // Strip leading section numbers: "2. 业务目标" / "3.1 已确认范围" / "3.2、非目标"
-        .replace(/^(?:\d+(?:\.\d+)*[.．、]?\s*)+/u, "")
-        .toLowerCase()
-        .replace(/[:：]\s*$/u, "")
-        .replace(/\s+/g, " ");
-}
 function normalizeAcceptanceId(raw) {
     return raw
         .trim()
@@ -69,12 +60,67 @@ function parseEmbeddedAcHeading(headingText) {
     const text = match[2]?.trim() || id;
     return { id, text };
 }
+function normalizeHeadingText(raw) {
+    return raw
+        .trim()
+        // Strip leading section numbers: "2. 业务目标" / "3.1 已确认范围" / "3.2、非目标"
+        .replace(/^(?:\d+(?:\.\d+)*[.．、]?\s*)+/u, "")
+        .toLowerCase()
+        .replace(/[:：]\s*$/u, "")
+        .replace(/\s+/g, " ");
+}
+/**
+ * Strip decorative suffixes that real PRD writers attach to section
+ * headings: "完成标准（验收）" → "完成标准", "Acceptance Criteria (DoD):" →
+ * "acceptance criteria", "验收标准 — 交付门槛" → "验收标准". Handles zh/en
+ * parens, dashes, colons and trailing separators before the suffix.
+ */
+function stripHeadingDecorations(normalized) {
+    return normalized
+        .replace(/[（(][^（()）]*[)）]\s*$/u, "")
+        .replace(/\s*[—–\-|]\s*[^—–\-|]+$/u, "")
+        .replace(/[:：]\s*$/u, "")
+        .trim();
+}
+const HEADING_PREFIX_HINTS = [
+    { key: "objective", hint: "目标" },
+    { key: "objective", hint: "objective" },
+    { key: "scope", hint: "范围" },
+    { key: "scope", hint: "scope" },
+    { key: "nonGoals", hint: "非目标" },
+    { key: "nonGoals", hint: "out of scope" },
+    { key: "acceptance", hint: "验收" },
+    { key: "acceptance", hint: "acceptance" },
+    { key: "acceptance", hint: "完成标准" },
+    { key: "acceptance", hint: "完成定义" },
+    { key: "acceptance", hint: "dod" },
+    { key: "constraints", hint: "约束" },
+    { key: "constraints", hint: "constraints" },
+    { key: "openQuestions", hint: "待决问题" },
+    { key: "openQuestions", hint: "open questions" },
+    { key: "assumptions", hint: "假设" },
+    { key: "assumptions", hint: "assumptions" },
+];
 function classifyHeading(text) {
     const normalized = normalizeHeadingText(text);
     for (const [key, aliases] of Object.entries(HEADING_ALIASES)) {
         if (aliases.has(normalized))
             return key;
     }
+    // Decoration-stripped exact match: "完成标准（验收）" → "完成标准".
+    const stripped = stripHeadingDecorations(normalized);
+    if (stripped && stripped !== normalized) {
+        for (const [key, aliases] of Object.entries(HEADING_ALIASES)) {
+            if (aliases.has(stripped))
+                return key;
+        }
+    }
+    // Prefix-contains fallback: "验收标准与测试" starts with "验收"; keep the
+    // hint list narrow (whole-word/leading-substring) to avoid false hits.
+    for (const { key, hint } of HEADING_PREFIX_HINTS) {
+        if (stripped === hint || stripped.startsWith(hint))
+            return key;
+    }
     return "other";
 }
 function isAtxHeading(line) {
@@ -408,10 +454,20 @@ export function fillMissingRequirementFacts(base, supplemental) {
 export function parseVerifyFlag(raw) {
     const idx = raw.indexOf(":");
     if (idx <= 0 || idx === raw.length - 1) {
-        throw new Error(`invalid --verify value "${raw}"; expected <label>:<command>`);
+        // Actionable error with concrete examples (2026-08-16 L3'-style):
+        // models were guessing flag names (--verify-label) and separator
+        // shapes; the example makes the contract self-evident.
+        const hint = !raw.includes(":")
+            ? `no label separator found; write it as <label>:<command>, e.g. --verify "typecheck:npm run typecheck"`
+            : `empty ${idx === 0 ? "label" : "command"}; write it as <label>:<command>, e.g. --verify "typecheck:npm run typecheck"`;
+        throw new Error(`invalid --verify value "${raw}"; expected <label>:<command> — ${hint}`);
+    }
+    const label = raw.slice(0, idx).trim();
+    if (!/^[a-z0-9][a-z0-9-]*$/i.test(label)) {
+        throw new Error(`invalid --verify label "${label}"; use short kebab-case letters/digits/hyphens (e.g. typecheck, unit-tests, build) — value was "${raw}"`);
     }
     return {
-        label: raw.slice(0, idx).trim(),
+        label,
         command: raw.slice(idx + 1).trim(),
     };
 }

package/dist/task/source-prepare/prepare.js

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { lstat, readFile } from "node:fs/promises";
+import path from "node:path";
 import { ContractMutationError, applyTaskContract, logicalRevisionForState, observeTaskContractState, projectConstraintsMarkdown, projectRequirementMarkdown, sha256OfCanonicalJson, validateDraftForTask, } from "../contract/index.js";
 import { TASK_CONTRACT_DRAFT_SCHEMA_VERSION } from "../contract/constants.js";
 import { getTaskContractPaths } from "../contract/paths.js";
@@ -28,26 +29,114 @@ async function loadExistingTaskConfig(repoRoot, taskId) {
         return null;
     }
 }
+/**
+ * Check whether a "## References" section in a managed 需求.md matches the
+ * projector's canonical form: every entry is `- [role] <manifest-path>` and
+ * every path exists in source-manifest.json. The projector itself writes
+ * this section, so matching entries are the writer's own round-trip output
+ * and must be accepted (2026-08-16 L1). Unknown/free-form entries stay
+ * blocking — they indicate hand-edited provenance.
+ */
+function isProjectedReferencesSection(sectionBody, manifestPaths) {
+    const entryRe = /^- \[(?<role>[^\]]+)\] (?<ref>\S.*)$/;
+    const lines = sectionBody
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    if (lines.length === 0)
+        return true; // empty section: nothing to reject
+    return lines.every((line) => {
+        const match = entryRe.exec(line);
+        if (!match?.groups)
+            return false;
+        const ref = match.groups.ref?.replace(/\\/g, "/").trim() ?? "";
+        return manifestPaths.has(ref);
+    });
+}
+/**
+ * Source Resolutions canonical projector shape:
+ * `- <sourceRef>: <conflict> → <decision> (<reason>; decidedBy=<who>)`.
+ */
+function isProjectedSourceResolutionsSection(sectionBody) {
+    const entryRe = /^- \S[^:]*: .+ → .+ \(.+; decidedBy=.+\)$/u;
+    const lines = sectionBody
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    if (lines.length === 0)
+        return true;
+    return lines.every((line) => entryRe.test(line));
+}
+/** Section titles the read-back validator may inspect (static whitelist). */
+const MANAGED_PROJECTION_SECTION_TITLES = [
+    "References",
+    "Source Resolutions",
+];
+/** Extract the body of the first `## <Title>` section, if present. */
+function extractSectionBody(markdown, title) {
+    const re = new RegExp(`^##\\s+${title}\\s*$`, "im");
+    const match = re.exec(markdown);
+    if (!match)
+        return null;
+    const rest = markdown.slice(match.index + match[0].length);
+    const nextHeading = /^##\s+/m.exec(rest);
+    return nextHeading ? rest.slice(0, nextHeading.index) : rest;
+}
+/** Materialized paths registered in the task's source-manifest.json. */
+async function loadSourceManifestPaths(requirementPath) {
+    const manifestPath = path.join(path.dirname(requirementPath), "source-manifest.json");
+    try {
+        const raw = JSON.parse(await readFile(manifestPath, "utf-8"));
+        return new Set((raw.documents ?? [])
+            .map((doc) => doc.materializedPath?.replace(/\\/g, "/"))
+            .filter((p) => Boolean(p)));
+    }
+    catch {
+        return new Set();
+    }
+}
 async function loadManagedProjectionDraft(input) {
     const config = input.existingTaskConfig;
     if (!config) {
         return { ok: false, message: "managed task config could not be loaded" };
     }
     try {
-        const [requirement, constraints] = await Promise.all([
+        const [requirementRaw, constraints] = await Promise.all([
             readFile(input.requirementPath, "utf-8"),
             readFile(input.constraintsPath, "utf-8"),
         ]);
-        const requirementFacts = extractRequirementFactsFromMarkdown(requirement);
-        const constraintFacts = extractRequirementFactsFromMarkdown(constraints);
-        if (/^##\s+(?:References|Source Resolutions)\s*$/im.test(requirement)) {
+        // L1 (2026-08-16): the requirement projector itself writes `## References`
+        // (from source-manifest) and `## Source Resolutions` sections into
+        // 需求.md. The read-back validator used to reject ANY such section —
+        // writer/reader contract drift that deadlocked every PRD import whose
+        // draft carried references. Now accept the projector's own canonical
+        // forms: References entries must all be `- [role] <path>` with paths
+        // present in source-manifest.json; Source Resolutions entries must
+        // match the projector's `- ref: conflict → decision (...)` shape.
+        // Free-form/hand-edited entries remain blocking.
+        const manifest = await loadSourceManifestPaths(input.requirementPath);
+        const referencesBody = extractSectionBody(requirementRaw, "References");
+        if (referencesBody !== null &&
+            !isProjectedReferencesSection(referencesBody, manifest)) {
+            return {
+                ok: false,
+                message: "managed requirement projection contains hand-edited or unknown References entries (not backed by source-manifest); use loop-agent task advance " +
+                    input.taskId +
+                    " --from-draft <reviewed-draft.json> --json",
+            };
+        }
+        const sourceResolutionsBody = extractSectionBody(requirementRaw, "Source Resolutions");
+        if (sourceResolutionsBody !== null &&
+            !isProjectedSourceResolutionsSection(sourceResolutionsBody)) {
             return {
                 ok: false,
-                message: "managed requirement projection contains unsupported References or Source Resolutions; use loop-agent task advance " +
+                message: "managed requirement projection contains hand-edited or malformed Source Resolutions entries; use loop-agent task advance " +
                     input.taskId +
                     " --from-draft <reviewed-draft.json> --json",
             };
         }
+        const requirementFacts = extractRequirementFactsFromMarkdown(requirementRaw);
+        const constraintFacts = extractRequirementFactsFromMarkdown(constraints);
         if (!requirementFacts.objective?.trim()) {
             return {
                 ok: false,
@@ -517,6 +606,14 @@ export async function prepareTaskSource(input) {
             code: "MANAGED_PROJECTION_INCOMPLETE",
             level: "blocking",
             message: managedProjectionError,
+            selfHealing: {
+                action: "adopt-draft",
+                steps: [
+                    "task status --json 读取 contract.observedCanonicalHash / observedSourceHashes，确认现有源文件状态",
+                    "从 Console drafts（<app-data>/repos/<repo>/drafts/<taskId>.json）或 semantic intake 产物（artifacts/intake/semantic-draft.json 的 draft 字段）取回结构化 draft",
+                    "补充缺失字段（scope/invariants 等）后：task advance --from-draft <reviewed-draft.json> --json",
+                ],
+            },
         });
     }
     // If --use-imported-prd and no parseable requirement and no AC from flags/text → blocking

package/dist/worker/console/chat/chat-event-store.js

@@ -152,6 +152,75 @@ export function projectOperationForChat(operation) {
         previewHash,
     };
 }
+/** Action families that leave a user-inspectable durable outcome. */
+const ARTIFACT_EMITTING_ACTIONS = new Set([
+    "taskAdvance",
+    "taskCreate",
+    "contractApply",
+    "dagReport",
+    "taskImportPrd",
+    "importPrd",
+]);
+/**
+ * Project a terminal operation into an「产物」rail card (2026-08-16).
+ * Mirrors `ArtifactCardState` (schemaVersion 1) so the existing frontend
+ * parser renders it without any change. Best-effort: operations without a
+ * durable outcome (pure status reads) return undefined.
+ */
+function artifactFromTerminalOperation(operation, projection) {
+    if (!ARTIFACT_EMITTING_ACTIONS.has(operation.action))
+        return undefined;
+    // Failed/interrupted actions leave nothing inspectable as a deliverable.
+    if (operation.state !== "succeeded")
+        return undefined;
+    const taskId = projection.taskId;
+    const kind = taskId
+        ? "contract"
+        : "operation";
+    const title = taskId ? `任务 ${taskId}` : `执行 ${operation.action}`;
+    const summary = projection.runSummary?.status
+        ? `运行 ${projection.runSummary.runId} · ${projection.runSummary.status}`
+        : projection.summaryPreview || undefined;
+    const reportLines = [];
+    if (projection.runSummary) {
+        const rs = projection.runSummary;
+        reportLines.push(`运行: ${rs.runId}`);
+        reportLines.push(`状态: ${rs.status}`);
+        if (rs.verdict)
+            reportLines.push(`结论: ${rs.verdict}`);
+        if (rs.failureCategory)
+            reportLines.push(`失败归类: ${rs.failureCategory}`);
+        if (Array.isArray(rs.nodes)) {
+            for (const node of rs.nodes.slice(0, 30)) {
+                reportLines.push(`- ${node.id}: ${node.status}`);
+            }
+        }
+    }
+    if (projection.stdoutPreview) {
+        reportLines.push("", "--- stdout 摘要 ---", projection.stdoutPreview);
+    }
+    const previewHash = createHash("sha256")
+        .update(JSON.stringify({
+        operationId: operation.operationId,
+        state: operation.state,
+        taskId: taskId ?? null,
+        runSummary: projection.runSummary ?? null,
+        stdoutPreview: projection.stdoutPreview ?? null,
+    }))
+        .digest("hex");
+    return {
+        schemaVersion: 1,
+        kind,
+        artifactId: `operation-${operation.operationId}`,
+        title,
+        ...(summary ? { summary } : {}),
+        ...(reportLines.length > 0
+            ? { reportText: reportLines.join("\n").slice(0, 8000) }
+            : {}),
+        inspectHref: projection.inspectHref,
+        previewHash,
+    };
+}
 export function projectCompactSnapshot(value) {
     const record = value && typeof value === "object"
         ? value
@@ -254,6 +323,7 @@ export function projectChatToolEventPayload(input) {
         resultPreview: preview,
         previewHash,
         isError: Boolean(input.isError),
+        ...(input.operationId ? { operationId: input.operationId } : {}),
     };
 }
 export function projectOperationEventSummary(event) {
@@ -411,6 +481,27 @@ export function createChatOperationLinker(options) {
                 },
             });
         }
+        // Artifact projection (2026-08-16): the sidebar「产物」tab was permanently
+        // empty because nothing in the server ever emitted `artifact-ref`. On a
+        // terminal operation with a durable outcome (task created / advanced /
+        // contract applied / report produced) project one artifact card so the
+        // user can inspect the deliverable straight from the rail.
+        if (isTerminalOperationState(operation.state)) {
+            const artifact = artifactFromTerminalOperation(operation, projection);
+            if (artifact) {
+                const artifactDuplicate = options.chatEvents
+                    .snapshot(input.sessionId)
+                    .some((event) => event.kind === "artifact-ref" &&
+                    event.data
+                        .artifact?.previewHash === artifact.previewHash);
+                if (!artifactDuplicate) {
+                    options.chatEvents.append(input.sessionId, input.turnId, {
+                        kind: "artifact-ref",
+                        data: { artifact },
+                    });
+                }
+            }
+        }
         if (isTerminalOperationState(operation.state)) {
             const key = keyFor(input.sessionId, input.operationId);
             followers.get(key)?.();

package/dist/worker/console/chat/pi-runtime.js

@@ -1963,6 +1963,31 @@ export class ConsolePiRuntime {
                     if (usage)
                         onEvent({ type: "usage", sessionId, usage });
                 }
+                // Context usage rides the usage event: refresh on agent_settled so the
+                // bar reflects the post-turn context window fill (pi-web parity).
+                if (event.type === "agent_settled") {
+                    try {
+                        const stats = session.getSessionStats?.();
+                        const contextUsage = stats?.contextUsage;
+                        if (contextUsage) {
+                            onEvent({
+                                type: "usage",
+                                sessionId,
+                                usage: {
+                                    inputTokens: 0,
+                                    outputTokens: 0,
+                                    totalTokens: 0,
+                                    ...(contextUsage.tokens === null
+                                        ? {}
+                                        : { contextUsage }),
+                                },
+                            });
+                        }
+                    }
+                    catch {
+                        // Stats getter is best-effort; never break the event stream.
+                    }
+                }
             });
             options?.signal?.addEventListener("abort", onAbort);
             if (options?.signal?.aborted) {