@tea-agent/loop-agent 0.42.0-next.6 → 0.42.0-next.8

package/AGENTS.md

@@ -81,7 +81,7 @@ DAG 执行期间，主 agent 不得修改 writeSet 外的任何工作区文件
 
 权威源：`docs/governance/verification-matrix.md`。
 
-默认节奏：编辑中只跑矩阵「最低验证」（typecheck + 定向 Vitest）；`git commit` 的 `pre-commit` 只做 `check-repo`；`git push` 的 `pre-push` 经 `node scripts/pre-push-verify.mjs` 在 receipt 命中时复用、miss 时跑 full `bash scripts/ci.sh`（全量 typecheck + `npm test`）。每个 clone 安装一次 hooks：`bash scripts/install-git-hooks.sh`。
+默认节奏：编辑中只跑矩阵「最低验证」（typecheck + 定向 Vitest）；常规 `npm test` 跳过约 6 分钟的 I/O-heavy 池（fast + integration）；`git commit` 的 `pre-commit` 只做 `check-repo`；`git push` 的 `pre-push` 经 `node scripts/pre-push-verify.mjs` 在 receipt 命中时复用、miss 时跑 full `bash scripts/ci.sh`（全量 typecheck + 含 I/O-heavy 的 `npm run test:full`）。每个 clone 安装一次 hooks：`bash scripts/install-git-hooks.sh`。
 
 连续 source→target 交付遵循**单一最终树全量验证**：同一 Git tree、相同环境与命令合同在 receipt TTL 内只选一个本地 full authority（有效 receipt / target pre-push / 可选 `npm run verify:tree`），不按分支名策略化，也不机械双跑 full CI。细节见 verification-matrix 与 branch-merge-guideline。
 

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 ## [Unreleased]
 
