carlos-flow 2.13.0 → 2.14.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/AGENTS.md +15 -1
- package/CHANGELOG.md +17 -0
- package/README.en.md +27 -2
- package/README.md +26 -3
- package/README.zh.md +26 -3
- package/TRIGGER_GUIDE.md +3 -3
- package/bridge/mcp-bridge.js +106 -6
- package/client/carlos.js +157 -3
- package/ghost.json +1 -1
- package/package.json +8 -4
- package/scripts/check-stubs.mjs +1 -1
- package/scripts/full-audit.mjs +3 -1
- package/scripts/lang-audit.mjs +7 -1
- package/scripts/mutation-check.mjs +74 -7
- package/src/dispatch.js +204 -17
- package/src/index.js +181 -47
- package/src/protocol.js +182 -1
- package/src/state.js +36 -4
package/src/index.js
CHANGED
|
@@ -8,10 +8,10 @@ import { createServer, connect } from "node:net";
|
|
|
8
8
|
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
|
|
9
9
|
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
|
|
10
10
|
import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
|
|
11
|
-
import { PROTOCOL } from "./protocol.js";
|
|
11
|
+
import { PROTOCOL, loadProjectSensitiveConfig } from "./protocol.js";
|
|
12
12
|
import { parseCard, validateCard, riskTier, isSensitive } from "./card.js";
|
|
13
13
|
import { loadState, saveState, defaultState, audit, readAudit, getUserMessages, writeUserMessage, pathExists, gitHead, isStale, isBypassed, verifyAuditChain, withStateLock, auditHashMode, workspaceFingerprint } from "./state.js";
|
|
14
|
-
import { buildContractPrompt, snapshotFiles, readManifest, readManifestAll, writeDispatchPrompt, saveAgentResult, runVerifyCommand, runNegativeControl, computeOutputHash, enforceScope, MAX_DISPATCH } from "./dispatch.js";
|
|
14
|
+
import { buildContractPrompt, snapshotFiles, readManifest, readManifestAll, writeDispatchPrompt, saveAgentResult, runVerifyCommand, runNegativeControl, computeOutputHash, enforceScope, formatError, MAX_DISPATCH } from "./dispatch.js";
|
|
15
15
|
|
|
16
16
|
const log = (msg) => {
|
|
17
17
|
try {
|
|
@@ -49,7 +49,21 @@ const ok = (obj) => {
|
|
|
49
49
|
const withOk = "ok" in payload ? payload : { ok: true, ...payload };
|
|
50
50
|
return { content: [{ type: "text", text: JSON.stringify(withOk, null, 2) }] };
|
|
51
51
|
};
|
|
52
|
-
|
|
52
|
+
// 报错解释层的「模式闸门」。
|
|
53
|
+
//
|
|
54
|
+
// 背景:guide 模式已经由 guideError() 把技术报错翻译成中文人话,
|
|
55
|
+
// 如果 fail() 再追加一层「为什么被拦」的机制说明,用户会看到两段解释(重复且啰嗝)。
|
|
56
|
+
// 因此这里用一次性闼门:guideError 真的翻译了 → fail 原样输出;
|
|
57
|
+
// 否则(pro 模式 / 未翻译的错误)→ 追加机制说明。
|
|
58
|
+
let GUIDE_TRANSLATED = false;
|
|
59
|
+
|
|
60
|
+
const fail = (message) => {
|
|
61
|
+
// 一次性消费:读完之后立即复位,避免影响下一条错误。
|
|
62
|
+
const alreadyHuman = GUIDE_TRANSLATED;
|
|
63
|
+
GUIDE_TRANSLATED = false;
|
|
64
|
+
const explained = alreadyHuman ? String(message) : formatError(String(message));
|
|
65
|
+
return { content: [{ type: "text", text: "ERROR: " + explained }], isError: true };
|
|
66
|
+
};
|
|
53
67
|
|
|
54
68
|
// ---- 向导模式(mode==='guide')报错人话翻译 --------------------------------
|
|
55
69
|
//
|
|
@@ -57,9 +71,43 @@ const fail = (message) => ({ content: [{ type: "text", text: "ERROR: " + String(
|
|
|
57
71
|
// 在 guide 模式下把技术码翻译成「发生了什么 + 下一步该怎么做」的中文人话。
|
|
58
72
|
// pro 模式或未知 mode → 原样返回 technicalMsg,行为绝对不变(向后兼容守护)。
|
|
59
73
|
//
|
|
74
|
+
// 激活占位卡的「补齐骨架」。
|
|
75
|
+
//
|
|
76
|
+
// 背景:智能触发只开一张占位卡(scope / acceptance / verify 全空),必须补齐才能开工。
|
|
77
|
+
// 旧提示只说「还差三项」,新手 Agent 仍不知道每一项该怎么填,于是在同一个报错上来回空转。
|
|
78
|
+
// 现在直接给出一份可复制的调用骨架:已填好的字段原样保留,缺的项用尖括号占位。
|
|
79
|
+
// 只在 guide 模式 + 占位卡未补齐时输出,pro 模式零影响。
|
|
80
|
+
function activationCardGuide(state) {
|
|
81
|
+
const pending = asStringArray(state && state.activation_pending);
|
|
82
|
+
const card = (state && state.card && typeof state.card === "object") ? state.card : {};
|
|
83
|
+
const kept = (v) => (Array.isArray(v) ? v.map((x) => String(x)).filter((s) => s.trim()) : []);
|
|
84
|
+
const goal = typeof card.goal === "string" && card.goal.trim() ? card.goal.trim() : "<一句话目标>";
|
|
85
|
+
const quote = typeof card.quote === "string" && card.quote.trim() ? card.quote.trim() : "<用户原话摘录>";
|
|
86
|
+
const scope = kept(card.scope);
|
|
87
|
+
const acceptance = kept(card.acceptance);
|
|
88
|
+
const verifyCmd = card.verify && typeof card.verify.cmd === "string" ? card.verify.cmd.trim() : "";
|
|
89
|
+
const skeleton = {
|
|
90
|
+
goal,
|
|
91
|
+
quote,
|
|
92
|
+
scope: scope.length ? scope : ["<要改的文件,仓库根相对路径,可写多个>"],
|
|
93
|
+
acceptance: acceptance.length ? acceptance : ["<怎么算做完:一条可判定的验收标准>"],
|
|
94
|
+
verify: { cmd: verifyCmd || "<能真正跑起来的验证命令,例如 npm test>" },
|
|
95
|
+
confirmed: false,
|
|
96
|
+
};
|
|
97
|
+
const missing = pending.length ? pending : ["scope", "acceptance", "verify"];
|
|
98
|
+
return [
|
|
99
|
+
"这张卡还差 " + missing.length + " 项才能开工:" + missing.join(" / ") + "。",
|
|
100
|
+
"把下面骨架里尖括号的内容换成真实的,再调用一次 flow_submit_requirement 就行(已经填好的字段原样保留):",
|
|
101
|
+
"flow_submit_requirement(" + JSON.stringify(skeleton, null, 2) + ")",
|
|
102
|
+
"补齐之后才能 flow_claim / flow_dispatch;不需要重新开卡。",
|
|
103
|
+
].join("\n");
|
|
104
|
+
}
|
|
105
|
+
|
|
60
106
|
// 接入原则:最小侵入——只在**典型门禁拦截点**调用,不做大规模重构。
|
|
61
107
|
function guideError(state, technicalMsg) {
|
|
62
108
|
if (!state || state.mode !== "guide") return technicalMsg;
|
|
109
|
+
// 打了这个标记,fail() 就知道「已经是人话」,不再叠机制说明。
|
|
110
|
+
GUIDE_TRANSLATED = true;
|
|
63
111
|
const msg = String(technicalMsg);
|
|
64
112
|
// 按关键词映射到通俗解释 + 操作指引
|
|
65
113
|
const translations = [
|
|
@@ -77,6 +125,10 @@ function guideError(state, technicalMsg) {
|
|
|
77
125
|
{ match: /负对照|falsify/, human: "需要做一次「反向验证」来证明测试确实在起作用。请先调用 flow_falsify 做负对照,通过后再记录裁定。" },
|
|
78
126
|
{ match: /卡片未指定\s*verify/, human: "任务卡里没有写验证命令,没法确认改动对不对。请重新提交一张带 verify.cmd 的任务卡(flow_submit_requirement),这样才有办法验证。" },
|
|
79
127
|
];
|
|
128
|
+
// 占位卡未补齐:优先给「可复制的补齐骨架」,而不是只说「还差三项」。
|
|
129
|
+
if (Array.isArray(state.activation_pending) && state.activation_pending.length > 0 && /占位卡/.test(msg)) {
|
|
130
|
+
return activationCardGuide(state) + "\n(原始提示:" + msg + ")";
|
|
131
|
+
}
|
|
80
132
|
for (const t of translations) {
|
|
81
133
|
if (t.match.test(msg)) {
|
|
82
134
|
return t.human + "\n(原始提示:" + msg + ")";
|
|
@@ -88,6 +140,42 @@ function guideError(state, technicalMsg) {
|
|
|
88
140
|
|
|
89
141
|
const asStringArray = (v) => (Array.isArray(v) ? v.map((x) => String(x)) : []);
|
|
90
142
|
|
|
143
|
+
// ---- 路径基准统一 ----------------------------------------------------------
|
|
144
|
+
//
|
|
145
|
+
// scope 的校验基准必须与 `git diff --name-only` 的基准**完全一致**。
|
|
146
|
+
//
|
|
147
|
+
// 实测事实(2026-11-17):git diff 即使在子目录里执行,输出的也是**仓库根相对路径**;
|
|
148
|
+
// 而旧实现拿 process.cwd() 当基准去校验 scope。MCP server 是常驻进程,
|
|
149
|
+
// 它的 cwd 是**启动时**的目录(可能是几个月前的旧仓库,也可能只是用户
|
|
150
|
+
// 随手打开终端的位置),于是出现「明明文件就在那,却报 scope 路径不存在」——
|
|
151
|
+
// 使用者根本猜不到真实原因是「基准目录不对」。
|
|
152
|
+
//
|
|
153
|
+
// 现在:一律先求 git 仓库根;非 git 项目才退回调用方给的目录(与旧行为一致)。
|
|
154
|
+
const REPO_ROOT_CACHE = new Map();
|
|
155
|
+
function resolveRepoRoot(cwd) {
|
|
156
|
+
const base = cwd || process.cwd();
|
|
157
|
+
// 缓存:本函数会 spawn 一次 git,而裁定链路上会被调用多次(scope 自查 / 越界判定)。
|
|
158
|
+
// 只缓存**命中**结果;未命中不缓存 —— 目录可能稍后才变成 git 仓库(测试里就是如此)。
|
|
159
|
+
const cached = REPO_ROOT_CACHE.get(base);
|
|
160
|
+
if (cached !== undefined) return cached;
|
|
161
|
+
try {
|
|
162
|
+
const r = spawnSync("git", ["rev-parse", "--show-toplevel"], {
|
|
163
|
+
cwd: base,
|
|
164
|
+
encoding: "utf8",
|
|
165
|
+
timeout: 5000,
|
|
166
|
+
windowsHide: true,
|
|
167
|
+
shell: false,
|
|
168
|
+
});
|
|
169
|
+
const top = r.status === 0 ? String(r.stdout || "").trim() : "";
|
|
170
|
+
if (top) {
|
|
171
|
+
if (REPO_ROOT_CACHE.size > 64) REPO_ROOT_CACHE.clear();
|
|
172
|
+
REPO_ROOT_CACHE.set(base, top);
|
|
173
|
+
return top;
|
|
174
|
+
}
|
|
175
|
+
} catch { /* git 不可用:退回原目录 */ }
|
|
176
|
+
return base;
|
|
177
|
+
}
|
|
178
|
+
|
|
91
179
|
// 卡片文本字段(scope / acceptance / unknowns / assumptions)**保留原始元素类型**,
|
|
92
180
|
// 不做任何过滤/转换。
|
|
93
181
|
// 背景:早先用 asStringArray(String(x))会把 null→「null」、{}→「[object Object]」,
|
|
@@ -164,9 +252,21 @@ const WARN_FINDINGS_LIMIT = 20;
|
|
|
164
252
|
// 附带回答 DIRECTION/LOCAL 路径:返工意见恰恰最需要坏味道清单,
|
|
165
253
|
// 所以三种裁定都带这份汇总。
|
|
166
254
|
function collectAxisWarnings(state) {
|
|
167
|
-
|
|
168
|
-
if (!ax || typeof ax !== "object") return [];
|
|
255
|
+
if (!state || typeof state !== "object") return [];
|
|
169
256
|
const out = [];
|
|
257
|
+
// ① 负对照的还原核对失败:改动可能没被完整写回工作区。
|
|
258
|
+
// 这不是「审查意见」而是「环境事实」,优先级最高 —— 放在最前面,
|
|
259
|
+
// 因为它意味着「你以为的改动后状态」可能已经不成立。
|
|
260
|
+
const lf = state.last_falsify;
|
|
261
|
+
if (lf && typeof lf === "object" && lf.restore && lf.restore.ok === false) {
|
|
262
|
+
out.push({
|
|
263
|
+
axis: "falsify",
|
|
264
|
+
finding: "负对照后工作区还原未通过核对:" + (lf.restore.mismatched || []).join(", "),
|
|
265
|
+
});
|
|
266
|
+
}
|
|
267
|
+
// ② 两轴里的 WARN(坏味道等 judgement call)
|
|
268
|
+
const ax = state.audit_axes;
|
|
269
|
+
if (!ax || typeof ax !== "object") return out;
|
|
170
270
|
for (const name of ["standards", "spec"]) {
|
|
171
271
|
const a = ax[name];
|
|
172
272
|
if (!a || !a.verdict) continue;
|
|
@@ -239,7 +339,11 @@ const TOOLS = [
|
|
|
239
339
|
try {
|
|
240
340
|
const a = args || {};
|
|
241
341
|
const sessionId = a.sessionId || "unknown";
|
|
242
|
-
|
|
342
|
+
// scope 校验基准 = git 仓库根(与 git diff 同基准);
|
|
343
|
+
// verify 执行目录 = 调用方显式给的目录,没给才用仓库根。
|
|
344
|
+
const cwdInput = a.cwd || process.cwd();
|
|
345
|
+
const scopeRoot = resolveRepoRoot(cwdInput);
|
|
346
|
+
const execDir = a.cwd || scopeRoot;
|
|
243
347
|
|
|
244
348
|
let card = null;
|
|
245
349
|
if (typeof a.cardText === "string" && a.cardText.trim() !== "") {
|
|
@@ -273,7 +377,7 @@ const TOOLS = [
|
|
|
273
377
|
|
|
274
378
|
const options = {
|
|
275
379
|
userMessages: messages,
|
|
276
|
-
scopeExists: (p) => pathExists(
|
|
380
|
+
scopeExists: (p) => pathExists(scopeRoot, p),
|
|
277
381
|
// 走 cardText 提交的卡片,其自身的 confirmed 字段同样必须生效,否则敏感路径永远无法通过
|
|
278
382
|
confirmed: (a.confirmed === true) || card.confirmed === true,
|
|
279
383
|
};
|
|
@@ -289,7 +393,7 @@ const TOOLS = [
|
|
|
289
393
|
return ok({ ok: false, reason, findings, tier });
|
|
290
394
|
}
|
|
291
395
|
|
|
292
|
-
card.env = { git_head: gitHead(
|
|
396
|
+
card.env = { git_head: gitHead(execDir), project: execDir };
|
|
293
397
|
|
|
294
398
|
// ---- 闸门待补项:服务端从当前卡片内容**幂等派生** ----
|
|
295
399
|
// 内容判定:与 validateCard 的必填字段口径**严格一致**(两边都要求
|
|
@@ -522,9 +626,9 @@ const TOOLS = [
|
|
|
522
626
|
// 必须先 flow_claim 领取派发名额(claimed 标记由 claim 设置)
|
|
523
627
|
if (state.claimed !== true) return fail(guideError(state, "未 claim,请先 flow_claim 领取派发名额。"));
|
|
524
628
|
|
|
525
|
-
|
|
526
|
-
|
|
527
|
-
|
|
629
|
+
// 派发基准同样必须对齐 git 仓库根:scope 是仓库根相对路径,
|
|
630
|
+
// snapshot / baseline / 裁定三处要用同一个基准,否则越界判定会自相矛盾。
|
|
631
|
+
const cwd = resolveRepoRoot(a.cwd || process.cwd());
|
|
528
632
|
state.dispatch_count = (Number(state.dispatch_count) || 0) + 1;
|
|
529
633
|
// 额度已消耗,需要重新 claim 才能再次派发
|
|
530
634
|
state.claimed = false;
|
|
@@ -544,15 +648,7 @@ const TOOLS = [
|
|
|
544
648
|
audit("run", sessionId, { kind: "snapshot", role, files: scope.length, ok: true });
|
|
545
649
|
|
|
546
650
|
// Phase 1-1: 记录「派发前基线」。
|
|
547
|
-
//
|
|
548
|
-
// 为什么是记录而不是当场阻断:
|
|
549
|
-
// 派发这一刻,子 Agent **还没动手** —— 它之后会改哪些文件根本无从得知。
|
|
550
|
-
// 此时跑 git diff 得到的是「用户自己已有的未提交改动」,
|
|
551
|
-
// 拿它当越界拦下来会**误伤正常用法**(用户本来就在改这些文件)。
|
|
552
|
-
//
|
|
553
|
-
// 正确的时机是**裁定前**:用「当前改动 - 派发基线」算出**本次执行引入的**
|
|
554
|
-
// 改动,再与卡片 scope 比对 —— 这才是「越界直接阻断」的真实落点,
|
|
555
|
-
// 阻断的是「越界之后仍然拿到 PASS」这个闭环。
|
|
651
|
+
// 使用与后续校验一致的 cwd,修正基准
|
|
556
652
|
const baseline = enforceScope(scope, cwd);
|
|
557
653
|
state.dispatch_baseline = Array.isArray(baseline.checked) ? baseline.checked : [];
|
|
558
654
|
saveState(sessionId, state);
|
|
@@ -712,11 +808,17 @@ const TOOLS = [
|
|
|
712
808
|
const sessionId = a.sessionId || "unknown";
|
|
713
809
|
const state = loadState(sessionId);
|
|
714
810
|
|
|
811
|
+
// 裁定闸门的分组与顺序与 docs/TOOL_CONTRACTS.md 第 1.2 节严格一致:
|
|
812
|
+
// 【无条件 2 组】1 有卡 · 2 占位卡已补齐
|
|
813
|
+
// 【仅 PASS 7 组】3 派发过 · 4 验证有效 · 5 验证未过期 · 6 无越界
|
|
814
|
+
// · 7 role=auditor · 8 负对照 · 9 双轴齐且无 FAIL
|
|
815
|
+
// 顺序不可调换:先证实验证有效(4/5)→ 再证改动合规(6/7)→ 再证测试有判别力(8)
|
|
816
|
+
// → 再证审查到位(9)。错位会让「未验证」被「双轴未齐」掩盖,调用方拿到不可操作的下一步。
|
|
715
817
|
if (!state.card) return fail(guideError(state, "没有留痕,无法记录裁定。"));
|
|
716
818
|
|
|
717
819
|
const verdict = a.verdict;
|
|
718
820
|
|
|
719
|
-
//
|
|
821
|
+
// ── 门禁 2/9(无条件):激活占位卡必须已补齐 ──
|
|
720
822
|
// 否则会出现「未派发、未验证、却直接 PASS」的假闭环。
|
|
721
823
|
// (先于 dispatch_count 检查:占位卡的错误信息更具体,也更可操作)
|
|
722
824
|
if (Array.isArray(state.activation_pending) && state.activation_pending.length > 0) {
|
|
@@ -729,7 +831,8 @@ const TOOLS = [
|
|
|
729
831
|
"),不能记录裁定。请先补齐后重新调用 flow_submit_requirement。"));
|
|
730
832
|
}
|
|
731
833
|
|
|
732
|
-
//
|
|
834
|
+
// ── 门禁 3/9(仅 PASS):确实派发过 ──
|
|
835
|
+
// 从未派发过任何执行,就不允许落 PASS 裁定。
|
|
733
836
|
// 否则一张刚提交、什么都没跑的卡也能直接标 completed_ok=true。
|
|
734
837
|
// 只施加于 PASS:DIRECTION / LOCAL 是「有问题」的裁定,不构成「完成」,
|
|
735
838
|
// 允许在未派发时先记录返工意见。
|
|
@@ -743,7 +846,8 @@ const TOOLS = [
|
|
|
743
846
|
"请先 flow_claim / flow_dispatch 派发并完成验证后再落 PASS。"));
|
|
744
847
|
}
|
|
745
848
|
|
|
746
|
-
//
|
|
849
|
+
// ── 门禁 4/9(仅 PASS):验证真实有效 ──
|
|
850
|
+
// 记 PASS 必须有**真实验证通过**的证据。
|
|
747
851
|
// 「派发过」≠「验证过」——只查 dispatch_count 时,一张跑过但验证失败的卡
|
|
748
852
|
// 照样能落 PASS(completed_ok=true),等于把验证环节架空。
|
|
749
853
|
// 三个条件同时成立才放行:
|
|
@@ -780,8 +884,8 @@ const TOOLS = [
|
|
|
780
884
|
exitCode: lv.exitCode,
|
|
781
885
|
verify_cmd: lv.cmd,
|
|
782
886
|
});
|
|
783
|
-
return fail("验证未通过(exitCode=" + lv.exitCode + "),不能记录 PASS 裁定。" +
|
|
784
|
-
"请先修复问题、让 verify.cmd 真实跑通(flow_run_verify),再记录裁定。");
|
|
887
|
+
return fail(formatError("验证未通过(exitCode=" + lv.exitCode + "),不能记录 PASS 裁定。" +
|
|
888
|
+
"请先修复问题、让 verify.cmd 真实跑通(flow_run_verify),再记录裁定。"));
|
|
785
889
|
}
|
|
786
890
|
if (!want || typeof lv.cmd !== "string" || lv.cmd.trim() !== want) {
|
|
787
891
|
audit("decision", sessionId, {
|
|
@@ -790,11 +894,12 @@ const TOOLS = [
|
|
|
790
894
|
verify_cmd: lv.cmd,
|
|
791
895
|
card_cmd: want,
|
|
792
896
|
});
|
|
793
|
-
return fail("已有的验证结果对应的命令与当前卡片的 verify.cmd 不一致,不能记录 PASS 裁定。" +
|
|
794
|
-
"请对当前卡片重新执行 flow_run_verify,再记录裁定。");
|
|
897
|
+
return fail(formatError("已有的验证结果对应的命令与当前卡片的 verify.cmd 不一致,不能记录 PASS 裁定。" +
|
|
898
|
+
"请对当前卡片重新执行 flow_run_verify,再记录裁定。"));
|
|
795
899
|
}
|
|
796
900
|
|
|
797
|
-
//
|
|
901
|
+
// ── 门禁 5/9(仅 PASS):验证结果未过期 ──
|
|
902
|
+
// 验证结果必须绑定当时的**代码状态**(A1)。
|
|
798
903
|
//
|
|
799
904
|
// 前面三道判断只看「验证跑过 / 跑通了 / 命令对得上」,**不看代码变没变**。
|
|
800
905
|
// 于是存在这条绕过路径:
|
|
@@ -815,11 +920,12 @@ const TOOLS = [
|
|
|
815
920
|
fp_was: fpWas.diff_sha256,
|
|
816
921
|
fp_now: fpNow.diff_sha256,
|
|
817
922
|
});
|
|
818
|
-
return fail("验证结果已过期(STALE):验证通过后代码又被修改,当前 diff 指纹已变化。" +
|
|
819
|
-
"请重新执行 flow_run_verify 再记录裁定。");
|
|
923
|
+
return fail(formatError("验证结果已过期(STALE):验证通过后代码又被修改,当前 diff 指纹已变化。" +
|
|
924
|
+
"请重新执行 flow_run_verify 再记录裁定。"));
|
|
820
925
|
}
|
|
821
926
|
|
|
822
|
-
//
|
|
927
|
+
// ── 门禁 6/9(仅 PASS):无越界改动 ──
|
|
928
|
+
// 越界改动必须被拦住。
|
|
823
929
|
//
|
|
824
930
|
// 「越界直接阻断」的**真实落点**在这里:判定「本次执行有没有改到
|
|
825
931
|
// scope 之外的文件」,而不是「派发前工作区干不干净」。
|
|
@@ -831,11 +937,12 @@ const TOOLS = [
|
|
|
831
937
|
// 无基线(未走过 flow_dispatch)时退化为「全量改动」判定:
|
|
832
938
|
// 此时没有参照点,用全量更保守(fail-closed)。
|
|
833
939
|
const scopeNow = Array.isArray(state.card.scope) ? state.card.scope : [];
|
|
834
|
-
const
|
|
940
|
+
const scopeRootNow = resolveRepoRoot(a.cwd || process.cwd());
|
|
941
|
+
const current = enforceScope(scopeNow, scopeRootNow);
|
|
835
942
|
const baseline = Array.isArray(state.dispatch_baseline) ? state.dispatch_baseline : [];
|
|
836
943
|
const baselineSet = new Set(baseline.map((f) => path.normalize(f)));
|
|
837
944
|
const introduced = (current.checked || []).filter((f) => !baselineSet.has(path.normalize(f)));
|
|
838
|
-
const scopeCheck = enforceScope(scopeNow,
|
|
945
|
+
const scopeCheck = enforceScope(scopeNow, scopeRootNow, introduced);
|
|
839
946
|
if (!scopeCheck.ok) {
|
|
840
947
|
audit("decision", sessionId, {
|
|
841
948
|
kind: "scope_violation",
|
|
@@ -843,19 +950,21 @@ const TOOLS = [
|
|
|
843
950
|
violations: scopeCheck.violations,
|
|
844
951
|
introduced: introduced.length,
|
|
845
952
|
});
|
|
846
|
-
return fail("检测到越界改动,不能记录 PASS 裁定:" +
|
|
953
|
+
return fail(formatError("检测到越界改动,不能记录 PASS 裁定:" +
|
|
847
954
|
(scopeCheck.violations || []).join(", ") +
|
|
848
955
|
"。这些文件不在卡片 scope 白名单内。" +
|
|
849
|
-
"请把越界文件加入 scope(重新提交任务卡)后重试,或先撤销这些改动。");
|
|
956
|
+
"请把越界文件加入 scope(重新提交任务卡)后重试,或先撤销这些改动。"));
|
|
850
957
|
}
|
|
851
958
|
|
|
852
|
-
//
|
|
959
|
+
// ── 门禁 7/9(仅 PASS):裁定角色必须是 auditor ──
|
|
960
|
+
// role 门禁绑定到会话 ID(claimed_role),而非调用方自述字符串
|
|
853
961
|
if (verdict === "PASS" && state.claimed_role !== "auditor") {
|
|
854
962
|
audit("decision", sessionId, { kind: "verdict_denied", reason: "role 未绑定到 auditor 会话", claimed_role: state.claimed_role });
|
|
855
963
|
return fail("PASS 裁定必须由已领取 auditor 角色的会话(flow_claim role=auditor)落下。当前会话 claimed_role=" + (state.claimed_role || "null"));
|
|
856
964
|
}
|
|
857
965
|
|
|
858
|
-
//
|
|
966
|
+
// ── 门禁 8/9(仅 PASS):负对照证明测试有判别力 ──
|
|
967
|
+
// 证明 verify.cmd 真的在测「本次改动」。
|
|
859
968
|
//
|
|
860
969
|
// 「验证通过」本身不是证据:verify.cmd 可以是 `|| true` / `echo ok`,
|
|
861
970
|
// 改动前后都退 0,门禁却以为测试过了。负对照要求:
|
|
@@ -870,8 +979,8 @@ const TOOLS = [
|
|
|
870
979
|
}
|
|
871
980
|
if (lf.verdict !== "meaningful") {
|
|
872
981
|
audit("decision", sessionId, { kind: "verdict_denied", reason: "负对照未通过", falsify_verdict: lf.verdict });
|
|
873
|
-
return fail("负对照未通过(" + lf.verdict + "):" + (lf.reason || "") +
|
|
874
|
-
" 不能记录 PASS 裁定。请修正 verify.cmd 或改动后重试。");
|
|
982
|
+
return fail(formatError("负对照未通过(" + lf.verdict + "):" + (lf.reason || "") +
|
|
983
|
+
" 不能记录 PASS 裁定。请修正 verify.cmd 或改动后重试。"));
|
|
875
984
|
}
|
|
876
985
|
// 绑定:裁定的证据必须就是负对照里「改动后」的那次运行。
|
|
877
986
|
if (typeof lf.after === "object" && lf.after && typeof lf.after.hash === "string" &&
|
|
@@ -881,10 +990,11 @@ const TOOLS = [
|
|
|
881
990
|
"请重新调用 flow_falsify(它会把改动后的运行写为验证证据)。");
|
|
882
991
|
}
|
|
883
992
|
|
|
884
|
-
//
|
|
993
|
+
// ── 门禁 9/9(仅 PASS):双轴审查齐且无 FAIL ──
|
|
885
994
|
//
|
|
886
995
|
// 位置说明(重要):必须放在负对照**之后**。语义顺序是
|
|
887
|
-
// 「先证实验证有效 →
|
|
996
|
+
// 「先证实验证有效 → 再证审查到位」,九道门(2 无条件 + 7 仅 PASS)
|
|
997
|
+
// 各自独立、互不掩盖。
|
|
888
998
|
// 若前置,会让「未验证」「未派发」「未做负对照」这些更基础的问题被
|
|
889
999
|
// 双轴错误信息掩盖,调用方拿到的是不可操作的下一步。
|
|
890
1000
|
//
|
|
@@ -1101,7 +1211,7 @@ const TOOLS = [
|
|
|
1101
1211
|
handler: async (args) => {
|
|
1102
1212
|
try {
|
|
1103
1213
|
const a = args || {};
|
|
1104
|
-
const cwd = a.cwd || process.cwd();
|
|
1214
|
+
const cwd = resolveRepoRoot(a.cwd || process.cwd());
|
|
1105
1215
|
const paths = asStringArray(a.paths);
|
|
1106
1216
|
|
|
1107
1217
|
const proc = spawnSync("git", ["diff", "-U0", "--no-color", ...paths], {
|
|
@@ -1394,6 +1504,9 @@ const TOOLS = [
|
|
|
1394
1504
|
reason: r.reason,
|
|
1395
1505
|
before: { exitCode: r.before.exitCode, ok: r.before.ok, hash: r.before.hash },
|
|
1396
1506
|
after: { exitCode: r.after.exitCode, ok: r.after.ok, hash: r.after.hash },
|
|
1507
|
+
// 工作区还原是否被核对通过(ok=false 表示负对照过程中改动可能没被完整写回)。
|
|
1508
|
+
// 不参与 PASS 判定,但会随裁定一起暴露 —— 免得「改动消失」只留在 stderr 里。
|
|
1509
|
+
restore: r.restore ? { ok: r.restore.ok, checked: r.restore.checked, mismatched: r.restore.mismatched } : null,
|
|
1397
1510
|
};
|
|
1398
1511
|
// 把「改动后」的运行写为 last_verify —— 裁定的证据绑定到这一次运行。
|
|
1399
1512
|
state2.last_verify = {
|
|
@@ -1417,6 +1530,9 @@ const TOOLS = [
|
|
|
1417
1530
|
after_exit: r.after.exitCode,
|
|
1418
1531
|
before_hash: r.before.hash,
|
|
1419
1532
|
after_hash: r.after.hash,
|
|
1533
|
+
restore_ok: r.restore ? r.restore.ok : null,
|
|
1534
|
+
restore_mismatched: r.restore ? r.restore.mismatched : [],
|
|
1535
|
+
recovered_files: r.recovered ? r.recovered.files : 0,
|
|
1420
1536
|
});
|
|
1421
1537
|
|
|
1422
1538
|
const trunc = (s) => (typeof s === "string" && s.length > 2000 ? s.slice(0, 2000) + "…" : s);
|
|
@@ -1426,9 +1542,17 @@ const TOOLS = [
|
|
|
1426
1542
|
reason: r.reason,
|
|
1427
1543
|
before: { exitCode: r.before.exitCode, ok: r.before.ok, hash: r.before.hash, stdout: trunc(r.before.stdout), stderr: trunc(r.before.stderr) },
|
|
1428
1544
|
after: { exitCode: r.after.exitCode, ok: r.after.ok, hash: r.after.hash, stdout: trunc(r.after.stdout), stderr: trunc(r.after.stderr) },
|
|
1429
|
-
|
|
1545
|
+
// 工作区还原的核对结果(失败时备份已保留,下次调用会先尝试恢复)
|
|
1546
|
+
restore: r.restore || null,
|
|
1547
|
+
// 本次调用开始时恢复掉的「上一次被中断的负对照」残留
|
|
1548
|
+
recovered: r.recovered || null,
|
|
1549
|
+
note: (r.verdict === "meaningful"
|
|
1430
1550
|
? "负对照通过:测试有判别力,可以记 PASS。"
|
|
1431
|
-
: "负对照未通过:不能记 PASS。" + r.reason
|
|
1551
|
+
: "负对照未通过:不能记 PASS。" + r.reason) +
|
|
1552
|
+
(r.restore && r.restore.ok === false
|
|
1553
|
+
? " ⚠️ 但工作区还原未通过核对,以下文件与进入负对照前不一致:" +
|
|
1554
|
+
(r.restore.mismatched || []).join(", ") + "(备份已保留,请人工确认后修复)"
|
|
1555
|
+
: ""),
|
|
1432
1556
|
});
|
|
1433
1557
|
} catch (e) {
|
|
1434
1558
|
return fail(e && e.message ? e.message : String(e));
|
|
@@ -1460,9 +1584,11 @@ const TOOLS = [
|
|
|
1460
1584
|
const paths = Array.isArray(a.paths) ? a.paths : [];
|
|
1461
1585
|
// 不传 paths → 自动跑 `git diff --name-only` 取当前实际改动清单。
|
|
1462
1586
|
// 传了 paths → 用调用方给的清单(自查场景)。
|
|
1587
|
+
// 自查同样按仓库根基准,否则「自查没越界、裁定却报越界」会自相矛盾
|
|
1588
|
+
const scopeRoot = resolveRepoRoot(a.cwd || process.cwd());
|
|
1463
1589
|
const result = paths.length
|
|
1464
|
-
? enforceScope(scope,
|
|
1465
|
-
: enforceScope(scope,
|
|
1590
|
+
? enforceScope(scope, scopeRoot, paths)
|
|
1591
|
+
: enforceScope(scope, scopeRoot);
|
|
1466
1592
|
|
|
1467
1593
|
return ok({ ok: result.ok, scope, checked: paths.length ? paths : result.checked || [], ...result });
|
|
1468
1594
|
} catch (e) {
|
|
@@ -1792,11 +1918,19 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
|
|
|
1792
1918
|
return { content: [{ type: "text", text: "ERROR: " + validation.error }], isError: true };
|
|
1793
1919
|
}
|
|
1794
1920
|
|
|
1921
|
+
// 项目级敏感路径扩展:从 cwd 逐级向上找 `.carlos.json`(只追加,不能缩减)。
|
|
1922
|
+
// 放在这里统一加载,保证同一请求里所有路径判定用同一份规则;
|
|
1923
|
+
// 配置缺失 / 损坏时自动退回内置基线,不影响门禁。
|
|
1924
|
+
try {
|
|
1925
|
+
loadProjectSensitiveConfig(typeof args.cwd === "string" && args.cwd ? args.cwd : process.cwd());
|
|
1926
|
+
} catch { /* 配置不可读:保持内置基线 */ }
|
|
1927
|
+
|
|
1795
1928
|
try {
|
|
1796
1929
|
return await t.handler(args);
|
|
1797
1930
|
} catch (e) {
|
|
1931
|
+
const err = e && e.message ? e.message : String(e);
|
|
1798
1932
|
return {
|
|
1799
|
-
content: [{ type: "text", text: "ERROR: " + (
|
|
1933
|
+
content: [{ type: "text", text: "ERROR: " + formatError(err) }],
|
|
1800
1934
|
isError: true,
|
|
1801
1935
|
};
|
|
1802
1936
|
}
|
package/src/protocol.js
CHANGED
|
@@ -4,7 +4,10 @@
|
|
|
4
4
|
// 状态字段从 defaultState() 生成,而不是手写常量 ——
|
|
5
5
|
// 手写副本会漂移(历史上就漏过 claimed / claimed_role / activation_* 等 9 个字段),
|
|
6
6
|
// 而协议是 Agent 运行时读取的权威依据,漂移会让 Agent 按错误的字段名做决策。
|
|
7
|
-
// 代价:protocol.js 依赖 state.js
|
|
7
|
+
// 代价:protocol.js 依赖 state.js(纯数据模块,无副作用,无循环依赖),
|
|
8
|
+
// 并依赖 node:fs / node:path 读取项目级敏感规则配置(见文件末尾)。
|
|
9
|
+
import fs from "node:fs";
|
|
10
|
+
import path from "node:path";
|
|
8
11
|
import { defaultState } from "./state.js";
|
|
9
12
|
|
|
10
13
|
export const GUIDE_MODE = { ROSTER: "主agent(Orchestrator),开发(executor+developer),测试(executor+tester),审核(auditor+reviewer)", TALKING_POINTS: ["一次只说一件事", "术语给类比", "给选择题不抛开放式问题", "复述意图", "明示能力边界"], REPORT_TEMPLATE: "【在做什么】/【已经完成】/【要你选】/【还有什么风险】" };
|
|
@@ -71,6 +74,168 @@ const SENSITIVE_EXTENSIONS = new Set([
|
|
|
71
74
|
".kdbx", ".kdb", ".gpg", ".asc", ".crt", ".cer", ".der",
|
|
72
75
|
]);
|
|
73
76
|
|
|
77
|
+
// ---- 项目级敏感路径扩展(只能追加,不能缩减)-------------------------------
|
|
78
|
+
//
|
|
79
|
+
// 为什么需要:内置名单(.env / 私钥 / 锁文件 / migrations 目录…)是**安全基线**,
|
|
80
|
+
// 但每个项目的敏感面并不相同 —— 有的私有证书目录叫 `secret_material/`,
|
|
81
|
+
// 有的对账账本放在 `billing/ledger/`。过去这些只能靠人肉提醒,
|
|
82
|
+
// 现在允许项目在仓库根放一个 `.carlos.json` 追加自己的规则:
|
|
83
|
+
//
|
|
84
|
+
// { "sensitive": { "names": ["pay_api_key.txt"], "segments": ["ledger"],
|
|
85
|
+
// "extensions": [".vault"], "prefixes": ["billing/ledger/"] } }
|
|
86
|
+
//
|
|
87
|
+
// 红线(AGENTS.md 第 1 条「门禁只许收紧,不许放宽」):
|
|
88
|
+
// · 只能**追加**:本模块不提供任何删减 / 豁免 / 否定语法;
|
|
89
|
+
// · 以 `!` 或 `-` 开头的条目一律忽略并写 stderr —— 防止有人用
|
|
90
|
+
// `"!package.json"` 试图把内置基线里的项放出去;
|
|
91
|
+
// · 配置读不到 / 解析失败 → 保持内置基线(不会因为配置坏了就放宽门禁)。
|
|
92
|
+
const PROJECT_CONFIG_FILE = ".carlos.json";
|
|
93
|
+
const MAX_CONFIG_WALK = 12; // 向上找配置的最大层数,防止符号链接成环
|
|
94
|
+
|
|
95
|
+
const EXTRA_SENSITIVE = {
|
|
96
|
+
names: new Set(),
|
|
97
|
+
segments: new Set(),
|
|
98
|
+
extensions: new Set(),
|
|
99
|
+
prefixes: [],
|
|
100
|
+
};
|
|
101
|
+
let extraConfigKey = "";
|
|
102
|
+
let extraConfigFile = "";
|
|
103
|
+
|
|
104
|
+
const normalizeRule = (v) => String(v == null ? "" : v).trim().replace(/\\/g, "/").toLowerCase();
|
|
105
|
+
|
|
106
|
+
function isNegated(rule) {
|
|
107
|
+
return rule.startsWith("!") || rule.startsWith("-");
|
|
108
|
+
}
|
|
109
|
+
|
|
110
|
+
function addRules(list, target, kind) {
|
|
111
|
+
let added = 0;
|
|
112
|
+
let ignored = 0;
|
|
113
|
+
for (const raw of Array.isArray(list) ? list : []) {
|
|
114
|
+
const n = normalizeRule(raw);
|
|
115
|
+
if (!n) continue;
|
|
116
|
+
if (isNegated(n)) {
|
|
117
|
+
// 不允许「取消敏感」语法:只提示,不生效(门禁只许收紧)
|
|
118
|
+
ignored++;
|
|
119
|
+
try {
|
|
120
|
+
process.stderr.write(`[carlos-flow] 已忽略否定式敏感规则(不允许放宽门禁):${raw}\n`);
|
|
121
|
+
} catch { /* stderr 不可写时静默 */ }
|
|
122
|
+
continue;
|
|
123
|
+
}
|
|
124
|
+
if (kind === "extension") {
|
|
125
|
+
const ext = n.startsWith(".") ? n : "." + n;
|
|
126
|
+
if (!target.has(ext)) { target.add(ext); added++; }
|
|
127
|
+
} else if (kind === "prefix") {
|
|
128
|
+
const p = n.endsWith("/") ? n : n + "/";
|
|
129
|
+
if (!target.includes(p)) { target.push(p); added++; }
|
|
130
|
+
} else if (!target.has(n)) {
|
|
131
|
+
target.add(n);
|
|
132
|
+
added++;
|
|
133
|
+
}
|
|
134
|
+
}
|
|
135
|
+
return { added, ignored };
|
|
136
|
+
}
|
|
137
|
+
|
|
138
|
+
/** 清空项目级扩展,回到内置基线(测试与「换项目」场景用)。 */
|
|
139
|
+
export function resetSensitiveRules() {
|
|
140
|
+
EXTRA_SENSITIVE.names.clear();
|
|
141
|
+
EXTRA_SENSITIVE.segments.clear();
|
|
142
|
+
EXTRA_SENSITIVE.extensions.clear();
|
|
143
|
+
EXTRA_SENSITIVE.prefixes.length = 0;
|
|
144
|
+
extraConfigKey = "";
|
|
145
|
+
extraConfigFile = "";
|
|
146
|
+
}
|
|
147
|
+
|
|
148
|
+
/**
|
|
149
|
+
* 追加一份项目级敏感规则(**只增不减**)。
|
|
150
|
+
* 接受 `.carlos.json` 的整份内容(读 `sensitive` 键),也接受直接给出的规则对象。
|
|
151
|
+
* 返回实际生效的条数与被忽略的否定式条数,便于 status / 测试断言「真的加上了」。
|
|
152
|
+
*/
|
|
153
|
+
export function addProjectSensitiveRules(cfg) {
|
|
154
|
+
const root = cfg && typeof cfg === "object" && !Array.isArray(cfg) ? cfg : {};
|
|
155
|
+
const s = root.sensitive && typeof root.sensitive === "object" && !Array.isArray(root.sensitive)
|
|
156
|
+
? root.sensitive
|
|
157
|
+
: root;
|
|
158
|
+
const out = { names: 0, segments: 0, extensions: 0, prefixes: 0, ignored: 0 };
|
|
159
|
+
const n = addRules(s.names, EXTRA_SENSITIVE.names, "name");
|
|
160
|
+
out.names = n.added; out.ignored += n.ignored;
|
|
161
|
+
const sg = addRules(s.segments, EXTRA_SENSITIVE.segments, "segment");
|
|
162
|
+
out.segments = sg.added; out.ignored += sg.ignored;
|
|
163
|
+
const ex = addRules(s.extensions, EXTRA_SENSITIVE.extensions, "extension");
|
|
164
|
+
out.extensions = ex.added; out.ignored += ex.ignored;
|
|
165
|
+
const px = addRules(s.prefixes, EXTRA_SENSITIVE.prefixes, "prefix");
|
|
166
|
+
out.prefixes = px.added; out.ignored += px.ignored;
|
|
167
|
+
return out;
|
|
168
|
+
}
|
|
169
|
+
|
|
170
|
+
/** 当前生效的敏感规则快照(内置基线 + 项目扩展),用于诊断与测试。 */
|
|
171
|
+
export function sensitiveRulesSnapshot() {
|
|
172
|
+
return {
|
|
173
|
+
builtin: {
|
|
174
|
+
names: SENSITIVE_NAMES.size,
|
|
175
|
+
segments: SENSITIVE_SEGMENTS.size,
|
|
176
|
+
extensions: SENSITIVE_EXTENSIONS.size,
|
|
177
|
+
},
|
|
178
|
+
extra: {
|
|
179
|
+
names: Array.from(EXTRA_SENSITIVE.names).sort(),
|
|
180
|
+
segments: Array.from(EXTRA_SENSITIVE.segments).sort(),
|
|
181
|
+
extensions: Array.from(EXTRA_SENSITIVE.extensions).sort(),
|
|
182
|
+
prefixes: EXTRA_SENSITIVE.prefixes.slice().sort(),
|
|
183
|
+
},
|
|
184
|
+
configFile: extraConfigFile || null,
|
|
185
|
+
};
|
|
186
|
+
}
|
|
187
|
+
|
|
188
|
+
/**
|
|
189
|
+
* 从 startDir 逐级向上找 `.carlos.json`,加载其中的 `sensitive` 规则。
|
|
190
|
+
*
|
|
191
|
+
* 缓存:按「文件路径 + mtime + size」判定是否重复加载 —— 每次工具调用都会走一遍,
|
|
192
|
+
* 不做缓存的话每个请求都要重新读盘解析。
|
|
193
|
+
* 找不到配置时**清空扩展**(回到内置基线),避免上一个项目追加的规则污染本项目。
|
|
194
|
+
*/
|
|
195
|
+
export function loadProjectSensitiveConfig(startDir) {
|
|
196
|
+
const start = typeof startDir === "string" && startDir ? path.resolve(startDir) : process.cwd();
|
|
197
|
+
let dir = start;
|
|
198
|
+
for (let i = 0; i < MAX_CONFIG_WALK; i++) {
|
|
199
|
+
const file = path.join(dir, PROJECT_CONFIG_FILE);
|
|
200
|
+
try {
|
|
201
|
+
const st = fs.statSync(file);
|
|
202
|
+
const key = file + "|" + st.mtimeMs + "|" + st.size;
|
|
203
|
+
if (key === extraConfigKey) {
|
|
204
|
+
return { loaded: extraConfigFile === file, file, cached: true };
|
|
205
|
+
}
|
|
206
|
+
let parsed = null;
|
|
207
|
+
let parseError = null;
|
|
208
|
+
try {
|
|
209
|
+
parsed = JSON.parse(fs.readFileSync(file, "utf8"));
|
|
210
|
+
} catch (e) {
|
|
211
|
+
parseError = e && e.message ? e.message : String(e);
|
|
212
|
+
}
|
|
213
|
+
resetSensitiveRules();
|
|
214
|
+
if (parseError) {
|
|
215
|
+
// 配置坏了 → 保持内置基线,绝不因此放宽门禁
|
|
216
|
+
try {
|
|
217
|
+
process.stderr.write(`[carlos-flow] .carlos.json 解析失败,已退回内置敏感基线:${parseError}\n`);
|
|
218
|
+
} catch { /* ignore */ }
|
|
219
|
+
extraConfigKey = key;
|
|
220
|
+
return { loaded: false, file, error: parseError };
|
|
221
|
+
}
|
|
222
|
+
const applied = addProjectSensitiveRules(parsed);
|
|
223
|
+
extraConfigKey = key;
|
|
224
|
+
extraConfigFile = file;
|
|
225
|
+
return { loaded: true, file, applied };
|
|
226
|
+
} catch (e) {
|
|
227
|
+
if (!e || e.code !== "ENOENT") {
|
|
228
|
+
// 权限等其它错误:保持当前规则继续向上找
|
|
229
|
+
}
|
|
230
|
+
}
|
|
231
|
+
const parent = path.dirname(dir);
|
|
232
|
+
if (parent === dir) break;
|
|
233
|
+
dir = parent;
|
|
234
|
+
}
|
|
235
|
+
if (extraConfigKey) resetSensitiveRules();
|
|
236
|
+
return { loaded: false, file: null };
|
|
237
|
+
}
|
|
238
|
+
|
|
74
239
|
export function isSensitive(rel) {
|
|
75
240
|
if (typeof rel !== "string" || rel.length === 0) return false;
|
|
76
241
|
const normalized = rel.replace(/\\/g, "/").toLowerCase();
|
|
@@ -85,6 +250,22 @@ export function isSensitive(rel) {
|
|
|
85
250
|
for (const ext of SENSITIVE_EXTENSIONS) {
|
|
86
251
|
if (base.endsWith(ext)) return true;
|
|
87
252
|
}
|
|
253
|
+
|
|
254
|
+
// 项目级扩展(只能追加;为空时零开销)
|
|
255
|
+
if (EXTRA_SENSITIVE.names.size && EXTRA_SENSITIVE.names.has(base)) return true;
|
|
256
|
+
if (EXTRA_SENSITIVE.segments.size) {
|
|
257
|
+
for (const seg of segments.slice(0, -1)) {
|
|
258
|
+
if (EXTRA_SENSITIVE.segments.has(seg)) return true;
|
|
259
|
+
}
|
|
260
|
+
}
|
|
261
|
+
if (EXTRA_SENSITIVE.extensions.size) {
|
|
262
|
+
for (const ext of EXTRA_SENSITIVE.extensions) {
|
|
263
|
+
if (base.endsWith(ext)) return true;
|
|
264
|
+
}
|
|
265
|
+
}
|
|
266
|
+
for (const prefix of EXTRA_SENSITIVE.prefixes) {
|
|
267
|
+
if (normalized === prefix.slice(0, -1) || normalized.startsWith(prefix)) return true;
|
|
268
|
+
}
|
|
88
269
|
return false;
|
|
89
270
|
}
|
|
90
271
|
|