rungate 0.2.1 → 0.3.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/bin/rungate.ts +70 -0
- package/lib/aes-calculator.ts +66 -0
- package/lib/agent-audit.ts +139 -0
- package/lib/agent-brief-validation.ts +359 -0
- package/lib/agents-md-refs.ts +90 -0
- package/lib/bash-file-read.ts +197 -0
- package/lib/behavioral-cache.ts +78 -0
- package/lib/branch-cleanup.ts +234 -0
- package/lib/brief-context-parser.ts +35 -0
- package/lib/canary.ts +117 -0
- package/lib/check-registry.ts +226 -0
- package/lib/ci-checkout.ts +400 -0
- package/lib/cli-commands.ts +137 -0
- package/lib/compliance-backfill.ts +220 -0
- package/lib/compliance-report.ts +504 -0
- package/lib/compliance.ts +361 -0
- package/lib/config-loader.ts +255 -0
- package/lib/conformity.ts +1818 -131
- package/lib/container-provenance.ts +230 -0
- package/lib/create-brief.ts +150 -0
- package/lib/create-sc.ts +272 -0
- package/lib/deep-merge.ts +69 -0
- package/lib/dev-liveness.ts +214 -0
- package/lib/directive-extractor.ts +210 -0
- package/lib/distribution-standing.ts +113 -0
- package/lib/doc-hygiene.ts +238 -0
- package/lib/eval-criteria.ts +6 -0
- package/lib/evidence-portability.ts +123 -0
- package/lib/evidence-prevalidator.ts +390 -0
- package/lib/evidence-required.ts +150 -0
- package/lib/evidence-satisfiability.ts +288 -0
- package/lib/frontmatter.ts +163 -0
- package/lib/gap-scanner.ts +348 -0
- package/lib/gate-enforcement.ts +366 -0
- package/lib/generators/agent-briefs.ts +136 -0
- package/lib/generators/agents-md.ts +506 -0
- package/lib/generators/code-map.ts +60 -0
- package/lib/generators/types.ts +184 -0
- package/lib/git-ref-normalizer.ts +107 -0
- package/lib/github.ts +539 -0
- package/lib/harness-identity.ts +63 -0
- package/lib/hill-climb.ts +164 -0
- package/lib/instruction-effectiveness.ts +131 -0
- package/lib/issue-closure-audit.ts +225 -0
- package/lib/issue-create-override.ts +343 -0
- package/lib/js-top-level-code.ts +250 -0
- package/lib/liveness-contradiction.ts +149 -0
- package/lib/organize.ts +505 -0
- package/lib/paths.ts +197 -6
- package/lib/post-fix-verify.ts +157 -0
- package/lib/prior-branch.ts +489 -0
- package/lib/project-state-shape.ts +166 -0
- package/lib/promote-outputs.ts +156 -0
- package/lib/prove-label-gate.ts +35 -0
- package/lib/reachability.ts +302 -0
- package/lib/release-preflight.ts +186 -0
- package/lib/rule-health-pipeline.ts +264 -0
- package/lib/rule-health-trend.ts +161 -0
- package/lib/rule-provenance.ts +149 -0
- package/lib/rule-registry.ts +128 -0
- package/lib/rungate-schema.ts +114 -4
- package/lib/sc-claim-forms.ts +179 -0
- package/lib/sc-cover.ts +150 -0
- package/lib/sc-guard.ts +157 -0
- package/lib/sc-ids.ts +344 -0
- package/lib/scaffold/defaults.ts +165 -0
- package/lib/scaffold/managed-workflow.ts +370 -0
- package/lib/scaffold/owned-files.ts +265 -0
- package/lib/scaffold/steps.ts +2680 -0
- package/lib/scanner.ts +701 -0
- package/lib/screenshot-upload.ts +73 -0
- package/lib/secret-patterns.ts +112 -0
- package/lib/security-verdict.ts +616 -0
- package/lib/signal-phrases.ts +1 -0
- package/lib/spec-change-conformity.ts +80 -0
- package/lib/spec-files.ts +62 -0
- package/lib/spec-registry.ts +133 -0
- package/lib/spec-updater.ts +96 -0
- package/lib/stale-cleanup.ts +224 -0
- package/lib/stale-issue-scanner.ts +36 -0
- package/lib/strip-js-comments.ts +269 -0
- package/lib/suite-measurement.ts +228 -0
- package/lib/task-completion-checks.ts +177 -0
- package/lib/test-suite-lock.ts +1136 -0
- package/lib/transcript-checker.ts +1140 -0
- package/lib/validators/spec-validators.ts +171 -0
- package/lib/verdict-capture.ts +73 -0
- package/lib/verified-push.ts +358 -0
- package/lib/workflow-security.ts +174 -0
- package/lib/worktree-cleanup.ts +250 -0
- package/lib/worktree-collect.ts +283 -0
- package/lib/worktree-isolation.ts +82 -0
- package/package.json +24 -2
- package/prompts/ac-adversary.md +14 -2
- package/prompts/aditi.md +5 -0
- package/prompts/blast-radius.md +5 -0
- package/prompts/container-verify.md +5 -0
- package/prompts/discovery.md +4 -0
- package/prompts/environment.md +5 -0
- package/prompts/evidence-hierarchy.md +5 -0
- package/prompts/evidence-validator.md +11 -0
- package/prompts/marcus.md +5 -0
- package/prompts/prevention.md +5 -0
- package/prompts/prove-reproducer.md +12 -0
- package/prompts/quinn-decision-tree.md +5 -0
- package/prompts/quinn-ui-brief.md +5 -0
- package/prompts/quinn.md +5 -0
- package/prompts/rca.md +5 -0
- package/prompts/read-before-write.md +4 -0
- package/prompts/regression.md +5 -0
- package/prompts/serena.md +5 -0
- package/scripts/audit-specs.ts +464 -0
- package/scripts/convert-spec.ts +293 -0
- package/scripts/create-sc.ts +92 -0
- package/scripts/create-spec.ts +166 -0
- package/scripts/extract-constraints.ts +4 -3
- package/scripts/generate-code-map.ts +1 -1
- package/scripts/scaffold-project.ts +138 -1426
- package/scripts/sync-spec-tests.ts +211 -126
|
@@ -0,0 +1,504 @@
|
|
|
1
|
+
import { appendFileSync, readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
|
|
2
|
+
import { dirname, join } from "path";
|
|
3
|
+
|
|
4
|
+
export interface ComplianceEntry {
|
|
5
|
+
timestamp: string;
|
|
6
|
+
issue: string;
|
|
7
|
+
role: string;
|
|
8
|
+
scores: Record<string, string>;
|
|
9
|
+
total: number;
|
|
10
|
+
followed: number;
|
|
11
|
+
pct: number;
|
|
12
|
+
flagged: string[];
|
|
13
|
+
}
|
|
14
|
+
|
|
15
|
+
export interface TrendLine {
|
|
16
|
+
compId: string;
|
|
17
|
+
rule: string;
|
|
18
|
+
lastN: string[];
|
|
19
|
+
passRate: number;
|
|
20
|
+
direction: "improving" | "stable" | "declining";
|
|
21
|
+
}
|
|
22
|
+
|
|
23
|
+
export interface ComplianceReport {
|
|
24
|
+
role: string;
|
|
25
|
+
issue: string;
|
|
26
|
+
current: { followed: number; total: number; pct: number };
|
|
27
|
+
threshold: number;
|
|
28
|
+
belowThreshold: boolean;
|
|
29
|
+
trend: { pcts: number[]; direction: string };
|
|
30
|
+
compTrends: TrendLine[];
|
|
31
|
+
alerts: string[];
|
|
32
|
+
}
|
|
33
|
+
|
|
34
|
+
const TREND_WINDOW = 5;
|
|
35
|
+
const ALERT_THRESHOLD = 0.4;
|
|
36
|
+
|
|
37
|
+
export function appendComplianceHistory(
|
|
38
|
+
historyPath: string,
|
|
39
|
+
entry: ComplianceEntry
|
|
40
|
+
): void {
|
|
41
|
+
const dir = dirname(historyPath);
|
|
42
|
+
if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
|
|
43
|
+
appendFileSync(historyPath, JSON.stringify(entry) + "\n");
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
export function loadComplianceHistory(historyPath: string): ComplianceEntry[] {
|
|
47
|
+
if (!existsSync(historyPath)) return [];
|
|
48
|
+
return readFileSync(historyPath, "utf-8")
|
|
49
|
+
.trim()
|
|
50
|
+
.split("\n")
|
|
51
|
+
.filter(Boolean)
|
|
52
|
+
.map((line) => JSON.parse(line));
|
|
53
|
+
}
|
|
54
|
+
|
|
55
|
+
function computeDirection(pcts: number[]): string {
|
|
56
|
+
if (pcts.length < 2) return "stable";
|
|
57
|
+
const first = pcts.slice(0, Math.ceil(pcts.length / 2));
|
|
58
|
+
const second = pcts.slice(Math.ceil(pcts.length / 2));
|
|
59
|
+
const avg = (arr: number[]) => arr.reduce((a, b) => a + b, 0) / arr.length;
|
|
60
|
+
const diff = avg(second) - avg(first);
|
|
61
|
+
if (diff > 5) return "improving";
|
|
62
|
+
if (diff < -5) return "declining";
|
|
63
|
+
return "stable";
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
const COMP_RULES: Record<string, string> = {
|
|
67
|
+
"COMP-1": "AGENTS.md context",
|
|
68
|
+
"COMP-2": "Suite run limit",
|
|
69
|
+
"COMP-3": "Golden fixture pattern",
|
|
70
|
+
"COMP-4": "Spec-drift hash update",
|
|
71
|
+
"COMP-5": "Governing spec context",
|
|
72
|
+
"COMP-6": "No duplicate reads",
|
|
73
|
+
"COMP-7": "No cat/head via Bash",
|
|
74
|
+
"COMP-8": "PROJECT-STATE context",
|
|
75
|
+
"COMP-9": "Tool call budget",
|
|
76
|
+
"COMP-10": "Grep:Read ratio",
|
|
77
|
+
"COMP-11": "Coding principles context",
|
|
78
|
+
"COMP-12": "Grep before Read",
|
|
79
|
+
"COMP-13": "TDD ordering",
|
|
80
|
+
};
|
|
81
|
+
|
|
82
|
+
export function generateComplianceReport(
|
|
83
|
+
current: ComplianceEntry,
|
|
84
|
+
history: ComplianceEntry[],
|
|
85
|
+
threshold: number
|
|
86
|
+
): ComplianceReport {
|
|
87
|
+
const roleHistory = history.filter((h) => h.role === current.role);
|
|
88
|
+
const window = roleHistory.slice(-TREND_WINDOW);
|
|
89
|
+
const allPcts = [...window.map((h) => h.pct), current.pct];
|
|
90
|
+
|
|
91
|
+
const allCompIds = new Set<string>();
|
|
92
|
+
for (const entry of [...window, current]) {
|
|
93
|
+
for (const id of Object.keys(entry.scores)) allCompIds.add(id);
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
const compTrends: TrendLine[] = [];
|
|
97
|
+
for (const compId of [...allCompIds].sort()) {
|
|
98
|
+
const verdicts = [...window, current].map(
|
|
99
|
+
(e) => e.scores[compId] || "N/A"
|
|
100
|
+
);
|
|
101
|
+
const checkable = verdicts.filter((v) => v !== "N/A");
|
|
102
|
+
const passed = checkable.filter((v) => v === "FOLLOWED").length;
|
|
103
|
+
const passRate = checkable.length > 0 ? passed / checkable.length : 0;
|
|
104
|
+
|
|
105
|
+
if (checkable.length < 2) {
|
|
106
|
+
compTrends.push({ compId, rule: COMP_RULES[compId] || compId, lastN: verdicts, passRate, direction: "stable" });
|
|
107
|
+
continue;
|
|
108
|
+
}
|
|
109
|
+
const firstHalf = checkable.slice(0, Math.ceil(checkable.length / 2));
|
|
110
|
+
const secondHalf = checkable.slice(Math.ceil(checkable.length / 2));
|
|
111
|
+
const firstRate =
|
|
112
|
+
firstHalf.length > 0
|
|
113
|
+
? firstHalf.filter((v) => v === "FOLLOWED").length / firstHalf.length
|
|
114
|
+
: 0;
|
|
115
|
+
const secondRate =
|
|
116
|
+
secondHalf.length > 0
|
|
117
|
+
? secondHalf.filter((v) => v === "FOLLOWED").length / secondHalf.length
|
|
118
|
+
: 0;
|
|
119
|
+
let direction: TrendLine["direction"] = "stable";
|
|
120
|
+
if (secondRate - firstRate > 0.2) direction = "improving";
|
|
121
|
+
else if (firstRate - secondRate > 0.2) direction = "declining";
|
|
122
|
+
|
|
123
|
+
compTrends.push({
|
|
124
|
+
compId,
|
|
125
|
+
rule: COMP_RULES[compId] || compId,
|
|
126
|
+
lastN: verdicts,
|
|
127
|
+
passRate,
|
|
128
|
+
direction,
|
|
129
|
+
});
|
|
130
|
+
}
|
|
131
|
+
|
|
132
|
+
const alerts: string[] = [];
|
|
133
|
+
for (const ct of compTrends) {
|
|
134
|
+
if (!ct.compId.startsWith("COMP-") && !ct.compId.startsWith("DIR-")) continue;
|
|
135
|
+
if (ct.passRate <= ALERT_THRESHOLD && ct.lastN.length >= 2) {
|
|
136
|
+
alerts.push(
|
|
137
|
+
`${ct.compId}: ${Math.round(ct.passRate * 100)}% pass rate — ${ct.rule} needs improvement`
|
|
138
|
+
);
|
|
139
|
+
}
|
|
140
|
+
if (ct.direction === "declining" && ct.lastN.length >= 3) {
|
|
141
|
+
alerts.push(`${ct.compId}: declining trend — was passing, now failing`);
|
|
142
|
+
}
|
|
143
|
+
}
|
|
144
|
+
|
|
145
|
+
if (current.pct < threshold) {
|
|
146
|
+
alerts.unshift(
|
|
147
|
+
`Overall score ${current.pct}% is BELOW ${threshold}% threshold`
|
|
148
|
+
);
|
|
149
|
+
}
|
|
150
|
+
|
|
151
|
+
return {
|
|
152
|
+
role: current.role,
|
|
153
|
+
issue: current.issue,
|
|
154
|
+
current: {
|
|
155
|
+
followed: current.followed,
|
|
156
|
+
total: current.total,
|
|
157
|
+
pct: current.pct,
|
|
158
|
+
},
|
|
159
|
+
threshold,
|
|
160
|
+
belowThreshold: current.pct < threshold,
|
|
161
|
+
trend: { pcts: allPcts, direction: computeDirection(allPcts) },
|
|
162
|
+
compTrends,
|
|
163
|
+
alerts,
|
|
164
|
+
};
|
|
165
|
+
}
|
|
166
|
+
|
|
167
|
+
export function formatComplianceReport(report: ComplianceReport): string {
|
|
168
|
+
const lines: string[] = [];
|
|
169
|
+
const bar = "═".repeat(50);
|
|
170
|
+
|
|
171
|
+
lines.push(bar);
|
|
172
|
+
lines.push(`COMPLIANCE REPORT — ${report.role} (${report.issue})`);
|
|
173
|
+
lines.push(bar);
|
|
174
|
+
|
|
175
|
+
const statusIcon = report.belowThreshold ? "❌ BELOW THRESHOLD" : "✅";
|
|
176
|
+
lines.push(
|
|
177
|
+
`Score: ${report.current.followed}/${report.current.total} (${report.current.pct}%) ${statusIcon}`
|
|
178
|
+
);
|
|
179
|
+
lines.push(`Threshold: ${report.threshold}%`);
|
|
180
|
+
|
|
181
|
+
if (report.trend.pcts.length > 1) {
|
|
182
|
+
const arrow =
|
|
183
|
+
report.trend.direction === "improving"
|
|
184
|
+
? "▲"
|
|
185
|
+
: report.trend.direction === "declining"
|
|
186
|
+
? "▼"
|
|
187
|
+
: "→";
|
|
188
|
+
lines.push(
|
|
189
|
+
`Trend (last ${report.trend.pcts.length}): ${report.trend.pcts.join("% → ")}% ${arrow} ${report.trend.direction}`
|
|
190
|
+
);
|
|
191
|
+
}
|
|
192
|
+
|
|
193
|
+
const compChecks = report.compTrends.filter((ct) => ct.compId.startsWith("COMP-"));
|
|
194
|
+
const dirChecks = report.compTrends.filter((ct) => ct.compId.startsWith("DIR-"));
|
|
195
|
+
|
|
196
|
+
if (compChecks.length > 0) {
|
|
197
|
+
lines.push("");
|
|
198
|
+
lines.push("Per-COMP breakdown:");
|
|
199
|
+
for (const ct of compChecks) {
|
|
200
|
+
const icon = ct.passRate >= 0.8 ? "✅" : ct.passRate >= 0.5 ? "⚠️" : "❌";
|
|
201
|
+
const pctStr = Math.round(ct.passRate * 100);
|
|
202
|
+
lines.push(
|
|
203
|
+
` ${icon} ${ct.compId.padEnd(8)} ${ct.rule.padEnd(28)} ${pctStr}% pass`
|
|
204
|
+
);
|
|
205
|
+
}
|
|
206
|
+
}
|
|
207
|
+
|
|
208
|
+
if (dirChecks.length > 0) {
|
|
209
|
+
const dirPass = dirChecks.filter((ct) => ct.passRate >= 0.5).length;
|
|
210
|
+
lines.push(
|
|
211
|
+
`\nDirective checks: ${dirPass}/${dirChecks.length} passing (${dirChecks.length - dirPass} need attention)`
|
|
212
|
+
);
|
|
213
|
+
}
|
|
214
|
+
|
|
215
|
+
const compAlerts = report.alerts.filter(
|
|
216
|
+
(a) => a.startsWith("COMP-") || a.startsWith("Overall")
|
|
217
|
+
);
|
|
218
|
+
if (compAlerts.length > 0) {
|
|
219
|
+
lines.push("");
|
|
220
|
+
lines.push("ALERTS:");
|
|
221
|
+
for (const alert of compAlerts) {
|
|
222
|
+
lines.push(` ⚠️ ${alert}`);
|
|
223
|
+
}
|
|
224
|
+
}
|
|
225
|
+
|
|
226
|
+
lines.push(bar);
|
|
227
|
+
return lines.join("\n");
|
|
228
|
+
}
|
|
229
|
+
|
|
230
|
+
// ── Config-driven compliance maps ────────────────────────
|
|
231
|
+
// All mappings (DIR→COMP, reinforcements, tier promotions) are read
|
|
232
|
+
// from .claude/rungate/compliance.json. Hardcoded fallbacks exist only
|
|
233
|
+
// for backward compatibility when the config directory doesn't exist.
|
|
234
|
+
import {
|
|
235
|
+
loadComplianceConfig,
|
|
236
|
+
buildDirToCompMap,
|
|
237
|
+
buildReinforcementMap,
|
|
238
|
+
buildTierPromotionMap,
|
|
239
|
+
type ComplianceConfig,
|
|
240
|
+
} from "./config-loader.js";
|
|
241
|
+
|
|
242
|
+
let _complianceCache: ComplianceConfig | null | undefined;
|
|
243
|
+
let _projectRoot: string | undefined;
|
|
244
|
+
|
|
245
|
+
export function setComplianceProjectRoot(root: string): void {
|
|
246
|
+
_projectRoot = root;
|
|
247
|
+
_complianceCache = undefined;
|
|
248
|
+
}
|
|
249
|
+
|
|
250
|
+
function getComplianceConfig(): ComplianceConfig | null {
|
|
251
|
+
if (_complianceCache !== undefined) return _complianceCache;
|
|
252
|
+
if (_projectRoot) {
|
|
253
|
+
_complianceCache = loadComplianceConfig(_projectRoot);
|
|
254
|
+
} else {
|
|
255
|
+
_complianceCache = null;
|
|
256
|
+
}
|
|
257
|
+
return _complianceCache;
|
|
258
|
+
}
|
|
259
|
+
|
|
260
|
+
function getDirToComp(): Record<string, string> {
|
|
261
|
+
const config = getComplianceConfig();
|
|
262
|
+
if (config) return buildDirToCompMap(config);
|
|
263
|
+
return {
|
|
264
|
+
"DIR-L29": "COMP-2",
|
|
265
|
+
"DIR-L25": "COMP-7",
|
|
266
|
+
"DIR-L31": "COMP-6",
|
|
267
|
+
"DIR-L23": "COMP-6",
|
|
268
|
+
};
|
|
269
|
+
}
|
|
270
|
+
|
|
271
|
+
function getReinforcementMap(): Record<string, string> {
|
|
272
|
+
const config = getComplianceConfig();
|
|
273
|
+
if (config) return buildReinforcementMap(config);
|
|
274
|
+
return {
|
|
275
|
+
"COMP-7": "NEVER read a file with cat, head, or tail via Bash — use Read with offset/limit. Piping output into head/tail as a stdin filter is fine (no file operand).",
|
|
276
|
+
"COMP-12": "Grep BEFORE Read for any file not in Key Files. Find the section, then Read with offset/limit.",
|
|
277
|
+
"COMP-13": "Write the test file BEFORE the implementation file. Tool-call order is mechanically checked.",
|
|
278
|
+
"COMP-6": "Read each file exactly ONCE. Use offset/limit to get what you need in one pass.",
|
|
279
|
+
"COMP-9": "Total tool calls must stay under 40. Batch related reads, use targeted tests.",
|
|
280
|
+
// No number here. The guard owns it, the reinforcement points at the
|
|
281
|
+
// guard, and a copy of "TWICE" in an agent's brief outlives any change to
|
|
282
|
+
// the rate — which is how an agent ends up obeying a limit that no longer
|
|
283
|
+
// exists while the grader measures a different one.
|
|
284
|
+
"COMP-2": "Run the full suite (bun test) sparingly. A per-worker rate limit enforces this mechanically and will refuse the run; do not plan around a specific number. Use targeted tests for iteration.",
|
|
285
|
+
};
|
|
286
|
+
}
|
|
287
|
+
|
|
288
|
+
function getTierPromotions(): Record<string, { tier: 2 | 3; promotion: string }> {
|
|
289
|
+
const config = getComplianceConfig();
|
|
290
|
+
if (config) return buildTierPromotionMap(config);
|
|
291
|
+
return {
|
|
292
|
+
"COMP-7": { tier: 3, promotion: "Deploy BashToolGuard hook" },
|
|
293
|
+
"COMP-12": { tier: 2, promotion: "Add grep-before-read reinforcement" },
|
|
294
|
+
"COMP-13": { tier: 2, promotion: "Add TDD-sequence reinforcement" },
|
|
295
|
+
"COMP-6": { tier: 2, promotion: "Add duplicate-read detection reinforcement" },
|
|
296
|
+
"COMP-9": { tier: 3, promotion: "Deploy tool-call budget hook" },
|
|
297
|
+
"COMP-2": { tier: 3, promotion: "Deploy test-run limiter hook" },
|
|
298
|
+
};
|
|
299
|
+
}
|
|
300
|
+
|
|
301
|
+
function getThresholds(): { consecutive: number; promote: number } {
|
|
302
|
+
const config = getComplianceConfig();
|
|
303
|
+
if (config) return { consecutive: config.defaults.consecutiveFailThreshold, promote: config.defaults.tierPromotionThreshold };
|
|
304
|
+
return { consecutive: 3, promote: 5 };
|
|
305
|
+
}
|
|
306
|
+
|
|
307
|
+
function normalizeDirToComp(id: string): string {
|
|
308
|
+
return getDirToComp()[id] || id;
|
|
309
|
+
}
|
|
310
|
+
|
|
311
|
+
// ── Auto hill-climb ──────────────────────────────────────
|
|
312
|
+
|
|
313
|
+
export interface HillClimbAction {
|
|
314
|
+
compId: string;
|
|
315
|
+
rule: string;
|
|
316
|
+
reinforcement: string;
|
|
317
|
+
consecutiveFails: number;
|
|
318
|
+
tier: 1 | 2 | 3;
|
|
319
|
+
promotion?: string;
|
|
320
|
+
}
|
|
321
|
+
|
|
322
|
+
function countConsecutiveFails(verdicts: string[]): number {
|
|
323
|
+
let count = 0;
|
|
324
|
+
for (let i = verdicts.length - 1; i >= 0; i--) {
|
|
325
|
+
if (verdicts[i] === "IGNORED" || verdicts[i] === "VIOLATED") count++;
|
|
326
|
+
else break;
|
|
327
|
+
}
|
|
328
|
+
return count;
|
|
329
|
+
}
|
|
330
|
+
|
|
331
|
+
export function detectHillClimbNeeds(report: ComplianceReport): HillClimbAction[] {
|
|
332
|
+
const actions: HillClimbAction[] = [];
|
|
333
|
+
const seen = new Set<string>();
|
|
334
|
+
for (const ct of report.compTrends) {
|
|
335
|
+
const compId = normalizeDirToComp(ct.compId);
|
|
336
|
+
if (seen.has(compId)) continue;
|
|
337
|
+
seen.add(compId);
|
|
338
|
+
const reinforcements = getReinforcementMap();
|
|
339
|
+
const promotions = getTierPromotions();
|
|
340
|
+
const thresholds = getThresholds();
|
|
341
|
+
if (!reinforcements[compId]) continue;
|
|
342
|
+
const consecutiveFails = countConsecutiveFails(ct.lastN);
|
|
343
|
+
if (consecutiveFails >= thresholds.promote && promotions[compId]) {
|
|
344
|
+
const promo = promotions[compId];
|
|
345
|
+
actions.push({
|
|
346
|
+
compId,
|
|
347
|
+
rule: ct.rule,
|
|
348
|
+
reinforcement: reinforcements[compId],
|
|
349
|
+
consecutiveFails,
|
|
350
|
+
tier: promo.tier,
|
|
351
|
+
promotion: promo.promotion,
|
|
352
|
+
});
|
|
353
|
+
} else if (consecutiveFails >= thresholds.consecutive) {
|
|
354
|
+
actions.push({
|
|
355
|
+
compId,
|
|
356
|
+
rule: ct.rule,
|
|
357
|
+
reinforcement: reinforcements[compId],
|
|
358
|
+
consecutiveFails,
|
|
359
|
+
tier: 1,
|
|
360
|
+
});
|
|
361
|
+
}
|
|
362
|
+
}
|
|
363
|
+
return actions;
|
|
364
|
+
}
|
|
365
|
+
|
|
366
|
+
export function applyHillClimb(
|
|
367
|
+
briefPath: string,
|
|
368
|
+
actions: HillClimbAction[]
|
|
369
|
+
): { applied: string[]; skipped: string[] } {
|
|
370
|
+
if (!existsSync(briefPath) || actions.length === 0)
|
|
371
|
+
return { applied: [], skipped: [] };
|
|
372
|
+
|
|
373
|
+
let content = readFileSync(briefPath, "utf-8");
|
|
374
|
+
const applied: string[] = [];
|
|
375
|
+
const skipped: string[] = [];
|
|
376
|
+
|
|
377
|
+
for (const action of actions) {
|
|
378
|
+
if (action.tier >= 2) {
|
|
379
|
+
skipped.push(
|
|
380
|
+
`${action.compId}: TIER ${action.tier} PROMOTION needed — ${action.promotion}`
|
|
381
|
+
);
|
|
382
|
+
continue;
|
|
383
|
+
}
|
|
384
|
+
|
|
385
|
+
const normalizedReinforcement = action.reinforcement
|
|
386
|
+
.toLowerCase()
|
|
387
|
+
.replace(/[`*"']/g, "");
|
|
388
|
+
const normalizedContent = content.toLowerCase().replace(/[`*"']/g, "");
|
|
389
|
+
|
|
390
|
+
if (normalizedContent.includes(normalizedReinforcement.slice(0, 40))) {
|
|
391
|
+
skipped.push(
|
|
392
|
+
`${action.compId}: reinforcement already present in brief`
|
|
393
|
+
);
|
|
394
|
+
continue;
|
|
395
|
+
}
|
|
396
|
+
|
|
397
|
+
const efficiencyIdx = content.indexOf("## Efficiency Rules");
|
|
398
|
+
const testingIdx = content.indexOf("## Testing Rules");
|
|
399
|
+
const neverIdx = content.indexOf("## Never Do");
|
|
400
|
+
|
|
401
|
+
let insertIdx = -1;
|
|
402
|
+
let prefix = "\n- ";
|
|
403
|
+
|
|
404
|
+
if (
|
|
405
|
+
action.compId === "COMP-2" &&
|
|
406
|
+
testingIdx !== -1
|
|
407
|
+
) {
|
|
408
|
+
const nextSection = content.indexOf("\n## ", testingIdx + 1);
|
|
409
|
+
insertIdx = nextSection !== -1 ? nextSection : content.length;
|
|
410
|
+
prefix = "\n- **REINFORCED (auto):** ";
|
|
411
|
+
} else if (efficiencyIdx !== -1) {
|
|
412
|
+
const nextSection = content.indexOf("\n## ", efficiencyIdx + 1);
|
|
413
|
+
insertIdx = nextSection !== -1 ? nextSection : content.length;
|
|
414
|
+
prefix = "\n- **REINFORCED (auto):** ";
|
|
415
|
+
} else if (neverIdx !== -1) {
|
|
416
|
+
const nextSection = content.indexOf("\n## ", neverIdx + 1);
|
|
417
|
+
insertIdx = nextSection !== -1 ? nextSection : content.length;
|
|
418
|
+
prefix = "\n- **REINFORCED (auto):** ";
|
|
419
|
+
}
|
|
420
|
+
|
|
421
|
+
if (insertIdx === -1) {
|
|
422
|
+
skipped.push(`${action.compId}: no suitable section found in brief`);
|
|
423
|
+
continue;
|
|
424
|
+
}
|
|
425
|
+
|
|
426
|
+
content =
|
|
427
|
+
content.slice(0, insertIdx) +
|
|
428
|
+
`${prefix}${action.reinforcement}` +
|
|
429
|
+
content.slice(insertIdx);
|
|
430
|
+
applied.push(
|
|
431
|
+
`${action.compId}: added reinforcement (${action.consecutiveFails} consecutive fails)`
|
|
432
|
+
);
|
|
433
|
+
}
|
|
434
|
+
|
|
435
|
+
if (applied.length > 0) {
|
|
436
|
+
writeFileSync(briefPath, content);
|
|
437
|
+
}
|
|
438
|
+
|
|
439
|
+
return { applied, skipped };
|
|
440
|
+
}
|
|
441
|
+
|
|
442
|
+
// --- WARN-to-FAIL promotion tracking (SC-515, DEC-012) ---
|
|
443
|
+
|
|
444
|
+
export interface PromotionFinding {
|
|
445
|
+
checkId: string;
|
|
446
|
+
verdict: 'TRUE_POSITIVE' | 'FALSE_POSITIVE';
|
|
447
|
+
}
|
|
448
|
+
|
|
449
|
+
export interface PromotionPrecision {
|
|
450
|
+
checkId: string;
|
|
451
|
+
/** Precision percentage — ratio of true positives to total findings */
|
|
452
|
+
precision: number;
|
|
453
|
+
total: number;
|
|
454
|
+
truePositives: number;
|
|
455
|
+
/** Eligible for WARN-to-FAIL promotion: precision >= 80% AND total >= 10 cycles */
|
|
456
|
+
eligible: boolean;
|
|
457
|
+
}
|
|
458
|
+
|
|
459
|
+
const PROMOTION_PRECISION_THRESHOLD = 80;
|
|
460
|
+
const PROMOTION_MIN_CYCLES = 10;
|
|
461
|
+
|
|
462
|
+
/**
|
|
463
|
+
* Calculate promotion precision for a specific check ID.
|
|
464
|
+
*
|
|
465
|
+
* WARN checks are promoted to FAIL only when mechanical precision tracking
|
|
466
|
+
* shows >80% precision over 10+ cycles (DEC-005, DEC-012).
|
|
467
|
+
*
|
|
468
|
+
* Filters findings by checkId, computes the ratio of TRUE_POSITIVE verdicts,
|
|
469
|
+
* and determines eligibility based on the 80% threshold and minimum sample size.
|
|
470
|
+
*/
|
|
471
|
+
export function calculatePromotionPrecision(
|
|
472
|
+
checkId: string,
|
|
473
|
+
findings: PromotionFinding[],
|
|
474
|
+
): PromotionPrecision {
|
|
475
|
+
const relevant = findings.filter(f => f.checkId === checkId);
|
|
476
|
+
const total = relevant.length;
|
|
477
|
+
const truePositives = relevant.filter(f => f.verdict === 'TRUE_POSITIVE').length;
|
|
478
|
+
const precision = total > 0 ? Math.round((truePositives / total) * 100) : 0;
|
|
479
|
+
const eligible = precision >= PROMOTION_PRECISION_THRESHOLD && total >= PROMOTION_MIN_CYCLES;
|
|
480
|
+
|
|
481
|
+
return { checkId, precision, total, truePositives, eligible };
|
|
482
|
+
}
|
|
483
|
+
|
|
484
|
+
/**
|
|
485
|
+
* Get all check IDs that are candidates for WARN-to-FAIL promotion.
|
|
486
|
+
*
|
|
487
|
+
* Scans all findings, groups by checkId, and returns those meeting the
|
|
488
|
+
* promotion criteria: >= 80% precision over >= 10 cycles.
|
|
489
|
+
*/
|
|
490
|
+
export function getPromotionCandidates(
|
|
491
|
+
findings: PromotionFinding[],
|
|
492
|
+
): PromotionPrecision[] {
|
|
493
|
+
const checkIds = new Set(findings.map(f => f.checkId));
|
|
494
|
+
const candidates: PromotionPrecision[] = [];
|
|
495
|
+
|
|
496
|
+
for (const checkId of checkIds) {
|
|
497
|
+
const result = calculatePromotionPrecision(checkId, findings);
|
|
498
|
+
if (result.eligible) {
|
|
499
|
+
candidates.push(result);
|
|
500
|
+
}
|
|
501
|
+
}
|
|
502
|
+
|
|
503
|
+
return candidates;
|
|
504
|
+
}
|