flow-comet 1.6.0 → 1.6.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (43) hide show
  1. package/.flow-comet/skills/flow-comet/GUIDANCE.md +26 -5
  2. package/.flow-comet/skills/flow-comet/INSTALLED_VERSION +1 -1
  3. package/.flow-comet/skills/flow-comet/SKILL.md +51 -2
  4. package/.flow-comet/skills/flow-comet/reference/KNOWN-ISSUES-template.md +3 -3
  5. package/.flow-comet/skills/flow-comet/reference/TEST-MATRIX.md +15 -15
  6. package/.flow-comet/skills/flow-comet/reference/dsh-platform.md +19 -11
  7. package/.flow-comet/skills/flow-comet/reference/recovery.md +1 -7
  8. package/.flow-comet/skills/flow-comet/reference/workflow-protocol.json +1 -1
  9. package/.flow-comet/skills/flow-comet/reference/worktree-notes.md +21 -3
  10. package/.flow-comet/skills/flow-comet/scripts/context-init.mjs +129 -3
  11. package/.flow-comet/skills/flow-comet/scripts/context-scan.mjs +396 -0
  12. package/.flow-comet/skills/flow-comet/scripts/contract-check.mjs +41 -31
  13. package/.flow-comet/skills/flow-comet/scripts/evolve.mjs +778 -0
  14. package/.flow-comet/skills/flow-comet/scripts/guard-self-test.mjs +5499 -596
  15. package/.flow-comet/skills/flow-comet/scripts/health.mjs +664 -0
  16. package/.flow-comet/skills/flow-comet/scripts/protocol-utils.mjs +1 -1
  17. package/.flow-comet/skills/flow-comet/scripts/route-node.mjs +459 -11
  18. package/.flow-comet/skills/flow-comet/scripts/state-schema.mjs +58 -3
  19. package/.flow-comet/skills/flow-comet/scripts/system-test.mjs +1024 -11
  20. package/.flow-comet/skills/flow-comet/scripts/time-utils.mjs +133 -0
  21. package/.flow-comet/skills/flow-comet/scripts/workflow-guard.mjs +285 -227
  22. package/.flow-comet/skills/flow-comet/scripts/workflow-handoff.mjs +6 -4
  23. package/.flow-comet/skills/flow-comet/scripts/workflow-state.mjs +515 -31
  24. package/.flow-comet/skills/flow-comet-archive/SKILL.md +2 -0
  25. package/.flow-comet/skills/flow-comet-change/SKILL.md +13 -1
  26. package/.flow-comet/skills/flow-comet-design/SKILL.md +6 -2
  27. package/.flow-comet/skills/flow-comet-dev/SKILL.md +3 -1
  28. package/.flow-comet/skills/flow-comet-evolve/SKILL.md +46 -11
  29. package/.flow-comet/skills/flow-comet-execute/SKILL.md +6 -4
  30. package/.flow-comet/skills/flow-comet-health/SKILL.md +57 -16
  31. package/.flow-comet/skills/flow-comet-integration/SKILL.md +2 -0
  32. package/.flow-comet/skills/flow-comet-open/SKILL.md +2 -0
  33. package/.flow-comet/skills/flow-comet-plan/SKILL.md +17 -6
  34. package/.flow-comet/skills/flow-comet-requirement/SKILL.md +2 -0
  35. package/.flow-comet/skills/flow-comet-review/SKILL.md +7 -5
  36. package/.flow-comet/skills/flow-comet-subagent-execute/SKILL.md +12 -9
  37. package/.flow-comet/skills/flow-comet-task/SKILL.md +7 -3
  38. package/.flow-comet/skills/flow-comet-test/SKILL.md +2 -0
  39. package/.flow-comet/skills/flow-comet-ui-design/SKILL.md +28 -3
  40. package/.flow-comet/skills/flow-comet-verify/SKILL.md +7 -5
  41. package/README.md +45 -119
  42. package/package.json +1 -1
  43. package/scripts/dsh-bridge.mjs +2 -2
@@ -5,7 +5,7 @@ import { fileURLToPath } from 'url';
5
5
  import { validateStateFields, verifyFailuresFor, setVerifyFailuresFor, RUNTIME_STATE_PATH, LEGACY_RUNTIME_STATE_PATH, resolveProtocolPathWithState, hasProtocolCliArg } from './state-schema.mjs';
6
6
  import { readProtocolFile, validateProtocolSchema, NODE_PROTOCOL_FILES, workflowPathInside, inspectWorkflowProtectedPath, readWorkflowProtectedFile, workflowFileObjectIdentity, workflowSameFileObject, workflowSameFileStat } from './protocol-utils.mjs';
7
7
  import { taskOpeningAttrs, taskBlocks as extractTaskBlocks } from './task-parsing.mjs';
8
- import { resolveNextNode, resolveFixRollbackDecision, resolveFixRollbackState, applyFixRollbackRound, resolveFixReturnNode, EXECUTE_FAMILY_NODE_IDS, TASK_SET_SIGNATURE_ALGO, taskSetSignature, parseTaskSetSignature, sameTaskSetSignature, taskSetSignatureVersionSkew, classifyFixReturnCause, normalizeHeading, FIX_SECTION_TITLE_FALLBACK } from './route-node.mjs';
8
+ import { resolveNextNode, resolveFixRollbackDecision, resolveFixRollbackState, applyFixRollbackRound, resolveFixReturnNode, EXECUTE_FAMILY_NODE_IDS, TASK_SET_SIGNATURE_ALGO, taskSetSignature, parseTaskSetSignature, sameTaskSetSignature, taskSetSignatureVersionSkew, classifyFixReturnCause, normalizeHeading, FIX_SECTION_TITLE_FALLBACK, analyzeDependencyGraph, findParallelWriteConflicts } from './route-node.mjs';
9
9
 
10
10
  const command = process.argv[2] ?? 'verify';
11
11
  const nodeId = process.argv[3] ?? null;
@@ -590,48 +590,6 @@ function eligibleParallelBlocks(blocks, doneIds) {
590
590
  });
591
591
  }
592
592
 