+- 修复 Operator Chat 打开已丢失会话时把孤儿 JSONL 升级成 503、以及删会话后残留 workspace 选择被误报为跨工作区冲突的问题：缺失会话文件现在自愈为 404 并清掉记录，前端恢复路径安静忘记该会话。
+- 修复前端 `--from-text` 任务缺少 source-fidelity ledger、DAG 生成后降级为 v1 并在 `frontend-contract-pi` 0ms 失败的问题：文本入口现在持久化可校验的 v2 绑定输入，init-hybrid 复用任务自有需求源；Console 默认模型与 Pi readiness 同时排除无凭据 provider，避免把不可执行模型误报为可用。
+- 常规回归 `npm test` 默认跳过约 6 分钟的 I/O-heavy 测试池（仍跑 fast + integration）；完整三池改为 `npm run test:full` / `LOOP_AGENT_FULL_TEST=1`。本地 `ci.sh`、GitHub PR 与 release/next 发布门禁仍跑全量，不降低交付验证。
+- 修复 backend-test 把 `pytest.param({"title": ""})` 整段 dict 当成 empty 观察、且 `example=` 空值导致 `target=body.title` 解析失败的问题：空 example 仍解析 field，dict 内空字符串按字段 MATCH。
+- 修复 backend-test 把自动化映射多写的横切测试点当成 Markdown BLOCKED、挡住 N11 修 docstring 的问题：只拦 `### 测试点` 未恰好绑定一次。
+- 修复 backend-test 把 pytest `_MISSING` 哨兵当成普通 Name、可选 `min; bound=0` UNDETERMINED 的问题：`_MISSING` 与 `_OMIT` 同为省略键。
+- 修复 backend-test 把可选字段 `min; bound=0` 的 `_OMIT` 判成 UNDETERMINED 的问题：省略键视为空最小；`OMITTED` TP 视为 missing。
+- 修复 backend-test 对 `http_client(operation, json_body=dict)` 观察不到 payload 的问题：http-like Name-call 的第一参是参数化 method 变量时仍计入 `json_body`。
+- 修复 backend-test 把 Markdown `Payload Required Paths: false` 当成路径、GET filter 整 Case UNSAFE 的问题：`true`/`false` 与 `none` 一样不是 path。
+- 修复 backend-test 把列表反引号里的 `场景意图: ... bound=0` 解析失败、并把 `max+1` 的数字 1 当成 minLength 的问题：围栏行可解析，`+/-` 后缀数字不进 prose 窗。
+- 修复 backend-test 把 fixture `http("POST", path, json_body={"title": ...})` 当成无 payload、整 Case PAYLOAD_SHAPE_MISMATCH 的问题：首参为 HTTP method 的 Name-call 进入 observedPaths。eligibility 门禁不放宽。
+- 修复 backend-test 把 `intent=min; bound=0` 当成缺 bound 并落到 `maxLength`、导致空 content MISMATCH 的问题：无 `minLength=` / TP LEN 时保留 0；`max; bound=0` 仍是哨兵。
+- 修复 backend-test 把 evidence-only pytest stub（模块 docstring + Case-ID、无 `def test_`）当成截断脚本、N9 `incomplete-write-set` 的问题：闭合 stub 可通过 completeness，半截 `def (` 仍 fail-closed。
+- 修复 backend-test 把 Markdown 机器行 `intent=max-1; bound=99` 当成契约 max、导致 `x*99` MISMATCH 的问题：`max-1`/`max+1`/`min-1` 优先 `maxLength=` 与文案三元组。eligibility 门禁不放宽。
+- 修复 backend-test 把 pytest 多写、Markdown 没有的 `0:1` extra symbol 当成 Markdown Test Point binding 缺陷并 BLOCKED 的问题：这类条目进入 N11 删除多余函数，不再清空 pytest repair。
+- 修复 backend-test N12 只读 effective collection 再次跑 scenario-param 确定性写回、在 `filesystem-only` 下 `write-guard` 失败的问题：N12 只复验，不再改 pytest。N10 仍可修一次。
+- 修复 backend-test 把 `脚本：无` 的 evidence-only Case 当成缺 pytest 符号送进 N11 的问题：精确 1:0 元用例不再触发 `missing-pytest-symbol` repair，N11 不得发明业务函数。真缺符号的 1:0 仍可修。eligibility 门禁不放宽。
+- 修复 backend-test 把 Scenario Partitions 数据行的 exact `TP-SP-...` 清单写成第 8 列、导致 N6 `MISSING_PARTITION` 的问题：仅当尾列全是该 Partition 的 slot ID 时确定性裁成 7 列并写回 run-owned plan。7 列契约与非 slot 多余列 fail-closed 不放宽。
+- 修复 backend-test scenario 把 `intent=max-1` 当成 unknown、以及 Markdown 只写「100 个字符的最大 / 1999、2000、2001」时解析不到 bound 的问题：`max-1` 进入 closed set，长度清单三元组与「N 个字符的最大」可得到 MATCH。eligibility 门禁不放宽。
 - 修复 backend-test correspondence 把前面函数的 `pytest.param(..., id="TP-...")` 叠进后续 Case `parameterIds` 的问题：decorator 区域遇到上一 `def`/`class` 或非 decorator 续行即停，不再把整组打成 `TEST_POINT_BINDING_EXTRA`。eligibility 门禁不放宽。
 - 修复 backend-test scenario facts 把内部 max/min/oversize helper 哨兵 `-1/-2/-3` 写成 `observedLength`、导致 N10 在 schema `min(0)` 上 `invalid-output` 的问题：这些 helper 仍按 Markdown bound MATCH，持久化长度只保留非负值。
 - 修复 backend-test 把 GET `params=`/`query=` 过滤字段、Python `True`/`False` 布尔字面量和混合大小写 `pytest.param` 列表漏出 correspondence/payload/scenario 观察的问题：这些 variant 现在可以按 item 授权，而不再把整 Case 打成 `PAYLOAD_SHAPE_MISMATCH` / `VARIANT_PARAMETER_MISSING`。eligibility 门禁不放宽。
@@ -14,6 +33,7 @@
 - 新建对话会优先复用当前工作区中真正的空白会话，避免重复创建；有历史消息、工具调用、待发送内容或正在运行的会话不会被复用。
 - 会话列表刷新现在会复用未变化的行和列表引用，标题、运行状态或队列变化时只更新对应会话，侧栏切换和刷新更平滑。
 - Operator Chat 新增仅对具备 Aimax 凭证的用户可见的 `/sdd-bingo` 数据对齐命令；`wizard-local` 模型请求会自动携带与上报一致的 OpenCode 风格会话身份、当前模型和最新 API key，请求头与资格文件变更均在下一次操作自动生效。
