flow-comet 1.6.5 → 1.7.0
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.
- package/.flow-comet/skills/flow-comet/INSTALLED_VERSION +1 -1
- package/.flow-comet/skills/flow-comet/SKILL.md +17 -5
- package/.flow-comet/skills/flow-comet/reference/commit-discipline.md +1 -1
- package/.flow-comet/skills/flow-comet/reference/entry-detail.md +23 -4
- package/.flow-comet/skills/flow-comet/scripts/context-init.mjs +26 -23
- package/.flow-comet/skills/flow-comet/scripts/guard-self-test.mjs +14 -94
- package/.flow-comet/skills/flow-comet/scripts/items/a.mjs +97 -3
- package/.flow-comet/skills/flow-comet/scripts/items/b.mjs +38 -2
- package/.flow-comet/skills/flow-comet/scripts/items/e.mjs +52 -10
- package/.flow-comet/skills/flow-comet/scripts/items/h.mjs +16 -3
- package/.flow-comet/skills/flow-comet/scripts/items/l.mjs +2 -0
- package/.flow-comet/skills/flow-comet/scripts/items/m.mjs +4 -0
- package/.flow-comet/skills/flow-comet/scripts/items/n.mjs +20 -11
- package/.flow-comet/skills/flow-comet/scripts/lib/ac-coverage.mjs +317 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-artifact-skeleton.mjs +47 -5
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-evidence-gates.mjs +297 -131
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-gates.mjs +616 -151
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-routing.mjs +96 -45
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-state-io.mjs +8 -6
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-template-fidelity.mjs +204 -51
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-uidesign.mjs +7 -9
- package/.flow-comet/skills/flow-comet/scripts/lib/lessons-hits.mjs +160 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/run-root.mjs +21 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/section-body.mjs +92 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-admin.mjs +38 -20
- package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-flow.mjs +439 -134
- package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-recovery.mjs +66 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-explain.mjs +92 -13
- package/.flow-comet/skills/flow-comet/scripts/lib/state-io.mjs +55 -2
- package/.flow-comet/skills/flow-comet/scripts/lib/state-skillmarkers.mjs +94 -39
- package/.flow-comet/skills/flow-comet/scripts/lib/system-fixtures.mjs +6 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/task-graph.mjs +84 -31
- package/.flow-comet/skills/flow-comet/scripts/lib/test-fixtures.mjs +57 -7
- package/.flow-comet/skills/flow-comet/scripts/lib/test-helpers.mjs +60 -3
- package/.flow-comet/skills/flow-comet/scripts/lib/text-anchor-checks.mjs +158 -3
- package/.flow-comet/skills/flow-comet/scripts/lib/wave-projection.mjs +341 -0
- package/.flow-comet/skills/flow-comet/scripts/protocol-utils.mjs +92 -17
- package/.flow-comet/skills/flow-comet/scripts/scenarios/a.mjs +1439 -11
- package/.flow-comet/skills/flow-comet/scripts/scenarios/b.mjs +1202 -8
- package/.flow-comet/skills/flow-comet/scripts/scenarios/c.mjs +1204 -76
- package/.flow-comet/skills/flow-comet/scripts/scenarios/d.mjs +753 -5
- package/.flow-comet/skills/flow-comet/scripts/scenarios/e.mjs +32 -1
- package/.flow-comet/skills/flow-comet/scripts/scenarios/f.mjs +582 -3
- package/.flow-comet/skills/flow-comet/scripts/scenarios/g.mjs +5 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/i.mjs +5 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/j.mjs +16 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/k.mjs +2 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/l.mjs +5 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/n.mjs +2041 -66
- package/.flow-comet/skills/flow-comet/scripts/state-schema.mjs +135 -0
- package/.flow-comet/skills/flow-comet/scripts/workflow-guard.mjs +143 -16
- package/.flow-comet/skills/flow-comet/scripts/workflow-handoff.mjs +312 -63
- package/.flow-comet/skills/flow-comet/scripts/workflow-state.mjs +5 -2
- package/.flow-comet/skills/flow-comet-execute/SKILL.md +30 -6
- package/.flow-comet/skills/flow-comet-plan/SKILL.md +10 -3
- package/.flow-comet/skills/flow-comet-review/SKILL.md +20 -11
- package/.flow-comet/skills/flow-comet-subagent-execute/SKILL.md +33 -8
- package/.flow-comet/skills/flow-comet-task/SKILL.md +2 -1
- package/README.md +1 -1
- package/package.json +1 -1
- package/scripts/dsh-bridge.mjs +2 -2
|
@@ -15,6 +15,7 @@
|
|
|
15
15
|
import fs from 'fs';
|
|
16
16
|
import path from 'path';
|
|
17
17
|
import { spawnSync } from 'child_process';
|
|
18
|
+
import { pathToFileURL } from 'url';
|
|
18
19
|
import {
|
|
19
20
|
assertExit,
|
|
20
21
|
assertNotOut,
|
|
@@ -33,19 +34,43 @@ import {
|
|
|
33
34
|
TASK_DONE,
|
|
34
35
|
customProtocol,
|
|
35
36
|
dropNamedImport,
|
|
37
|
+
engineCodeText,
|
|
36
38
|
engineDefinitionHits,
|
|
37
39
|
engineDefinitionModule,
|
|
40
|
+
engineDefinitionPattern,
|
|
41
|
+
engineImportsSymbolFrom,
|
|
38
42
|
engineScriptTexts,
|
|
39
43
|
handoffFor,
|
|
44
|
+
HANDOFF,
|
|
45
|
+
STATE,
|
|
46
|
+
writeNodeDeclarationMarkers,
|
|
40
47
|
} from '../lib/test-fixtures.mjs';
|
|
41
48
|
import { scenarioProtocolPath } from '../lib/test-assertions.mjs';
|
|
42
|
-
import {
|
|
49
|
+
import { taskBlocks } from '../task-parsing.mjs';
|
|
50
|
+
// 波次段名的登记点与「登记名 ↔ 模板段名」对账:登记值在骨架模块(模板缺席时的段名基准唯一登记处),
|
|
51
|
+
// 归一化取共享实现——两边同一把尺子,改字的段名不得被判成一致。
|
|
52
|
+
import { WAVE_SECTION_NAME } from '../lib/guard-artifact-skeleton.mjs';
|
|
53
|
+
import { normalizeHeading } from '../route-node.mjs';
|
|
54
|
+
import {
|
|
55
|
+
AUTHORITATIVE_SOURCE_ANCHOR_REL,
|
|
56
|
+
GITHOOKS_CODES_REL,
|
|
57
|
+
PUBLIC_FACE_CODE_DOCS,
|
|
58
|
+
SCENARIO_COUNT_FILES,
|
|
59
|
+
SYSTEM_TEST_COUNT_FILES,
|
|
60
|
+
maintainerFacePresent,
|
|
61
|
+
publicFaceDocsAbsent,
|
|
62
|
+
publicFaceSelfCheck,
|
|
63
|
+
singleSourceImportProblems,
|
|
64
|
+
} from '../lib/text-anchor-checks.mjs';
|
|
43
65
|
|
|
44
66
|
// ---------- 登记表与模板夹具(夹具输入面,不是判据) ----------
|
|
45
67
|
|
|
46
68
|
const REGISTRY_FILE = path.join(SCRIPTS_DIR, '..', 'reference', 'artifact-templates.json');
|
|
47
69
|
const CHANGE_DIR = '.specs/' + CHANGE_ID;
|
|
48
70
|
const SKILLS_ROOT = path.join(SCRIPTS_DIR, '..', '..');
|
|
71
|
+
// 公开文档面的形态判据来自 lib 的 publicFaceDocsAbsent(与底部自检、场景 105 同一实现):本组不再
|
|
72
|
+
// 自持第二套(曾按 docs/authority-map.json 是否在场分流,与 lib 的 docs/ 判据各说各话)。
|
|
73
|
+
// 只按 docs/ 在不在也不够——分支 / 稀疏检出 / 误删把 docs/ 拿掉时,整块判据会变成可见 SKIP。
|
|
49
74
|
|
|
50
75
|
let registryMemo;
|
|
51
76
|
function artifactRegistry() {
|
|
@@ -238,12 +263,18 @@ const VERIFY_COMMAND_BODY = ['```', 'node --check baseline.js', '```'].join('\n'
|
|
|
238
263
|
const TASK_BLOCK_BODY = '<task id="T01" status="done"><action>实现夹具被测项</action>'
|
|
239
264
|
+ '<write_files>src/fixture.mjs</write_files><verify>node --check baseline.js</verify></task>';
|
|
240
265
|
|
|
266
|
+
// 波次段正文:夹具任务 T01 无依赖 ⇒ 第 1 波。段在场却一条 Wave 行都没有时,plan 出口按「波次划分段
|
|
267
|
+
// 内容不可判」拦(未验证 ≠ 通过)——本场景测的是「缺必填 H2」的段形判据,波次段必须写出可判声明,
|
|
268
|
+
// 否则它先被波次判据拦下,被测报文根本不会出现。
|
|
269
|
+
const TASK_WAVE_BODY = ['```', 'Wave 1: T01', '```'].join('\n');
|
|
270
|
+
|
|
241
271
|
// 段级正文覆盖:[模板键, 段名片段, 正文]——只在夹具需要实质内容的位置使用。
|
|
242
272
|
const BODY_OVERRIDES = [
|
|
243
273
|
['SUMMARY', '6 维自查', SIX_DIM_BODY],
|
|
244
274
|
['SUMMARY', 'verify 输出', VERIFY_COMMAND_BODY],
|
|
245
275
|
['REQUIREMENT', '验收准则', '- Given 夹具前置\n- When 夹具动作\n- Then 夹具结果(AC 夹具)'],
|
|
246
276
|
['REQUIREMENT', '用户故事', '- US-1 作为执行者,我想让夹具可通过结构校验。'],
|
|
277
|
+
['TASK', '波次划分', TASK_WAVE_BODY],
|
|
247
278
|
['TASK', '任务清单', TASK_BLOCK_BODY],
|
|
248
279
|
['REVIEW', '2.2', '- **F1 · 夹具发现**:某处存在一个可记录的衰退风险 [已修]\n'
|
|
249
280
|
+ ' - **Symptom**: 夹具现象\n - **Source**: 夹具来源\n'
|
|
@@ -404,17 +435,9 @@ function uiDesignDoc(opts = {}, omitKeys = []) {
|
|
|
404
435
|
|
|
405
436
|
// 前端 change 的声明标记:节点自身协议标记(design → 2-design.md)与 ui-design 技能标记
|
|
406
437
|
// (guarded 绑定要求真实声明)。两者缺一都会先被证据门 / 标记门拦下,掩盖被测的段形判据。
|
|
438
|
+
// 走统一的声明标记夹具(协议派生,不手抄技能/协议清单);前端 = 连条件绑定的 ui-design 一起声明。
|
|
407
439
|
function writeFrontendDesignMarkers(dir) {
|
|
408
|
-
|
|
409
|
-
JSON.stringify({
|
|
410
|
-
node: 'design', skill: 'flow-comet-design', protocol: '2-design.md',
|
|
411
|
-
templates: ['DESIGN'], at: '2026-08-01T00:00:00.000Z',
|
|
412
|
-
}, null, 2) + '\n');
|
|
413
|
-
writeFile(dir, CHANGE_DIR + '/.skill-loads/design-flow-comet-ui-design.json',
|
|
414
|
-
JSON.stringify({
|
|
415
|
-
node: 'design', skill: 'flow-comet-ui-design', protocol: '2a-ui-design.md',
|
|
416
|
-
templates: ['UI-DESIGN'], at: '2026-08-01T00:00:00.000Z',
|
|
417
|
-
}, null, 2) + '\n');
|
|
440
|
+
writeNodeDeclarationMarkers(dir, 'design', { frontend: true });
|
|
418
441
|
}
|
|
419
442
|
|
|
420
443
|
// 每个 setup 先清空 change 目录与归档目录:同一夹具根里连续构造多组用例时,上一组残留的工件
|
|
@@ -434,6 +457,7 @@ function setupOpen(dir, changeOpts = {}, requirementOpts = {}) {
|
|
|
434
457
|
const st = newChangeState('open');
|
|
435
458
|
st.evidence.open = { summary: 'intake complete' };
|
|
436
459
|
writeState(dir, st);
|
|
460
|
+
writeNodeDeclarationMarkers(dir, 'open');
|
|
437
461
|
}
|
|
438
462
|
|
|
439
463
|
function setupDesign(dir, { changeOpts = {}, designOpts = {}, uiDesign = undefined, declareUiDesign = false } = {}) {
|
|
@@ -452,6 +476,8 @@ function setupDesign(dir, { changeOpts = {}, designOpts = {}, uiDesign = undefin
|
|
|
452
476
|
? { summary: 'design done', completedChecks: ['required-skill:design.flow-comet-ui-design'] }
|
|
453
477
|
: { summary: 'design done' };
|
|
454
478
|
writeState(dir, st);
|
|
479
|
+
// 前端夹具(uiDesign 在场 = 前端)连条件绑定的 ui-design 一起声明;非前端不写它(本就不要求)。
|
|
480
|
+
writeNodeDeclarationMarkers(dir, 'design', { frontend: uiDesign !== undefined });
|
|
455
481
|
}
|
|
456
482
|
|
|
457
483
|
function setupPlan(dir, taskOpts = {}) {
|
|
@@ -461,6 +487,7 @@ function setupPlan(dir, taskOpts = {}) {
|
|
|
461
487
|
const st = newChangeState('plan');
|
|
462
488
|
st.evidence.plan = { summary: 'plan done' };
|
|
463
489
|
writeState(dir, st);
|
|
490
|
+
writeNodeDeclarationMarkers(dir, 'plan');
|
|
464
491
|
}
|
|
465
492
|
|
|
466
493
|
function setupExecute(dir, summaryOpts = {}) {
|
|
@@ -473,6 +500,7 @@ function setupExecute(dir, summaryOpts = {}) {
|
|
|
473
500
|
st.evidence.execute = { summary: 'executed' };
|
|
474
501
|
st.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01']) };
|
|
475
502
|
writeState(dir, st);
|
|
503
|
+
writeNodeDeclarationMarkers(dir, 'execute');
|
|
476
504
|
}
|
|
477
505
|
|
|
478
506
|
function setupReview(dir, reviewOpts = {}) {
|
|
@@ -482,17 +510,33 @@ function setupReview(dir, reviewOpts = {}) {
|
|
|
482
510
|
const st = newChangeState('review');
|
|
483
511
|
st.evidence.review = { summary: 'review done' };
|
|
484
512
|
writeState(dir, st);
|
|
513
|
+
writeNodeDeclarationMarkers(dir, 'review');
|
|
485
514
|
}
|
|
486
515
|
|
|
516
|
+
// verify 夹具自带的 AC 覆盖配对(准则清单 + 1.1 矩阵行):verify 出口先跑 AC 覆盖判据,新 change 下
|
|
517
|
+
// 缺 `REQUIREMENT.md` 或矩阵行会在被测的段形判据之前拦下——夹具因此给出可判的最小一对,
|
|
518
|
+
// 覆盖之外的形态(缺段 / 缺子段 / 矩阵段改标题)由各用例自己改写。
|
|
519
|
+
const AC_COVERAGE_REQUIREMENT_BODY = '- **AC-1**: Given 夹具前置 When 夹具动作 Then 夹具结果';
|
|
520
|
+
const AC_COVERAGE_MATRIX_BODY = ['| AC | 类型 | 用例文件 / UAT | 状态 |', '|---|---|---|---|',
|
|
521
|
+
'| AC-1 | unit | baseline.js | ✅ |'].join('\n');
|
|
522
|
+
|
|
487
523
|
function setupVerify(dir, testOpts = {}) {
|
|
488
524
|
resetFixture(dir);
|
|
489
525
|
writeTemplateFixture(dir, 'TEST');
|
|
526
|
+
writeTemplateFixture(dir, 'REQUIREMENT');
|
|
490
527
|
writeBaseline(dir);
|
|
491
|
-
writeFile(dir, CHANGE_DIR + '/
|
|
528
|
+
writeFile(dir, CHANGE_DIR + '/REQUIREMENT.md', renderDoc('REQUIREMENT', {
|
|
529
|
+
body: [['验收准则', AC_COVERAGE_REQUIREMENT_BODY]],
|
|
530
|
+
}));
|
|
531
|
+
writeFile(dir, CHANGE_DIR + '/TEST.md', renderDoc('TEST', {
|
|
532
|
+
...testOpts,
|
|
533
|
+
body: [...(testOpts.body ?? []), ['1.1', AC_COVERAGE_MATRIX_BODY]],
|
|
534
|
+
}));
|
|
492
535
|
writeFile(dir, CHANGE_DIR + '/UAT.md', '# UAT\n\n## 验收结果\n\n- 通过(夹具)。\n');
|
|
493
536
|
const st = newChangeState('verify');
|
|
494
537
|
st.evidence.verify = { summary: 'verified' };
|
|
495
538
|
writeState(dir, st);
|
|
539
|
+
writeNodeDeclarationMarkers(dir, 'verify');
|
|
496
540
|
}
|
|
497
541
|
|
|
498
542
|
const LESSONS_FIXTURE = [
|
|
@@ -525,6 +569,9 @@ function setupArchive(dir, { evidence = {}, lessons = LESSONS_FIXTURE, summaryCo
|
|
|
525
569
|
const st = newChangeState('archive');
|
|
526
570
|
st.evidence.archive = { summary: 'archived', ...evidence };
|
|
527
571
|
writeState(dir, st);
|
|
572
|
+
// 标记写在**活动** change 目录里(真实链路里它随归档动作一起搬家——模拟搬家的用例自己 rename
|
|
573
|
+
// CHANGE_DIR,标记因此天然跟随;找不到活动路径时 findSkillLoadsDir 才回溯归档路径)。
|
|
574
|
+
writeNodeDeclarationMarkers(dir, 'archive', { changeId: CHANGE_ID });
|
|
528
575
|
}
|
|
529
576
|
|
|
530
577
|
function runSideCommand(dir, scriptRel, args) {
|
|
@@ -549,6 +596,18 @@ function repoFileExists(rel) {
|
|
|
549
596
|
return fs.existsSync(path.join(REPO_ROOT, ...rel.split('/')));
|
|
550
597
|
}
|
|
551
598
|
|
|
599
|
+
// 公开面缺席判据(同一实现驱动真实断言与变异探针):形态判据认定本检出带公开面时(docs/、
|
|
600
|
+
// CONTRIBUTING.md 或 .github/ 任一在场,见 lib 的 publicFaceDocsAbsent),该面任何一份文档缺席都是
|
|
601
|
+
// 判据失效——「两份机制册都被删」若只落一条 SKIP,公开面机制文档整份消失而套件仍绿。缺席的读法
|
|
602
|
+
// 不能由「少了哪份文件」自行决定:只有整份载体俱缺才是合法的「不在本检出」,由调用方输出可见 SKIP
|
|
603
|
+
// 并声明未校验。
|
|
604
|
+
function publicFaceAbsenceProblems(docs) {
|
|
605
|
+
const missing = [...docs].filter(([, text]) => typeof text !== 'string').map(([rel]) => rel);
|
|
606
|
+
if (missing.length === 0) return [];
|
|
607
|
+
return ['公开面文档不在检出面: ' + missing.join('、')
|
|
608
|
+
+ '(形态判据认定本检出带公开面,未走跳过通道;文档缺席即判据失效,不是「本次未校验」)'];
|
|
609
|
+
}
|
|
610
|
+
|
|
552
611
|
// 文本判据(同一函数驱动真实断言与变异探针):rules = [{ rel, label, include[], exclude[] }]。
|
|
553
612
|
function textRuleProblems(docs, rules) {
|
|
554
613
|
const problems = [];
|
|
@@ -585,6 +644,633 @@ function assertProbesDiscriminate(problems, docs, rules, probes) {
|
|
|
585
644
|
}
|
|
586
645
|
}
|
|
587
646
|
|
|
647
|
+
// 公开面自检的**形态分派**(判定本体在 lib:publicFaceSelfCheck)——各载体形态各造一个临时根、驱动
|
|
648
|
+
// 同一判定,分派对错因此成为常驻断言,不必等到在包形态里整跑一次套件才知道:
|
|
649
|
+
// ① 包形态(技能树锚在场、docs/ + CONTRIBUTING.md + .github/ 三者俱缺)→ SKIP 通知 + 零问题:
|
|
650
|
+
// 这种载体本来就不带公开面,「受检条目不在场」是它的正常形态;报成幽灵条目会把读者送去修一个
|
|
651
|
+
// 不存在的缺陷;
|
|
652
|
+
// ② 权威源形态完整(受检面文件照真迹复制,计数自然同步)→ 零问题(判据不是恒红的摆设);
|
|
653
|
+
// ③ 同一根上移走一份受检文档(docs/VERSIONS.md)→ 必须报问题并点名该文件——跳过通道只对
|
|
654
|
+
// 「整份公开面不存在」开放,判据没有顺手放宽;
|
|
655
|
+
// ④ 安装副本形态(无技能树锚)→ 词表镜像判据的「不适用」说明 + 零问题;
|
|
656
|
+
// ⑤ 半包形态(docs/ 整份不在,但 CONTRIBUTING.md 或 .github/ 在场)→ 必须照跑全判据并判红:
|
|
657
|
+
// 这两份同样不进 npm tarball,任一在场即证明本检出是仓库(只是被裁坏了);只按 docs/ 分流会让
|
|
658
|
+
// 分支 / 稀疏检出 / 误删把整块判据变成 SKIP 并 exit 0。
|
|
659
|
+
// 形态本身同样由既有判据派生(技能树锚 + publicFaceDocsAbsent),夹具不另写一套形态判据。
|
|
660
|
+
|
|
661
|
+
// 受检面文件清单(照真迹复制的范围)= 公开产物零代号清单 ∪ 计数受检清单 ∪ 词表私有面:
|
|
662
|
+
// 三面齐了同一次判定才可能零问题——少一面就会以问题形态暴露,夹具不会悄悄缩小判据面。
|
|
663
|
+
function countFaceFiles() {
|
|
664
|
+
return [...new Set([
|
|
665
|
+
...PUBLIC_FACE_CODE_DOCS, ...SCENARIO_COUNT_FILES, ...SYSTEM_TEST_COUNT_FILES, GITHOOKS_CODES_REL,
|
|
666
|
+
])];
|
|
667
|
+
}
|
|
668
|
+
|
|
669
|
+
function copyRepoFileInto(root, rel) {
|
|
670
|
+
const parts = rel.split('/');
|
|
671
|
+
const dest = path.join(root, ...parts);
|
|
672
|
+
fs.mkdirSync(path.dirname(dest), { recursive: true });
|
|
673
|
+
fs.copyFileSync(path.join(REPO_ROOT, ...parts), dest);
|
|
674
|
+
}
|
|
675
|
+
|
|
676
|
+
async function assertPublicFaceSelfCheckShapes(dir) {
|
|
677
|
+
const shapeRoot = (name, { authoritative = true } = {}) => {
|
|
678
|
+
const root = path.join(dir, 'shape-' + name);
|
|
679
|
+
fs.mkdirSync(root, { recursive: true });
|
|
680
|
+
// 技能树锚点:与真实检出同一相对位置(路径字面量由 lib 单点拥有,不在此重写)
|
|
681
|
+
if (authoritative) writeFile(root, AUTHORITATIVE_SOURCE_ANCHOR_REL, '---\nname: flow-comet\n---\n');
|
|
682
|
+
return root;
|
|
683
|
+
};
|
|
684
|
+
const describe = (result) => result.problems.map((problem) => problem.name + ': ' + problem.error).join('; ')
|
|
685
|
+
|| '(零问题)';
|
|
686
|
+
// ① 包形态(docs/ + CONTRIBUTING.md + .github/ 三者俱缺):分派若改成「照跑全套」,这里会报一串
|
|
687
|
+
// 「受检条目文件缺失(幽灵条目)」——正是要拦的形态
|
|
688
|
+
const packaged = await publicFaceSelfCheck({ root: shapeRoot('package') });
|
|
689
|
+
if (packaged.problems.length > 0) {
|
|
690
|
+
throw new Error('包形态(技能树锚在、docs/ 与 CONTRIBUTING.md / .github/ 俱缺)不得报问题——'
|
|
691
|
+
+ '受检条目不在场是这种载体的正常形态,报出来就是幽灵条目: ' + describe(packaged));
|
|
692
|
+
}
|
|
693
|
+
if (packaged.skip === null || packaged.skip.reason !== 'package-without-public-face') {
|
|
694
|
+
throw new Error('包形态应命中显式跳过分支(skip.reason=package-without-public-face): '
|
|
695
|
+
+ JSON.stringify(packaged.skip));
|
|
696
|
+
}
|
|
697
|
+
if (!packaged.skip.notice.includes('未校验')) {
|
|
698
|
+
throw new Error('包形态的跳过提示必须写明「未校验」(跳过 ≠ 通过): ' + packaged.skip.notice);
|
|
699
|
+
}
|
|
700
|
+
// ② 权威源形态完整:受检面文件照真迹复制,计数自然同步(不硬编码数字)
|
|
701
|
+
const full = shapeRoot('authoritative');
|
|
702
|
+
for (const rel of countFaceFiles()) copyRepoFileInto(full, rel);
|
|
703
|
+
const complete = await publicFaceSelfCheck({ root: full });
|
|
704
|
+
if (complete.problems.length > 0) {
|
|
705
|
+
throw new Error('权威源形态完整(受检面文件照真迹复制)不应报问题: ' + describe(complete));
|
|
706
|
+
}
|
|
707
|
+
// ③ 同一根上移走一份受检文档:跳过通道只对「整份公开面不存在」开放,缺一份必须判红并点名
|
|
708
|
+
const removedDoc = 'docs/VERSIONS.md';
|
|
709
|
+
fs.rmSync(path.join(full, ...removedDoc.split('/')));
|
|
710
|
+
const truncated = await publicFaceSelfCheck({ root: full });
|
|
711
|
+
if (!truncated.problems.some((problem) => problem.error.includes(removedDoc))) {
|
|
712
|
+
throw new Error('权威源形态里移走一份受检文档必须报问题并点名该文件(判据不得因形态分派而放宽): '
|
|
713
|
+
+ describe(truncated));
|
|
714
|
+
}
|
|
715
|
+
// ④ 安装副本形态:无技能树锚 = 主仓私有面结构性缺席 → 「不适用」说明,不误红
|
|
716
|
+
const installed = await publicFaceSelfCheck({ root: shapeRoot('installed', { authoritative: false }) });
|
|
717
|
+
if (installed.problems.length > 0 || installed.skip === null
|
|
718
|
+
|| installed.skip.reason !== 'installed-copy-without-skill-tree') {
|
|
719
|
+
throw new Error('安装副本形态(无技能树锚)应命中「不适用」分支且零问题: '
|
|
720
|
+
+ JSON.stringify(installed.skip) + ' / ' + describe(installed));
|
|
721
|
+
}
|
|
722
|
+
if (!installed.skip.notice.includes('不适用')) {
|
|
723
|
+
throw new Error('安装副本形态的跳过提示必须写明「不适用」(不适用 ≠ 已校验): ' + installed.skip.notice);
|
|
724
|
+
}
|
|
725
|
+
// ⑤ 半包形态(docs/ 整份不在,但 CONTRIBUTING.md 或 .github/ 在场):必须是判红,不得复用包形态的
|
|
726
|
+
// 跳过通道——否则分支 / 稀疏检出 / 误删把 docs/ 拿掉时,计数一致性、公开产物零代号与词表镜像会整块
|
|
727
|
+
// 变成可见 SKIP 并 exit 0。两份载体分开造根:任一单独在场都足以证明本检出是仓库而不是「本来不带
|
|
728
|
+
// 公开面」的 npm 包 / 安装副本(两者都不进 npm tarball;README 会被 npm 强制包含,不作判据)。
|
|
729
|
+
for (const carrier of ['CONTRIBUTING.md', '.github/workflows/ci.yml']) {
|
|
730
|
+
const partial = shapeRoot('docs-less-' + carrier.split('/')[0].replace(/\./g, ''));
|
|
731
|
+
writeFile(partial, carrier, '');
|
|
732
|
+
const partialResult = await publicFaceSelfCheck({ root: partial });
|
|
733
|
+
if (partialResult.skip !== null) {
|
|
734
|
+
throw new Error('docs/ 不在但 ' + carrier + ' 在场不得命中跳过分支(skip.reason='
|
|
735
|
+
+ partialResult.skip.reason + ')——该形态下公开面判据会整块变成 SKIP 并 exit 0');
|
|
736
|
+
}
|
|
737
|
+
if (!partialResult.problems.some((problem) => problem.name === '计数一致性')) {
|
|
738
|
+
throw new Error('docs/ 不在但 ' + carrier + ' 在场时必须照跑计数一致性并判红,实际: '
|
|
739
|
+
+ describe(partialResult));
|
|
740
|
+
}
|
|
741
|
+
}
|
|
742
|
+
}
|
|
743
|
+
|
|
744
|
+
// 机制表行判据(同一函数驱动真实断言与变异探针)。机制行按**结构**定位,不按「首个含某组词的行」:
|
|
745
|
+
// 文档正文随时可能为另一条修正补进既含「段名」又有 plan 的段落,词形判据会被它抢位(已实证的失效形态)。
|
|
746
|
+
// 结构 = markdown 表格的数据行(表头 + 分隔行 + 连续 | 行);机制行取其中末列(适用面列)点名出口名
|
|
747
|
+
// 最多的那一行——那正是「这套形状校验适用于哪些出口」的口径声明。
|
|
748
|
+
const EXIT_NODES = ['open', 'design', 'plan', 'execute', 'subagent-execute', 'review', 'verify', 'archive'];
|
|
749
|
+
|
|
750
|
+
function markdownTableRows(text) {
|
|
751
|
+
const lines = text.split(/\r?\n/);
|
|
752
|
+
const rows = [];
|
|
753
|
+
for (let i = 0; i + 1 < lines.length; i++) {
|
|
754
|
+
if (!/^\s*\|/.test(lines[i]) || !/^\s*\|[\s:|-]*-[\s:|-]*\|?\s*$/.test(lines[i + 1])) continue;
|
|
755
|
+
let j = i + 2;
|
|
756
|
+
for (; j < lines.length && /^\s*\|/.test(lines[j]); j++) rows.push({ index: j, raw: lines[j] });
|
|
757
|
+
i = j - 1;
|
|
758
|
+
}
|
|
759
|
+
return rows;
|
|
760
|
+
}
|
|
761
|
+
|
|
762
|
+
function markdownCells(raw) {
|
|
763
|
+
// 本仓公开文档的表格单元格不含转义竖线,故按 | 直接切分。
|
|
764
|
+
return raw.trim().replace(/^\|/, '').replace(/\|$/, '').split('|').map((cell) => cell.trim());
|
|
765
|
+
}
|
|
766
|
+
|
|
767
|
+
function findMechanismRow(text) {
|
|
768
|
+
let best = null;
|
|
769
|
+
for (const row of markdownTableRows(text)) {
|
|
770
|
+
const appliesTo = markdownCells(row.raw).pop() ?? '';
|
|
771
|
+
const exits = EXIT_NODES.filter((node) => appliesTo.includes('`' + node + '`'));
|
|
772
|
+
if (best === null || exits.length > best.exits.length) best = { ...row, appliesTo, exits };
|
|
773
|
+
}
|
|
774
|
+
return best !== null && best.exits.length > 0 ? best : null;
|
|
775
|
+
}
|
|
776
|
+
|
|
777
|
+
// 机制行必须覆盖全部 8 个出口(旧表只列 5 个):抽掉任一出口即判违规,判据不放宽。
|
|
778
|
+
function mechanismRowProblems(docs) {
|
|
779
|
+
const problems = [];
|
|
780
|
+
for (const rel of ['docs/MECHANISM-zh.md', 'docs/MECHANISM.md']) {
|
|
781
|
+
const text = docs.get(rel);
|
|
782
|
+
if (typeof text !== 'string') continue; // 缺席面由调用方的缺席判据逐份点名(本函数只判在场的机制行)
|
|
783
|
+
const row = findMechanismRow(text);
|
|
784
|
+
if (row === null) {
|
|
785
|
+
problems.push(rel + ' 缺「节点文档是否符合模板」机制行(无法核对出口面)');
|
|
786
|
+
continue;
|
|
787
|
+
}
|
|
788
|
+
for (const node of EXIT_NODES) {
|
|
789
|
+
if (!row.exits.includes(node)) problems.push(rel + ' 机制行未覆盖出口 ' + node + '(口径落后于门禁范围)');
|
|
790
|
+
}
|
|
791
|
+
}
|
|
792
|
+
return problems;
|
|
793
|
+
}
|
|
794
|
+
|
|
795
|
+
// 失效形态复现用:旧判据「首个同时含『段名』且匹配 open|design|plan 的行」。只被正锚探针用来确认
|
|
796
|
+
// 「插入的段落确实会被旧判据抢位」——证明正锚构造有效,不参与真实断言。
|
|
797
|
+
function legacyMechanismLine(text) {
|
|
798
|
+
return text.split(/\r?\n/).find((line) => line.includes('段名') && /open|design|plan/.test(line)) ?? '';
|
|
799
|
+
}
|
|
800
|
+
|
|
801
|
+
// ---------- 段体切片形态探针(段体单源锁的判据面) ----------
|
|
802
|
+
|
|
803
|
+
// 一份「按标题切段体」的实现 = 三种写法之一(A/B/C)写在两种位置之一(D = 对象属性箭头);判定粒度是
|
|
804
|
+
// **具名代码单元**(`functionBodies` 切出的顶层函数体、`objectLiteralArrowBodies` 切出的对象属性箭头体),
|
|
805
|
+
// 形态命中按「文件 + 名称」登记,与取用面的「文件 + 符号」同一粒度:
|
|
806
|
+
// A 行扫描:同一单元里三件事齐备——① 段头判定(行首 ATX 标题正则,或以其为模式串的 RegExp
|
|
807
|
+
// 构造)② 在判定处收尾(break)③ 把原始行拼成段体(+= line / push(line…) / slice(…).join(…));
|
|
808
|
+
// B 正则切片:同一单元里出现「从段头截到下一个段头」的正则 idiom——惰性 `[\s\S]` 片段配
|
|
809
|
+
// `(?=…\n## …)` 前瞻,或 `.split(/\n## …/)` 按标题行切;
|
|
810
|
+
// C 字符串字面量切分:段界写成字符串而不是正则——`.split('\n## …')` / `.indexOf('## …')`
|
|
811
|
+
// (B 的判据要求正则字面量,同一件事换个写法就整份躲在锁外);
|
|
812
|
+
// D 位置:以上任一写法写进**对象字面量的内联箭头**(`passes: (t) => { … }`)——顶层函数切分只看
|
|
813
|
+
// `function NAME` / `const NAME = () => {`,属性值的箭头体它看不见。
|
|
814
|
+
// 缺任一件都不算:围栏状态过滤器没有段头判定,条目块收集器不在标题处收尾,键解析器把行拆成字段。
|
|
815
|
+
// 段头判定的正则形态覆盖三种写法:`/^#…`、`/^(#{1,6})…`(标题等级写成捕获组)与 `.startsWith('#')`。
|
|
816
|
+
// 旧判定只认「`/^#` 紧邻」一种形态,`^(#{1,6})` 这种带捕获组的写法整份躲在锁外——context-init 的
|
|
817
|
+
// 私有段体切片正是此形态,受检面扩面时一并修掉。
|
|
818
|
+
const SECTION_HEADING_TEST_RE = /\/\^\(?#{1,6}|['"]\^\(?#{1,6}|\.startsWith\(\s*['"]#/u;
|
|
819
|
+
const SECTION_BREAK_RE = /\bbreak\b/u;
|
|
820
|
+
const SECTION_BODY_ACCUMULATION_RE = /\+=\s*line\b|\.push\(\s*line\b|\.push\(\s*lines\[|\.slice\([^)]*\)\.join\(/u;
|
|
821
|
+
|
|
822
|
+
// 顶层函数体(function 声明 / const NAME = (…) => {…})按花括号配对切。注释与字符串里的花括号会让配对
|
|
823
|
+
// 偏一档,只影响检出精度、不影响判据方向:误报会显式红,漏报由行为断言兜住。
|
|
824
|
+
// 花括号配对切体(唯一一处):从起始行切到配对闭合的那一行(含首末行)。顶层函数体与对象属性箭头体
|
|
825
|
+
// 共用它——两处各写一份配对循环时,其中一处改了口径(例如只认 `}` 起头的行)另一处不会跟上。
|
|
826
|
+
function bracedBodyFrom(lines, startIndex) {
|
|
827
|
+
let depth = 0;
|
|
828
|
+
let started = false;
|
|
829
|
+
const body = [];
|
|
830
|
+
for (let line = startIndex; line < lines.length; line += 1) {
|
|
831
|
+
for (const ch of lines[line]) {
|
|
832
|
+
if (ch === '{') { depth += 1; started = true; } else if (ch === '}') depth -= 1;
|
|
833
|
+
}
|
|
834
|
+
body.push(lines[line]);
|
|
835
|
+
if (started && depth <= 0) break;
|
|
836
|
+
}
|
|
837
|
+
return body.join('\n');
|
|
838
|
+
}
|
|
839
|
+
|
|
840
|
+
function functionBodies(code) {
|
|
841
|
+
const lines = String(code).split('\n');
|
|
842
|
+
const out = [];
|
|
843
|
+
for (let index = 0; index < lines.length; index += 1) {
|
|
844
|
+
const matched = lines[index].match(/^(?:export\s+)?(?:async\s+)?function\s+([A-Za-z0-9_$]+)/u)
|
|
845
|
+
?? lines[index].match(/^(?:export\s+)?const\s+([A-Za-z0-9_$]+)\s*=\s*(?:async\s*)?(?:\([^)]*\)|[A-Za-z0-9_$]+)\s*=>\s*\{/u);
|
|
846
|
+
if (matched === null) continue;
|
|
847
|
+
out.push({ name: matched[1], text: bracedBodyFrom(lines, index) });
|
|
848
|
+
}
|
|
849
|
+
return out;
|
|
850
|
+
}
|
|
851
|
+
|
|
852
|
+
// A 形态(行扫描):在段头判定处 break,再把原始行拼成段体。
|
|
853
|
+
function isLineScanSlicer(unit) {
|
|
854
|
+
return SECTION_HEADING_TEST_RE.test(unit.text)
|
|
855
|
+
&& SECTION_BREAK_RE.test(unit.text)
|
|
856
|
+
&& SECTION_BODY_ACCUMULATION_RE.test(unit.text);
|
|
857
|
+
}
|
|
858
|
+
|
|
859
|
+
// B 形态(正则切片):段界写在一对正则里——截取式(`[\s\S]` 片段 + 前瞻 `(?=` + 前瞻里出现 `\n##`)
|
|
860
|
+
// 或切分式(`.split(/\n## …/)`)。两条都要求「标题行」在场:没有标题就没有段界,也就不是段体切片——
|
|
861
|
+
// 只按行宽 / 标点切分的实现不在此列。
|
|
862
|
+
const SECTION_SLICE_EXCERPT_RE = /\[\s*\\s\\S\s*\]/u;
|
|
863
|
+
const SECTION_SLICE_FORWARD_LOOK_RE = /\(\?=/u;
|
|
864
|
+
const SECTION_SLICE_HEADING_BOUNDARY_RE = /\\n#{1,6}/u;
|
|
865
|
+
const SECTION_SLICE_SPLIT_RE = /\.split\(\s*\/[^/\n]*\\n#{1,6}/u;
|
|
866
|
+
|
|
867
|
+
function isRegexSlicer(unit) {
|
|
868
|
+
return unit.text.split('\n').some((line) => SECTION_SLICE_EXCERPT_RE.test(line)
|
|
869
|
+
&& SECTION_SLICE_FORWARD_LOOK_RE.test(line)
|
|
870
|
+
&& SECTION_SLICE_HEADING_BOUNDARY_RE.test(line))
|
|
871
|
+
|| SECTION_SLICE_SPLIT_RE.test(unit.text);
|
|
872
|
+
}
|
|
873
|
+
|
|
874
|
+
// C 形态(字符串字面量切分):段界写成字符串字面量——`.split('\n## …')` / `.indexOf('## …')`。
|
|
875
|
+
// 与 B 同义(按标题行切段)而写法不同:B 的两条判据都要求正则字面量,同一件事换个写法就整份在锁外
|
|
876
|
+
// (context-init 的「已锁决策」格式检查正是这一形态,静态锁因此判它绿)。
|
|
877
|
+
const SECTION_SLICE_STRING_BOUNDARY_RES = [
|
|
878
|
+
/\.split\(\s*['"]\\n#{1,6}/u,
|
|
879
|
+
/\.indexOf\(\s*['"]#{1,6}[\s'"]/u,
|
|
880
|
+
];
|
|
881
|
+
|
|
882
|
+
function isStringLiteralSlicer(unit) {
|
|
883
|
+
return SECTION_SLICE_STRING_BOUNDARY_RES.some((boundary) => boundary.test(unit.text));
|
|
884
|
+
}
|
|
885
|
+
|
|
886
|
+
// 对象字面量内联箭头(`passes: (t) => { … }`):属性值的箭头体。顶层函数切分(functionBodies)只看
|
|
887
|
+
// `function NAME` / `const NAME = () => {`,写进对象属性就躲开了形态面。符号名取属性键——登记粒度与
|
|
888
|
+
// 「文件 + 符号」一致,属性名在同一文件内重名时按「文件 + 属性名」合并(与第二份定义同名的处置相同)。
|
|
889
|
+
function objectLiteralArrowBodies(code) {
|
|
890
|
+
const lines = String(code).split('\n');
|
|
891
|
+
const out = [];
|
|
892
|
+
for (let index = 0; index < lines.length; index += 1) {
|
|
893
|
+
const matched = lines[index].match(/^\s*([A-Za-z0-9_$]+)\s*:\s*(?:async\s*)?(?:\([^)]*\)|[A-Za-z0-9_$]+)\s*=>\s*\{/u);
|
|
894
|
+
if (matched === null) continue;
|
|
895
|
+
out.push({ name: matched[1], text: bracedBodyFrom(lines, index) });
|
|
896
|
+
}
|
|
897
|
+
return out;
|
|
898
|
+
}
|
|
899
|
+
|
|
900
|
+
// E 行数组切片:段首用 `findIndex(标题谓词)` 定位、段尾用 `slice(start, …)` 取到——「按标题行切出
|
|
901
|
+
// 一段」的第三种写法。段界判定往往被提成辅助函数(`headingOf` / `sectionEnd` / 导入的 `hasSection9`),
|
|
902
|
+
// 单元里只剩下 `findIndex` + `slice`,于是 A/B/C 三条写法一条也不命中:evolve 的沉淀段切片正是此形态,
|
|
903
|
+
// 旧判据对它整份判绿。判据因此要求三件事同现——`findIndex(`、`slice(`,以及**可达的标题判定**
|
|
904
|
+
// (单元内联的标题正则 / `startsWith('#')`,或单元调用的、同文件内定义的含标题判定的辅助函数)。
|
|
905
|
+
// 边界(如实登记):谓词若完全来自别的模块且不落在同文件辅助上(例如本文件既没有标题正则、也没有
|
|
906
|
+
// 标题辅助),本形态就够不着——登记条目的「合并条件」正是写这种边界的唯一落点,行为断言另兜一层。
|
|
907
|
+
const SECTION_SLICE_FINDINDEX_RE = /\.findIndex\(/u;
|
|
908
|
+
const SECTION_SLICE_ARRAY_CUT_RE = /\.slice\(/u;
|
|
909
|
+
|
|
910
|
+
// 同文件内「含标题判定的辅助函数」名:单元调用它们即视为段界判定可达(把判定提成辅助不等于换了
|
|
911
|
+
// 一件事)。只取顶层声明——对象属性箭头里再套一层标题判定的写法由 D 位置面单独覆盖。
|
|
912
|
+
function headingPredicateNames(code) {
|
|
913
|
+
return functionBodies(code)
|
|
914
|
+
.filter((unit) => SECTION_HEADING_TEST_RE.test(unit.text))
|
|
915
|
+
.map((unit) => unit.name);
|
|
916
|
+
}
|
|
917
|
+
|
|
918
|
+
function mentionsHeadingBoundary(unit, helperNames) {
|
|
919
|
+
if (SECTION_HEADING_TEST_RE.test(unit.text)) return true;
|
|
920
|
+
return helperNames.some((name) => name !== unit.name
|
|
921
|
+
&& new RegExp('\\b' + name + '\\b', 'u').test(unit.text));
|
|
922
|
+
}
|
|
923
|
+
|
|
924
|
+
function isLineArraySlicer(unit, helperNames) {
|
|
925
|
+
return SECTION_SLICE_FINDINDEX_RE.test(unit.text)
|
|
926
|
+
&& SECTION_SLICE_ARRAY_CUT_RE.test(unit.text)
|
|
927
|
+
&& mentionsHeadingBoundary(unit, helperNames);
|
|
928
|
+
}
|
|
929
|
+
|
|
930
|
+
// 形态面 = 两种位置 × 四种写法的全部命中:写法判定各是一份谓词,位置只决定在哪一堆具名单元上套用。
|
|
931
|
+
// 位置面的盲区(D:对象字面量内联箭头)因此不与写法面各写一套——旧的锁只看顶层函数,把同一件事写进
|
|
932
|
+
// 对象属性就整份躲开了。谓词签名(unit, helperNames)统一:E 形态要看「调用的辅助是不是标题判定」,
|
|
933
|
+
// A/B/C 忽略第二个参数(它们只看单元文本)。
|
|
934
|
+
const SECTION_SLICE_FORM_PREDICATES = [isLineScanSlicer, isRegexSlicer, isStringLiteralSlicer, isLineArraySlicer];
|
|
935
|
+
|
|
936
|
+
function sectionSliceHits(code) {
|
|
937
|
+
const helperNames = headingPredicateNames(code);
|
|
938
|
+
const hitsIn = (units) => units
|
|
939
|
+
.filter((unit) => SECTION_SLICE_FORM_PREDICATES.some((matches) => matches(unit, helperNames)))
|
|
940
|
+
.map((unit) => unit.name);
|
|
941
|
+
return [...new Set([...hitsIn(functionBodies(code)), ...hitsIn(objectLiteralArrowBodies(code))])];
|
|
942
|
+
}
|
|
943
|
+
|
|
944
|
+
// 单源的导出符号集:只有它们受「导出实现恰一处 / 不得自带第二份定义 / 必须具名取用」约束。
|
|
945
|
+
const SECTION_SOURCE_SYMBOLS = ['sectionBody', 'scanHeadings'];
|
|
946
|
+
|
|
947
|
+
// 段体单源锁的**登记表**:把面内仍存在的同类实现逐条登记(文件 + 符号 + 理由 + **合并条件**四件齐备)。
|
|
948
|
+
// 登记是让缺口可见,不是放行:
|
|
949
|
+
// · 只覆盖 ③ 形态命中这一条判据;② 的单源符号第二份定义 / 未取用**不接受豁免**——否则登记一个
|
|
950
|
+
// sectionBody 副本就能让真实副本静默通过(旧锁把 `continue` 放在符号判定之前,正是如此);
|
|
951
|
+
// · 条目必须**当场命中**(该文件该函数此刻仍在形态面上):修好或改名后未删 ⇒ 陈旧,判红。
|
|
952
|
+
// · **合并条件必填**:一条登记要回答「什么条件下就该删掉它、改用单源」——只写理由的登记是永久
|
|
953
|
+
// 豁免(缺口从此不可收口),而锁本身判不了「这个缺口还会不会收」,只能要求它写下来并被看见。
|
|
954
|
+
// 受检面 = 引擎实现面(与 `engineScriptTexts` 同一派生口径:顶层入口 ∪ 静态可达模块 ∪ 非套件自持的
|
|
955
|
+
// `lib/**`)。套件自持面(`scenarios/**`、`items/**`、只被套件入口可达的 lib 模块)是夹具与其自身
|
|
956
|
+
// 判据,不在引擎面上——把它们算进来会让锁去登记自己用的行扫描辅助(形态探针本身),判据反而失真。
|
|
957
|
+
const SECTION_SLICE_REGISTRY = [
|
|
958
|
+
{
|
|
959
|
+
file: 'health.mjs',
|
|
960
|
+
symbol: 'collectDebt',
|
|
961
|
+
// 这一条是**能力差异**,不是同一件事的第二份实现:技术债段体的段界要与**段标题自身的层级**比较
|
|
962
|
+
// (`## 技术债` + `### 明细` 里的子标题属于段内,不是段边界——按固定级别截断会把子标题之后的
|
|
963
|
+
// 表格整段丢掉),而这个层级还要随读数回传给「复现命令」(命令里的段级必须取自同一处,否则
|
|
964
|
+
// `## 技术债` 的项目照抄命令就复现不出本报告的读数)。单源的 sectionBody 两项能力都给不了:
|
|
965
|
+
// 它只接受一个固定的结束级别,且只返回段体正文、不返回命中的标题。
|
|
966
|
+
reason: '能力差异:段界要与段标题自身的层级比较,且该层级需回传给「复现命令」——'
|
|
967
|
+
+ 'sectionBody 只接受固定结束级别、只返回段体正文,两项都给不了。',
|
|
968
|
+
mergeCondition: 'section-body.mjs 增加「段体 + 命中标题(含层级)」的返回形态后,health.mjs 改用它'
|
|
969
|
+
+ '并把段级从同一次命中取回;届时删除本条(陈旧登记判红会提醒)。',
|
|
970
|
+
},
|
|
971
|
+
{
|
|
972
|
+
file: 'evolve.mjs',
|
|
973
|
+
symbol: 'locateSedimentSection',
|
|
974
|
+
// 能力差异:evolve 要的是**行区间**而不是段体正文——沉淀段的候选解析在行数组上做(表格行 / 列表
|
|
975
|
+
// 项 / 围栏块整块),插入点也要落回同一个行数组;段首行(含标题)与「同级或更高级标题」的边界
|
|
976
|
+
// 都由它自己算,层级取自该段标题自身。sectionBody 只给段体字符串、只接受固定结束级别;
|
|
977
|
+
// scanHeadings 给得出围栏外的标题下标,但区间的「按标题层级收尾」仍要消费方自己推。
|
|
978
|
+
reason: '能力差异:消费方要行区间(段首行 + 段尾行)而不是段体正文字符串,段界按段标题自身层级收。',
|
|
979
|
+
mergeCondition: 'section-body.mjs 增加「段体区间(标题行下标 + 段尾下标,按命中标题层级)」的返回形态'
|
|
980
|
+
+ '后,evolve 的 locateSedimentSection / findSection 改用它取区间并删除本条;本条是该文件在写面外'
|
|
981
|
+
+ '期间的登记,不是收口结论。',
|
|
982
|
+
},
|
|
983
|
+
];
|
|
984
|
+
|
|
985
|
+
// 段体单源判据(纯函数 + 合成输入可驱动):given = Map(相对路径 → 文本),registry = 登记表。
|
|
986
|
+
// ① 单源模块由**导出面**派生(不写文件名):导出实现恰一处,且 {sectionBody, scanHeadings} 都定义
|
|
987
|
+
// 在那里;
|
|
988
|
+
// ② **取用面** = 面内提到单源符号的模块:必须具名取用,不得自带第二份定义、不得改从别处取用;
|
|
989
|
+
// ③ **形态面** = 面内**全部**模块的全部具名代码单元(顶层函数 ∪ 对象字面量内联箭头)——受检面不再
|
|
990
|
+
// 只是取用面:把一份私有实现搬进一个不引用该符号的模块就躲不开了;形如切段体者只许是单源本身,
|
|
991
|
+
// 其余必须登记。写法面 = A 行扫描 / B 正则切片 / C 字符串字面量切分(B 的判据要求正则字面量,
|
|
992
|
+
// C 是同一件事的另一种写法);位置面 = 顶层函数 / 对象字面量内联箭头(后者是 functionBodies 的盲区)。
|
|
993
|
+
// 返回问题描述数组(空 = 收口)。
|
|
994
|
+
function sectionSingleSourceProblems({ texts: given, registry = SECTION_SLICE_REGISTRY }) {
|
|
995
|
+
const problems = [];
|
|
996
|
+
const exported = [...given.entries()]
|
|
997
|
+
.filter(([, text]) => /export\s+(?:async\s+)?function\s+sectionBody\b|export\s+const\s+sectionBody\s*=/u
|
|
998
|
+
.test(engineCodeText(text)))
|
|
999
|
+
.map(([rel]) => rel);
|
|
1000
|
+
if (exported.length !== 1) {
|
|
1001
|
+
problems.push('sectionBody 的导出实现应恰一处,实际 ' + JSON.stringify(exported));
|
|
1002
|
+
return problems;
|
|
1003
|
+
}
|
|
1004
|
+
const sourceRel = exported[0];
|
|
1005
|
+
const sourceText = given.get(sourceRel) ?? '';
|
|
1006
|
+
for (const symbol of SECTION_SOURCE_SYMBOLS) {
|
|
1007
|
+
if (!engineDefinitionPattern(symbol).test(sourceText)) {
|
|
1008
|
+
problems.push(sourceRel + ' 未定义段体单源的 ' + symbol);
|
|
1009
|
+
}
|
|
1010
|
+
}
|
|
1011
|
+
const mentionRe = /\b(?:sectionBody|scanHeadings)\b/u;
|
|
1012
|
+
const consumers = [...given.keys()].filter((rel) => rel !== sourceRel
|
|
1013
|
+
&& mentionRe.test(engineCodeText(given.get(rel) ?? '')));
|
|
1014
|
+
if (consumers.length < 5) {
|
|
1015
|
+
problems.push('段体消费面不足五处(由真实引用派生): ' + JSON.stringify(consumers));
|
|
1016
|
+
}
|
|
1017
|
+
for (const rel of consumers) {
|
|
1018
|
+
const code = engineCodeText(given.get(rel));
|
|
1019
|
+
for (const symbol of SECTION_SOURCE_SYMBOLS) {
|
|
1020
|
+
if (!new RegExp('\\b' + symbol + '\\b', 'u').test(code)) continue;
|
|
1021
|
+
if (engineDefinitionPattern(symbol).test(code)) {
|
|
1022
|
+
problems.push(rel + ' 自带第二份 ' + symbol + ' 定义(应取用单一来源;登记不覆盖单源符号的副本)');
|
|
1023
|
+
continue;
|
|
1024
|
+
}
|
|
1025
|
+
if (!engineImportsSymbolFrom({ text: given.get(rel), consumerRel: rel, symbol, sourceRel, texts: given })) {
|
|
1026
|
+
problems.push(rel + ' 未从 ' + sourceRel + ' 取用 ' + symbol);
|
|
1027
|
+
}
|
|
1028
|
+
}
|
|
1029
|
+
}
|
|
1030
|
+
const hits = [];
|
|
1031
|
+
for (const [rel, text] of given) {
|
|
1032
|
+
if (rel === sourceRel) continue;
|
|
1033
|
+
const code = engineCodeText(text);
|
|
1034
|
+
for (const symbol of sectionSliceHits(code)) {
|
|
1035
|
+
if (hits.some((hit) => hit.rel === rel && hit.symbol === symbol)) continue;
|
|
1036
|
+
hits.push({ rel, symbol });
|
|
1037
|
+
}
|
|
1038
|
+
}
|
|
1039
|
+
for (const hit of hits) {
|
|
1040
|
+
const entry = registry.find((item) => item.file === hit.rel && item.symbol === hit.symbol);
|
|
1041
|
+
if (entry === undefined) {
|
|
1042
|
+
problems.push(hit.rel + ' 自带段体切片实现 ' + hit.symbol
|
|
1043
|
+
+ '(段界应只由 ' + sourceRel + ' 决定;确属另一件事则在锁里登记文件 + 符号 + 理由)');
|
|
1044
|
+
continue;
|
|
1045
|
+
}
|
|
1046
|
+
if (SECTION_SOURCE_SYMBOLS.includes(hit.symbol)) {
|
|
1047
|
+
problems.push(hit.rel + ' 的 ' + hit.symbol + ' 是单源符号的副本——登记不能放行真实副本');
|
|
1048
|
+
continue;
|
|
1049
|
+
}
|
|
1050
|
+
if (String(entry.reason ?? '').trim() === '') {
|
|
1051
|
+
problems.push(hit.rel + ' 的 ' + hit.symbol + ' 登记缺理由(登记是让缺口可见,不是静默放行)');
|
|
1052
|
+
}
|
|
1053
|
+
if (String(entry.mergeCondition ?? '').trim() === '') {
|
|
1054
|
+
problems.push(hit.rel + ' 的 ' + hit.symbol + ' 登记缺合并条件(登记要写出「什么条件下收口」,'
|
|
1055
|
+
+ '否则这条豁免永远没有到期日)');
|
|
1056
|
+
}
|
|
1057
|
+
}
|
|
1058
|
+
for (const entry of registry) {
|
|
1059
|
+
if (!hits.some((hit) => hit.rel === entry.file && hit.symbol === entry.symbol)) {
|
|
1060
|
+
problems.push('登记已陈旧:' + entry.file + ' 的 ' + entry.symbol
|
|
1061
|
+
+ ' 不再是段体切片形态(收口或改名后请删除该登记)');
|
|
1062
|
+
}
|
|
1063
|
+
}
|
|
1064
|
+
return problems;
|
|
1065
|
+
}
|
|
1066
|
+
|
|
1067
|
+
// 本任务收口的三处私有实现(原样搬回):静态判据只读文本、不执行变异体——探针证明「改回私有实现 ⇒
|
|
1068
|
+
// 锁必红」。每条 edits 的锚文本若漂移,调用方报「锚已漂移」(不静默跳过:否则探针会退化成恒绿)。
|
|
1069
|
+
// 旧实现一律用 String.raw 模板保存:里面的 `\uFEFF` / `\r?\n` 是字面量,不该被再次转义。
|
|
1070
|
+
const REVERTED_PRIVATE_SLICERS = [
|
|
1071
|
+
{
|
|
1072
|
+
label: 'guard-uidesign 的「视觉调性」段体改回围栏盲的行扫描',
|
|
1073
|
+
rel: 'lib/guard-uidesign.mjs',
|
|
1074
|
+
symbols: ['visualToneSectionState'],
|
|
1075
|
+
edits: [[
|
|
1076
|
+
String.raw` const body = sectionBody(text, headingPattern, { level: 2, endOnSeparator: false });`,
|
|
1077
|
+
String.raw` let body = null;
|
|
1078
|
+
for (const line of String(text).replace(/\uFEFF/g, '').split(/\r?\n/)) {
|
|
1079
|
+
if (/^##\s+/.test(line)) {
|
|
1080
|
+
if (body !== null) break; // 到达下一个 H2 → 本段结束
|
|
1081
|
+
if (headingPattern.test(line)) body = '';
|
|
1082
|
+
continue;
|
|
1083
|
+
}
|
|
1084
|
+
if (body !== null) body += line + '\n';
|
|
1085
|
+
}`,
|
|
1086
|
+
]],
|
|
1087
|
+
},
|
|
1088
|
+
{
|
|
1089
|
+
label: 'guard-evidence-gates 的「6 维自查」/「自检方法」段体改回两条正则切片',
|
|
1090
|
+
rel: 'lib/guard-evidence-gates.mjs',
|
|
1091
|
+
symbols: ['summarySixDimBody', 'summarySelfCheckMethodBody'],
|
|
1092
|
+
edits: [
|
|
1093
|
+
[
|
|
1094
|
+
String.raw`function summarySixDimBody(content) {
|
|
1095
|
+
return sectionBody(content, SIX_DIM_HEADING_PATTERN, { level: 2, endOnSeparator: true });
|
|
1096
|
+
}`,
|
|
1097
|
+
String.raw`function summarySixDimBody(content) {
|
|
1098
|
+
const sixDim = content.match(/##\s*6\s*维自查[\s\S]*?(?=\n##\s|\n---|(?![\s\S]))/i);
|
|
1099
|
+
return sixDim === null ? null : sixDim[0];
|
|
1100
|
+
}`,
|
|
1101
|
+
],
|
|
1102
|
+
[
|
|
1103
|
+
String.raw`function summarySelfCheckMethodBody(content) {
|
|
1104
|
+
return sectionBody(content, SELF_CHECK_METHOD_HEADING_PATTERN, { level: 2, endOnSeparator: true });
|
|
1105
|
+
}`,
|
|
1106
|
+
String.raw`function summarySelfCheckMethodBody(content) {
|
|
1107
|
+
const methodMatch = content.match(/##\s*自检方法(?:[((][^))\n]*[))])?\s*\n([\s\S]*)/i);
|
|
1108
|
+
return methodMatch ? methodMatch[1].split(/\n##\s|\n---/)[0] : null;
|
|
1109
|
+
}`,
|
|
1110
|
+
],
|
|
1111
|
+
],
|
|
1112
|
+
},
|
|
1113
|
+
{
|
|
1114
|
+
label: 'context-init 改回同名私有 sectionBody((body, headingName) 变体)',
|
|
1115
|
+
rel: 'context-init.mjs',
|
|
1116
|
+
symbols: ['sectionBody'],
|
|
1117
|
+
edits: [[
|
|
1118
|
+
String.raw`function contextSectionBody(structureText, headingName) {
|
|
1119
|
+
const wanted = normalizeSectionName(headingName);
|
|
1120
|
+
return sectionBody(
|
|
1121
|
+
structureText,
|
|
1122
|
+
(heading) => heading.level === 2 && normalizeSectionName(heading.text) === wanted,
|
|
1123
|
+
{ level: 2, endOnSeparator: false },
|
|
1124
|
+
);
|
|
1125
|
+
}`,
|
|
1126
|
+
String.raw`function sectionBody(body, headingName) {
|
|
1127
|
+
const wanted = normalizeSectionName(headingName);
|
|
1128
|
+
const kept = [];
|
|
1129
|
+
let inSection = false;
|
|
1130
|
+
for (const line of String(body ?? '').split('\n')) {
|
|
1131
|
+
const heading = /^(#{1,6})[ \t]+(.+?)[ \t]*$/.exec(line);
|
|
1132
|
+
if (heading) {
|
|
1133
|
+
const level = heading[1].length;
|
|
1134
|
+
if (inSection && level <= 2) break; // 到下一个同级或更高级标题即段结束
|
|
1135
|
+
if (!inSection && level === 2 && normalizeSectionName(heading[2]) === wanted) {
|
|
1136
|
+
inSection = true;
|
|
1137
|
+
continue;
|
|
1138
|
+
}
|
|
1139
|
+
}
|
|
1140
|
+
if (inSection) kept.push(line);
|
|
1141
|
+
}
|
|
1142
|
+
return inSection ? kept.join('\n') : null;
|
|
1143
|
+
}`,
|
|
1144
|
+
],
|
|
1145
|
+
// 调用点也一并改回旧名:变异体因此是一份自洽的「改动之前的文件」,而不是半截替换。
|
|
1146
|
+
['contextSectionBody(t, EVOLVE_METADATA_SECTION)', 'sectionBody(t, EVOLVE_METADATA_SECTION)'],
|
|
1147
|
+
],
|
|
1148
|
+
},
|
|
1149
|
+
];
|
|
1150
|
+
|
|
1151
|
+
// ---------- 任务对键形态探针(配对键单源锁的判据面) ----------
|
|
1152
|
+
|
|
1153
|
+
// 「任务对键」= 无序任务对的键:两个 id 先比较定序,再用一个**字符串字面量**当分隔符拼起来
|
|
1154
|
+
// (`a < b ? a + '\u0000' + b : b + '\u0000' + a`)。判据按**形态**判定,不看名字也不看分隔符取值:
|
|
1155
|
+
// 历史上的第二份实现叫 `gapPairKey`(与第一份不同名),换 `|` 一类分隔符的漂移也同样是第二份实现——
|
|
1156
|
+
// 按标识符名计数的锚对这两种形态都判绿(这正是本判据要补的盲区)。
|
|
1157
|
+
const PAIR_KEY_ORDER_RE = /\b([A-Za-z0-9_$]+)\s*<\s*([A-Za-z0-9_$]+)\s*\?/u;
|
|
1158
|
+
|
|
1159
|
+
function pairKeyForm(text) {
|
|
1160
|
+
const order = PAIR_KEY_ORDER_RE.exec(String(text ?? ''));
|
|
1161
|
+
if (order === null) return false;
|
|
1162
|
+
const [, left, right] = order;
|
|
1163
|
+
if (left === right) return false;
|
|
1164
|
+
// 分隔符只认「字符串字面量夹在两个标识符之间」:`left + '<任意字面量>' + right`(两种定序各判一次)。
|
|
1165
|
+
// 标识符里的 `$` 是正则元字符:直接拼进模式会被当作串尾锚,含它的键因此被静默漏检(探针的假绿形态)。
|
|
1166
|
+
const escaped = (identifier) => identifier.replace(/\$/gu, '\\$');
|
|
1167
|
+
const joined = (first, second) => new RegExp(
|
|
1168
|
+
'\\b' + escaped(first) + '\\s*\\+\\s*[\'"`][^\'"`]*[\'"`]\\s*\\+\\s*\\b' + escaped(second) + '\\b', 'u');
|
|
1169
|
+
return joined(left, right).test(text) || joined(right, left).test(text);
|
|
1170
|
+
}
|
|
1171
|
+
|
|
1172
|
+
// 引擎注释的「过程叙述」判据(纯函数 + 合成输入可驱动):注释行里不许出现任务号与
|
|
1173
|
+
// 「本任务 / 待收口 / 已收进 / 已照形态」一类改动叙述——注释写的是不变式,不是某一轮改动的日记。
|
|
1174
|
+
// Wave 行写法示例是注释里唯一允许出现任务号的地方(它示范的是输入形态,不是改动历史),故带
|
|
1175
|
+
// `Wave ` / `depends on` / `[P]` 的行跳过。返回命中数组(空 = 收口),每条 { kind, lineNumber, line }。
|
|
1176
|
+
// 受检面是整个引擎实现面(调用方逐文件喂 engineScriptTexts),故命中必须带行号:没有行号的
|
|
1177
|
+
// 「某文件里有一处」等于让接手的人自己再 grep 一次。
|
|
1178
|
+
function commentNarrationHits(text) {
|
|
1179
|
+
const narrative = /本任务|待收口|已收进|已照形态/u;
|
|
1180
|
+
// 任务号 = `T` + 两位数字。紧跟半角冒号的**不是**任务号,而是 ISO 时间戳的时分量
|
|
1181
|
+
// (`2026-02-30T00:00:00Z` 里的 `T00`)——注释里贴时间戳字面量是常态,判据不得把它读成任务号。
|
|
1182
|
+
const taskNumber = /[^A-Za-z]T\d{2}\b(?!:)/u;
|
|
1183
|
+
return String(text).split('\n')
|
|
1184
|
+
.map((line, index) => ({ line, lineNumber: index + 1 }))
|
|
1185
|
+
.filter((entry) => /^\s*\/\//u.test(entry.line))
|
|
1186
|
+
.filter((entry) => !entry.line.includes('Wave ')
|
|
1187
|
+
&& !entry.line.includes('depends on') && !entry.line.includes('[P]'))
|
|
1188
|
+
.flatMap(({ line, lineNumber }) => {
|
|
1189
|
+
const hits = [];
|
|
1190
|
+
if (taskNumber.test(line)) hits.push({ kind: '任务号', lineNumber, line: line.trim() });
|
|
1191
|
+
if (narrative.test(line)) hits.push({ kind: '过程叙述', lineNumber, line: line.trim() });
|
|
1192
|
+
return hits;
|
|
1193
|
+
});
|
|
1194
|
+
}
|
|
1195
|
+
|
|
1196
|
+
// 配对键单源判据(纯函数 + 合成输入可驱动):返回问题数组(空 = 收口)。
|
|
1197
|
+
// ① 形态面:「任务对键」形态在引擎面内只许出现一处(键只有一份实现);
|
|
1198
|
+
// ② 落点:那一处必须就在产出第三族的模块里(键与它的生产者同源;落点由定义面反查,不写文件名);
|
|
1199
|
+
// ③ 消费方:补集判据所在的模块不得持有任何键形态——它消费 task-graph 返回的判定(谓词),
|
|
1200
|
+
// 不自己比 id(第二份键的形态一旦漂移,两端键就不再相等,补集判据会静默失效)。
|
|
1201
|
+
function pairKeySingleSourceProblems({ texts }) {
|
|
1202
|
+
const problems = [];
|
|
1203
|
+
const hits = [];
|
|
1204
|
+
for (const [rel, text] of texts) {
|
|
1205
|
+
for (const unit of [...functionBodies(text), ...objectLiteralArrowBodies(text)]) {
|
|
1206
|
+
if (pairKeyForm(unit.text)) hits.push({ rel, symbol: unit.name });
|
|
1207
|
+
}
|
|
1208
|
+
}
|
|
1209
|
+
if (hits.length !== 1) {
|
|
1210
|
+
problems.push('任务对键应恰一处实现,实际: ' + JSON.stringify(hits));
|
|
1211
|
+
return problems;
|
|
1212
|
+
}
|
|
1213
|
+
const producer = engineDefinitionModule('collectCrossTaskConflicts');
|
|
1214
|
+
if (producer === null) {
|
|
1215
|
+
problems.push('第三族产出的定义面不唯一(反查失败): '
|
|
1216
|
+
+ JSON.stringify(engineDefinitionHits('collectCrossTaskConflicts')));
|
|
1217
|
+
return problems;
|
|
1218
|
+
}
|
|
1219
|
+
if (hits[0].rel !== producer.file) {
|
|
1220
|
+
problems.push('任务对键落在 ' + hits[0].rel + '(应与第三族产出同源: ' + producer.file + ')');
|
|
1221
|
+
}
|
|
1222
|
+
const consumer = engineDefinitionModule('parallelGapReview');
|
|
1223
|
+
if (consumer !== null && hits.some((hit) => hit.rel === consumer.file)) {
|
|
1224
|
+
problems.push(consumer.file + ' 自建任务对键(补集判据应消费 ' + producer.file + ' 返回的判定)');
|
|
1225
|
+
}
|
|
1226
|
+
return problems;
|
|
1227
|
+
}
|
|
1228
|
+
|
|
1229
|
+
// ---------- 写面元素的取用面(写面单源锁的判据面) ----------
|
|
1230
|
+
|
|
1231
|
+
// 写面元素标签的字面量(元素名大小写无关)。判据按**形态**判定,不看名字与常量名:元素提取的形态是
|
|
1232
|
+
// 同一行里同时出现开标签与闭标签(正则字面量不能跨行),任何消费方自持一份标签正则,代码层就留下这个
|
|
1233
|
+
// 形态——元素名少一个 /i 的副本(大小写敏感)同样被它看见。那种副本让 7 字段门判「字段在场」、写面
|
|
1234
|
+
// 判定判「未知」:任务静默掉出写面判据面(写写重叠漏拦、同文件族漏判、伪并行启发式漏报),而同波同层
|
|
1235
|
+
// 的同文件对反被 [P] 判据当成「可并行」误报,恢复句还把方向指到 depends_on。只提到一次标签的报文 /
|
|
1236
|
+
// 恢复指引不是提取形态(「缺 <write_files> 元素」是在说缺什么,不是在解析它)。
|
|
1237
|
+
const WRITE_FACE_TAG_MENTION_RE = /write_files>/giu;
|
|
1238
|
+
const WRITE_FACE_EXTRACTION_MIN_MENTIONS = 2;
|
|
1239
|
+
|
|
1240
|
+
// 一行里的标签提及次数(剥注释后的代码层):>= 2 即元素提取形态(开 + 闭)。
|
|
1241
|
+
function writeFaceExtractionLines(text) {
|
|
1242
|
+
return engineCodeText(text).split('\n')
|
|
1243
|
+
.filter((line) => (line.match(WRITE_FACE_TAG_MENTION_RE) ?? []).length >= WRITE_FACE_EXTRACTION_MIN_MENTIONS);
|
|
1244
|
+
}
|
|
1245
|
+
|
|
1246
|
+
// 单源面判据(纯函数 + 合成输入可驱动):元素提取形态只许出现在单源模块的代码层(且恰一处),其余模块
|
|
1247
|
+
// 一处都不许有。返回问题数组(空 = 收口)。
|
|
1248
|
+
function writeFaceSourceProblems({ texts, sourceRel }) {
|
|
1249
|
+
const problems = [];
|
|
1250
|
+
for (const [rel, text] of texts) {
|
|
1251
|
+
const extractionLines = writeFaceExtractionLines(text);
|
|
1252
|
+
if (rel === sourceRel) {
|
|
1253
|
+
if (extractionLines.length !== 1) {
|
|
1254
|
+
problems.push(rel + ':写面元素提取应恰一处,实际 ' + extractionLines.length + ' 处(单源面被破坏)');
|
|
1255
|
+
}
|
|
1256
|
+
continue;
|
|
1257
|
+
}
|
|
1258
|
+
if (extractionLines.length > 0) {
|
|
1259
|
+
problems.push(rel + ' 自带写面元素标签提取(' + extractionLines.length + ' 处)——元素提取应取用单源,'
|
|
1260
|
+
+ '大小写敏感的副本会让同一份写面在一处判在场、另一处判未知');
|
|
1261
|
+
}
|
|
1262
|
+
}
|
|
1263
|
+
return problems;
|
|
1264
|
+
}
|
|
1265
|
+
|
|
1266
|
+
// 派生面模块的**内存变异体**(data: URL;相对 import 重写为绝对 file: URL):反向构造只改内存里的源
|
|
1267
|
+
// 文本,不落盘、不留残留。变异体因此与真模块共享同一组依赖,行为差异只来自被改动的那处代码。
|
|
1268
|
+
function inlineModuleUrl(source, rel) {
|
|
1269
|
+
const rewritten = source.replace(/(from\s*')(\.[^']*)(')/gu, (whole, head, specifier, tail) =>
|
|
1270
|
+
head + pathToFileURL(path.resolve(SCRIPTS_DIR, path.dirname(rel), specifier)).href + tail);
|
|
1271
|
+
return 'data:text/javascript;charset=utf-8,' + encodeURIComponent(rewritten);
|
|
1272
|
+
}
|
|
1273
|
+
|
|
588
1274
|
export const ENTRIES = [
|
|
589
1275
|
|
|
590
1276
|
// ============================================================================================
|
|
@@ -630,7 +1316,7 @@ export const ENTRIES = [
|
|
|
630
1316
|
// ② SUMMARY 缺「已知接受 + 理由」→ BLOCKED;③ 示例条目(🔴 / ADR- / AC- / L- 形态)未出现
|
|
631
1317
|
// **不算缺段**(正例即「无任何示例条目的工件必须放行」)。
|
|
632
1318
|
{
|
|
633
|
-
name: 'TA-02 H3 结构子段缺则拦(TEST 1.5 / SUMMARY 已知接受 + 理由),示例条目不参与骨架',
|
|
1319
|
+
name: 'TA-02 H3 结构子段缺则拦(TEST 1.5 / SUMMARY 已知接受 + 理由),示例条目不参与骨架 + review 出口的 AC 覆盖汇总 WARN(段名走骨架)',
|
|
634
1320
|
run: async (dir) => {
|
|
635
1321
|
// ① TEST 缺结构子段
|
|
636
1322
|
setupVerify(dir, { subsectionOmit: ['测试质量自检'] });
|
|
@@ -652,6 +1338,75 @@ export const ENTRIES = [
|
|
|
652
1338
|
// ④ 反向构造(判别力):被抽掉的 TEST 子段确实来自登记表骨架,而不是标题巧合
|
|
653
1339
|
const registered = (docEntry('TEST').structureSubsections ?? []).map((s) => s.name).join('\n');
|
|
654
1340
|
assertTrue(registered.includes('测试质量自检'), '登记表未登记 TEST 的 1.5 结构子段——判据无处生根');
|
|
1341
|
+
|
|
1342
|
+
// ⑤~⑧ AC 覆盖与 1.1 矩阵段(review 出口只汇总、不阻断):
|
|
1343
|
+
// · 验收段与 1.1 矩阵段的段名都从骨架派生(模板权威单链,判据不自写标题正则)——省编号 /
|
|
1344
|
+
// 省括号的宽容写法同样命中(⑥),矩阵段换成无关标题即「不可判」而不是「全覆盖」(⑦);
|
|
1345
|
+
// · review 出口对缺覆盖只给**一条**汇总 WARN(列缺失编号),退出码不变(AC-8);
|
|
1346
|
+
// · 无 TEST.md 时不打该 WARN(review 出口今天不要求 TEST.md,判据无从求值就不制造噪音)。
|
|
1347
|
+
const acBody = (ids) => (ids.length > 0
|
|
1348
|
+
? ids.map((id) => '### ' + id + ' · 夹具准则\n\n- **Given** 夹具前置\n- **When** 夹具动作\n- **Then** 夹具结果').join('\n\n')
|
|
1349
|
+
: '- 本段只写散文、不含任何编号。');
|
|
1350
|
+
const acMatrix = (ids) => ['| AC | 类型 | 用例文件 / UAT | 状态 |', '|---|---|---|---|',
|
|
1351
|
+
...ids.map((id) => '| ' + id + ' | unit | guard-self-test.mjs | ✅ |')].join('\n');
|
|
1352
|
+
const matrixHeading = '### 1.1 测试矩阵(AC → 用例)';
|
|
1353
|
+
// 夹具:review 节点 + REQUIREMENT(验收段列 acIds)+ TEST(1.1 矩阵只列 coveredIds);
|
|
1354
|
+
// heading 可换掉 1.1 段标题,用于段名宽容与「段缺席」两侧构造。
|
|
1355
|
+
const setupAcReview = (acIds, coveredIds, heading = matrixHeading, matrixBodyOverride = null) => {
|
|
1356
|
+
setupReview(dir);
|
|
1357
|
+
writeTemplateFixture(dir, 'REQUIREMENT');
|
|
1358
|
+
writeTemplateFixture(dir, 'TEST');
|
|
1359
|
+
writeFile(dir, CHANGE_DIR + '/REQUIREMENT.md',
|
|
1360
|
+
renderDoc('REQUIREMENT', { body: [['验收准则', acBody(acIds)]] }));
|
|
1361
|
+
const testDoc = renderDoc('TEST', { body: [['1.1', matrixBodyOverride ?? acMatrix(coveredIds)]] });
|
|
1362
|
+
writeFile(dir, CHANGE_DIR + '/TEST.md',
|
|
1363
|
+
heading === matrixHeading ? testDoc : testDoc.replace(matrixHeading, heading));
|
|
1364
|
+
};
|
|
1365
|
+
const acSummaryLine = (res) => (res.output.match(/缺 AC 覆盖[^\n]*/u) ?? [''])[0];
|
|
1366
|
+
// ⑤ 汇总 WARN:一条(不逐条刷屏)、列缺失编号、不阻断
|
|
1367
|
+
setupAcReview(['AC-1', 'AC-2', 'AC-3'], ['AC-1']);
|
|
1368
|
+
const reviewMissing = runGuard(['exit', 'review'], dir);
|
|
1369
|
+
assertExit(reviewMissing, 0);
|
|
1370
|
+
assertOut(reviewMissing, 'REVIEW WARN: TEST.md 的 1.1 测试矩阵缺 AC 覆盖');
|
|
1371
|
+
assertTrue((reviewMissing.output.match(/缺 AC 覆盖/gu) ?? []).length === 1,
|
|
1372
|
+
'review 出口只给一条汇总 WARN(不逐条刷屏),实际出现 '
|
|
1373
|
+
+ (reviewMissing.output.match(/缺 AC 覆盖/gu) ?? []).length + ' 次');
|
|
1374
|
+
assertTrue(acSummaryLine(reviewMissing).includes('AC-2') && acSummaryLine(reviewMissing).includes('AC-3'),
|
|
1375
|
+
'汇总 WARN 应列出全部缺失编号,实际: ' + acSummaryLine(reviewMissing));
|
|
1376
|
+
assertNotOut(reviewMissing, 'BLOCKED');
|
|
1377
|
+
// ⑥ 段名宽容:省编号、省括号的写法同样命中(定位走骨架 headingPattern,不是写死标题)
|
|
1378
|
+
setupAcReview(['AC-1', 'AC-2'], ['AC-1'], '### 测试矩阵');
|
|
1379
|
+
const reviewLoose = runGuard(['exit', 'review'], dir);
|
|
1380
|
+
assertExit(reviewLoose, 0);
|
|
1381
|
+
assertOut(reviewLoose, 'REVIEW WARN: TEST.md 的 1.1 测试矩阵缺 AC 覆盖');
|
|
1382
|
+
// ⑦ 反向构造(判别力):矩阵段缺席 ⇒ 不可判(打不出缺覆盖),不是「全覆盖」;全量覆盖同理不打 WARN
|
|
1383
|
+
setupAcReview(['AC-1', 'AC-2'], ['AC-1'], '### 覆盖说明');
|
|
1384
|
+
const reviewNoMatrix = runGuard(['exit', 'review'], dir);
|
|
1385
|
+
assertExit(reviewNoMatrix, 0);
|
|
1386
|
+
assertNotOut(reviewNoMatrix, '缺 AC 覆盖');
|
|
1387
|
+
setupAcReview(['AC-1', 'AC-2'], ['AC-1', 'AC-2']);
|
|
1388
|
+
const reviewCovered = runGuard(['exit', 'review'], dir);
|
|
1389
|
+
assertExit(reviewCovered, 0);
|
|
1390
|
+
assertNotOut(reviewCovered, '缺 AC 覆盖');
|
|
1391
|
+
// ⑧ TEST.md 缺席(review 出口不要求它)→ 判据无从求值,不打 WARN、不改变退出码
|
|
1392
|
+
setupReview(dir);
|
|
1393
|
+
const reviewNoTest = runGuard(['exit', 'review'], dir);
|
|
1394
|
+
assertExit(reviewNoTest, 0);
|
|
1395
|
+
assertNotOut(reviewNoTest, '缺 AC 覆盖');
|
|
1396
|
+
assertOut(reviewNoTest, 'ALL CHECKS PASSED');
|
|
1397
|
+
// ⑨ 段体切片的围栏语义(1.1 矩阵段的段界由 lib/section-body.mjs 单点决定):矩阵段里贴了围栏代码块
|
|
1398
|
+
// (块内含 `## `)时,围栏之后的矩阵行仍参与覆盖判定——段体若在示例处截断,一条 AC 都读不到,
|
|
1399
|
+
// 「全覆盖」会被读成「全缺失」。
|
|
1400
|
+
const fencedMatrix = ['```md', '## 代码块里的示例段标题', '```', '', acMatrix(['AC-1', 'AC-2'])].join('\n');
|
|
1401
|
+
setupAcReview(['AC-1', 'AC-2'], [], matrixHeading, fencedMatrix);
|
|
1402
|
+
const reviewFencedMatrix = runGuard(['exit', 'review'], dir);
|
|
1403
|
+
assertExit(reviewFencedMatrix, 0);
|
|
1404
|
+
assertNotOut(reviewFencedMatrix, '缺 AC 覆盖');
|
|
1405
|
+
// ⑩ 分隔线语义保持:1.1 矩阵段不以 `---` 结束(既有语义)——分隔线之后的矩阵行照常参与判定
|
|
1406
|
+
setupAcReview(['AC-1', 'AC-2'], [], matrixHeading, '---\n\n' + acMatrix(['AC-1', 'AC-2']));
|
|
1407
|
+
const reviewRuleMatrix = runGuard(['exit', 'review'], dir);
|
|
1408
|
+
assertExit(reviewRuleMatrix, 0);
|
|
1409
|
+
assertNotOut(reviewRuleMatrix, '缺 AC 覆盖');
|
|
655
1410
|
},
|
|
656
1411
|
},
|
|
657
1412
|
|
|
@@ -792,7 +1547,11 @@ export const ENTRIES = [
|
|
|
792
1547
|
// TA-08 · 条件子段与父段豁免(AC-8)+ 可选段语义(C-1)——① 前端 change 的 UI-DESIGN 缺
|
|
793
1548
|
// `### Button (Primary)` → BLOCKED(注意 Primary / Secondary 归一后同键:只写 Secondary 不得算
|
|
794
1549
|
// Primary 在场);② 非前端 change 的 TEST 第 4 轮整段 N/A 且缺 4.1~4.4 子段 → 通过(父段 N/A →
|
|
795
|
-
// 子段不要求);⑤⑥ UI-DESIGN §0(optional
|
|
1550
|
+
// 子段不要求);⑤⑥ UI-DESIGN §0(optional)整段删除合法,但保留标题就得填;⑦ 四种包裹
|
|
1551
|
+
// 符号(**N/A** / > N/A / - N/A / (N/A))都算整段不适用、⑦b `**N/A**(理由)`(闭合标记后紧跟
|
|
1552
|
+
// 说明)同样算整段不适用、⑧ 「**见 N/A**」不算(不吞真句子;它是 ⑦b 的过度接受反锚)且报文
|
|
1553
|
+
// 给出与判据一致的规范写法;⑨⑩ 缺子段时点名「实际挂在 X 段下」/「实际在文末」;⑪ 补充提示只对
|
|
1554
|
+
// 父段正文的 N/A 意图痕迹发声(④ 是它的负锚:普通正文不弹),且父段名取模板里的真实段名。
|
|
796
1555
|
{
|
|
797
1556
|
name: 'TA-08 条件子段与父段豁免:UI-DESIGN 缺 Button (Primary) 拦;TEST 第 4 轮 N/A 放行',
|
|
798
1557
|
run: async (dir) => {
|
|
@@ -817,11 +1576,15 @@ export const ENTRIES = [
|
|
|
817
1576
|
const okTest = exitNode(dir, 'verify');
|
|
818
1577
|
assertExit(okTest, 0);
|
|
819
1578
|
assertOut(okTest, 'ALL CHECKS PASSED');
|
|
820
|
-
// ④ 反向构造(判别力):把第 4 轮改成有实质内容 → 其结构子段重新变为必填 →
|
|
1579
|
+
// ④ 反向构造(判别力):把第 4 轮改成有实质内容 → 其结构子段重新变为必填 → 缺子段必拦;
|
|
1580
|
+
// 同时是「若要整段不适用」补充提示的负锚——正文是普通说明、没有 N/A 意图痕迹,漏写子段时
|
|
1581
|
+
// 报文不得带这条提示(提示只对当事人想写 N/A 却写不规范的情形发声)。
|
|
821
1582
|
setupVerify(dir, { body: [['兼容性测试', '实测了三种视口组合的兼容性结论。']], subsectionOmit: ['跨浏览器'] });
|
|
822
1583
|
const resRound4 = exitNode(dir, 'verify');
|
|
823
1584
|
assertExit(resRound4, 1);
|
|
824
1585
|
assertOut(resRound4, '跨浏览器');
|
|
1586
|
+
assertNotOut(resRound4, '若要整段不适用');
|
|
1587
|
+
assertNotOut(resRound4, '父段「」');
|
|
825
1588
|
// ⑤ 可选段(optional)语义:UI-DESIGN §0 是模板自述「greenfield 删掉此段」的可选段——
|
|
826
1589
|
// 整段缺席合法,不得报「条件段标题缺席」(与 conditional 分流;conditional 仍要求标题在场,见 TA-07)。
|
|
827
1590
|
setupDesign(dir, {
|
|
@@ -844,6 +1607,71 @@ export const ENTRIES = [
|
|
|
844
1607
|
const resEmptyOptional = exitNode(dir, 'design');
|
|
845
1608
|
assertExit(resEmptyOptional, 1);
|
|
846
1609
|
assertOut(resEmptyOptional, '0.1');
|
|
1610
|
+
// ⑦ 整段不适用的包裹符号(AC-8):粗体 / 引用 / 列表 / 括号四种写法都是同一个词的包装——
|
|
1611
|
+
// 第 4 轮正文写成这些形态、其结构子段 4.1~4.4 全缺席 → 不报缺子段(父段豁免生效)。
|
|
1612
|
+
for (const wrapped of ['**N/A**', '> N/A', '- N/A', '(N/A)']) {
|
|
1613
|
+
setupVerify(dir, { body: [['兼容性测试', wrapped]], subsectionOmit: ['4.1', '4.2', '4.3', '4.4'] });
|
|
1614
|
+
const resWrapped = exitNode(dir, 'verify');
|
|
1615
|
+
assertTrue(resWrapped.status === 0, '第 4 轮正文「' + wrapped + '」应视为整段不适用、豁免结构子段,实际 exit '
|
|
1616
|
+
+ resWrapped.status + '\n' + resWrapped.output);
|
|
1617
|
+
assertOut(resWrapped, 'ALL CHECKS PASSED');
|
|
1618
|
+
}
|
|
1619
|
+
// ⑦b 闭合标记后紧跟说明(正例锚):`**N/A**(本轮无变更)` 是「整段不适用 + 为什么」的合法
|
|
1620
|
+
// 书写形态。旧实现只剥尾部的**裸**闭合标记,标记之后一有文字裸文本就变成 `N/A**(…)`、
|
|
1621
|
+
// 白名单词后不再紧邻边界 ⇒ 判已填、子段照旧要求(报文还写着「不要加粗或引用」,与判据相反)。
|
|
1622
|
+
setupVerify(dir, { body: [['兼容性测试', '**N/A**(本轮无变更)']], subsectionOmit: ['4.1', '4.2', '4.3', '4.4'] });
|
|
1623
|
+
const resClosedNote = exitNode(dir, 'verify');
|
|
1624
|
+
assertTrue(resClosedNote.status === 0,
|
|
1625
|
+
'第 4 轮正文「**N/A**(本轮无变更)」应视为整段不适用、豁免结构子段,实际 exit '
|
|
1626
|
+
+ resClosedNote.status + '\n' + resClosedNote.output);
|
|
1627
|
+
assertOut(resClosedNote, 'ALL CHECKS PASSED');
|
|
1628
|
+
// ⑧ 反例(AC-9):包装里是「见 N/A」这类真句子(剥掉包装后开头不是白名单词)→ 仍报缺子段。
|
|
1629
|
+
// 它是 ⑦b 的**过度接受**反锚:容忍「闭合标记后紧跟说明」不得顺手把「包装里包着真句子」也
|
|
1630
|
+
// 放行——区别在开头是不是白名单词,不在有没有包裹符号。
|
|
1631
|
+
// 父段有正文却不落白名单,报文同时给出**与判据一致**的规范写法(AC-10):包裹符号本身就被
|
|
1632
|
+
// 接受(旧报文写「不要加粗或引用」,与判据相反);要跟说明就写在闭合标记之后(⑦b 的形态)。
|
|
1633
|
+
setupVerify(dir, { body: [['兼容性测试', '**见 N/A**']], subsectionOmit: ['4.1', '4.2', '4.3', '4.4'] });
|
|
1634
|
+
const resSentence = exitNode(dir, 'verify');
|
|
1635
|
+
assertExit(resSentence, 1);
|
|
1636
|
+
assertOut(resSentence, '缺结构子段');
|
|
1637
|
+
assertOut(resSentence, '4.1');
|
|
1638
|
+
assertOut(resSentence, '若要整段不适用,请让整段以 N/A 开头');
|
|
1639
|
+
assertOut(resSentence, '包裹符号本身就被接受');
|
|
1640
|
+
assertOut(resSentence, '`**N/A**(理由)`');
|
|
1641
|
+
assertNotOut(resSentence, '不要加粗或引用');
|
|
1642
|
+
assertNotOut(resSentence, '父段「」');
|
|
1643
|
+
// ⑨ 诊断一(挂错父段):4.3 实际写在「第 5 轮 · 可观测性验证」下 → 报文点名实际归属
|
|
1644
|
+
// (只加定位说明,不改归属算法)。
|
|
1645
|
+
setupVerify(dir, {
|
|
1646
|
+
body: [['兼容性测试', '实测了三种视口组合的兼容性结论。']],
|
|
1647
|
+
subsectionOmit: ['4.3'],
|
|
1648
|
+
insertAfter: [['可观测性验证', '### 4.3 数据迁移(涉及 schema 变更必填)\n\n夹具:误挂在第 5 轮下的子段。\n']],
|
|
1649
|
+
});
|
|
1650
|
+
const resMisplaced = exitNode(dir, 'verify');
|
|
1651
|
+
assertExit(resMisplaced, 1);
|
|
1652
|
+
assertOut(resMisplaced, '缺结构子段');
|
|
1653
|
+
assertOut(resMisplaced, '实际挂在');
|
|
1654
|
+
assertOut(resMisplaced, '第 5 轮 · 可观测性验证 段下');
|
|
1655
|
+
// ⑩ 诊断一(文末):4.4 被贴到模板骨架之外(文末「附录」段之下)→ 报文写「实际在文末」。
|
|
1656
|
+
setupVerify(dir, {
|
|
1657
|
+
body: [['兼容性测试', '实测了三种视口组合的兼容性结论。']],
|
|
1658
|
+
subsectionOmit: ['4.4'],
|
|
1659
|
+
extra: ['## 附录\n\n### 4.4 跨版本\n\n夹具:误贴在文末的子段。'],
|
|
1660
|
+
});
|
|
1661
|
+
const resTail = exitNode(dir, 'verify');
|
|
1662
|
+
assertExit(resTail, 1);
|
|
1663
|
+
assertOut(resTail, '缺结构子段');
|
|
1664
|
+
assertOut(resTail, '实际在文末');
|
|
1665
|
+
// ⑪ 正锚(④ 的对称面):父段正文留下 N/A 意图痕迹(「(说明:N/A)」这类带前置说明词、
|
|
1666
|
+
// 不在整段白名单里的写法)→ 子段仍要求,报文给出规范写法;父段名取模板里的真实段名,
|
|
1667
|
+
// 空父段名「父段「」」对定位毫无价值,两处都不许出现。
|
|
1668
|
+
setupVerify(dir, { body: [['兼容性测试', '(说明:N/A)']], subsectionOmit: ['4.1', '4.2', '4.3', '4.4'] });
|
|
1669
|
+
const resIntent = exitNode(dir, 'verify');
|
|
1670
|
+
assertExit(resIntent, 1);
|
|
1671
|
+
assertOut(resIntent, '若要整段不适用,请让整段以 N/A 开头');
|
|
1672
|
+
assertOut(resIntent, '包裹符号本身就被接受');
|
|
1673
|
+
assertOut(resIntent, '父段「第 4 轮 · 兼容性测试」');
|
|
1674
|
+
assertNotOut(resIntent, '父段「」');
|
|
847
1675
|
},
|
|
848
1676
|
},
|
|
849
1677
|
|
|
@@ -918,8 +1746,10 @@ export const ENTRIES = [
|
|
|
918
1746
|
|
|
919
1747
|
// TA-11 · 旧 change 只告警(AC-11)——旧 change(无 newChange 标记)同构缺段 → 不阻断并输出 WARN;
|
|
920
1748
|
// 反向构造:同一夹具置 newChange → BLOCKED。
|
|
1749
|
+
// ⑤ 追加「视觉调性」段体的围栏语义:段里贴了含 `## ` 的围栏示例时,示例之后的「不适用」声明
|
|
1750
|
+
// 仍要被读到(段界只由围栏外的标题决定)。
|
|
921
1751
|
{
|
|
922
|
-
name: 'TA-11 旧 change 同构缺段只 WARN 不阻断;同一夹具新 change 必 BLOCKED',
|
|
1752
|
+
name: 'TA-11 旧 change 同构缺段只 WARN 不阻断;同一夹具新 change 必 BLOCKED;视觉调性段内的围栏示例不截断',
|
|
923
1753
|
run: async (dir) => {
|
|
924
1754
|
const missing = { omit: ['影响面'] };
|
|
925
1755
|
// ① 新 change:拦(对照基准——同一份缺损工件)
|
|
@@ -950,13 +1780,27 @@ export const ENTRIES = [
|
|
|
950
1780
|
const designLegacyRes = exitNode(dir, 'design');
|
|
951
1781
|
assertExit(designLegacyRes, 0);
|
|
952
1782
|
assertOut(designLegacyRes, '旧 change 兼容');
|
|
1783
|
+
// ⑤ 段体围栏语义:「视觉调性」段里贴一段含 `## ` 的围栏示例,「不适用」声明写在围栏**之后**
|
|
1784
|
+
// ⇒ 段体不被示例里的标题截断,判据仍读到声明(围栏是正文示例,不是段界)。旧的按行扫描
|
|
1785
|
+
// 在这里截断段体 → 标记消失 → 判成前端 → 要求一份本不该存在的 UI-DESIGN.md(BLOCKED)。
|
|
1786
|
+
setupDesign(dir, {
|
|
1787
|
+
changeOpts: {
|
|
1788
|
+
body: [['视觉调性',
|
|
1789
|
+
'- **选定**:6 有机 / Organic\n\n```md\n## 示例段(围栏内,不是段界)\n```\n\n- 适用性:不适用(CLI 工具,无用户可见界面)']],
|
|
1790
|
+
},
|
|
1791
|
+
});
|
|
1792
|
+
writeFrontendDesignMarkers(dir);
|
|
1793
|
+
const fencedTone = exitNode(dir, 'design');
|
|
1794
|
+
assertExit(fencedTone, 0);
|
|
1795
|
+
assertOut(fencedTone, 'UI-DESIGN: skipped(非前端)');
|
|
953
1796
|
},
|
|
954
1797
|
},
|
|
955
1798
|
|
|
956
1799
|
// TA-12 · 增量段合法位置(AC-12)——①②④⑤ 合法位置通过;③ 自检方法夹在中间 → BLOCKED。
|
|
957
1800
|
// 合法位置:紧随越界检查 / 文末 / 验证命令标题后紧跟代码块 / LESSONS 扫描位于自检方法之后。
|
|
1801
|
+
// ⑥ 追加 SUMMARY 两条段体切片的围栏语义:6 维自查 / 自检方法段内的围栏示例不截断段体。
|
|
958
1802
|
{
|
|
959
|
-
name: 'TA-12 增量段位置:紧随越界检查/文末/验证命令+代码块/LESSONS
|
|
1803
|
+
name: 'TA-12 增量段位置:紧随越界检查/文末/验证命令+代码块/LESSONS 扫描在后均通过,夹中间拦;6 维自查/自检方法段内围栏示例不截断',
|
|
960
1804
|
run: async (dir) => {
|
|
961
1805
|
// ① 紧随越界检查(默认渲染即此形态)
|
|
962
1806
|
setupExecute(dir);
|
|
@@ -983,6 +1827,20 @@ export const ENTRIES = [
|
|
|
983
1827
|
assertExit(inMiddle, 1);
|
|
984
1828
|
assertOut(inMiddle, 'BLOCKED');
|
|
985
1829
|
assertOut(inMiddle, '自检方法');
|
|
1830
|
+
// ⑥ 段体围栏语义(SUMMARY 的两条切片):6 维自查 / 自检方法段里各贴一段含 `## ` 的围栏示例,
|
|
1831
|
+
// 方法声明写在围栏**之后** ⇒ 段体不被示例里的标题截断,六维实质内容与声明都仍被读到。
|
|
1832
|
+
// 旧的两条正则在示例处截断段体 → 「6 维自查段无实质内容」/「缺 ## 自检方法 段」(BLOCKED)。
|
|
1833
|
+
const fencedBlock = '```md\n## 示例段(围栏内,不是段界)\n```\n\n';
|
|
1834
|
+
setupExecute(dir, {
|
|
1835
|
+
body: [
|
|
1836
|
+
['6 维自查', fencedBlock + SIX_DIM_BODY],
|
|
1837
|
+
['自检方法', fencedBlock + 'brooks-review(夹具声明)'],
|
|
1838
|
+
],
|
|
1839
|
+
});
|
|
1840
|
+
const fencedExecute = exitNode(dir, 'execute');
|
|
1841
|
+
assertExit(fencedExecute, 0);
|
|
1842
|
+
assertOut(fencedExecute, 'ALL CHECKS PASSED');
|
|
1843
|
+
assertNotOut(fencedExecute, '6 维自查段无实质内容');
|
|
986
1844
|
},
|
|
987
1845
|
},
|
|
988
1846
|
|
|
@@ -994,6 +1852,8 @@ export const ENTRIES = [
|
|
|
994
1852
|
// ① `entry <内置节点>` 先打 `READ PROMPT:` 再打 `READ TEMPLATE:`,顺序按输出行索引判
|
|
995
1853
|
// (不是只查两行在不在——行序是语义的一部分);
|
|
996
1854
|
// ② 声明别的节点的协议文件(open 声明 execute 的 4-dev.md)→ 入口 BLOCK,报文点名「与节点协议文件不符」;
|
|
1855
|
+
// ②c 一个标记声明**多份**协议(0-change.md + 4-dev.md)→ 入口逐份核对,第二份越界同样 BLOCK 并
|
|
1856
|
+
// 点名 4-dev.md(只读 protocol 单值的实现只看第一份,这条会绿);两份都在面内 ⇒ 放行;
|
|
997
1857
|
// ③ design 的 2a-ui-design.md 是条件提示词(属该节点协议面)→ 不拦;入口按前端判据追出条件行
|
|
998
1858
|
// (非前端不打印,反向构造即同一夹具只改「视觉调性」);换成无关文件 → 拦;
|
|
999
1859
|
// ④ record 缺 `--templates` 声明 → BLOCK,补上 → 放行;⑤ explain 现问输出 `TEMPLATE:` 行。
|
|
@@ -1072,6 +1932,45 @@ export const ENTRIES = [
|
|
|
1072
1932
|
const correctedPrompt = runGuard(['entry', 'open'], dir);
|
|
1073
1933
|
assertExit(correctedPrompt, 0);
|
|
1074
1934
|
assertNotOut(correctedPrompt, '与节点协议文件不符');
|
|
1935
|
+
// ②b 入口只认活动路径(in-place 扩展):同样的错路径声明只存在于归档目录(真实的归档形态
|
|
1936
|
+
// <日期>-<本 change>)时,入口不追溯归档——那一轮没在活动目录里声明,就没有可核对的声明;
|
|
1937
|
+
// 归档里的声明属于归档前的执行者,拿它判当前节点会把「没声明」判成「声明过」。判据可证伪:
|
|
1938
|
+
// 一旦入口改去读归档,这条错路径声明会当场 BLOCK。
|
|
1939
|
+
const loadsDir = path.join(dir, CHANGE_DIR, '.skill-loads');
|
|
1940
|
+
const loadsAside = path.join(dir, '.specs', 'loads-aside');
|
|
1941
|
+
fs.renameSync(loadsDir, loadsAside);
|
|
1942
|
+
writeFile(dir, '.specs/archive/2026-10-01-' + CHANGE_ID + '/.skill-loads/open-flow-comet-change.json',
|
|
1943
|
+
JSON.stringify({
|
|
1944
|
+
node: 'open', skill: 'flow-comet-change', protocol: '4-dev.md',
|
|
1945
|
+
templates: ['CHANGE', 'REQUIREMENT'], at: '2026-08-01T00:00:00.000Z',
|
|
1946
|
+
}, null, 2) + '\n');
|
|
1947
|
+
const archivedDeclaration = runGuard(['entry', 'open'], dir);
|
|
1948
|
+
assertExit(archivedDeclaration, 0);
|
|
1949
|
+
assertNotOut(archivedDeclaration, '与节点协议文件不符');
|
|
1950
|
+
// 复位:归档诱饵撤掉、活动声明标记归位——③ 起按「已声明」继续
|
|
1951
|
+
fs.rmSync(path.join(dir, '.specs', 'archive'), { recursive: true, force: true });
|
|
1952
|
+
fs.renameSync(loadsAside, loadsDir);
|
|
1953
|
+
|
|
1954
|
+
// ②c 多 --prompt:一个标记可声明多份协议,入口必须**逐份**核对。只读 protocol 单值的实现只看
|
|
1955
|
+
// 第一份 ⇒ 第二份落在节点协议面外也照样放行(记下的是「声明过」,不是「声明对」)。第一份是
|
|
1956
|
+
// open 的协议文件、第二份是 execute 的 4-dev.md → BLOCKED 且点名 4-dev.md。
|
|
1957
|
+
const multiPrompt = (prompts) => runState([
|
|
1958
|
+
'skill-load', 'open', 'flow-comet-change',
|
|
1959
|
+
...prompts.flatMap((prompt) => ['--prompt', 'flow-kit/prompts/' + prompt]),
|
|
1960
|
+
'--templates', 'CHANGE.md,REQUIREMENT.md',
|
|
1961
|
+
], dir);
|
|
1962
|
+
assertExit(multiPrompt(['0-change.md', '4-dev.md']), 0);
|
|
1963
|
+
const multiPromptEntry = runGuard(['entry', 'open'], dir);
|
|
1964
|
+
assertExit(multiPromptEntry, 1);
|
|
1965
|
+
assertOut(multiPromptEntry, 'BLOCKED');
|
|
1966
|
+
assertOut(multiPromptEntry, '与节点协议文件不符');
|
|
1967
|
+
assertOut(multiPromptEntry, '4-dev.md');
|
|
1968
|
+
// 反向构造(单变量 = 被声明的路径):两条 --prompt 都落在 open 的协议面内 ⇒ 放行。拦点因此是
|
|
1969
|
+
// 「哪一份被声明」,不是「声明了几份」。
|
|
1970
|
+
assertExit(multiPrompt(['0-change.md', '1-requirement.md']), 0);
|
|
1971
|
+
const multiPromptOk = runGuard(['entry', 'open'], dir);
|
|
1972
|
+
assertExit(multiPromptOk, 0);
|
|
1973
|
+
assertNotOut(multiPromptOk, '与节点协议文件不符');
|
|
1075
1974
|
|
|
1076
1975
|
// ③ 条件提示词不误拦 + 按前端判定打印:design 声明 2a-ui-design.md(条件提示词,属该节点协议面)
|
|
1077
1976
|
// → 放行;前端 change 的入口追出条件行(与条件模板行对称),非前端 change 不打印。
|
|
@@ -1186,18 +2085,145 @@ export const ENTRIES = [
|
|
|
1186
2085
|
const builtinUndeclared = runGuard(['exit', 'open'], dir);
|
|
1187
2086
|
assertExit(builtinUndeclared, 1);
|
|
1188
2087
|
assertOut(builtinUndeclared, 'BLOCKED');
|
|
1189
|
-
// ④
|
|
1190
|
-
// (与入口 READ PROMPT
|
|
1191
|
-
|
|
1192
|
-
|
|
1193
|
-
|
|
1194
|
-
|
|
1195
|
-
|
|
1196
|
-
|
|
1197
|
-
const
|
|
1198
|
-
|
|
1199
|
-
|
|
2088
|
+
// ④ 声明命令的形态(唯一构造器的直接判据):内置节点拼该节点**全部**协议文件的真实路径
|
|
2089
|
+
// (与入口 READ PROMPT 同源)与该节点的模板全清单;自定义节点没有内置提示词映射 → 不拼
|
|
2090
|
+
// (不编造路径,也不打占位符)。只带首份协议 / 漏模板清单都是「照抄走不通」的形态,逐条断死。
|
|
2091
|
+
// 构造器同时产出**脚本路径**(平台化 + 引号)与**协议上下文**(本次运行解析到的协议不是内置
|
|
2092
|
+
// 默认时才带 --protocol):状态命令族与守卫族取的是这一处,裸脚本名 / 无协议上下文的形态不再存在
|
|
2093
|
+
// ——「照抄能跑通」的行为证据在场景 100(解析打印文本 → 真执行)。
|
|
2094
|
+
const { declarationSkillTargets } = await import('../protocol-utils.mjs');
|
|
2095
|
+
const { declarationCommand } = await import('../lib/state-explain.mjs');
|
|
2096
|
+
const declarationContext = (protocolPath) => ({
|
|
2097
|
+
scriptsDir: path.join(dir, '.claude', 'skills', 'flow-comet', 'scripts'),
|
|
2098
|
+
runRoot: dir,
|
|
2099
|
+
packageRoot: path.join(dir, '.claude', 'skills', 'flow-comet'),
|
|
2100
|
+
protocolPath,
|
|
2101
|
+
});
|
|
2102
|
+
// 内置默认协议 = **本次运行的那个安装根**自己的 reference/workflow-protocol.json(不是权威源
|
|
2103
|
+
// 那一份):判据比较的就是这两个路径,故夹具必须按「该安装根的内置默认」构造。
|
|
2104
|
+
const installedSkillRoot = path.join(dir, '.claude', 'skills', 'flow-comet');
|
|
2105
|
+
const builtinContext = declarationContext(path.join(installedSkillRoot, 'reference', 'workflow-protocol.json'));
|
|
2106
|
+
const executeCommand = declarationCommand({
|
|
2107
|
+
node: { id: 'execute' }, skill: 'flow-comet-dev', context: builtinContext });
|
|
2108
|
+
assertTrue(executeCommand.startsWith('node "'),
|
|
2109
|
+
'声明命令应以 node "<脚本路径>" 起头(裸脚本名照抄 command not found),实际: ' + executeCommand);
|
|
2110
|
+
assertTrue(executeCommand.includes('/workflow-state.mjs" skill-load execute flow-comet-dev'
|
|
2111
|
+
+ ' --prompt flow-kit/prompts/4-dev.md --templates SUMMARY.md'),
|
|
2112
|
+
'内置节点的声明命令应带脚本路径、全部协议文件与模板全清单,实际: ' + executeCommand);
|
|
2113
|
+
// 协议上下文按「本次运行解析到的是不是内置默认」决定:内置默认加载它只是噪音,自定义协议
|
|
2114
|
+
// 不随命令走则照抄解析到另一份(状态命令族没有 state 绑定这一来源)。
|
|
2115
|
+
assertTrue(!executeCommand.includes('--protocol'),
|
|
2116
|
+
'内置默认协议时声明命令不应带 --protocol,实际: ' + executeCommand);
|
|
2117
|
+
const customProtocolContext = declarationCommand({
|
|
2118
|
+
node: { id: 'execute' }, skill: 'flow-comet-dev', context: declarationContext(path.join(dir, 'custom-protocol.json')) });
|
|
2119
|
+
assertTrue(customProtocolContext.includes('--protocol "custom-protocol.json"'),
|
|
2120
|
+
'自定义协议下声明命令必须自带协议上下文(持久化相对形态),实际: ' + customProtocolContext);
|
|
2121
|
+
// open:一条命令带该节点两份协议(旧形态只带首份 0-change.md——照抄后 exit 仍点名 1-requirement.md)
|
|
2122
|
+
const openCommand = declarationCommand({
|
|
2123
|
+
node: { id: 'open' }, skill: 'flow-comet-requirement', context: builtinContext });
|
|
2124
|
+
assertTrue(openCommand.includes(' skill-load open flow-comet-requirement'
|
|
2125
|
+
+ ' --prompt flow-kit/prompts/0-change.md --prompt flow-kit/prompts/1-requirement.md'
|
|
2126
|
+
+ ' --templates CHANGE.md,REQUIREMENT.md'),
|
|
2127
|
+
'open 的声明命令应带该节点全部协议文件与模板全清单,实际: ' + openCommand);
|
|
2128
|
+
const customCommand = declarationCommand({
|
|
2129
|
+
node: { id: 'brainstorm', templates: ['CHANGE'] }, skill: 'fixture-skill', context: builtinContext });
|
|
2130
|
+
assertTrue(customCommand.includes(' skill-load brainstorm fixture-skill --templates CHANGE.md')
|
|
2131
|
+
&& !customCommand.includes('--prompt'),
|
|
1200
2132
|
'自定义节点无内置提示词映射时不应拼 --prompt,实际: ' + customCommand);
|
|
2133
|
+
// 装配单源:命令构造器在引擎面只此一处定义(第二份装配 = 同一件事的第二种文本形态,
|
|
2134
|
+
// 而两种文本只有一种能执行——这正是本判据要防的形态)。
|
|
2135
|
+
const constructorHits = engineDefinitionHits('declarationCommand');
|
|
2136
|
+
assertTrue(constructorHits.length === 1 && constructorHits[0].count === 1,
|
|
2137
|
+
'声明命令的构造器应恰一处定义,实际: ' + JSON.stringify(constructorHits));
|
|
2138
|
+
// 声明的目标技能:每个 guarded 必需技能各一条(open 两条);条件绑定(design 的 ui-design)不在
|
|
2139
|
+
// 同步面展开——它是否适用要判前端,展开权归判得了该判据的出口。
|
|
2140
|
+
// 目标集取自协议节点本身(guarded 必需技能是协议面的事实,不是测试里另编的一份)
|
|
2141
|
+
const builtinOpenNode = JSON.parse(fs.readFileSync(
|
|
2142
|
+
path.join(SCRIPTS_DIR, '..', 'reference', 'workflow-protocol.json'), 'utf8')).nodes.find((node) => node.id === 'open');
|
|
2143
|
+
const openTargets = declarationSkillTargets(builtinOpenNode);
|
|
2144
|
+
assertTrue(openTargets.join(',') === 'flow-comet-change,flow-comet-requirement',
|
|
2145
|
+
'open 的声明目标应是两个 guarded 必需技能,实际: ' + openTargets.join(','));
|
|
2146
|
+
const designTargets = declarationSkillTargets({
|
|
2147
|
+
id: 'design',
|
|
2148
|
+
implementation: { skill: 'flow-comet-design' },
|
|
2149
|
+
requiredSkillCalls: [
|
|
2150
|
+
{ skill: 'flow-comet-design', enforcement: 'guarded', scope: 'main' },
|
|
2151
|
+
{ skill: 'flow-comet-ui-design', enforcement: 'guarded', scope: 'main' },
|
|
2152
|
+
],
|
|
2153
|
+
});
|
|
2154
|
+
assertTrue(designTargets.join(',') === 'flow-comet-design',
|
|
2155
|
+
'design 的同步面声明目标应只含无条件必需技能(ui-design 由判得了前端的出口展开),实际: '
|
|
2156
|
+
+ designTargets.join(','));
|
|
2157
|
+
|
|
2158
|
+
// ⑤ --preflight 与自定义协议的组合(in-place 扩展):结构预检的**声明工件**判据必须来自命令行
|
|
2159
|
+
// 指定的那份协议。造法 = 内置协议副本 + 给 open 节点追加一件只在这份协议里声明的 file 类产物,
|
|
2160
|
+
// 同一夹具跑两次、唯一变量是 --protocol:不指这份协议时没人会去查那件产物,指了就按它拦。
|
|
2161
|
+
// 环境变量(= 上面的对照侧)先复位成**未经改写的**内置副本——本场景 ③ 曾把该副本的模板声明
|
|
2162
|
+
// 改过,带着它做对照就不是单变量了。故「忽略 CLI 参数」与「内置判据写死」两种退化都会让第一次
|
|
2163
|
+
// 调用变成通过(或缺件不被点名)。
|
|
2164
|
+
const builtinProtocolCopy = JSON.parse(
|
|
2165
|
+
fs.readFileSync(path.join(SCRIPTS_DIR, '..', 'reference', 'workflow-protocol.json'), 'utf8'));
|
|
2166
|
+
writeFile(dir, 'reference/workflow-protocol.json', JSON.stringify(builtinProtocolCopy, null, 2) + '\n');
|
|
2167
|
+
const protocolWithExtraArtifact = {
|
|
2168
|
+
...builtinProtocolCopy,
|
|
2169
|
+
nodes: builtinProtocolCopy.nodes.map((node) => (node.id === 'open'
|
|
2170
|
+
? { ...node, outputSchemas: [...node.outputSchemas, 'fixture.extra-artifact.v1'] }
|
|
2171
|
+
: node)),
|
|
2172
|
+
outputSchemas: [...builtinProtocolCopy.outputSchemas, {
|
|
2173
|
+
id: 'fixture.extra-artifact.v1',
|
|
2174
|
+
description: '协议追加的 open 产物(只在本自定义协议里声明)',
|
|
2175
|
+
artifacts: [{
|
|
2176
|
+
id: 'custom-evidence', kind: 'file', required: true,
|
|
2177
|
+
paths: ['<change-id>/custom-evidence.md'], pathBase: 'specs-root',
|
|
2178
|
+
}],
|
|
2179
|
+
evidence: [],
|
|
2180
|
+
}],
|
|
2181
|
+
};
|
|
2182
|
+
const customProtocolFile = path.join(dir, 'reference', 'custom-preflight-protocol.json');
|
|
2183
|
+
writeFile(dir, 'reference/custom-preflight-protocol.json', JSON.stringify(protocolWithExtraArtifact, null, 2) + '\n');
|
|
2184
|
+
setupOpen(dir);
|
|
2185
|
+
const customPreflight = runGuard(['exit', 'open', '--preflight', '--protocol', customProtocolFile], dir);
|
|
2186
|
+
assertExit(customPreflight, 1);
|
|
2187
|
+
assertOut(customPreflight, '声明工件缺失');
|
|
2188
|
+
assertOut(customPreflight, '.specs/' + CHANGE_ID + '/custom-evidence.md');
|
|
2189
|
+
assertTrue(!fs.existsSync(path.join(dir, CHANGE_DIR, '.template-hints.json')),
|
|
2190
|
+
'--preflight 不得写提示账本(自定义协议下同样是只读)');
|
|
2191
|
+
// 反向对照(单变量 = 少一个 --protocol):同一夹具、同一节点、同一命令形态 → 内置副本里没有
|
|
2192
|
+
// 这件产物,故不报缺件(同时排除「预检本来就一律报缺件」这一读法)。
|
|
2193
|
+
const builtinPreflight = runGuard(['exit', 'open', '--preflight'], dir);
|
|
2194
|
+
assertExit(builtinPreflight, 0);
|
|
2195
|
+
assertNotOut(builtinPreflight, 'custom-evidence.md');
|
|
2196
|
+
// 正例:按自定义协议声明的路径补上该产物 → 同一命令转为通过(判据跟着协议走,不是恒拦)
|
|
2197
|
+
writeFile(dir, CHANGE_DIR + '/custom-evidence.md', '# 追加产物\n\n自定义协议声明的结构输入。\n');
|
|
2198
|
+
const satisfiedPreflight = runGuard(['exit', 'open', '--preflight', '--protocol', customProtocolFile], dir);
|
|
2199
|
+
assertExit(satisfiedPreflight, 0);
|
|
2200
|
+
assertOut(satisfiedPreflight, 'ALL CHECKS PASSED');
|
|
2201
|
+
|
|
2202
|
+
// ⑥ 参数面收紧(in-place 扩展):同一命令形态、同一夹具,只改参数的拼写——单横线疑似旗标
|
|
2203
|
+
// (`-apply` 单横线笔误 / `-h`)与节点之后的多余位置参数,修复前都被静默忽略(`-apply` 既不
|
|
2204
|
+
// 落盘也不报错,看起来像一次成功的预演;多余的裸词同样无人认领)。现在两者一律是用法错误、
|
|
2205
|
+
// 非零退出,且不得进入任何门禁链——参数面因此与「已知旗标 + 一个节点名」逐字对得上。
|
|
2206
|
+
const singleDashFlag = runGuard(['exit', 'open', '--preflight', '-apply'], dir);
|
|
2207
|
+
assertExit(singleDashFlag, 1);
|
|
2208
|
+
assertOut(singleDashFlag, '用法错误');
|
|
2209
|
+
assertOut(singleDashFlag, '-apply');
|
|
2210
|
+
assertNotOut(singleDashFlag, 'ALL CHECKS PASSED');
|
|
2211
|
+
const shortFlag = runGuard(['exit', 'open', '-h'], dir);
|
|
2212
|
+
assertExit(shortFlag, 1);
|
|
2213
|
+
assertOut(shortFlag, '用法错误');
|
|
2214
|
+
assertOut(shortFlag, '-h');
|
|
2215
|
+
// 多余位置参数:--protocol 的取值不算位置参数(两者在同一命令里并存,判据不得把取值当多余项)。
|
|
2216
|
+
const extraOperand = runGuard(
|
|
2217
|
+
['exit', 'open', '--preflight', '--protocol', customProtocolFile, 'extra-operand'], dir);
|
|
2218
|
+
assertExit(extraOperand, 1);
|
|
2219
|
+
assertOut(extraOperand, '用法错误');
|
|
2220
|
+
assertOut(extraOperand, 'extra-operand');
|
|
2221
|
+
assertNotOut(extraOperand, 'ALL CHECKS PASSED');
|
|
2222
|
+
// 正对照:同一夹具的合法形态(--protocol 取值 + 无多余操作数)仍然通过——上面三条不是
|
|
2223
|
+
// 「预检一律失败」的同义反复。
|
|
2224
|
+
const legalAgain = runGuard(['exit', 'open', '--preflight', '--protocol', customProtocolFile], dir);
|
|
2225
|
+
assertExit(legalAgain, 0);
|
|
2226
|
+
assertOut(legalAgain, 'ALL CHECKS PASSED');
|
|
1201
2227
|
},
|
|
1202
2228
|
},
|
|
1203
2229
|
|
|
@@ -1269,6 +2295,32 @@ export const ENTRIES = [
|
|
|
1269
2295
|
assertExit(brokeAgain, 1);
|
|
1270
2296
|
assertTrue(!omitSection(brokeAgain, 'T01-SUMMARY.md'),
|
|
1271
2297
|
'释放后再次坏掉应按首败处理(不列段名): ' + failureLine(brokeAgain, 'T01-SUMMARY.md'));
|
|
2298
|
+
|
|
2299
|
+
// ⑧ --preflight 与完整 exit 的两阶段差异(in-place 扩展):预检只读、不维护提示账本,故同一
|
|
2300
|
+
// 节点连跑两次预检都停在报文的**首段**(只报类别计数);写账本的是完整 exit,它才在第二次
|
|
2301
|
+
// 点名段名。两侧都得锁住——预检若改成写账本,第二次预检会提前把段名用掉(「先读模板」的
|
|
2302
|
+
// 引导被绕开);完整 exit 若不写账本,第二次仍只报计数(两阶段报错退化成单阶段)。
|
|
2303
|
+
setupExecute(dir, { omit: ['是否触发新工作'] });
|
|
2304
|
+
assertTrue(!fs.existsSync(hintFile), '夹具起点不应有提示账本');
|
|
2305
|
+
const preFirst = runGuard(['exit', 'execute', '--preflight'], dir);
|
|
2306
|
+
assertExit(preFirst, 1);
|
|
2307
|
+
assertOut(preFirst, '缺段 1 项');
|
|
2308
|
+
assertNotOut(preFirst, '是否触发新工作');
|
|
2309
|
+
assertTrue(!fs.existsSync(hintFile), '--preflight 不得写提示账本(首段形态的前提)');
|
|
2310
|
+
const preSecond = runGuard(['exit', 'execute', '--preflight'], dir);
|
|
2311
|
+
assertExit(preSecond, 1);
|
|
2312
|
+
assertOut(preSecond, '缺段 1 项');
|
|
2313
|
+
assertNotOut(preSecond, '是否触发新工作');
|
|
2314
|
+
assertTrue(!fs.existsSync(hintFile), '第二次 --preflight 仍不得写提示账本(不升级成列段名)');
|
|
2315
|
+
// 同一节点、同一工件、同一缺损:完整 exit 首次只报计数并开账本,第二次点名段名。
|
|
2316
|
+
const fullFirst = exitNode(dir, 'execute');
|
|
2317
|
+
assertExit(fullFirst, 1);
|
|
2318
|
+
assertOut(fullFirst, '缺段 1 项');
|
|
2319
|
+
assertNotOut(fullFirst, '是否触发新工作');
|
|
2320
|
+
assertTrue(fs.existsSync(hintFile), '完整 exit 首次失败应写提示账本(再犯才有「再犯」可言)');
|
|
2321
|
+
const fullSecond = exitNode(dir, 'execute');
|
|
2322
|
+
assertExit(fullSecond, 1);
|
|
2323
|
+
assertOut(fullSecond, '缺段 1 项: 是否触发新工作');
|
|
1272
2324
|
},
|
|
1273
2325
|
},
|
|
1274
2326
|
|
|
@@ -1339,6 +2391,33 @@ export const ENTRIES = [
|
|
|
1339
2391
|
const h3Adjudicated = exitNode(dir, 'review');
|
|
1340
2392
|
assertExit(h3Adjudicated, 0);
|
|
1341
2393
|
assertOut(h3Adjudicated, 'ALL CHECKS PASSED');
|
|
2394
|
+
// ⑧ 段体切片的围栏语义(发现区的段界由 lib/section-body.mjs 单点决定):条目正文里贴了 Markdown
|
|
2395
|
+
// 代码块时,围栏内的 `## ` 不是发现区的段界。修复前它是——发现区被重置成「非发现区」,围栏
|
|
2396
|
+
// 之后的发现条目整段消失,「每条发现必须有处置标记」那道门禁因此对它们形同虚设。
|
|
2397
|
+
const fencedFindings = [
|
|
2398
|
+
'### 🔴 C-3 · 夹具发现:条目正文里贴了一段 Markdown 示例',
|
|
2399
|
+
'**Symptom**:示例代码块里出现段标题',
|
|
2400
|
+
'',
|
|
2401
|
+
'```md',
|
|
2402
|
+
'## 代码块里的示例段标题',
|
|
2403
|
+
'```',
|
|
2404
|
+
'',
|
|
2405
|
+
'- **C-4 · 围栏之后的发现:缺处置标记**:修复前这条整段消失',
|
|
2406
|
+
].join('\n');
|
|
2407
|
+
setupReview(dir, { body: [['2.2', fencedFindings]] });
|
|
2408
|
+
const fencedMissing = exitNode(dir, 'review');
|
|
2409
|
+
assertExit(fencedMissing, 1);
|
|
2410
|
+
assertOut(fencedMissing, '发现区 2 项'); // 两条都在发现区内(修复前只数到围栏之前那条)
|
|
2411
|
+
// ⑨ 围栏外的同级标题照常结束发现区:`## 结论` 之后的列表项不是 2.2 的发现
|
|
2412
|
+
setupReview(dir, { body: [['2.2', h3Finding + '\n\n## 结论\n\n- **C-9 · 段外条目:缺处置标记**']] });
|
|
2413
|
+
const outsideFindings = exitNode(dir, 'review');
|
|
2414
|
+
assertExit(outsideFindings, 1);
|
|
2415
|
+
assertOut(outsideFindings, '发现区 1 项'); // 段外那条不计入(计入则为 2 项)
|
|
2416
|
+
// ⑩ 分隔线语义保持:`---` 不结束发现区(2.2 段内的分隔线是正文,既有语义)
|
|
2417
|
+
setupReview(dir, { body: [['2.2', h3Finding + '\n\n---\n\n- **C-8 · 分隔线之后的发现:缺处置标记**']] });
|
|
2418
|
+
const afterRule = exitNode(dir, 'review');
|
|
2419
|
+
assertExit(afterRule, 1);
|
|
2420
|
+
assertOut(afterRule, '发现区 2 项'); // 分隔线之后的条目仍计入(计入才说明分隔线不结束发现区)
|
|
1342
2421
|
},
|
|
1343
2422
|
},
|
|
1344
2423
|
|
|
@@ -1519,6 +2598,37 @@ export const ENTRIES = [
|
|
|
1519
2598
|
const answered = exitNode(dir, 'execute');
|
|
1520
2599
|
assertExit(answered, 0);
|
|
1521
2600
|
assertOut(answered, 'ALL CHECKS PASSED');
|
|
2601
|
+
|
|
2602
|
+
// 段体切片的围栏语义(LESSONS 扫描段的段界由 lib/section-body.mjs 单点决定):回应写在围栏代码块
|
|
2603
|
+
// 之后仍算数(围栏内的 `## ` 不结束段体);围栏外的分隔线照常结束段体。
|
|
2604
|
+
const lessonsScanTask = () => writeFile(dir, CHANGE_DIR + '/TASK.md', '# TASK\n\n## 任务清单\n\n'
|
|
2605
|
+
+ '<task id="T01" status="done"><action>改模板保真门禁</action>'
|
|
2606
|
+
+ '<write_files>scripts/lib/guard-template-fidelity.mjs</write_files>'
|
|
2607
|
+
+ '<verify>node --check baseline.js</verify></task>\n');
|
|
2608
|
+
// ④ 围栏(反引号)内含二级标题 → 段体不被截断,围栏之后的回应仍被读到
|
|
2609
|
+
setupExecute(dir, { body: [['LESSONS 扫描',
|
|
2610
|
+
'```md\n## 代码块里的示例段标题\n```\n\n- L-501:已读并声明差异(围栏之后的回应)。']] });
|
|
2611
|
+
writeFile(dir, '.specs/LESSONS.md', LESSONS_FIXTURE);
|
|
2612
|
+
lessonsScanTask();
|
|
2613
|
+
const fencedScan = exitNode(dir, 'execute');
|
|
2614
|
+
assertExit(fencedScan, 0);
|
|
2615
|
+
assertOut(fencedScan, 'ALL CHECKS PASSED');
|
|
2616
|
+
// ⑤ 围栏(波浪号)同理:两种围栏记号同口径
|
|
2617
|
+
setupExecute(dir, { body: [['LESSONS 扫描',
|
|
2618
|
+
'~~~md\n## 代码块里的示例段标题\n~~~\n\n- L-501:已读并声明差异(波浪号围栏之后的回应)。']] });
|
|
2619
|
+
writeFile(dir, '.specs/LESSONS.md', LESSONS_FIXTURE);
|
|
2620
|
+
lessonsScanTask();
|
|
2621
|
+
const tildeScan = exitNode(dir, 'execute');
|
|
2622
|
+
assertExit(tildeScan, 0);
|
|
2623
|
+
assertOut(tildeScan, 'ALL CHECKS PASSED');
|
|
2624
|
+
// ⑥ 反向构造:围栏外的分隔线结束段体 —— 回应落在分隔线之后 ⇒ 等于没回应 ⇒ BLOCKED
|
|
2625
|
+
setupExecute(dir, { body: [['LESSONS 扫描',
|
|
2626
|
+
'夹具说明(本段到这里结束)。\n\n---\n\n- L-501:已读并声明差异(分隔线之后的回应)。']] });
|
|
2627
|
+
writeFile(dir, '.specs/LESSONS.md', LESSONS_FIXTURE);
|
|
2628
|
+
lessonsScanTask();
|
|
2629
|
+
const ruleClosedScan = exitNode(dir, 'execute');
|
|
2630
|
+
assertExit(ruleClosedScan, 1);
|
|
2631
|
+
assertOut(ruleClosedScan, 'L-501');
|
|
1522
2632
|
},
|
|
1523
2633
|
},
|
|
1524
2634
|
|
|
@@ -1553,6 +2663,66 @@ export const ENTRIES = [
|
|
|
1553
2663
|
const ok = exitNode(dir, 'archive');
|
|
1554
2664
|
assertExit(ok, 0);
|
|
1555
2665
|
assertOut(ok, 'ALL CHECKS PASSED');
|
|
2666
|
+
// ④b 份数只数本 change 的归档目录(in-place 扩展):归档移动已发生(活动目录不在原位)时,
|
|
2667
|
+
// 同后缀诱饵——名字以 -<本 change> 结尾的别的 change 归档目录——既有份数不得被数进来,也不得
|
|
2668
|
+
// 在本 change 归档目录缺席时充当「有目录可数」。归档目录按 <日期>-<本 change> 精确形态定位。
|
|
2669
|
+
setupArchive(dir, {
|
|
2670
|
+
evidence: { lessonsNomination: { scanned: 2, nominated: ['L-501'], reasonIfNone: '' } },
|
|
2671
|
+
});
|
|
2672
|
+
const archiveRoot = path.join(dir, '.specs', 'archive');
|
|
2673
|
+
// 归档移动:活动目录整体搬成 .specs/archive/2026-10-21-<本 change>/(2 份 SUMMARY 随目录走),
|
|
2674
|
+
// 归档产物 KNOWN-ISSUES.md 也归位到这一份目录,诱饵目录只放 3 份别人的 SUMMARY。
|
|
2675
|
+
fs.renameSync(path.join(dir, CHANGE_DIR), path.join(archiveRoot, '2026-10-21-' + CHANGE_ID));
|
|
2676
|
+
fs.renameSync(path.join(archiveRoot, '2026-10-20-' + CHANGE_ID, 'KNOWN-ISSUES.md'),
|
|
2677
|
+
path.join(archiveRoot, '2026-10-21-' + CHANGE_ID, 'KNOWN-ISSUES.md'));
|
|
2678
|
+
fs.rmSync(path.join(archiveRoot, '2026-10-20-' + CHANGE_ID), { recursive: true, force: true });
|
|
2679
|
+
for (let i = 1; i <= 3; i += 1) {
|
|
2680
|
+
writeFile(dir, '.specs/archive/2026-10-20-other-' + CHANGE_ID + '/T0' + i + '-SUMMARY.md',
|
|
2681
|
+
'# SUMMARY\n\n## 做了什么\n\n诱饵归档的份数。\n');
|
|
2682
|
+
}
|
|
2683
|
+
const ownArchiveCount = runGuard(['exit', 'archive'], dir);
|
|
2684
|
+
assertExit(ownArchiveCount, 0);
|
|
2685
|
+
assertOut(ownArchiveCount, 'ALL CHECKS PASSED');
|
|
2686
|
+
// 反向构造(同一判据 + 单变量):本 change 的归档目录缺席、同后缀诱饵仍在场——份数不可核对
|
|
2687
|
+
// (null),不得退回数诱饵的 3 份。修复前 .find 命中诱饵,3 份与声明一致就整体放行:份数对账
|
|
2688
|
+
// 拿别人的归档作证。这里声明正好写 3,放行即证明数的是诱饵。
|
|
2689
|
+
fs.renameSync(path.join(archiveRoot, '2026-10-21-' + CHANGE_ID, 'KNOWN-ISSUES.md'),
|
|
2690
|
+
path.join(archiveRoot, '2026-10-20-other-' + CHANGE_ID, 'KNOWN-ISSUES.md'));
|
|
2691
|
+
fs.rmSync(path.join(archiveRoot, '2026-10-21-' + CHANGE_ID), { recursive: true, force: true });
|
|
2692
|
+
const decoyOnlyState = newChangeState('archive');
|
|
2693
|
+
decoyOnlyState.evidence.archive = {
|
|
2694
|
+
summary: 'archived',
|
|
2695
|
+
lessonsNomination: { scanned: 3, nominated: [], reasonIfNone: '无新增条目' },
|
|
2696
|
+
};
|
|
2697
|
+
writeState(dir, decoyOnlyState);
|
|
2698
|
+
const decoyOnly = runGuard(['exit', 'archive'], dir);
|
|
2699
|
+
assertExit(decoyOnly, 1);
|
|
2700
|
+
assertOut(decoyOnly, '工件目录缺失');
|
|
2701
|
+
assertNotOut(decoyOnly, 'ALL CHECKS PASSED');
|
|
2702
|
+
// ⑤ 扫描份数的**类型**在写入前就拦(in-place 扩展):scanned 是出口按**数值**比对的字段
|
|
2703
|
+
// (份数相等才算留痕成立),故字符串 "2" 必须被 record 拒。修复前它能落库成功、要等到 archive
|
|
2704
|
+
// 出口才因 "2" !== 2 炸——正是 record 形状校验要消灭的「错误延后暴露」(出错的是 record,
|
|
2705
|
+
// 报错的却是 exit)。判据仍只判类型:取值是否等于 SUMMARY 份数归出口(③),不在这里重复业务规则。
|
|
2706
|
+
writeFile(dir, '.specs/LESSONS.md', LESSONS_FIXTURE);
|
|
2707
|
+
const recordState = baseState('archive');
|
|
2708
|
+
recordState.evidence.archive = { summary: 'archived' };
|
|
2709
|
+
writeState(dir, recordState);
|
|
2710
|
+
const stringScanned = runState(['record', 'archive',
|
|
2711
|
+
'{"summary":"archived","lessonsNomination":{"scanned":"2","nominated":[],"reasonIfNone":"无新增条目"}}'], dir);
|
|
2712
|
+
assertExit(stringScanned, 1);
|
|
2713
|
+
assertOut(stringScanned, 'lessonsNomination.scanned');
|
|
2714
|
+
assertOut(stringScanned, '必须是数字(当前是 string)');
|
|
2715
|
+
const afterReject = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
|
|
2716
|
+
assertTrue(afterReject.evidence.archive.lessonsNomination === undefined,
|
|
2717
|
+
'类型非法的载荷不得落库: ' + JSON.stringify(afterReject.evidence.archive));
|
|
2718
|
+
// 反向构造(单变量:只把 "2" 改成 2):同一载荷 record 通过并原样写入——判据只判类型,
|
|
2719
|
+
// 不新增业务规则,合法载荷不因这条形状校验变得不可写。
|
|
2720
|
+
const numericScanned = runState(['record', 'archive',
|
|
2721
|
+
'{"summary":"archived","lessonsNomination":{"scanned":2,"nominated":[],"reasonIfNone":"无新增条目"}}'], dir);
|
|
2722
|
+
assertExit(numericScanned, 0);
|
|
2723
|
+
const afterAccept = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
|
|
2724
|
+
assertTrue(afterAccept.evidence.archive.lessonsNomination?.scanned === 2,
|
|
2725
|
+
'类型合法的载荷应原样写入 scanned: ' + JSON.stringify(afterAccept.evidence.archive));
|
|
1556
2726
|
},
|
|
1557
2727
|
},
|
|
1558
2728
|
|
|
@@ -1562,9 +2732,10 @@ export const ENTRIES = [
|
|
|
1562
2732
|
|
|
1563
2733
|
// TA-20 · 项目级工件的触发点(AC-20)——① CONTEXT 存在但缺模板段 → open 出口拦;
|
|
1564
2734
|
// ② UI-DESIGN 存在但缺 frontmatter 键 → 前端 change 的 design 出口拦;
|
|
1565
|
-
// ③ `.specs/ARCHITECTURE.md` 缺段 →
|
|
2735
|
+
// ③ `.specs/ARCHITECTURE.md` 缺段 → 侧命令报告列出结构问题但**不阻断**(只读);
|
|
2736
|
+
// ④ CONTEXT 的「evolve 元数据」段体:段内围栏示例不截断段体,围栏里的样例字段也不算数据。
|
|
1566
2737
|
{
|
|
1567
|
-
name: 'TA-20 项目级工件:CONTEXT 缺段拦、UI-DESIGN 缺 frontmatter 键拦、ARCHITECTURE
|
|
2738
|
+
name: 'TA-20 项目级工件:CONTEXT 缺段拦、UI-DESIGN 缺 frontmatter 键拦、ARCHITECTURE 只读报告;CONTEXT 元数据段内围栏示例不截断、样例字段不算数据',
|
|
1568
2739
|
run: async (dir) => {
|
|
1569
2740
|
// ① CONTEXT 缺段(文件存在才查)——段清单基准来自 CONTEXT 模板,故夹具根必须带模板:
|
|
1570
2741
|
// 模板缺席时判据按 C9 整体跳过并显式「未校验(模板缺失)」,该形态由 TA-21 覆盖。
|
|
@@ -1603,6 +2774,47 @@ export const ENTRIES = [
|
|
|
1603
2774
|
const sideOk = runSideCommand(dir, 'evolve.mjs', ['scan', '--root', dir, '--stdout']);
|
|
1604
2775
|
assertExit(sideOk, 0);
|
|
1605
2776
|
assertOut(sideOk, '结构问题(.specs/ARCHITECTURE.md):0 项');
|
|
2777
|
+
// ④ CONTEXT 的「evolve 元数据」段体:段界由 lib/section-body.mjs 单点决定(本任务把
|
|
2778
|
+
// context-init 的同名私有实现收进单源)。两条腿——
|
|
2779
|
+
// ① 段里贴了含 `## ` 的围栏示例、三字段写在示例**之后** ⇒ 段体不被示例里的标题截断,
|
|
2780
|
+
// 校验通过(INIT-DONE);
|
|
2781
|
+
// ② 三字段只写在围栏**内** ⇒ 仍判缺字段(围栏里的书写样例不是数据——段体切片之前结构文本
|
|
2782
|
+
// 已剥离围栏,这条钉住了「别为了省事直接拿原文切片」这个错法)。
|
|
2783
|
+
const ctxRoot = path.join(dir, 'ctx-init');
|
|
2784
|
+
fs.mkdirSync(path.join(ctxRoot, 'reference'), { recursive: true });
|
|
2785
|
+
fs.copyFileSync(scenarioProtocolPath(dir), scenarioProtocolPath(ctxRoot));
|
|
2786
|
+
const contextDoc = (fieldsInFence) => [
|
|
2787
|
+
'# CONTEXT',
|
|
2788
|
+
'## 项目概要', 'x',
|
|
2789
|
+
'## 技术栈', 'x',
|
|
2790
|
+
'## 域语言', '| 术语 | 定义 |', '|---|---|', '| 例 | 定义 |',
|
|
2791
|
+
'## 已锁决策', '- [2026-08-01] 决策一',
|
|
2792
|
+
'## 默认偏好', 'x',
|
|
2793
|
+
'## 既有抽象索引', 'x',
|
|
2794
|
+
'## evolve 元数据', '',
|
|
2795
|
+
'```md',
|
|
2796
|
+
'## 示例段(围栏内,不是段界)',
|
|
2797
|
+
...(fieldsInFence
|
|
2798
|
+
? ['- **last_evolve_at**: 2026-09-01T10:00:00+08:00', '- **scanner**: fixture', '- **下次建议**: 无']
|
|
2799
|
+
: []),
|
|
2800
|
+
'```',
|
|
2801
|
+
...(fieldsInFence
|
|
2802
|
+
? []
|
|
2803
|
+
: ['', '- **last_evolve_at**: 2026-09-01T10:00:00+08:00', '- **scanner**: fixture', '- **下次建议**: 无']),
|
|
2804
|
+
'## intel-scan 元数据',
|
|
2805
|
+
'- **last_intel_scan**: x', '- **scanner**: x', '- **下次重扫建议**: x',
|
|
2806
|
+
'',
|
|
2807
|
+
].join('\n');
|
|
2808
|
+
writeFile(ctxRoot, '.specs/CONTEXT.md', contextDoc(false));
|
|
2809
|
+
const ctxFenced = runState(['init', CHANGE_ID + '-ctx', '--init-context'], ctxRoot);
|
|
2810
|
+
assertExit(ctxFenced, 0);
|
|
2811
|
+
assertOut(ctxFenced, 'INIT-DONE');
|
|
2812
|
+
assertNotOut(ctxFenced, 'INIT-VALIDATE-FAILED');
|
|
2813
|
+
writeFile(ctxRoot, '.specs/CONTEXT.md', contextDoc(true));
|
|
2814
|
+
const ctxFencedOnly = runState(['init', CHANGE_ID + '-ctx2', '--init-context'], ctxRoot);
|
|
2815
|
+
assertExit(ctxFencedOnly, 0);
|
|
2816
|
+
assertOut(ctxFencedOnly, 'INIT-VALIDATE-FAILED');
|
|
2817
|
+
assertOut(ctxFencedOnly, 'evolve 元数据');
|
|
1606
2818
|
},
|
|
1607
2819
|
},
|
|
1608
2820
|
|
|
@@ -1610,8 +2822,14 @@ export const ENTRIES = [
|
|
|
1610
2822
|
// 「未校验(模板缺失)」。反向构造:模板在场时同一工件必被拦(证明不是判据空转)。
|
|
1611
2823
|
// ③④ 追加「段名清单单一来源」:模板缺席时仍要生效的四份段名清单(SUMMARY 段序兜底 / open·design 段名回退 /
|
|
1612
2824
|
// LESSONS 扫描段名 / SUMMARY 必填三段)只许骨架模块登记一份——静态单源锁 + 行为侧反向构造。
|
|
2825
|
+
// ⑤ 追加「段体切片单源锁」的静态面:受检面 = 引擎实现面(不再只是取用面),形态面含行扫描与正则
|
|
2826
|
+
// 切片两种;仍存在的同类实现逐条登记(文件 + 符号 + 理由),并配回退探针证明锁看得见它们。
|
|
2827
|
+
// 写法面追加字符串字面量切分、位置面追加对象字面量内联箭头(各有合成切片探针):字面量切分写在
|
|
2828
|
+
// 属性箭头里正是静态锁此前的盲区——引擎里因此留着第二份段体切片而判据全绿。
|
|
2829
|
+
// ⑦ 追加「配对键单源」:第三族的任务对键只在 task-graph 表达一次,[P] 判据的补集消费它返回的判定;
|
|
2830
|
+
// 反向构造三层(换名字 / 换分隔符的第二份键 + 形态漂移的行为变异体)证明补集断言真的敏感。
|
|
1613
2831
|
{
|
|
1614
|
-
name: 'TA-21
|
|
2832
|
+
name: 'TA-21 模板缺席降级:不阻断且显式输出「未校验(模板缺失)」;模板在场时同夹具被拦;段名清单 / 段体切片 / 任务对键 / 写面元素 / 运行根的单源锁(受检面 = 引擎实现面)+ 运行根隔离(真跑 CLI)',
|
|
1615
2833
|
run: async (dir) => {
|
|
1616
2834
|
// ① 模板缺席:只写工件,不写 flow-kit/templates/
|
|
1617
2835
|
writeFile(dir, CHANGE_DIR + '/CHANGE.md', renderDoc('CHANGE', { omit: ['影响面'] }));
|
|
@@ -1619,6 +2837,7 @@ export const ENTRIES = [
|
|
|
1619
2837
|
const st = newChangeState('open');
|
|
1620
2838
|
st.evidence.open = { summary: 'intake complete' };
|
|
1621
2839
|
writeState(dir, st);
|
|
2840
|
+
writeNodeDeclarationMarkers(dir, 'open');
|
|
1622
2841
|
const degraded = exitNode(dir, 'open');
|
|
1623
2842
|
assertExit(degraded, 0);
|
|
1624
2843
|
assertOut(degraded, '未校验');
|
|
@@ -1642,8 +2861,51 @@ export const ENTRIES = [
|
|
|
1642
2861
|
'TEMPLATE_FALLBACK_SECTION_PATTERNS',
|
|
1643
2862
|
'LESSONS_SCAN_SECTION',
|
|
1644
2863
|
'SUMMARY_REQUIRED_SECTIONS',
|
|
2864
|
+
'WAVE_SECTION_NAME',
|
|
1645
2865
|
];
|
|
1646
2866
|
const issues = [];
|
|
2867
|
+
// ③0 夹具能力自检(反向构造的前提,先于被测面):摘 import 要覆盖三种位置——名前 / 名后 / 唯一项。
|
|
2868
|
+
// 夹具此前只处理「逗号相邻」:单名单行 import 摘不动,反向构造于是报「前提失效(变异未改变
|
|
2869
|
+
// 文件)」而不是真回归(锁在说谎,L-151)。三份合成 import 逐份验「名字真的没了、语句还在」。
|
|
2870
|
+
const dropProbeSymbol = segmentSymbols[0];
|
|
2871
|
+
for (const dropForm of [
|
|
2872
|
+
'import { ' + dropProbeSymbol + ', otherName } from "./x.mjs";',
|
|
2873
|
+
'import { otherName, ' + dropProbeSymbol + ' } from "./x.mjs";',
|
|
2874
|
+
'import { ' + dropProbeSymbol + ' } from "./x.mjs";',
|
|
2875
|
+
]) {
|
|
2876
|
+
const dropped = dropNamedImport(dropForm, dropProbeSymbol);
|
|
2877
|
+
assertTrue(!new RegExp('\\b' + dropProbeSymbol + '\\b').test(dropped)
|
|
2878
|
+
&& /^import\s*\{[^}]*\}\s*from\s*"\.\/x\.mjs";$/u.test(dropped.trim()),
|
|
2879
|
+
'夹具摘 import 漏了一种位置(原样 ' + JSON.stringify(dropForm) + ' → 摘后 ' + JSON.stringify(dropped)
|
|
2880
|
+
+ '):反向构造会退化成前提失效,锁的判别力无从证明');
|
|
2881
|
+
}
|
|
2882
|
+
// ③0b 共享段标题谓词(「这一行是不是登记的某段」的唯一判定 = normalizeHeading 相等 + 级别):
|
|
2883
|
+
// 定义面恰一处,波次门与 AC 门都具名取用。反向构造走**唯一项** import——夹具摘不动时这一格
|
|
2884
|
+
// 会一直绿,正是上一轮那条接缝(引擎迁就夹具)的闭合断言:原样零问题、摘掉 import 必报「未从」。
|
|
2885
|
+
const sharedPredicate = engineDefinitionModule('headingPredicate');
|
|
2886
|
+
assertTrue(sharedPredicate !== null,
|
|
2887
|
+
'共享段标题谓词的定义面应恰一处(波次门与 AC 门同一口径): '
|
|
2888
|
+
+ JSON.stringify(engineDefinitionHits('headingPredicate')));
|
|
2889
|
+
const sharedPredicateProblems = singleSourceImportProblems({
|
|
2890
|
+
symbol: 'headingPredicate', sourceRel: sharedPredicate.file, texts,
|
|
2891
|
+
});
|
|
2892
|
+
assertTrue(sharedPredicateProblems.length === 0,
|
|
2893
|
+
'段标题谓词单源违规(两道门必须从同一处取用): ' + sharedPredicateProblems.join(' | '));
|
|
2894
|
+
const soleItemText = 'import { headingPredicate } from "./guard-artifact-skeleton.mjs";\n'
|
|
2895
|
+
+ 'export const probeHeadingJudged = headingPredicate;\n';
|
|
2896
|
+
const soleItemDropped = dropNamedImport(soleItemText, 'headingPredicate');
|
|
2897
|
+
assertTrue(soleItemDropped !== soleItemText,
|
|
2898
|
+
'夹具摘不动唯一项 import(单名、单行):反向构造会退化成前提失效,锁的判别力无从证明');
|
|
2899
|
+
const soleItemProblems = (consumerText) => singleSourceImportProblems({
|
|
2900
|
+
symbol: 'headingPredicate',
|
|
2901
|
+
sourceRel: sharedPredicate.file,
|
|
2902
|
+
texts: new Map([[sharedPredicate.file, sharedPredicate.text], ['lib/probe-consumer.mjs', consumerText]]),
|
|
2903
|
+
});
|
|
2904
|
+
assertTrue(soleItemProblems(soleItemText).length === 0,
|
|
2905
|
+
'唯一项 import 的原样文本被判违规(探针前提不成立): ' + JSON.stringify(soleItemProblems(soleItemText)));
|
|
2906
|
+
assertTrue(soleItemProblems(soleItemDropped).some((problem) => problem.includes('未从')),
|
|
2907
|
+
'唯一项 import 摘除后取用面判据未发声(夹具摘不动时反向构造形同虚设): '
|
|
2908
|
+
+ JSON.stringify(soleItemProblems(soleItemDropped)));
|
|
1647
2909
|
for (const symbol of segmentSymbols) {
|
|
1648
2910
|
const lookup = engineDefinitionModule(symbol);
|
|
1649
2911
|
if (lookup === null) {
|
|
@@ -1659,6 +2921,32 @@ export const ENTRIES = [
|
|
|
1659
2921
|
}
|
|
1660
2922
|
assertTrue(issues.length === 0, '段名清单单源违规: ' + issues.join(' | '));
|
|
1661
2923
|
|
|
2924
|
+
// ③a 登记名与模板实际段名一致(模板在场时对账):段名登记成常量之后,模板若把该段改名,登记值
|
|
2925
|
+
// 就成了新的静默源——判据仍按一个不存在的段名读,换个标题写法即「未校验」放行。对账用共享归一
|
|
2926
|
+
// 做比较(编号前缀 / 尾部括号 / 闭合 ATX 不算差异),并配反向构造(改一个字不得被判成一致)。
|
|
2927
|
+
// 模板缺席(本检出无 vendored flow-kit)时退到登记表的段名清单,并显式声明降级来源:模板侧
|
|
2928
|
+
// 一致性由发版期指纹作业保证,SKIP = 未校验,不是通过。
|
|
2929
|
+
const waveSectionNorm = normalizeHeading(WAVE_SECTION_NAME);
|
|
2930
|
+
const waveNameMatches = (names) => names.some((name) => normalizeHeading(name) === waveSectionNorm);
|
|
2931
|
+
const registryTaskNames = (docEntry('TASK').sections ?? []).map((section) => section.name);
|
|
2932
|
+
assertTrue(waveNameMatches(registryTaskNames),
|
|
2933
|
+
'波次段名登记值与登记表的 TASK 段名不一致(登记值 ' + JSON.stringify(WAVE_SECTION_NAME)
|
|
2934
|
+
+ ' 不在 ' + JSON.stringify(registryTaskNames) + ')——段名只有一处登记,改一处即可');
|
|
2935
|
+
assertTrue(!waveNameMatches(registryTaskNames.map((name) => name.replace('波次划分', '波次分配'))),
|
|
2936
|
+
'段名对账判据不具判别力:改一个字的段名与登记值被判成一致(比较退化成恒真)');
|
|
2937
|
+
const vendoredTaskTemplate = path.join(REPO_ROOT, 'flow-kit', 'templates', 'TASK.md');
|
|
2938
|
+
if (fs.existsSync(vendoredTaskTemplate)) {
|
|
2939
|
+
const templateHeadings = fs.readFileSync(vendoredTaskTemplate, 'utf8').split(/\r?\n/u)
|
|
2940
|
+
.filter((line) => /^##\s+/u.test(line))
|
|
2941
|
+
.map((line) => line.replace(/^##\s+/u, '').trim());
|
|
2942
|
+
assertTrue(waveNameMatches(templateHeadings),
|
|
2943
|
+
'波次段名登记值与 TASK 模板的实际段名不一致(模板段名 ' + JSON.stringify(templateHeadings)
|
|
2944
|
+
+ ' 不含登记值 ' + JSON.stringify(WAVE_SECTION_NAME) + ')——模板改名时须同批更新登记值');
|
|
2945
|
+
} else {
|
|
2946
|
+
console.log('SKIP: 波次段名与 TASK 模板对账(本检出无 vendored flow-kit 模板)'
|
|
2947
|
+
+ '——已退到登记表段名对账;模板侧一致性由发版期指纹作业保证(SKIP = 未校验,不是通过)');
|
|
2948
|
+
}
|
|
2949
|
+
|
|
1662
2950
|
// ③b 反向构造(同一判据驱动 · 逐项改坏输入 ⇒ 必报,还原 ⇒ 复绿):四份清单逐份证明判别力,
|
|
1663
2951
|
// 不是「只有某一份碰巧被测到」。
|
|
1664
2952
|
{
|
|
@@ -1714,6 +3002,7 @@ export const ENTRIES = [
|
|
|
1714
3002
|
// 负例:把「做了什么」挪到「越界检查」之后 → 偏离兜底段序 → BLOCKED(模板缺席也判)
|
|
1715
3003
|
writeFile(dir, CHANGE_DIR + '/T01-SUMMARY.md', renderDoc('SUMMARY', { swap: [['做了什么', '越界检查']] }));
|
|
1716
3004
|
writeState(dir, executeState());
|
|
3005
|
+
writeNodeDeclarationMarkers(dir, 'execute');
|
|
1717
3006
|
const outOfOrder = exitNode(dir, 'execute');
|
|
1718
3007
|
assertExit(outOfOrder, 1);
|
|
1719
3008
|
assertOut(outOfOrder, '未校验');
|
|
@@ -1721,6 +3010,7 @@ export const ENTRIES = [
|
|
|
1721
3010
|
// 正例:段序按清单 → 通过
|
|
1722
3011
|
writeFile(dir, CHANGE_DIR + '/T01-SUMMARY.md', renderDoc('SUMMARY'));
|
|
1723
3012
|
writeState(dir, executeState());
|
|
3013
|
+
writeNodeDeclarationMarkers(dir, 'execute');
|
|
1724
3014
|
const ordered = exitNode(dir, 'execute');
|
|
1725
3015
|
assertExit(ordered, 0);
|
|
1726
3016
|
assertOut(ordered, 'ALL CHECKS PASSED');
|
|
@@ -1739,6 +3029,7 @@ export const ENTRIES = [
|
|
|
1739
3029
|
return next;
|
|
1740
3030
|
};
|
|
1741
3031
|
writeState(dir, openState());
|
|
3032
|
+
writeNodeDeclarationMarkers(dir, 'open');
|
|
1742
3033
|
const noFallback = exitNode(dir, 'open');
|
|
1743
3034
|
assertExit(noFallback, 0);
|
|
1744
3035
|
assertNotOut(noFallback, '缺必填段');
|
|
@@ -1753,6 +3044,7 @@ export const ENTRIES = [
|
|
|
1753
3044
|
writeFile(dir, CHANGE_DIR + '/CHANGE.md', renderDoc('CHANGE', { omit: ['Why'] }));
|
|
1754
3045
|
writeFile(dir, CHANGE_DIR + '/REQUIREMENT.md', renderDoc('REQUIREMENT'));
|
|
1755
3046
|
writeState(dir, openState());
|
|
3047
|
+
writeNodeDeclarationMarkers(dir, 'open');
|
|
1756
3048
|
const fallbackStill = exitNode(dir, 'open');
|
|
1757
3049
|
assertExit(fallbackStill, 1);
|
|
1758
3050
|
assertOut(fallbackStill, '缺必填段');
|
|
@@ -1771,6 +3063,653 @@ export const ENTRIES = [
|
|
|
1771
3063
|
const fallbackPick = derivedPatterns.pick('change', ['Why'], routing.TEMPLATE_FALLBACK_SECTION_PATTERNS.changeWhy);
|
|
1772
3064
|
assertTrue(fallbackPick instanceof RegExp && fallbackPick.test('## Why(为什么做)'),
|
|
1773
3065
|
'模板在场但缺该段名时 pick 仍回落 fallback 正则(C9 后半句),实际: ' + String(fallbackPick));
|
|
3066
|
+
|
|
3067
|
+
// ⑥b 轮廓解析跨围栏(段体单源化的**行为面**):把某段的标题只写在**围栏示例**里、真段删掉
|
|
3068
|
+
// ——围栏里的标题不开段,缺段必须照样判出。旧 parseOutline 按行扫 `^##`(围栏盲):
|
|
3069
|
+
// 示例里的标题被读成真实段,缺段被静默放过(假绿)。它是段序 / 空正文 / 增量段位置的
|
|
3070
|
+
// 共同输入,同一份盲区在那三处也会各自变成假绿——所以这里钉的是轮廓解析本身。
|
|
3071
|
+
resetFixture(dir);
|
|
3072
|
+
writeTemplateFixture(dir, 'CHANGE');
|
|
3073
|
+
// 段名取模板里**最后一个**必需段:把它的标题只写进围栏示例(放在它前面那段里)——示例行
|
|
3074
|
+
// 被读成真实段时它落在自己的模板位置上,段序判据不出声,缺段就此静默放过(正是假绿形态)。
|
|
3075
|
+
writeFile(dir, CHANGE_DIR + '/CHANGE.md', renderDoc('CHANGE', {
|
|
3076
|
+
omit: ['风险与未知'],
|
|
3077
|
+
body: [['验收线', ['验收线(夹具)。', '',
|
|
3078
|
+
'```markdown', '## 风险与未知', '示例:围栏内的段标题', '```', ''].join('\n')]],
|
|
3079
|
+
}));
|
|
3080
|
+
writeFile(dir, CHANGE_DIR + '/REQUIREMENT.md', renderDoc('REQUIREMENT'));
|
|
3081
|
+
writeState(dir, openState());
|
|
3082
|
+
writeNodeDeclarationMarkers(dir, 'open');
|
|
3083
|
+
const fencedOutline = exitNode(dir, 'open');
|
|
3084
|
+
assertExit(fencedOutline, 1);
|
|
3085
|
+
assertOut(fencedOutline, '缺段');
|
|
3086
|
+
assertNotOut(fencedOutline, 'BLOCKED: CHANGE.md 模板结构校验失败: 段序');
|
|
3087
|
+
|
|
3088
|
+
// ⑤ 段体切片单源锁:受检面 = **引擎实现面**(`engineScriptTexts`:顶层入口 ∪ 静态可达模块 ∪
|
|
3089
|
+
// 非套件自持的 `lib/**`)——不再是「提到 sectionBody 的取用面」:把一份私有实现搬进面内一个
|
|
3090
|
+
// 不引用该符号的模块(健康巡检、任一 guard 模块)就躲不开了。三条判据:① 单源模块由导出面派生
|
|
3091
|
+
// (不写文件名),{sectionBody, scanHeadings}
|
|
3092
|
+
// 都定义在那里;② 取用面:提到单源符号的模块必须具名取用、不得自带第二份定义;③ 形态面:
|
|
3093
|
+
// 面内任一函数的任一形态(行扫描 / 正则切片 / 字符串字面量 / 行数组切片)若在切段体,只许是
|
|
3094
|
+
// 单源本身,否则必须登记(SECTION_SLICE_REGISTRY:文件 + 符号 + 理由 + 合并条件;陈旧登记判红)。
|
|
3095
|
+
// 反向构造:合成切片放进「不引用单源符号」的模块(证明受检面比取用面宽)/ 改 import 来源 /
|
|
3096
|
+
// 第二份定义 / 本任务收口的三处各自改回私有实现 / 登记放行真实副本 / 陈旧登记 / 缺理由登记
|
|
3097
|
+
// ——逐条证明判别力,还原 ⇒ 复绿。
|
|
3098
|
+
{
|
|
3099
|
+
const texts = engineScriptTexts();
|
|
3100
|
+
const baseProblems = sectionSingleSourceProblems({ texts });
|
|
3101
|
+
assertTrue(baseProblems.length === 0, '段体单源违规: ' + baseProblems.join(' | '));
|
|
3102
|
+
const probeIssues = [];
|
|
3103
|
+
// 探针打在**登记之外**的消费方上,否则变异会被登记豁免吃掉、退化成恒绿。
|
|
3104
|
+
const consumers = [...texts.keys()].filter((rel) => /\b(?:sectionBody|scanHeadings)\b/u
|
|
3105
|
+
.test(engineCodeText(texts.get(rel) ?? '')));
|
|
3106
|
+
const probeRel = consumers.find((rel) => !SECTION_SLICE_REGISTRY.some((entry) => entry.file === rel));
|
|
3107
|
+
const probeText = texts.get(probeRel);
|
|
3108
|
+
const probeSlicer = [
|
|
3109
|
+
'function probeSectionBody(content) {',
|
|
3110
|
+
' const body = [];',
|
|
3111
|
+
' for (const line of String(content).split(/\\n/)) {',
|
|
3112
|
+
' if (/^##\\s/u.test(line)) break;',
|
|
3113
|
+
' body.push(line);',
|
|
3114
|
+
' }',
|
|
3115
|
+
' return body.join("\\n");',
|
|
3116
|
+
'}',
|
|
3117
|
+
].join('\n');
|
|
3118
|
+
// 受检面必须比取用面宽(否则「形态面」只是换名字的取用面):把同一份合成切片放进一个从不引用
|
|
3119
|
+
// 单源符号的模块,判据仍须点名它。这条同时钉住了 SECTION_SLICE_REGISTRY 的登记面——那几条
|
|
3120
|
+
// 命中都不 import sectionBody,一旦受检面退回取用面,它们会立刻变成陈旧登记(也是红的)。
|
|
3121
|
+
const shadowRel = SECTION_SLICE_REGISTRY[0].file;
|
|
3122
|
+
assertTrue(!/\b(?:sectionBody|scanHeadings)\b/u.test(engineCodeText(texts.get(shadowRel) ?? '')),
|
|
3123
|
+
'受检面扩面的前提失效:' + shadowRel + ' 引用了单源符号(形态面与取用面不再可区分)');
|
|
3124
|
+
const shadowProblems = sectionSingleSourceProblems({
|
|
3125
|
+
texts: new Map(texts).set(shadowRel, (texts.get(shadowRel) ?? '') + '\n' + probeSlicer),
|
|
3126
|
+
});
|
|
3127
|
+
if (!shadowProblems.some((problem) => problem.includes(shadowRel) && problem.includes('probeSectionBody'))) {
|
|
3128
|
+
probeIssues.push('受检面退回了取用面:' + shadowRel + ' 里的合成切片未被判红('
|
|
3129
|
+
+ JSON.stringify(shadowProblems) + ')');
|
|
3130
|
+
}
|
|
3131
|
+
// 取用面两格:改 import 来源(单符号 import 摘名字靠不住,换来源才是同一件事的可靠构造)/
|
|
3132
|
+
// 自带第二份定义。
|
|
3133
|
+
const referenced = SECTION_SOURCE_SYMBOLS.find((symbol) => new RegExp('\\b' + symbol + '\\b', 'u')
|
|
3134
|
+
.test(engineCodeText(probeText))) ?? 'sectionBody';
|
|
3135
|
+
const retargeted = probeText.replace(/(from\s*'[^']*)section-body\.mjs'/u, "$1section-body-absent.mjs'");
|
|
3136
|
+
const takenProbes = [
|
|
3137
|
+
['消费方不再从单源取用(import 来源被换掉)', retargeted, '未从'],
|
|
3138
|
+
['消费方自带第二份定义', probeText + '\nfunction ' + referenced + '() { return null; }\n', '自带第二份'],
|
|
3139
|
+
];
|
|
3140
|
+
for (const [label, mutatedText, expected] of takenProbes) {
|
|
3141
|
+
if (mutatedText === probeText) {
|
|
3142
|
+
probeIssues.push(label + ':变异未改变 ' + probeRel);
|
|
3143
|
+
continue;
|
|
3144
|
+
}
|
|
3145
|
+
const reported = sectionSingleSourceProblems({ texts: new Map(texts).set(probeRel, mutatedText) });
|
|
3146
|
+
if (!reported.some((problem) => problem.includes(probeRel) && problem.includes(expected))) {
|
|
3147
|
+
probeIssues.push(label + ':未被判违规(' + JSON.stringify(reported) + ')');
|
|
3148
|
+
}
|
|
3149
|
+
}
|
|
3150
|
+
// 写法面两格(C 字符串字面量切分 / D 对象字面量内联箭头)各一份**合成实现**放进取用面之外的
|
|
3151
|
+
// 模块 ⇒ 判据必须点名它们:旧锁对这两种写法都判绿(B 的判据只认正则字面量,functionBodies 只看
|
|
3152
|
+
// 顶层声明),「锁看不见」于是无从发现——这一格是这两种写法的常驻判别力锚。
|
|
3153
|
+
const syntheticSlicers = [
|
|
3154
|
+
['C 字符串字面量切分', 'probeStringSlicer', [
|
|
3155
|
+
'function probeStringSlicer(content) {',
|
|
3156
|
+
' return (String(content).split("## S")[1] ?? "").split("\\n##")[0];',
|
|
3157
|
+
'}',
|
|
3158
|
+
].join('\n')],
|
|
3159
|
+
['D 对象字面量内联箭头', 'probeInlineSlicer', [
|
|
3160
|
+
'const probeChecks = [',
|
|
3161
|
+
' {',
|
|
3162
|
+
' probeInlineSlicer: (text) => {',
|
|
3163
|
+
' const seg = (text.split("## 已锁决策")[1] ?? "").split("\\n##")[0];',
|
|
3164
|
+
' return seg.length >= 0;',
|
|
3165
|
+
' },',
|
|
3166
|
+
' },',
|
|
3167
|
+
'];',
|
|
3168
|
+
].join('\n')],
|
|
3169
|
+
];
|
|
3170
|
+
for (const [label, symbol, synthetic] of syntheticSlicers) {
|
|
3171
|
+
const reported = sectionSingleSourceProblems({
|
|
3172
|
+
texts: new Map(texts).set(shadowRel, (texts.get(shadowRel) ?? '') + '\n' + synthetic),
|
|
3173
|
+
});
|
|
3174
|
+
if (!reported.some((problem) => problem.includes(shadowRel) && problem.includes(symbol))) {
|
|
3175
|
+
probeIssues.push('形态面未覆盖「' + label + '」:' + shadowRel + ' 里的合成切片 ' + symbol
|
|
3176
|
+
+ ' 未被判红(' + JSON.stringify(reported) + ')');
|
|
3177
|
+
}
|
|
3178
|
+
}
|
|
3179
|
+
// 形态面:本任务收口的三处各自改回私有实现 ⇒ 锁必红(变异体 = 删掉的旧实现原文)。
|
|
3180
|
+
const revertedTexts = new Map();
|
|
3181
|
+
for (const reverted of REVERTED_PRIVATE_SLICERS) {
|
|
3182
|
+
// 变异体按 LF 归一后再套用(工作树是 CRLF,锚文本写的是 LF):不归一时整段锚永远找不到,
|
|
3183
|
+
// 探针会以「锚已漂移」红——那红说的是行尾,不是判据。
|
|
3184
|
+
const original = (texts.get(reverted.rel) ?? '').replace(/\r\n/gu, '\n');
|
|
3185
|
+
let mutated = original;
|
|
3186
|
+
for (const [from, to] of reverted.edits) {
|
|
3187
|
+
if (!mutated.includes(from)) {
|
|
3188
|
+
probeIssues.push(reverted.label + ':锚已漂移(' + reverted.rel + ' 里找不到待替换片段)');
|
|
3189
|
+
continue;
|
|
3190
|
+
}
|
|
3191
|
+
mutated = mutated.split(from).join(to);
|
|
3192
|
+
}
|
|
3193
|
+
if (mutated === original) {
|
|
3194
|
+
probeIssues.push(reverted.label + ':变异未改变 ' + reverted.rel);
|
|
3195
|
+
continue;
|
|
3196
|
+
}
|
|
3197
|
+
revertedTexts.set(reverted.rel, mutated);
|
|
3198
|
+
const reported = sectionSingleSourceProblems({ texts: new Map(texts).set(reverted.rel, mutated) });
|
|
3199
|
+
for (const symbol of reverted.symbols) {
|
|
3200
|
+
if (!reported.some((problem) => problem.includes(reverted.rel) && problem.includes(symbol))) {
|
|
3201
|
+
probeIssues.push(reverted.label + ':锁没看见 ' + reverted.rel + ' 的 ' + symbol
|
|
3202
|
+
+ '(' + JSON.stringify(reported) + ')');
|
|
3203
|
+
}
|
|
3204
|
+
}
|
|
3205
|
+
}
|
|
3206
|
+
// 登记机制本身的五格:陈旧登记判红 / 缺理由判红 / 缺合并条件判红(登记要写到期的条件,
|
|
3207
|
+
// 不是永久豁免)/ **登记不能放行真实副本**(给 context-init 的私有 sectionBody 配一条登记,
|
|
3208
|
+
// 判据仍须报「自带第二份定义」——登记只覆盖形态命中)/ 登记条目必须**当场命中**(删掉
|
|
3209
|
+
// evolve.mjs 的那条 ⇒ 判据点名它的 locateSedimentSection,证明 E 形态真的落在形态面上)。
|
|
3210
|
+
const staleRegistry = [...SECTION_SLICE_REGISTRY, {
|
|
3211
|
+
file: 'lib/guard-uidesign.mjs', symbol: 'visualToneSectionState', reason: '(探针)已收口处仍登记',
|
|
3212
|
+
}];
|
|
3213
|
+
const staleProblems = sectionSingleSourceProblems({ texts, registry: staleRegistry });
|
|
3214
|
+
if (!staleProblems.some((problem) => problem.includes('登记已陈旧') && problem.includes('visualToneSectionState'))) {
|
|
3215
|
+
probeIssues.push('陈旧登记未被判红(已收口的视觉调性段体仍登记): ' + JSON.stringify(staleProblems));
|
|
3216
|
+
}
|
|
3217
|
+
const noReasonProblems = sectionSingleSourceProblems({
|
|
3218
|
+
texts,
|
|
3219
|
+
registry: [{ ...SECTION_SLICE_REGISTRY[0], reason: ' ' }],
|
|
3220
|
+
});
|
|
3221
|
+
if (!noReasonProblems.some((problem) => problem.includes('登记缺理由'))) {
|
|
3222
|
+
probeIssues.push('缺理由登记未被判红: ' + JSON.stringify(noReasonProblems));
|
|
3223
|
+
}
|
|
3224
|
+
const noMergeProblems = sectionSingleSourceProblems({
|
|
3225
|
+
texts,
|
|
3226
|
+
registry: [{ ...SECTION_SLICE_REGISTRY[0], mergeCondition: ' ' }],
|
|
3227
|
+
});
|
|
3228
|
+
if (!noMergeProblems.some((problem) => problem.includes('登记缺合并条件'))) {
|
|
3229
|
+
probeIssues.push('缺合并条件的登记未被判红(永久豁免没到期日): ' + JSON.stringify(noMergeProblems));
|
|
3230
|
+
}
|
|
3231
|
+
// 登记条目必须当场命中:evolve.mjs 的 E 形态(findIndex + slice + 可达标题判定)是这一条
|
|
3232
|
+
// 的判别锚——删掉登记 ⇒ 判据必须点名它,否则那条登记是装饰、E 形态整份在锁外。
|
|
3233
|
+
const evolveEntry = SECTION_SLICE_REGISTRY.find((entry) => entry.file === 'evolve.mjs');
|
|
3234
|
+
if (evolveEntry === undefined) {
|
|
3235
|
+
probeIssues.push('登记表缺 evolve.mjs 的段体切片登记(E 形态没有登记条目)');
|
|
3236
|
+
} else {
|
|
3237
|
+
const unregistered = sectionSingleSourceProblems({
|
|
3238
|
+
texts,
|
|
3239
|
+
registry: SECTION_SLICE_REGISTRY.filter((entry) => entry !== evolveEntry),
|
|
3240
|
+
});
|
|
3241
|
+
if (!unregistered.some((problem) => problem.includes('evolve.mjs')
|
|
3242
|
+
&& problem.includes(evolveEntry.symbol))) {
|
|
3243
|
+
probeIssues.push('E 形态未被形态面看见:删掉 evolve.mjs 的登记后判据仍不点名 '
|
|
3244
|
+
+ evolveEntry.symbol + '(' + JSON.stringify(unregistered) + ')');
|
|
3245
|
+
}
|
|
3246
|
+
}
|
|
3247
|
+
const lenientProblems = sectionSingleSourceProblems({
|
|
3248
|
+
texts: new Map(texts).set('context-init.mjs', revertedTexts.get('context-init.mjs') ?? ''),
|
|
3249
|
+
registry: [...SECTION_SLICE_REGISTRY, {
|
|
3250
|
+
file: 'context-init.mjs', symbol: 'sectionBody', reason: '(探针)给真实副本配一条登记',
|
|
3251
|
+
}],
|
|
3252
|
+
});
|
|
3253
|
+
if (!lenientProblems.some((problem) => problem.includes('context-init.mjs')
|
|
3254
|
+
&& problem.includes('第二份 sectionBody'))) {
|
|
3255
|
+
probeIssues.push('登记放行了真实副本(context-init 的私有 sectionBody 配登记后仍须判红): '
|
|
3256
|
+
+ JSON.stringify(lenientProblems));
|
|
3257
|
+
}
|
|
3258
|
+
if (sectionSingleSourceProblems({ texts }).length !== 0) probeIssues.push('还原后未复绿(判据受输入顺序影响)');
|
|
3259
|
+
assertTrue(probeIssues.length === 0, '段体单源锁反向构造失败: ' + probeIssues.join(' | '));
|
|
3260
|
+
}
|
|
3261
|
+
|
|
3262
|
+
// ⑥ 段体契约(单源的语义面,八格逐条对照):围栏内的标题与分隔线不结束段体;围栏外的同级标题
|
|
3263
|
+
// 与分隔线按 options 结束;结束标题的级别按 options;段缺席返回 null(与「段在场正文为空」
|
|
3264
|
+
// 可区分——调用方据此判「未校验」而不是「没写」)。
|
|
3265
|
+
{
|
|
3266
|
+
const sectionModule = await import('../lib/section-body.mjs');
|
|
3267
|
+
const contract = [
|
|
3268
|
+
['围栏内的二级标题不结束段体',
|
|
3269
|
+
'## S\n\n```md\n## 块内标题\n```\n\n正文\n\n## T\n', /^##\s*S/u, {},
|
|
3270
|
+
'\n```md\n## 块内标题\n```\n\n正文\n'],
|
|
3271
|
+
['波浪号围栏同口径',
|
|
3272
|
+
'## S\n\n~~~md\n## 块内标题\n~~~\n\n正文\n', /^##\s*S/u, {}, '\n~~~md\n## 块内标题\n~~~\n\n正文\n'],
|
|
3273
|
+
['围栏外的同级标题结束段体',
|
|
3274
|
+
'## S\n\n正文\n\n## T\n\n别段\n', /^##\s*S/u, {}, '\n正文\n'],
|
|
3275
|
+
['分隔线结束段体(默认)',
|
|
3276
|
+
'## S\n\n正文\n\n---\n\n尾\n', /^##\s*S/u, {}, '\n正文\n'],
|
|
3277
|
+
['分隔线不结束段体(endOnSeparator: false)',
|
|
3278
|
+
'## S\n\n正文\n\n---\n\n尾\n', /^##\s*S/u, { endOnSeparator: false },
|
|
3279
|
+
'\n正文\n\n---\n\n尾\n'],
|
|
3280
|
+
['三级标题不结束二级段体(level: 2)',
|
|
3281
|
+
'## S\n\n正文\n\n### 子\n\n子正文\n', /^##\s*S/u, {},
|
|
3282
|
+
'\n正文\n\n### 子\n\n子正文\n'],
|
|
3283
|
+
['同级标题结束三级段体(level: 3)',
|
|
3284
|
+
'### S\n\n正文\n\n### T\n\n别段\n', /^###\s*S/u, { level: 3 }, '\n正文\n'],
|
|
3285
|
+
['段缺席返回 null',
|
|
3286
|
+
'## 其他\n\n正文\n', /^##\s*S/u, {}, null],
|
|
3287
|
+
];
|
|
3288
|
+
for (const [label, docText, pattern, options, expected] of contract) {
|
|
3289
|
+
const actual = sectionModule.sectionBody(docText, pattern, options);
|
|
3290
|
+
assertTrue(actual === expected,
|
|
3291
|
+
'段体契约(' + label + '): 期望 ' + JSON.stringify(expected) + ',实际 ' + JSON.stringify(actual));
|
|
3292
|
+
}
|
|
3293
|
+
}
|
|
3294
|
+
|
|
3295
|
+
// ⑦ 配对键单源(P8):第三族(同文件跨任务)的「任务对键」只在 task-graph 表达一次;[P] 判据的
|
|
3296
|
+
// 补集(写面重叠 ⇒ 不该被要求标 [P])消费 task-graph 返回的判定,不自己再建一份键——第二份键
|
|
3297
|
+
// 的形态一旦漂移(换分隔符 / 换定序),两端键不再相等,补集静默失效(重叠的一对被当成「本可
|
|
3298
|
+
// 并行」)。反向构造三层:静态两格(换名字的第二份键 / 换分隔符的漂移形态都必红)+ 行为一格
|
|
3299
|
+
// (把补集判据改回自建键且形态漂移 ⇒ 重叠对被误报,补集断言必红)。
|
|
3300
|
+
{
|
|
3301
|
+
const texts = engineScriptTexts();
|
|
3302
|
+
const baseProblems = pairKeySingleSourceProblems({ texts });
|
|
3303
|
+
assertTrue(baseProblems.length === 0, '任务对键单源违规: ' + baseProblems.join(' | '));
|
|
3304
|
+
const waveRel = (engineDefinitionModule('parallelGapReview') ?? {}).file;
|
|
3305
|
+
assertTrue(typeof waveRel === 'string', '补集判据的定义面不唯一(反查失败): '
|
|
3306
|
+
+ JSON.stringify(engineDefinitionHits('parallelGapReview')));
|
|
3307
|
+
const waveText = texts.get(waveRel) ?? '';
|
|
3308
|
+
const secondKeyMutants = [
|
|
3309
|
+
['换名字的第二份键(历史上删掉的 gapPairKey 原形)',
|
|
3310
|
+
'\nfunction gapPairKey(left, right) {\n'
|
|
3311
|
+
+ ' return left < right ? left + "\\u0000" + right : right + "\\u0000" + left;\n}\n'],
|
|
3312
|
+
['换分隔符的漂移形态(判据不看分隔符取值)',
|
|
3313
|
+
'\nfunction probePairKey(a, b) {\n return a < b ? a + "|" + b : b + "|" + a;\n}\n'],
|
|
3314
|
+
];
|
|
3315
|
+
for (const [label, injected] of secondKeyMutants) {
|
|
3316
|
+
const reported = pairKeySingleSourceProblems({ texts: new Map(texts).set(waveRel, waveText + injected) });
|
|
3317
|
+
assertTrue(reported.some((problem) => problem.includes(waveRel)),
|
|
3318
|
+
'配对键单源锁看不见「' + label + '」: ' + JSON.stringify(reported));
|
|
3319
|
+
}
|
|
3320
|
+
// 行为面:同一对任务(同波同层、写同一个文件、都没标 parallel)在两支下对照——真实模块里补集
|
|
3321
|
+
// 判据把这对排除(写面重叠的一对不是「可并行」);变异体(补集判据改回自建键 + 分隔符漂移)
|
|
3322
|
+
// 里两端键对不上 ⇒ 同一对被误报成「可并行却未标 [P]」⇒ 补集断言变红。
|
|
3323
|
+
const overlapTask = (id) => '<task id="' + id + '" status="pending"><action>实现 ' + id
|
|
3324
|
+
+ '</action><write_files>src/shared.mjs</write_files><verify>node --check src/shared.mjs</verify>'
|
|
3325
|
+
+ '<depends_on></depends_on></task>\n';
|
|
3326
|
+
const overlapTaskContent = '# TASK\n\n## 波次划分\n\nWave 1: T01, T02\n\n## 任务清单\n\n'
|
|
3327
|
+
+ overlapTask('T01') + overlapTask('T02');
|
|
3328
|
+
const overlapBlocks = taskBlocks(overlapTaskContent);
|
|
3329
|
+
const waveModule = await import('../lib/wave-projection.mjs');
|
|
3330
|
+
const overlapWaves = waveModule.waveProjectionReview({
|
|
3331
|
+
taskContent: overlapTaskContent, blocks: overlapBlocks,
|
|
3332
|
+
});
|
|
3333
|
+
assertTrue(overlapWaves.waves instanceof Map && overlapWaves.waves.size === 2,
|
|
3334
|
+
'夹具前提失效:波次分组应可判(' + JSON.stringify([...((overlapWaves.waves) ?? [])]) + ')');
|
|
3335
|
+
const realGaps = waveModule.parallelGapReview({
|
|
3336
|
+
taskContent: overlapTaskContent, blocks: overlapBlocks, waves: overlapWaves.waves,
|
|
3337
|
+
});
|
|
3338
|
+
assertTrue(realGaps.gaps.length === 0,
|
|
3339
|
+
'补集判据失效:写面重叠(同一文件)的一对被要求标 [P](' + JSON.stringify(realGaps.gaps) + ')');
|
|
3340
|
+
// 写面未知 ≠ 写面不重叠:同波同层、其中一方**没有** write_files 的一对不在「可并行却未标 [P]」
|
|
3341
|
+
// 的判据面上——写面未知意味着「不能断言不重叠」,不是「不重叠」。候选判据若只按波次/层级/
|
|
3342
|
+
// status/修复族过滤,就会把「没写写面」读成「写面不重叠」,把这一对报成漏标 [P],恢复句还让
|
|
3343
|
+
// 作者补 depends_on(真正缺的是 write_files 字段)。判据面因此与 task-graph 的参与者判据对齐:
|
|
3344
|
+
// 没有写面的任务不参与「可并行」的断言。
|
|
3345
|
+
const unknownWriteTask = (id) => '<task id="' + id + '" status="pending"><action>实现 ' + id
|
|
3346
|
+
+ '</action><verify>node --check src/a.mjs</verify><depends_on></depends_on></task>\n';
|
|
3347
|
+
const unknownWriteContent = '# TASK\n\n## 波次划分\n\nWave 1: T01, T02\n\n## 任务清单\n\n'
|
|
3348
|
+
+ '<task id="T01" status="pending"><action>实现 T01</action><write_files>src/a.mjs</write_files>'
|
|
3349
|
+
+ '<verify>node --check src/a.mjs</verify><depends_on></depends_on></task>\n'
|
|
3350
|
+
+ unknownWriteTask('T02');
|
|
3351
|
+
const unknownWriteBlocks = taskBlocks(unknownWriteContent);
|
|
3352
|
+
const unknownWaves = waveModule.waveProjectionReview({
|
|
3353
|
+
taskContent: unknownWriteContent, blocks: unknownWriteBlocks,
|
|
3354
|
+
});
|
|
3355
|
+
assertTrue(unknownWaves.waves instanceof Map && unknownWaves.waves.size === 2,
|
|
3356
|
+
'夹具前提失效:写面未知那一格的波次分组应可判('
|
|
3357
|
+
+ JSON.stringify([...((unknownWaves.waves) ?? [])]) + ')');
|
|
3358
|
+
const unknownGaps = waveModule.parallelGapReview({
|
|
3359
|
+
taskContent: unknownWriteContent, blocks: unknownWriteBlocks, waves: unknownWaves.waves,
|
|
3360
|
+
});
|
|
3361
|
+
assertTrue(unknownGaps.gaps.length === 0,
|
|
3362
|
+
'写面未知被当成「写面不重叠」:没有 write_files 的任务被要求标 [P]'
|
|
3363
|
+
+ '(写面未知时不能断言可并行,恢复句还会指错方向): ' + JSON.stringify(unknownGaps.gaps));
|
|
3364
|
+
// 注释写不变式,不写过程:引擎注释里不留任务号与改动叙述——接手的人读到的是约束,不是某一轮
|
|
3365
|
+
// 改动的日记。受检面 = **引擎实现面**(与本节其余格子同一派生口径:入口 ∪ 静态可达模块 ∪
|
|
3366
|
+
// 非套件自持的 lib/ 模块),逐文件扫:判据只扫一个模块、注释却宣称「引擎注释」时,覆盖面只
|
|
3367
|
+
// 存在于注释里。判据是具名纯函数(见 commentNarrationHits),正向断言之外配三条探针:叙述
|
|
3368
|
+
// 混回去必须被检出、任务号混回去必须被检出(否则「零命中」可能是谓词根本认不出东西),而
|
|
3369
|
+
// 注释里贴 ISO 时间戳字面量(`2026-02-30T00:00:00Z` 的 `T00`)不得被读成任务号。
|
|
3370
|
+
const narrations = [];
|
|
3371
|
+
for (const [rel, text] of texts) {
|
|
3372
|
+
for (const hit of commentNarrationHits(text)) {
|
|
3373
|
+
narrations.push(rel + ':' + hit.lineNumber + ' [' + hit.kind + '] ' + hit.line);
|
|
3374
|
+
}
|
|
3375
|
+
}
|
|
3376
|
+
assertTrue(narrations.length === 0,
|
|
3377
|
+
'引擎注释里出现任务号 / 过程叙述(应写不变式): ' + JSON.stringify(narrations, null, 1));
|
|
3378
|
+
assertTrue(commentNarrationHits('// 本任务里已照形态加过一支。\n').length > 0,
|
|
3379
|
+
'注释叙述判据不具判别力:混入「本任务 / 已照形态」的注释没有被检出');
|
|
3380
|
+
assertTrue(commentNarrationHits('// 旧条目判定含 T11 的迁移保留形态。\n').length > 0,
|
|
3381
|
+
'注释叙述判据不具判别力:混入任务号的注释没有被检出');
|
|
3382
|
+
assertTrue(commentNarrationHits('// V8 对 `2026-02-30T00:00:00Z` 会静默滚到 3 月 2 日。\n').length === 0,
|
|
3383
|
+
'注释叙述判据把注释里的 ISO 时间戳字面量读成了任务号(假阳性)');
|
|
3384
|
+
// 变异体经 inlineModuleUrl 只在内存里编译(不落盘、不留残留)。
|
|
3385
|
+
// 变异 = 把「取单源判定」换回「两端各算一次键」,并只让**消费方**那一端漂移(生产方仍用
|
|
3386
|
+
// task-graph 的 NUL 形态):这正是第二份键实现存在的真实风险——改一端、漏一端,键就不再相等。
|
|
3387
|
+
// 两处锚各自只改一处代码位置(不搬动实参行),变异体因此语法完整、只把键的两份形态造出来。
|
|
3388
|
+
const decisionAnchor = ' const { isOverlappingPair } = collectCrossTaskConflicts({';
|
|
3389
|
+
const gapsAnchor = ' const gaps = [];';
|
|
3390
|
+
assertTrue(waveText.includes(decisionAnchor) && waveText.includes(gapsAnchor),
|
|
3391
|
+
'反向构造前提失效:' + waveRel + ' 未按单源形态取用第三族判定(锚已漂移)');
|
|
3392
|
+
const driftedText = waveText
|
|
3393
|
+
.replace(decisionAnchor, ' const probeResult = collectCrossTaskConflicts({')
|
|
3394
|
+
.replace(gapsAnchor, [
|
|
3395
|
+
" const producerPairKey = (a, b) => (a < b ? a + '\\u0000' + b : b + '\\u0000' + a);",
|
|
3396
|
+
" const consumerPairKey = (a, b) => (a < b ? a + '|' + b : b + '|' + a);",
|
|
3397
|
+
' const overlappingPairs = new Set(probeResult.conflicts.map((conflict)'
|
|
3398
|
+
+ ' => producerPairKey(conflict.a, conflict.b)));',
|
|
3399
|
+
' const isOverlappingPair = (a, b) => overlappingPairs.has(consumerPairKey(a, b));',
|
|
3400
|
+
' const gaps = [];',
|
|
3401
|
+
].join('\n'));
|
|
3402
|
+
assertTrue(driftedText !== waveText, '反向构造前提失效:变异未改变 ' + waveRel);
|
|
3403
|
+
const driftedModule = await import(inlineModuleUrl(driftedText, waveRel));
|
|
3404
|
+
const driftedGaps = driftedModule.parallelGapReview({
|
|
3405
|
+
taskContent: overlapTaskContent, blocks: overlapBlocks, waves: overlapWaves.waves,
|
|
3406
|
+
});
|
|
3407
|
+
assertTrue(driftedGaps.gaps.length > 0,
|
|
3408
|
+
'反向构造失效:补集判据改回「自建键 + 分隔符漂移」后,写面重叠的一对没有被误报——'
|
|
3409
|
+
+ '说明该断言对任务对键的形态不敏感(' + JSON.stringify(driftedGaps.gaps) + ')');
|
|
3410
|
+
}
|
|
3411
|
+
|
|
3412
|
+
// ⑧ 写面元素的取用面(task-graph 的路径解析 / plan 出口的伪并行启发式):写面判定在
|
|
3413
|
+
// lib/lessons-hits.mjs 已只有一份实现,两处消费方却各自拿着**大小写敏感**的标签正则——混合
|
|
3414
|
+
// 大小写时 7 字段门判「字段在场」、写面判定判「未知」,任务静默掉出判据面:写写重叠漏拦、
|
|
3415
|
+
// 同文件族漏判、伪并行启发式漏报,而同波同层的同文件对反被 [P] 判据当成「可并行」误报。
|
|
3416
|
+
// 三条面:结构锁(标签字面量只许在单源模块)+ 行为(混合大小写与全小写写法在四条判据上给出
|
|
3417
|
+
// 同一结论)+ 反向构造(把取用改回大小写敏感 ⇒ 锁与行为断言都必红)。
|
|
3418
|
+
{
|
|
3419
|
+
const faceTexts = engineScriptTexts();
|
|
3420
|
+
const faceSource = engineDefinitionModule('taskWriteFilesById');
|
|
3421
|
+
assertTrue(faceSource !== null,
|
|
3422
|
+
'写面元素提取(taskWriteFilesById)的定义面应恰一处(反查失败): '
|
|
3423
|
+
+ JSON.stringify(engineDefinitionHits('taskWriteFilesById')));
|
|
3424
|
+
const faceTagProblems = writeFaceSourceProblems({ texts: faceTexts, sourceRel: faceSource.file });
|
|
3425
|
+
assertTrue(faceTagProblems.length === 0, '写面元素标签单源违规: ' + faceTagProblems.join(' | '));
|
|
3426
|
+
const faceTakenProblems = singleSourceImportProblems({
|
|
3427
|
+
symbol: 'taskWriteFilesById', sourceRel: faceSource.file, texts: faceTexts,
|
|
3428
|
+
});
|
|
3429
|
+
assertTrue(faceTakenProblems.length === 0,
|
|
3430
|
+
'写面元素提取应只有一处实现且消费方都从它取用:\n' + faceTakenProblems.join('\n'));
|
|
3431
|
+
// 反向构造两格(互不覆盖):① 消费方保留取用、另带一份大小写敏感的标签正则——副本溜回来的
|
|
3432
|
+
// 真实形态,由形态锁点名;② 消费方摘掉单源取用而仍引用该符号,由取用面锁点名。
|
|
3433
|
+
const faceProbes = [];
|
|
3434
|
+
const carriedCopy = '\nconst probeWriteFilesFace = (block) => String(block).match(/<write_files>([\\s\\S]*?)<\\/write_files>/);\n';
|
|
3435
|
+
for (const rel of ['lib/task-graph.mjs', 'lib/guard-gates.mjs']) {
|
|
3436
|
+
const original = faceTexts.get(rel) ?? '';
|
|
3437
|
+
const carriedProblems = writeFaceSourceProblems({
|
|
3438
|
+
texts: new Map(faceTexts).set(rel, original + carriedCopy), sourceRel: faceSource.file,
|
|
3439
|
+
});
|
|
3440
|
+
if (!carriedProblems.some((problem) => problem.includes(rel))) {
|
|
3441
|
+
faceProbes.push(rel + ':副本(保留取用 + 自持标签正则)未被形态锁点名');
|
|
3442
|
+
}
|
|
3443
|
+
const droppedProblems = singleSourceImportProblems({
|
|
3444
|
+
symbol: 'taskWriteFilesById', sourceRel: faceSource.file,
|
|
3445
|
+
texts: new Map(faceTexts).set(rel, dropNamedImport(original, 'taskWriteFilesById')),
|
|
3446
|
+
});
|
|
3447
|
+
if (!droppedProblems.some((problem) => problem.includes(rel))) {
|
|
3448
|
+
faceProbes.push(rel + ':摘掉单源取用后未被取用面锁点名');
|
|
3449
|
+
}
|
|
3450
|
+
}
|
|
3451
|
+
assertTrue(faceProbes.length === 0, '写面单源锁反向构造失败: ' + faceProbes.join(' | '));
|
|
3452
|
+
|
|
3453
|
+
// 行为面:混合大小写写面与全小写写法必须给出同一结论(全小写格是夹具前提,混合格是断言)。
|
|
3454
|
+
// 写写强判(并行对)与同文件族(串行对)各一格——两族都由 task-graph 的路径解析供数。
|
|
3455
|
+
const faceBlock = (id, tag, attrs) => '<task id="' + id + '"' + attrs + ' status="pending">'
|
|
3456
|
+
+ '<action>实现 ' + id + '</action><' + tag + '>src/shared.mjs</' + tag + '>'
|
|
3457
|
+
+ '<verify>node --check src/shared.mjs</verify></task>\n';
|
|
3458
|
+
const facePlan = (tag, attrs) => '# TASK\n\n## 任务清单\n\n'
|
|
3459
|
+
+ faceBlock('W01', tag, attrs) + faceBlock('W02', tag, attrs);
|
|
3460
|
+
const faceRoot = (label) => path.join(dir, 'write-face-' + label);
|
|
3461
|
+
const conflictsIn = async (module, label, planText) => {
|
|
3462
|
+
writeFile(faceRoot(label), '.specs/' + CHANGE_ID + '/TASK.md', planText);
|
|
3463
|
+
return module.findParallelWriteConflicts(path.join(faceRoot(label), '.specs', CHANGE_ID));
|
|
3464
|
+
};
|
|
3465
|
+
const taskGraph = await import('../lib/task-graph.mjs');
|
|
3466
|
+
const lowerParallel = await conflictsIn(taskGraph, 'lower-parallel', facePlan('write_files', ' parallel="true"'));
|
|
3467
|
+
assertTrue(lowerParallel.writeConflicts.length === 1,
|
|
3468
|
+
'夹具前提失效:全小写写面的同文件并行对未被写写强判检出('
|
|
3469
|
+
+ JSON.stringify(lowerParallel.writeConflicts) + ')');
|
|
3470
|
+
const upperParallel = await conflictsIn(taskGraph, 'upper-parallel', facePlan('WRITE_FILES', ' parallel="true"'));
|
|
3471
|
+
assertTrue(upperParallel.writeConflicts.length === 1,
|
|
3472
|
+
'混合大小写写面的同文件并行对逃过写写强判(元素名大小写无关,同一份写面应判重叠): '
|
|
3473
|
+
+ JSON.stringify(upperParallel.writeConflicts));
|
|
3474
|
+
const lowerSerial = await conflictsIn(taskGraph, 'lower-serial', facePlan('write_files', ''));
|
|
3475
|
+
assertTrue(lowerSerial.crossTaskConflicts.length === 1,
|
|
3476
|
+
'夹具前提失效:全小写写面的同文件串行对未被同文件族检出('
|
|
3477
|
+
+ JSON.stringify(lowerSerial.crossTaskConflicts) + ')');
|
|
3478
|
+
const upperSerial = await conflictsIn(taskGraph, 'upper-serial', facePlan('WRITE_FILES', ''));
|
|
3479
|
+
assertTrue(upperSerial.crossTaskConflicts.length === 1,
|
|
3480
|
+
'混合大小写写面的同文件串行对逃过同文件族(同文件且无依赖路径,应判冲突): '
|
|
3481
|
+
+ JSON.stringify(upperSerial.crossTaskConflicts));
|
|
3482
|
+
|
|
3483
|
+
// [P] 判据:写面重叠的一对不该被要求标 [P](写面未知 ≠ 写面不重叠),写面互不重叠的一对必须
|
|
3484
|
+
// 照常点名——后半格钉住「不是把混合写法整片排除出判据面」。
|
|
3485
|
+
const waveFace = await import('../lib/wave-projection.mjs');
|
|
3486
|
+
const gapsFor = (tag, leftWrite, rightWrite) => {
|
|
3487
|
+
const block = (id, writePath) => '<task id="' + id + '" status="pending"><action>实现 ' + id
|
|
3488
|
+
+ '</action><' + tag + '>' + writePath + '</' + tag + '><verify>node --check ' + writePath
|
|
3489
|
+
+ '</verify><depends_on></depends_on></task>\n';
|
|
3490
|
+
const content = '# TASK\n\n## 波次划分\n\nWave 1: G01, G02\n\n## 任务清单\n\n'
|
|
3491
|
+
+ block('G01', leftWrite) + block('G02', rightWrite);
|
|
3492
|
+
const blocks = taskBlocks(content);
|
|
3493
|
+
const review = waveFace.waveProjectionReview({ taskContent: content, blocks });
|
|
3494
|
+
return waveFace.parallelGapReview({ taskContent: content, blocks, waves: review.waves });
|
|
3495
|
+
};
|
|
3496
|
+
assertTrue(gapsFor('write_files', 'src/shared.mjs', 'src/shared.mjs').gaps.length === 0,
|
|
3497
|
+
'夹具前提失效:全小写写面重叠的一对被 [P] 判据要求标 [P]');
|
|
3498
|
+
const upperOverlapGaps = gapsFor('WRITE_FILES', 'src/shared.mjs', 'src/shared.mjs');
|
|
3499
|
+
assertTrue(upperOverlapGaps.gaps.length === 0,
|
|
3500
|
+
'混合大小写写面重叠的一对被 [P] 判据误报为「可并行却未标 [P]」——写面未知被当成写面不重叠: '
|
|
3501
|
+
+ JSON.stringify(upperOverlapGaps.gaps));
|
|
3502
|
+
const upperDistinctGaps = gapsFor('WRITE_FILES', 'src/a.mjs', 'src/b.mjs');
|
|
3503
|
+
assertTrue(upperDistinctGaps.gaps.length === 1,
|
|
3504
|
+
'混合大小写写面互不重叠的一对未被 [P] 判据点名——判据应正常参与,不是把混合写法整片排除: '
|
|
3505
|
+
+ JSON.stringify(upperDistinctGaps.gaps));
|
|
3506
|
+
|
|
3507
|
+
// 伪并行启发式:仅写测试产物的并行任务必须照样进集合(掉出去 = 告警静默消失),混有生产文件的
|
|
3508
|
+
// 并行任务不进集合(不是把混合写法整片标成伪并行)。
|
|
3509
|
+
const guardGates = await import('../lib/guard-gates.mjs');
|
|
3510
|
+
const testOnlyFor = (tag) => {
|
|
3511
|
+
const content = '# TASK\n\n## 任务清单\n\n'
|
|
3512
|
+
+ '<task id="P-MIX" parallel="true" status="pending"><action>实现 P-MIX</action><' + tag
|
|
3513
|
+
+ '>tests/test_mix.mjs</' + tag + '><verify>node --check tests/test_mix.mjs</verify></task>\n'
|
|
3514
|
+
+ '<task id="P-PROD" parallel="true" status="pending"><action>实现 P-PROD</action><' + tag
|
|
3515
|
+
+ '>src/mix.mjs\ntests/test_mix2.mjs</' + tag + '><verify>node --check src/mix.mjs</verify></task>\n';
|
|
3516
|
+
return guardGates.collectTestOnlyParallelIds({ taskContent: content, blocks: taskBlocks(content) });
|
|
3517
|
+
};
|
|
3518
|
+
assertTrue(JSON.stringify(testOnlyFor('write_files')) === JSON.stringify(['P-MIX']),
|
|
3519
|
+
'夹具前提失效:全小写写面的纯测试面并行任务未进伪并行集合('
|
|
3520
|
+
+ JSON.stringify(testOnlyFor('write_files')) + ')');
|
|
3521
|
+
assertTrue(JSON.stringify(testOnlyFor('WRITE_FILES')) === JSON.stringify(['P-MIX']),
|
|
3522
|
+
'混合大小写写面的纯测试面并行任务掉出伪并行集合(元素名大小写无关,应照样告警): '
|
|
3523
|
+
+ JSON.stringify(testOnlyFor('WRITE_FILES')));
|
|
3524
|
+
|
|
3525
|
+
// 行为面反向构造:把 task-graph 的写面取用改回大小写敏感的自持正则 ⇒ 同一份混合大小写夹具在
|
|
3526
|
+
// 变异体上重新「看不见重叠」,上面那两条行为断言因此确实对取用面敏感(不是恒绿)。
|
|
3527
|
+
const taskGraphRel = engineDefinitionModule('findParallelWriteConflicts')?.file;
|
|
3528
|
+
assertTrue(typeof taskGraphRel === 'string',
|
|
3529
|
+
'写写强判的定义面不唯一(反查失败): '
|
|
3530
|
+
+ JSON.stringify(engineDefinitionHits('findParallelWriteConflicts')));
|
|
3531
|
+
const taskGraphText = faceTexts.get(taskGraphRel) ?? '';
|
|
3532
|
+
const faceAnchor = ' const writeFaces = taskWriteFilesById(text);';
|
|
3533
|
+
assertTrue(taskGraphText.includes(faceAnchor),
|
|
3534
|
+
'反向构造前提失效:' + taskGraphRel + ' 未按单源形态取用写面元素(锚已漂移)');
|
|
3535
|
+
const driftedFaceText = taskGraphText.replace(faceAnchor, [
|
|
3536
|
+
' const writeFaces = new Map();',
|
|
3537
|
+
' for (const probeBlock of allBlocks) {',
|
|
3538
|
+
' const probeAttrs = taskOpeningAttrs(probeBlock);',
|
|
3539
|
+
' const probeMatch = probeBlock.match(/<write_files>([\\s\\S]*?)<\\/write_files>/);',
|
|
3540
|
+
' if (probeAttrs && probeAttrs.id && probeMatch) writeFaces.set(probeAttrs.id, probeMatch[1]);',
|
|
3541
|
+
' }',
|
|
3542
|
+
].join('\n'));
|
|
3543
|
+
assertTrue(driftedFaceText !== taskGraphText, '反向构造前提失效:变异未改变 ' + taskGraphRel);
|
|
3544
|
+
const driftedFaceModule = await import(inlineModuleUrl(driftedFaceText, taskGraphRel));
|
|
3545
|
+
const driftedUpper = await conflictsIn(driftedFaceModule, 'upper-parallel-drift', facePlan('WRITE_FILES', ' parallel="true"'));
|
|
3546
|
+
assertTrue(driftedUpper.writeConflicts.length === 0,
|
|
3547
|
+
'反向构造失效:写面取用改回大小写敏感后,混合大小写夹具仍被检出重叠——'
|
|
3548
|
+
+ '该断言对取用面不敏感(' + JSON.stringify(driftedUpper.writeConflicts) + ')');
|
|
3549
|
+
}
|
|
3550
|
+
// ⑧ 运行根单源 + 隔离(行为面在前、结构锁在后):「这次调用把哪个目录当项目根」曾被两处各自
|
|
3551
|
+
// 回答——守卫族读 FLOW_COMET_RUN_ROOT,状态命令族直接用进程 cwd。用变量把实验指向临时目录
|
|
3552
|
+
// 时,状态命令仍在 cwd 仓库里建分支、把正在跑的 change 的 state 覆盖成新 change 的初始状态
|
|
3553
|
+
// (数据覆盖,靠备份才恢复)。本格先真跑命令证明「设了变量就只作用于那个根」,再用单源锁
|
|
3554
|
+
// 钉住「解析只许有一处实现」。
|
|
3555
|
+
{
|
|
3556
|
+
const rootsDir = path.join(dir, 'run-root-isolation');
|
|
3557
|
+
const cwdRepo = path.join(rootsDir, 'cwd-repo');
|
|
3558
|
+
const envRoot = path.join(rootsDir, 'env-root');
|
|
3559
|
+
const asRes = (res) => ({ status: res.status ?? 1, output: String(res.stdout ?? '') + String(res.stderr ?? '') });
|
|
3560
|
+
const gitOut = (repo, ...args) => {
|
|
3561
|
+
const res = spawnSync('git', args, { cwd: repo, encoding: 'utf8', timeout: 60000 });
|
|
3562
|
+
if ((res.status ?? 1) !== 0) throw new Error('夹具 git ' + args.join(' ') + ' 失败: ' + String(res.stderr ?? ''));
|
|
3563
|
+
return String(res.stdout ?? '').trim();
|
|
3564
|
+
};
|
|
3565
|
+
const stateFileAt = (root) => path.join(root, '.flow-comet', 'flow-comet-state.json');
|
|
3566
|
+
const stateBytesAt = (root) => fs.readFileSync(stateFileAt(root));
|
|
3567
|
+
const stateAt = (root) => JSON.parse(fs.readFileSync(stateFileAt(root), 'utf8'));
|
|
3568
|
+
// 两个真实 git 仓库:cwd 侧带活跃 change(state + 工件 + 声明标记),变量侧是空仓库。协议副本各放
|
|
3569
|
+
// 一份——受保护读取要求协议位于所属运行根内,两侧各有一份才能分别作真实命令的输入。
|
|
3570
|
+
for (const repo of [cwdRepo, envRoot]) {
|
|
3571
|
+
fs.mkdirSync(path.join(repo, 'reference'), { recursive: true });
|
|
3572
|
+
fs.copyFileSync(scenarioProtocolPath(dir), path.join(repo, 'reference', 'workflow-protocol.json'));
|
|
3573
|
+
gitOut(repo, 'init', '-q');
|
|
3574
|
+
gitOut(repo, '-c', 'user.name=fixture', '-c', 'user.email=fixture@example.com',
|
|
3575
|
+
'commit', '--allow-empty', '-m', 'init');
|
|
3576
|
+
}
|
|
3577
|
+
writeState(cwdRepo, {
|
|
3578
|
+
...baseState('open'),
|
|
3579
|
+
activeChange: 'live-change',
|
|
3580
|
+
newChange: true,
|
|
3581
|
+
status: 'running',
|
|
3582
|
+
enteredNodes: ['open'],
|
|
3583
|
+
evidence: {
|
|
3584
|
+
open: { summary: 'live' },
|
|
3585
|
+
'subagent-execute': {
|
|
3586
|
+
handoffRequests: { 'LIVE-01': { description: 'live', requestedAt: '2026-08-01T00:00:00.000Z' } },
|
|
3587
|
+
},
|
|
3588
|
+
},
|
|
3589
|
+
});
|
|
3590
|
+
writeFile(cwdRepo, '.specs/live-change/CHANGE.md', '# CHANGE\n\n## Why(为什么做)\nlive\n');
|
|
3591
|
+
writeNodeDeclarationMarkers(cwdRepo, 'open', { changeId: 'live-change' });
|
|
3592
|
+
const cwdStateBefore = stateBytesAt(cwdRepo);
|
|
3593
|
+
const cwdHeadBefore = gitOut(cwdRepo, 'rev-parse', 'HEAD');
|
|
3594
|
+
const cwdBranchBefore = gitOut(cwdRepo, 'rev-parse', '--abbrev-ref', 'HEAD');
|
|
3595
|
+
// 状态命令一律以 cwd = 仓库、运行根 = 变量指向的那个仓库发起(真实隔离场景的形态)。
|
|
3596
|
+
const inEnvRoot = (script, args) => asRes(spawnSync(process.execPath, [script, ...args], {
|
|
3597
|
+
cwd: cwdRepo,
|
|
3598
|
+
env: {
|
|
3599
|
+
...process.env,
|
|
3600
|
+
FLOW_COMET_RUN_ROOT: envRoot,
|
|
3601
|
+
// 协议取运行根相对形态:同一个调用里,命令字面不必随根变化——变的是「哪一个是根」。
|
|
3602
|
+
FLOW_COMET_PROTOCOL: 'reference/workflow-protocol.json',
|
|
3603
|
+
},
|
|
3604
|
+
encoding: 'utf8',
|
|
3605
|
+
timeout: 60000,
|
|
3606
|
+
}));
|
|
3607
|
+
|
|
3608
|
+
// ① init:state 落点与分支判定/创建都跟运行根走
|
|
3609
|
+
const initIsolated = inEnvRoot(STATE, ['init', 'fresh-change']);
|
|
3610
|
+
assertExit(initIsolated, 0);
|
|
3611
|
+
assertOut(initIsolated, 'Initialized: fresh-change');
|
|
3612
|
+
assertTrue(fs.existsSync(stateFileAt(envRoot)),
|
|
3613
|
+
'设置 FLOW_COMET_RUN_ROOT 后 init 未把 state 写到该根(写到了进程 cwd)——临时实验会覆盖真实 change 的 state');
|
|
3614
|
+
assertTrue(stateAt(envRoot).activeChange === 'fresh-change',
|
|
3615
|
+
'运行根下的 state 未记录新 change: ' + JSON.stringify(stateAt(envRoot).activeChange));
|
|
3616
|
+
assertTrue(fs.existsSync(path.join(envRoot, '.specs', 'fresh-change')), 'init 未在运行根下建 change 目录');
|
|
3617
|
+
assertTrue(gitOut(envRoot, 'rev-parse', '--abbrev-ref', 'HEAD') === 'change/fresh-change',
|
|
3618
|
+
'分支未按运行根创建/切换(HEAD = ' + gitOut(envRoot, 'rev-parse', '--abbrev-ref', 'HEAD') + ')');
|
|
3619
|
+
|
|
3620
|
+
// ② cwd 侧:state 字节、HEAD、当前分支零改动;也不得在 cwd 仓库新建同名分支
|
|
3621
|
+
assertTrue(stateBytesAt(cwdRepo).equals(cwdStateBefore),
|
|
3622
|
+
'cwd 仓库的 state 字节被改写——设置运行根后状态命令仍写到了进程 cwd');
|
|
3623
|
+
assertTrue(gitOut(cwdRepo, 'rev-parse', 'HEAD') === cwdHeadBefore, 'cwd 仓库的 HEAD 被移动');
|
|
3624
|
+
assertTrue(gitOut(cwdRepo, 'rev-parse', '--abbrev-ref', 'HEAD') === cwdBranchBefore,
|
|
3625
|
+
'cwd 仓库的当前分支被切换: ' + gitOut(cwdRepo, 'rev-parse', '--abbrev-ref', 'HEAD'));
|
|
3626
|
+
assertTrue(gitOut(cwdRepo, 'branch', '--list', 'change/fresh-change') === '',
|
|
3627
|
+
'cwd 仓库里出现了本该建在运行根的分支 change/fresh-change');
|
|
3628
|
+
|
|
3629
|
+
// ③ status / record:读写的都是运行根那一个 state
|
|
3630
|
+
const statusIsolated = inEnvRoot(STATE, ['status']);
|
|
3631
|
+
assertTrue(statusIsolated.status === 0, 'status 应成功: ' + statusIsolated.output);
|
|
3632
|
+
assertOut(statusIsolated, '"change": "fresh-change"');
|
|
3633
|
+
assertNotOut(statusIsolated, 'live-change');
|
|
3634
|
+
assertTrue(stateBytesAt(cwdRepo).equals(cwdStateBefore), 'status 改写了 cwd 仓库的 state');
|
|
3635
|
+
// record 目标取零模板节点:声明门会按节点模板清单核对标记,本格不引入模板面——只要标记在场,
|
|
3636
|
+
// 记录结果就只取决于「读到的是哪一个 state」。
|
|
3637
|
+
writeNodeDeclarationMarkers(envRoot, 'verify', { changeId: 'fresh-change' });
|
|
3638
|
+
const recordIsolated = inEnvRoot(STATE, ['record', 'verify', '{"summary":"run-root record"}']);
|
|
3639
|
+
assertExit(recordIsolated, 0);
|
|
3640
|
+
assertOut(recordIsolated, 'EVIDENCE: verify');
|
|
3641
|
+
assertTrue(stateAt(envRoot).evidence?.verify?.summary === 'run-root record',
|
|
3642
|
+
'record 未写入运行根的 state: ' + JSON.stringify(stateAt(envRoot).evidence));
|
|
3643
|
+
assertTrue(stateBytesAt(cwdRepo).equals(cwdStateBefore), 'record 改写了 cwd 仓库的 state');
|
|
3644
|
+
|
|
3645
|
+
// ④ 委托入口(第三个取用面):status 只读,用它证明它也认同一处解析——两侧 state 各带一个可
|
|
3646
|
+
// 区分的活跃 change 与委托记录,读错根会立刻显形。
|
|
3647
|
+
const handoffIsolated = inEnvRoot(HANDOFF, ['status']);
|
|
3648
|
+
assertTrue(handoffIsolated.status === 0, 'handoff status 应成功: ' + handoffIsolated.output);
|
|
3649
|
+
assertOut(handoffIsolated, '"activeChange": "fresh-change"');
|
|
3650
|
+
assertNotOut(handoffIsolated, 'LIVE-01');
|
|
3651
|
+
|
|
3652
|
+
// ⑤ 反向构造(同一夹具、去掉变量):解析退回进程 cwd —— 上面「cwd 零改动」三条断言正是会红的
|
|
3653
|
+
// 那三条;这里直接证明夹具确实能把 cwd 侧改写照出来(不是恒绿)。
|
|
3654
|
+
const envRootStateBefore = stateBytesAt(envRoot);
|
|
3655
|
+
const noRootInit = asRes(spawnSync(process.execPath, [STATE, 'init', 'cwd-change'], {
|
|
3656
|
+
cwd: cwdRepo,
|
|
3657
|
+
env: {
|
|
3658
|
+
...process.env,
|
|
3659
|
+
FLOW_COMET_RUN_ROOT: '',
|
|
3660
|
+
FLOW_COMET_PROTOCOL: 'reference/workflow-protocol.json',
|
|
3661
|
+
},
|
|
3662
|
+
encoding: 'utf8',
|
|
3663
|
+
timeout: 60000,
|
|
3664
|
+
}));
|
|
3665
|
+
assertExit(noRootInit, 0);
|
|
3666
|
+
assertTrue(stateAt(cwdRepo).activeChange === 'cwd-change',
|
|
3667
|
+
'反向构造前提失效:无变量时 init 未写回 cwd 仓库,上面「cwd 零改动」断言无判别力');
|
|
3668
|
+
assertTrue(gitOut(cwdRepo, 'rev-parse', '--abbrev-ref', 'HEAD') === 'change/cwd-change',
|
|
3669
|
+
'反向构造前提失效:无变量时未在 cwd 仓库建分支');
|
|
3670
|
+
assertTrue(stateBytesAt(envRoot).equals(envRootStateBefore), '无变量的那次 init 改写了运行根的 state');
|
|
3671
|
+
|
|
3672
|
+
// ⑥ 单源结构锁:运行根解析只许一处实现,状态命令族两个入口与守卫族运行根模块一律具名取用。
|
|
3673
|
+
// 反向构造:摘 import ⇒ 「未从」;注入第二份定义 ⇒ 被点名;原样 ⇒ 复绿。
|
|
3674
|
+
const runRootSymbol = 'resolveRunRoot';
|
|
3675
|
+
const runRootModule = engineDefinitionModule(runRootSymbol);
|
|
3676
|
+
assertTrue(runRootModule !== null,
|
|
3677
|
+
'运行根解析的定义面应恰一处: ' + JSON.stringify(engineDefinitionHits(runRootSymbol)));
|
|
3678
|
+
const runRootTexts = engineScriptTexts();
|
|
3679
|
+
const runRootProblems = singleSourceImportProblems({
|
|
3680
|
+
symbol: runRootSymbol, sourceRel: runRootModule.file, texts: runRootTexts,
|
|
3681
|
+
});
|
|
3682
|
+
assertTrue(runRootProblems.length === 0, '运行根单源违规: ' + runRootProblems.join(' | '));
|
|
3683
|
+
const runRootProbes = [];
|
|
3684
|
+
for (const consumerRel of ['workflow-state.mjs', 'workflow-handoff.mjs', 'lib/guard-state-io.mjs']) {
|
|
3685
|
+
const consumerText = runRootTexts.get(consumerRel) ?? '';
|
|
3686
|
+
if (!new RegExp('\\b' + runRootSymbol + '\\b', 'u').test(engineCodeText(consumerText))) {
|
|
3687
|
+
runRootProbes.push(consumerRel + ' 不再取用单一来源的运行根解析');
|
|
3688
|
+
continue;
|
|
3689
|
+
}
|
|
3690
|
+
const droppedText = dropNamedImport(consumerText, runRootSymbol);
|
|
3691
|
+
if (droppedText === consumerText) {
|
|
3692
|
+
runRootProbes.push(consumerRel + ' 的 import 摘不动(反向构造会退化为前提失效)');
|
|
3693
|
+
continue;
|
|
3694
|
+
}
|
|
3695
|
+
const droppedProblems = singleSourceImportProblems({
|
|
3696
|
+
symbol: runRootSymbol, sourceRel: runRootModule.file,
|
|
3697
|
+
texts: new Map(runRootTexts).set(consumerRel, droppedText),
|
|
3698
|
+
});
|
|
3699
|
+
if (!droppedProblems.some((problem) => problem.includes(consumerRel) && problem.includes('未从'))) {
|
|
3700
|
+
runRootProbes.push(consumerRel + ' 摘掉单源取用后未被取用面锁点名');
|
|
3701
|
+
}
|
|
3702
|
+
}
|
|
3703
|
+
const injectedProblems = singleSourceImportProblems({
|
|
3704
|
+
symbol: runRootSymbol, sourceRel: runRootModule.file,
|
|
3705
|
+
texts: new Map(runRootTexts).set('lib/probe-run-root.mjs',
|
|
3706
|
+
'export function ' + runRootSymbol + '() { return process.cwd(); }\n'),
|
|
3707
|
+
});
|
|
3708
|
+
if (!injectedProblems.some((problem) => problem.includes('lib/probe-run-root.mjs') && problem.includes('自带第二份'))) {
|
|
3709
|
+
runRootProbes.push('第二份实现注入后未被单源锁点名(锁对新增实现面没有判别力)');
|
|
3710
|
+
}
|
|
3711
|
+
assertTrue(runRootProbes.length === 0, '运行根单源锁反向构造失败: ' + runRootProbes.join(' | '));
|
|
3712
|
+
}
|
|
1774
3713
|
},
|
|
1775
3714
|
},
|
|
1776
3715
|
|
|
@@ -1860,6 +3799,7 @@ export const ENTRIES = [
|
|
|
1860
3799
|
return next;
|
|
1861
3800
|
};
|
|
1862
3801
|
writeState(dir, openState());
|
|
3802
|
+
writeNodeDeclarationMarkers(dir, 'open');
|
|
1863
3803
|
const warned = exitNode(dir, 'open');
|
|
1864
3804
|
assertExit(warned, 0);
|
|
1865
3805
|
assertOut(warned, 'TEMPLATE-REGISTRY WARN');
|
|
@@ -1969,11 +3909,15 @@ export const ENTRIES = [
|
|
|
1969
3909
|
// TA-24 · 公开面不再说假话(AC-24)——5 对双语公开文本的覆盖表述与实际门禁范围一致:不再有
|
|
1970
3910
|
// 「完全继承 / 段名在运行时派生」这类 overclaim;机制册的「哪些节点查段名」表覆盖全部出口;
|
|
1971
3911
|
// 故障排查给出两阶段报错指引;工件保真条点明本仓增量段。
|
|
3912
|
+
//
|
|
3913
|
+
// 缺席的**两种读法**(判据面形态先判,再判内容):本检出带公开面(docs/、CONTRIBUTING.md 或
|
|
3914
|
+
// .github/ 任一在场)时,该面任何一份文档缺席都是判据失效——「两份机制册都被删」= 公开面机制
|
|
3915
|
+
// 文档不在检出面,判红,不能只落一条 SKIP;只有整份载体俱缺(安装副本只带技能树、npm 包按 files
|
|
3916
|
+
// 白名单不含 docs/ 与 CONTRIBUTING / .github)才是合法的「本检出没有这一面」,此时输出可见 SKIP
|
|
3917
|
+
// 并明确写「本次未校验」,仍不算通过。
|
|
1972
3918
|
{
|
|
1973
|
-
name: 'TA-24 公开面口径:5 对双语去除 overclaim
|
|
1974
|
-
run: () => {
|
|
1975
|
-
const docs = new Map();
|
|
1976
|
-
const missingFaces = [];
|
|
3919
|
+
name: 'TA-24 公开面口径:5 对双语去除 overclaim,机制表覆盖全出口,缺席即红(整面缺席才 SKIP)',
|
|
3920
|
+
run: async (dir) => {
|
|
1977
3921
|
const pairs = [
|
|
1978
3922
|
['README.md', 'README-zh.md'],
|
|
1979
3923
|
['CONTRIBUTING.md', 'CONTRIBUTING-zh.md'],
|
|
@@ -1981,20 +3925,35 @@ export const ENTRIES = [
|
|
|
1981
3925
|
['docs/MECHANISM.md', 'docs/MECHANISM-zh.md'],
|
|
1982
3926
|
['docs/TROUBLESHOOTING.md', 'docs/TROUBLESHOOTING-zh.md'],
|
|
1983
3927
|
];
|
|
3928
|
+
// 形态判据先于内容判据:公开面载体整份缺席 = 本检出不含公开文档(安装副本 / npm 包形态),
|
|
3929
|
+
// 整面输出一条可见 SKIP——不是「已校验」,也不把合法形态判红。判据本体走 lib 的
|
|
3930
|
+
// publicFaceDocsAbsent(与底部自检、场景 105 同一实现):本场景不再自持第二套(曾按
|
|
3931
|
+
// docs/authority-map.json 在不在分流);单看 docs/ 也不够——它被裁掉而 CONTRIBUTING.md /
|
|
3932
|
+
// .github/ 还在时,这五对文档的判据会整块变成 SKIP。
|
|
3933
|
+
if (publicFaceDocsAbsent(REPO_ROOT)) {
|
|
3934
|
+
console.log('SKIP: TA-24 的公开面口径判据(此形态不含公开文档:docs/、CONTRIBUTING.md 与 .github/'
|
|
3935
|
+
+ ' 都不在本检出)——本次检出未校验 5 对双语公开文档的 overclaim / 机制表 / 排查指引口径,'
|
|
3936
|
+
+ '请在权威源检出重跑本套件(未验证 ≠ 通过)');
|
|
3937
|
+
return;
|
|
3938
|
+
}
|
|
3939
|
+
// 形态分派自身的常驻判别力锚:临时根上驱动同一判定,分派对错不再只能靠「在包形态里整跑一次
|
|
3940
|
+
// 套件」才知道。夹具的「完整形态」从本检出的公开面真迹复制,故只在声明了公开面的检出上跑。
|
|
3941
|
+
await assertPublicFaceSelfCheckShapes(dir);
|
|
3942
|
+
// 判据面完整在册(缺席用 null 占位而不是从集合里删掉):缺席由下面的缺席判据逐份点名,
|
|
3943
|
+
// 「少了哪份文件」因此是**判据事实**,不是可以静默缩小的受检面。
|
|
3944
|
+
const docs = new Map();
|
|
1984
3945
|
for (const [en, zh] of pairs) {
|
|
1985
|
-
const
|
|
1986
|
-
if (missing.length > 0) {
|
|
1987
|
-
missingFaces.push(...missing);
|
|
1988
|
-
continue;
|
|
1989
|
-
}
|
|
1990
|
-
docs.set(en, repoFileText(en));
|
|
1991
|
-
docs.set(zh, repoFileText(zh));
|
|
3946
|
+
for (const rel of [en, zh]) docs.set(rel, repoFileExists(rel) ? repoFileText(rel) : null);
|
|
1992
3947
|
}
|
|
1993
|
-
|
|
1994
|
-
//
|
|
1995
|
-
|
|
1996
|
-
|
|
1997
|
-
|
|
3948
|
+
const problems = publicFaceAbsenceProblems(docs);
|
|
3949
|
+
// 缺席判据的变异探针(同一实现、纯内存):抽掉两份机制册 ⇒ 必须报「不在检出面」。修复前
|
|
3950
|
+
// 「两份机制册都被删」只落一条 SKIP(缺席被读成未校验),公开面机制文档整份消失而套件仍绿。
|
|
3951
|
+
// 缺失在判据面里表现为「键在场、文本为 null」(与真实路径同一形态:文件不在 ≠ 键被删)。
|
|
3952
|
+
const shrunk = new Map(docs);
|
|
3953
|
+
for (const rel of ['docs/MECHANISM.md', 'docs/MECHANISM-zh.md']) shrunk.set(rel, null);
|
|
3954
|
+
const absenceProbe = publicFaceAbsenceProblems(shrunk);
|
|
3955
|
+
if (absenceProbe.length === 0 || !absenceProbe[0].includes('docs/MECHANISM.md')) {
|
|
3956
|
+
problems.push('反向构造判别力缺失(抽掉两份机制册未被判「不在检出面」)');
|
|
1998
3957
|
}
|
|
1999
3958
|
const rules = [
|
|
2000
3959
|
{ rel: 'README-zh.md', label: '去 overclaim(继承表述)', exclude: ['完全继承'] },
|
|
@@ -2004,27 +3963,43 @@ export const ENTRIES = [
|
|
|
2004
3963
|
{ rel: 'docs/TROUBLESHOOTING-zh.md', label: '两阶段报错指引', include: ['两阶段'] },
|
|
2005
3964
|
{ rel: 'docs/MECHANISM-zh.md', label: '机制表覆盖全出口', include: ['段名是否符合模板'] },
|
|
2006
3965
|
];
|
|
2007
|
-
//
|
|
2008
|
-
|
|
2009
|
-
|
|
2010
|
-
//
|
|
2011
|
-
|
|
2012
|
-
|
|
2013
|
-
|
|
2014
|
-
|
|
2015
|
-
|
|
2016
|
-
|
|
2017
|
-
const
|
|
2018
|
-
|
|
2019
|
-
|
|
2020
|
-
|
|
3966
|
+
// 内容判据跑全表(不再按「本检出有没有这份文件」缩小):缺席的文档在规则面里报「不在判据面内」,
|
|
3967
|
+
// 缺席本身已由上方缺席判据逐份点名——受检面不因文件消失而静默变窄。
|
|
3968
|
+
problems.push(...textRuleProblems(docs, rules));
|
|
3969
|
+
// 机制行的出口清单覆盖:行按结构定位(机制表里适用面最宽的那行),8 个出口一个都不能少。
|
|
3970
|
+
problems.push(...mechanismRowProblems(docs));
|
|
3971
|
+
// 机制行判据自己的变异探针(同一函数驱动)——词形定位的失效形态与「判据恒真」各配一条:
|
|
3972
|
+
// 正锚:把「含『段名』且提到 plan」的段落插到机制表之前,结构定位不得被抢位;
|
|
3973
|
+
// 反向:从机制行抽掉一个出口 ⇒ 必须报「未覆盖出口」。
|
|
3974
|
+
const zhMechanism = docs.get('docs/MECHANISM-zh.md');
|
|
3975
|
+
if (typeof zhMechanism === 'string') {
|
|
3976
|
+
const hijack = '结构预检只跑结构那一半:缺 H2 段只按类别报计数,具体段名留到节点收尾的完整 `exit`;'
|
|
3977
|
+
+ '`plan` 节点的任务块另查七字段。';
|
|
3978
|
+
const hijacked = hijack + '\n' + zhMechanism;
|
|
3979
|
+
// 正锚比对「定位到哪一行」,不比对报文——否则真实断言先红时探针会被遮蔽,看不出判别力。
|
|
3980
|
+
const beforeRow = findMechanismRow(zhMechanism);
|
|
3981
|
+
const afterRow = findMechanismRow(hijacked);
|
|
3982
|
+
if (legacyMechanismLine(hijacked) === legacyMechanismLine(zhMechanism)) {
|
|
3983
|
+
problems.push('正锚构造前提失效(段名段落未被词形判据抢位)');
|
|
3984
|
+
} else if (beforeRow === null || afterRow === null || afterRow.index !== beforeRow.index + 1) {
|
|
3985
|
+
problems.push('机制行定位被抢位:插入的「段名 + plan」段落改写了定位结果');
|
|
2021
3986
|
}
|
|
2022
|
-
|
|
2023
|
-
|
|
3987
|
+
if (beforeRow === null) {
|
|
3988
|
+
problems.push('反向构造前提失效(未定位到机制行)');
|
|
3989
|
+
} else {
|
|
3990
|
+
const lines = zhMechanism.split(/\r?\n/);
|
|
3991
|
+
lines[beforeRow.index] = lines[beforeRow.index].replace('`execute`', '');
|
|
3992
|
+
const gutted = lines.join('\n');
|
|
3993
|
+
if (gutted === zhMechanism) {
|
|
3994
|
+
problems.push('反向构造前提失效(机制行未发生变化)');
|
|
3995
|
+
} else if (!mechanismRowProblems(new Map(docs).set('docs/MECHANISM-zh.md', gutted))
|
|
3996
|
+
.some((problem) => problem.includes('未覆盖出口 execute'))) {
|
|
3997
|
+
problems.push('反向构造判别力缺失(抽掉出口 execute 未被判违规)');
|
|
3998
|
+
}
|
|
2024
3999
|
}
|
|
2025
4000
|
}
|
|
2026
4001
|
// 变异探针:正向(overclaim 写回 / 口径改回旧形态)与反向(补上缺失口径 ⇒ 不再报)。
|
|
2027
|
-
//
|
|
4002
|
+
// 文本探针只在该文档真实在场时执行:缺席的文档无法被「改写」,其缺席已由缺席判据判红。
|
|
2028
4003
|
const activeProbes = [
|
|
2029
4004
|
['overclaim 写回', 'README-zh.md', (text) => text + '\n工件与规则完全继承。\n', '仍含旧表述「完全继承」'],
|
|
2030
4005
|
['段名来源改回运行时派生', 'CONTRIBUTING-zh.md',
|
|
@@ -2033,8 +4008,8 @@ export const ENTRIES = [
|
|
|
2033
4008
|
(text) => text + '\n## 缺段报错(两阶段)\n\n首次只给模板路径与类别计数,再犯才列段名。\n', '缺「两阶段」', false],
|
|
2034
4009
|
['补上增量段口径', 'docs/USAGE-zh.md',
|
|
2035
4010
|
(text) => text + '\n工件保真 = 上游模板段 + 本仓增量段。\n', '缺「增量段」', false],
|
|
2036
|
-
].filter(([, rel]) => docs.
|
|
2037
|
-
assertProbesDiscriminate(problems, docs,
|
|
4011
|
+
].filter(([, rel]) => typeof docs.get(rel) === 'string');
|
|
4012
|
+
assertProbesDiscriminate(problems, docs, rules, activeProbes);
|
|
2038
4013
|
if (problems.length > 0) throw new Error('公开面口径不符: ' + problems.join('; '));
|
|
2039
4014
|
},
|
|
2040
4015
|
},
|