593
- // 依赖图分析:对全部 <task> 块建依赖图(deps 边),Kahn 拓扑排序判环 + 缺失依赖收集。
594
- // 返回 { ids, depsById, missing: [{id, dep}], cyclic, cycleIds }(cycleIds = 拓扑排序无解的
595
- // 任务集合,含被环传递拖累的下游任务)。plan 出口波次校验与 subagent-execute 出口孤儿检测
596
- // 共用同一实现(单一语义:依赖图无环 + 依赖链可满足)。
597
- function analyzeDependencyGraph(blocks) {
598
- const parsed = blocks
599
- .map((block) => ({ block, attrs: taskOpeningAttrs(block) }))
600
- .filter((x) => x.attrs && x.attrs.id);
601
- const ids = new Set(parsed.map((x) => x.attrs.id));
602
- const depsById = new Map();
603
- const missing = [];
604
- for (const x of parsed) {
605
- const deps = [...new Set(taskDependsOn(x.block))];
606
- depsById.set(x.attrs.id, deps);
607
- for (const d of deps) {
608
- if (!ids.has(d)) missing.push({ id: x.attrs.id, dep: d });
609
- }
610
- }
611
- const indegree = new Map([...ids].map((id) => [id, 0]));
612
- const dependents = new Map([...ids].map((id) => [id, []]));
613
- for (const [id, deps] of depsById) {
614
- for (const d of deps) {
615
- if (!ids.has(d)) continue;
616
- indegree.set(id, indegree.get(id) + 1);
617
- dependents.get(d).push(id);
618
- }
619
- }
620
- let queue = [...ids].filter((id) => indegree.get(id) === 0);
621
- const sorted = [];
622
- while (queue.length > 0) {
623
- const n = queue.shift();
624
- sorted.push(n);
625
- for (const m of dependents.get(n)) {
626
- indegree.set(m, indegree.get(m) - 1);
627
- if (indegree.get(m) === 0) queue.push(m);
628
- }
629
- }
630
- const cyclic = sorted.length < ids.size;
631
- const cycleIds = cyclic ? [...ids].filter((id) => !sorted.includes(id)) : [];
632
- return { ids, depsById, missing, cyclic, cycleIds };
633
- }
634
-
635
593
  function printNext(protocol, node) {
636
594
  if (!node) {
637
595
  console.log('NEXT: done');
@@ -707,90 +665,6 @@ function missingRequiredSchemaEvidence(protocol, node, evidence) {
707
665
  return missing;
708
666
  }
709
667
 
710
- // 并行文件依赖检测——解析 TASK.md 中本趟可运行的 parallel=pending 任务的 read/write_files 声明,
711
- // 分两级返回:write∩write(写写绝对冲突,强判)与 read∩write(共享读写嫌疑,弱判——仅对彼此
712
- // 无显式 depends_on 关联的并行对探测,有显式关联=依赖已声明,跳过→合法拓扑零新增告警)。
713
- // 路径解析按声明实际内容(换行切分 → 分号二次切分 → trim → 滤空与 HTML 注释),不做扩展名
714
- // 白名单过滤——txt/log/无扩展名路径同等检出(链式重命名的 .txt 事故面闭合;与既有自动解析
715
- // 同源实现)。开标签属性解析与 workflow-state 路由共享 taskOpeningAttrs(属性序无关;不读块内文本)。
716
- async function findParallelWriteConflicts(changeDir) {
717
- const taskFile = path.join(changeDir, 'TASK.md');
718
- let text;
719
- try { text = await fs.readFile(taskFile, 'utf8'); } catch { return { writeConflicts: [], readWarnings: [] }; }
720
- const allBlocks = extractTaskBlocks(text);
721
- // 依赖资格收窄:仅统计「本趟可运行」的并行任务——deps ⊆ doneIds;
722
- // 等待后续趟次的并行任务(依赖未满足)与已交付任务不参与同趟冲突判定,
723
- // 使 A→B 同写路径的跨趟合法计划不再被首趟误拦(与路由谓词同一口径)。
724
- const doneIds = new Set(allBlocks
725
- .map((b) => taskOpeningAttrs(b))
726
- .filter((a) => a && a.id && a.status === 'done')
727
- .map((a) => a.id));
728
- const dependsOnOf = (b) => {
729
- const m = b.match(/<depends_on>([\s\S]*?)<\/depends_on>/);
730
- return m ? m[1].trim().split(/[,\s]+/).filter(Boolean) : [];
731
- };
732
- const blocks = allBlocks.filter((b) => {
733
- const a = taskOpeningAttrs(b);
734
- if (!a || !a.parallel || a.status !== 'pending') return false;
735
- return dependsOnOf(b).every((d) => doneIds.has(d));
736
- });
737
- // 路径解析与既有自动解析同源:剥 HTML 注释 → 换行切分 → 分号二次切分 → trim → 滤空
738
- // 路径归一化(CodeRabbit 采纳):分隔符统一 '/'、解 '.' 段(`./` / `a/./b`)、`..` 逃出项目根
739
- // 按越界处理(返回 null 不参与重叠比较)——`src/a.mjs` vs `src/./a.mjs` / `src\a.mjs` 变体不再
740
- // 绕过写写强判与读写弱判;与委托入口共用同一函数(两侧同语义)。
741
- const normalizeTaskPath = (raw) => {
742
- const p = String(raw).trim();
743
- if (p === '') return null;
744
- const segments = p.replace(/\\/g, '/').split('/').filter((s) => s !== '' && s !== '.');
745
- const out = [];
746
- for (const seg of segments) {
747
- if (seg === '..') {
748
- if (out.length === 0) return null; // 逃出项目根 → 越界(不参与比较)
749
- out.pop();
750
- } else {
751
- out.push(seg);
752
- }
753
- }
754
- return out.join('/');
755
- };
756
- const parsePaths = (matchText) => String(matchText ?? '')
757
- .replace(/<!--[\s\S]*?-->/g, '')
758
- .trim().split(/\s*\n\s*/).map((l) => l.trim()).filter(Boolean)
759
- .flatMap((l) => l.split(';')).map((l) => l.trim()).filter(Boolean)
760
- .map(normalizeTaskPath)
761
- .filter((p) => p !== null && p !== '');
762
- const perTask = [];
763
- for (const b of blocks) {
764
- const a = taskOpeningAttrs(b);
765
- if (!a || !a.id) continue;
766
- const wf = b.match(/<write_files>([\s\S]*?)<\/write_files>/);
767
- const rf = b.match(/<read_files>([\s\S]*?)<\/read_files>/);
768
- if (!wf && !rf) continue;
769
- perTask.push({
770
- id: a.id,
771
- deps: new Set(dependsOnOf(b)),
772
- writes: new Set(parsePaths(wf && wf[1])),
773
- reads: new Set(parsePaths(rf && rf[1])),
774
- });
775
- }
776
- const writeConflicts = [];
777
- const readWarnings = [];
778
- for (let i = 0; i < perTask.length; i++) {
779
- for (let j = i + 1; j < perTask.length; j++) {
780
- const overlap = [...perTask[i].writes].filter((f) => perTask[j].writes.has(f));
781
- if (overlap.length) writeConflicts.push({ a: perTask[i].id, b: perTask[j].id, files: overlap });
782
- // 读写弱判触发面:仅无显式 depends_on 关联的并行对(有显式关联=依赖已声明,跳过)
783
- const associated = perTask[i].deps.has(perTask[j].id) || perTask[j].deps.has(perTask[i].id);
784
- if (associated) continue;
785
- const readOverlap = [...perTask[i].reads].filter((f) => perTask[j].writes.has(f));
786
- if (readOverlap.length) readWarnings.push({ a: perTask[i].id, b: perTask[j].id, files: readOverlap });
787
- const readOverlap2 = [...perTask[j].reads].filter((f) => perTask[i].writes.has(f));
788
- if (readOverlap2.length) readWarnings.push({ a: perTask[j].id, b: perTask[i].id, files: readOverlap2 });
789
- }
790
- }
791
- return { writeConflicts, readWarnings };
792
- }
793
-
794
668
  function escapeRegExp(value) {
795
669
  return String(value).replace(/[|\\{}()[\]^$+?.]/gu, '\\$&');
796
670
  }
@@ -931,6 +805,7 @@ let templateSectionPatternsCache = null;
931
805
 
932
806
  const TEMPLATE_FALLBACK_SECTION_PATTERNS = {
933
807
  changeWhy: /^##\s*Why\b/im,
808
+ changeVisualTone: /^##\s*视觉调性/im,
934
809
  requirementUserStory: /^##\s*用户故事/im,
935
810
  requirementAcceptance: /##\s*(验收准则|验收标准|AC|Acceptance Criteria)/i,
936
811
  designDecisionList: /^##\s*\d*\.?\s*决策清单/m,
@@ -985,6 +860,131 @@ async function templateSectionPatterns() {
985
860
  return result;
986
861
  }
987
862
 
863
+ // ===== ui-design 适用性门控(前端判据 · 结构级,不做语义)=====
864
+ // 协议 design 节点的 ui-design 绑定为 guarded,但它「仅前端」适用 ⇒ 出口自动补 required-skill
865
+ // 声明对该绑定失效(须真实 skill-load 声明),判据不成立(非前端)时按 advisory 处理并在出口
866
+ // 输出可见跳过行(不留假绿:跳过是显式记录,非静默省略)。
867
+ // 键控(enforcement 是这道门的单一表达处):门只在「协议登记了该绑定 ∧ enforcement === 'guarded'」
868
+ // 时存在——协议副本删掉绑定或把等级调回 advisory ⇒ 门不适用(留可见「门未启用」行,不静默消失),
869
+ // 相应路径逐字回到未登记绑定的原语义。门禁侧不持有第二份键表:登记表 APPLICABILITY_GATED_BINDINGS
870
+ // 按 `<nodeId>.<skill>` 键控,工件门与出口自动补写共用下方 applicabilityGatedBinding 查询。
871
+ // 判据必须结构性可判:CHANGE.md 的「视觉调性」段在场且段内不含**结构形态**的「不适用」标记 ⇒
872
+ // 前端;段缺席 / 段内以结构形态标注 ⇒ 非前端。段名基准从 flow-kit/templates/CHANGE.md 派生
873
+ // (与 C2/M3 同源,模板缺失 → 内置骨架名),不做段名第二实现。
874
+ const UI_DESIGN_SKILL = 'flow-comet-ui-design';
875
+ const APPLICABILITY_GATED_BINDINGS = new Set(['design.' + UI_DESIGN_SKILL]);
876
+ const VISUAL_TONE_NOT_APPLICABLE = '不适用';
877
+
878
+ // 负向标记的结构约束(三种形态,共用同一词形边界)——裸子串会让「不适用于暗色主题」这类自然句子
879
+ // 关掉整道门(fail-open),故标记必须落在结构锚位且成词形边界:
880
+ // 形态 A 独立行:整行(去块引用 / 列表符 / 加粗)就是标记,可带括注理由与尾标点;
881
+ // 形态 B 行首:行以标记开头(如「不适用 —— CLI 工具,无用户可见界面。」);
882
+ // 形态 C 字段值位:`<适用性标签>: 不适用`——标签限本约定的短标签表(适用性 / 前端 / 视觉调性 …),
883
+ // 不通配任意字段名:`- 暗色主题:不适用` 这类「某子维度不适用」的字段不得关掉整道门。
884
+ // 词形边界 = 标记后为行尾 / 空白 / 标点 / 括注引号——「不适用于…」的「于」不是边界。
885
+ const TONE_MARKER_TAIL = String.raw`(?=$|[\s,。;、,;.::!!??…—()()【】「」『』“”"'])`;
886
+ const TONE_MARKER_LEAD = String.raw`^[>\s]*(?:[-*+]\s+)?(?:\*\*)?`;
887
+ const TONE_MARKER_FIELD_LABELS = '适用性|适用范围|是否前端|视觉调性|前端|界面|适用';
888
+ const TONE_MARKER_ALONE_LINE = new RegExp(TONE_MARKER_LEAD + VISUAL_TONE_NOT_APPLICABLE
889
+ + String.raw`(?:\*\*)?(?:\s*[((][^))]*[))])?[。.;;,,]?\s*$`);
890
+ const TONE_MARKER_LINE_HEAD = new RegExp(TONE_MARKER_LEAD + VISUAL_TONE_NOT_APPLICABLE
891
+ + String.raw`(?:\*\*)?` + TONE_MARKER_TAIL);
892
+ const TONE_MARKER_FIELD_VALUE = new RegExp(String.raw`(?:^|[\s|])(?:\*\*)?(?:`
893
+ + TONE_MARKER_FIELD_LABELS + String.raw`)(?:\*\*)?\s*[::]\s*(?:\*\*)?`
894
+ + VISUAL_TONE_NOT_APPLICABLE + String.raw`(?:\*\*)?` + TONE_MARKER_TAIL);
895
+
896
+ // 「视觉调性」段正文(段标题之后、下一个 H2 之前;段缺席 → null)
897
+ async function visualToneSectionBody(changeName) {
898
+ if (!changeName) return null;
899
+ let text;
900
+ try {
901
+ text = await fs.readFile(path.join(runRoot, '.specs', changeName, 'CHANGE.md'), 'utf8');
902
+ } catch {
903
+ return null;
904
+ }
905
+ const headingPattern = (await templateSectionPatterns())
906
+ .pick('change', ['视觉调性'], TEMPLATE_FALLBACK_SECTION_PATTERNS.changeVisualTone);
907
+ let body = null;
908
+ for (const line of String(text).replace(/\uFEFF/g, '').split(/\r?\n/)) {
909
+ if (/^##\s+/.test(line)) {
910
+ if (body !== null) break; // 到达下一个 H2 → 本段结束
911
+ if (headingPattern.test(line)) body = '';
912
+ continue;
913
+ }
914
+ if (body !== null) body += line + '\n';
915
+ }
916
+ return body;
917
+ }
918
+
919
+ // 段内负向标记命中(逐行判定——判据限段内):命中 → 返回命中行片段(去空白 + 超长截断),
920
+ // 未命中 → null。片段回显进出口的跳过行,跳过因此自证(不是「段内某处出现过什么字面」)。
921
+ function visualToneNotApplicableHit(body) {
922
+ for (const rawLine of String(body).split(/\r?\n/)) {
923
+ const line = rawLine.trim();
924
+ if (line === '') continue;
925
+ if (TONE_MARKER_ALONE_LINE.test(line)
926
+ || TONE_MARKER_LINE_HEAD.test(line)
927
+ || TONE_MARKER_FIELD_VALUE.test(line)) {
928
+ return line.length > 60 ? line.slice(0, 60) + '…' : line;
929
+ }
930
+ }
931
+ return null;
932
+ }
933
+
934
+ // 登记表查询(唯一键表,键形 `<nodeId>.<skill>`):该节点 + 技能是否受适用性门控
935
+ function isRegisteredApplicabilityBinding(node, skill) {
936
+ return APPLICABILITY_GATED_BINDINGS.has(node.id + '.' + skill);
937
+ }
938
+
939
+ // 适用性门控绑定的单一查询:在场 ∧ enforcement === 'guarded' ∧ 登记在表 → 协议绑定;否则 null。
940
+ // 工件门、出口自动补写与缺声明恢复指引共用本查询——enforcement 是该门的单一表达处。
941
+ function applicabilityGatedBinding(node, skill) {
942
+ if (!isRegisteredApplicabilityBinding(node, skill)) return null;
943
+ return (node.requiredSkillCalls ?? []).find((call) => call.skill === skill && call.enforcement === 'guarded') ?? null;
944
+ }
945
+
946
+ // 前端判据:{ applicable, reason }——applicable=true 表示本 change 判为前端项目
947
+ async function frontendCriterion(changeName) {
948
+ const body = await visualToneSectionBody(changeName);
949
+ if (body === null) return { applicable: false, reason: '「视觉调性」段缺席(判非前端)' };
950
+ const hit = visualToneNotApplicableHit(body);
951
+ if (hit !== null) {
952
+ return { applicable: false, reason: '「视觉调性」段标注「不适用」(判非前端;命中片段: ' + hit + ')' };
953
+ }
954
+ return { applicable: true, reason: '「视觉调性」段在场且未标注「不适用」(判前端;无结构形态标记)' };
955
+ }
956
+
957
+ // design 出口 ui-design 工件门(按协议绑定键控:登记 ∧ 等级 = guarded ∧ 判据成立)——判据成立 ⇒
958
+ // 要求 UI-DESIGN.md 在场:新 change 缺件 BLOCKED + 恢复指引,旧 change WARN 渐进不阻断(不静默
959
+ // 放行);判据不成立(非前端)⇒ 可见跳过行(含命中片段)后照常放行;协议删掉该绑定或等级非
960
+ // guarded ⇒ 门未启用(同样可见输出),行为回到未登记绑定的原语义——闸门开关由协议表达。
961
+ async function checkUiDesignArtifact(node, state) {
962
+ if (!state.activeChange || !isRegisteredApplicabilityBinding(node, UI_DESIGN_SKILL)) return;
963
+ if (!applicabilityGatedBinding(node, UI_DESIGN_SKILL)) {
964
+ const protocolState = (node.requiredSkillCalls ?? []).some((call) => call.skill === UI_DESIGN_SKILL)
965
+ ? '协议 ' + node.id + ' 绑定等级 = advisory,非 guarded'
966
+ : '协议 ' + node.id + ' 节点未登记 ' + UI_DESIGN_SKILL + ' 绑定';
967
+ console.error('UI-DESIGN: 门未启用(' + protocolState + ')');
968
+ return;
969
+ }
970
+ const frontend = await frontendCriterion(state.activeChange);
971
+ if (!frontend.applicable) {
972
+ console.error('UI-DESIGN: skipped(非前端)——' + frontend.reason + ',不要求 UI-DESIGN.md');
973
+ return;
974
+ }
975
+ const artifact = path.join(runRoot, '.specs', state.activeChange, 'UI-DESIGN.md');
976
+ if (await fileExists(artifact)) return;
977
+ const recovery = '补 .specs/' + state.activeChange + '/UI-DESIGN.md(加载 ' + UI_DESIGN_SKILL + ' 并按其协议产出 design token / 反 AI-slop 自检),'
978
+ + '或在 .specs/' + state.activeChange + '/CHANGE.md 的「视觉调性」段以结构形态标注「不适用」(非前端项目)后重试 exit design';
979
+ if (isNewChange(state)) {
980
+ console.error('BLOCKED: design 出口缺 UI-DESIGN.md——' + frontend.reason + ',前端项目须产出 UI-DESIGN.md');
981
+ console.error('恢复: ' + recovery);
982
+ process.exit(1);
983
+ }
984
+ console.error('UI-DESIGN WARN: 缺 .specs/' + state.activeChange + '/UI-DESIGN.md——' + frontend.reason + '(旧 change 渐进不阻断;新 change 将强制)');
985
+ console.error('恢复: ' + recovery);
986
+ }
987
+
988
988
  // Fix 段标题从 <runRoot>/flow-kit/templates/TASK.md 派生(单一模板源 + 模块级缓存 + runRoot 键控):
989
989
  // 扫描模板全部 H2,用 route-node 共享 heading 归一(单一权威,含闭合 ATX)识别 Fix 段标题;
990
990
  // 无匹配(模板缺失 / 读取失败 / 无 Fix 段)返回 undefined,由回程分类器的内置 fallback 常量兜底。
@@ -1616,111 +1616,135 @@ async function main() {
1616
1616
  } catch {}
1617
1617
  }
1618
1618
  }
1619
+ // design 出口 ui-design 工件门(按协议绑定键控:登记 ∧ 等级 = guarded ∧ 判据成立)——见 checkUiDesignArtifact
1620
+ await checkUiDesignArtifact(node, state);
1619
1621
  // plan exit 校验 TASK 含 task 块和 verify 字段
1620
1622
  if (node.id === 'plan' && state.activeChange) {
1621
1623
  const taskFile = path.join(runRoot, '.specs', state.activeChange, 'TASK.md');
1622
- try {
1623
- const content = await fs.readFile(taskFile, 'utf8');
1624
- // <task> 块提取与属性解析统一走 task-parsing.mjs(开标签语义,属性序无关)
1625
- const taskList = extractTaskBlocks(content);
1626
- if (taskList.length === 0) {
1627
- console.error('BLOCKED: TASK.md 无 <task> 块');
1628
- process.exit(1);
1629
- }
1630
- const missingVerify = taskList.filter(b => !/<verify>/.test(b));
1631
- if (missingVerify.length > 0) {
1632
- console.error('BLOCKED: TASK.md 中 ' + missingVerify.length + ' 个 task 缺 <verify> 字段');
1633
- process.exit(1);
1634
- }
1635
- // 波次散文一致性检测: 波次散文一致性检测(WARN 渐进)——## 波次划分 的 Wave 行任务带 [P] 标记
1636
- // (并行语义)但 XML 任务无 parallel="true" → WARN(散文与机器路由依据不一致,以任务
1637
- // 标记为准)。容错:无并行语义的 Wave 行不参与比对;解析不到波次段跳过(不误报)。
1638
- const waveSection = content.match(/##\s*波次划分\s*\n([\s\S]*?)(?=\n##\s|\n---|\Z)/);
1639
- if (waveSection) {
1640
- const proseParallelIds = [];
1641
- for (const line of waveSection[1].split('\n')) {
1642
- if (!/(Wave|\d+\s*波|parallel|并行)/i.test(line)) continue; // 无并行语义行跳过
1643
- for (const m of line.matchAll(/([A-Z][A-Z0-9-]*)\[P\]/g)) proseParallelIds.push(m[1]);
1624
+ // 读文件是唯一需要容错的动作(TASK.md 缺失 → 无内容可判,判据段不适用,保持既有语义);
1625
+ // 判据段独立成层——判据自身抛错不得被空 catch 吞掉:空 catch 会让整段文件依赖门禁(含既有
1626
+ // 写写强判 BLOCK)静默失效,与「未验证 ≠ 通过」相悖。命中即显式报出原因并按 fail-closed 拒绝。
1627
+ let content = null;
1628
+ try { content = await fs.readFile(taskFile, 'utf8'); } catch { content = null; }
1629
+ if (content !== null) {
1630
+ try {
1631
+ // <task> 块提取与属性解析统一走 task-parsing.mjs(开标签语义,属性序无关)
1632
+ const taskList = extractTaskBlocks(content);
1633
+ if (taskList.length === 0) {
1634
+ console.error('BLOCKED: TASK.md 无 <task> 块');
1635
+ process.exit(1);
1644
1636
  }
1645
- if (proseParallelIds.length > 0) {
1646
- const xmlParallelIds = taskList
1647
- .filter(b => { const a = taskOpeningAttrs(b); return a && a.parallel; })
1648
- .map(b => (taskOpeningAttrs(b) || {}).id)
1649
- .filter(Boolean);
1650
- const missing = proseParallelIds.filter(id => !xmlParallelIds.includes(id));
1651
- if (missing.length > 0) {
1652
- if (isNewChange(state)) {
1653
- console.error('BLOCKED: 波次散文标记任务为并行([P])但任务无 parallel="true"(新 change 强制散文与任务标记一致);恢复: 对齐散文或任务标记');
1637
+ const missingVerify = taskList.filter(b => !/<verify>/.test(b));
1638
+ if (missingVerify.length > 0) {
1639
+ console.error('BLOCKED: TASK.md 中 ' + missingVerify.length + ' 个 task 缺 <verify> 字段');
1654
1640
  process.exit(1);
1655
1641
  }
1656
- console.error('WARN: 波次散文标记为并行([P])但任务无 parallel="true"——散文与任务标记不一致(以任务标记为准): ' + missing.join(', '));
1642
+ // 波次散文一致性检测: 波次散文一致性检测(WARN 渐进)——## 波次划分 的 Wave 行任务带 [P] 标记
1643
+ // (并行语义)但 XML 任务无 parallel="true" → WARN(散文与机器路由依据不一致,以任务
1644
+ // 标记为准)。容错:无并行语义的 Wave 行不参与比对;解析不到波次段跳过(不误报)。
1645
+ const waveSection = content.match(/##\s*波次划分\s*\n([\s\S]*?)(?=\n##\s|\n---|\Z)/);
1646
+ if (waveSection) {
1647
+ const proseParallelIds = [];
1648
+ for (const line of waveSection[1].split('\n')) {
1649
+ if (!/(Wave|\d+\s*波|parallel|并行)/i.test(line)) continue; // 无并行语义行跳过
1650
+ for (const m of line.matchAll(/([A-Z][A-Z0-9-]*)\[P\]/g)) proseParallelIds.push(m[1]);
1651
+ }
1652
+ if (proseParallelIds.length > 0) {
1653
+ const xmlParallelIds = taskList
1654
+ .filter(b => { const a = taskOpeningAttrs(b); return a && a.parallel; })
1655
+ .map(b => (taskOpeningAttrs(b) || {}).id)
1656
+ .filter(Boolean);
1657
+ const missing = proseParallelIds.filter(id => !xmlParallelIds.includes(id));
1658
+ if (missing.length > 0) {
1659
+ if (isNewChange(state)) {
1660
+ console.error('BLOCKED: 波次散文标记任务为并行([P])但任务无 parallel="true"(新 change 强制散文与任务标记一致);恢复: 对齐散文或任务标记');
1661
+ process.exit(1);
1662
+ }
1663
+ console.error('WARN: 波次散文标记为并行([P])但任务无 parallel="true"——散文与任务标记不一致(以任务标记为准): ' + missing.join(', '));
1664
+ }
1657
1665
  }
1658
1666
  }
1659
- }
1660
- // 波次分组校验重定义(依赖图校验决策 · 混排合法化):原「并行块必须单个连续且居首/尾」形态约束废除——
1661
- // 串行任务位置不再受限,串→并→串 / 并→串→并 / 多波混合均合法(多趟循环路由按依赖拓扑分趟)。
1662
- // 改为依赖图校验:① 全部任务建依赖图(deps 边)做 Kahn 拓扑排序判环——有环即规划结构性死锁;
1663
- // ② 全部引用的任务 id 必须存在(无环图下「每个 parallel 任务的全部传递依赖存在且非环」
1664
- // ⟺ 直接引用都存在)。违规分级:新 change BLOCKED(含「依赖环」/缺失依赖明细 + depends_on
1665
- // 调整恢复指引);旧 change 渐进 WARN 不阻断。波次散文一致性检测保留不动(与形态约束正交的既有独立检测,维持不变)。
1666
- const depGraph = analyzeDependencyGraph(taskList);
1667
- if (depGraph.cyclic || depGraph.missing.length > 0) {
1668
- const detail = depGraph.cyclic
1669
- ? '依赖环(拓扑排序无解,涉及任务: ' + depGraph.cycleIds.join(', ') + ')'
1670
- : '依赖不存在的任务: ' + depGraph.missing.map((m) => m.id + '→' + m.dep).join(', ');
1671
- const guide = ';恢复: 调整任务 depends_on——移除成环引用或改为真实存在的任务 id 后重试';
1672
- if (isNewChange(state)) {
1673
- console.error('BLOCKED: TASK.md ' + detail + '——依赖图不可满足(任务的依赖链必须存在且无环)' + guide);
1674
- process.exit(1);
1667
+ // 波次分组校验重定义(依赖图校验决策 · 混排合法化):原「并行块必须单个连续且居首/尾」形态约束废除——
1668
+ // 串行任务位置不再受限,串→并→串 / 并→串→并 / 多波混合均合法(多趟循环路由按依赖拓扑分趟)。
1669
+ // 改为依赖图校验:① 全部任务建依赖图(deps 边)做 Kahn 拓扑排序判环——有环即规划结构性死锁;
1670
+ // ② 全部引用的任务 id 必须存在(无环图下「每个 parallel 任务的全部传递依赖存在且非环」
1671
+ // ⟺ 直接引用都存在)。违规分级:新 change BLOCKED(含「依赖环」/缺失依赖明细 + depends_on
1672
+ // 调整恢复指引);旧 change 渐进 WARN 不阻断。波次散文一致性检测保留不动(与形态约束正交的既有独立检测,维持不变)。
1673
+ const depGraph = analyzeDependencyGraph(taskList);
1674
+ if (depGraph.cyclic || depGraph.missing.length > 0) {
1675
+ const detail = depGraph.cyclic
1676
+ ? '依赖环(拓扑排序无解,涉及任务: ' + depGraph.cycleIds.join(', ') + ')'
1677
+ : '依赖不存在的任务: ' + depGraph.missing.map((m) => m.id + '→' + m.dep).join(', ');
1678
+ const guide = ';恢复: 调整任务 depends_on——移除成环引用或改为真实存在的任务 id 后重试';
1679
+ if (isNewChange(state)) {
1680
+ console.error('BLOCKED: TASK.md ' + detail + '——依赖图不可满足(任务的依赖链必须存在且无环)' + guide);
1681
+ process.exit(1);
1682
+ }
1683
+ console.error('WARN: TASK.md ' + detail + '——依赖图不可满足(旧 change 渐进不阻断)' + guide);
1675
1684
  }
1676
- console.error('WARN: TASK.md ' + detail + '——依赖图不可满足(旧 change 渐进不阻断)' + guide);
1677
- }
1678
- // 伪并行检测(真实载体验证暴露的设计盲区兜底):如果一个标记为并行的任务只写测试文件
1679
- // 而无任何生产代码文件,它很可能隐式依赖某个实现类并行任务的产出(如测试 import
1680
- // 尚未存在的函数)。这种"伪并行"在多趟路由下会导致委托后测试失败。
1681
- // 启发式:并行任务的 write_files 全部匹配 tests/ 或 test_ 前缀 → 视为疑似伪并行。
1682
- // WARN 渐进不阻断——由执行者判断是否真独立(纯测试基础设施改动可合法全测试面)。
1683
- const testOnlyParallelIds = [];
1684
- for (const block of taskList) {
1685
- const attrs = taskOpeningAttrs(block);
1686
- if (!attrs || !attrs.parallel || attrs.status !== 'pending') continue;
1687
- const wfMatch = block.match(/<write_files>([\s\S]*?)<\/write_files>/);
1688
- if (!wfMatch) continue;
1689
- // 分号容错:与 workflow-handoff.mjs 自动解析同源实现(分号容错双点内联,与 workflow-handoff.mjs 同源互锚)——
1690
- // 换行切分后逐段按 ';' 二次切分、trim、滤空与 HTML 注释行(路径含分号的极端形态不支持,须换行书写)
1691
- const blockContent = wfMatch[1].replace(/<!--[\s\S]*?-->/g, '');
1692
- const filePaths = blockContent.trim().split(/\s*\n\s*/).map(l => l.trim()).filter(Boolean)
1693
- .flatMap(l => l.split(';')).map(l => l.trim()).filter(Boolean);
1694
- if (filePaths.length === 0) continue;
1695
- const prodFiles = filePaths.filter(f => !/(?:^|[\/\\])(?:__tests__\/|test_|tests?\/)|\.(?:test|spec)\.(?:mjs|js|jsx|ts|tsx|cjs)$/.test(f));
1696
- if (prodFiles.length === 0) {
1697
- testOnlyParallelIds.push(attrs.id || 'unknown');
1685
+ // 伪并行检测(真实载体验证暴露的设计盲区兜底):如果一个标记为并行的任务只写测试文件
1686
+ // 而无任何生产代码文件,它很可能隐式依赖某个实现类并行任务的产出(如测试 import
1687
+ // 尚未存在的函数)。这种"伪并行"在多趟路由下会导致委托后测试失败。
1688
+ // 启发式:并行任务的 write_files 全部匹配 tests/ 或 test_ 前缀 → 视为疑似伪并行。
1689
+ // WARN 渐进不阻断——由执行者判断是否真独立(纯测试基础设施改动可合法全测试面)。
1690
+ const testOnlyParallelIds = [];
1691
+ for (const block of taskList) {
1692
+ const attrs = taskOpeningAttrs(block);
1693
+ if (!attrs || !attrs.parallel || attrs.status !== 'pending') continue;
1694
+ const wfMatch = block.match(/<write_files>([\s\S]*?)<\/write_files>/);
1695
+ if (!wfMatch) continue;
1696
+ // 分号容错:与 workflow-handoff.mjs 自动解析同源实现(分号容错双点内联,与 workflow-handoff.mjs 同源互锚)——
1697
+ // 换行切分后逐段按 ';' 二次切分、trim、滤空与 HTML 注释行(路径含分号的极端形态不支持,须换行书写)
1698
+ const blockContent = wfMatch[1].replace(/<!--[\s\S]*?-->/g, '');
1699
+ const filePaths = blockContent.trim().split(/\s*\n\s*/).map(l => l.trim()).filter(Boolean)
1700
+ .flatMap(l => l.split(';')).map(l => l.trim()).filter(Boolean);
1701
+ if (filePaths.length === 0) continue;
1702
+ const prodFiles = filePaths.filter(f => !/(?:^|[\/\\])(?:__tests__\/|test_|tests?\/)|\.(?:test|spec)\.(?:mjs|js|jsx|ts|tsx|cjs)$/.test(f));
1703
+ if (prodFiles.length === 0) {
1704
+ testOnlyParallelIds.push(attrs.id || 'unknown');
1705
+ }
1698
1706
  }
1699
- }
1700
- if (testOnlyParallelIds.length > 0) {
1701
- console.error('WARN: 伪并行检测——以下并行任务仅写测试文件而无生产代码文件: '
1702
- + testOnlyParallelIds.join(', ')
1703
- + '。测试通常依赖实现产出的符号,可能存在隐式依赖;建议添加 depends_on 声明或合并为垂直切片');
1704
- }
1705
- // 并行文件依赖检测前移(触发面):write∩write 写写强判(新 change BLOCKED / 旧 change
1706
- // WARN 渐进,与依赖环分级同先例)+ read∩write 读写弱判(仅无显式 depends_on 关联的并行对;
1707
- // WARN 提示级,新/旧均不 BLOCK——渐进提示)。与委托前既有拦截并存(委托前为第二道写写锚,
1708
- // 行为与消息保持既有语义不变)。
1709
- const { writeConflicts, readWarnings } = await findParallelWriteConflicts(path.join(runRoot, '.specs', state.activeChange));
1710
- if (writeConflicts.length > 0) {
1711
- const detail = writeConflicts.map((c) => `${c.a}×${c.b}(${c.files.join(',')})`).join('; ');
1712
- const guide = ';恢复: 补显式 depends_on 或拆为串行任务后重试';
1713
- if (isNewChange(state)) {
1714
- console.error('BLOCKED: TASK.md 并行任务 write_files 重叠(写写冲突,同波次并行会竞态覆盖): ' + detail + guide);
1715
- process.exit(1);
1707
+ if (testOnlyParallelIds.length > 0) {
1708
+ console.error('WARN: 伪并行检测——以下并行任务仅写测试文件而无生产代码文件: '
1709
+ + testOnlyParallelIds.join(', ')
1710
+ + '。测试通常依赖实现产出的符号,可能存在隐式依赖;建议添加 depends_on 声明或合并为垂直切片');
1716
1711
  }
1717
- console.error('WARN: TASK.md 并行任务 write_files 重叠(写写冲突,建议补显式 depends_on 或拆为串行任务): ' + detail + guide);
1718
- }
1719
- if (readWarnings.length > 0) {
1720
- console.error('WARN: TASK.md 并行任务 read∩write 隐式依赖嫌疑(一方读取对方写路径,建议补显式 depends_on 声明): '
1721
- + readWarnings.map((c) => `${c.a}×${c.b}(${c.files.join(',')})`).join('; '));
1712
+ // 并行文件依赖检测前移(触发面):write∩write 写写强判(新 change BLOCKED / 旧 change
1713
+ // WARN 渐进,与依赖环分级同先例)+ read∩write 读写弱判(仅无显式 depends_on 关联的并行对;
1714
+ // WARN 提示级,新/旧均不 BLOCK——渐进提示)+ 同文件跨任务且无依赖路径(未完成任务写入面
1715
+ // 重叠而两任务间无依赖路径——新 change BLOCKED / 旧 change WARN 渐进;串行拆分同样命中,
1716
+ // 修复任务族不参与,族语义见 route-node 判定块注释)。与委托前既有拦截并存(委托前为第二道
1717
+ // 写写锚,行为与消息保持既有语义不变)。
1718
+ const { writeConflicts, readWarnings, crossTaskConflicts } = await findParallelWriteConflicts(path.join(runRoot, '.specs', state.activeChange));
1719
+ if (writeConflicts.length > 0) {
1720
+ const detail = writeConflicts.map((c) => `${c.a}×${c.b}(${c.files.join(',')})`).join('; ');
1721
+ const guide = ';恢复: 补显式 depends_on 或拆为串行任务后重试';
1722
+ if (isNewChange(state)) {
1723
+ console.error('BLOCKED: TASK.md 并行任务 write_files 重叠(写写冲突,同波次并行会竞态覆盖): ' + detail + guide);
1724
+ process.exit(1);
1725
+ }
1726
+ console.error('WARN: TASK.md 并行任务 write_files 重叠(写写冲突,建议补显式 depends_on 或拆为串行任务): ' + detail + guide);
1727
+ }
1728
+ if (crossTaskConflicts.length > 0) {
1729
+ const detail = crossTaskConflicts.map((c) => `${c.a}×${c.b}(${c.files.join(',')})`).join('; ');
1730
+ const guide = ';恢复: 补显式 depends_on 或合并为一个任务后重试';
1731
+ if (isNewChange(state)) {
1732
+ console.error('BLOCKED: TASK.md 同文件跨任务且无依赖路径: ' + detail + guide);
1733
+ process.exit(1);
1734
+ }
1735
+ console.error('WARN: TASK.md 同文件跨任务且无依赖路径(建议补显式 depends_on 或合并为一个任务): ' + detail + guide);
1736
+ }
1737
+ if (readWarnings.length > 0) {
1738
+ console.error('WARN: TASK.md 并行任务 read∩write 隐式依赖嫌疑(一方读取对方写路径,建议补显式 depends_on 声明): '
1739
+ + readWarnings.map((c) => `${c.a}×${c.b}(${c.files.join(',')})`).join('; '));
1740
+ }
1741
+ } catch (judgeError) {
1742
+ console.error('BLOCKED: TASK.md 文件依赖判据未执行: '
1743
+ + (judgeError && judgeError.message ? judgeError.message : String(judgeError))
1744
+ + '——门禁无法完成校验,按 fail-closed 拒绝通过(未验证 ≠ 通过)');
1745
+ process.exit(1);
1722
1746
  }
1723
- } catch {}
1747
+ }
1724
1748
  }
1725
1749
  // review exit 校验 REVIEW 含实质内容 + 发现区条目处置状态结构级校验
1726
1750
  if (node.id === 'review' && state.activeChange) {
@@ -1851,6 +1875,12 @@ async function main() {
1851
1875
  process.exit(1);
1852
1876
  }
1853
1877
  }
1878
+ // execute 出口空退出豁免(M6 收窄)——豁免仅适用于「无任何串行任务」的全并行 change;
1879
+ // 含串行任务(parallel!=="true",缺省串行——与 task-parsing.mjs 同语义)时豁免不生效,
1880
+ // 后续产物校验照常执行(陈旧 emptyExitApproved 不得静默放行)。
1881
+ // 判据单一来源:evidence 谓词只在此处求值一次,execute 出口块与 M6 共用(L-067)。
1882
+ const executeEmptyExitApproved = node.id === 'execute' && !!(state.evidence?.execute?.emptyExitApproved);
1883
+ let executeEmptyExitExempt = false;
1854
1884
  // execute 出口校验——统一委托后所有 done 任务需 handoff(越俎代庖检测覆盖串行/并行)
1855
1885
  if (node.id === 'execute' && state.activeChange) {
1856
1886
  const taskFile = path.join(runRoot, '.specs', state.activeChange, 'TASK.md');
@@ -1867,9 +1897,15 @@ async function main() {
1867
1897
  // 串行 pending → BLOCKED(execute 任务没做完)——emptyExitApproved 不豁免串行 pending:
1868
1898
  // 豁免语义是"全 parallel 无串行可做时空退出";存在未完成串行任务时豁免不应生效
1869
1899
  // (防规划错误被豁免掩盖;豁免仅作用于后续产物校验跳过,审计提示保留)
1870
- const emptyExitApproved = !!(state.evidence?.execute && state.evidence.execute.emptyExitApproved);
1871
- if (emptyExitApproved) {
1872
- console.error('EMPTY-EXIT: execute 空退出豁免已生效(evidence.execute.emptyExitApproved)——审计记录:该 change 在无串行任务时显式豁免空退出');
1900
+ if (executeEmptyExitApproved) {
1901
+ // M6 前置条件(收窄):TASK 存在任一串行任务块(parallel!=="true",含缺省)时豁免不生效,
1902
+ // 无论该串行任务 pending 还是 done——陈旧标记不得跳过产物/摘要校验。
1903
+ if (tasks.some(t => !t.parallel)) {
1904
+ console.error('EMPTY-EXIT 未生效:本 change 含串行任务,豁免仅适用于全并行 change');
1905
+ } else {
1906
+ executeEmptyExitExempt = true;
1907
+ console.error('EMPTY-EXIT: execute 空退出豁免已生效(evidence.execute.emptyExitApproved)——审计记录:该 change 在无串行任务时显式豁免空退出');
1908
+ }
1873
1909
  }
1874
1910
  // serialPending 收窄为「可运行串行」(出口拦截集合收窄):仅 deps ⊆ doneIds 的
1875
1911
  // 未完成串行计入拦截——deps 未满足的串行 pending 是等后续波次的合法中间态,放行由多趟
@@ -2391,11 +2427,17 @@ async function main() {
2391
2427
  }
2392
2428
  }
2393
2429
 
2394
- // 自动补 required-skill completedChecks——节点被完成即视为其实现 skill 已加载
2430
+ // 自动补 required-skill completedChecks——节点被完成即视为其实现 skill 已加载。
2431
+ // 分派(ui-design 门):仅「guarded 且适用性判据成立(判前端)」的登记绑定在**新 change**
2432
+ // 上停止自动补——该绑定须真实 skill-load 声明,由下方 missingRequiredSkillChecks 拦截;
2433
+ // 判据不成立(非前端)、旧 change(渐进兼容——自动补写保持原语义,工件门照常 WARN)或未登记
2434
+ // 的绑定 → 逐字保持原自动补语义(其它节点/绑定不受影响)。
2395
2435
  if ((node.requiredSkillCalls ?? []).length > 0) {
2396
2436
  const checks = Array.isArray(evidence.completedChecks) ? evidence.completedChecks : [];
2397
2437
  for (const binding of node.requiredSkillCalls ?? []) {
2398
2438
  const check = 'required-skill:' + node.id + '.' + binding.skill;
2439
+ const applicabilityGated = applicabilityGatedBinding(node, binding.skill) !== null;
2440
+ if (applicabilityGated && isNewChange(state) && (await frontendCriterion(state.activeChange)).applicable) continue;
2399
2441
  if (!checks.includes(check)) checks.push(check);
2400
2442
  }
2401
2443
  evidence.completedChecks = checks;
@@ -2405,9 +2447,15 @@ async function main() {
2405
2447
  console.error('BLOCKED: missing Output Schema evidence: ' + missingSchemaEvidence.join(', '));
2406
2448
  process.exit(1);
2407
2449
  }
2408
- // M6: execute 显式空退出豁免——evidence.execute.emptyExitApproved 时跳过产物校验(全 parallel 无 SUMMARY 属预期)
2409
- const missingArtifacts = (node.id === 'execute' && state.evidence?.execute?.emptyExitApproved)
2410
- ? [] : await missingRequiredArtifacts(protocol, node, state.activeChange);
2450
+ // M6: execute 显式空退出豁免——仅当豁免活性成立(executeEmptyExitApproved 且 TASK 无任何
2451
+ // 串行任务)时跳过产物校验(全 parallel 无 SUMMARY 属预期);含串行任务的 change 豁免不生效,
2452
+ // 照常校验,不得静默放行。生效时追加被跳过项清单(EMPTY-EXIT-SKIPPED)。
2453
+ const checkedArtifacts = await missingRequiredArtifacts(protocol, node, state.activeChange);
2454
+ let missingArtifacts = checkedArtifacts;
2455
+ if (executeEmptyExitApproved && executeEmptyExitExempt) {
2456
+ console.error('EMPTY-EXIT-SKIPPED: ' + (checkedArtifacts.length > 0 ? checkedArtifacts.join(', ') : '(无缺失产物项)'));
2457
+ missingArtifacts = [];
2458
+ }
2411
2459
  if (missingArtifacts.length > 0) {
2412
2460
  console.error('BLOCKED: missing Output Schema artifacts: ' + missingArtifacts.join(', '));
2413
2461
  process.exit(1);
@@ -2415,6 +2463,16 @@ async function main() {
2415
2463
  const missingRequired = missingRequiredSkillChecks(node, evidence);
2416
2464
  if (missingRequired.length > 0) {
2417
2465
  console.error('BLOCKED: missing required Skill evidence: ' + missingRequired.join(', '));
2466
+ // ui-design 门:适用性门控绑定缺的是「真实 skill-load 声明」(出口不再自动补写)——给出补齐路径
2467
+ // (判据与该门同源:applicabilityGatedBinding 查询,不在此另写键表)
2468
+ for (const binding of node.requiredSkillCalls ?? []) {
2469
+ const check = 'required-skill:' + node.id + '.' + binding.skill;
2470
+ if (missingRequired.includes(check) && applicabilityGatedBinding(node, binding.skill) !== null) {
2471
+ console.error('恢复: ' + check + ' 不再由出口自动补写(guarded + 适用性判据成立)——先加载 ' + binding.skill
2472
+ + ' 并运行 workflow-state.mjs skill-load ' + node.id + ' ' + binding.skill
2473
+ + ' --prompt <flow-kit/prompts/ 协议文件> 声明已加载后重试 exit');
2474
+ }
2475
+ }
2418
2476
  process.exit(1);
2419
2477
  }
2420
2478
  const missingAugmentations = missingAugmentationChecks(node, evidence);