opencode-windows-scheduler 1.5.2 → 1.5.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/CHANGELOG.md +46 -1
- package/LICENSE +21 -21
- package/README.md +3 -2
- package/ROADMAP-STRATEGY.md +5 -4
- package/ROADMAP.md +251 -72
- package/dist/core/local-ai.d.ts +52 -0
- package/dist/core/local-ai.d.ts.map +1 -0
- package/dist/core/local-ai.js +119 -0
- package/dist/core/ps-wrapper.d.ts +2 -30
- package/dist/core/ps-wrapper.d.ts.map +1 -1
- package/dist/core/ps-wrapper.js +211 -39
- package/dist/core/triage-chain.d.ts +34 -0
- package/dist/core/triage-chain.d.ts.map +1 -0
- package/dist/core/triage-chain.js +70 -0
- package/dist/core/triage-rules.d.ts +23 -0
- package/dist/core/triage-rules.d.ts.map +1 -0
- package/dist/core/triage-rules.js +174 -0
- package/dist/core/triage-shadow.d.ts +47 -0
- package/dist/core/triage-shadow.d.ts.map +1 -0
- package/dist/core/triage-shadow.js +48 -0
- package/dist/core/triage.d.ts +76 -0
- package/dist/core/triage.d.ts.map +1 -0
- package/dist/core/triage.js +271 -0
- package/dist/gui-experimental.cjs +1 -0
- package/dist/i18n.d.ts.map +1 -1
- package/dist/i18n.js +34 -7
- package/dist/index.d.ts +27 -0
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +187 -2
- package/dist/notifications.d.ts.map +1 -1
- package/dist/notifications.js +9 -1
- package/dist/rpc.d.ts +259 -0
- package/dist/rpc.d.ts.map +1 -1
- package/dist/rpc.js +58 -0
- package/dist/settings.d.ts +80 -0
- package/dist/settings.d.ts.map +1 -1
- package/dist/settings.js +199 -0
- package/docs/ARCHITECTURE.md +9 -7
- package/docs/FEATURES.md +22 -2
- package/docs/LOCAL-AI.md +202 -0
- package/docs/MIGRATION.md +17 -0
- package/docs/README.ru.md +5 -4
- package/docs/spikes/local-model-structured-output.md +81 -0
- package/docs/spikes/ollama-qwen3-4b-smoke.json +28 -0
- package/docs/spikes/ollama-qwen3-4b.json +163 -0
- package/gui-experimental.cjs +8 -8
- package/locales/en.json +32 -0
- package/locales/ru.json +32 -0
- package/package.json +9 -2
- package/scripts/bench-local.mjs +321 -0
- package/scripts/spike-local-structured.mjs +182 -0
- package/skills/scheduled-job-best-practices/references/recipes.md +40 -0
- package/src/core/local-ai.ts +173 -0
- package/src/core/ps-wrapper.ts +218 -38
- package/src/core/triage-chain.ts +116 -0
- package/src/core/triage-rules.ts +215 -0
- package/src/core/triage-shadow.ts +96 -0
- package/src/core/triage.ts +366 -0
- package/src/gui.tsx +4761 -4533
- package/src/i18n.ts +32 -9
- package/src/index.ts +222 -2
- package/src/notifications.ts +16 -0
- package/src/rpc.ts +58 -0
- package/src/settings.ts +318 -0
|
@@ -0,0 +1,116 @@
|
|
|
1
|
+
import {
|
|
2
|
+
classifyNotification,
|
|
3
|
+
type TriageFailure,
|
|
4
|
+
type TriageInput,
|
|
5
|
+
type TriageOptions,
|
|
6
|
+
type TriageVerdict,
|
|
7
|
+
} from "./triage.js";
|
|
8
|
+
import { evaluateTriageRules } from "./triage-rules.js";
|
|
9
|
+
import { recordShadowDecision } from "./triage-shadow.js";
|
|
10
|
+
import type { TriageSettings } from "../settings.js";
|
|
11
|
+
|
|
12
|
+
/** Что делать с уведомлением после триажа. */
|
|
13
|
+
export type TriageAction = "notify" | "skip";
|
|
14
|
+
|
|
15
|
+
/** Откуда взято решение — для shadow-режима и диагностики. */
|
|
16
|
+
export type TriageSource = "off" | "llm" | "rules" | "fallback";
|
|
17
|
+
|
|
18
|
+
/** Итог цепочки LLM → правила → fail-open. */
|
|
19
|
+
export interface TriageDecision {
|
|
20
|
+
action: TriageAction;
|
|
21
|
+
source: TriageSource;
|
|
22
|
+
verdict?: TriageVerdict;
|
|
23
|
+
/** Причина, по которой LLM не дал пригодного вердикта. */
|
|
24
|
+
failure?: TriageFailure | "low-confidence";
|
|
25
|
+
attempts: number;
|
|
26
|
+
latencyMs: number;
|
|
27
|
+
/** id сработавшего правила, если решение приняли правила. */
|
|
28
|
+
ruleId?: string;
|
|
29
|
+
}
|
|
30
|
+
|
|
31
|
+
const NOTIFY: TriageAction = "notify";
|
|
32
|
+
|
|
33
|
+
function ruleDecision(
|
|
34
|
+
input: TriageInput,
|
|
35
|
+
settings: TriageSettings,
|
|
36
|
+
source: TriageSource
|
|
37
|
+
): TriageDecision {
|
|
38
|
+
const result = evaluateTriageRules(input, settings.rules);
|
|
39
|
+
return {
|
|
40
|
+
action: result.action,
|
|
41
|
+
source,
|
|
42
|
+
verdict: result.verdict,
|
|
43
|
+
attempts: 0,
|
|
44
|
+
latencyMs: 0,
|
|
45
|
+
ruleId: result.ruleId,
|
|
46
|
+
};
|
|
47
|
+
}
|
|
48
|
+
|
|
49
|
+
/**
|
|
50
|
+
* Применяет цепочку деградации к одному уведомлению.
|
|
51
|
+
*
|
|
52
|
+
* - `off` — триаж выключен, уведомление отправляется.
|
|
53
|
+
* - `rules` — решают только правила; нет совпадения = отправить.
|
|
54
|
+
* - `llm`/`auto` — LLM классифицирует, но сам ничего не подавляет; при
|
|
55
|
+
* ошибке, таймауте или низкой уверенности управление переходит к правилам
|
|
56
|
+
* (если `fallback: "rules"`) либо уведомление отправляется без правил.
|
|
57
|
+
*
|
|
58
|
+
* Функция никогда не бросает исключение и по умолчанию возвращает `notify`:
|
|
59
|
+
* недоступный классификатор не должен терять уведомление.
|
|
60
|
+
*/
|
|
61
|
+
export async function decideTriage(
|
|
62
|
+
input: TriageInput,
|
|
63
|
+
settings: TriageSettings | undefined,
|
|
64
|
+
options: TriageOptions = {}
|
|
65
|
+
): Promise<TriageDecision> {
|
|
66
|
+
if (!settings || settings.mode === "off") {
|
|
67
|
+
return { action: NOTIFY, source: "off", attempts: 0, latencyMs: 0 };
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
if (settings.mode === "rules") {
|
|
71
|
+
return ruleDecision(input, settings, "rules");
|
|
72
|
+
}
|
|
73
|
+
|
|
74
|
+
const llm = await classifyNotification(input, settings, options);
|
|
75
|
+
if (llm.ok && llm.verdict && llm.verdict.confidence >= settings.confidenceThreshold) {
|
|
76
|
+
return {
|
|
77
|
+
action: NOTIFY,
|
|
78
|
+
source: "llm",
|
|
79
|
+
verdict: llm.verdict,
|
|
80
|
+
attempts: llm.attempts,
|
|
81
|
+
latencyMs: llm.latencyMs,
|
|
82
|
+
};
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
const failure: TriageFailure | "low-confidence" = llm.ok
|
|
86
|
+
? "low-confidence"
|
|
87
|
+
: llm.failure ?? "invalid-response";
|
|
88
|
+
|
|
89
|
+
if (settings.fallback === "skip") {
|
|
90
|
+
return {
|
|
91
|
+
action: NOTIFY,
|
|
92
|
+
source: "fallback",
|
|
93
|
+
failure,
|
|
94
|
+
attempts: llm.attempts,
|
|
95
|
+
latencyMs: llm.latencyMs,
|
|
96
|
+
};
|
|
97
|
+
}
|
|
98
|
+
|
|
99
|
+
const byRules = ruleDecision(input, settings, "fallback");
|
|
100
|
+
return {
|
|
101
|
+
...byRules,
|
|
102
|
+
failure,
|
|
103
|
+
attempts: llm.attempts,
|
|
104
|
+
latencyMs: llm.latencyMs,
|
|
105
|
+
};
|
|
106
|
+
}
|
|
107
|
+
|
|
108
|
+
/** Записывает решение в shadow-журнал, если shadow-режим активен. */
|
|
109
|
+
export function recordShadow(
|
|
110
|
+
input: TriageInput,
|
|
111
|
+
decision: TriageDecision,
|
|
112
|
+
shadow: TriageSettings["shadow"] | undefined
|
|
113
|
+
): void {
|
|
114
|
+
if (!shadow || !shadow.enabled) return;
|
|
115
|
+
recordShadowDecision(input, decision);
|
|
116
|
+
}
|
|
@@ -0,0 +1,215 @@
|
|
|
1
|
+
import type { TriageRule, TriageRuleAction } from "../settings.js";
|
|
2
|
+
import type {
|
|
3
|
+
TriageCategory,
|
|
4
|
+
TriageInput,
|
|
5
|
+
TriageSeverity,
|
|
6
|
+
TriageVerdict,
|
|
7
|
+
} from "./triage.js";
|
|
8
|
+
|
|
9
|
+
/**
|
|
10
|
+
* Rules-движок триажа (Спринт 30.4).
|
|
11
|
+
*
|
|
12
|
+
* Проверяет правила по убыванию priority, при равенстве — в порядке массива.
|
|
13
|
+
* Срабатывает только первое совпавшее правило. Движок чистый: ничего не
|
|
14
|
+
* отправляет и не пишет в БД, поэтому его легко использовать в 30.5.
|
|
15
|
+
*/
|
|
16
|
+
|
|
17
|
+
export interface TriageRuleResult {
|
|
18
|
+
matched: boolean;
|
|
19
|
+
ruleId?: string;
|
|
20
|
+
action: TriageRuleAction;
|
|
21
|
+
verdict: TriageVerdict;
|
|
22
|
+
}
|
|
23
|
+
|
|
24
|
+
const DEFAULT_REASON = "Правило не совпало.";
|
|
25
|
+
|
|
26
|
+
/**
|
|
27
|
+
* Встроенные правила. Работают, если в настройках нет поля `rules`
|
|
28
|
+
* (пустой массив отключает их). Специфичные ошибки важнее статуса.
|
|
29
|
+
*/
|
|
30
|
+
export const DEFAULT_TRIAGE_RULES: readonly TriageRule[] = [
|
|
31
|
+
{
|
|
32
|
+
id: "error-timeout",
|
|
33
|
+
field: "error",
|
|
34
|
+
operator: "regex",
|
|
35
|
+
value: "timeout|timed out|таймаут|deadline exceeded",
|
|
36
|
+
category: "timeout",
|
|
37
|
+
severity: "high",
|
|
38
|
+
confidence: 0.9,
|
|
39
|
+
priority: 100,
|
|
40
|
+
reason: "В ошибке есть признак таймаута.",
|
|
41
|
+
},
|
|
42
|
+
{
|
|
43
|
+
id: "error-permission",
|
|
44
|
+
field: "error",
|
|
45
|
+
operator: "regex",
|
|
46
|
+
value:
|
|
47
|
+
"permission denied|access denied|eacces|unauthorized|forbidden|доступ запрещ|нет прав",
|
|
48
|
+
category: "permission",
|
|
49
|
+
severity: "high",
|
|
50
|
+
confidence: 0.9,
|
|
51
|
+
priority: 100,
|
|
52
|
+
reason: "В ошибке есть признак отказа доступа.",
|
|
53
|
+
},
|
|
54
|
+
{
|
|
55
|
+
id: "error-network",
|
|
56
|
+
field: "error",
|
|
57
|
+
operator: "regex",
|
|
58
|
+
value:
|
|
59
|
+
"econnrefused|enotfound|eai_again|network error|connection reset|dns|сеть недоступна|соединение",
|
|
60
|
+
category: "network",
|
|
61
|
+
severity: "high",
|
|
62
|
+
confidence: 0.85,
|
|
63
|
+
priority: 100,
|
|
64
|
+
reason: "В ошибке есть признак сетевой проблемы.",
|
|
65
|
+
},
|
|
66
|
+
{
|
|
67
|
+
id: "error-quality",
|
|
68
|
+
field: "error",
|
|
69
|
+
operator: "regex",
|
|
70
|
+
value: "quality gate|tests? failed|build failed|lint|тест[ыа]? не прош|сборка",
|
|
71
|
+
category: "quality",
|
|
72
|
+
severity: "high",
|
|
73
|
+
confidence: 0.85,
|
|
74
|
+
priority: 100,
|
|
75
|
+
reason: "В ошибке есть признак проблемы качества.",
|
|
76
|
+
},
|
|
77
|
+
{
|
|
78
|
+
id: "status-error",
|
|
79
|
+
field: "status",
|
|
80
|
+
operator: "equals",
|
|
81
|
+
value: "error",
|
|
82
|
+
category: "unknown",
|
|
83
|
+
severity: "high",
|
|
84
|
+
confidence: 0.8,
|
|
85
|
+
priority: 10,
|
|
86
|
+
reason: "Задача завершилась ошибкой.",
|
|
87
|
+
},
|
|
88
|
+
{
|
|
89
|
+
id: "status-partial",
|
|
90
|
+
field: "status",
|
|
91
|
+
operator: "equals",
|
|
92
|
+
value: "partial",
|
|
93
|
+
category: "unknown",
|
|
94
|
+
severity: "medium",
|
|
95
|
+
confidence: 0.8,
|
|
96
|
+
priority: 10,
|
|
97
|
+
reason: "Часть работы завершилась ошибкой.",
|
|
98
|
+
},
|
|
99
|
+
{
|
|
100
|
+
id: "status-success",
|
|
101
|
+
field: "status",
|
|
102
|
+
operator: "equals",
|
|
103
|
+
value: "success",
|
|
104
|
+
category: "unknown",
|
|
105
|
+
severity: "low",
|
|
106
|
+
confidence: 0.8,
|
|
107
|
+
priority: 10,
|
|
108
|
+
reason: "Задача завершилась успешно.",
|
|
109
|
+
},
|
|
110
|
+
];
|
|
111
|
+
|
|
112
|
+
function textFor(field: TriageRule["field"], input: TriageInput): string | null {
|
|
113
|
+
switch (field) {
|
|
114
|
+
case "status":
|
|
115
|
+
return input.status ?? "";
|
|
116
|
+
case "task":
|
|
117
|
+
return input.taskName ?? "";
|
|
118
|
+
case "error":
|
|
119
|
+
return input.error ?? "";
|
|
120
|
+
default:
|
|
121
|
+
return null;
|
|
122
|
+
}
|
|
123
|
+
}
|
|
124
|
+
|
|
125
|
+
function compareNumber(actual: number, operator: TriageRule["operator"], expected: number): boolean {
|
|
126
|
+
switch (operator) {
|
|
127
|
+
case "equals":
|
|
128
|
+
return actual === expected;
|
|
129
|
+
case "gt":
|
|
130
|
+
return actual > expected;
|
|
131
|
+
case "lt":
|
|
132
|
+
return actual < expected;
|
|
133
|
+
case "gte":
|
|
134
|
+
return actual >= expected;
|
|
135
|
+
case "lte":
|
|
136
|
+
return actual <= expected;
|
|
137
|
+
default:
|
|
138
|
+
return false;
|
|
139
|
+
}
|
|
140
|
+
}
|
|
141
|
+
|
|
142
|
+
function matches(rule: TriageRule, input: TriageInput): boolean {
|
|
143
|
+
if (rule.field === "cost") {
|
|
144
|
+
const cost = Number(input.costUsd);
|
|
145
|
+
if (!Number.isFinite(cost) || typeof rule.value !== "number") return false;
|
|
146
|
+
return compareNumber(cost, rule.operator, rule.value);
|
|
147
|
+
}
|
|
148
|
+
|
|
149
|
+
const text = textFor(rule.field, input);
|
|
150
|
+
if (text === null || typeof rule.value !== "string") return false;
|
|
151
|
+
|
|
152
|
+
if (rule.operator === "equals") {
|
|
153
|
+
return text.trim().toLowerCase() === rule.value.trim().toLowerCase();
|
|
154
|
+
}
|
|
155
|
+
if (rule.operator === "contains") {
|
|
156
|
+
return text.toLowerCase().includes(rule.value.toLowerCase());
|
|
157
|
+
}
|
|
158
|
+
if (rule.operator === "regex") {
|
|
159
|
+
try {
|
|
160
|
+
return new RegExp(rule.value, "i").test(text);
|
|
161
|
+
} catch {
|
|
162
|
+
return false;
|
|
163
|
+
}
|
|
164
|
+
}
|
|
165
|
+
return false;
|
|
166
|
+
}
|
|
167
|
+
|
|
168
|
+
function conditionLabel(rule: TriageRule): string {
|
|
169
|
+
return rule.id ?? `${rule.field} ${rule.operator} ${rule.value}`;
|
|
170
|
+
}
|
|
171
|
+
|
|
172
|
+
/** Оценивает одно уведомление по правилам. Не бросает исключений. */
|
|
173
|
+
export function evaluateTriageRules(
|
|
174
|
+
input: TriageInput,
|
|
175
|
+
rules: readonly TriageRule[] | undefined = DEFAULT_TRIAGE_RULES
|
|
176
|
+
): TriageRuleResult {
|
|
177
|
+
const ordered = (rules ?? [])
|
|
178
|
+
.map((rule, index) => ({ rule, index }))
|
|
179
|
+
.sort(
|
|
180
|
+
(a, b) =>
|
|
181
|
+
(b.rule.priority ?? 0) - (a.rule.priority ?? 0) || a.index - b.index
|
|
182
|
+
);
|
|
183
|
+
|
|
184
|
+
for (const { rule } of ordered) {
|
|
185
|
+
if (!matches(rule, input)) continue;
|
|
186
|
+
|
|
187
|
+
const category = (rule.category ?? "unknown") as TriageCategory;
|
|
188
|
+
const severity = (rule.severity ?? "medium") as TriageSeverity;
|
|
189
|
+
const confidence =
|
|
190
|
+
typeof rule.confidence === "number" && Number.isFinite(rule.confidence)
|
|
191
|
+
? Math.min(1, Math.max(0, rule.confidence))
|
|
192
|
+
: 0.8;
|
|
193
|
+
const reason =
|
|
194
|
+
rule.reason?.trim() ||
|
|
195
|
+
`Правило "${conditionLabel(rule)}" совпало: ${rule.field} ${rule.operator} ${rule.value}.`;
|
|
196
|
+
|
|
197
|
+
return {
|
|
198
|
+
matched: true,
|
|
199
|
+
ruleId: rule.id,
|
|
200
|
+
action: rule.action ?? "notify",
|
|
201
|
+
verdict: { category, severity, confidence, reason },
|
|
202
|
+
};
|
|
203
|
+
}
|
|
204
|
+
|
|
205
|
+
return {
|
|
206
|
+
matched: false,
|
|
207
|
+
action: "notify",
|
|
208
|
+
verdict: {
|
|
209
|
+
category: "unknown",
|
|
210
|
+
severity: "low",
|
|
211
|
+
confidence: 0,
|
|
212
|
+
reason: DEFAULT_REASON,
|
|
213
|
+
},
|
|
214
|
+
};
|
|
215
|
+
}
|
|
@@ -0,0 +1,96 @@
|
|
|
1
|
+
import type { TriageDecision } from "./triage-chain.js";
|
|
2
|
+
import type { TriageInput } from "./triage.js";
|
|
3
|
+
import type { TriageShadowSettings } from "../settings.js";
|
|
4
|
+
import { isShadowActive } from "../settings.js";
|
|
5
|
+
|
|
6
|
+
/**
|
|
7
|
+
* Shadow-режим триажа (Спринт 30.6).
|
|
8
|
+
*
|
|
9
|
+
* Решения триажа фиксируются в памяти, но уведомления не подавляются.
|
|
10
|
+
* Ведётся счётчик «false-skip» — сколько раз триаж хотел бы подавить
|
|
11
|
+
* уведомление (action === "skip"), и сколько уведомлений в сумме
|
|
12
|
+
* прошли бы через shadow-фильтр.
|
|
13
|
+
*/
|
|
14
|
+
|
|
15
|
+
/** Одно зафиксированное shadow-решение. */
|
|
16
|
+
export interface ShadowDecisionRecord {
|
|
17
|
+
taskName: string;
|
|
18
|
+
status: string;
|
|
19
|
+
action: "notify" | "skip";
|
|
20
|
+
source: TriageDecision["source"];
|
|
21
|
+
ruleId?: string;
|
|
22
|
+
failure?: TriageDecision["failure"];
|
|
23
|
+
confidence?: number;
|
|
24
|
+
latencyMs: number;
|
|
25
|
+
ts: string;
|
|
26
|
+
}
|
|
27
|
+
|
|
28
|
+
/** Накопленные shadow-решения (в памяти, сбрасываются при перезапуске процесса). */
|
|
29
|
+
const shadowDecisions: ShadowDecisionRecord[] = [];
|
|
30
|
+
|
|
31
|
+
/**
|
|
32
|
+
* Записывает shadow-решение. Не выбрасывает исключений.
|
|
33
|
+
*/
|
|
34
|
+
export function recordShadowDecision(
|
|
35
|
+
input: TriageInput,
|
|
36
|
+
decision: TriageDecision
|
|
37
|
+
): void {
|
|
38
|
+
shadowDecisions.push({
|
|
39
|
+
taskName: input.taskName ?? "",
|
|
40
|
+
status: input.status ?? "",
|
|
41
|
+
action: decision.action,
|
|
42
|
+
source: decision.source,
|
|
43
|
+
ruleId: decision.ruleId,
|
|
44
|
+
failure: decision.failure,
|
|
45
|
+
confidence: decision.verdict?.confidence,
|
|
46
|
+
latencyMs: decision.latencyMs,
|
|
47
|
+
ts: new Date().toISOString(),
|
|
48
|
+
});
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
/** Сколько раз триаж хотел подавить уведомление (action === "skip"). */
|
|
52
|
+
export function shadowSkipCount(): number {
|
|
53
|
+
return shadowDecisions.filter((d) => d.action === "skip").length;
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
/** Сколько уведомлений всего прошло через shadow-фильтр. */
|
|
57
|
+
export function shadowTotalCount(): number {
|
|
58
|
+
return shadowDecisions.length;
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
/** Полный отчёт по shadow-режиму. */
|
|
62
|
+
export interface ShadowReport {
|
|
63
|
+
active: boolean;
|
|
64
|
+
startedAt: string | null;
|
|
65
|
+
days: number;
|
|
66
|
+
total: number;
|
|
67
|
+
skips: number;
|
|
68
|
+
wouldSuppress: number; // === skips (потенциально подавленные уведомления)
|
|
69
|
+
bySource: Record<string, number>;
|
|
70
|
+
decisions: ShadowDecisionRecord[];
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
/** Сформировать отчёт. */
|
|
74
|
+
export function shadowReport(
|
|
75
|
+
shadow: TriageShadowSettings | undefined
|
|
76
|
+
): ShadowReport {
|
|
77
|
+
const bySource: Record<string, number> = {};
|
|
78
|
+
for (const d of shadowDecisions) {
|
|
79
|
+
bySource[d.source] = (bySource[d.source] ?? 0) + 1;
|
|
80
|
+
}
|
|
81
|
+
return {
|
|
82
|
+
active: isShadowActive(shadow),
|
|
83
|
+
startedAt: shadow?.startedAt ?? null,
|
|
84
|
+
days: shadow?.days ?? 0,
|
|
85
|
+
total: shadowTotalCount(),
|
|
86
|
+
skips: shadowSkipCount(),
|
|
87
|
+
wouldSuppress: shadowSkipCount(),
|
|
88
|
+
bySource,
|
|
89
|
+
decisions: [...shadowDecisions],
|
|
90
|
+
};
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
/** Очистить накопленные shadow-решения (для тестов и сброса отчёта). */
|
|
94
|
+
export function resetShadowDecisions(): void {
|
|
95
|
+
shadowDecisions.length = 0;
|
|
96
|
+
}
|