+- DAG 节点检查器的「执行记录」默认自动跟随最新内容；右下角新增纯图标悬浮开关，可显式暂停并保留阅读位置，恢复后立即回到底部，悬停时显示当前可执行动作。
 - 修复前端任务产物派生续跑无法识别当前节点链的问题；从实现节点继续时，设计约束、写入准入、验证和收尾步骤会按现行流程安全重放。
 - 统一工作区、Todo 和其他滚动区域的滚动条样式，默认更轻巧，鼠标悬浮时也更容易辨认。
 - HTML 文件预览现在支持页面内的标签切换等交互；较大的自包含 HTML 可以在新窗口中直接完整加载，不再受源码摘要长度影响。

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "0.42.0-next.6",
-  "gitSha": "6919b06fcb268f3a61890e85b6bc4dcbf11b62e1",
-  "builtAt": "2026-09-02T06:01:45.078Z"
+  "version": "0.42.0-next.8",
+  "gitSha": "1d1ada8ede350e5778d753c04ed72bacd778e43d",
+  "builtAt": "2026-09-02T23:47:25.236Z"
 }

package/dist/executors/dag-pi-executor.js

@@ -2019,6 +2019,41 @@ export async function createFrontendContractTools(input) {
         },
     };
 }
+async function resolveFrontendScoutSourceDeclaredPaths(input) {
+    const binding = input.spec.sourceBinding;
+    if (!binding?.sources?.length)
+        return undefined;
+    const declared = new Set();
+    const pathToken = /(?:\.?\.?\/)?[A-Za-z0-9_.-]+(?:\/[A-Za-z0-9_.-]+)+\/?/g;
+    const writerPaths = input.spec.tasks
+        .filter((task) => task.executor === "pi" && task.toolProfile === "write")
+        .flatMap((task) => task.allowedPaths ?? []);
+    const prefixes = writerPaths
+        .map((pattern) => pattern.replaceAll("\\", "/").replace(/^\.\//, ""))
+        .map((pattern) => pattern.slice(0, pattern.search(/[!*?[{]/) >= 0 ? pattern.search(/[!*?[{]/) : pattern.length))
+        .map((prefix) => prefix.slice(0, prefix.lastIndexOf("/") + 1))
+        .filter(Boolean);
+    for (const source of binding.sources) {
+        try {
+            const text = await readFile(path.resolve(input.cwd, source.path), "utf8");
+            for (const match of text.matchAll(pathToken)) {
+                const token = match[0].replaceAll("\\", "/").replace(/^\.\//, "").replace(/\/$/, "");
+                if (!token || token.startsWith("http") || token.startsWith("api/"))
+                    continue;
+                declared.add(token);
+                for (const prefix of prefixes) {
+                    if (!token.startsWith(prefix) && !token.startsWith(".harness/"))
+                        declared.add(`${prefix}${token}`);
+                }
+            }
+        }
+        catch {
+            // The source binding itself remains the authority; an unreadable source
+            // produces an empty declaration set, so future test paths fail closed.
+        }
+    }
+    return [...declared].sort();
+}
 /**
  * A+B: `frontend-scout-pi` incremental evidence tools (origin=scout). Runtime
  * enriches committed target-surface / design-evidence facts with hash/section/
@@ -2043,6 +2078,12 @@ export async function createFrontendScoutEvidenceTools(input) {
         content: [{ type: "text", text: JSON.stringify(details) }],
         details,
     });
+    const sourceDeclaredPaths = (input.sourceDeclaredPaths ?? []).map((value) => value.replaceAll("\\", "/").replace(/^\.\//, "").replace(/\/$/, ""));
+    const hasSourceDeclarations = input.sourceDeclaredPaths !== undefined;
+    const isSourceDeclared = (candidate) => {
+        const normalized = candidate.replaceAll("\\", "/").replace(/^\.\//, "").replace(/\/$/, "");
+        return sourceDeclaredPaths.some((declared) => declared === normalized || declared.startsWith(`${normalized}/`));
+    };
     // A+B (AC-003): runtime enriches declared scout paths with hash/freshness
     // from the real filesystem. The model's self-reported path list is never
     // trusted for content identity; a missing file fails closed to fresh=false
@@ -2056,7 +2097,7 @@ export async function createFrontendScoutEvidenceTools(input) {
             const absolute = path.resolve(workspaceRoot, relative);
             if (absolute !== workspaceRoot &&
                 !absolute.startsWith(`${workspaceRoot}${path.sep}`)) {
-                evidence.push({ path: relative, sha256: "0".repeat(64), fresh: false });
+                evidence.push({ path: relative, sha256: "0".repeat(64), fresh: false, sourceDeclared: isSourceDeclared(relative) });
                 continue;
             }
             try {
@@ -2073,6 +2114,7 @@ export async function createFrontendScoutEvidenceTools(input) {
                         path: relative,
                         sha256: createHash("sha256").update(`directory:${relative}`).digest("hex"),
                         fresh: true,
+                        sourceDeclared: isSourceDeclared(relative),
                     });
                     continue;
                 }
@@ -2081,10 +2123,11 @@ export async function createFrontendScoutEvidenceTools(input) {
                     path: relative,
                     sha256: createHash("sha256").update(bytes).digest("hex"),
                     fresh: true,
+                    sourceDeclared: isSourceDeclared(relative),
                 });
             }
             catch {
-                evidence.push({ path: relative, sha256: "0".repeat(64), fresh: false });
+                evidence.push({ path: relative, sha256: "0".repeat(64), fresh: false, sourceDeclared: isSourceDeclared(relative) });
             }
         }
         return evidence;
@@ -2157,6 +2200,7 @@ export async function createFrontendScoutEvidenceTools(input) {
                 dataSource: params?.dataSource ?? "",
                 allowedPathConflicts: params?.allowedPathConflicts ?? [],
                 unresolvedPaths: params?.unresolvedPaths ?? [],
+                ...(hasSourceDeclarations ? { sourceDeclaredPaths } : {}),
                 ...(pathEvidence.length > 0 ? { pathEvidence } : {}),
             });
             return receipt(result);
@@ -3798,6 +3842,10 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
                 runDir: meta.runDir,
                 nodeId: input.task.id,
                 workspaceRoot: input.cwd,
+                sourceDeclaredPaths: await resolveFrontendScoutSourceDeclaredPaths({
+                    cwd: input.cwd,
+                    spec: meta.spec,
+                }),
             });
             writerToolPolicy = {
                 requireSdk: true,
@@ -4091,24 +4139,37 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
             })),
         ];
     if (readBudgetIssues.length > 0) {
-        // Read-budget telemetry is diagnostic only when the provider/executor has
-        // already failed. In particular, keep context-overflow so node-execution
-        // selects its compact retry envelope instead of treating the attempt as a
-        // generic read-burst retry.
-        if (!mapped.ok) {
+        const hasTypedFrontendTerminal = isFrontendReviewTypedTerminalNode(input.task) ||
+            isFrontendDesignTypedTerminalNode(input.task);
+        // A stale/generated DAG may still carry the legacy read budget. Once a
+        // design/review node has a successful typed terminal, telemetry is
+        // diagnostic only; the terminal shadow below still fails closed when the
+        // fact is missing or conflicting.
+        if (mapped.ok && hasTypedFrontendTerminal) {
+            // Continue to the typed terminal shadow validation below.
+        }
+        else {
+            // Read-budget telemetry is diagnostic only when the provider/executor
+            // has already failed. In particular, keep context-overflow so
+            // node-execution selects its compact retry envelope instead of treating
+            // the attempt as a generic read-burst retry.
+            if (!mapped.ok) {
+                return {
+                    ...mapped,
+                    stderr: [mapped.stderr, ...readBudgetIssues]
+                        .filter(Boolean)
+                        .join("\n\n"),
+                };
+            }
             return {
                 ...mapped,
+                ok: false,
+                failureCategory: "read-burst",
                 stderr: [mapped.stderr, ...readBudgetIssues]
                     .filter(Boolean)
                     .join("\n\n"),
             };
         }
-        return {
-            ...mapped,
-            ok: false,
-            failureCategory: "read-burst",
-            stderr: [mapped.stderr, ...readBudgetIssues].filter(Boolean).join("\n\n"),
-        };
     }
     if (isFrontendReviewTypedTerminalNode(input.task)) {
         return await runFrontendReviewTerminalShadow({

package/dist/executors/shell-executor.js

@@ -58,6 +58,7 @@ import { readProjectGovernanceContext } from "../workflows/dag/project-governanc
 import { assertMavenPlanFresh, MavenPlanStaleError, } from "../verification/maven/index.js";
 async function runBackendScenarioParamPreflight(input) {
     const outputs = [];
+    const allowRepair = input.allowRepair !== false;
     const initial = await assessBackendScenarioParamConsistency({
         workspaceRoot: input.workspaceRoot,
         phase: "initial",
@@ -73,7 +74,7 @@ async function runBackendScenarioParamPreflight(input) {
     outputs.push(`scenarioParamInitial=${initialArtifacts.reportPath}`);
     let finalFacts;
     let finalMarkdown;
-    if (initial.facts.repairEligible) {
+    if (allowRepair && initial.facts.repairEligible) {
         const repair = await applyDeterministicScenarioParamRepairs({
             workspaceRoot: input.workspaceRoot,
             facts: initial.facts,
@@ -979,6 +980,7 @@ async function executeBackendTestPipeline(input, meta) {
                     workspaceRoot: input.cwd,
                     runDir: meta.runDir,
                     layout: backendLayout,
+                    allowRepair: false,
                     strictScenarioParamGate: Boolean((meta.spec.globalConstraints ?? []).some((item) => /strictScenarioParamGate\s*=\s*true/i.test(item))),
                 });
                 outputs.push(...scenario.outputs);

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

@@ -16,17 +16,15 @@ const NON_GOAL_HEADING_RE = /(?:^|\s)(?:非目标|out of scope|non-goals|non goa
 const OBJECTIVE_HEADING_RE = /(?:^|\s)(?:目标|objective|问题与目标|业务目标|需求概述)(?:\s|$)/iu;
 /** 可执行片段启发式（AC 风格/祈使语气）：命中则不可按 context-only 降级。 */
 const EXECUTABLE_HINT_RE = /(?:必须|应当|应支持|需要|需|不得|should|must|shall|will|require|support|implement|provide|ensure|verify|当.*?时|when.*?then)/iu;
-/** 显式 AC 式 ID 前缀：AC-001 / AC-FE-001 / AC-FE-INS-001 等（允许 bullet 标记后空格
- * 与 checklist 勾选框）。收紧解析（AC-001 / AC-HARD-001）：AC 后必须跟分隔符
- * （-/_）+ 大写字母/数字 id 形态（含可选 FE/BE/UI/API 作用域前缀与 V4 `#### AC-*`
- * 标题归属）；`## Acceptance Criteria` / `## Acceptance` / Ac 开头普通单词永不产生
- * 伪造 id（ACCEPTANCE 类 id 全量消失）。捕获组 1 = AC id，捕获组 2 = 余下文本。 */
-const EXPLICIT_AC_ID_RE = /^\s*(?:[-*+]|\d+[.)])\s+(?:\[[ xX]\]\s+)?(AC(?:[-_](?:FE|BE|UI|API))?[-_][A-Z0-9]+(?:[-_][A-Z0-9]+)*)\s*[:：]?\s*(.*)$/iu;
-/** 显式 AC 标题式：`#### AC-FE-001 Save nickname` / `### AC-001：正文`。
- * AC 后必须跟分隔符（-/_）+ id 形态；普通单词（Acceptance Criteria / Acceptance）
- * 永不匹配，按 ACCEPTANCE_HEADING_RE 章节分类生成稳定 REQ-SRC-* 片段。
- * 捕获组 1 = AC id，捕获组 2 = 标题余下文本。 */
-const EXPLICIT_AC_HEADING_RE = /^\s*(AC(?:[-_](?:FE|BE|UI|API))?[-_][A-Z0-9]+(?:[-_][A-Z0-9]+)*)\s*[:：]?\s*(.*)$/iu;
+/** 显式 requirement ID：AC-001 / BR-001 / REQ-SRC-001 等（允许 bullet 标记后空格
+ * 与 checklist 勾选框）。AC/BR/REQ 都是 DAG 的合法 canonical requirement 身份；
+ * 之前这里只识别 AC，导致已进入 canonicalRequirements 的 BR 片段无法绑定来源。
+ * 捕获组 1 = requirement id，捕获组 2 = 余下文本。 */
+const EXPLICIT_REQUIREMENT_ID_RE = /^\s*(?:(?:[-*+]|\d+[.)])\s+(?:\[[ xX]\]\s+)?)?((?:REQ|BR|AC)(?:[-_][A-Z0-9]+)+)\s*[:：]?\s*(.*)$/iu;
+/** 显式 requirement 标题式：`#### AC-FE-001 Save nickname` / `### BR-001：正文`。
+ * 普通单词（Acceptance Criteria / Acceptance）永不匹配，按章节分类生成稳定
+ * REQ-SRC-* 片段。捕获组 1 = requirement id，捕获组 2 = 标题余下文本。 */
+const EXPLICIT_REQUIREMENT_HEADING_RE = /^\s*((?:REQ|BR|AC)(?:[-_][A-Z0-9]+)+)\s*[:：]?\s*(.*)$/iu;
 /** Markdown 表格数据行（非分隔行）。 */
 const TABLE_DATA_ROW_RE = /^\s*\|.*\|\s*$/;
 const TABLE_SEPARATOR_ROW_RE = /^\s*\|[\s:|-]+\|\s*$/;
@@ -35,11 +33,11 @@ function isTableHeaderRow(line, nextLine) {
     return isTableDataRow(line) && TABLE_SEPARATOR_ROW_RE.test(nextLine.trim());
 }
 /** 表格行首格显式 AC ID：`| AC-001 | 订单列表加载完成 |` → id=AC-001, rest=订单列表加载完成。 */
-function matchTableRowAcId(line) {
+function matchTableRowRequirementId(line) {
     const trimmed = line.trim().replace(/^\|/, "");
     const cells = trimmed.split("|");
     const first = cells[0]?.trim() ?? "";
-    const idMatch = EXPLICIT_AC_HEADING_RE.exec(first);
+    const idMatch = EXPLICIT_REQUIREMENT_HEADING_RE.exec(first);
     if (!idMatch)
         return null;
     const id = (idMatch[1] ?? "").trim().toUpperCase().replace(/_/g, "-");
@@ -52,6 +50,14 @@ function matchTableRowAcId(line) {
         .trim();
     return { id, rest: rest || id };
 }
+/** The splitter may use only AC ids as fragment identities; BR/REQ ids are
+ * mapped later while keeping the generated REQ-SRC fragment identity. */
+function matchTableRowAcId(line) {
+    const match = matchTableRowRequirementId(line);
+    if (!match || !/^AC(?:-[A-Z0-9]+)+$/iu.test(match.id))
+        return null;
+    return match;
+}
 export function sha256Text(text) {
     return createHash("sha256").update(text, "utf8").digest("hex");
 }
@@ -66,7 +72,20 @@ export function normalizeFragmentText(text) {
         .trim();
 }
 export function matchExplicitAcId(line) {
-    const match = EXPLICIT_AC_ID_RE.exec(line.trim());
+    const match = EXPLICIT_REQUIREMENT_ID_RE.exec(line.trim());
+    if (!match)
+        return null;
+    const rawId = match[1] ?? "";
+    if (!/^AC(?:[-_][A-Z0-9]+)+$/iu.test(rawId))
+        return null;
+    const id = rawId.trim().toUpperCase().replace(/_/g, "-");
+    if (!id)
+        return null;
+    return { id, rest: (match[2] ?? "").trim() };
+}
+/** Match an explicit AC/BR/REQ id in a list item or a paragraph fragment. */
+export function matchExplicitRequirementId(line) {
+    const match = EXPLICIT_REQUIREMENT_ID_RE.exec(line.trim());
     if (!match)
         return null;
     const rawId = match[1] ?? "";
@@ -77,7 +96,20 @@ export function matchExplicitAcId(line) {
 }
 /** V4 显式 AC 标题式匹配：`#### AC-FE-001 Save nickname` → id=AC-FE-001, rest=Save nickname。 */
 export function matchExplicitAcHeading(headingText) {
-    const match = EXPLICIT_AC_HEADING_RE.exec(headingText.trim());
+    const match = EXPLICIT_REQUIREMENT_HEADING_RE.exec(headingText.trim());
+    if (!match)
+        return null;
+    const rawId = match[1] ?? "";
+    if (!/^AC(?:[-_][A-Z0-9]+)+$/iu.test(rawId))
+        return null;
+    const id = rawId.trim().toUpperCase().replace(/_/g, "-");
+    if (!id)
+        return null;
+    return { id, rest: (match[2] ?? "").trim() };
+}
+/** Match an explicit AC/BR/REQ id in a heading. */
+export function matchExplicitRequirementHeading(headingText) {
+    const match = EXPLICIT_REQUIREMENT_HEADING_RE.exec(headingText.trim());
     if (!match)
         return null;
     const rawId = match[1] ?? "";
@@ -389,7 +421,8 @@ export function buildFragmentInventory(input) {
             : null;
         const explicit = explicitIdFromId
             ? { id: explicitIdFromId, rest: fragment.text }
-            : matchExplicitAcId(fragment.text);
+            : matchExplicitRequirementId(fragment.text) ??
+                matchTableRowRequirementId(fragment.text);
         // V4 标题/条目下正文继承的显式 AC ID（不生成取代它的 REQ-SRC-*）。
         const inherited = !explicit && fragment.explicitAcId
             ? { id: fragment.explicitAcId, rest: fragment.text }

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

@@ -796,29 +796,46 @@ export async function prepareTaskSource(input) {
     // -------------------------------------------------------------------
     let ledger;
     let ledgerSummary;
-    if (hasImportedPrd &&
-        sourceIntegrity &&
-        sourceIntegrity.parseableDocuments.some((doc) => doc.role === "requirement" || doc.role === "acceptance")) {
+    const hasAuthoritativeImportedDocs = Boolean(hasImportedPrd &&
+        sourceIntegrity?.parseableDocuments.some((doc) => doc.role === "requirement" || doc.role === "acceptance"));
+    // Frontend tasks created from text still need the same source-fidelity
+    // contract as imported-PRD tasks.  In that case the projected requirement
+    // document is the canonical, task-owned source that the DAG can bind to;
+    // without it init-hybrid would silently emit a v1 binding and the first
+    // frontend-contract node would fail before making a model call.
+    if (built.draft.taskKind === "frontend-implementation" &&
+        (hasAuthoritativeImportedDocs ||
+            (input.intent.kind === "facts" && Boolean(input.intent.text)))) {
         try {
-            const authoritativeDocs = sourceIntegrity.parseableDocuments.filter((doc) => (doc.role === "requirement" || doc.role === "acceptance") &&
+            const authoritativeDocs = sourceIntegrity?.parseableDocuments.filter((doc) => (doc.role === "requirement" || doc.role === "acceptance") &&
                 typeof doc.content === "string" &&
-                doc.content.trim().length > 0);
-            const sourceDocuments = authoritativeDocs.map((doc) => {
-                // Canonical source identity 单一边界（AC-001 / AC-FIDELITY-REPAIR-001）：
-                // ledger sourceDocuments[].path 与 DAG 侧 serializeDagTaskSourcePath /
-                // resolveDagTaskSourcePath 一致（repo-root relative POSIX），路径转换只
-                // 发生在该边界，不再二次转换进入 digest 计算。
-                const absolute = path.resolve(contractPaths.sourceDir, doc.materializedPath);
-                return {
-                    path: path
-                        .relative(repoRoot, absolute)
-                        .split(path.sep)
-                        .join("/"),
-                    content: doc.content,
-                };
-            });
+                doc.content.trim().length > 0) ?? [];
+            const requirementProjection = projectRequirementMarkdown(built.draft);
+            const sourceDocuments = authoritativeDocs.length > 0
+                ? authoritativeDocs.map((doc) => {
+                    // Canonical source identity 单一边界（AC-001 / AC-FIDELITY-REPAIR-001）：
+                    // ledger sourceDocuments[].path 与 DAG 侧 serializeDagTaskSourcePath /
+                    // resolveDagTaskSourcePath 一致（repo-root relative POSIX），路径转换只
+                    // 发生在该边界，不再二次转换进入 digest 计算。
+                    const absolute = path.resolve(contractPaths.sourceDir, doc.materializedPath);
+                    return {
+                        path: path
+                            .relative(repoRoot, absolute)
+                            .split(path.sep)
+                            .join("/"),
+                        content: doc.content,
+                    };
+                })
+                : [
+                    {
+                        path: path
+                            .relative(repoRoot, contractPaths.requirementPath)
+                            .split(path.sep)
+                            .join("/"),
+                        content: requirementProjection,
+                    },
+                ];
             if (sourceDocuments.length > 0) {
-                const requirementProjection = projectRequirementMarkdown(built.draft);
                 ledger = await buildRequirementLedger({
                     taskId,
                     requirementSha256: sha256Utf8(requirementProjection),

package/dist/worker/console/chat/model-resolver.js

@@ -125,11 +125,14 @@ function resolveTierDescriptor(selection, available) {
         });
         return {
             provider: selection.provider,
-            resolved: Boolean(entry),
+            resolved: Boolean(entry && entry.hasCredentials !== false),
         };
     }
     const entry = findProviderForModelId(selection.modelId, available);
-    return { provider: entry?.provider, resolved: Boolean(entry) };
+    return {
+        provider: entry?.provider,
+        resolved: Boolean(entry && entry.hasCredentials !== false),
+    };
 }
 /**
  * Resolve harness executors.pi tiers (LOW/MED/HIGH) to provider descriptors.
@@ -196,7 +199,7 @@ export async function resolveDefaultChatModel(repoRoot, available, options) {
         const entry = findProviderForModelId(selection.modelId, available, {
             preferredProvider: selection.provider,
         });
-        if (!entry)
+        if (!entry || entry.hasCredentials === false)
             return undefined;
         return {
             provider: selection.provider,
@@ -205,7 +208,7 @@ export async function resolveDefaultChatModel(repoRoot, available, options) {
         };
     }
     const entry = findProviderForModelId(selection.modelId, available);
-    if (!entry)
+    if (!entry || entry.hasCredentials === false)
         return undefined;
     return {
         provider: entry.provider,

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

@@ -26,7 +26,7 @@
  * `createDefaultPiSdkBindings()`.
  */
 import { createHash, randomBytes } from "node:crypto";
-import { access, stat } from "node:fs/promises";
+import { access, mkdir, rm, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { extractAssistantContentBlocks, extractAssistantText, isAssistantSdkMessage, } from "./assistant-content.js";
 import { parseProviderError, } from "./provider-error.js";
@@ -1331,6 +1331,15 @@ export class ConsolePiRuntime {
         if (!sessionFile) {
             throw new Error(`chat session shell missing sessionFile for ${sessionId}`);
         }
+        // Pi's SessionManager.create deliberately postpones writing a JSONL until
+        // an assistant response. Materialize a valid header now, otherwise Console
+        // could persist a path that disappears on a restart before first reply.
+        await this.bindings.materializeSessionShell({
+            sessionManager,
+            sessionId,
+            sessionFile,
+            cwd: this.options.cwd,
+        });
         this.sessionManagers.set(sessionId, sessionManager);
         this.thinkingSelections.set(sessionId, "auto");
         // Detached single-flight materialization; dependent routes await the same promise.
@@ -2338,6 +2347,16 @@ export class ConsolePiRuntime {
             });
         }
         catch (error) {
+            const code = error && typeof error === "object" && "code" in error
+                ? String(error.code ?? "")
+                : "";
+            if (code === "SESSION_FILE_MISSING" || code === "ENOENT") {
+                return {
+                    ok: false,
+                    code: "NO_SESSION_FILE",
+                    message: `Pi session file missing or not openable: ${init.sessionFile}`,
+                };
+            }
             return {
                 ok: false,
                 code: "REOPEN_FAILED",
@@ -3173,6 +3192,36 @@ export function createDefaultPiSdkBindings() {
                 id: opts.sessionId,
             });
         },
+        materializeSessionShell: async (opts) => {
+            const sdk = (await loadSdk());
+            const manager = opts.sessionManager;
+            if (typeof manager.setSessionFile !== "function") {
+                throw new Error("Pi SessionManager cannot materialize a session file");
+            }
+            let created = false;
+            try {
+                await mkdir(path.dirname(opts.sessionFile), { recursive: true });
+                // Match Pi's documented session header. Rebinding through the public
+                // SessionManager API marks it flushed, so Pi appends the first user
+                // entry instead of trying to create the already-present file later.
+                await writeFile(opts.sessionFile, `${JSON.stringify({
+                    type: "session",
+                    version: typeof sdk.CURRENT_SESSION_VERSION === "number"
+                        ? sdk.CURRENT_SESSION_VERSION
+                        : 3,
+                    id: opts.sessionId,
+                    timestamp: new Date().toISOString(),
+                    cwd: opts.cwd,
+                })}\n`, { encoding: "utf8", flag: "wx", mode: 0o600 });
+                created = true;
+                manager.setSessionFile(opts.sessionFile);
+            }
+            catch (error) {
+                if (created)
+                    await rm(opts.sessionFile, { force: true }).catch(() => undefined);
+                throw error;
+            }
+        },
         createInMemorySessionManager: async (opts) => {
             const sdk = (await loadSdk());
             return sdk.SessionManager.inMemory(opts.cwd);
@@ -3189,13 +3238,19 @@ export function createDefaultPiSdkBindings() {
                 // wrong conversation under the durable Console sessionId. Fail closed
                 // before open when the persisted file is absent.
                 await access(opts.sessionFile);
-                return sdk.SessionManager.open(opts.sessionFile);
             }
-            catch {
-                // Missing/corrupt session file — caller fails closed rather than
-                // silently creating a fresh session and losing prior context.
+            catch (error) {
+                const code = error && typeof error === "object" && "code" in error
+                    ? String(error.code ?? "")
+                    : "";
+                if (code === "ENOENT") {
+                    throw Object.assign(new Error(`SESSION_FILE_MISSING: ${opts.sessionFile}`), { code: "SESSION_FILE_MISSING", cause: error });
+                }
+                // File exists but is unreadable (permissions / I/O) — caller maps
+                // undefined to 503 rather than silently creating a fresh session.
                 return undefined;
             }
+            return sdk.SessionManager.open(opts.sessionFile);
         },
         resolveModel: (opts) => {
             const rt = opts.modelRuntime;