flow-comet 1.6.3 → 1.6.4
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/scripts/comet-hook-guard.mjs +11 -13
- package/.flow-comet/skills/flow-comet/scripts/context-init.mjs +2 -2
- package/.flow-comet/skills/flow-comet/scripts/evolve.mjs +6 -6
- package/.flow-comet/skills/flow-comet/scripts/guard-self-test.mjs +67 -18878
- package/.flow-comet/skills/flow-comet/scripts/health.mjs +1 -1
- package/.flow-comet/skills/flow-comet/scripts/items/a.mjs +1030 -0
- package/.flow-comet/skills/flow-comet/scripts/items/b.mjs +830 -0
- package/.flow-comet/skills/flow-comet/scripts/items/c.mjs +781 -0
- package/.flow-comet/skills/flow-comet/scripts/items/d.mjs +99 -0
- package/.flow-comet/skills/flow-comet/scripts/items/e.mjs +185 -0
- package/.flow-comet/skills/flow-comet/scripts/items/f.mjs +90 -0
- package/.flow-comet/skills/flow-comet/scripts/items/g.mjs +59 -0
- package/.flow-comet/skills/flow-comet/scripts/items/h.mjs +815 -0
- package/.flow-comet/skills/flow-comet/scripts/items/i.mjs +77 -0
- package/.flow-comet/skills/flow-comet/scripts/items/j.mjs +75 -0
- package/.flow-comet/skills/flow-comet/scripts/items/k.mjs +1427 -0
- package/.flow-comet/skills/flow-comet/scripts/items/l.mjs +275 -0
- package/.flow-comet/skills/flow-comet/scripts/items/m.mjs +614 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/count-derivation.mjs +97 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/fix-loop-node.mjs +196 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-evidence-gates.mjs +553 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-gates.mjs +837 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-routing.mjs +404 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-state-io.mjs +404 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-template-fidelity.mjs +302 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-uidesign.mjs +133 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/reentry-node.mjs +237 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/replan-node.mjs +209 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-branch.mjs +49 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-bridgecheck.mjs +201 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-admin.mjs +141 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-flow.mjs +700 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-recovery.mjs +578 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-determine.mjs +52 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-evolve-hint.mjs +55 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-explain.mjs +106 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-intelscan.mjs +58 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-io.mjs +147 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-skillmarkers.mjs +189 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/system-fixtures.mjs +1441 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/task-graph.mjs +471 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/test-assertions.mjs +509 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/test-fixtures.mjs +1228 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/test-helpers.mjs +237 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/text-anchor-checks.mjs +2484 -0
- package/.flow-comet/skills/flow-comet/scripts/protocol-utils.mjs +2 -2
- package/.flow-comet/skills/flow-comet/scripts/route-node.mjs +72 -1123
- package/.flow-comet/skills/flow-comet/scripts/scenarios/a.mjs +966 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/b.mjs +1233 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/c.mjs +1382 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/d.mjs +483 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/e.mjs +1388 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/f.mjs +1466 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/g.mjs +1364 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/h.mjs +1287 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/i.mjs +1436 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/j.mjs +1384 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/k.mjs +1338 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/l.mjs +1484 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/m.mjs +971 -0
- package/.flow-comet/skills/flow-comet/scripts/state-schema.mjs +1 -1
- package/.flow-comet/skills/flow-comet/scripts/system-test.mjs +58 -7559
- package/.flow-comet/skills/flow-comet/scripts/time-utils.mjs +4 -4
- package/.flow-comet/skills/flow-comet/scripts/workflow-guard.mjs +151 -2476
- package/.flow-comet/skills/flow-comet/scripts/workflow-handoff.mjs +5 -5
- package/.flow-comet/skills/flow-comet/scripts/workflow-state.mjs +27 -2190
- package/.flow-comet/skills/flow-comet-plan/GUIDANCE.md +1 -1
- package/README.md +52 -69
- package/package.json +3 -2
- package/scripts/dsh-bridge.mjs +2 -2
- package/scripts/lib/installer-cleanup.mjs +152 -0
- package/scripts/lib/installer-flowkit.mjs +119 -0
- package/scripts/lib/installer-hooks.mjs +363 -0
- package/scripts/lib/installer-loader.mjs +220 -0
- package/scripts/lib/installer-migrate.mjs +236 -0
- package/scripts/lib/installer-platforms.mjs +314 -0
- package/scripts/prepare-env.mjs +21 -1313
|
@@ -0,0 +1,2484 @@
|
|
|
1
|
+
// text-anchor-checks.mjs — 文档面与源文本的机检判据(单一来源)
|
|
2
|
+
//
|
|
3
|
+
// 定位:技能树文本锁、分发面文档判据、计数一致性(场景数 / 系统测试集项数)与维护者面
|
|
4
|
+
// 引用/结构机检。判据一律「读文本 → 返回问题描述数组」,收口方(套件底部自检、场景)只负责
|
|
5
|
+
// 报告;计数取数经 `count-derivation.mjs` 单一通道,本模块不再自持正则或虚拟机求值。
|
|
6
|
+
|
|
7
|
+
import fs from 'fs';
|
|
8
|
+
import path from 'path';
|
|
9
|
+
import { execFileSync, spawnSync } from 'child_process';
|
|
10
|
+
import { scenarioCount, systemItemCount } from './count-derivation.mjs';
|
|
11
|
+
import {
|
|
12
|
+
assertExit,
|
|
13
|
+
baseState,
|
|
14
|
+
runHandoff,
|
|
15
|
+
writeFile,
|
|
16
|
+
writeState,
|
|
17
|
+
} from './test-helpers.mjs';
|
|
18
|
+
import {
|
|
19
|
+
CHANGE_ID,
|
|
20
|
+
HOOK,
|
|
21
|
+
REPO_ROOT,
|
|
22
|
+
SCRIPTS_DIR,
|
|
23
|
+
engineCodeText,
|
|
24
|
+
engineDefinitionModule,
|
|
25
|
+
engineDefinitionPattern,
|
|
26
|
+
engineImportsSymbolFrom,
|
|
27
|
+
engineScriptFiles,
|
|
28
|
+
engineScriptTexts,
|
|
29
|
+
} from './test-fixtures.mjs';
|
|
30
|
+
import {
|
|
31
|
+
requireRouteNodeExport,
|
|
32
|
+
scenarioProtocolPath,
|
|
33
|
+
} from './test-assertions.mjs';
|
|
34
|
+
|
|
35
|
+
// 公开产物零代号判据(与 .githooks/internal-codes.mjs 的 BANNED 保持同步——单一来源约定:
|
|
36
|
+
// 本文件随技能包分发,不能 import 主仓私有的 .githooks;改动词表时两份同改,行为必须一致)。
|
|
37
|
+
// 等价性不只靠注释约定:底部自检在权威源检出下读该私有件**逐字符比对**(主仓形态),安装副本
|
|
38
|
+
// 形态输出显式「不适用」描述符(未验证 ≠ 通过)——见词表镜像漂移判据。
|
|
39
|
+
// 除既有过程代号外,本批并入"未公开概念"类**收窄模式**:批次编号 / 批+数字 / 级别编号 /
|
|
40
|
+
// 验收代号 / 工作项编号。模式刻意收窄(词界 + 字母边界):合法中文用法(发布批次 / 维护批次 /
|
|
41
|
+
// 级联 / 变更请求与采纳编号前缀)不命中;判别力与边界锚见维护文档机检场景族(表驱动等价性:
|
|
42
|
+
// 词表每个分支各一条正例 + 一条对应反例,另加本文件注释层零残留——三向自检)。禁止放宽为裸词
|
|
43
|
+
// ——那会误伤公开面大量合法中文用法。
|
|
44
|
+
// 收窄一处:「批 + 数字」补中文序数否定环视——「第 N 批 + 数字」是普通计数短语
|
|
45
|
+
// (合法中文用法),旧模式把它当未公开概念命中。序号与「批」之间隔着数字(阿拉伯或中文),
|
|
46
|
+
// 故环视必须吸收这段数字(变长环视),且**允许两侧空格**(`第 1 批 2 次` 同属普通计数短语);
|
|
47
|
+
// 工作项编号补**尾界**(要求恰好两位,`R-123` 形态不命中)。以上均属"只收窄不放宽";
|
|
48
|
+
// 只排除这两类形态,其余判定不变。无空格连写形态(如「批次2」)刻意不命中:实测受检三层 0 处,
|
|
49
|
+
// 放宽会增误报。本正则与 `.githooks/internal-codes.mjs` 的 `BANNED` 保持 **source 逐字符相等**
|
|
50
|
+
// (主仓形态由镜像漂移判据强制,改一侧必须同步另一侧)。
|
|
51
|
+
export const PUBLIC_CODE_RE = /\bS\d{1,3}\b|T-FIX|batch-(?![a-z])|D-\d+|P[0-7]\b|round\s*\d|dogfood|内部|批次 [A-Z0-9]|(?<!第 ?[0-9一二三四五六七八九十百千万]* ?)批 ?\d|级 [0-9]|UAT-\d|(?<![A-Za-z])R-\d{2}(?![A-Za-z0-9_-])/;
|
|
52
|
+
|
|
53
|
+
// 场景数一致性自检清单(15 文件 = 9 分发组 + 6 维护者组,全变体:ALL n SCENARIOS PASSED / n scenarios / n 场景 / n/n)——
|
|
54
|
+
// 数字由下方常量清单**推导**、不硬编码:9 = SCENARIO_COUNT_FILES 9 条与 SYSTEM_TEST_COUNT_FILES 4 条的
|
|
55
|
+
// 并集(后者是前者子集);6 = SCENARIO_COUNT_FILES_MAINTAINER 6 条与 SYSTEM_TEST_COUNT_FILES_MAINTAINER
|
|
56
|
+
// 6 条的并集(后者是前者子集,故并集即 6 条)——底部自检输出「受检面: n 文件」实际值,清单/数字漂移即可见(防再漂移)。
|
|
57
|
+
// 场景数自检与底部自检共用同一清单/同一实现(自检常量同步:SCENARIOS.length 变更 → 全部受检文件须同步)。
|
|
58
|
+
// 分两组按"分发形态"划界(AC-14:条目缺失必须显式报告,不得静默跳过——幽灵条目无处藏身):
|
|
59
|
+
// ① 分发组:随仓库分发(受版本控制),**任何**权威源检出都必须存在——维护者工作副本、
|
|
60
|
+
// CI 全新检出、worktree 检出皆然 → 条目缺失即报错(幽灵条目在此被强制暴露)。
|
|
61
|
+
// ② 维护者组:被 .gitignore 排除(docs/internal/),只存在于维护者工作副本;CI 全新检出与
|
|
62
|
+
// worktree 检出**整组必然缺席** → 判据取"整组是否在场"而非"单条目是否在场":整组缺席 =
|
|
63
|
+
// 该检出无此文档面,跳过该组;整组在场时同样逐条强制存在与同步,缺失即报错。
|
|
64
|
+
// (单条目静默跳过正是本 change 修正的缺陷——故跳过粒度只能是"整组",不能是"单条"。)
|
|
65
|
+
// CLAUDE.md 为主仓私有指导文件(gitignore 不随 clone 分发)——现列入**维护者组**受检清单:
|
|
66
|
+
// 与 docs/internal/ 同进同退(该目录缺席即整组跳过,非维护者检出不会误红),主仓形态下其
|
|
67
|
+
// 计数不再由人工维护。分发组仍只含随仓库分发的文件。
|
|
68
|
+
// 文档重构:计数只允许出现在入口页徽章行、发布权威与机器锁面(PR 模板 / CI / 欢迎消息 / 变更日志);
|
|
69
|
+
// 其余公开文档一律改述为「见 VERSIONS」,因此本清单随之收缩(此前把 CONTRIBUTING/INSTALLATION/MECHANISM 也列进来,
|
|
70
|
+
// 与单一权威策略冲突:同一数字散落越多越容易漂移)。
|
|
71
|
+
export const SCENARIO_COUNT_FILES = [
|
|
72
|
+
'README.md', 'README-zh.md',
|
|
73
|
+
'docs/VERSIONS.md', 'docs/VERSIONS-zh.md', '.github/PULL_REQUEST_TEMPLATE.md',
|
|
74
|
+
'CHANGELOG.md', 'CHANGELOG-zh.md',
|
|
75
|
+
// CI workflow 文件纳入场景数自检(此前盲区——ci.yml 注释/greeting 欢迎消息的
|
|
76
|
+
// 场景数字样游离,发布时靠人工核对;纳入后自检强制同步,防漏)
|
|
77
|
+
'.github/workflows/ci.yml', '.github/workflows/greeting.yml',
|
|
78
|
+
];
|
|
79
|
+
// 维护者组(见上方分组说明);整组在场判据取**组外**的目录 `docs/internal/`——不能取组内成员:
|
|
80
|
+
// 若用某个成员当探针,该成员缺失时会被判成"整组缺席"而跳过,正好把这个成员的缺失藏起来
|
|
81
|
+
//(即 AC-14 要消灭的"永不生效的条目")。用目录作探针则目录在场即逐条严检,成员缺失照样报告。
|
|
82
|
+
// 会话接续文档(`next-session-prompt-<日期>.md`)**刻意不在本清单内**:它每次会话更名,
|
|
83
|
+
// 而本清单是**受版本控制**的——把它写进来,等于让一个被跟踪的检查器去要求一个
|
|
84
|
+
// 「被忽略且随会话改名」的文件名:在未执行同一次本地迁移的维护者检出里,它会被报成缺失
|
|
85
|
+
// 而让套件失败(CI 因整组跳过不会暴露这一点)。详见本清单下方的分组说明。
|
|
86
|
+
export const SCENARIO_COUNT_FILES_MAINTAINER = [
|
|
87
|
+
'docs/internal/ARCHITECTURE.md', 'docs/internal/DOC-CHECKLIST.md', 'docs/internal/MECHANISM.md',
|
|
88
|
+
'docs/internal/ROADMAP.md',
|
|
89
|
+
'docs/internal/WORKING-METHOD.md',
|
|
90
|
+
// 主仓私有指导面(见上方分组说明):纳入维护者组后其场景数由机检维护;docs/internal/ 缺席
|
|
91
|
+
// 的检出形态整组跳过(该文件同样被 gitignore,两种缺席同源)。
|
|
92
|
+
'CLAUDE.md',
|
|
93
|
+
];
|
|
94
|
+
export const MAINTAINER_DOC_DIR = 'docs/internal';
|
|
95
|
+
// 本仓 CONTEXT 工件(**流程工件面**:.specs/ 被 gitignore)。存在性即「维护者形态」判据——
|
|
96
|
+
// CI 全新检出 / worktree 下结构性缺席,依赖它的场景须输出**可见 SKIP**(未验证 ≠ 通过),
|
|
97
|
+
// 不得把「文件不在场」当成「校验通过」。与 docs/internal/(MAINTAINER_DOC_DIR)同源缺席。
|
|
98
|
+
export const REPO_CONTEXT_FILE = path.join(REPO_ROOT, '.specs', 'CONTEXT.md');
|
|
99
|
+
// 三册显式清单(维护文档机检扫描面;与 docs/internal/*.md、.specs/adr/*.md 并列):
|
|
100
|
+
// 知识权威累积面,更新频率高——写入即需校验。显式清单(不用 .specs/*.md 通配)可预测、
|
|
101
|
+
// 可按册 allowlist,未来新增册需手工登记(与计数受检清单同纪律)。
|
|
102
|
+
export const MAINTAINER_BOOKS = ['.specs/CONTEXT.md', '.specs/LESSONS.md', '.specs/CHANGELOG.md'];
|
|
103
|
+
|
|
104
|
+
// 系统测试集项数受检清单——与场景数清单**并列不合并**:两者数字不同、受检文件面也不同
|
|
105
|
+
// (项数只出现在下面这些文档里;场景数散布更广,含 README / 模板 / CI)。清单本身是
|
|
106
|
+
// 单一来源:改动项数必须同步列出的全部文件,漏同步即套件报错(此前无任何机检锚定,
|
|
107
|
+
// 漂移只能靠人工发现)。分组语义与场景数清单一致(见上方分组说明):分发组恒检,
|
|
108
|
+
// 维护者组整组在场时逐条严检。
|
|
109
|
+
export const SYSTEM_TEST_COUNT_FILES = [
|
|
110
|
+
'docs/VERSIONS.md', 'docs/VERSIONS-zh.md',
|
|
111
|
+
'CHANGELOG.md', 'CHANGELOG-zh.md',
|
|
112
|
+
];
|
|
113
|
+
export const SYSTEM_TEST_COUNT_FILES_MAINTAINER = [
|
|
114
|
+
'docs/internal/ARCHITECTURE.md', 'docs/internal/DOC-CHECKLIST.md', 'docs/internal/MECHANISM.md',
|
|
115
|
+
'docs/internal/ROADMAP.md', 'docs/internal/WORKING-METHOD.md',
|
|
116
|
+
// 与场景数维护者组同面同序(该组为子集关系,便于并集口径一眼可核):机制知识册纳入后
|
|
117
|
+
// 其项数由机检维护;CLAUDE.md 同属主仓私有面。
|
|
118
|
+
'CLAUDE.md',
|
|
119
|
+
];
|
|
120
|
+
// 刻意不收进清单的项数副本(逐条留痕,避免"清单外漏网"变成无声的例外):
|
|
121
|
+
// - .specs/CONTEXT.md:流程工件目录随 change 清理/归档——收进清单会让套件在维护者检出
|
|
122
|
+
// 依赖流程工件状态。
|
|
123
|
+
// 两条原排除说明已结清:CLAUDE.md 与 docs/internal/MECHANISM.md 现均列入维护者组受检清单
|
|
124
|
+
// (前者随 docs/internal/ 缺席整组跳过;后者的项数已与当前值同步)。presence 之外另有 stale
|
|
125
|
+
// 检测兜住"在场但值过期"的形态(见下方 staleCountProblems)。
|
|
126
|
+
export const SYSTEM_TEST_SCRIPT_REL = '.flow-comet/skills/flow-comet/scripts/system-test.mjs';
|
|
127
|
+
|
|
128
|
+
// ---------- 工具函数 ----------
|
|
129
|
+
|
|
130
|
+
// 计数变体:受检文档可接受的写法(含运行时输出形态)。场景数沿用既有全变体;
|
|
131
|
+
// 系统测试集项数用它真实出现的三形态(运行输出 `SYSTEM TEST: n/n passed` 与文档手抄
|
|
132
|
+
// `n items` / `n 项`)。
|
|
133
|
+
export function scenarioCountVariants(n) {
|
|
134
|
+
return ['ALL ' + n + ' SCENARIOS PASSED', n + ' scenarios', n + ' 场景', n + '/' + n];
|
|
135
|
+
}
|
|
136
|
+
export function systemTestCountVariants(itemCount) {
|
|
137
|
+
return [itemCount + '/' + itemCount, itemCount + ' items', itemCount + ' 项'];
|
|
138
|
+
}
|
|
139
|
+
|
|
140
|
+
// 受检文件扫描(单一实现,两套计数共用):返回 { missing, unsynced }(空数组 = 通过)。
|
|
141
|
+
// AC-14:条目缺失**显式报告**,不静默跳过。
|
|
142
|
+
// root 可覆盖扫描根(默认仓库根)——仅为可测性接缝:使「清单条目缺失 → 显式报告」
|
|
143
|
+
// 这一分支能在真实文件系统上被场景驱动(否则该分支只能靠人工实验验证,回归时可能被改回
|
|
144
|
+
// 静默跳过而套件仍全绿)。生产调用不传该参数。
|
|
145
|
+
export function scanCountFiles(files, variants, root = REPO_ROOT) {
|
|
146
|
+
const missing = [];
|
|
147
|
+
const unsynced = [];
|
|
148
|
+
for (const rel of files) {
|
|
149
|
+
let text;
|
|
150
|
+
try {
|
|
151
|
+
text = fs.readFileSync(path.join(root, rel), 'utf8');
|
|
152
|
+
} catch (e) {
|
|
153
|
+
if (e.code === 'ENOENT') { missing.push(rel); continue; } // AC-14:显式记录缺失(不再 continue 静默)
|
|
154
|
+
throw e;
|
|
155
|
+
}
|
|
156
|
+
if (!variants.some((v) => text.includes(v))) unsynced.push(rel);
|
|
157
|
+
}
|
|
158
|
+
return { missing, unsynced };
|
|
159
|
+
}
|
|
160
|
+
|
|
161
|
+
// 维护者面的在场探针(单一来源):以**组外**目录 docs/internal/ 是否存在为判据——不能用组内
|
|
162
|
+
// 成员当探针(成员缺失会被误判成「整组缺席」而跳过,正好藏起该成员的缺失)。计数受检清单的
|
|
163
|
+
// 维护者组与 maintainerFaceSkips 的计数面描述符共用本判据(单一决策,避免多处各写一份而漂移)。
|
|
164
|
+
export function maintainerFacePresent(root = REPO_ROOT) {
|
|
165
|
+
return fs.existsSync(path.join(root, MAINTAINER_DOC_DIR));
|
|
166
|
+
}
|
|
167
|
+
|
|
168
|
+
// ---------- 计数 stale 检测(presence 之外的判别力补足) ----------
|
|
169
|
+
// presence 只能证明"当前值在场",证不了"旧值不在场":维护面曾长期带着无标记旧值仍全绿。
|
|
170
|
+
// 判据:受检面里出现**计数形态 token**、数值落在合理量程、且不等于当前值、且行内没有历史
|
|
171
|
+
// 标记 → 报"旧值未标记"(在场 + 旧值不在场两条一起才叫同步)。
|
|
172
|
+
// ① token 白名单(只认这几种计数写法,避免把通用比值/编号误当计数):`N 场景` / `N scenarios` /
|
|
173
|
+
// `N 项` / `N items` / `ALL N SCENARIOS` / `N/N`——最后一种还须**同行点名套件**
|
|
174
|
+
// (guard-self-test|system-test|SYSTEM TEST|SCENARIOS|场景|项|items|scenarios),
|
|
175
|
+
// 否则 `69/69 = 100%` 一类通用比值会被误伤(设计期实测口径)。
|
|
176
|
+
// ② 量程门:30~400 之外不参与(把版本号、年份、行号一类数字挡在外面)。
|
|
177
|
+
// ③ 历史标记豁免:行内出现"历史 / history / VERSIONS"即视为已标注的历史值。另有两枚等价标记
|
|
178
|
+
// `本轮`(维护笔记记述既往事件的固定措辞)与 `过时`(行内自述该值已过期)——实测受检面里
|
|
179
|
+
// 仅有的两处旧值都出现在这类回顾叙述行里,它们是**已标注**的历史值,不是"未标记旧值"。
|
|
180
|
+
// 受检面(staleCountTargets):维护者面(docs/internal/ 全册 + CLAUDE.md)+ 参考册
|
|
181
|
+
// (reference/*.md,路径从本脚本自身位置推导)。**分发组计数清单不入本面**:变更日志按语义
|
|
182
|
+
// 就是历史记录(双语实测 42 处既往计数),纳入即灾难性误报;分发组的"当前值在场"要求照旧
|
|
183
|
+
// 由 presence 判据覆盖(见上方清单)。
|
|
184
|
+
export const STALE_COUNT_TOKEN_RE = /\b(\d{2,4})\s*(?:场景|scenarios|项|items)|\b(\d{2,4})\/(\d{2,4})\b|\bALL (\d{2,4}) SCENARIOS\b/g;
|
|
185
|
+
export const STALE_COUNT_SUITE_KEYWORD_RE = /guard-self-test|system-test|SYSTEM TEST|SCENARIOS|场景|项|items|scenarios/;
|
|
186
|
+
export const STALE_COUNT_HISTORY_MARKER_RE = /历史|history|VERSIONS|本轮|过时|outdated|superseded/i;
|
|
187
|
+
export const STALE_COUNT_MIN = 30;
|
|
188
|
+
export const STALE_COUNT_MAX = 400;
|
|
189
|
+
// 参考册面(分发参考册):技能树从本脚本自身位置推导——权威源与各安装副本(.claude / .agents /
|
|
190
|
+
// .dsh/skills)同一推导覆盖,不假定权威源布局(与技能树布局感知注释同一纪律)。
|
|
191
|
+
export const REFERENCE_FACE_DIR_REL = path
|
|
192
|
+
.relative(REPO_ROOT, path.join(SCRIPTS_DIR, '..', 'reference'))
|
|
193
|
+
.split(path.sep).join('/');
|
|
194
|
+
|
|
195
|
+
export function staleCountTargets(root = REPO_ROOT) {
|
|
196
|
+
const targets = [];
|
|
197
|
+
const internalDir = path.join(root, MAINTAINER_DOC_DIR);
|
|
198
|
+
if (fs.existsSync(internalDir)) {
|
|
199
|
+
for (const name of fs.readdirSync(internalDir)) {
|
|
200
|
+
if (name.endsWith('.md')) targets.push(path.posix.join(MAINTAINER_DOC_DIR, name));
|
|
201
|
+
}
|
|
202
|
+
}
|
|
203
|
+
const referenceDir = path.join(root, REFERENCE_FACE_DIR_REL);
|
|
204
|
+
if (fs.existsSync(referenceDir)) {
|
|
205
|
+
for (const name of fs.readdirSync(referenceDir)) {
|
|
206
|
+
if (name.endsWith('.md')) targets.push(path.posix.join(REFERENCE_FACE_DIR_REL, name));
|
|
207
|
+
}
|
|
208
|
+
}
|
|
209
|
+
if (fs.existsSync(path.join(root, 'CLAUDE.md'))) targets.push('CLAUDE.md');
|
|
210
|
+
return targets;
|
|
211
|
+
}
|
|
212
|
+
|
|
213
|
+
// counts = 当前值集合(场景数 / 系统测试集项数;派生失败时按 null 过滤——派生失败本身已由
|
|
214
|
+
// 计数一致性判据显式报告,不在此重复)。返回问题描述数组(空数组 = 无未标记旧值)。
|
|
215
|
+
export function staleCountProblems(counts, root = REPO_ROOT) {
|
|
216
|
+
const problems = [];
|
|
217
|
+
const current = new Set(counts.filter((v) => typeof v === 'number' && Number.isFinite(v)));
|
|
218
|
+
for (const rel of staleCountTargets(root)) {
|
|
219
|
+
let text;
|
|
220
|
+
try {
|
|
221
|
+
text = fs.readFileSync(path.join(root, rel), 'utf8');
|
|
222
|
+
} catch (e) {
|
|
223
|
+
// 与维护文档机检同型:读取失败不得静默跳过("未执行 ≠ 通过")。
|
|
224
|
+
const reason = e && e.code ? e.code : (e && e.message ? e.message : String(e));
|
|
225
|
+
problems.push('无法读取: ' + rel + ': ' + reason);
|
|
226
|
+
continue;
|
|
227
|
+
}
|
|
228
|
+
const lines = text.split(/\r?\n/);
|
|
229
|
+
for (let i = 0; i < lines.length; i += 1) {
|
|
230
|
+
const line = lines[i];
|
|
231
|
+
if (STALE_COUNT_HISTORY_MARKER_RE.test(line)) continue;
|
|
232
|
+
for (const m of line.matchAll(STALE_COUNT_TOKEN_RE)) {
|
|
233
|
+
let value = null;
|
|
234
|
+
if (m[1] !== undefined) {
|
|
235
|
+
value = Number(m[1]);
|
|
236
|
+
} else if (m[2] !== undefined) {
|
|
237
|
+
if (m[2] !== m[3]) continue; // 非等值比值(如 69/70)不是计数形态
|
|
238
|
+
if (!STALE_COUNT_SUITE_KEYWORD_RE.test(line)) continue; // 通用比值须同行点名套件
|
|
239
|
+
value = Number(m[2]);
|
|
240
|
+
} else {
|
|
241
|
+
value = Number(m[4]);
|
|
242
|
+
}
|
|
243
|
+
if (!Number.isFinite(value) || value < STALE_COUNT_MIN || value > STALE_COUNT_MAX) continue;
|
|
244
|
+
if (current.has(value)) continue;
|
|
245
|
+
problems.push('旧值未标记: ' + rel + ':' + (i + 1) + ' 计数 ' + m[0].trim()
|
|
246
|
+
+ '(当前值 ' + [...current].join(' / ') + ')——请改写为当前值,或补历史标记'
|
|
247
|
+
+ '(历史 / VERSIONS 指针 / 过时 说明)');
|
|
248
|
+
}
|
|
249
|
+
}
|
|
250
|
+
}
|
|
251
|
+
return problems;
|
|
252
|
+
}
|
|
253
|
+
|
|
254
|
+
// 场景数一致性检查(单一来源):场景 105 与底部自检共用同一实现与同一判据。
|
|
255
|
+
// 返回问题描述数组(空数组 = 通过)。
|
|
256
|
+
// root 可覆盖扫描根(默认仓库根)——同上:仅为可测性接缝(生产调用不传,判据与改前一致)。
|
|
257
|
+
export function scenarioCountSyncProblems(n, root = REPO_ROOT) {
|
|
258
|
+
const problems = [];
|
|
259
|
+
const dist = scanCountFiles(SCENARIO_COUNT_FILES, scenarioCountVariants(n), root);
|
|
260
|
+
if (dist.missing.length > 0) problems.push('受检条目文件缺失(幽灵条目): ' + dist.missing.join(', '));
|
|
261
|
+
if (dist.unsynced.length > 0) problems.push('场景数未同步(应为 ' + n + '): ' + dist.unsynced.join(', '));
|
|
262
|
+
// 维护者组:整组在场才检查(CI 全新检出 / worktree 检出整组必然缺席——见清单分组说明)
|
|
263
|
+
if (maintainerFacePresent(root)) {
|
|
264
|
+
const mnt = scanCountFiles(SCENARIO_COUNT_FILES_MAINTAINER, scenarioCountVariants(n), root);
|
|
265
|
+
if (mnt.missing.length > 0) problems.push('维护者文档条目文件缺失(幽灵条目): ' + mnt.missing.join(', '));
|
|
266
|
+
if (mnt.unsynced.length > 0) problems.push('维护者文档场景数未同步(应为 ' + n + '): ' + mnt.unsynced.join(', '));
|
|
267
|
+
}
|
|
268
|
+
return problems;
|
|
269
|
+
}
|
|
270
|
+
|
|
271
|
+
// 系统测试集项数派生(经 count-derivation 单一通道):派生源缺失 = 数据层尚未落地这一事实,
|
|
272
|
+
// 不是判据失败——调用方须**显式报告**(未执行 ≠ 通过),故以 { count: null, missing } 返回而非
|
|
273
|
+
// 静默计 0;其余派生错误(组文件不合约定等)原样抛出(fail-closed)。
|
|
274
|
+
export async function deriveSystemItemCount(scriptsDir = SCRIPTS_DIR) {
|
|
275
|
+
try {
|
|
276
|
+
return { count: await systemItemCount(scriptsDir), missing: null };
|
|
277
|
+
} catch (e) {
|
|
278
|
+
if (e && e.code === 'COUNT_SOURCE_MISSING') return { count: null, missing: e.path || SYSTEM_TEST_SCRIPT_REL };
|
|
279
|
+
throw e;
|
|
280
|
+
}
|
|
281
|
+
}
|
|
282
|
+
|
|
283
|
+
// 派生源在报告里的名字:能相对受检根表达就用相对路径(消息可核),否则原样给出。
|
|
284
|
+
export function derivationSourceLabel(root, missing) {
|
|
285
|
+
const abs = String(missing || '');
|
|
286
|
+
if (!abs) return SYSTEM_TEST_SCRIPT_REL;
|
|
287
|
+
const rel = path.relative(root, abs);
|
|
288
|
+
return rel && !rel.startsWith('..') ? rel.split(path.sep).join('/') : abs;
|
|
289
|
+
}
|
|
290
|
+
|
|
291
|
+
// 系统测试集项数一致性检查:受检面与场景数面同构(分发组恒检 + 维护者组整组在场时严检)。
|
|
292
|
+
export async function systemTestCountSyncProblems(root = REPO_ROOT, scriptsDir = SCRIPTS_DIR) {
|
|
293
|
+
const { count: itemCount, missing } = await deriveSystemItemCount(scriptsDir);
|
|
294
|
+
if (missing) return ['系统测试集项数派生源缺失(无法核对项数): ' + derivationSourceLabel(root, missing)];
|
|
295
|
+
return systemTestCountProblems(itemCount, root);
|
|
296
|
+
}
|
|
297
|
+
|
|
298
|
+
// presence 面检查(给定已派生的项数):分发组恒检 + 维护者组整组在场时严检。
|
|
299
|
+
export function systemTestCountProblems(itemCount, root = REPO_ROOT) {
|
|
300
|
+
const problems = [];
|
|
301
|
+
const dist = scanCountFiles(SYSTEM_TEST_COUNT_FILES, systemTestCountVariants(itemCount), root);
|
|
302
|
+
if (dist.missing.length > 0) problems.push('系统测试集项数条目文件缺失(幽灵条目): ' + dist.missing.join(', '));
|
|
303
|
+
if (dist.unsynced.length > 0) problems.push('系统测试集项数未同步(应为 ' + itemCount + '): ' + dist.unsynced.join(', '));
|
|
304
|
+
if (maintainerFacePresent(root)) {
|
|
305
|
+
const mnt = scanCountFiles(SYSTEM_TEST_COUNT_FILES_MAINTAINER, systemTestCountVariants(itemCount), root);
|
|
306
|
+
if (mnt.missing.length > 0) problems.push('维护者文档系统测试集项数条目文件缺失(幽灵条目): ' + mnt.missing.join(', '));
|
|
307
|
+
if (mnt.unsynced.length > 0) problems.push('维护者文档系统测试集项数未同步(应为 ' + itemCount + '): ' + mnt.unsynced.join(', '));
|
|
308
|
+
}
|
|
309
|
+
return problems;
|
|
310
|
+
}
|
|
311
|
+
|
|
312
|
+
// 计数一致性检查(两套计数合并 + stale 检测):场景 105 与底部自检共用,两处判据不会漂移。
|
|
313
|
+
// 顺序有意为之:先跑 presence(含派生源缺失/失败,必要时 fail-closed 抛出),再跑 stale——
|
|
314
|
+
// 当前值取自同一派生(场景数 = SCENARIOS.length,项数 = 系统测试集脚本派生),不二次硬编码。
|
|
315
|
+
export async function countSyncProblems(root = REPO_ROOT, scriptsDir = SCRIPTS_DIR) {
|
|
316
|
+
const scenarioTotal = await scenarioCount(scriptsDir);
|
|
317
|
+
const { count: itemCount, missing } = await deriveSystemItemCount(scriptsDir);
|
|
318
|
+
const problems = [
|
|
319
|
+
...scenarioCountSyncProblems(scenarioTotal, root),
|
|
320
|
+
...(missing
|
|
321
|
+
? ['系统测试集项数派生源缺失(无法核对项数): ' + derivationSourceLabel(root, missing)]
|
|
322
|
+
: systemTestCountProblems(itemCount, root)),
|
|
323
|
+
];
|
|
324
|
+
problems.push(...staleCountProblems([scenarioTotal, itemCount], root));
|
|
325
|
+
return problems;
|
|
326
|
+
}
|
|
327
|
+
|
|
328
|
+
// 维护文档机检(docs-governance):覆盖 CI 结构上不可见的维护者面——docs/internal/、
|
|
329
|
+
// .specs/adr/ 与三册显式清单(见 MAINTAINER_BOOKS)的
|
|
330
|
+
// ① 死引用(文档中的仓库相对路径引用必须存在);② ROADMAP 最低结构(Now / Next / Later / Open decisions)。
|
|
331
|
+
// 与计数检查同构:全部目标面缺席(CI 全新检出 / worktree 检出)→ 跳过(空数组,不误红)。
|
|
332
|
+
// 判别力边界(实测教训):提取必须取「完整路径 token」而非后缀子串;scripts/… 一类简写按技能树基准解析;
|
|
333
|
+
// 占位符 / 通配 / 未来路径不参与判定(见 ALLOWLIST)。
|
|
334
|
+
// 解析基准(数据驱动,扩展条目不写逻辑分支):前四条为既有基准(技能树 / 包根 / 上游),
|
|
335
|
+
// 新增基准覆盖权威树根(.flow-comet)、技能树根(.flow-comet/skills、.claude/skills、
|
|
336
|
+
// .agents/skills、.dsh/skills)、规则树根(.flow-comet/rules、.claude/rules)与平台副本根
|
|
337
|
+
// (.claude)——用于解析 `rules/…`、`flow-comet-*/SKILL.md` 这类树根相对形态。
|
|
338
|
+
export const INTERNAL_DOC_REF_BASES = [
|
|
339
|
+
'.flow-comet/skills/flow-comet', '.claude/skills/flow-comet', '', 'flow-kit',
|
|
340
|
+
'.flow-comet', '.flow-comet/skills', '.flow-comet/rules',
|
|
341
|
+
'.claude', '.claude/skills', '.claude/rules', '.agents/skills', '.dsh/skills',
|
|
342
|
+
];
|
|
343
|
+
// 窄域报告规则(判别力补丁):基准全部未解析时,首段属于下列「仓库内树根相对形态」族的引用
|
|
344
|
+
// 必须按死引用报告——即使顶层目录在仓库根不存在也报(这正是旧逻辑「顶层整体缺席 → 跳过」
|
|
345
|
+
// 会静默放过的形态)。族为声明式清单,只覆盖已确证的形态:flow-comet* 技能目录 / rules。
|
|
346
|
+
export const INTERNAL_DOC_REF_TREE_ROOT_FAMILIES = [/^flow-comet[A-Za-z0-9-]*$/, /^rules$/];
|
|
347
|
+
export function isTreeRootRelativeRef(ref) {
|
|
348
|
+
const firstSegment = ref.split('/')[0];
|
|
349
|
+
return INTERNAL_DOC_REF_TREE_ROOT_FAMILIES.some((re) => re.test(firstSegment));
|
|
350
|
+
}
|
|
351
|
+
// 声明式族(取代"顶层段不存在即静默跳过"):解析失败后仍允许跳过的形态必须**逐条显式登记**,
|
|
352
|
+
// 未登记者一律按死引用报告(fail-closed)。旧语义实测吞掉过指向已移除临时区的真实残留——
|
|
353
|
+
// 隐含边界把"允许"藏进了代码,声明式族把允许面变成可见清单,新增跳过必须显式登记。
|
|
354
|
+
// ① 外部命名空间族(前缀声明):平台侧命名空间,本仓库根天然不存在。
|
|
355
|
+
export const EXTERNAL_NAMESPACE_PREFIXES = ['DSH_HOME/', 'dsh-tui/', 'dsh-base/'];
|
|
356
|
+
// ② 退役命名空间允许面(**按角色 / 前缀匹配**,不再逐条硬编码精确 ref):仅限**记录该迁移**
|
|
357
|
+
// 的决策件与决策册——退役命名空间在那里是历史事实,改掉反而丢失迁移记录。
|
|
358
|
+
// 匹配 = 文件面(前缀形态 `filePrefix` 或角色形态 `role`)+ 引用面(退役命名空间前缀)。
|
|
359
|
+
// 精确 ref 硬编码的脆性在于:文件改名即静默失配 → 合法历史迁移记录被误报死引用(误红),
|
|
360
|
+
// 而误红会诱导维护者删掉历史事实。改名不改角色,故按角色/前缀匹配;反过来**不**放宽
|
|
361
|
+
// 引用面与文件面之外的部分:未登记文件 / 未登记命名空间的引用照旧一律报(fail-closed)。
|
|
362
|
+
export const RETIRED_NAMESPACE_PREFIX = '.comet/';
|
|
363
|
+
// 决策册角色判定:`.specs` 下的决策账本族文件(含改名后的 `CONTEXT-<后缀>.md` 形态)——
|
|
364
|
+
// 角色判定按语义而非精确文件名,改名不该让合法迁移记录变成死引用误报。
|
|
365
|
+
// 边界(登记):角色判定只作用于**扫描目标**(该族文件本身须在受检目标清单内才会被扫描)。
|
|
366
|
+
export function isDecisionLedgerFile(rel) {
|
|
367
|
+
return /^\.specs\/CONTEXT(?:[-.][A-Za-z0-9_.-]+)?\.md$/i.test(rel);
|
|
368
|
+
}
|
|
369
|
+
// 文件面匹配器(声明式):kind = filePrefix(路径前缀,改名后缀不影响)| role(角色判定函数)。
|
|
370
|
+
export const RETIRED_NAMESPACE_FILE_MATCHERS = {
|
|
371
|
+
'decision-ledger': isDecisionLedgerFile,
|
|
372
|
+
};
|
|
373
|
+
export const RETIRED_NAMESPACE_ALLOWLIST = [
|
|
374
|
+
{
|
|
375
|
+
filePrefix: '.specs/adr/ADR-009',
|
|
376
|
+
refPrefix: RETIRED_NAMESPACE_PREFIX,
|
|
377
|
+
reason: '记录运行时命名空间迁移的决策件:退役命名空间作为迁移前事实保留(改名不改角色)',
|
|
378
|
+
},
|
|
379
|
+
{
|
|
380
|
+
filePrefix: '.specs/adr/ADR-010',
|
|
381
|
+
refPrefix: RETIRED_NAMESPACE_PREFIX,
|
|
382
|
+
reason: '同族决策件(迁移决策的后续修订):迁移前事实同样保留,按前缀匹配避免改名失配',
|
|
383
|
+
},
|
|
384
|
+
{
|
|
385
|
+
role: 'decision-ledger',
|
|
386
|
+
refPrefix: RETIRED_NAMESPACE_PREFIX,
|
|
387
|
+
reason: '决策册角色(.specs 下决策账本族):已锁决策记录迁移事实(退役命名空间的历史形态)',
|
|
388
|
+
},
|
|
389
|
+
];
|
|
390
|
+
// 允许面条目匹配(单一实现):文件面(前缀 / 角色)与引用面(前缀)同时命中才算登记在案。
|
|
391
|
+
export function matchesRetiredNamespaceEntry(entry, rel, ref) {
|
|
392
|
+
const refOk = typeof entry.refPrefix === 'string' && ref.startsWith(entry.refPrefix);
|
|
393
|
+
if (!refOk) return false;
|
|
394
|
+
if (typeof entry.filePrefix === 'string' && rel.startsWith(entry.filePrefix)) return true;
|
|
395
|
+
if (typeof entry.role === 'string') {
|
|
396
|
+
const roleMatcher = RETIRED_NAMESPACE_FILE_MATCHERS[entry.role];
|
|
397
|
+
if (typeof roleMatcher === 'function' && roleMatcher(rel)) return true;
|
|
398
|
+
}
|
|
399
|
+
return false;
|
|
400
|
+
}
|
|
401
|
+
// ③ 示例形态允许面(逐条 {file, ref, reason}):文档里的示意路径。清单**逐条登记**——
|
|
402
|
+
// 未登记即报(fail-closed),不是「该判据不生效」;查询带长度短路(零条目时不进入匹配),
|
|
403
|
+
// 避免把零条目扩展点当成隐式权限。出现新示例时在此登记(登记即把边界显式化:文档措辞
|
|
404
|
+
// 不动,只声明「该路径是示意、不是真实文件」)。
|
|
405
|
+
export const EXAMPLE_REF_ALLOWLIST = [
|
|
406
|
+
{
|
|
407
|
+
file: '.specs/adr/ADR-014-parallel-delegation-contract.md',
|
|
408
|
+
ref: 'src/foo.mjs',
|
|
409
|
+
reason: '写冲突盲区的示例路径(非真实文件)',
|
|
410
|
+
},
|
|
411
|
+
];
|
|
412
|
+
export function isDeclaredReferenceSkip(rel, ref) {
|
|
413
|
+
if (EXTERNAL_NAMESPACE_PREFIXES.some((prefix) => ref.startsWith(prefix))) return true;
|
|
414
|
+
if (RETIRED_NAMESPACE_ALLOWLIST.some((e) => matchesRetiredNamespaceEntry(e, rel, ref))) return true;
|
|
415
|
+
if (EXAMPLE_REF_ALLOWLIST.length > 0
|
|
416
|
+
&& EXAMPLE_REF_ALLOWLIST.some((e) => e.file === rel && e.ref === ref)) return true;
|
|
417
|
+
return false;
|
|
418
|
+
}
|
|
419
|
+
export const INTERNAL_DOC_REF_ALLOWLIST = new Set(['.specs/archive/CONTEXT-history.md']);
|
|
420
|
+
// 引用提取:既有形态(≥1 段路径 + 扩展名)+ **可选行号后缀**(`:N` / `:N-M` / 逗号列表
|
|
421
|
+
// `:N,M`)——行号存在性与不越界判据需要把行号一起取出来(见 internalDocsProblems)。
|
|
422
|
+
export const INTERNAL_DOC_REF_RE = /(?<![A-Za-z0-9_.\-\/])(\.?(?:[A-Za-z0-9_][A-Za-z0-9_.\-]*\/)+[A-Za-z0-9_.\-]+\.(?:md|mjs|cjs|js|ts|json|ya?ml|sh|patch|toml))(?::(\d+(?:-\d+)?(?:\s*,\s*\d+(?:-\d+)?)*))?(?![A-Za-z0-9])/gm;
|
|
423
|
+
// 并列写法护栏:首段**本身带文件扩展名**的 token 不是路径引用(如 `TEST.md/REVIEW.md` 是两个
|
|
424
|
+
// 文件名并列写法)——不参与解析(存在性判据与行号判据同此)。判据必须收窄到"首段带扩展名":
|
|
425
|
+
// 用"首段含 `.`"会把 `.specs/…` / `.flow-comet/…` 这类隐藏目录一并误排(设计期实测该写法把
|
|
426
|
+
// 5 处带行号引用压成 3 处)。
|
|
427
|
+
export const INTERNAL_DOC_REF_PARALLEL_RE = /\.(?:md|mjs|cjs|js|ts|json|ya?ml|sh|patch|toml)$/i;
|
|
428
|
+
|
|
429
|
+
// 行号后缀 → 数值数组(区间取两端;逗号列表逐项展开)。
|
|
430
|
+
export function parseRefLineNumbers(suffix) {
|
|
431
|
+
if (!suffix) return [];
|
|
432
|
+
const out = [];
|
|
433
|
+
for (const part of suffix.split(/\s*,\s*/)) {
|
|
434
|
+
if (part.includes('-')) {
|
|
435
|
+
const [start, end] = part.split('-');
|
|
436
|
+
out.push(Number(start), Number(end));
|
|
437
|
+
} else {
|
|
438
|
+
out.push(Number(part));
|
|
439
|
+
}
|
|
440
|
+
}
|
|
441
|
+
return out;
|
|
442
|
+
}
|
|
443
|
+
|
|
444
|
+
export function internalDocRefCandidates(text) {
|
|
445
|
+
const out = [];
|
|
446
|
+
const seen = new Set();
|
|
447
|
+
const lines = String(text).split(/\r?\n/);
|
|
448
|
+
for (let i = 0; i < lines.length; i += 1) {
|
|
449
|
+
for (const m of lines[i].matchAll(INTERNAL_DOC_REF_RE)) {
|
|
450
|
+
const token = m[1];
|
|
451
|
+
if (token.includes('*') || token.includes('<')) continue; // 通配 / 占位符
|
|
452
|
+
if (INTERNAL_DOC_REF_PARALLEL_RE.test(token.split('/')[0])) continue; // 并列写法(见上方护栏)
|
|
453
|
+
const key = i + 1 + ' ' + token + ':' + (m[2] || '');
|
|
454
|
+
if (seen.has(key)) continue;
|
|
455
|
+
seen.add(key);
|
|
456
|
+
out.push({ ref: token, line: i + 1, lineRefs: parseRefLineNumbers(m[2]) });
|
|
457
|
+
}
|
|
458
|
+
}
|
|
459
|
+
return out;
|
|
460
|
+
}
|
|
461
|
+
|
|
462
|
+
// 引用解析(单一实现):按声明式基准清单逐个试解析,命中即返回绝对路径;全部失败返回 null。
|
|
463
|
+
export function resolveInternalDocRef(ref, root = REPO_ROOT) {
|
|
464
|
+
for (const base of INTERNAL_DOC_REF_BASES) {
|
|
465
|
+
const p = base === '' ? path.join(root, ref) : path.join(root, base, ref);
|
|
466
|
+
if (fs.existsSync(p)) return p;
|
|
467
|
+
}
|
|
468
|
+
return null;
|
|
469
|
+
}
|
|
470
|
+
|
|
471
|
+
// 维护文档机检的受检目标清单(单一来源):docs/internal/*.md(目录在场时)+ .specs/adr/*.md
|
|
472
|
+
// + 三册显式清单(MAINTAINER_BOOKS)。三册是知识权威累积面、更新频率高(写入即需校验);
|
|
473
|
+
// 显式清单可预测,未来新增第四册需手工登记(与计数受检清单同纪律)。
|
|
474
|
+
// 全部目标面缺席 → 空数组(组缺席语义;internalDocsProblems 与 maintainerFaceSkips 共用同一判据)。
|
|
475
|
+
export function internalDocTargets(root = REPO_ROOT) {
|
|
476
|
+
const targets = [];
|
|
477
|
+
const internalDir = path.join(root, MAINTAINER_DOC_DIR);
|
|
478
|
+
if (fs.existsSync(internalDir)) {
|
|
479
|
+
for (const name of fs.readdirSync(internalDir)) {
|
|
480
|
+
if (name.endsWith('.md')) targets.push(path.posix.join(MAINTAINER_DOC_DIR, name));
|
|
481
|
+
}
|
|
482
|
+
}
|
|
483
|
+
const adrDir = path.join(root, '.specs', 'adr');
|
|
484
|
+
if (fs.existsSync(adrDir)) {
|
|
485
|
+
for (const name of fs.readdirSync(adrDir)) {
|
|
486
|
+
if (name.endsWith('.md')) targets.push(path.posix.join('.specs', 'adr', name));
|
|
487
|
+
}
|
|
488
|
+
}
|
|
489
|
+
for (const rel of MAINTAINER_BOOKS) {
|
|
490
|
+
if (fs.existsSync(path.join(root, rel))) targets.push(rel);
|
|
491
|
+
}
|
|
492
|
+
return targets;
|
|
493
|
+
}
|
|
494
|
+
|
|
495
|
+
// ROADMAP 表头新鲜度(内容锚):声明式表头行 `> 最后更新:<YYYY-MM-DD>` 的日期必须 ≥ 该文件
|
|
496
|
+
// 正文中出现过的最大日期。维护面无 git 跟踪文件(实测 0 跟踪),提交日锚不可得——内容锚纯结构、
|
|
497
|
+
// 可夹具驱动。未声明表头的目标跳过(登记边界:表头即"最后更新"声明,没声明就没得比)。
|
|
498
|
+
export const ROADMAP_HEADER_RE = /^\s*>\s*最后更新[::]\s*(20\d{2}-\d{2}-\d{2})/m;
|
|
499
|
+
export const INTERNAL_DOC_DATE_RE = /20\d{2}-\d{2}-\d{2}/g;
|
|
500
|
+
// 归档目录条目:`<日期>-<change-id>`。
|
|
501
|
+
export const ARCHIVE_DIR_ENTRY_RE = /^\d{4}-\d{2}-\d{2}-(.+)$/;
|
|
502
|
+
|
|
503
|
+
// 行号存在与不越界判定(结构级;单一实现):只在引用本身解析成功后才调用——引用不存在时由
|
|
504
|
+
// 死引用判据负责报告(同一处只报一次,不叠两条)。区间取两端、逗号列表逐项,逐个校验 1..N。
|
|
505
|
+
export function lineNumberProblems(rel, entry, resolvedPath, lineCountOf) {
|
|
506
|
+
const problems = [];
|
|
507
|
+
if (entry.lineRefs.length === 0) return problems;
|
|
508
|
+
const total = lineCountOf(resolvedPath);
|
|
509
|
+
if (total === null) return problems; // 目标瞬时不可读:存在性已通过,行号按不可判跳过
|
|
510
|
+
for (const num of entry.lineRefs) {
|
|
511
|
+
if (num < 1 || num > total) {
|
|
512
|
+
problems.push('行号越界: ' + rel + ':' + entry.line + ' → ' + entry.ref + ':' + num
|
|
513
|
+
+ '(目标共 ' + total + ' 行)——请改指目标里真实存在的行,或删除行号后缀');
|
|
514
|
+
}
|
|
515
|
+
}
|
|
516
|
+
return problems;
|
|
517
|
+
}
|
|
518
|
+
|
|
519
|
+
// 表头新鲜度判定(内容锚;单一实现):无表头声明 → 跳过(登记边界);表头日期 < 正文最大日期 → 报。
|
|
520
|
+
export function headerFreshnessProblems(rel, text) {
|
|
521
|
+
const header = text.match(ROADMAP_HEADER_RE);
|
|
522
|
+
if (!header) return [];
|
|
523
|
+
const dates = [...text.matchAll(INTERNAL_DOC_DATE_RE)].map((m) => m[0]);
|
|
524
|
+
const maxBody = dates.reduce((a, b) => (a > b ? a : b), '');
|
|
525
|
+
if (maxBody === '' || header[1] >= maxBody) return [];
|
|
526
|
+
return ['表头不新鲜: ' + rel + ' 表头 ' + header[1] + ' < 正文最大 ' + maxBody
|
|
527
|
+
+ '——请把表头日期刷新到不早于正文最大日期'];
|
|
528
|
+
}
|
|
529
|
+
|
|
530
|
+
// 已归档 change 清单(读目录名;归档面缺席 → 空数组,非维护者检出/夹具形态不误红)。
|
|
531
|
+
export function archivedChangeIds(root = REPO_ROOT) {
|
|
532
|
+
const archiveDir = path.join(root, '.specs', 'archive');
|
|
533
|
+
if (!fs.existsSync(archiveDir)) return [];
|
|
534
|
+
const ids = [];
|
|
535
|
+
for (const name of fs.readdirSync(archiveDir)) {
|
|
536
|
+
const m = ARCHIVE_DIR_ENTRY_RE.exec(name);
|
|
537
|
+
if (m) ids.push({ id: m[1], dir: name });
|
|
538
|
+
}
|
|
539
|
+
return ids;
|
|
540
|
+
}
|
|
541
|
+
|
|
542
|
+
// `## Now`(在办段)不得出现已归档 change-id:段定位**必须用标题扫描**(允许段名尾部括号注记),
|
|
543
|
+
// 切到下一个二级标题 Next 为止。禁止用 indexOf('## Now')——该册文件头的目录说明行里含被反引号
|
|
544
|
+
// 包住的同名标题字样,indexOf 会命中说明行、切出极短窗口使判据恒过(实测教训:判据的定位口径
|
|
545
|
+
// 必须自实测推导,不能被同一文件里"看起来对"的文本骗过)。
|
|
546
|
+
export function roadmapNowArchivedProblems(rel, text, root = REPO_ROOT) {
|
|
547
|
+
const problems = [];
|
|
548
|
+
const nowRe = /^##\s*Now\s*(?:[((][^))\n]*[))])?\s*$/m;
|
|
549
|
+
const nowMatch = nowRe.exec(text);
|
|
550
|
+
if (!nowMatch) return problems; // 段缺席由结构判据报告,此处不重复
|
|
551
|
+
const rest = text.slice(nowMatch.index + nowMatch[0].length);
|
|
552
|
+
const nextRe = /^##\s*Next\s*(?:[((][^))\n]*[))])?\s*$/m;
|
|
553
|
+
const nextMatch = nextRe.exec(rest);
|
|
554
|
+
const section = nextMatch ? rest.slice(0, nextMatch.index) : rest;
|
|
555
|
+
for (const { id, dir } of archivedChangeIds(root)) {
|
|
556
|
+
// 命中面 = id 及其路径形态(两形态都要判:只判路径会漏掉裸 id 写法)。
|
|
557
|
+
// id 用**整词**匹配(字母/数字/连字符为词字符)——直接 `includes(id)` 会让短 id 命中更长 id
|
|
558
|
+
// 或同族更长 id 的中间(如归档 id `archived-fixture` 命中 `archived-fixture-v2`),属假红。
|
|
559
|
+
const idRe = new RegExp('(?<![A-Za-z0-9_-])' + id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '(?![A-Za-z0-9_-])');
|
|
560
|
+
if (idRe.test(section) || section.includes(dir)) {
|
|
561
|
+
problems.push('Now 段含已归档 change-id: ' + id + '(' + rel + ' 的在办段引用了已归档记录 '
|
|
562
|
+
+ dir + ')——请从在办段移出(历史指针面记录)');
|
|
563
|
+
}
|
|
564
|
+
}
|
|
565
|
+
return problems;
|
|
566
|
+
}
|
|
567
|
+
|
|
568
|
+
export function internalDocsProblems(root = REPO_ROOT) {
|
|
569
|
+
const problems = [];
|
|
570
|
+
const targets = internalDocTargets(root);
|
|
571
|
+
if (targets.length === 0) return problems; // 全部目标面缺席 → 整组跳过(CI / worktree 形态)
|
|
572
|
+
const lineCountCache = new Map();
|
|
573
|
+
const lineCountOf = (p) => {
|
|
574
|
+
if (!lineCountCache.has(p)) {
|
|
575
|
+
try {
|
|
576
|
+
// 逻辑行数:**尾随换行不产生额外一行**(`a\nb\nc\n` = 3 行),**空文件 = 0 行**(不是 1 行)。
|
|
577
|
+
// 直接取 `split(/\r?\n/).length` 会把尾随空段算成一行 → `:N+1` 越界被漏报;空文件若按段数
|
|
578
|
+
// 计会得 1 行 → `:1` 被放过(空文件没有任何行,任何行号都越界)。
|
|
579
|
+
const body = fs.readFileSync(p, 'utf8');
|
|
580
|
+
const parts = body === '' ? [] : body.split(/\r?\n/);
|
|
581
|
+
if (parts.length > 1 && parts[parts.length - 1] === '') parts.pop();
|
|
582
|
+
lineCountCache.set(p, parts.length);
|
|
583
|
+
} catch {
|
|
584
|
+
lineCountCache.set(p, null); // 目标瞬时不可读:存在性已通过,行号判据按不可判跳过
|
|
585
|
+
}
|
|
586
|
+
}
|
|
587
|
+
return lineCountCache.get(p);
|
|
588
|
+
};
|
|
589
|
+
for (const rel of targets) {
|
|
590
|
+
let text;
|
|
591
|
+
try {
|
|
592
|
+
text = fs.readFileSync(path.join(root, rel), 'utf8');
|
|
593
|
+
} catch (e) {
|
|
594
|
+
// F4:读取失败(EACCES / EBUSY / EISDIR 等)不得静默 continue——该目标既没被判死引用、
|
|
595
|
+
// 也没被判缺失,静默跳过会让受检面出现「未执行 ≠ 通过」的黑洞(同类静默通道;本批
|
|
596
|
+
// 正落在新扩扫描面上)。按可见问题报告,并继续扫描其余目标(一个目标损坏不吞整册扫描面)。
|
|
597
|
+
const reason = e && e.code ? e.code : (e && e.message ? e.message : String(e));
|
|
598
|
+
problems.push('无法读取: ' + rel + ': ' + reason);
|
|
599
|
+
continue;
|
|
600
|
+
}
|
|
601
|
+
for (const entry of internalDocRefCandidates(text)) {
|
|
602
|
+
if (INTERNAL_DOC_REF_ALLOWLIST.has(entry.ref)) continue;
|
|
603
|
+
const resolved = resolveInternalDocRef(entry.ref, root);
|
|
604
|
+
if (resolved !== null) {
|
|
605
|
+
problems.push(...lineNumberProblems(rel, entry, resolved, lineCountOf));
|
|
606
|
+
continue;
|
|
607
|
+
}
|
|
608
|
+
// 窄域报告规则:树根相对形态(flow-comet* 技能目录 / rules)基准全失败 → 按死引用报告,
|
|
609
|
+
// 不再落入「顶层整体缺席 → 跳过」(旧逻辑在此静默放过——族见上方声明)。
|
|
610
|
+
if (isTreeRootRelativeRef(entry.ref)) {
|
|
611
|
+
problems.push('死引用: ' + rel + ':' + entry.line + ' → ' + entry.ref
|
|
612
|
+
+ '(树根相对形态未解析:技能树 / 规则树内不存在该目标)');
|
|
613
|
+
continue;
|
|
614
|
+
}
|
|
615
|
+
// 声明式族:登记在案的外部命名空间 / 退役命名空间 / 示例形态 → 跳过;其余一律按死引用报
|
|
616
|
+
// (顶层段不存在不再是免检理由——那正是旧逻辑吞掉真实残留的通道)。
|
|
617
|
+
if (isDeclaredReferenceSkip(rel, entry.ref)) continue;
|
|
618
|
+
problems.push('死引用: ' + rel + ':' + entry.line + ' → ' + entry.ref
|
|
619
|
+
+ '(顶层段不存在且未登记为允许跳过;请修正路径,或按声明式族逐条登记理由)');
|
|
620
|
+
}
|
|
621
|
+
// 表头新鲜度(内容锚;未声明表头 → 跳过)
|
|
622
|
+
problems.push(...headerFreshnessProblems(rel, text));
|
|
623
|
+
}
|
|
624
|
+
const roadmapRel = path.posix.join(MAINTAINER_DOC_DIR, 'ROADMAP.md');
|
|
625
|
+
if (!fs.existsSync(path.join(root, roadmapRel))) {
|
|
626
|
+
problems.push('ROADMAP 缺失: ' + roadmapRel);
|
|
627
|
+
} else {
|
|
628
|
+
let text = null;
|
|
629
|
+
try {
|
|
630
|
+
text = fs.readFileSync(path.join(root, roadmapRel), 'utf8');
|
|
631
|
+
} catch (e) {
|
|
632
|
+
// F4 语义的结构检查侧补齐:ROADMAP 自身读取失败(EACCES / EBUSY / EISDIR 等)与目标扫描
|
|
633
|
+
// 同型报告(同一错误摘要口径),并跳过四段结构检查——不得让同一受检面在结构检查处抛
|
|
634
|
+
// 未捕获异常、以堆栈崩溃整个套件(读取失败可见化在两个消费点语义一致)。
|
|
635
|
+
const reason = e && e.code ? e.code : (e && e.message ? e.message : String(e));
|
|
636
|
+
problems.push('无法读取: ' + roadmapRel + ': ' + reason);
|
|
637
|
+
}
|
|
638
|
+
if (text !== null) {
|
|
639
|
+
for (const section of ['Now', 'Next', 'Later', 'Open decisions']) {
|
|
640
|
+
const sectionRe = new RegExp('^##\\s*' + section + '\\s*(?:[((][^))\\n]*[))])?\\s*$', 'm');
|
|
641
|
+
if (!sectionRe.test(text)) {
|
|
642
|
+
problems.push('ROADMAP 结构缺段: ' + section + '(' + roadmapRel + ')');
|
|
643
|
+
}
|
|
644
|
+
}
|
|
645
|
+
problems.push(...roadmapNowArchivedProblems(roadmapRel, text, root));
|
|
646
|
+
}
|
|
647
|
+
}
|
|
648
|
+
return problems;
|
|
649
|
+
}
|
|
650
|
+
|
|
651
|
+
// 维护者面缺席可见化(可测接缝;root 可覆盖=测试专用入口,生产调用不传):
|
|
652
|
+
// 返回被跳过的面与原因描述符数组(空数组 = 全部维护者面在场,无跳过)。与消费点共用同一在场
|
|
653
|
+
// 判据——① 计数受检清单的维护者组复用 maintainerFacePresent(组外目录探针,与
|
|
654
|
+
// scenarioCountSyncProblems 同源);② 维护文档机检以 internalDocTargets 是否为空为判据
|
|
655
|
+
// (同 internalDocsProblems)。
|
|
656
|
+
// 只产出描述符,不改任何判定 / 返回值语义 / 退出码;套件底部据此输出可见的 SKIP 行
|
|
657
|
+
// (worktree / CI 全新检出等结构性缺席不误红,但不得被当成「已校验」——以维护者主树 L1 为准)。
|
|
658
|
+
export function maintainerFaceSkips(root = REPO_ROOT) {
|
|
659
|
+
const skips = [];
|
|
660
|
+
if (!maintainerFacePresent(root)) {
|
|
661
|
+
skips.push({
|
|
662
|
+
face: '维护者文档计数面(场景数 + 系统测试集项数)',
|
|
663
|
+
reason: MAINTAINER_DOC_DIR + '/ 目录缺席(CI 全新检出 / worktree 检出等非维护者形态)',
|
|
664
|
+
});
|
|
665
|
+
}
|
|
666
|
+
if (internalDocTargets(root).length === 0) {
|
|
667
|
+
skips.push({
|
|
668
|
+
face: '维护文档机检(引用解析 + 路线图结构)',
|
|
669
|
+
reason: '受检目标面全部缺席(' + MAINTAINER_DOC_DIR + ' 与 .specs/adr 与三册均不可见)',
|
|
670
|
+
});
|
|
671
|
+
}
|
|
672
|
+
return skips;
|
|
673
|
+
}
|
|
674
|
+
|
|
675
|
+
// 系统测试集项数受检面的分支夹具(场景 231 用):逐条驱动组文件派生、组文件契约违约(导出非数组 /
|
|
676
|
+
// 空数组 / 元素缺 name 各自 fail-closed 且指名文件)、条目缺失、项数未同步、维护者组整组在场判定、
|
|
677
|
+
// 组文件目录缺失(目录缺席 / 空目录 / 套件入口在场三种输入形态)——判据统一是「显式报告、不静默
|
|
678
|
+
// 跳过」(AC-14 同型)。
|
|
679
|
+
// 夹具根即受检根:数据层按组文件约定建在 <dir>/scripts/items/ 下,并把该 scripts/ 作为派生的
|
|
680
|
+
// 可测接缝传入——派生值必须是「读组文件」得来,不是常量。
|
|
681
|
+
export async function exerciseSystemTestCountCheck(dir) {
|
|
682
|
+
const scriptsDir = path.join(dir, 'scripts');
|
|
683
|
+
// 契约违约探针:写一份畸形组文件 → 派生必须抛错,且消息指名该文件与违约形态(fail-closed;
|
|
684
|
+
// 分支若改成静默计 0,这里即红)。文件名逐组不同——ESM 按 URL 缓存模块,同名复用会取回上一份
|
|
685
|
+
// 已求值的模块。验完即删,后续步骤仍以 3 条合法条目为前提。
|
|
686
|
+
const expectContractError = async (fileName, source, ...expected) => {
|
|
687
|
+
const rel = path.posix.join('items', fileName);
|
|
688
|
+
writeFile(scriptsDir, rel, source);
|
|
689
|
+
let caught = null;
|
|
690
|
+
try {
|
|
691
|
+
await systemItemCount(scriptsDir);
|
|
692
|
+
} catch (e) {
|
|
693
|
+
caught = e;
|
|
694
|
+
}
|
|
695
|
+
fs.rmSync(path.join(scriptsDir, rel));
|
|
696
|
+
if (!caught) throw new Error('组文件违约未被 fail-closed 抛出(静默计数): ' + rel);
|
|
697
|
+
for (const frag of [rel, ...expected]) {
|
|
698
|
+
if (!String(caught.message).includes(frag)) {
|
|
699
|
+
throw new Error('组文件违约报告未指向「' + frag + '」: ' + caught.message);
|
|
700
|
+
}
|
|
701
|
+
}
|
|
702
|
+
};
|
|
703
|
+
// ① 组文件派生:两份组文件共 3 条 → 派生值必须是 3(证明计数是读出来的,不是硬编码)
|
|
704
|
+
writeFile(scriptsDir, 'items/a.mjs', 'export const ENTRIES = [\n'
|
|
705
|
+
+ ' { name: \'x1\', run: () => {} },\n'
|
|
706
|
+
+ ' { name: \'x2\', run: () => {} },\n'
|
|
707
|
+
+ '];\n');
|
|
708
|
+
writeFile(scriptsDir, 'items/b.mjs', 'export const ENTRIES = [\n'
|
|
709
|
+
+ ' { name: \'x3\', run: () => {} },\n'
|
|
710
|
+
+ '];\n');
|
|
711
|
+
const derived = await deriveSystemItemCount(scriptsDir);
|
|
712
|
+
if (derived.count !== 3) throw new Error('项数未从组文件派生(应为 3): ' + JSON.stringify(derived));
|
|
713
|
+
const itemCount = derived.count;
|
|
714
|
+
for (const rel of SYSTEM_TEST_COUNT_FILES) writeFile(dir, rel, itemCount + ' items\n');
|
|
715
|
+
const clean = await systemTestCountSyncProblems(dir, scriptsDir);
|
|
716
|
+
if (clean.length !== 0) {
|
|
717
|
+
throw new Error('受检面齐备且同步时不应报告问题: ' + JSON.stringify(clean));
|
|
718
|
+
}
|
|
719
|
+
// ② 组文件契约违约三形态(AC-9 的「篡改」支):各自 fail-closed,消息含文件名 + 违约形态
|
|
720
|
+
await expectContractError('bad-nonarray.mjs', 'export const ENTRIES = {};\n', '未导出 ENTRIES 数组');
|
|
721
|
+
await expectContractError('bad-empty.mjs', 'export const ENTRIES = [];\n', '为空数组');
|
|
722
|
+
await expectContractError('bad-noname.mjs', 'export const ENTRIES = [\n { run: () => {} },\n];\n', '缺 name 字段');
|
|
723
|
+
// ③ 移走一个条目(幽灵条目形态)→ 显式报告缺失项(列出文件名)
|
|
724
|
+
const missingRel = 'CHANGELOG-zh.md';
|
|
725
|
+
if (!SYSTEM_TEST_COUNT_FILES.includes(missingRel)) throw new Error('夹具前提失效:' + missingRel + ' 不在受检清单内');
|
|
726
|
+
fs.rmSync(path.join(dir, missingRel));
|
|
727
|
+
const missingProblems = await systemTestCountSyncProblems(dir, scriptsDir);
|
|
728
|
+
if (!missingProblems.some((p) => p.includes('缺失') && p.includes(missingRel))) {
|
|
729
|
+
throw new Error('系统测试集项数缺失条目未被显式报告: ' + JSON.stringify(missingProblems));
|
|
730
|
+
}
|
|
731
|
+
// ④ 条目在场但项数未同步 → 同样上报(缺省放过即为静默失检)
|
|
732
|
+
writeFile(dir, missingRel, '未同步的内容\n');
|
|
733
|
+
const stale = (await systemTestCountSyncProblems(dir, scriptsDir)).join(' | ');
|
|
734
|
+
if (!stale.includes('未同步') || !stale.includes(missingRel)) {
|
|
735
|
+
throw new Error('系统测试集项数未同步条目未被上报: ' + stale);
|
|
736
|
+
}
|
|
737
|
+
// ⑤ 维护者组整组在场判定:组目录缺席 → 整组跳过(CI 全新检出形态,不可判成假红)
|
|
738
|
+
writeFile(dir, missingRel, itemCount + ' items\n');
|
|
739
|
+
const groupAbsent = await systemTestCountSyncProblems(dir, scriptsDir);
|
|
740
|
+
if (groupAbsent.length !== 0) {
|
|
741
|
+
throw new Error('组目录缺席时应整组跳过: ' + JSON.stringify(groupAbsent));
|
|
742
|
+
}
|
|
743
|
+
// ⑥ 组目录在场 → 逐条严检:成员缺席照样显式报告("整组跳过"不等于"组内在场者免检")
|
|
744
|
+
writeFile(dir, path.posix.join(MAINTAINER_DOC_DIR, 'stand-in.md'), 'stand-in\n');
|
|
745
|
+
const mntMissing = await systemTestCountSyncProblems(dir, scriptsDir);
|
|
746
|
+
if (!mntMissing.some((p) => p.includes('缺失') && p.includes(SYSTEM_TEST_COUNT_FILES_MAINTAINER[0]))) {
|
|
747
|
+
throw new Error('维护者组成员缺席未被显式报告: ' + JSON.stringify(mntMissing));
|
|
748
|
+
}
|
|
749
|
+
// ⑦ 组文件目录缺失 → fail-closed 且指向真实缺口(组文件目录),不静默计 0。三种输入形态:
|
|
750
|
+
// A 目录缺席 / A′ 空目录 / B 真实安装形态(目录缺席而套件入口在场——派生不得回落去解析入口文本,
|
|
751
|
+
// 改动前此处抛 `ReferenceError: GROUP_A is not defined`)。
|
|
752
|
+
const itemsDir = path.join(scriptsDir, 'items');
|
|
753
|
+
const expectMissingDir = async (label) => {
|
|
754
|
+
let caught = null;
|
|
755
|
+
try {
|
|
756
|
+
await systemItemCount(scriptsDir);
|
|
757
|
+
} catch (e) {
|
|
758
|
+
caught = e;
|
|
759
|
+
}
|
|
760
|
+
if (!caught || caught.code !== 'COUNT_SOURCE_MISSING') {
|
|
761
|
+
throw new Error(label + ':组文件目录缺失未抛 COUNT_SOURCE_MISSING: '
|
|
762
|
+
+ (caught ? (caught.code + ' ' + caught.message) : '未抛错'));
|
|
763
|
+
}
|
|
764
|
+
if (!String(caught.message).includes(itemsDir)) {
|
|
765
|
+
throw new Error(label + ':缺失报告未指向组文件目录 ' + itemsDir + ': ' + caught.message);
|
|
766
|
+
}
|
|
767
|
+
const reported = (await systemTestCountSyncProblems(dir, scriptsDir)).join(' | ');
|
|
768
|
+
if (!reported.includes('缺失') || !reported.includes('scripts/items')) {
|
|
769
|
+
throw new Error(label + ':消费方的显式「缺失」报告未指向组文件目录: ' + reported);
|
|
770
|
+
}
|
|
771
|
+
};
|
|
772
|
+
fs.rmSync(itemsDir, { recursive: true, force: true });
|
|
773
|
+
await expectMissingDir('形态 A(目录缺席)');
|
|
774
|
+
fs.mkdirSync(itemsDir, { recursive: true });
|
|
775
|
+
await expectMissingDir('形态 A′(空目录)');
|
|
776
|
+
fs.rmSync(itemsDir, { recursive: true, force: true });
|
|
777
|
+
writeFile(scriptsDir, 'system-test.mjs', 'const TEST_ITEMS = [\n ...GROUP_A,\n];\n');
|
|
778
|
+
await expectMissingDir('形态 B(组文件目录缺席,套件入口在场)');
|
|
779
|
+
}
|
|
780
|
+
// ---------- 词表镜像漂移判据(主仓私有单一来源 ↔ 分发套件的同义镜像) ----------
|
|
781
|
+
// 背景:套件随技能包分发、不能 import 主仓私有的 .githooks(该面不随 clone 分发),故套件内
|
|
782
|
+
// 保留同义镜像 PUBLIC_CODE_RE。两份此前只有注释互指"同步",零一致性判据:主仓增补模式时
|
|
783
|
+
// 分发侧扫描静默落后(新词可在公开面长期存活而套件全绿),反向则分发面误红——正是
|
|
784
|
+
// 「同一判据两份实现必然分叉」点名的形态。本判据把等价性变成机检事实:
|
|
785
|
+
// · 主仓形态(权威源检出):读 .githooks 的 BANNED.source,与套件镜像**逐字符比对**,
|
|
786
|
+
// 不等即报(消息含两侧 source 片段、长度与首个差异位置,可直接定位);
|
|
787
|
+
// · 安装副本形态:该私有面结构性缺席 → 判据**不适用**,由调用方输出显式「不适用」描述符
|
|
788
|
+
// (未验证 ≠ 通过,与维护者面缺席的可见 SKIP 同族语义)。
|
|
789
|
+
export const GITHOOKS_CODES_REL = path.posix.join('.githooks', 'internal-codes.mjs');
|
|
790
|
+
|
|
791
|
+
// 导出正则字面量抽取(\ 转义感知):从 `export const <name> = /<body>/<flags>;` 取 body 与 flags。
|
|
792
|
+
// 解析失败返回 null(调用方按"判据未执行"显式报告,不静默放过)。
|
|
793
|
+
export function extractExportedRegexLiteral(text, name) {
|
|
794
|
+
const re = new RegExp('export\\s+const\\s+' + name + '\\s*=\\s*/((?:\\\\.|[^/\\\\\\n])*)/([a-z]*)\\s*;');
|
|
795
|
+
const m = re.exec(text);
|
|
796
|
+
return m === null ? null : { source: m[1], flags: m[2] };
|
|
797
|
+
}
|
|
798
|
+
|
|
799
|
+
export function vocabularyMirrorProblems(root = REPO_ROOT) {
|
|
800
|
+
const problems = [];
|
|
801
|
+
const rel = GITHOOKS_CODES_REL;
|
|
802
|
+
let text;
|
|
803
|
+
try {
|
|
804
|
+
text = fs.readFileSync(path.join(root, rel), 'utf8');
|
|
805
|
+
} catch (e) {
|
|
806
|
+
const reason = e && e.code ? e.code : (e && e.message ? e.message : String(e));
|
|
807
|
+
problems.push('词表镜像漂移判据无法执行: ' + rel + ' 读取失败(' + reason
|
|
808
|
+
+ ')——未执行 ≠ 通过;请在主仓私有面在场处重跑(主树 L1)');
|
|
809
|
+
return problems;
|
|
810
|
+
}
|
|
811
|
+
const banned = extractExportedRegexLiteral(text, 'BANNED');
|
|
812
|
+
if (banned === null) {
|
|
813
|
+
problems.push('词表镜像漂移判据无法执行: ' + rel + ' 未解析出导出的 BANNED 正则字面量'
|
|
814
|
+
+ '(词表单一来源形态变化)——未执行 ≠ 通过');
|
|
815
|
+
return problems;
|
|
816
|
+
}
|
|
817
|
+
const mine = PUBLIC_CODE_RE.source;
|
|
818
|
+
if (banned.source !== mine) {
|
|
819
|
+
const shared = Math.min(banned.source.length, mine.length);
|
|
820
|
+
let firstDiff = shared;
|
|
821
|
+
for (let i = 0; i < shared; i += 1) {
|
|
822
|
+
if (banned.source[i] !== mine[i]) { firstDiff = i; break; }
|
|
823
|
+
}
|
|
824
|
+
const fragment = (s) => (s.length > 80 ? s.slice(0, 80) + '…' : s);
|
|
825
|
+
problems.push('词表镜像漂移: ' + rel + ' 的 BANNED.source(' + banned.source.length
|
|
826
|
+
+ ' 字符)≠ 套件 PUBLIC_CODE_RE.source(' + mine.length + ' 字符);首个差异位置 ' + firstDiff
|
|
827
|
+
+ ';主仓侧片段「' + fragment(banned.source) + '」;套件侧片段「' + fragment(mine)
|
|
828
|
+
+ '」——两侧必须逐字符等价,请同改(词表只许收窄、不许放宽)');
|
|
829
|
+
}
|
|
830
|
+
if (banned.flags !== PUBLIC_CODE_RE.flags) {
|
|
831
|
+
problems.push('词表镜像标志位漂移: ' + rel + ' 的 BANNED flags=' + JSON.stringify(banned.flags)
|
|
832
|
+
+ ' ≠ 套件 PUBLIC_CODE_RE flags=' + JSON.stringify(PUBLIC_CODE_RE.flags));
|
|
833
|
+
}
|
|
834
|
+
return problems;
|
|
835
|
+
}
|
|
836
|
+
|
|
837
|
+
export function twoLayerEntryProblems(rel, text) {
|
|
838
|
+
const out = [];
|
|
839
|
+
if (text.includes('见上方 Required Calls 表')) out.push(rel + ' 含 Implementation/Required 混淆句式');
|
|
840
|
+
if (text.includes('record 会自动补写缺失的声明标记')) out.push(rel + ' 含无限定自动补表述');
|
|
841
|
+
if (!text.includes('Skill 工具加载该节点的 Implementation 技能')) out.push(rel + ' 缺入口层锚点句');
|
|
842
|
+
if (!text.includes('前置门')) out.push(rel + ' 缺前置门表述');
|
|
843
|
+
return out;
|
|
844
|
+
}
|
|
845
|
+
|
|
846
|
+
// 技能加载措辞判据(场景 164 使用;纯函数 + 合成输入可驱动):主 SKILL / 入口展开册 / 八个节点册
|
|
847
|
+
// 各须含「Skill 工具」与「不得跳过 / 禁止跳过」两条存在级锚点句(加载 = Skill 工具注入会话,
|
|
848
|
+
// 只读文件不叫加载)。返回问题描述数组(空 = 两条齐备);判别力由场景内的逐条抽掉构造常驻证明。
|
|
849
|
+
export function skillLoadingWordingProblems(rel, text) {
|
|
850
|
+
const out = [];
|
|
851
|
+
if (!text.includes('Skill 工具')) out.push(rel + ' 缺「Skill 工具」');
|
|
852
|
+
if (!text.includes('不得跳过') && !text.includes('禁止跳过')) out.push(rel + ' 缺「不得跳过/禁止跳过」');
|
|
853
|
+
return out;
|
|
854
|
+
}
|
|
855
|
+
|
|
856
|
+
// 委托纪律三块归一处(场景 184 的 ⑥ 使用;纯函数 + 合成输入可驱动):ADR-016 把「两册三块逐字
|
|
857
|
+
// 一致(切片 ≥400 字符)+ 两册各持 41 条判别句」重定向为「两册各自的要点句在场 + 权威处唯一 +
|
|
858
|
+
// 留正文的判别句逐句留原文但**不再要求两册相同**」。归一处:pathspec 五要素与集成四要素的**全文**
|
|
859
|
+
// → `reference/commit-discipline.md`;四属性契约(能力契约锚)→ 两册正文 + 入口册 + 平台事实册。
|
|
860
|
+
// ① 要素级 token 组:措辞可分叉(逐字锁已作废),但**要素一条不得缺**(两册 + 权威处同时受限);
|
|
861
|
+
// ② 权威处正文在场:权威处独有的判别句必须在该文件(缺句即红);
|
|
862
|
+
// ③ 权威处唯一:权威处正文**回流任一册即红**——这一侧原逐字锁完全没有(它**要求**两册各持一份);
|
|
863
|
+
// ④ 证据与判级类判别句(随平台事实移走):只在权威处,回流册子即红;
|
|
864
|
+
// ⑤ 条件句指针:两册各自须指向 commit-discipline / platform-facts / fix-loop 三个权威文件。
|
|
865
|
+
export const COMMIT_DISCIPLINE_REL = 'flow-comet/reference/commit-discipline.md';
|
|
866
|
+
export const PLATFORM_FACTS_REL = 'flow-comet/reference/platform-facts.md';
|
|
867
|
+
export const COMMIT_DISCIPLINE_ELEMENT_GROUPS = [
|
|
868
|
+
['提交面 pathspec 纪律 · 适用条件', ['**各自独立工作区(worktree 等)内的局部 `reset` / `clean` 不在禁令内**']],
|
|
869
|
+
['提交面 pathspec 纪律 · 要素 1(字面路径集)',
|
|
870
|
+
['`git add -- <自己字面路径>`', '`git commit -- <同一路径>`', 'write_files']],
|
|
871
|
+
['提交面 pathspec 纪律 · 要素 2(锁失败重试)', ['锁失败重试', 'index.lock', '失败即重试']],
|
|
872
|
+
['提交面 pathspec 纪律 · 要素 3(禁裸命令)',
|
|
873
|
+
['禁裸', '`commit -a`', '`stash`', '`clean`', '`reset`']],
|
|
874
|
+
['提交面 pathspec 纪律 · 要素 4(为什么 · 索引竞态)', ['并发索引竞态', '索引与工作树']],
|
|
875
|
+
['提交面 pathspec 纪律 · 要素 5(并行波次附加两条)', ['`git commit --amend`', '`--soft`']],
|
|
876
|
+
['集成纪律 · 要素 1(机制选择)', ['`git merge --no-ff`', 'cherry-pick']],
|
|
877
|
+
['集成纪律 · 要素 2(顺序)', ['拓扑序', 'task id 升序']],
|
|
878
|
+
['集成纪律 · 要素 3(审计留痕)', ['INTEGRATE: <task-id> <commitHash> → <集成提交>']],
|
|
879
|
+
['集成纪律 · 要素 4(冲突处置两类)', ['机械冲突', '语义冲突', '上抛']],
|
|
880
|
+
];
|
|
881
|
+
// 权威处**正文**(逐字搬运进 `commit-discipline.md` 的原句;实测两册均无这些整句——回流即红)。
|
|
882
|
+
export const COMMIT_DISCIPLINE_AUTHORITY_PHRASES = [
|
|
883
|
+
'2. **`git commit -- <同一路径>`**:提交以 pathspec 限定范围,保证提交只含自己的文件;路径集与上一步**逐字一致**。',
|
|
884
|
+
'3. **锁失败重试**:并发提交会撞 `index.lock` / `cannot lock ref`——**失败即重试**(临时仓真并发实测:20 提交 / 25 次锁失败全部重试成功);不得因锁失败改用宽泛命令。',
|
|
885
|
+
'5. **为什么**:并发写者共享**同一个索引与工作树**——宽泛命令存在**并发索引竞态**:一方 `add -A` 会把另一方的半成品纳入自己的提交(串味 / 多文件提交);`stash` / `clean` / `reset` 更会直接破坏同伴的未提交工作。',
|
|
886
|
+
'**并行波次附加两条(与上列五要素并列适用 · 不改其语义与适用条件)**:',
|
|
887
|
+
'- **并行波次禁用 `git commit --amend`**:共享工作区下 HEAD 会被并行写者推进——`--amend` 改的是 **HEAD 指向的提交**、不一定是「你的提交」,会把同伴的提交连同提交信息一并改写(本仓实测撞过:amend 误改了另一并行任务的提交,经 `reset --soft` 复原,内容零损失)。确需修正时必须**先断言 `git rev-parse HEAD` 等于自己刚提交的哈希**,否则一律改用**新提交追加**。',
|
|
888
|
+
'- **误改后的自救通道(与上列第 4 条的定向例外)**:合法修复路径 = **先断言** `git rev-parse HEAD` 即被误改的那次提交,再 `git reset --soft <自己的父提交>` 回退(**只用 `--soft`**:只移动 HEAD、不动索引与工作树,同伴的未提交工作零影响),最后以 **pathspec** 重建自己的提交。纪律必须留出这条明路——让执行者**不必违规**(force-push / 手改历史)即可收拾;**无合法修复通道时人会暗改**(见 ADR-013 记录的同型教训)。',
|
|
889
|
+
'2. **顺序(确定性规则)**:先按 `depends_on` 的**拓扑序**集成(被依赖者先入);同一拓扑层内按 **task id 升序**(计划期固定的稳定键,与完成先后无关)。**不得依赖书写顺序** / 提交到达顺序 / 完成先后等运行期不确定量。',
|
|
890
|
+
'3. **审计留痕**:每次集成输出一行审计行 `INTEGRATE: <task-id> <commitHash> → <集成提交>`;降级路径为 `INTEGRATE: <task-id> <commitHash> via cherry-pick -- 降级原因:<原因>`。映射(task-id → commitHash → 集成提交)记入该趟流程记录(`<task-id>-SUMMARY.md` / handoff evidence 文本字段)。**判级**:审计行是**执行纪律**(review 把关),本节点不声称存在机械门禁校验它。',
|
|
891
|
+
' - **机械冲突**(不改用户可见行为:同一文件不同区域 / 相邻行 / 纯格式):执行者**可自行解决**——解决后必须跑**合并后验证**(该任务 `verify` + 受影响任务的判据),并在审计行记录冲突与解决方式。',
|
|
892
|
+
' - **语义冲突**(两侧对同一行为 / 契约 / 接口给出不同语义:同一函数语义分叉、同一 AC 的两种实现、公共 API 形状不一致):**必须中止集成并上抛**(记 BLOCKED + 恢复指引),**不得**由执行者自行拍板;由协调者 / 用户裁决(补 `depends_on`、拆任务或开新 change)。',
|
|
893
|
+
];
|
|
894
|
+
// 四属性契约(能力契约锚 · ADR-016 明示「该怎么干」类 ⇒ 留两册正文;两册不再要求逐字相同)。
|
|
895
|
+
export const PARALLEL_CONTRACT_BOOK_PHRASES = [
|
|
896
|
+
'> **并行安全四属性契约**:契约对象是**四属性**,不是 worktree',
|
|
897
|
+
'| ① | **写权限** | 每个写者必须有一条被守卫认可的写入通道 |',
|
|
898
|
+
'| ③ | **验证隔离** | 同一时刻只有一个写者:全量判据不得与在飞写者并行 |',
|
|
899
|
+
'出口校验锚 = `handoffRequests` 有 request 无对应 `handoffResult` ⇒ 新 change BLOCKED / 旧 change WARN;全部有 result ⇒ 放行;无证据 ⇒ 零输出',
|
|
900
|
+
'**已撤回的 request 不构成在飞委托**',
|
|
901
|
+
'`workflow-handoff.mjs withdraw <task-id> --by <来源>` 在原记录上留痕 `withdrawnAt` + `withdrawnBy`,已撤回 = 终态、历史不删',
|
|
902
|
+
'**并同时注入桥接通道标记 `FLOW_COMET_AGENT_DEPTH_SOURCE`——守卫要求标记与深度同时在场才接受该通道**',
|
|
903
|
+
'**写面含 gitignored 面的任务(四属性映射 · 与其他任务同一判据)**',
|
|
904
|
+
'① **写权限**仍走**身份通道**',
|
|
905
|
+
'② **提交隔离**走既有 **`noCommit` 资格**',
|
|
906
|
+
'**并行 × 零提交**因此合法',
|
|
907
|
+
'**留痕的边界(诚实声明 · 与 `directOverride` / `completedChecks` / `reentryAuthorization` 同族)**',
|
|
908
|
+
'留痕记录的是「**发生过委派**」,**不是**对执行者身份的物理证明',
|
|
909
|
+
'与 `completedChecks` 只能记录声明、`directOverride` 只能记录授权、`reentryAuthorization` 只能记录授权源同理',
|
|
910
|
+
];
|
|
911
|
+
// 四属性的四个属性名(硬约束要求保留的能力契约锚;两册正文逐册在场)。
|
|
912
|
+
export const PARALLEL_CONTRACT_ATTRIBUTE_NAMES = ['**写权限**', '**提交隔离**', '**验证隔离**', '**集成纪律**'];
|
|
913
|
+
// 证据与判级类判别句(ADR-016 ⑥:随平台事实移走)——只在 `platform-facts.md`,回流册子即红。
|
|
914
|
+
export const CONTRACT_EVIDENCE_AUTHORITY_PHRASES = [
|
|
915
|
+
'**+ 通道标记 `FLOW_COMET_AGENT_DEPTH_SOURCE`**;0 / 缺失 / 无标记 = 协调者',
|
|
916
|
+
'**证实**——Codex 交互式会话的原生子代理载荷含 `agent_id`',
|
|
917
|
+
'**推翻**——「Codex 载荷无身份字段」只对 `codex exec` headless 主线程成立,**不得外推**为平台结论。',
|
|
918
|
+
'**未覆盖(显式标注,不得写成已支持)**',
|
|
919
|
+
'> | **Claude Code** | 身份分派(载荷含 `agent_id` / `agent_type`——**证实**:真机实测子代理载荷含二者、主会话载荷不含,与 Codex 同一判据)',
|
|
920
|
+
'CC 子代理载荷含 `agent_id` / `agent_type`(真机实测:子代理载荷含二者、主会话载荷不含,与 Codex 同一判据)',
|
|
921
|
+
'非 `bypassPermissions` 权限模式下的载荷形态',
|
|
922
|
+
];
|
|
923
|
+
// 两册各自须持的三个条件句指针(`reference/fix-loop.md` 属修复回路段,见场景 258)。
|
|
924
|
+
export const DELEGATION_POINTER_RELS = [
|
|
925
|
+
'reference/commit-discipline.md', 'reference/platform-facts.md', 'reference/fix-loop.md',
|
|
926
|
+
];
|
|
927
|
+
export function delegationDisciplineProblems({ books, elementDocs, authorityTexts }) {
|
|
928
|
+
const problems = [];
|
|
929
|
+
for (const [rel, text] of elementDocs) {
|
|
930
|
+
for (const [label, tokens] of COMMIT_DISCIPLINE_ELEMENT_GROUPS) {
|
|
931
|
+
const missing = tokens.filter((token) => !text.includes(token));
|
|
932
|
+
if (missing.length > 0) {
|
|
933
|
+
problems.push(rel + ' 缺「' + label + '」要点句(缺 token: ' + missing.join(' / ') + ')');
|
|
934
|
+
}
|
|
935
|
+
}
|
|
936
|
+
}
|
|
937
|
+
const authorityText = authorityTexts.get(COMMIT_DISCIPLINE_REL);
|
|
938
|
+
for (const phrase of COMMIT_DISCIPLINE_AUTHORITY_PHRASES) {
|
|
939
|
+
if (!authorityText.includes(phrase)) {
|
|
940
|
+
problems.push(COMMIT_DISCIPLINE_REL + ' 缺权威处判别句:' + phrase.slice(0, 40) + '…');
|
|
941
|
+
}
|
|
942
|
+
for (const [rel, text] of books) {
|
|
943
|
+
if (text.includes(phrase)) {
|
|
944
|
+
problems.push(rel + ' 回流了 ' + COMMIT_DISCIPLINE_REL + ' 的权威处正文:' + phrase.slice(0, 40) + '…');
|
|
945
|
+
}
|
|
946
|
+
}
|
|
947
|
+
}
|
|
948
|
+
for (const [rel, text] of books) {
|
|
949
|
+
for (const phrase of PARALLEL_CONTRACT_BOOK_PHRASES) {
|
|
950
|
+
if (!text.includes(phrase)) {
|
|
951
|
+
problems.push(rel + ' 缺四属性契约判别句:' + phrase.slice(0, 40) + '…');
|
|
952
|
+
}
|
|
953
|
+
}
|
|
954
|
+
for (const attribute of PARALLEL_CONTRACT_ATTRIBUTE_NAMES) {
|
|
955
|
+
if (!text.includes(attribute)) {
|
|
956
|
+
problems.push(rel + ' 缺四属性契约属性名:' + attribute);
|
|
957
|
+
}
|
|
958
|
+
}
|
|
959
|
+
for (const pointer of DELEGATION_POINTER_RELS) {
|
|
960
|
+
if (!text.includes(pointer)) {
|
|
961
|
+
problems.push(rel + ' 缺条件句(指针不在场): ' + pointer);
|
|
962
|
+
}
|
|
963
|
+
}
|
|
964
|
+
}
|
|
965
|
+
const evidenceText = authorityTexts.get(PLATFORM_FACTS_REL);
|
|
966
|
+
for (const phrase of CONTRACT_EVIDENCE_AUTHORITY_PHRASES) {
|
|
967
|
+
if (!evidenceText.includes(phrase)) {
|
|
968
|
+
problems.push(PLATFORM_FACTS_REL + ' 缺证据与判级判别句:' + phrase.slice(0, 40) + '…');
|
|
969
|
+
}
|
|
970
|
+
for (const [rel, text] of books) {
|
|
971
|
+
if (text.includes(phrase)) {
|
|
972
|
+
problems.push(rel + ' 回流了证据与判级判别句:' + phrase.slice(0, 40) + '…(权威处唯一)');
|
|
973
|
+
}
|
|
974
|
+
}
|
|
975
|
+
}
|
|
976
|
+
return problems;
|
|
977
|
+
}
|
|
978
|
+
|
|
979
|
+
// 前端判据散文口径(场景 286 使用;纯函数 + 合成文本面可驱动):ADR-016 把原「五份文本**各自**
|
|
980
|
+
// 陈述五个结构 token」重定向为「**一处权威**(`flow-comet-ui-design` 册的「触发与跳过」段陈述
|
|
981
|
+
// 结构形态三种 + 词形边界 + 命中片段回显)+ **各引用册指针在场**(条件句指向该册,缺即红)+
|
|
982
|
+
// **该口径正文唯一**(块级跨距:任何其它分发文本不得含权威口径段的 ≥ `FRONTEND_CRITERION_BLOCK_SPAN`
|
|
983
|
+
// 字符逐字副本——短片段(要素名 / 命令形态 / 互指指针 / 压缩要点句)天然重合,按 T-03 实测建议
|
|
984
|
+
// 取块级跨距,避免必然假红)。反向构造的目标随之从「每份文本」改到**权威处**。
|
|
985
|
+
export const FRONTEND_CRITERION_AUTHORITY_REL = 'flow-comet-ui-design/SKILL.md';
|
|
986
|
+
export const FRONTEND_CRITERION_BLOCK_SPAN = 120;
|
|
987
|
+
// 各引用册的指针判别句式(逐册 token 组:必须同指该唯一权威,缺一册即红)。
|
|
988
|
+
export const FRONTEND_CRITERION_POINTER_RELS = [
|
|
989
|
+
['flow-comet/SKILL.md', ['唯一权威是 `flow-comet-ui-design` 册']],
|
|
990
|
+
['flow-comet-design/SKILL.md', ['唯一权威 → `flow-comet-ui-design` 册', '「触发与跳过」段']],
|
|
991
|
+
['flow-comet-change/SKILL.md', ['**判据与强制等级(唯一权威)**', '`flow-comet-ui-design` 册的「触发与跳过」段']],
|
|
992
|
+
];
|
|
993
|
+
export function frontendCriterionAuthorityBlock(text) {
|
|
994
|
+
const match = /「结构形态」的三种任一[\s\S]*?仍判前端。/.exec(text);
|
|
995
|
+
return match ? match[0] : null;
|
|
996
|
+
}
|
|
997
|
+
export function frontendCriterionRedirectProblems({ authorityRel, authorityText, pointerDocs, docs }) {
|
|
998
|
+
const problems = [];
|
|
999
|
+
// ① 一处权威:结构形态五 token 齐备(同一判据前端散文函数)+ 旧口径零残留。
|
|
1000
|
+
problems.push(...frontendCriterionProseProblems(authorityRel, authorityText));
|
|
1001
|
+
const block = frontendCriterionAuthorityBlock(authorityText);
|
|
1002
|
+
if (block === null) {
|
|
1003
|
+
problems.push(authorityRel + ' 缺权威口径段(「结构形态」三种任一 → 仍判前端 的整段)');
|
|
1004
|
+
} else if (block.length < FRONTEND_CRITERION_BLOCK_SPAN) {
|
|
1005
|
+
problems.push(authorityRel + ' 权威口径段过短(' + block.length + ' 字符 < '
|
|
1006
|
+
+ FRONTEND_CRITERION_BLOCK_SPAN + ')——正文唯一性判据无从成立');
|
|
1007
|
+
}
|
|
1008
|
+
// ② 各引用册指针在场:每册须含指向该权威的条件句(缺任一册即红)。
|
|
1009
|
+
for (const [rel, tokens] of FRONTEND_CRITERION_POINTER_RELS) {
|
|
1010
|
+
const text = pointerDocs.get(rel);
|
|
1011
|
+
if (text === undefined) {
|
|
1012
|
+
problems.push(rel + ' 不在场(前端判据的引用册指针无从校验)');
|
|
1013
|
+
continue;
|
|
1014
|
+
}
|
|
1015
|
+
const missing = tokens.filter((token) => !text.includes(token));
|
|
1016
|
+
if (missing.length > 0) {
|
|
1017
|
+
problems.push(rel + ' 指针不在场(缺指向 ' + authorityRel + ' 的条件句 token: ' + missing.join(' / ') + ')');
|
|
1018
|
+
}
|
|
1019
|
+
}
|
|
1020
|
+
// ③ 正文唯一:权威口径段不得在第二份分发文本里逐字出现(块级跨距)。
|
|
1021
|
+
if (block !== null) {
|
|
1022
|
+
for (const [rel, text] of docs) {
|
|
1023
|
+
if (rel === authorityRel) continue;
|
|
1024
|
+
const span = longestCommonSpan(block, text);
|
|
1025
|
+
if (span.length >= FRONTEND_CRITERION_BLOCK_SPAN) {
|
|
1026
|
+
problems.push(rel + ' 出现结构判据口径的第二份正文(连续同文 ' + span.length + ' 字符 ≥ '
|
|
1027
|
+
+ FRONTEND_CRITERION_BLOCK_SPAN + ')——权威处唯一');
|
|
1028
|
+
}
|
|
1029
|
+
}
|
|
1030
|
+
}
|
|
1031
|
+
return problems;
|
|
1032
|
+
}
|
|
1033
|
+
|
|
1034
|
+
// 修复回路状态机路径(场景 258 使用;纯函数 + 合成输入可驱动):ADR-016 把「三册段正文 sha256
|
|
1035
|
+
// 完全一致」的逐字锁重定向为「三册各含要点句与条件句 + 该段正文**仅一处**(权威 =
|
|
1036
|
+
// `reference/fix-loop.md`)+ 原 6 个关键词与『禁 `advance` 作正常路径』断言**迁到权威处**」。
|
|
1037
|
+
// 要点句取**要素级 token 组**(措辞可分叉——ADR-016 明示三册口径一致但不再要求逐字相同);
|
|
1038
|
+
// 「仅一处」用块级跨距(连续同文 ≥ `FIX_LOOP_BLOCK_SPAN` 字符)判:册子的要点句与权威段落天然
|
|
1039
|
+
// 局部重合(公式化命令形态 / 要素名),短片段不计——只有把权威段落**整段复制回册子**才红。
|
|
1040
|
+
export const FIX_LOOP_AUTHORITY_REL = 'flow-comet/reference/fix-loop.md';
|
|
1041
|
+
export const FIX_LOOP_SECTION_HEADING = '## 修复回路状态机路径';
|
|
1042
|
+
export const FIX_LOOP_AUTHORITY_KEYWORDS = [
|
|
1043
|
+
'受控归位', 'NODE: execute', '回源节点跑出口', 'entry <源节点>', 'exit <源节点> --apply', '禁止绕过',
|
|
1044
|
+
];
|
|
1045
|
+
export const FIX_LOOP_BLOCK_SPAN = 120;
|
|
1046
|
+
export const FIX_LOOP_BOOK_ELEMENT_GROUPS = [
|
|
1047
|
+
['追加 Fix 任务', ['## Fix 任务', '禁止文件尾追加']],
|
|
1048
|
+
['受控归位 execute', ['受控归位', 'NODE: execute']],
|
|
1049
|
+
['execute 四类出口', ['record execute', 'exit execute --apply', '任务集签名']],
|
|
1050
|
+
['回源节点跑出口', ['回源节点跑出口', 'entry <源节点>', 'exit <源节点> --apply']],
|
|
1051
|
+
['禁止绕过', ['禁止绕过', 'BLOCKED']],
|
|
1052
|
+
['条件句指针', ['reference/fix-loop.md']],
|
|
1053
|
+
];
|
|
1054
|
+
// 段切片(同一区间:首个 `## 修复回路状态机路径` → 下一 `##` 或 EOF,标题不计入)。
|
|
1055
|
+
export function fixLoopStateMachineSectionOf(text) {
|
|
1056
|
+
const match = text.match(/(?:^|\r?\n)## 修复回路状态机路径\r?\n([\s\S]*?)(?=\r?\n## |$)/);
|
|
1057
|
+
return match ? match[1].replace(/\r\n/g, '\n') : null;
|
|
1058
|
+
}
|
|
1059
|
+
export function fixLoopStateMachineProblems({ books, authority }) {
|
|
1060
|
+
const problems = [];
|
|
1061
|
+
for (const [rel, text] of books) {
|
|
1062
|
+
const section = fixLoopStateMachineSectionOf(text);
|
|
1063
|
+
if (section === null) {
|
|
1064
|
+
problems.push(rel + ' SKILL.md 缺「' + FIX_LOOP_SECTION_HEADING + '」段');
|
|
1065
|
+
continue;
|
|
1066
|
+
}
|
|
1067
|
+
if (section.trim() === '') problems.push(rel + ' 修复回路状态机路径段不得为空');
|
|
1068
|
+
for (const [label, tokens] of FIX_LOOP_BOOK_ELEMENT_GROUPS) {
|
|
1069
|
+
const missing = tokens.filter((token) => !section.includes(token));
|
|
1070
|
+
if (missing.length > 0) {
|
|
1071
|
+
problems.push(rel + ' 缺「' + label + '」要点句(缺 token: ' + missing.join(' / ') + ')');
|
|
1072
|
+
}
|
|
1073
|
+
}
|
|
1074
|
+
// 反捷径(册内一侧):`advance` 不作正常路径;「直接 exit 源节点收场」只允许以被禁形态出现。
|
|
1075
|
+
if (section.includes('advance')) {
|
|
1076
|
+
problems.push(rel + ' 修复回路状态机路径段不得把 advance 作为正常路径');
|
|
1077
|
+
}
|
|
1078
|
+
for (const line of section.split(/\r?\n/)) {
|
|
1079
|
+
if (line.includes('直接') && line.includes('exit') && !/禁止|不得|会被 BLOCKED/.test(line)) {
|
|
1080
|
+
problems.push(rel + ' 修复回路状态机路径段不得把直接 exit 源节点收场作为正常路径: ' + line.trim());
|
|
1081
|
+
}
|
|
1082
|
+
}
|
|
1083
|
+
}
|
|
1084
|
+
// 权威处:原 6 个关键词 + 反 advance + 「禁止直接 exit 收场」断言全部迁到该文件。
|
|
1085
|
+
const authoritySection = fixLoopStateMachineSectionOf(authority);
|
|
1086
|
+
if (authoritySection === null) {
|
|
1087
|
+
problems.push(FIX_LOOP_AUTHORITY_REL + ' 缺「' + FIX_LOOP_SECTION_HEADING + '」段(唯一权威处缺失)');
|
|
1088
|
+
return problems;
|
|
1089
|
+
}
|
|
1090
|
+
for (const keyword of FIX_LOOP_AUTHORITY_KEYWORDS) {
|
|
1091
|
+
if (!authoritySection.includes(keyword)) {
|
|
1092
|
+
problems.push(FIX_LOOP_AUTHORITY_REL + ' 修复回路段缺关键词: ' + keyword);
|
|
1093
|
+
}
|
|
1094
|
+
}
|
|
1095
|
+
if (authoritySection.includes('advance')) {
|
|
1096
|
+
problems.push(FIX_LOOP_AUTHORITY_REL + ' 修复回路段不得把 advance 作为正常路径');
|
|
1097
|
+
}
|
|
1098
|
+
let hasForbiddenForm = false;
|
|
1099
|
+
for (const line of authoritySection.split(/\r?\n/)) {
|
|
1100
|
+
if (line.includes('直接') && line.includes('exit') && /禁止|不得|会被 BLOCKED/.test(line)) hasForbiddenForm = true;
|
|
1101
|
+
if (line.includes('直接') && line.includes('exit') && !/禁止|不得|会被 BLOCKED/.test(line)) {
|
|
1102
|
+
problems.push(FIX_LOOP_AUTHORITY_REL + ' 修复回路段不得把直接 exit 源节点收场作为正常路径: ' + line.trim());
|
|
1103
|
+
}
|
|
1104
|
+
}
|
|
1105
|
+
if (!hasForbiddenForm) {
|
|
1106
|
+
problems.push(FIX_LOOP_AUTHORITY_REL + ' 修复回路段缺「禁止直接 exit 源节点收场」的显式断言(原册内断言未随迁)');
|
|
1107
|
+
}
|
|
1108
|
+
// 正文唯一:权威段落整段回流任一册即红(块级跨距 ≥ FIX_LOOP_BLOCK_SPAN)。比对面取**整册正文**:
|
|
1109
|
+
// 复制回流的落点不限于同名小节(换个标题贴进别处同样算第二份正文)。
|
|
1110
|
+
for (const [rel, text] of books) {
|
|
1111
|
+
const span = longestCommonSpan(authoritySection, text);
|
|
1112
|
+
if (span.length >= FIX_LOOP_BLOCK_SPAN) {
|
|
1113
|
+
problems.push(rel + ' 出现 ' + FIX_LOOP_AUTHORITY_REL + ' 的第二份正文(该段正文仅一处;连续同文 '
|
|
1114
|
+
+ span.length + ' 字符 ≥ ' + FIX_LOOP_BLOCK_SPAN + ')');
|
|
1115
|
+
}
|
|
1116
|
+
}
|
|
1117
|
+
return problems;
|
|
1118
|
+
}
|
|
1119
|
+
|
|
1120
|
+
// 技能树正文里的**相对路径引用必须解析得到**(场景 184 附;纯函数 + 合成输入可驱动):本轮
|
|
1121
|
+
// `GUIDANCE.md` → `reference/entry-detail.md` 的改名曾造成 5 册死引用而**零红灯**——技能树正文的
|
|
1122
|
+
// 相对引用此前没有任何机检覆盖(只能靠人工/子代理顺带发现)。判据面刻意收窄到技能树内的
|
|
1123
|
+
// `reference/**.md|json` 相对引用。
|
|
1124
|
+
// **解析基准 = 引用处所在册的册根**(不是「任何册都按入口册册根解析」):裸形态 `reference/<file>`
|
|
1125
|
+
// 是**册根相对**形态,故候选 = ① 引用处文件所在目录(入口册 `SKILL.md` 与入口册 `reference/**`
|
|
1126
|
+
// 展开面正是这一形态);② 引用处**所在册的册根**(`<册>/reference/<file>`,覆盖展开面文件引用
|
|
1127
|
+
// 同册兄弟文件的写法)。跨册引用必须写**显式形态** `../flow-comet/reference/<file>`(先例 =
|
|
1128
|
+
// `flow-comet-compose` 引 `../flow-comet/reference/workflow-protocol.json`),只对该形态接受
|
|
1129
|
+
// **入口册册根**这一额外候选——裸形态在节点册里因此**解析不到即红**:节点册没有 `reference/`
|
|
1130
|
+
// 目录,而旧实现给每个引用合成「入口册册根」第二候选,把节点册里的裸指针一律静默判绿
|
|
1131
|
+
//(**为抓这一类而写的锚放过了这一类的实例**)。
|
|
1132
|
+
// `flow-kit/**` 一类**技能树外**引用不在判据面(其根随安装形态变化,由项目根决定)。
|
|
1133
|
+
export const SKILL_TREE_REFERENCE_RE = /(?<!flow-kit\/)(?<![\w./-])(?:\.\.\/flow-comet\/)?reference\/[A-Za-z0-9._-]+\.(?:md|json)/g;
|
|
1134
|
+
export const SKILL_TREE_ENTRY_BOOK = 'flow-comet';
|
|
1135
|
+
export const SKILL_TREE_EXPLICIT_REFERENCE_PREFIX = '../flow-comet/';
|
|
1136
|
+
export function skillTreeReferenceCandidates(rel, ref) {
|
|
1137
|
+
const tail = ref.replace(/^\.\.\/flow-comet\//, '');
|
|
1138
|
+
const explicit = ref.startsWith(SKILL_TREE_EXPLICIT_REFERENCE_PREFIX);
|
|
1139
|
+
// 裸形态按**引用处所在册的册根**解析;跨册解析只对显式形态开放(收窄点)。
|
|
1140
|
+
const crossBookRoot = explicit ? SKILL_TREE_ENTRY_BOOK : rel.split('/')[0];
|
|
1141
|
+
return [
|
|
1142
|
+
path.posix.normalize(path.posix.join(path.posix.dirname(rel), ref)),
|
|
1143
|
+
path.posix.normalize(path.posix.join(crossBookRoot, tail)),
|
|
1144
|
+
];
|
|
1145
|
+
}
|
|
1146
|
+
export function skillTreeReferenceProblems(docs, skillsRoot) {
|
|
1147
|
+
const problems = [];
|
|
1148
|
+
for (const [rel, text] of docs) {
|
|
1149
|
+
for (const ref of new Set(text.match(SKILL_TREE_REFERENCE_RE) ?? [])) {
|
|
1150
|
+
const candidates = skillTreeReferenceCandidates(rel, ref);
|
|
1151
|
+
if (!candidates.some((candidate) => fs.existsSync(path.join(skillsRoot, candidate)))) {
|
|
1152
|
+
problems.push(rel + ' 的相对路径引用解析不到: ' + ref + '(候选: ' + candidates.join(' / ') + ')');
|
|
1153
|
+
}
|
|
1154
|
+
}
|
|
1155
|
+
}
|
|
1156
|
+
return problems;
|
|
1157
|
+
}
|
|
1158
|
+
|
|
1159
|
+
// **成对展开文件的指针不得指错**(场景 184 附 2;纯函数 + 合成输入可驱动):本仓是「`SKILL.md` 手写区 +
|
|
1160
|
+
// **同目录同名 `GUIDANCE.md` 展开版**」的成对形态——册首注释里的**裸文件名**指本册自己那份。修"死引用"
|
|
1161
|
+
// 的过程里四册曾被改成指向**入口册**的展开版(`../flow-comet/reference/entry-detail.md`):目标确实存在、
|
|
1162
|
+
// 上面那条解析判据全绿,但它**指错了文档**,各册展开版里的独有内容从此再无入口可读——「**能解析 ≠ 指对了**」。
|
|
1163
|
+
// 判据 = ① 同目录有同名 `GUIDANCE.md` 的册 ⇒ 指针必须是裸文件名 `GUIDANCE.md`(本册那份);
|
|
1164
|
+
// ② 入口册(无同名展开版,展开版为 `reference/entry-detail.md`)⇒ **唯一例外**,指针必须是该文件;
|
|
1165
|
+
// ③ 既无同名展开版又非入口册的册 ⇒ 不允许出现该指针(在册里指谁都是指错)。
|
|
1166
|
+
// 取目标用**注释整句的捕获组**(不是"是否含 `GUIDANCE.md` 子串")——裸子串判据会被同文件其它
|
|
1167
|
+
// 上下文满足而恒真空过,下文的反向构造即证「换成别处的展开版必红」。
|
|
1168
|
+
export const PAIRED_GUIDANCE_ENTRY_REL = 'flow-comet/SKILL.md';
|
|
1169
|
+
export const PAIRED_GUIDANCE_ENTRY_TARGET = 'reference/entry-detail.md';
|
|
1170
|
+
export const PAIRED_GUIDANCE_POINTER_RE = /<!--\s*手写区详细协议见\s*([^\s()]+)(可选阅读)\s*-->/g;
|
|
1171
|
+
export function pairedGuidancePointerProblems(docs, skillsRoot) {
|
|
1172
|
+
const problems = [];
|
|
1173
|
+
for (const [rel, text] of docs) {
|
|
1174
|
+
if (!rel.endsWith('/SKILL.md')) continue;
|
|
1175
|
+
const dir = path.posix.dirname(rel);
|
|
1176
|
+
if (dir.includes('/')) continue; // 只判册根层(`<册>/SKILL.md`)
|
|
1177
|
+
const targets = [...text.matchAll(PAIRED_GUIDANCE_POINTER_RE)].map((match) => match[1]);
|
|
1178
|
+
const hasOwnGuidance = fs.existsSync(path.join(skillsRoot, dir, 'GUIDANCE.md'));
|
|
1179
|
+
if (targets.length === 0) {
|
|
1180
|
+
if (hasOwnGuidance) {
|
|
1181
|
+
problems.push(rel + ' 缺「手写区详细协议见 …」指针(同目录有 GUIDANCE.md ⇒ 指针须在场且指向本册)');
|
|
1182
|
+
}
|
|
1183
|
+
continue;
|
|
1184
|
+
}
|
|
1185
|
+
if (targets.length > 1) {
|
|
1186
|
+
problems.push(rel + ' 的「手写区详细协议见 …」指针出现 ' + targets.length + ' 处(只允许 1 处)');
|
|
1187
|
+
}
|
|
1188
|
+
const expected = hasOwnGuidance ? 'GUIDANCE.md'
|
|
1189
|
+
: (rel === PAIRED_GUIDANCE_ENTRY_REL ? PAIRED_GUIDANCE_ENTRY_TARGET : null);
|
|
1190
|
+
if (expected === null) {
|
|
1191
|
+
problems.push(rel + ' 的「手写区详细协议见 …」指针指向 ' + targets.join(' / ')
|
|
1192
|
+
+ ',但该册既无同目录 GUIDANCE.md 也非入口册(无配对展开版即不得保留指针)');
|
|
1193
|
+
continue;
|
|
1194
|
+
}
|
|
1195
|
+
for (const target of targets) {
|
|
1196
|
+
if (target !== expected) {
|
|
1197
|
+
problems.push(rel + ' 的「手写区详细协议见 ' + target + '」指错文档(应为 ' + expected + ')');
|
|
1198
|
+
}
|
|
1199
|
+
}
|
|
1200
|
+
}
|
|
1201
|
+
return problems;
|
|
1202
|
+
}
|
|
1203
|
+
|
|
1204
|
+
// CC 行判级升格 + 三平台 cwd 语义对照(场景 184 的 ⑦ 使用;纯函数 + 合成文本面可驱动):判级由
|
|
1205
|
+
// 「未覆盖」升为「证实」后,落地形态由**两处**承载——入口册(用户可见总表 + 已知边界旁的三平台
|
|
1206
|
+
// `cwd` 对照,7 条字面量是能力契约锚,本批明文保留)与 `reference/platform-facts.md`(原
|
|
1207
|
+
// `reference/worktree-notes.md` 的同一批整句随文件移出技能树后**逐字搬入**的新落点)。判据:
|
|
1208
|
+
// 「两处正文在场 + 其余册零回流(唯一处)+ 旧「未覆盖」判级句零残留」。
|
|
1209
|
+
export const IDENTITY_UPGRADE_ENTRY_PHRASES = [
|
|
1210
|
+
'| ① 写权限 | 载荷 `agent_id` / `agent_type`——**证实**(真机实测:子代理载荷含二者、主会话载荷不含;与 Codex 同一判据) |',
|
|
1211
|
+
'**三平台 `cwd` 语义对照(真机实测新增的精确事实 · 「身份先于路径」的精确理由)**',
|
|
1212
|
+
'| **Claude Code** | **子代理的工作目录**(`…\\.claude\\worktrees\\<agent-id>`) | **路径判定是正确的** |',
|
|
1213
|
+
'| **Codex** | **恒等于会话根**(子代理在 worktree 写入而 `cwd` 仍是主工程) | **路径判定必错** |',
|
|
1214
|
+
'| **dsh** | 载荷**无** `cwd`(桥接另读会话 header cwd) | 路径判定**不适用** |',
|
|
1215
|
+
'三平台 `cwd` 语义各不相同(正确 / 恒错 / 无)——只有身份判据是三平台同义的',
|
|
1216
|
+
'非 `bypassPermissions` 权限模式**均未覆盖**',
|
|
1217
|
+
];
|
|
1218
|
+
export const IDENTITY_UPGRADE_AUTHORITY_PHRASES = [
|
|
1219
|
+
'载荷 `agent_id` / `agent_type`——**证实**(真机实测:子代理载荷含二者、主会话载荷不含;与 Codex 同一判据)',
|
|
1220
|
+
'**三平台 `cwd` 语义对照(真机实测新增的精确事实 · 「身份先于路径」的精确理由)**——同为载荷 `cwd`,三平台语义各不相同;下表**三行各自独立**,缺一行即口径残缺:',
|
|
1221
|
+
'| **Claude Code** | **子代理的工作目录**(`…\\.claude\\worktrees\\<agent-id>`) | **路径判定是正确的** |',
|
|
1222
|
+
'| **Codex** | **恒等于会话根**(子代理在 worktree 写入而 `cwd` 仍是主工程) | **路径判定必错** |',
|
|
1223
|
+
'| **dsh** | 载荷**无** `cwd`(桥接另读会话 header cwd) | 路径判定**不适用** |',
|
|
1224
|
+
'三平台 `cwd` 语义各不相同(正确 / 恒错 / 无)——只有身份判据是三平台同义的',
|
|
1225
|
+
];
|
|
1226
|
+
export const IDENTITY_UPGRADE_STALE_PHRASES = ['该次实测只覆盖 Codex', '真机会话复核待补', 'CC 隔离树的真实落点探针待补'];
|
|
1227
|
+
export function identityUpgradeProblems({ entry, facts, others }) {
|
|
1228
|
+
const problems = [];
|
|
1229
|
+
for (const phrase of IDENTITY_UPGRADE_ENTRY_PHRASES) {
|
|
1230
|
+
if (!entry.includes(phrase)) {
|
|
1231
|
+
problems.push('flow-comet/SKILL.md 缺「CC 行升格 / 三平台 cwd 对照」判别句式:' + phrase.slice(0, 40) + '…');
|
|
1232
|
+
}
|
|
1233
|
+
}
|
|
1234
|
+
for (const phrase of IDENTITY_UPGRADE_AUTHORITY_PHRASES) {
|
|
1235
|
+
if (!facts.includes(phrase)) {
|
|
1236
|
+
problems.push(PLATFORM_FACTS_REL + ' 缺「CC 行升格 / 三平台 cwd 对照」判别句式:' + phrase.slice(0, 40) + '…');
|
|
1237
|
+
}
|
|
1238
|
+
}
|
|
1239
|
+
const carried = [...IDENTITY_UPGRADE_ENTRY_PHRASES, ...IDENTITY_UPGRADE_AUTHORITY_PHRASES];
|
|
1240
|
+
for (const [rel, text] of others) {
|
|
1241
|
+
for (const phrase of carried) {
|
|
1242
|
+
if (text.includes(phrase)) {
|
|
1243
|
+
problems.push(rel + ' 回流了 cwd 对照 / CC 判级句(唯一处 = 入口册 + 平台事实册):'
|
|
1244
|
+
+ phrase.slice(0, 40) + '…');
|
|
1245
|
+
}
|
|
1246
|
+
}
|
|
1247
|
+
}
|
|
1248
|
+
for (const [rel, text] of [['flow-comet/SKILL.md', entry], [PLATFORM_FACTS_REL, facts]]) {
|
|
1249
|
+
for (const stale of IDENTITY_UPGRADE_STALE_PHRASES) {
|
|
1250
|
+
if (text.includes(stale)) {
|
|
1251
|
+
problems.push(rel + ' 残留 CC 行旧「未覆盖」判级表述:' + stale);
|
|
1252
|
+
}
|
|
1253
|
+
}
|
|
1254
|
+
}
|
|
1255
|
+
return problems;
|
|
1256
|
+
}
|
|
1257
|
+
|
|
1258
|
+
// 平台事实(场景 184 的 ⑤ / ⑦ 使用;纯函数 + 合成输入可驱动):Codex 平台事实与支持面的判别句
|
|
1259
|
+
// 随 `worktree-notes.md` 移出技能树后**唯一权威处** = `flow-comet/reference/platform-facts.md`
|
|
1260
|
+
//(T07 已按「逐字搬运,不重写」搬入)。判据三侧:① 权威处在场(判别句 + 旧独断句只允许被反驳
|
|
1261
|
+
// 引用形态 + 适用范围限定 + fail-open / 未闭合的现判据);② 各引用册**指针在场**;③ **证据正文
|
|
1262
|
+
// 不回流册子**(权威处唯一——原逐字锁「多处各持一份」的方向已反转)。
|
|
1263
|
+
// `PLATFORM_FACTS_ONLY_PHRASES` 是**证据与过程记录**类判别句(按 ADR-016 的「证据与判级随平台事实
|
|
1264
|
+
// 移走」分类):它们只允许出现在权威处,回流任一册即红。
|
|
1265
|
+
export const PLATFORM_FACTS_ONLY_PHRASES = [
|
|
1266
|
+
'**旧结论(实测 2026-08-13;证据已不可复核',
|
|
1267
|
+
'`codex features list` 可查',
|
|
1268
|
+
'本机真实交互式会话日志中记录到 `spawn_agent` / `wait_agent` / `close_agent` 的实际调用',
|
|
1269
|
+
'**静态喂测(独立复现)**',
|
|
1270
|
+
'**hook 触发条件**:隔离 `CODEX_HOME` 无持久信任时默认 headless **不执行**项目 hook',
|
|
1271
|
+
'实测 3/21;补 `--dangerously-bypass-approvals-and-sandbox` 后 5/5',
|
|
1272
|
+
'**交互式 Codex 实测口径',
|
|
1273
|
+
];
|
|
1274
|
+
export function platformFactsAuthorityProblems(rel, facts, pointerBooks) {
|
|
1275
|
+
const problems = [];
|
|
1276
|
+
const refutedClaim = '「Codex 不能委派 / 不使用并行委托」';
|
|
1277
|
+
for (const keyword of ['multi_agent', '机制缺口']) {
|
|
1278
|
+
if (!facts.includes(keyword)) {
|
|
1279
|
+
problems.push(rel + ' 缺「' + keyword + '」(Codex 平台事实与支持面判别锚)');
|
|
1280
|
+
}
|
|
1281
|
+
}
|
|
1282
|
+
// 旧独断句只允许以被反驳引用的完整形态出现:剥离该引用后不得再有残句。
|
|
1283
|
+
if (facts.split(refutedClaim).join('').includes('不使用并行委托')) {
|
|
1284
|
+
problems.push(rel + ' 残留旧独断句「不使用并行委托」(非被反驳引用形态)');
|
|
1285
|
+
}
|
|
1286
|
+
if (!facts.includes('不得外推') && !facts.includes('不可外推')) {
|
|
1287
|
+
problems.push(rel + ' 缺「不得外推 / 不可外推」适用范围限定');
|
|
1288
|
+
}
|
|
1289
|
+
for (const keyword of ['fail-open', '未闭合']) {
|
|
1290
|
+
if (!facts.includes(keyword)) {
|
|
1291
|
+
problems.push(rel + ' 缺「' + keyword + '」(Codex/worktree 订正限定)');
|
|
1292
|
+
}
|
|
1293
|
+
}
|
|
1294
|
+
for (const [stale, label] of [
|
|
1295
|
+
['受支持的工作流仍是串行执行', '旧独断句'],
|
|
1296
|
+
['写入仍会被协调者白名单拦截', '旧过宽句'],
|
|
1297
|
+
]) {
|
|
1298
|
+
if (facts.includes(stale)) problems.push(rel + ' 残留「' + stale + '」' + label);
|
|
1299
|
+
}
|
|
1300
|
+
for (const phrase of PLATFORM_FACTS_ONLY_PHRASES) {
|
|
1301
|
+
if (!facts.includes(phrase)) {
|
|
1302
|
+
problems.push(rel + ' 缺证据与过程记录判别句:' + phrase.slice(0, 40) + '…');
|
|
1303
|
+
}
|
|
1304
|
+
}
|
|
1305
|
+
for (const [bookRel, text] of pointerBooks) {
|
|
1306
|
+
if (!text.includes('reference/platform-facts.md')) {
|
|
1307
|
+
problems.push(bookRel + ' 缺「reference/platform-facts.md」条件句(平台事实的引用册指针不在场)');
|
|
1308
|
+
}
|
|
1309
|
+
for (const phrase of PLATFORM_FACTS_ONLY_PHRASES) {
|
|
1310
|
+
if (text.includes(phrase)) {
|
|
1311
|
+
problems.push(bookRel + ' 回流了平台事实的证据正文:' + phrase.slice(0, 40) + '…(权威处唯一)');
|
|
1312
|
+
}
|
|
1313
|
+
}
|
|
1314
|
+
if (text.includes('写入会被协调者白名单拦截')) {
|
|
1315
|
+
problems.push(bookRel + ' 残留「写入会被协调者白名单拦截」旧过宽句');
|
|
1316
|
+
}
|
|
1317
|
+
}
|
|
1318
|
+
return problems;
|
|
1319
|
+
}
|
|
1320
|
+
|
|
1321
|
+
// 模板权威声明(场景 184 的 ② 使用;纯函数 + 合成文档面可驱动):ADR-016 把原「14 册同持整句」
|
|
1322
|
+
// 的逐字锁重定向为「单一权威 + 指针在场 + 正文唯一」三件套。本函数是**单一实现**——真实判据与
|
|
1323
|
+
// 反向构造探针共用,逐条对应重定向后的一侧:
|
|
1324
|
+
// · 指针在场:每份文档须含模板权威锚句,句内按序组合五个锚点(整句语义组合,防拆句 / 半句);
|
|
1325
|
+
// · 该句只在 1 处(册内一侧):同一文档出现第二处锚行即红(重复回潮的同册形态);
|
|
1326
|
+
// · 单一权威:持锚行必须点名 `flow-kit/templates/**`——段形权威只能指向这一个来源;
|
|
1327
|
+
// · 正文唯一(声明块的**正文部分**):判据面 = 锚行所在的 `>` 块**减去锚行本身**——锚行是全册
|
|
1328
|
+
// **按形态要求必须持有**的指针句(「本节点」9 册 / 「本技能」5 册逐字同文属**设计要求**,不是
|
|
1329
|
+
// 重复),把它算进判据面必然要么假红要么恒真;块内锚行之外的正文行才是「第二份正文」的入口。
|
|
1330
|
+
// 阈值**按对派生自受保护内容**:一对正文以**较短一侧的实际块长**为界——只要一侧的正文整段
|
|
1331
|
+
// (或更长)出现在另一侧即红,两侧各写各的措辞不误伤。**旧写死阈值 400 的教训**(`LESSONS`
|
|
1332
|
+
// 候选取证):旧判据面含锚行且阈值写死 400,而实测块长只有 109 / 211(入口册与
|
|
1333
|
+
// `reference/entry-detail.md` 曾各持同一段 211 字符块 = 锚行 + archive 读法行)⇒ 锚**数学
|
|
1334
|
+
// 不可触发**、真实重复就在眼前却恒绿(Coverage Illusion 型假绿);阈值改为从受保护内容派生
|
|
1335
|
+
// 后,该对真实重复当场变红,本批同批把重复收成「一处 + 指针」。
|
|
1336
|
+
export const TEMPLATE_AUTHORITY_SKILLS = [
|
|
1337
|
+
'flow-comet-open', 'flow-comet-design', 'flow-comet-plan', 'flow-comet-execute',
|
|
1338
|
+
'flow-comet-subagent-execute', 'flow-comet-review', 'flow-comet-verify', 'flow-comet-archive',
|
|
1339
|
+
'flow-comet-task',
|
|
1340
|
+
'flow-comet-change', 'flow-comet-requirement', 'flow-comet-dev', 'flow-comet-test',
|
|
1341
|
+
'flow-comet-integration',
|
|
1342
|
+
];
|
|
1343
|
+
export const TEMPLATE_AUTHORITY_ANCHORS = [
|
|
1344
|
+
'唯一权威 = ', '`flow-kit/templates/**`', '是历史证据', '不是模板来源', '上一轮就是这么写的',
|
|
1345
|
+
];
|
|
1346
|
+
// 整句形态**专有**的展开锚点(短指针形态不含):出现任一条即要求整句按序齐备(半句 / 拆句防护)。
|
|
1347
|
+
export const TEMPLATE_AUTHORITY_EXPANSION_ANCHORS = [
|
|
1348
|
+
'唯一权威 = ', '是历史证据', '不是模板来源', '上一轮就是这么写的',
|
|
1349
|
+
];
|
|
1350
|
+
// 「模板权威」声明的**段落切片**:锚行所在的那一段连续引用行(`>` 块)——正文唯一判据的判据面。
|
|
1351
|
+
export function templateAuthorityParagraphs(text) {
|
|
1352
|
+
const lines = text.split(/\r?\n/);
|
|
1353
|
+
const out = [];
|
|
1354
|
+
for (let i = 0; i < lines.length; i += 1) {
|
|
1355
|
+
if (!lines[i].includes('模板权威')) continue;
|
|
1356
|
+
let start = i;
|
|
1357
|
+
while (start > 0 && lines[start - 1].startsWith('>')) start -= 1;
|
|
1358
|
+
let end = i;
|
|
1359
|
+
while (end + 1 < lines.length && lines[end + 1].startsWith('>')) end += 1;
|
|
1360
|
+
out.push(lines.slice(start, end + 1).join('\n'));
|
|
1361
|
+
}
|
|
1362
|
+
return out;
|
|
1363
|
+
}
|
|
1364
|
+
// 声明块的**正文部分** = 块内锚行之外的引用行(锚行是每册必须逐字持有的指针句,见上;空串 =
|
|
1365
|
+
// 该册只有锚行一行,正文唯一判据对它不发声——「只持指针」是设计要求,不是重复)。
|
|
1366
|
+
export function templateAuthorityBody(paragraph) {
|
|
1367
|
+
return paragraph.split('\n').filter((line) => !line.includes('模板权威')).join('\n');
|
|
1368
|
+
}
|
|
1369
|
+
// 最长连续同文跨距(返回该片段本身;空串 = 无重合)。
|
|
1370
|
+
export function longestCommonSpan(a, b) {
|
|
1371
|
+
const left = String(a);
|
|
1372
|
+
const right = String(b);
|
|
1373
|
+
let best = '';
|
|
1374
|
+
const dp = new Array(right.length + 1).fill(0);
|
|
1375
|
+
for (let i = 1; i <= left.length; i += 1) {
|
|
1376
|
+
let prev = 0;
|
|
1377
|
+
for (let j = 1; j <= right.length; j += 1) {
|
|
1378
|
+
const tmp = dp[j];
|
|
1379
|
+
if (left[i - 1] === right[j - 1]) {
|
|
1380
|
+
dp[j] = prev + 1;
|
|
1381
|
+
if (dp[j] > best.length) best = left.slice(i - dp[j], i);
|
|
1382
|
+
} else {
|
|
1383
|
+
dp[j] = 0;
|
|
1384
|
+
}
|
|
1385
|
+
prev = tmp;
|
|
1386
|
+
}
|
|
1387
|
+
}
|
|
1388
|
+
return best;
|
|
1389
|
+
}
|
|
1390
|
+
export function templateAuthorityProblems(docs) {
|
|
1391
|
+
const problems = [];
|
|
1392
|
+
const paragraphs = [];
|
|
1393
|
+
for (const [rel, text] of docs) {
|
|
1394
|
+
const lines = text.split(/\r?\n/).filter((line) => line.includes('模板权威'));
|
|
1395
|
+
if (lines.length === 0) {
|
|
1396
|
+
problems.push(rel + ' 缺模板权威整句声明(正向权威 + 反向历史证据组合缺失)');
|
|
1397
|
+
continue;
|
|
1398
|
+
}
|
|
1399
|
+
if (lines.length > 1) {
|
|
1400
|
+
problems.push(rel + ' 模板权威锚句出现 ' + lines.length + ' 处(同一册只允许 1 处)');
|
|
1401
|
+
}
|
|
1402
|
+
const line = lines[0];
|
|
1403
|
+
// 指针在场(两形态皆算、缺一即红):① **短指针形态**——点名唯一权威 `flow-kit/templates/**`;
|
|
1404
|
+
// ② **整句形态**——锚点按序组合(正向权威 + 反向历史证据)。ADR-016 的方向是「13 册留短指针」,
|
|
1405
|
+
// 故两种形态都必须算通过(当前 14 册为整句形态、入口册与入口展开册为短指针形态,判据对**两种
|
|
1406
|
+
// 布局都成立**——书籍侧若按 ADR 收敛成短指针,本锚不会因此变红)。
|
|
1407
|
+
if (!line.includes('`flow-kit/templates/**`')) {
|
|
1408
|
+
problems.push(rel + ' 的模板权威行未指向 `flow-kit/templates/**`(段形权威被指到别处)');
|
|
1409
|
+
}
|
|
1410
|
+
if (!line.includes('唯一权威')) {
|
|
1411
|
+
problems.push(rel + ' 的模板权威行未声明「唯一权威」(指针未指向唯一来源)');
|
|
1412
|
+
}
|
|
1413
|
+
// 半句 / 拆句防护:一旦行内出现**整句形态专有**的展开锚点(历史证据 / 反向声明 / 收口句),
|
|
1414
|
+
// 五个锚点必须按序齐备(不得只留半句)——短指针形态只点名唯一权威,不触发本项。
|
|
1415
|
+
const expansionAnchors = TEMPLATE_AUTHORITY_EXPANSION_ANCHORS.filter((anchor) => line.includes(anchor));
|
|
1416
|
+
if (expansionAnchors.length > 0) {
|
|
1417
|
+
let cursor = -1;
|
|
1418
|
+
for (const anchor of TEMPLATE_AUTHORITY_ANCHORS) {
|
|
1419
|
+
const at = line.indexOf(anchor, cursor + 1);
|
|
1420
|
+
if (at < 0) {
|
|
1421
|
+
problems.push(rel + ' 模板权威整句缺「' + anchor + '」(整句语义组合)');
|
|
1422
|
+
} else {
|
|
1423
|
+
cursor = at;
|
|
1424
|
+
}
|
|
1425
|
+
}
|
|
1426
|
+
}
|
|
1427
|
+
if (text.includes('archive 是模板来源')) {
|
|
1428
|
+
problems.push(rel + ' 含「archive 是模板来源」旧反向声明');
|
|
1429
|
+
}
|
|
1430
|
+
for (const paragraph of templateAuthorityParagraphs(text)) {
|
|
1431
|
+
paragraphs.push([rel, templateAuthorityBody(paragraph)]);
|
|
1432
|
+
}
|
|
1433
|
+
}
|
|
1434
|
+
for (let i = 0; i < paragraphs.length; i += 1) {
|
|
1435
|
+
for (let j = i + 1; j < paragraphs.length; j += 1) {
|
|
1436
|
+
const [relA, bodyA] = paragraphs[i];
|
|
1437
|
+
const [relB, bodyB] = paragraphs[j];
|
|
1438
|
+
if (relA === relB || bodyA === '' || bodyB === '') continue;
|
|
1439
|
+
const span = longestCommonSpan(bodyA, bodyB);
|
|
1440
|
+
// 阈值**按对派生自受保护内容**(较短一侧的实际正文块长):一侧的正文整段出现在另一侧即红。
|
|
1441
|
+
const derived = Math.min(bodyA.length, bodyB.length);
|
|
1442
|
+
if (span.length >= derived) {
|
|
1443
|
+
problems.push('模板权威声明出现第二份展开正文(' + relA + ' ↔ ' + relB
|
|
1444
|
+
+ ',连续同文 ' + span.length + ' 字符 ≥ 较短一侧正文块长 ' + derived + ')');
|
|
1445
|
+
}
|
|
1446
|
+
}
|
|
1447
|
+
}
|
|
1448
|
+
return problems;
|
|
1449
|
+
}
|
|
1450
|
+
// 作者面完备性判据(纯函数;真实判据与反向构造探针共用):实际持「模板权威」声明的技能树文本
|
|
1451
|
+
// 必须**登记**在受检面(`TEMPLATE_AUTHORITY_SKILLS` + 入口册两件)里;未登记 ⇒ 报「未登记的
|
|
1452
|
+
// 权威声明」,报错指向真实动作(登记新册)。**单向判定**:受检面成员**缺**声明由
|
|
1453
|
+
// `templateAuthorityProblems` 的逐份「缺模板权威整句声明」覆盖,故不需要计数相等——计数相等
|
|
1454
|
+
// 正是同文件别处判据注释明确反对的「以总量取红」自锁探针(合法扩册先撞红,报错指向锚)。
|
|
1455
|
+
export function templateAuthorityRegistrationProblems(actualHolders, expectedHolders) {
|
|
1456
|
+
const problems = [];
|
|
1457
|
+
for (const rel of actualHolders) {
|
|
1458
|
+
if (!expectedHolders.includes(rel)) {
|
|
1459
|
+
problems.push(rel + ' 持有「模板权威」声明但未登记在受检面(新增册须同批登记 TEMPLATE_AUTHORITY_SKILLS)');
|
|
1460
|
+
}
|
|
1461
|
+
}
|
|
1462
|
+
return problems;
|
|
1463
|
+
}
|
|
1464
|
+
|
|
1465
|
+
// ——— 7 字段集合的文本 ↔ 实现一致锚(场景 184 使用) ———
|
|
1466
|
+
// 唯一权威 = 引擎的 `TASK7_REQUIRED` 常量(plan 出口判据与执行期 `replan` 判据的共同集合来源;所在
|
|
1467
|
+
// 模块由导出符号反查,锚里不写文件名)。锚**从常量派生**集合后再与技能树文本逐处对账:任一处枚举
|
|
1468
|
+
// 与判据分叉即红——「两册三处而两级基线全绿」的成因正是「同一口径另写一份、且没有断言绑定」;锚里
|
|
1469
|
+
// **不得把集合再抄一遍**(抄一遍就是又造一处同口径表达)。
|
|
1470
|
+
export const TASK7_AUTHORITY_CONSTANT = 'TASK7_REQUIRED';
|
|
1471
|
+
// 7 字段 BLOCKED 文案的**渲染片段**:文案落点由该片段在引擎面内反查。常量已下沉到最底层模块——
|
|
1472
|
+
// 「权威常量所在模块」与「渲染文案的模块」不再同址,落点判定不得再假定两者合一。
|
|
1473
|
+
export const TASK7_MESSAGE_ANCHOR = '任务缺 7 字段(';
|
|
1474
|
+
// 「7 字段」标记(中文 / 英文两形态):标记与枚举**同行**是当前唯一形态;标记行不带枚举(指针形态,
|
|
1475
|
+
// 如「集合见上表」)不算缺席——判据只对「标记 + 枚举」同场的行发声。
|
|
1476
|
+
export const TASK7_MARKER_RE = /7\s*个?\s*字段|7 required fields|7-field set/;
|
|
1477
|
+
// 斜杠枚举形态(`` `name` / `read_files` / … ``;同时覆盖无引号的裸形态)。
|
|
1478
|
+
export const TASK7_RUN_RE = /(?:`?[a-z][a-z_]*`?[ \t]*\/[ \t]*)+`?[a-z][a-z_]*`?/g;
|
|
1479
|
+
// **已知站点基线**(每站 = 该枚举行上独有的判别句式,即站点的身份):锚**逐站点**断言「该站点仍持与派生
|
|
1480
|
+
// 集合一致的枚举」——任一处丢失(改成指针 / 删掉该行 / 抽掉枚举)即红;**新增站点不受限**(自动进入逐处
|
|
1481
|
+
// 对账,不因新增而红)。身份**不用 `file:line`**:行号随无关编辑漂移,会把「无关改动」误判成「站点丢失」
|
|
1482
|
+
// (同族自锁——报错方向指向锚而非真实原因)。**站点集合是处数的唯一事实源**(无独立处数常量)。
|
|
1483
|
+
export const TASK7_KNOWN_SITES = [
|
|
1484
|
+
{ rel: 'flow-comet-plan/SKILL.md', anchor: '| TASK.md | 至少一个' },
|
|
1485
|
+
{ rel: 'flow-comet-plan/SKILL.md', anchor: 'Populate 7 required fields per task' },
|
|
1486
|
+
{ rel: 'flow-comet-plan/SKILL.md', anchor: 'the 7-field set' },
|
|
1487
|
+
{ rel: 'flow-comet-task/SKILL.md', anchor: '**每任务 7 字段**' },
|
|
1488
|
+
];
|
|
1489
|
+
// 探针期望哨兵:该探针要求**零问题**(合法新增站点不得被判违规)——与「必报某问题」的期望区分。
|
|
1490
|
+
export const TASK7_ZERO_PROBLEMS = '(该探针要求零问题)';
|
|
1491
|
+
|
|
1492
|
+
// 从实现侧常量**派生** 7 字段集合(null = 权威常量缺席 ⇒ 由调用方报红,锚里不写第二份集合)。
|
|
1493
|
+
export function task7RequiredSet(guardSrc) {
|
|
1494
|
+
const match = guardSrc.match(new RegExp('const\\s+' + TASK7_AUTHORITY_CONSTANT + '\\s*=\\s*\\[([^\\]]*)\\]'));
|
|
1495
|
+
if (!match) return null;
|
|
1496
|
+
const fields = match[1].split(',')
|
|
1497
|
+
.map((part) => part.trim().replace(/^['"]|['"]$/g, ''))
|
|
1498
|
+
.filter((part) => part !== '');
|
|
1499
|
+
return fields.length > 0 ? fields : null;
|
|
1500
|
+
}
|
|
1501
|
+
|
|
1502
|
+
// 值恰好等于权威集合的常量名(断言 BLOCKED 文案**从常量派生**用——文案里再写字面集合即第二处同口径表达)。
|
|
1503
|
+
export function task7ConstantNames(src, fieldSet) {
|
|
1504
|
+
const names = [];
|
|
1505
|
+
const re = /const\s+([A-Za-z_$][\w$]*)\s*=\s*\[([^\]]*)\];/g;
|
|
1506
|
+
let match;
|
|
1507
|
+
while ((match = re.exec(src)) !== null) {
|
|
1508
|
+
const fields = match[2].split(',')
|
|
1509
|
+
.map((part) => part.trim().replace(/^['"]|['"]$/g, ''))
|
|
1510
|
+
.filter((part) => part !== '');
|
|
1511
|
+
if (fields.length === fieldSet.length && fields.every((field, index) => field === fieldSet[index])) {
|
|
1512
|
+
names.push(match[1]);
|
|
1513
|
+
}
|
|
1514
|
+
}
|
|
1515
|
+
return names;
|
|
1516
|
+
}
|
|
1517
|
+
|
|
1518
|
+
// 文案落点(判据形态:不写文件名):引擎面内**渲染**该 BLOCKED 文案的模块——注释层引用不是渲染点
|
|
1519
|
+
// (`engineCodeText` 去注释行)。常量搬家、落点新增都不必改锚:新增落点自动进入逐处对账。
|
|
1520
|
+
export function task7MessageSites(scriptsDir = SCRIPTS_DIR) {
|
|
1521
|
+
return [...engineScriptTexts(scriptsDir)]
|
|
1522
|
+
.filter(([, text]) => engineCodeText(text).includes(TASK7_MESSAGE_ANCHOR))
|
|
1523
|
+
.map(([rel]) => rel);
|
|
1524
|
+
}
|
|
1525
|
+
|
|
1526
|
+
// 值等于权威集合的常量名(文案派生的合法来源):① 本模块自持的字面常量(`const NAME = [<集合>];`);
|
|
1527
|
+
// ② **单源取用**的权威常量(以具名 import 从权威模块取用,含经再导出枢纽的情形)——常量下沉到最底层
|
|
1528
|
+
// 模块后,文案落点不再自持字面量,取用共享常量同样是「从判据常量派生」,判据「不得再写一遍字面
|
|
1529
|
+
// 集合」不变。
|
|
1530
|
+
export function task7DerivationNames(src, fieldSet, { rel, authorityRel, scriptsDir = SCRIPTS_DIR } = {}) {
|
|
1531
|
+
const names = task7ConstantNames(src, fieldSet);
|
|
1532
|
+
if (rel !== undefined && authorityRel !== undefined
|
|
1533
|
+
&& engineImportsSymbolFrom({
|
|
1534
|
+
text: src, consumerRel: rel, symbol: TASK7_AUTHORITY_CONSTANT, sourceRel: authorityRel, scriptsDir,
|
|
1535
|
+
})) {
|
|
1536
|
+
names.push(TASK7_AUTHORITY_CONSTANT);
|
|
1537
|
+
}
|
|
1538
|
+
return names;
|
|
1539
|
+
}
|
|
1540
|
+
|
|
1541
|
+
// 单行「标记同行枚举」提取(逐处对账与站点断言共用同一实现):返回 { raw, tokens } 列表。
|
|
1542
|
+
export function task7LineEnumerationTokens(fieldSet, line) {
|
|
1543
|
+
if (!TASK7_MARKER_RE.test(line)) return [];
|
|
1544
|
+
const out = [];
|
|
1545
|
+
for (const raw of line.match(TASK7_RUN_RE) ?? []) {
|
|
1546
|
+
const tokens = raw.split('/').map((token) => token.trim().replace(/`/g, ''));
|
|
1547
|
+
if (tokens.length < 3) continue;
|
|
1548
|
+
// 只认「字段枚举」:过半数 token 落在派生集合内(同行的其它斜杠短语不参与)。
|
|
1549
|
+
if (tokens.filter((token) => fieldSet.includes(token)).length * 2 <= tokens.length) continue;
|
|
1550
|
+
out.push({ raw, tokens });
|
|
1551
|
+
}
|
|
1552
|
+
return out;
|
|
1553
|
+
}
|
|
1554
|
+
|
|
1555
|
+
// 技能树「7 字段」枚举行扫描(真实判据与反向构造探针共用同一实现;每处记原始片段供探针精确改行)。
|
|
1556
|
+
export function task7EnumerationRuns(fieldSet, docs) {
|
|
1557
|
+
const runs = [];
|
|
1558
|
+
for (const [rel, text] of docs) {
|
|
1559
|
+
text.split(/\r?\n/).forEach((line, index) => {
|
|
1560
|
+
for (const { raw, tokens } of task7LineEnumerationTokens(fieldSet, line)) {
|
|
1561
|
+
runs.push({ rel, line: index + 1, raw, tokens });
|
|
1562
|
+
}
|
|
1563
|
+
});
|
|
1564
|
+
}
|
|
1565
|
+
return runs;
|
|
1566
|
+
}
|
|
1567
|
+
|
|
1568
|
+
// 已知站点上的枚举行(站点在场断言与站点级反向构造探针共用同一实现)。
|
|
1569
|
+
export function task7KnownSiteRuns(fieldSet, docs) {
|
|
1570
|
+
const runs = [];
|
|
1571
|
+
for (const site of TASK7_KNOWN_SITES) {
|
|
1572
|
+
const text = docs.get(site.rel);
|
|
1573
|
+
if (typeof text !== 'string') continue;
|
|
1574
|
+
text.split(/\r?\n/).forEach((line, index) => {
|
|
1575
|
+
if (!line.includes(site.anchor)) return;
|
|
1576
|
+
for (const { raw, tokens } of task7LineEnumerationTokens(fieldSet, line)) {
|
|
1577
|
+
runs.push({ site, rel: site.rel, line: index + 1, raw, tokens });
|
|
1578
|
+
}
|
|
1579
|
+
});
|
|
1580
|
+
}
|
|
1581
|
+
return runs;
|
|
1582
|
+
}
|
|
1583
|
+
|
|
1584
|
+
// 判据:① 每处「标记同行枚举」须与派生集合**逐字同序同值**(含新增站点);② 每个**已知站点**仍须持有
|
|
1585
|
+
// 这样的枚举——站点丢失即红(这才是「处数下降即红」的站点级实现,且不与「新增站点」对冲)。
|
|
1586
|
+
export function task7EnumerationProblems(fieldSet, docs) {
|
|
1587
|
+
const out = [];
|
|
1588
|
+
const expected = fieldSet.join('/');
|
|
1589
|
+
for (const run of task7EnumerationRuns(fieldSet, docs)) {
|
|
1590
|
+
const actual = run.tokens.join('/');
|
|
1591
|
+
if (actual !== expected) {
|
|
1592
|
+
out.push(run.rel + ':' + run.line + ' 的 7 字段枚举与实现集合不一致(文本 ' + actual + ' / 实现 ' + expected + ')');
|
|
1593
|
+
}
|
|
1594
|
+
}
|
|
1595
|
+
const siteRuns = task7KnownSiteRuns(fieldSet, docs);
|
|
1596
|
+
for (const site of TASK7_KNOWN_SITES) {
|
|
1597
|
+
if (siteRuns.some((run) => run.site === site)) continue;
|
|
1598
|
+
out.push('已知 7 字段站点「' + site.anchor + '」(' + site.rel + ')的标记同行枚举不在场'
|
|
1599
|
+
+ '(该行已改为指针 / 被删 / 枚举被抽掉,或已不含实现集合的多数项)');
|
|
1600
|
+
}
|
|
1601
|
+
return out;
|
|
1602
|
+
}
|
|
1603
|
+
|
|
1604
|
+
// 判据:「文案落后于判据」静默面——每处 BLOCKED 文案的集合字符串必须从**值等于权威集合的常量**
|
|
1605
|
+
// 派生(文案区域须出现该常量的 .join('/'),且不得再现该集合的字面拼接)。构造方式变了、渲染结果
|
|
1606
|
+
// 不变;`sources` = 文案落点(rel → 文本),`context.authorityRel` 供单源取用判定用。
|
|
1607
|
+
export function task7MessageDerivationProblems(fieldSet, sources, context = {}) {
|
|
1608
|
+
const out = [];
|
|
1609
|
+
const joined = fieldSet.join('/');
|
|
1610
|
+
for (const [rel, src] of sources) {
|
|
1611
|
+
const at = src.indexOf(TASK7_MESSAGE_ANCHOR);
|
|
1612
|
+
if (at < 0) {
|
|
1613
|
+
out.push(rel + ' 未找到「任务缺 7 字段」文案锚点(文案派生判据无从对账)');
|
|
1614
|
+
continue;
|
|
1615
|
+
}
|
|
1616
|
+
const region = src.slice(at, at + 240);
|
|
1617
|
+
const constants = task7DerivationNames(src, fieldSet, { ...context, rel });
|
|
1618
|
+
if (constants.length === 0) {
|
|
1619
|
+
out.push(rel + ' 未找到值等于权威集合的常量(判据与文案的共同来源缺席)');
|
|
1620
|
+
continue;
|
|
1621
|
+
}
|
|
1622
|
+
if (!constants.some((name) => region.includes(name + ".join('/')"))) {
|
|
1623
|
+
out.push(rel + ' 的 7 字段 BLOCKED 文案未从判据常量派生(缺 <常量>.join(\'/\'))——文案会静默落后于判据');
|
|
1624
|
+
}
|
|
1625
|
+
if (region.includes(joined)) {
|
|
1626
|
+
out.push(rel + ' 的 7 字段 BLOCKED 文案又写了一遍字面集合(' + joined + ')——第二处同口径表达');
|
|
1627
|
+
}
|
|
1628
|
+
}
|
|
1629
|
+
return out;
|
|
1630
|
+
}
|
|
1631
|
+
|
|
1632
|
+
// 7 字段集合锚的聚合判据(真实判据 + 反向构造探针;场景 184e 调用,返回问题描述数组)。
|
|
1633
|
+
// **落点反查**(判据形态:不写文件名):权威常量所在模块由导出符号反查、文案落点由渲染片段反查——
|
|
1634
|
+
// 模块再切分 / 再搬家不必改锚("唯一权威在 workflow-guard.mjs 里" 这类布局事实不再在锚里存第二份);
|
|
1635
|
+
// 常量模块与文案落点**各自独立**反查(常量下沉后两者不再同址);任一前提不在场即显式报失效。
|
|
1636
|
+
export function task7SetAnchorProblems({ docs, scriptsDir = SCRIPTS_DIR }) {
|
|
1637
|
+
const out = [];
|
|
1638
|
+
const authority = engineDefinitionModule(TASK7_AUTHORITY_CONSTANT, scriptsDir);
|
|
1639
|
+
if (authority === null) {
|
|
1640
|
+
out.push(TASK7_AUTHORITY_CONSTANT + ' 常量缺席或其定义面不唯一(7 字段集合的唯一权威不在场,文本侧无从对账): '
|
|
1641
|
+
+ JSON.stringify(engineDefinitionHits(TASK7_AUTHORITY_CONSTANT, scriptsDir)));
|
|
1642
|
+
return out;
|
|
1643
|
+
}
|
|
1644
|
+
const fieldSet = task7RequiredSet(authority.text);
|
|
1645
|
+
if (fieldSet === null || fieldSet.length !== 7) {
|
|
1646
|
+
out.push(authority.file + ' 的 ' + TASK7_AUTHORITY_CONSTANT
|
|
1647
|
+
+ ' 常量元素数 ≠ 7(7 字段集合的唯一权威不在场,文本侧无从对账)');
|
|
1648
|
+
return out;
|
|
1649
|
+
}
|
|
1650
|
+
// 文案落点(plan 出口门禁 + 执行期 replan 各一处)须都在场:任一处文案被删 / 改成指针,文案派生
|
|
1651
|
+
// 判定面即残缺——按**前提失效**显式报(不静默取小集后照样判绿)。
|
|
1652
|
+
const messageRels = task7MessageSites(scriptsDir);
|
|
1653
|
+
if (messageRels.length < 2) {
|
|
1654
|
+
out.push('7 字段 BLOCKED 文案落点不足两处(plan 出口门禁与 replan 出口须各自渲染该文案): '
|
|
1655
|
+
+ JSON.stringify(messageRels));
|
|
1656
|
+
return out;
|
|
1657
|
+
}
|
|
1658
|
+
const sources = new Map(messageRels.map((rel) => [rel, fs.readFileSync(path.join(scriptsDir, rel), 'utf8')]));
|
|
1659
|
+
const context = { authorityRel: authority.file, scriptsDir };
|
|
1660
|
+
out.push(...task7EnumerationProblems(fieldSet, docs));
|
|
1661
|
+
out.push(...task7MessageDerivationProblems(fieldSet, sources, context));
|
|
1662
|
+
out.push(...task7ReverseConstructionProblems(fieldSet, docs, sources, context));
|
|
1663
|
+
return out;
|
|
1664
|
+
}
|
|
1665
|
+
|
|
1666
|
+
// 反向构造(判别句式 + 反向构造;与真实判据同一实现驱动):逐项把锚的输入改坏 ⇒ 必红;
|
|
1667
|
+
// 另含**判别力方向**探针——合法新增站点必须**零问题**(防「全局计数地板」式自锁:以总量取红的探针会让
|
|
1668
|
+
// 「新增一处」与「丢失一处」对冲,且把报错方向指向探针而非真实原因)。
|
|
1669
|
+
export function task7ReverseConstructionProblems(fieldSet, docs, sources, context) {
|
|
1670
|
+
const out = [];
|
|
1671
|
+
const replaceRunLine = (targetDocs, run, mutate) => new Map(targetDocs).set(run.rel,
|
|
1672
|
+
(targetDocs.get(run.rel) ?? '').split(/\r?\n/)
|
|
1673
|
+
.map((line, index) => (index === run.line - 1 ? mutate(line) : line)).join('\n'));
|
|
1674
|
+
const dropRunLine = (targetDocs, run) => new Map(targetDocs).set(run.rel,
|
|
1675
|
+
(targetDocs.get(run.rel) ?? '').split(/\r?\n/)
|
|
1676
|
+
.filter((line, index) => index !== run.line - 1).join('\n'));
|
|
1677
|
+
const appendSite = (targetDocs, rel, fields) => new Map(targetDocs).set(rel,
|
|
1678
|
+
(targetDocs.get(rel) ?? '') + '\n(反向构造:新增站点)7 字段:' + fields.join(' / ') + '\n');
|
|
1679
|
+
// 文案落点全数改写(逐个落点同改:文案面探针须证明**每一处**落点的派生都被判据守住,而不是只守住
|
|
1680
|
+
// 反查所得的第一个)。
|
|
1681
|
+
const rewriteSourceTexts = (from, to) => new Map([...sources].map(([rel, src]) => [rel, src.replaceAll(from, to)]));
|
|
1682
|
+
const sample = task7KnownSiteRuns(fieldSet, docs)[0];
|
|
1683
|
+
if (sample === undefined) {
|
|
1684
|
+
out.push('7 字段枚举反向构造的前提不成立:已知站点上找不到与派生集合一致的枚举');
|
|
1685
|
+
return out;
|
|
1686
|
+
}
|
|
1687
|
+
const siteLabel = '已知站点「' + sample.site.anchor + '」(' + sample.rel + ':' + sample.line + ')';
|
|
1688
|
+
const probes = [
|
|
1689
|
+
// 站点丢失面(「处数下降即红」的站点级实现):抽掉该站点整处枚举 / 删掉整行 ⇒ 必红
|
|
1690
|
+
['抽掉 ' + siteLabel + ' 的整处枚举(改指针形态)',
|
|
1691
|
+
() => task7EnumerationProblems(fieldSet, replaceRunLine(docs, sample,
|
|
1692
|
+
(line) => line.replace(sample.raw, '(反向构造:改为指针形态)'))), '已知 7 字段站点'],
|
|
1693
|
+
['删掉 ' + siteLabel + ' 整行',
|
|
1694
|
+
() => task7EnumerationProblems(fieldSet, dropRunLine(docs, sample)), '已知 7 字段站点'],
|
|
1695
|
+
// 新增站点面(自锁回归):合法新增必须零问题;错误新增仍必红
|
|
1696
|
+
['新增一处集合正确的站点(不得被判违规)',
|
|
1697
|
+
() => task7EnumerationProblems(fieldSet, appendSite(docs, sample.rel, fieldSet)), TASK7_ZERO_PROBLEMS],
|
|
1698
|
+
['新增一处集合错误的新站点',
|
|
1699
|
+
() => task7EnumerationProblems(fieldSet, appendSite(docs, sample.rel,
|
|
1700
|
+
fieldSet.map((field) => (field === 'depends_on' ? 'id' : field)))), '与实现集合不一致'],
|
|
1701
|
+
// 集合分叉面
|
|
1702
|
+
['把 ' + siteLabel + ' 的 depends_on 换成 id',
|
|
1703
|
+
() => task7EnumerationProblems(fieldSet, replaceRunLine(docs, sample,
|
|
1704
|
+
(line) => line.replace(sample.raw, sample.raw.replace('depends_on', 'id')))), '与实现集合不一致'],
|
|
1705
|
+
['把 id 追加成第 8 项',
|
|
1706
|
+
() => task7EnumerationProblems(fieldSet, replaceRunLine(docs, sample,
|
|
1707
|
+
(line) => line.replace(sample.raw, sample.raw + ' / id'))), '与实现集合不一致'],
|
|
1708
|
+
['实现侧常量把 depends_on 改成 dependsOn',
|
|
1709
|
+
() => task7EnumerationProblems(fieldSet.map((field) => (field === 'depends_on' ? 'dependsOn' : field)), docs),
|
|
1710
|
+
'与实现集合不一致'],
|
|
1711
|
+
// 文案派生面(⑧):构造方式回退 / 派生被抽掉 ⇒ 必红(探针改坏的是**反查所得**的全部文案落点)
|
|
1712
|
+
['文案回写字面集合',
|
|
1713
|
+
() => task7MessageDerivationProblems(fieldSet,
|
|
1714
|
+
rewriteSourceTexts(TASK7_AUTHORITY_CONSTANT + ".join('/')", "'" + fieldSet.join('/') + "'"), context),
|
|
1715
|
+
'又写了一遍字面集合'],
|
|
1716
|
+
['文案抽掉派生',
|
|
1717
|
+
() => task7MessageDerivationProblems(fieldSet,
|
|
1718
|
+
rewriteSourceTexts(TASK7_AUTHORITY_CONSTANT + ".join('/')", "'7 字段'"), context),
|
|
1719
|
+
'未从判据常量派生'],
|
|
1720
|
+
];
|
|
1721
|
+
// 探针判定只看**相对当前文本的新增问题**(`ambient` 差分):工作树本身已红时,探针不得把
|
|
1722
|
+
// 「环境里已有的问题」记成自己的判别力(否则报错方向会指向探针,而不是指向真实原因)。
|
|
1723
|
+
const ambient = task7EnumerationProblems(fieldSet, docs);
|
|
1724
|
+
for (const [label, probe, expected] of probes) {
|
|
1725
|
+
const added = probe().filter((problem) => !ambient.includes(problem));
|
|
1726
|
+
const passed = expected === TASK7_ZERO_PROBLEMS
|
|
1727
|
+
? added.length === 0
|
|
1728
|
+
: added.some((problem) => problem.includes(expected));
|
|
1729
|
+
if (!passed) {
|
|
1730
|
+
out.push(expected === TASK7_ZERO_PROBLEMS
|
|
1731
|
+
? '反向构造判别力缺失(' + label + ' 被判违规——锚对合法扩展自锁): ' + added.join('; ')
|
|
1732
|
+
: '反向构造判别力缺失(' + label + ' 未被判违规)');
|
|
1733
|
+
}
|
|
1734
|
+
}
|
|
1735
|
+
return out;
|
|
1736
|
+
}
|
|
1737
|
+
|
|
1738
|
+
// 前端判据**散文口径**判据(场景 286 使用;纯函数 + 合成输入可驱动):引擎侧判据已升为结构形态
|
|
1739
|
+
// (独立行 / 行首 / 适用性标签的字段值位 + 词形边界 + 命中片段回显),五份分发文本是它的散文副本——
|
|
1740
|
+
// 副本必须陈述**结构形态**,不得残留旧口径(「段内不含 / 未标注字面『不适用』」这类把判据说成
|
|
1741
|
+
// 段内任意位置子串的表述,正是「一处措辞即关闸」fail-open 的文字版)。返回问题描述数组。
|
|
1742
|
+
export const FRONTEND_CRITERION_STRUCTURE_GROUPS = [
|
|
1743
|
+
['独立行', '独占一行'],
|
|
1744
|
+
['行首'],
|
|
1745
|
+
['字段值位'],
|
|
1746
|
+
['词形边界'],
|
|
1747
|
+
['命中片段', '回显'],
|
|
1748
|
+
];
|
|
1749
|
+
// 旧口径的**显式措辞**(逐条对应改前的真实句子,收窄到这些形态以免误伤新口径的正常行文)。
|
|
1750
|
+
export const FRONTEND_CRITERION_STALE_PROSE_RES = [
|
|
1751
|
+
/段内\s*\*{0,2}(?:不含|不包含|未含|不得含|不得出现)\*{0,2}\s*(?:字面\s*)?「?不适用」?/,
|
|
1752
|
+
/段内\s*\*{0,2}(?:标注|标记)\*{0,2}\s*「?不适用」?\s*(?:两个)?字面/,
|
|
1753
|
+
/未标注\s*「不适用」/,
|
|
1754
|
+
/不含\s*字面\s*「不适用」/,
|
|
1755
|
+
];
|
|
1756
|
+
export function frontendCriterionProseProblems(label, text) {
|
|
1757
|
+
const problems = [];
|
|
1758
|
+
for (const group of FRONTEND_CRITERION_STRUCTURE_GROUPS) {
|
|
1759
|
+
if (!group.some((token) => text.includes(token))) {
|
|
1760
|
+
problems.push(label + ' 未陈述结构形态「' + group[0] + '」(散文副本须与引擎的结构判据同口径)');
|
|
1761
|
+
}
|
|
1762
|
+
}
|
|
1763
|
+
for (const re of FRONTEND_CRITERION_STALE_PROSE_RES) {
|
|
1764
|
+
const hit = re.exec(text);
|
|
1765
|
+
if (hit !== null) problems.push(label + ' 残留旧口径表述: ' + JSON.stringify(hit[0]));
|
|
1766
|
+
}
|
|
1767
|
+
return problems;
|
|
1768
|
+
}
|
|
1769
|
+
|
|
1770
|
+
// 时间纪律四条硬规则的**文本判据**(场景 302 使用;纯函数 + 合成输入可驱动):入参是承载该纪律的
|
|
1771
|
+
// 文本(入口技能 / 验证阶梯),按规则逐条检查关键词组合;返回问题描述数组(空数组 = 四条齐备)。
|
|
1772
|
+
// 判别力由场景内的逐条移除构造常驻证明(移掉任一条的关键词 → 必报),不依赖人工实验。
|
|
1773
|
+
export const TIME_DISCIPLINE_RULES = [
|
|
1774
|
+
['规则① 时间戳一律本地时间 + 显式偏移', ['本地时间 + 显式偏移']],
|
|
1775
|
+
['规则② 比较一律 Date.parse 差值', ['Date.parse']],
|
|
1776
|
+
['规则③ 判活 / 判时以 mtime 或 git 时间为准、date 不作基准', ['mtime', 'git 时间', '不作基准']],
|
|
1777
|
+
['规则④ 纪律已写入验证阶梯', ['验证阶梯']],
|
|
1778
|
+
];
|
|
1779
|
+
export function timeDisciplineTextProblems(label, text) {
|
|
1780
|
+
const problems = [];
|
|
1781
|
+
for (const [rule, tokens] of TIME_DISCIPLINE_RULES) {
|
|
1782
|
+
const missing = tokens.filter((token) => !text.includes(token));
|
|
1783
|
+
if (missing.length > 0) problems.push(label + ' 缺 ' + rule + '(缺 ' + missing.join(' / ') + ')');
|
|
1784
|
+
}
|
|
1785
|
+
return problems;
|
|
1786
|
+
}
|
|
1787
|
+
|
|
1788
|
+
// CRLF 行尾判据(场景 303 使用;纯函数 + 合成输入可驱动):CRLF 文档的**每一条行**都必须以 CRLF
|
|
1789
|
+
// 终结——`split('\n')` 之后除末尾哨兵外每个元素都须以 `\r` 收尾,且文档得以换行收尾。返回违例
|
|
1790
|
+
// 行号(空数组 = 整篇行尾一致)。旧实现在「以换行收尾的文档」上直接于哨兵之后追加,拼出一条
|
|
1791
|
+
// **无 `\r` 的空行**:同一文件两种行尾,渲染层看不见、diff 层刺眼(REVIEW 实测形态)。
|
|
1792
|
+
export function crlfLineViolations(text) {
|
|
1793
|
+
const value = String(text);
|
|
1794
|
+
const lines = value.split('\n');
|
|
1795
|
+
const offenders = [];
|
|
1796
|
+
if (!value.endsWith('\n')) offenders.push(lines.length);
|
|
1797
|
+
for (let i = 0; i < lines.length - 1; i += 1) {
|
|
1798
|
+
if (!lines[i].endsWith('\r')) offenders.push(i + 1);
|
|
1799
|
+
}
|
|
1800
|
+
return offenders;
|
|
1801
|
+
}
|
|
1802
|
+
|
|
1803
|
+
// EVOLVE 报告列表符号判据(场景 304 使用;纯函数 + 合成输入可驱动):报告行不得出现 `- -`
|
|
1804
|
+
// 双层列表符号——` - ` 前缀与条目自带的 `- ` 叠加后渲染成「空壳父项 + 子项」,读者看到两条。
|
|
1805
|
+
export function evolveReportBulletProblems(reportText) {
|
|
1806
|
+
const problems = [];
|
|
1807
|
+
const lines = String(reportText).split('\n');
|
|
1808
|
+
for (let i = 0; i < lines.length; i += 1) {
|
|
1809
|
+
if (/^\s*-\s+-\s/.test(lines[i])) {
|
|
1810
|
+
problems.push('第 ' + (i + 1) + ' 行出现双列表符号: ' + JSON.stringify(lines[i]));
|
|
1811
|
+
}
|
|
1812
|
+
}
|
|
1813
|
+
return problems;
|
|
1814
|
+
}
|
|
1815
|
+
|
|
1816
|
+
// 确定性层「每项都带可复现命令」判据(场景 306 使用,对应验收条款的该子句;纯函数 + 合成输入
|
|
1817
|
+
// 可驱动):确定性层以 `### k · 名称` 分项,每个项内必须随附 `- 复现命令:` 行——项是「机器可判」
|
|
1818
|
+
// 的承诺,复现命令是它的兑现方式:缺一项,该层就有一格不可复核(读数与命令两边只在校验报告里
|
|
1819
|
+
// 出现过一次,读者无法自己重算)。返回问题描述数组(空 = 每项都有)。
|
|
1820
|
+
export function deterministicReproProblems(reportText) {
|
|
1821
|
+
const layer = /## 确定性层(机器可判)\n([\s\S]*?)(?=\n## |$)/.exec(String(reportText));
|
|
1822
|
+
if (layer === null) return ['缺「## 确定性层(机器可判)」段'];
|
|
1823
|
+
const chunks = layer[1].split(/\n(?=### )/).filter((chunk) => chunk.startsWith('### '));
|
|
1824
|
+
if (chunks.length === 0) return ['确定性层零个分项(判据无从校验)'];
|
|
1825
|
+
const problems = [];
|
|
1826
|
+
for (const chunk of chunks) {
|
|
1827
|
+
const title = chunk.split('\n')[0].replace(/^###\s*/, '').trim();
|
|
1828
|
+
if (!/^- 复现命令:/m.test(chunk)) problems.push('确定性项缺复现命令: ' + title);
|
|
1829
|
+
}
|
|
1830
|
+
return problems;
|
|
1831
|
+
}
|
|
1832
|
+
|
|
1833
|
+
// 上游覆盖声明四要素判据(场景 307 使用;纯函数 + 合成输入可驱动)。上游语义被本仓有意覆盖,
|
|
1834
|
+
// 声明此前是纯文本、无机检——读者无从判断「说没说清不采用什么」。四要素:
|
|
1835
|
+
// ① 上游文件标记为**只读基准**;② **「不采用」栏** ≥1 条(逐条点名,不是笼统「有意偏离」);
|
|
1836
|
+
// ③ **「沿用上游」栏** ≥1 条(**指针式入口豁免**——细则在各自技能册,入口只留指针);
|
|
1837
|
+
// ④ **「以…为准」兜底语**(冲突时以本节为准)。
|
|
1838
|
+
// 「栏内条目」计数容忍两种行文形态:序号标记(①②③…)与顿号 / 分号列举——技能册一用序号、
|
|
1839
|
+
// 一用顿号,形态差异不是「有没有条目」的差异;判据只锚「栏在场且至少一条」。
|
|
1840
|
+
export const OVERRIDE_CLAUSE_ITEM_MARKS = /[①②③④⑤⑥⑦⑧⑨⑩]/g;
|
|
1841
|
+
// 兜底语 = **冲突优先**声明(「以本节为准」式):判据不认任何 `以…为准`——`以安装平台为准`
|
|
1842
|
+
// 一类是无关行文,`冲突以 state 为准` 一类是局部字段优先级,都会被它冒充满足。
|
|
1843
|
+
export const OVERRIDE_FALLBACK_RE = /以(?:本节|本册|本文)[^\n。]{0,20}为准|冲突[^\n。]{1,60}为准/;
|
|
1844
|
+
// 声明块 = 「只读基准」所在行起,向后吞掉「空行 / 粗体栏名开头的段落 / 兜底语所在行」,直到首个
|
|
1845
|
+
// 既非空行、也不以 `**` 开头、也不含兜底语的行为止——四要素都必须落在**块内**。没有块边界,
|
|
1846
|
+
// 判据会被文件里别处的 `以…为准` / 局部优先级条款冒充满足(「锚偏弱」的另一种形态)。
|
|
1847
|
+
export function overrideDeclarationBlock(text) {
|
|
1848
|
+
const lines = String(text).split('\n');
|
|
1849
|
+
const start = lines.findIndex((line) => line.includes('只读基准'));
|
|
1850
|
+
if (start < 0) return null;
|
|
1851
|
+
let end = start + 1;
|
|
1852
|
+
for (let i = start; i < lines.length; i += 1) {
|
|
1853
|
+
const line = lines[i];
|
|
1854
|
+
if (i > start && line.trim() !== '' && !line.startsWith('**') && !OVERRIDE_FALLBACK_RE.test(line)) break;
|
|
1855
|
+
end = i + 1;
|
|
1856
|
+
}
|
|
1857
|
+
return lines.slice(start, end).join('\n');
|
|
1858
|
+
}
|
|
1859
|
+
export function labeledClauseItemCount(text, label) {
|
|
1860
|
+
const value = String(text);
|
|
1861
|
+
const at = value.indexOf(label);
|
|
1862
|
+
if (at < 0) return null;
|
|
1863
|
+
const nextLine = value.indexOf('\n', at);
|
|
1864
|
+
const line = value.slice(at, nextLine < 0 ? value.length : nextLine);
|
|
1865
|
+
// 栏名之后先剥掉自身的粗体闭合与冒号,再截到**下一个栏名**(粗体 + 冒号形态)为止:
|
|
1866
|
+
// 栏内联的粗体强调(`**确定性子集**(…)`)不是栏名,不能当成栏边界。
|
|
1867
|
+
const rest = line.slice(label.length).replace(/^[*::\s]+/, '');
|
|
1868
|
+
const nextLabel = rest.search(/\*\*[^*]{1,20}\*\*\s*[::]/);
|
|
1869
|
+
const body = nextLabel < 0 ? rest : rest.slice(0, nextLabel);
|
|
1870
|
+
const marked = (body.match(OVERRIDE_CLAUSE_ITEM_MARKS) ?? []).length;
|
|
1871
|
+
const listed = body.split(/[、;]/).map((piece) => piece.trim()).filter((piece) => piece.length > 0).length;
|
|
1872
|
+
return Math.max(marked, listed);
|
|
1873
|
+
}
|
|
1874
|
+
export function overrideDeclarationProblems(label, text, { pointer = false } = {}) {
|
|
1875
|
+
const problems = [];
|
|
1876
|
+
const block = overrideDeclarationBlock(text);
|
|
1877
|
+
if (block === null) return [label + ' 找不到覆盖声明块(缺「只读基准」标记)'];
|
|
1878
|
+
if (!block.includes('只读基准')) problems.push(label + ' 未把上游文件标记为「只读基准」');
|
|
1879
|
+
const notAdopted = labeledClauseItemCount(block, '不采用');
|
|
1880
|
+
if (notAdopted === null) problems.push(label + ' 缺「不采用」栏');
|
|
1881
|
+
else if (notAdopted === 0) problems.push(label + ' 的「不采用」栏零条目(须逐条点名上游语义)');
|
|
1882
|
+
if (!pointer) {
|
|
1883
|
+
const kept = labeledClauseItemCount(block, '沿用上游');
|
|
1884
|
+
if (kept === null) problems.push(label + ' 缺「沿用上游」栏');
|
|
1885
|
+
else if (kept === 0) problems.push(label + ' 的「沿用上游」栏零条目');
|
|
1886
|
+
}
|
|
1887
|
+
if (!OVERRIDE_FALLBACK_RE.test(block)) {
|
|
1888
|
+
problems.push(label + ' 缺「以…为准」兜底语(冲突时以本节 / 本册为准)');
|
|
1889
|
+
}
|
|
1890
|
+
return problems;
|
|
1891
|
+
}
|
|
1892
|
+
|
|
1893
|
+
// 覆盖声明里点名的上游工件路径(`flow-kit/prompts/...` 形态,含 `{a,b,c}.md` 花括号合写):
|
|
1894
|
+
// 逐条展开为可 stat 的真实路径——声明的锚必须指向在场实体,不能指向幽灵路径。尖括号占位形态
|
|
1895
|
+
// (`flow-kit/prompts/<阶段>.md` 一类说明性写法)不是实体,直接排除。
|
|
1896
|
+
export function upstreamArtifactPaths(text) {
|
|
1897
|
+
const found = String(text).match(/flow-kit\/prompts\/[^\s`)()、,。]+\.md/g) ?? [];
|
|
1898
|
+
const out = [];
|
|
1899
|
+
for (const raw of found) {
|
|
1900
|
+
if (raw.includes('<') || raw.includes('>')) continue;
|
|
1901
|
+
const brace = /\{([^}]*)\}/.exec(raw);
|
|
1902
|
+
if (brace === null) { out.push(raw); continue; }
|
|
1903
|
+
for (const name of brace[1].split(',')) out.push(raw.replace(brace[0], name.trim()));
|
|
1904
|
+
}
|
|
1905
|
+
return out;
|
|
1906
|
+
}
|
|
1907
|
+
|
|
1908
|
+
// 原子写惯用法指纹(两条件同现于一个文件):`+ '.tmp'` 拼接 + `fs.rename(` 落位——即「同目录固定
|
|
1909
|
+
// 临时名 + rename」的写法。**受检面 = 引擎实现面(入口 ∪ `lib/`)**,唯一实现只许落在原子写的
|
|
1910
|
+
// 单一来源模块;受保护写入是**独立的安全硬化通道**(临时名含 pid + 随机段),由 uniqueTempNameHits
|
|
1911
|
+
// 的**形态锚**认出并作为已登记例外(形态一旦退回本惯用法即红),不是静默排除。
|
|
1912
|
+
// root / files 是可测性接缝:使「第二份实现 → 检出 2 处」能在合成目录上被场景驱动,
|
|
1913
|
+
// 否则该判据只能靠人工实验证明判别力、回归时可能被改成恒真空过(场景 291 反向构造)。
|
|
1914
|
+
export const ATOMIC_TEMP_SUFFIX_RE = /\+\s*'\.tmp'/g;
|
|
1915
|
+
export function atomicWriteIdiomHits(root = SCRIPTS_DIR, files = null) {
|
|
1916
|
+
const candidates = files ?? engineScriptFiles(root);
|
|
1917
|
+
const hits = [];
|
|
1918
|
+
for (const file of candidates) {
|
|
1919
|
+
const text = fs.readFileSync(path.join(root, file), 'utf8');
|
|
1920
|
+
const count = (text.match(ATOMIC_TEMP_SUFFIX_RE) ?? []).length;
|
|
1921
|
+
if (count > 0 && text.includes('fs.rename(')) hits.push({ file, count });
|
|
1922
|
+
}
|
|
1923
|
+
return hits;
|
|
1924
|
+
}
|
|
1925
|
+
|
|
1926
|
+
// 「唯一临时名」硬化通道的**形态锚**:临时名含 pid + 随机段(固定同目录名会被并发写者互相覆盖,
|
|
1927
|
+
// 故受保护写入必须唯一化)。它按形态定位、不写文件名——通道退回「固定 `.tmp`」惯用法时检出 0 处
|
|
1928
|
+
// 即红(强制重评它是否落回原子写收敛面)。原子写受检面据此把它认成**已登记例外**而非漏网。
|
|
1929
|
+
const UNIQUE_TEMP_PID_RE = /String\(process\.pid\)/;
|
|
1930
|
+
const UNIQUE_TEMP_RANDOM_RE = /Math\.random\(\)\.toString\(16\)/;
|
|
1931
|
+
export function uniqueTempNameHits(root = SCRIPTS_DIR, files = null) {
|
|
1932
|
+
const candidates = files ?? engineScriptFiles(root);
|
|
1933
|
+
const hits = [];
|
|
1934
|
+
for (const file of candidates) {
|
|
1935
|
+
const text = fs.readFileSync(path.join(root, file), 'utf8');
|
|
1936
|
+
if (UNIQUE_TEMP_PID_RE.test(text) && UNIQUE_TEMP_RANDOM_RE.test(text)) hits.push({ file });
|
|
1937
|
+
}
|
|
1938
|
+
return hits;
|
|
1939
|
+
}
|
|
1940
|
+
|
|
1941
|
+
// 日期前缀判据的**表达式形态**扫描(与原子写惯用法同型):报告 / 工件名的「日期前缀」判定只许由
|
|
1942
|
+
// time-utils.mjs 表达一处——本判据认的形态是「日期三分量以**字面连字符**相接」的前缀写法
|
|
1943
|
+
// (`/^(\d{4}-\d{2}-\d{2})/` 一类),在其它脚本内联第二份即为单源违规(注释互指同源不作数,
|
|
1944
|
+
// 判据只认形态)。时刻形态 `\d{4})-(\d{2})-(\d{2})T…`(`TIMESTAMP_SHAPE`)是另一个判据面,同样
|
|
1945
|
+
// 落在 time-utils 一处,不在本形态内。**受检面 = 引擎实现面**:归档日志的日期条目匹配(行锚 +
|
|
1946
|
+
// `matchAll(.../gm)`)是**文档内容**里的日期匹配、不是文件名前缀判定,由 dateContentMatchHits 的
|
|
1947
|
+
// **形态锚**认出并作为已登记例外(形态一旦不再是内容条目匹配即红),不是静默排除。
|
|
1948
|
+
// root / files 是可测性接缝:使「第二份实现 → 检出 2 处」能在合成目录上被场景驱动,
|
|
1949
|
+
// 否则该判据只能靠人工实验证明判别力、回归时可能被改成恒真空过(场景 295 反向构造)。
|
|
1950
|
+
export const DATE_PREFIX_LITERAL_RE = /\\d\{4\}-\\d\{2\}-\\d\{2\}/g;
|
|
1951
|
+
// 归档日志日期条目的形态锚(`matchAll(/^…\d{4}-\d{2}-\d{2}…/gm)`):按形态定位、不写文件名。
|
|
1952
|
+
const DATE_CONTENT_MATCH_RE = /matchAll\(\/\^[^\n]*\\d\{4\}-\\d\{2\}-\\d\{2\}[^\n]*\/gm\)/g;
|
|
1953
|
+
export function dateContentMatchHits(root = SCRIPTS_DIR, files = null) {
|
|
1954
|
+
const candidates = files ?? engineScriptFiles(root);
|
|
1955
|
+
const hits = [];
|
|
1956
|
+
for (const file of candidates) {
|
|
1957
|
+
const count = (fs.readFileSync(path.join(root, file), 'utf8').match(DATE_CONTENT_MATCH_RE) ?? []).length;
|
|
1958
|
+
if (count > 0) hits.push({ file, count });
|
|
1959
|
+
}
|
|
1960
|
+
return hits;
|
|
1961
|
+
}
|
|
1962
|
+
export function datePrefixRegexpHits(root = SCRIPTS_DIR, files = null) {
|
|
1963
|
+
const candidates = files ?? engineScriptFiles(root);
|
|
1964
|
+
const hits = [];
|
|
1965
|
+
for (const file of candidates) {
|
|
1966
|
+
const text = fs.readFileSync(path.join(root, file), 'utf8');
|
|
1967
|
+
const count = (text.match(DATE_PREFIX_LITERAL_RE) ?? []).length;
|
|
1968
|
+
if (count > 0) hits.push({ file, count });
|
|
1969
|
+
}
|
|
1970
|
+
return hits;
|
|
1971
|
+
}
|
|
1972
|
+
|
|
1973
|
+
// 备份实现形态(改写前版本落盘):`命名族字面量 + fs.copyFile(` 同现于一个文件即「一份备份实现」。
|
|
1974
|
+
// 收敛面 = 单源模块 state-schema.mjs + 两个消费方:实现只许落在单源模块一处,消费方只许具名
|
|
1975
|
+
// import 后消费导出(此前 evolve 与 context-scan 各写一份——命名族或失败处置再演进时只改到一侧)。
|
|
1976
|
+
// root / files 是可测性接缝(默认引擎脚本目录):使「第二份实现 → 检出 2 处」能在合成目录上被场景
|
|
1977
|
+
// 驱动,否则该判据只能靠人工实验证明判别力、回归时可能被改成恒真空过(场景 301)。
|
|
1978
|
+
export const BACKUP_NAME_LITERAL = "'.bak-'";
|
|
1979
|
+
export const BACKUP_IMPL_FACE = ['state-schema.mjs', 'evolve.mjs', 'context-scan.mjs'];
|
|
1980
|
+
export function inlineBackupHits(root = SCRIPTS_DIR, files = null) {
|
|
1981
|
+
const candidates = files ?? engineScriptFiles(root);
|
|
1982
|
+
const hits = [];
|
|
1983
|
+
for (const file of candidates) {
|
|
1984
|
+
const text = fs.readFileSync(path.join(root, file), 'utf8');
|
|
1985
|
+
if (!text.includes(BACKUP_NAME_LITERAL)) continue;
|
|
1986
|
+
const count = (text.match(/await fs\.copyFile\(/g) ?? []).length;
|
|
1987
|
+
if (count > 0) hits.push({ file, count });
|
|
1988
|
+
}
|
|
1989
|
+
return hits;
|
|
1990
|
+
}
|
|
1991
|
+
|
|
1992
|
+
// 裸时间拼接静态锚(DESIGN R4「禁裸拼接」):时间形态 / 格式化的唯一权威是 time-utils.mjs。
|
|
1993
|
+
// 两面判据——① 三条侧命令**零容忍**(它们的产物是人可见报告、CLI 摘要行与备份名);
|
|
1994
|
+
// ② 其余引擎脚本走**显式白名单 + 逐条理由**:既有落点都是已持久化的机器字段(state 时刻 /
|
|
1995
|
+
// handoff 工件字段 / 审计事件),迁移须连同一批历史值的解析与比较面,留专门窗口并登记债务;
|
|
1996
|
+
// 白名单**精确匹配**(新增与消失都必须显式改这里,不许静默漂移)。判据只看代码不看散文:
|
|
1997
|
+
// 行注释剥掉后计数——注释里的反例引用不是「实现」(time-utils 的头部注释就引用了该形态)。
|
|
1998
|
+
// root / files 是可测性接缝:合成目录可驱动「新增即红」(场景 298)。
|
|
1999
|
+
export const BARE_ISO_TIMESTAMP_RE = /new Date\(\)\.toISOString\(\)/g;
|
|
2000
|
+
export const BARE_ISO_SIDE_COMMANDS = ['health.mjs', 'evolve.mjs', 'context-scan.mjs'];
|
|
2001
|
+
// 条目按**落点**登记(迁移后的实现在 `lib/`:state 机器字段随拆分分落三个命令模块;白名单面
|
|
2002
|
+
// 与受检面同口径——递归的引擎面,数据层夹具不登记)。
|
|
2003
|
+
export const BARE_ISO_ENGINE_WHITELIST = [
|
|
2004
|
+
{
|
|
2005
|
+
file: 'lib/state-commands-flow.mjs',
|
|
2006
|
+
count: 3,
|
|
2007
|
+
reason: 'state 的机器字段时间戳(init 的 createdAt / record 的记录时刻 / 强制推进事件的 at):Z 形已随既有 state 与事件流持久化,迁移须同批处理历史值的解析与比较,留专门窗口(登记 KNOWN-ISSUES);扫描时刻(last_intel_scan)已迁出本条——写入走 time-utils 的 nowTimestamp(场景 308 的形态锚 + 277 的单源消费面看守)',
|
|
2008
|
+
},
|
|
2009
|
+
{
|
|
2010
|
+
file: 'lib/state-commands-admin.mjs',
|
|
2011
|
+
count: 2,
|
|
2012
|
+
reason: 'state 的机器字段时间戳(execution-mode 的 directOverrideAt 授权留痕 / skill-load 标记的 at):与 state 其余时刻同形、同批迁移;标记 at 的**读取**已走 time-utils 的比较面(场景 277 的单源消费面看守)',
|
|
2013
|
+
},
|
|
2014
|
+
{
|
|
2015
|
+
file: 'lib/state-commands-recovery.mjs',
|
|
2016
|
+
count: 2,
|
|
2017
|
+
reason: '受控重入 / 重校授权的机器时刻(authorizedAt):随 state 事件流时间形态一并迁移;轮次推导已由综合判定派生,本条只剩落盘时刻',
|
|
2018
|
+
},
|
|
2019
|
+
{
|
|
2020
|
+
file: 'workflow-handoff.mjs',
|
|
2021
|
+
count: 4,
|
|
2022
|
+
reason: 'handoff 请求 / 结果的机器字段(requestedAt / revokedAt / completedAt):Z 形是既有 handoff 工件契约,须与 workflow-state 同批迁移;新增的撤回留痕不走本条——withdrawnAt 由 time-utils 的 nowTimestamp 生成(本地时间 + 显式偏移),人可见回显亦按标准形态格式化',
|
|
2023
|
+
},
|
|
2024
|
+
{
|
|
2025
|
+
file: 'workflow-guard.mjs',
|
|
2026
|
+
count: 1,
|
|
2027
|
+
reason: 'exit-applied 审计事件的机器时刻:非人可见报告面,随事件流时间形态一并迁移',
|
|
2028
|
+
},
|
|
2029
|
+
];
|
|
2030
|
+
// intel-scan 元数据「段名 / 字段名」字面量的跨文件一致判据(纯函数 + 合成输入可驱动):双落点判据在
|
|
2031
|
+
// init 侧按「段名 + 字段名」定位段内取值,段行的写通道在 context-scan 侧——同一条命名决定落在两处
|
|
2032
|
+
// 声明里(单一来源收口须改到测试面之外的脚本,见场景 309 的登记)。字面量若各自漂移,init 侧会
|
|
2033
|
+
// **静默**退化成「段不在场」(零提示)——静默面正是该机制要消灭的形态,故此处让「两处声明逐字相等」
|
|
2034
|
+
// 可机检。返回问题描述数组(空数组 = 一致)。
|
|
2035
|
+
export const INTEL_NAME_DECL_RE = /const\s+(INTEL_SECTION(?:_NAME)?|INTEL_FIELD(?:_NAME)?)\s*=\s*'([^']+)'/g;
|
|
2036
|
+
export function intelMetadataNameDeclarations(text) {
|
|
2037
|
+
const out = {};
|
|
2038
|
+
for (const match of String(text).matchAll(INTEL_NAME_DECL_RE)) {
|
|
2039
|
+
out[match[1].startsWith('INTEL_SECTION') ? 'section' : 'field'] = match[2];
|
|
2040
|
+
}
|
|
2041
|
+
return out;
|
|
2042
|
+
}
|
|
2043
|
+
export function intelMetadataNameProblems(consumerText, producerText) {
|
|
2044
|
+
const problems = [];
|
|
2045
|
+
const consumer = intelMetadataNameDeclarations(consumerText);
|
|
2046
|
+
const producer = intelMetadataNameDeclarations(producerText);
|
|
2047
|
+
for (const role of ['section', 'field']) {
|
|
2048
|
+
const label = role === 'section' ? '段名' : '字段名';
|
|
2049
|
+
if (consumer[role] === undefined) { problems.push('init 侧未声明 intel-scan ' + label + '字面量'); continue; }
|
|
2050
|
+
if (producer[role] === undefined) { problems.push('重扫命令侧未声明 intel-scan ' + label + '字面量'); continue; }
|
|
2051
|
+
if (consumer[role] !== producer[role]) {
|
|
2052
|
+
problems.push('intel-scan ' + label + '字面量两处声明不一致: init 侧 ' + JSON.stringify(consumer[role])
|
|
2053
|
+
+ ' / 重扫命令侧 ' + JSON.stringify(producer[role]) + '(段侧定位会静默退化为「段不在场」)');
|
|
2054
|
+
}
|
|
2055
|
+
}
|
|
2056
|
+
return problems;
|
|
2057
|
+
}
|
|
2058
|
+
|
|
2059
|
+
// 行注释剥离(`//` 之后非代码):判据的语义是「代码里有没有裸拼接」,散文引用不算实现。
|
|
2060
|
+
// 字符串里的 `//`(URL 一类)会把其后内容当注释剥掉——只可能**少计**(判据变松),而白名单面
|
|
2061
|
+
// 另有精确条数锚(13 处)兜底;不为注释识别引入字符串感知的复杂度。
|
|
2062
|
+
export function stripLineComments(text) {
|
|
2063
|
+
return text.split('\n').map((line) => {
|
|
2064
|
+
const at = line.indexOf('//');
|
|
2065
|
+
return at === -1 ? line : line.slice(0, at);
|
|
2066
|
+
}).join('\n');
|
|
2067
|
+
}
|
|
2068
|
+
export function bareIsoTimestampHits(root = SCRIPTS_DIR, files = null) {
|
|
2069
|
+
const candidates = files ?? engineScriptFiles(root);
|
|
2070
|
+
const hits = [];
|
|
2071
|
+
for (const file of candidates) {
|
|
2072
|
+
const text = stripLineComments(fs.readFileSync(path.join(root, file), 'utf8'));
|
|
2073
|
+
const count = (text.match(BARE_ISO_TIMESTAMP_RE) ?? []).length;
|
|
2074
|
+
if (count > 0) hits.push({ file, count });
|
|
2075
|
+
}
|
|
2076
|
+
return hits;
|
|
2077
|
+
}
|
|
2078
|
+
// 白名单判定(纯函数,合成输入可驱动):条数漂移(增 / 减)与未登记文件各自必报。
|
|
2079
|
+
export function bareIsoWhitelistProblems(hits, whitelist) {
|
|
2080
|
+
const problems = [];
|
|
2081
|
+
const actual = new Map(hits.map((hit) => [hit.file, hit.count]));
|
|
2082
|
+
for (const entry of whitelist) {
|
|
2083
|
+
const count = actual.get(entry.file) ?? 0;
|
|
2084
|
+
if (count === entry.count) continue;
|
|
2085
|
+
problems.push(entry.file + ' 白名单 ' + entry.count + ' 处 / 实际 ' + count
|
|
2086
|
+
+ ' 处(须显式改白名单:新增落点先迁移到 time-utils,已迁移的落点同步收窄;理由:' + entry.reason + ')');
|
|
2087
|
+
}
|
|
2088
|
+
for (const hit of hits) {
|
|
2089
|
+
if (whitelist.some((entry) => entry.file === hit.file)) continue;
|
|
2090
|
+
problems.push(hit.file + ' 未登记白名单(' + hit.count
|
|
2091
|
+
+ ' 处)——人可见面禁新增裸时间拼接,改用 time-utils.mjs 的 nowTimestamp / formatLocalTimestamp');
|
|
2092
|
+
}
|
|
2093
|
+
return problems;
|
|
2094
|
+
}
|
|
2095
|
+
|
|
2096
|
+
// 分发面源码的**注释层零代号**判据(纯函数 + 合成输入可驱动):受检面由调用方给定的
|
|
2097
|
+
// { rel → 文本 } 派生(生产侧 = 技能树内全部脚本,递归),注释行判定与词表判据同口径
|
|
2098
|
+
//(行首 `//` / `*` / `/*` 才算注释行)。旧形态只扫套件入口单文件——拆分后注释量最大的新模块
|
|
2099
|
+
// 全在面外,判据仍在而判别力消失;故受检面与反向构造探针都由本函数驱动(单一实现)。
|
|
2100
|
+
export function commentCodeProblems(texts) {
|
|
2101
|
+
const out = [];
|
|
2102
|
+
for (const [rel, text] of texts) {
|
|
2103
|
+
const lines = String(text).split(/\r?\n/);
|
|
2104
|
+
for (let i = 0; i < lines.length; i += 1) {
|
|
2105
|
+
if (!/^\s*(\/\/|\*|\/\*)/.test(lines[i])) continue;
|
|
2106
|
+
const hit = lines[i].match(PUBLIC_CODE_RE);
|
|
2107
|
+
if (hit) out.push(rel + ':' + (i + 1) + ': ' + hit[0]);
|
|
2108
|
+
}
|
|
2109
|
+
}
|
|
2110
|
+
return out;
|
|
2111
|
+
}
|
|
2112
|
+
|
|
2113
|
+
// 单一来源静态锁(纯函数 + 合成输入可驱动):某符号的实现只许落在**单源模块**一处,
|
|
2114
|
+
// 消费面(入口 ∪ `lib/**`)一律具名取用、不得自带第二份定义。判据形态两处都不写文件名:
|
|
2115
|
+
// 单源模块由调用方**反查**(engineDefinitionModule)传入,消费方由 `texts` 的真实引用派生
|
|
2116
|
+
// (所以模块再切分 / 再搬家不必改锚,新增消费方自动进入对账)。
|
|
2117
|
+
export function singleSourceImportProblems({ symbol, sourceRel, texts }) {
|
|
2118
|
+
const out = [];
|
|
2119
|
+
const definitionRe = engineDefinitionPattern(symbol);
|
|
2120
|
+
const mentionRe = new RegExp('\\b' + symbol + '\\b');
|
|
2121
|
+
const definers = [...texts.entries()].filter(([, text]) => definitionRe.test(text)).map(([rel]) => rel);
|
|
2122
|
+
if (definers.length !== 1 || definers[0] !== sourceRel) {
|
|
2123
|
+
out.push('单一来源被破坏:' + symbol + ' 的实现面应为 [' + sourceRel + '],实际 ' + JSON.stringify(definers));
|
|
2124
|
+
}
|
|
2125
|
+
for (const [rel, text] of texts) {
|
|
2126
|
+
if (rel === sourceRel) continue;
|
|
2127
|
+
if (!mentionRe.test(engineCodeText(text))) continue;
|
|
2128
|
+
if (definitionRe.test(text)) {
|
|
2129
|
+
out.push(rel + ' 自带第二份 ' + symbol + ' 定义(应取用单一来源)');
|
|
2130
|
+
continue;
|
|
2131
|
+
}
|
|
2132
|
+
// 取用面走**唯一实现**(import 自单源 / import 自再导出枢纽 / `export … from` 单源)
|
|
2133
|
+
const taken = engineImportsSymbolFrom({ text, consumerRel: rel, symbol, sourceRel, texts });
|
|
2134
|
+
if (!taken) out.push(rel + ' 未从 ' + sourceRel + ' 取用 ' + symbol + '(单一来源 fail-closed)');
|
|
2135
|
+
}
|
|
2136
|
+
return out;
|
|
2137
|
+
}
|
|
2138
|
+
// health 报告夹具:报告名的日期前缀与读数快照都是**构造出来的输入面**——快照哨兵值只在被采作
|
|
2139
|
+
// 基线时才出现在新报告里(哨兵 → `999999 → …`),据此可判「当前基线到底是哪一份」,不必解析
|
|
2140
|
+
// 报告结构。哨兵键取全小写键(快照行的键形态判据只认小写字母与 `.` / `_`),与既有 `context.exists`
|
|
2141
|
+
// 一类保持一致。
|
|
2142
|
+
export function healthReportFixture(date, sentinelEntries) {
|
|
2143
|
+
return [
|
|
2144
|
+
'# 健康巡检 · ' + date,
|
|
2145
|
+
'',
|
|
2146
|
+
'## 读数快照(机器可读 · 供下次报告对比)',
|
|
2147
|
+
'',
|
|
2148
|
+
'```text',
|
|
2149
|
+
'lessons.exists=true',
|
|
2150
|
+
'lessons.entries=' + sentinelEntries,
|
|
2151
|
+
'```',
|
|
2152
|
+
'',
|
|
2153
|
+
'## 与上次对比',
|
|
2154
|
+
'',
|
|
2155
|
+
'- 基线:无(夹具报告)',
|
|
2156
|
+
'',
|
|
2157
|
+
].join('\n');
|
|
2158
|
+
}
|
|
2159
|
+
|
|
2160
|
+
// 读数快照的**往返夹具**:把生产者自己产出的快照段整段(不解析、不重排、不改键名)当作历史
|
|
2161
|
+
// 基线喂回去——写方与读方的键形态是否同源,由「每个产出的键都能被读回」这一往返判定,而不是
|
|
2162
|
+
// 由套件再持一份键形态(第三份表达只会掩盖同一类缺陷)。此前写方发 6 个含大写字母的键、读方的
|
|
2163
|
+
// 键形态正则只认全小写,这 6 个键在对比段恒判「(基线无此读数)」:逐键趋势静默失效且不报错。
|
|
2164
|
+
export function healthReportWithSnapshot(date, snapshotSectionText) {
|
|
2165
|
+
return [
|
|
2166
|
+
'# 健康巡检 · ' + date,
|
|
2167
|
+
'',
|
|
2168
|
+
snapshotSectionText.trimEnd(),
|
|
2169
|
+
'',
|
|
2170
|
+
'## 与上次对比',
|
|
2171
|
+
'',
|
|
2172
|
+
'- 基线:无(夹具报告)',
|
|
2173
|
+
'',
|
|
2174
|
+
].join('\n');
|
|
2175
|
+
}
|
|
2176
|
+
// 报告里「## 读数快照」段的原文切片(往返夹具的输入 = 生产面的真实字节)
|
|
2177
|
+
export function snapshotSectionOf(reportText) {
|
|
2178
|
+
const start = reportText.indexOf('## 读数快照');
|
|
2179
|
+
if (start === -1) return null;
|
|
2180
|
+
const rest = reportText.slice(start);
|
|
2181
|
+
const end = rest.indexOf('\n## ', 1);
|
|
2182
|
+
return end === -1 ? rest : rest.slice(0, end);
|
|
2183
|
+
}
|
|
2184
|
+
// 快照段内的读数条数(`key=value` 行,排除围栏与空行)——往返判据的「应读到条数」由生产面原文派生
|
|
2185
|
+
export function snapshotEntryCount(sectionText) {
|
|
2186
|
+
return sectionText.split('\n').filter((line) => /^[^`\s][^=]*=/.test(line)).length;
|
|
2187
|
+
}
|
|
2188
|
+
|
|
2189
|
+
// CONTEXT.md 夹具(七段骨架 + 可选 evolve 段)——夹具不装 flow-kit 模板时 validateContext
|
|
2190
|
+
// 取内置基准段名;`intel-scan 元数据` / `evolve 元数据` 字段行与模板同形。
|
|
2191
|
+
// 与 system-test.mjs 的同名夹具**同形镜像**(两份载体刻意独立、不互相 import:夹具若从被测模块
|
|
2192
|
+
// 派生,锚点会退化成同义反复)——改段名 / 字段名时必须两份同改(与词表镜像同纪律)。
|
|
2193
|
+
export const CONTEXT_BASE_SECTION_NAMES = ['项目概要', '技术栈', '域语言', '已锁决策', '默认偏好', '既有抽象索引'];
|
|
2194
|
+
// 段侧扫描时刻的取值与行尾说明:**真实生成件形态**(`--init-context` 的 CONTEXT 生成物 = 取值词元 +
|
|
2195
|
+
// 行尾说明;写侧 `context-scan` 只替换首个取值词元、说明原样保留)。夹具取这一形态——裸取值词元
|
|
2196
|
+
// 夹具下「读侧取整行剩余文本」的口径缺陷在两级基线下都不可见(见场景 308 的单变量对照)。
|
|
2197
|
+
export const INTEL_FIELD_VALUE = '2026-09-01T10:00:00+08:00';
|
|
2198
|
+
export const INTEL_FIELD_SUFFIX = ' (首次接入生成时留占位;由 `init --init-context` 或 `context-scan` 记录扫描时间)';
|
|
2199
|
+
export const INTEL_METADATA_FIELD_LINES = [
|
|
2200
|
+
'- **last_intel_scan**: ' + INTEL_FIELD_VALUE + INTEL_FIELD_SUFFIX,
|
|
2201
|
+
'- **scanner**: `flow-comet`',
|
|
2202
|
+
'- **下次重扫建议**: 3 个月后',
|
|
2203
|
+
];
|
|
2204
|
+
export const EVOLVE_METADATA_FIELD_LINES = [
|
|
2205
|
+
'- **last_evolve_at**: `2026-09-01T10:00:00+08:00`',
|
|
2206
|
+
'- **scanner**: `flow-comet-evolve`',
|
|
2207
|
+
'- **下次建议**: 约 60 天后,或新增 ≥ 5 个带 §9 内容的 change 之后',
|
|
2208
|
+
];
|
|
2209
|
+
|
|
2210
|
+
export function contextFixtureText({ evolveSection = null, intelSection = true, tail = '' } = {}) {
|
|
2211
|
+
const lines = ['# 项目上下文', ''];
|
|
2212
|
+
for (const name of CONTEXT_BASE_SECTION_NAMES) {
|
|
2213
|
+
lines.push('## ' + name, '');
|
|
2214
|
+
if (name === '已锁决策') {
|
|
2215
|
+
lines.push('- [2026-09-01] 夹具决策 — 来自 @.specs/CONTEXT.md', '');
|
|
2216
|
+
continue;
|
|
2217
|
+
}
|
|
2218
|
+
if (name === '域语言') {
|
|
2219
|
+
// 域语言段须带模板表格表头(格式判据:`| 术语 | 定义 |`)
|
|
2220
|
+
lines.push('| 术语 | 定义 |', '|---|---|', '| 夹具 | 测试用上下文 |', '');
|
|
2221
|
+
continue;
|
|
2222
|
+
}
|
|
2223
|
+
lines.push('- 夹具条目(' + name + ')', '');
|
|
2224
|
+
}
|
|
2225
|
+
if (intelSection) lines.push('## intel-scan 元数据', '', ...INTEL_METADATA_FIELD_LINES, '');
|
|
2226
|
+
if (evolveSection !== null) lines.push('## evolve 元数据', '', ...evolveSection, '');
|
|
2227
|
+
if (tail !== '') lines.push(tail, '');
|
|
2228
|
+
return lines.join('\n');
|
|
2229
|
+
}
|
|
2230
|
+
|
|
2231
|
+
// 段侧取值的读取口径:结构提取返回的是**整行剩余文本**(取值词元 + markdown 引号 + 行尾说明),
|
|
2232
|
+
// 而写侧(`context-scan` 的 `INTEL_FIELD_LINE`)只替换首个 `(\S+)` 取值词元、说明原样保留——
|
|
2233
|
+
// 断言必须与写侧同口径取词元,否则「带说明行」会被判成不一致(本缺陷的成因即读侧取整行)。
|
|
2234
|
+
export function intelFieldToken(value) {
|
|
2235
|
+
return String(value).trim().split(/\s+/)[0].replace(/^`+/, '').replace(/`+$/, '');
|
|
2236
|
+
}
|
|
2237
|
+
|
|
2238
|
+
// design 出口 ui-design 门夹具:CHANGE.md 的「视觉调性」段是结构级前端判据的输入面
|
|
2239
|
+
export const VISUAL_TONE_APPLICABLE = '## 视觉调性(Visual Tone)\n\n现代、克制的工具型界面。\n';
|
|
2240
|
+
export const VISUAL_TONE_NOT_APPLICABLE = '## 视觉调性(Visual Tone)\n\n不适用(非前端项目)。\n';
|
|
2241
|
+
// 负向标记的另外几种形态(判据不接受裸子串,只接受结构形态):
|
|
2242
|
+
// 行首形态(标记 + 破折号理由,非独立行)
|
|
2243
|
+
export const VISUAL_TONE_LINE_HEAD_MARKER = '## 视觉调性(Visual Tone)\n\n不适用 —— CLI 工具,无用户可见界面。\n';
|
|
2244
|
+
// 字段值位(`- 适用性:不适用`)
|
|
2245
|
+
export const VISUAL_TONE_FIELD_MARKER = '## 视觉调性(Visual Tone)\n\n- 适用性:不适用(CLI 工具,无用户可见界面)\n';
|
|
2246
|
+
// 子维度字段(标签不是适用性标签)——结构形态在场,但主体是暗色主题,不得关掉整道门
|
|
2247
|
+
export const VISUAL_TONE_SUBDIMENSION_FIELD = '## 视觉调性(Visual Tone)\n\n- 选定:克制工具型\n- 暗色主题:不适用\n';
|
|
2248
|
+
// 自然句子(标记词出现在行首与句内,但都不成结构形态)——不得据它把前端 change 改判非前端
|
|
2249
|
+
export const VISUAL_TONE_NATURAL_SENTENCE = '## 视觉调性(Visual Tone)\n\n不适用于暗色主题,本 change 仅覆盖浅色分支。\n';
|
|
2250
|
+
|
|
2251
|
+
// ui-design 门键控夹具:以内置协议副本(runGuardWithProtocol 指向的同一路径)为基准改写 design
|
|
2252
|
+
// 节点的 flow-comet-ui-design 绑定——'guarded'(默认形态,写回)/ 'advisory'(等级降级)/
|
|
2253
|
+
// 'absent'(删掉绑定)。协议副本是「门是否在场」的唯一输入面。
|
|
2254
|
+
export function writeUiDesignBindingVariant(dir, variant) {
|
|
2255
|
+
const file = scenarioProtocolPath(dir);
|
|
2256
|
+
const protocol = JSON.parse(fs.readFileSync(file, 'utf8'));
|
|
2257
|
+
const design = (protocol.nodes ?? []).find((node) => node.id === 'design');
|
|
2258
|
+
if (!design) throw new Error('内置协议缺 design 节点(夹具前提不成立)');
|
|
2259
|
+
const kept = (design.requiredSkillCalls ?? []).filter((call) => call.skill !== 'flow-comet-ui-design');
|
|
2260
|
+
if (variant !== 'absent') {
|
|
2261
|
+
kept.push({
|
|
2262
|
+
skill: 'flow-comet-ui-design', operation: 'require', scope: 'main', enforcement: variant, reason: 'UI-DESIGN(仅前端)',
|
|
2263
|
+
});
|
|
2264
|
+
}
|
|
2265
|
+
design.requiredSkillCalls = kept;
|
|
2266
|
+
fs.writeFileSync(file, JSON.stringify(protocol, null, 2) + '\n');
|
|
2267
|
+
}
|
|
2268
|
+
|
|
2269
|
+
export function writeDesignExitFixture(dir, {
|
|
2270
|
+
newChange, visualTone, uiDesign, declareUiDesign, changeName = CHANGE_ID, changeTail = '', declareDesign = true,
|
|
2271
|
+
}) {
|
|
2272
|
+
writeFile(dir, 'flow-kit/templates/DESIGN.md', '# DESIGN 模板\n\n## 0. 技术栈选型\n## 1. 技术决策清单\n');
|
|
2273
|
+
const state = baseState('design');
|
|
2274
|
+
state.newChange = newChange === true;
|
|
2275
|
+
state.enteredNodes = ['design'];
|
|
2276
|
+
const checks = [];
|
|
2277
|
+
if (declareDesign) checks.push('required-skill:design.flow-comet-design');
|
|
2278
|
+
if (declareUiDesign) checks.push('required-skill:design.flow-comet-ui-design');
|
|
2279
|
+
state.evidence.design = { summary: 'design done', completedChecks: checks };
|
|
2280
|
+
writeState(dir, state);
|
|
2281
|
+
writeFile(dir, '.specs/' + changeName + '/CHANGE.md',
|
|
2282
|
+
'# CHANGE\n\n- **Change ID**: ' + changeName + '\n\n## Why(为什么做)\n\n夹具。\n\n' + visualTone + changeTail);
|
|
2283
|
+
writeFile(dir, '.specs/' + changeName + '/DESIGN.md',
|
|
2284
|
+
'# DESIGN\n\n- **Change ID**: ' + changeName + '\n\n## 0. 技术栈选型\n\nNode(纯脚本)\n\n## 1. 技术决策清单\n\n- [ ] 决策 1\n');
|
|
2285
|
+
if (uiDesign) {
|
|
2286
|
+
writeFile(dir, '.specs/' + changeName + '/UI-DESIGN.md',
|
|
2287
|
+
'# UI-DESIGN\n\n## 1. 设计 token\n\n- 主色 `oklch(0.6 0.1 250)`\n');
|
|
2288
|
+
} else {
|
|
2289
|
+
// 同一目录里连续构造四个子用例:缺席必须真实缺席(残留上一用例的工件会让缺件门形同虚设)
|
|
2290
|
+
fs.rmSync(path.join(dir, '.specs', changeName, 'UI-DESIGN.md'), { force: true });
|
|
2291
|
+
}
|
|
2292
|
+
}
|
|
2293
|
+
|
|
2294
|
+
// ---------- 锚助手(模块级具名实现:场景主体只调用,避免长体内插) ----------
|
|
2295
|
+
|
|
2296
|
+
// apply_patch heredoc 目标解析的耐久锚。载荷形态 = Codex 承载补丁的真实调用
|
|
2297
|
+
// (tool_name="Bash"、补丁正文在 tool_input.command、载荷无 file_path):四类补丁摘要行
|
|
2298
|
+
// (Update / Add / Delete / Move to)× 身份 / 协调者白名单两态 × 定界符变体 × 反例组。
|
|
2299
|
+
// 判据含**内建反向构造**:把守卫副本的补丁解析停用(解析器入口早退)后,同一组
|
|
2300
|
+
// 载荷里预期拦截的用例必须**全部**翻成放行——证明本锚断言的不是恒真形态。副本落在场景临时
|
|
2301
|
+
// 目录(只复制守卫与其三个同包依赖),不触碰权威源文件(零写入、零临时改名)。
|
|
2302
|
+
// 保护集第二目标按**本次运行实际生效的协议文件**取值(FLOW_COMET_PROTOCOL 的解析结果),
|
|
2303
|
+
// 不是「任意名为 workflow-protocol.json 的文件」——同名异路径用例(allow)即该边界的判别锚。
|
|
2304
|
+
export function applyPatchPayloadMatrix() {
|
|
2305
|
+
const stateTarget = '.flow-comet/flow-comet-state.json';
|
|
2306
|
+
const protocolTarget = 'reference/workflow-protocol.json'; // = 本场景实际生效的协议路径
|
|
2307
|
+
const sameNameElsewhere = '.specs/' + CHANGE_ID + '/workflow-protocol.json';
|
|
2308
|
+
const srcTarget = 'src/patched.mjs';
|
|
2309
|
+
const specsTarget = '.specs/' + CHANGE_ID + '/patched.md';
|
|
2310
|
+
const identity = { agent_id: 'agent-abc123' };
|
|
2311
|
+
// 补丁承载形态:`apply_patch <<'PATCH'` + 正文 + 定界行;dash / 引号形态按 shell 语义拼装。
|
|
2312
|
+
const patchCommand = (bodyLines, { delimiter = "'PATCH'", dash = false, close = true } = {}) => {
|
|
2313
|
+
const closing = (dash ? '\t' : '') + delimiter.replace(/^["']|["']$/g, '');
|
|
2314
|
+
const lines = ['apply_patch <<' + (dash ? '-' : '') + delimiter, '*** Begin Patch', ...bodyLines];
|
|
2315
|
+
if (close) lines.push(closing);
|
|
2316
|
+
return lines.join('\n');
|
|
2317
|
+
};
|
|
2318
|
+
const payloads = [];
|
|
2319
|
+
const add = (label, command, expect, withIdentity = true) =>
|
|
2320
|
+
payloads.push({ label, command, expect, identity: withIdentity ? identity : {} });
|
|
2321
|
+
// ① 四类摘要行 × 身份态 → 机器状态文件仍受拦(保护集,身份放行不放行它)
|
|
2322
|
+
for (const header of ['*** Update File:', '*** Add File:', '*** Delete File:', '*** Move to:']) {
|
|
2323
|
+
add('身份 + ' + header + ' state 文件', patchCommand([header + ' ' + stateTarget]), 'block');
|
|
2324
|
+
}
|
|
2325
|
+
// ② 身份态对照:普通源码放行(不过宽);实际生效的协议文件受拦;**同名异路径**放行(判据是
|
|
2326
|
+
// 解析结果而非文件名——保护集第二目标的边界)
|
|
2327
|
+
add('身份 + Update File 普通源码', patchCommand(['*** Update File: ' + srcTarget]), 'allow');
|
|
2328
|
+
add('身份 + Update File 生效协议文件', patchCommand(['*** Update File: ' + protocolTarget]), 'block');
|
|
2329
|
+
add('身份 + Update File 同名异路径协议文件', patchCommand(['*** Update File: ' + sameNameElsewhere]), 'allow');
|
|
2330
|
+
// ③ 协调者白名单态(无身份):.specs/ 放行;源码拦截;state 文件仍受拦(保护集无条件)
|
|
2331
|
+
add('无身份 + Update File .specs/ 工件', patchCommand(['*** Update File: ' + specsTarget]), 'allow', false);
|
|
2332
|
+
add('无身份 + Update File 源码', patchCommand(['*** Update File: ' + srcTarget]), 'block', false);
|
|
2333
|
+
add('无身份 + Update File state 文件', patchCommand(['*** Update File: ' + stateTarget]), 'block', false);
|
|
2334
|
+
// ④ 定界符变体 × state 文件 × 身份态 → 仍受拦
|
|
2335
|
+
add('双引号定界符', patchCommand(['*** Update File: ' + stateTarget], { delimiter: '"PATCH"' }), 'block');
|
|
2336
|
+
add('裸定界符', patchCommand(['*** Update File: ' + stateTarget], { delimiter: 'PATCH' }), 'block');
|
|
2337
|
+
add('<<- 制表符定界行', patchCommand(['*** Update File: ' + stateTarget], { delimiter: "'PATCH'", dash: true }), 'block');
|
|
2338
|
+
// ⑤ 反例:定界符之后的散行不得被吞并(吞并会把下游命令的参数读成写入目标);正文无摘要行、
|
|
2339
|
+
// 非 heredoc 的内联文本、引号内同名文本、无命令名的摘要行一律不误报
|
|
2340
|
+
add('定界符后散行不吞并',
|
|
2341
|
+
patchCommand(['*** Update File: ' + specsTarget]) + '\n*** Update File: ' + stateTarget, 'allow');
|
|
2342
|
+
add('正文无摘要行', patchCommand(['@@ -1 +1 @@', '-old', '+new']), 'allow');
|
|
2343
|
+
add('内联文本无 heredoc', 'echo "*** Update File: ' + stateTarget + '"', 'allow');
|
|
2344
|
+
add('引号内 apply_patch 文本', 'echo "apply_patch <<\'PATCH\'"', 'allow');
|
|
2345
|
+
add('无 apply_patch 命令名', 'grep -n "*** Update File: ' + stateTarget + '" patch.diff', 'allow');
|
|
2346
|
+
// ⑥ 未闭合 heredoc:按「正文到命令末尾」处理(偏拦截方向的 fail-closed),摘要行仍被抽出
|
|
2347
|
+
add('未闭合 heredoc', patchCommand(['*** Update File: ' + stateTarget], { close: false }), 'block');
|
|
2348
|
+
return payloads;
|
|
2349
|
+
}
|
|
2350
|
+
|
|
2351
|
+
// 单组载荷求值(真实守卫与反向构造副本共用):cwd / runRoot / 协议路径与场景夹具一致。
|
|
2352
|
+
export function runApplyPatchPayload(dir, hookPath, payload) {
|
|
2353
|
+
const res = spawnSync(process.execPath, [hookPath, 'before_tool'], {
|
|
2354
|
+
cwd: dir,
|
|
2355
|
+
input: JSON.stringify({ tool_name: 'Bash', tool_input: { command: payload.command }, ...payload.identity }),
|
|
2356
|
+
env: {
|
|
2357
|
+
...process.env,
|
|
2358
|
+
FLOW_COMET_RUN_ROOT: dir,
|
|
2359
|
+
FLOW_COMET_PROTOCOL: path.join(dir, 'reference', 'workflow-protocol.json'),
|
|
2360
|
+
},
|
|
2361
|
+
encoding: 'utf8',
|
|
2362
|
+
timeout: 60000,
|
|
2363
|
+
});
|
|
2364
|
+
return { status: res.status ?? 1, output: String(res.stdout || '') + String(res.stderr || '') };
|
|
2365
|
+
}
|
|
2366
|
+
|
|
2367
|
+
// 矩阵求值(单一实现):逐组比对期望出口码与拦截报文,返回问题串。
|
|
2368
|
+
export function applyPatchVerdictProblems(dir, hookPath, payloads) {
|
|
2369
|
+
const problems = [];
|
|
2370
|
+
for (const payload of payloads) {
|
|
2371
|
+
const expected = payload.expect === 'block' ? 2 : 0;
|
|
2372
|
+
const res = runApplyPatchPayload(dir, hookPath, payload);
|
|
2373
|
+
if (res.status !== expected) {
|
|
2374
|
+
problems.push('apply_patch 锚(' + payload.label + ')预期 exit ' + expected
|
|
2375
|
+
+ ',实际 exit ' + res.status + ':' + res.output.trim().slice(0, 120));
|
|
2376
|
+
} else if (payload.expect === 'block' && !res.output.includes('BLOCKED')) {
|
|
2377
|
+
problems.push('apply_patch 锚(' + payload.label + ')拦截报文缺 BLOCKED:' + res.output.trim().slice(0, 120));
|
|
2378
|
+
}
|
|
2379
|
+
}
|
|
2380
|
+
return problems;
|
|
2381
|
+
}
|
|
2382
|
+
|
|
2383
|
+
// 耐久锚主体:真实矩阵 + 内建反向构造。
|
|
2384
|
+
export function applyPatchAnchorProblems(dir) {
|
|
2385
|
+
const payloads = applyPatchPayloadMatrix();
|
|
2386
|
+
const problems = applyPatchVerdictProblems(dir, HOOK, payloads);
|
|
2387
|
+
// 内建反向构造:停用补丁解析 ⇒ 依赖该解析的拦截用例必须全部变红(此处判红)。
|
|
2388
|
+
const probeDir = path.join(dir, 'probe-scripts');
|
|
2389
|
+
fs.mkdirSync(probeDir, { recursive: true });
|
|
2390
|
+
for (const rel of ['comet-hook-guard.mjs', 'protocol-utils.mjs', 'state-schema.mjs', 'time-utils.mjs']) {
|
|
2391
|
+
fs.copyFileSync(path.join(SCRIPTS_DIR, rel), path.join(probeDir, rel));
|
|
2392
|
+
}
|
|
2393
|
+
const probeHookPath = path.join(probeDir, 'comet-hook-guard.mjs');
|
|
2394
|
+
const probeSource = fs.readFileSync(probeHookPath, 'utf8');
|
|
2395
|
+
const entry = probeSource.indexOf('function applyPatchHeredocs(command) {');
|
|
2396
|
+
if (entry < 0) {
|
|
2397
|
+
problems.push('反向构造探针无法定位补丁解析入口(实现已改名——锚与实现漂移)');
|
|
2398
|
+
return problems;
|
|
2399
|
+
}
|
|
2400
|
+
const brace = probeSource.indexOf('{', entry);
|
|
2401
|
+
fs.writeFileSync(probeHookPath,
|
|
2402
|
+
probeSource.slice(0, brace + 1) + '\n return []; // 反向构造:停用补丁解析\n' + probeSource.slice(brace + 1), 'utf8');
|
|
2403
|
+
let flipped = 0;
|
|
2404
|
+
for (const payload of payloads) {
|
|
2405
|
+
const res = runApplyPatchPayload(dir, probeHookPath, payload);
|
|
2406
|
+
if (payload.expect === 'block') {
|
|
2407
|
+
if (res.status === 0) flipped += 1;
|
|
2408
|
+
else problems.push('反向构造判别力缺失(' + payload.label + ' 在解析停用后仍拦截)');
|
|
2409
|
+
} else if (res.status !== 0) {
|
|
2410
|
+
problems.push('反向构造引入新拦截(' + payload.label + ' 在解析停用后被拦)');
|
|
2411
|
+
}
|
|
2412
|
+
}
|
|
2413
|
+
const blockCases = payloads.filter((p) => p.expect === 'block').length;
|
|
2414
|
+
if (flipped !== blockCases) {
|
|
2415
|
+
problems.push('反向构造未覆盖全部拦截用例(' + flipped + '/' + blockCases + ' 翻红)');
|
|
2416
|
+
}
|
|
2417
|
+
console.log('ANCHOR: apply_patch 目标解析矩阵 ' + payloads.length + ' 组(四类摘要行 × 身份/白名单两态 × '
|
|
2418
|
+
+ '定界符变体 × 反例;反向构造停用解析后 ' + flipped + '/' + blockCases + ' 组拦截用例全部翻红)');
|
|
2419
|
+
fs.rmSync(probeDir, { recursive: true, force: true });
|
|
2420
|
+
return problems;
|
|
2421
|
+
}
|
|
2422
|
+
|
|
2423
|
+
// 段内 glob 语义两处实现的等价性锚(route-node 的计划期重叠判定 ↔ workflow-handoff 的提交
|
|
2424
|
+
// 子集校验):同一 (声明, 字面) 矩阵两侧求值必须同判——否则「形态同源 + 漂移可见」无凭据。
|
|
2425
|
+
// 等价域 = **已归一**声明 × git 报告的**字面**路径(route-node 侧入参经计划期归一;handoff 侧
|
|
2426
|
+
// 的文件名来自 git,永不含 glob)。域外边界显式声明:双侧 glob 的保守重叠判定在 handoff 侧无
|
|
2427
|
+
// 对应物(提交文件名不可能是 glob),不在等价断言内。
|
|
2428
|
+
export function globEquivalenceProblems(dir) {
|
|
2429
|
+
const problems = [];
|
|
2430
|
+
const overlaps = requireRouteNodeExport('collectPathOverlaps');
|
|
2431
|
+
execFileSync('git', ['init', '-q'], { cwd: dir, stdio: 'ignore' });
|
|
2432
|
+
const git = (...args) => execFileSync('git', args, { cwd: dir, stdio: 'ignore' });
|
|
2433
|
+
const commitFile = (rel) => {
|
|
2434
|
+
writeFile(dir, rel, 'export const probe = 1;\n');
|
|
2435
|
+
git('add', '--', rel);
|
|
2436
|
+
git('-c', 'user.name=t', '-c', 'user.email=t@t', 'commit', '-qm', 'chore: glob probe ' + rel);
|
|
2437
|
+
return execFileSync('git', ['rev-parse', 'HEAD'], { cwd: dir, encoding: 'utf8' }).trim();
|
|
2438
|
+
};
|
|
2439
|
+
const hashes = new Map();
|
|
2440
|
+
const hashFor = (rel) => {
|
|
2441
|
+
if (!hashes.has(rel)) hashes.set(rel, commitFile(rel));
|
|
2442
|
+
return hashes.get(rel);
|
|
2443
|
+
};
|
|
2444
|
+
// 矩阵:{ pattern: 已归一声明, literal: 真实提交路径, covered: 两侧应同判的结论 }
|
|
2445
|
+
const matrix = [
|
|
2446
|
+
{ pattern: 'src/*.mjs', literal: 'src/a.mjs', covered: true, label: '段内通配命中' },
|
|
2447
|
+
{ pattern: 'src/*.mjs', literal: 'src/b.ts', covered: false, label: '段内通配扩展名不符' },
|
|
2448
|
+
{ pattern: 'src/*.mjs', literal: 'src/deep/a.mjs', covered: false, label: '段数不等不跨 /' },
|
|
2449
|
+
{ pattern: 'src/*', literal: 'src/a.mjs', covered: true, label: '整段通配' },
|
|
2450
|
+
{ pattern: 'src/a.mjs', literal: 'src/a.mjs', covered: true, label: '字面相等' },
|
|
2451
|
+
{ pattern: 'src/foo.mjs', literal: 'src/foobar.mjs', covered: false, label: '字面非前缀匹配' },
|
|
2452
|
+
{ pattern: 'SRC/*.mjs', literal: 'src/a.mjs', covered: false, label: '大小写不同不命中' },
|
|
2453
|
+
{ pattern: 'src/a?.mjs', literal: 'src/a1.mjs', covered: false, label: '非 * 元字符按字面(两侧同口径)' },
|
|
2454
|
+
];
|
|
2455
|
+
let index = 0;
|
|
2456
|
+
for (const cell of matrix) {
|
|
2457
|
+
index += 1;
|
|
2458
|
+
const taskId = 'E' + String(index).padStart(2, '0');
|
|
2459
|
+
const routeSide = overlaps([cell.pattern], [cell.literal]).length > 0;
|
|
2460
|
+
assertExit(runHandoff(['request', taskId, '--write-files', cell.pattern], dir), 0);
|
|
2461
|
+
const handoffSide = runHandoff(['result', taskId, JSON.stringify({
|
|
2462
|
+
status: 'DONE', taskId, commitHash: hashFor(cell.literal),
|
|
2463
|
+
completedChecks: ['required-skill:subagent-execute.flow-comet-dev'],
|
|
2464
|
+
redEvidence: { command: 'echo ok' },
|
|
2465
|
+
greenEvidence: { command: 'echo ok', output: 'ok' },
|
|
2466
|
+
})], dir);
|
|
2467
|
+
const handoffCovered = handoffSide.status === 0;
|
|
2468
|
+
if (!handoffCovered && !handoffSide.output.includes('超出 writeFiles 范围')) {
|
|
2469
|
+
problems.push('等价性锚(' + cell.label + ')提交子集校验未给出可判定结论:'
|
|
2470
|
+
+ handoffSide.output.trim().slice(0, 120));
|
|
2471
|
+
continue;
|
|
2472
|
+
}
|
|
2473
|
+
if (routeSide !== cell.covered || handoffCovered !== cell.covered) {
|
|
2474
|
+
problems.push('glob 语义两处实现不一致(' + cell.label + '):声明 ' + cell.pattern + ' × 字面 '
|
|
2475
|
+
+ cell.literal + ' 期望 ' + cell.covered + ',route-node=' + routeSide + ',handoff=' + handoffCovered);
|
|
2476
|
+
}
|
|
2477
|
+
}
|
|
2478
|
+
const coveredCount = matrix.filter((c) => c.covered).length;
|
|
2479
|
+
console.log('ANCHOR: 段内 glob 等价性矩阵 ' + matrix.length + ' 格(命中 ' + coveredCount + ' / 不命中 '
|
|
2480
|
+
+ (matrix.length - coveredCount) + ')——route-node 计划期重叠判定与 workflow-handoff 提交子集校验同判;'
|
|
2481
|
+
+ '任一恒真或恒假实现即红');
|
|
2482
|
+
return problems;
|
|
2483
|
+
}
|
|
2484
|
+
|