@ngockhoale/ukit 3.5.14 → 3.5.15
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
CHANGED
|
@@ -2,6 +2,17 @@
|
|
|
2
2
|
|
|
3
3
|
All notable changes to UKit are documented here.
|
|
4
4
|
|
|
5
|
+
## 3.5.15 - 2026-11-21
|
|
6
|
+
|
|
7
|
+
Field-telemetry fix round 3.
|
|
8
|
+
|
|
9
|
+
- **Semantic contract mismatch no longer blocks Stop (#6).** The gate re-derived a task's contract from its first prompt and blocked when it differed from the stored one (≈390 field blocks: BAGuide 281, UKit 101, AI-Gateway 9). The router legitimately grows the stored contract during a task (carried evidence, publication and verification flags, mode churn), so a mismatch is not proof of a contradiction. Stop now evaluates the stored contract (no accumulated obligation is dropped), records the diagnostic, and shows a one-line note once per task.
|
|
10
|
+
- **task-watchdog accepts large payloads (#9).** It staged stdin with a 64 KiB cap while every other hook uses 2 MiB, so long Stop messages and big tool outputs were reported as "truncated or stalled during stdin staging". The cap now matches; real truncation still fails open.
|
|
11
|
+
- **Route state is recovered at Stop (#14).** When the session sidecar is missing and the shared route file is unstamped or stamped by another session but carries this session's task id, the gate adopts it instead of reporting "route state … was lost".
|
|
12
|
+
- **Playbook notes stop crying wolf (#17).** The trace was rebuilt from a 24-receipt window, so in long runs the early Read/Edit/test receipts fell out and `analog-search`/`verify` flipped back to "missing" (228 + 56 field notes). Completed steps now persist across the window, and the note is shown once per task.
|
|
13
|
+
- **Release fingerprint ignores hook-written memory notes.** `docs/memory/topics/*.md` are regenerated by edit hooks and are not package content; they changed the candidate fingerprint mid-gate and made the publish guard refuse. They are now excluded like other runtime outputs.
|
|
14
|
+
- Root `.omp/config.yml` comment synced with the template (worktree preflight parity).
|
|
15
|
+
|
|
5
16
|
## 3.5.14 - 2026-11-20
|
|
6
17
|
|
|
7
18
|
Field-telemetry fix round 1. Source: Claude Code transcripts and `.ukit/storage/` of every consumer project (BAGuide, CKit, 4vn, XoonCube, UnicDB, …). New offline tools measure each class before and after a fix: `scripts/audit/field-telemetry.mjs` clusters hook messages and latency, and `scripts/audit/field-replay.mjs` re-runs historical hook inputs through the current hooks.
|
package/package.json
CHANGED
|
@@ -4,8 +4,9 @@ import { createHash } from 'node:crypto';
|
|
|
4
4
|
import path from 'node:path';
|
|
5
5
|
|
|
6
6
|
// Runtime receipts are outputs of verification, not release candidate inputs.
|
|
7
|
+
// docs/memory/topics/ = hook-derived notes (memory-topics.mjs), not in package.json "files"; hooks rewrite them mid-gate.
|
|
7
8
|
// Canonical template_project runtime sources are deliberately NOT excluded.
|
|
8
|
-
const mutable = /^(?:\.ukit\/storage\/|\.claude\/ukit\/runtime\/\.ukit\/storage\/|\.cache\/|node_modules\/)/;
|
|
9
|
+
const mutable = /^(?:\.ukit\/storage\/|\.claude\/ukit\/runtime\/\.ukit\/storage\/|\.cache\/|docs\/memory\/topics\/|node_modules\/)/;
|
|
9
10
|
|
|
10
11
|
export function candidateFingerprint(root) {
|
|
11
12
|
// `git ls-files --others` lists an untracked nested repository (a running test's temp project
|
|
@@ -35,12 +35,12 @@ if source "$SCRIPT_DIR/../ukit/runtime/hook-input.sh" 2>/dev/null; then
|
|
|
35
35
|
# runtime (pre-install tree) simply leaves telemetry off.
|
|
36
36
|
source "$SCRIPT_DIR/../ukit/runtime/hook-telemetry.sh" 2>/dev/null || true
|
|
37
37
|
trap ukit_cleanup_hook_input EXIT
|
|
38
|
-
# Bounded stdin (H01): the
|
|
38
|
+
# Bounded stdin (H01): the cap is 2 MiB like the other Stop hooks, but the payload now travels
|
|
39
39
|
# as a staged file path — never through the exec environment, so an oversized
|
|
40
40
|
# input can no longer stop node from starting (E2BIG) or stall the wrapper in
|
|
41
41
|
# `cat`. A truncated payload simply fails JSON.parse inside node → {} → silent
|
|
42
42
|
# degrade exit 0 (documented posture).
|
|
43
|
-
ukit_stage_hook_input
|
|
43
|
+
ukit_stage_hook_input 2097152 truncate
|
|
44
44
|
__ukit_main_stage_rc=$?
|
|
45
45
|
if [ "$__ukit_main_stage_rc" -ne 0 ]; then
|
|
46
46
|
# Infra failure during staging (mktemp/truncate): payload was never
|
|
@@ -48,7 +48,7 @@ source "$SCRIPT_DIR/../ukit/runtime/hook-telemetry.sh" 2>/dev/null || true
|
|
|
48
48
|
ukit_emit_input_degraded advisory "task-watchdog"
|
|
49
49
|
fi
|
|
50
50
|
# BUG-C21-01: a truncated/stalled staged payload must be announced (SPEC §8), never silently passed.
|
|
51
|
-
# Exception: a payload cut ONLY by the
|
|
51
|
+
# Exception: a payload cut ONLY by the 2 MiB size cap (not a stall) for PostToolUse. That path reads
|
|
52
52
|
# nothing but hook_event_name from the payload (tasks/state/config all come from disk), so a size-truncated
|
|
53
53
|
# payload is not incomplete for this hook. The event name is recovered only when provably complete
|
|
54
54
|
# (ukit_salvage_tool_field); anything else - stall, unrecoverable name, non-PostToolUse (Stop forwards the
|
|
@@ -62,16 +62,16 @@ if ukit_input_degraded; then
|
|
|
62
62
|
[ -n "$UKIT_WD_SALVAGED_EVENT" ] || ukit_emit_input_degraded advisory "task-watchdog"
|
|
63
63
|
fi
|
|
64
64
|
else
|
|
65
|
-
#
|
|
65
|
+
# 2 MiB cap and the advisory degrade path alive.
|
|
66
66
|
# Runtime helper missing (pre-install tree): the SAME bounded staging,
|
|
67
67
|
# inline - `cat >/dev/null` used to block forever on a producer that never
|
|
68
68
|
# closes the pipe (R4.5). Read cap+1 in the background, bound the wait.
|
|
69
69
|
UKIT_INPUT_FILE="$(mktemp "${TMPDIR:-/tmp}/ukit-hook-in.XXXXXX")"
|
|
70
70
|
if [ -e /dev/fd/0 ]; then
|
|
71
71
|
exec 8<&0
|
|
72
|
-
head -c
|
|
72
|
+
head -c 2097153 <&8 > "$UKIT_INPUT_FILE" 2>/dev/null &
|
|
73
73
|
else
|
|
74
|
-
head -c
|
|
74
|
+
head -c 2097153 > "$UKIT_INPUT_FILE" 2>/dev/null &
|
|
75
75
|
fi
|
|
76
76
|
__ukit_reader=$!
|
|
77
77
|
__ukit_stage_ms="${UKIT_HOOK_STAGE_MS:-2000}"
|
|
@@ -88,7 +88,7 @@ else
|
|
|
88
88
|
wait "$__ukit_waiter" 2>/dev/null
|
|
89
89
|
exec 8<&-
|
|
90
90
|
__ukit_size="$(wc -c < "$UKIT_INPUT_FILE" 2>/dev/null | tr -d '[:space:]')"
|
|
91
|
-
if [ "$__ukit_stage_rc" -ne 0 ] || [ "$__ukit_size" -gt
|
|
91
|
+
if [ "$__ukit_stage_rc" -ne 0 ] || [ "$__ukit_size" -gt 2097152 ]; then
|
|
92
92
|
# BUG-C21-01 fallback parity (SPEC §8): a truncated/stalled staged payload
|
|
93
93
|
# must be announced, never silently acted on — same shape as the helper
|
|
94
94
|
# path's ukit_emit_input_degraded.
|
|
@@ -330,6 +330,22 @@ export async function readRouteState(projectRoot, payload = {}) {
|
|
|
330
330
|
return readSessionRouteState(projectRoot, sessionId);
|
|
331
331
|
}
|
|
332
332
|
|
|
333
|
+
// Field #14 recovery: the session sidecar is missing, but the shared single-slot route file may still
|
|
334
|
+
// hold THIS session's task (unstamped by an older router, or re-stamped by a concurrent session that
|
|
335
|
+
// routed afterwards). The session ledger records the taskInstanceId it was opened under; a shared
|
|
336
|
+
// route carrying that exact id is the same task, so adopt it (in memory only) rather than declaring
|
|
337
|
+
// the route lost. Task ids are unique per route, so a different task is never adopted.
|
|
338
|
+
export async function recoverRouteStateFromLedger(projectRoot, payload = {}, ledger = {}) {
|
|
339
|
+
try {
|
|
340
|
+
const taskId = ledger?.taskInstanceId;
|
|
341
|
+
const sessionId = explicitSessionId(payload);
|
|
342
|
+
if (!taskId || !sessionId) return null;
|
|
343
|
+
const shared = await readJson(path.join(projectRoot, '.claude', 'ukit', 'skill-router-state.json'), null);
|
|
344
|
+
if (!shared || shared.routePublicationIncomplete || shared.taskInstanceId !== taskId) return null;
|
|
345
|
+
return { ...shared, sessionId };
|
|
346
|
+
} catch { return null; }
|
|
347
|
+
}
|
|
348
|
+
|
|
333
349
|
export function ownerStopActive(state, payload = {}) {
|
|
334
350
|
const control = state?.ownerControl;
|
|
335
351
|
if (!control || control.kind !== 'stop') return false;
|
|
@@ -2671,7 +2687,7 @@ function isPlaybookRead(file, playbookId) {
|
|
|
2671
2687
|
* playbookId yields the not-applicable trace (no requirements) — the greeting /
|
|
2672
2688
|
* informational shape.
|
|
2673
2689
|
*/
|
|
2674
|
-
export function buildPlaybookTrace(ledger = {}, playbookId = null) {
|
|
2690
|
+
export function buildPlaybookTrace(ledger = {}, playbookId = null, priorTrace = null) {
|
|
2675
2691
|
const id = playbookId || null;
|
|
2676
2692
|
if (!id) {
|
|
2677
2693
|
return {
|
|
@@ -2746,9 +2762,29 @@ export function buildPlaybookTrace(ledger = {}, playbookId = null) {
|
|
|
2746
2762
|
stepsSkipped.push({ id: step.id, justification: PROPORTIONATE_JUSTIFICATION });
|
|
2747
2763
|
}
|
|
2748
2764
|
}
|
|
2765
|
+
// Monotone: the receipt window is capped (MAX_RECEIPTS), so a step proven earlier in the task may have
|
|
2766
|
+
// had its receipt evicted. A prior trace of the SAME playbook keeps its done steps/outputs (field #17:
|
|
2767
|
+
// false "missing: analog-search, verify" after long runs).
|
|
2768
|
+
let priorVerified = false;
|
|
2769
|
+
if (priorTrace && priorTrace.playbookId === id) {
|
|
2770
|
+
const have = new Set(stepsDone.map((step) => step.id));
|
|
2771
|
+
for (const done of Array.isArray(priorTrace.stepsDone) ? priorTrace.stepsDone : []) {
|
|
2772
|
+
if (done?.id && steps.some((step) => step.id === done.id) && !have.has(done.id)) {
|
|
2773
|
+
stepsDone.push(done);
|
|
2774
|
+
const at = stepsSkipped.findIndex((skip) => skip.id === done.id);
|
|
2775
|
+
if (at !== -1) stepsSkipped.splice(at, 1);
|
|
2776
|
+
}
|
|
2777
|
+
}
|
|
2778
|
+
stepsDone.sort((x, y) => steps.findIndex((st) => st.id === x.id) - steps.findIndex((st) => st.id === y.id));
|
|
2779
|
+
for (const out of Array.isArray(priorTrace.outputs) ? priorTrace.outputs : []) {
|
|
2780
|
+
if (typeof out === 'string' && !outputs.includes(out) && outputs.length < MAX_PLAYBOOK_OUTPUTS) outputs.push(out);
|
|
2781
|
+
}
|
|
2782
|
+
priorVerified = priorTrace.verification === 'passed';
|
|
2783
|
+
if (priorTrace.loaded === true) loaded = true;
|
|
2784
|
+
}
|
|
2749
2785
|
const verification = steps.length === 0
|
|
2750
2786
|
? 'n/a'
|
|
2751
|
-
: stepEvidence.has('post-verify') ? 'passed'
|
|
2787
|
+
: stepEvidence.has('post-verify') || priorVerified ? 'passed'
|
|
2752
2788
|
: anyVerificationFailed ? 'failed'
|
|
2753
2789
|
: 'pending';
|
|
2754
2790
|
return {
|
|
@@ -3259,7 +3295,7 @@ function applyReceiptCore(ledger, receipt, { vibecode = false, projectRoot } = {
|
|
|
3259
3295
|
// receipt (live and journaled replay alike) so the persisted record never
|
|
3260
3296
|
// shows an evictable window. Only playbook-routed ledgers grow the field.
|
|
3261
3297
|
if (next.playbookId) {
|
|
3262
|
-
next.playbookTrace = buildPlaybookTrace(next, next.playbookId);
|
|
3298
|
+
next.playbookTrace = buildPlaybookTrace(next, next.playbookId, ledger?.playbookTrace);
|
|
3263
3299
|
}
|
|
3264
3300
|
next.updatedAt = Date.now();
|
|
3265
3301
|
return { ledger: next, value: null };
|
|
@@ -5478,7 +5514,7 @@ function playbookStopAdvisory({ state = {}, ledger = {}, cwd } = {}, result = {}
|
|
|
5478
5514
|
if (!playbookId || playbookId === BUGFIX_PLAYBOOK_ID) return null;
|
|
5479
5515
|
const effectiveLedger = effectiveRequestLedger(state, ledger, cwd);
|
|
5480
5516
|
if (effectiveLedger.writeAttempted !== true) return null;
|
|
5481
|
-
const trace = buildPlaybookTrace(effectiveLedger, playbookId);
|
|
5517
|
+
const trace = buildPlaybookTrace(effectiveLedger, playbookId, effectiveLedger.playbookTrace);
|
|
5482
5518
|
const stepNote = playbookTraceMissingSteps(trace).length === 0 ? null
|
|
5483
5519
|
: `UKit playbook note: ${formatPlaybookTrace(trace)} (advisory).`;
|
|
5484
5520
|
// Round 5: a delegated feature run adds its acceptance verdict — advisory text only.
|
|
@@ -5743,6 +5779,31 @@ export async function reconcileStaleContract(projectRoot, state) {
|
|
|
5743
5779
|
} catch { return state; }
|
|
5744
5780
|
}
|
|
5745
5781
|
|
|
5782
|
+
// One advisory line per task for a semantic-contract invariant violation (marker under the seal cache dir).
|
|
5783
|
+
async function takeInvariantAdvisory(projectRoot, payload, state, diagnostic) {
|
|
5784
|
+
const id = state?.taskInstanceId || 'unknown';
|
|
5785
|
+
const file = path.join(path.dirname(sealPath(projectRoot, payload)), `invariant-advisory-${sessionIdentity(payload)}.json`);
|
|
5786
|
+
const seen = await readJson(file, {}) || {};
|
|
5787
|
+
try { process.stderr.write(`[ukit-completion] semantic contract invariant diagnostic (self-healed, stored contract kept): ${JSON.stringify(diagnostic)}\n`); } catch { /* advisory */ }
|
|
5788
|
+
if (seen[id]) return null;
|
|
5789
|
+
seen[id] = Date.now();
|
|
5790
|
+
await fs.mkdir(path.dirname(file), { recursive: true });
|
|
5791
|
+
await writeJsonAtomic(file, Object.fromEntries(Object.entries(seen).sort((x, y) => y[1] - x[1]).slice(0, SEAL_MAX)));
|
|
5792
|
+
return 'UKit note: internal semantic-contract check disagreed; continuing with the task\'s stored contract (no obligations dropped).';
|
|
5793
|
+
}
|
|
5794
|
+
|
|
5795
|
+
// The playbook note is advisory telemetry: show it at most once per task (marker beside the seal cache).
|
|
5796
|
+
async function takePlaybookNoteOnce(projectRoot, payload, state) {
|
|
5797
|
+
const id = state?.taskInstanceId || state?.requestKey || 'unknown';
|
|
5798
|
+
const file = path.join(path.dirname(sealPath(projectRoot, payload)), `playbook-note-${sessionIdentity(payload)}.json`);
|
|
5799
|
+
const seen = await readJson(file, {}) || {};
|
|
5800
|
+
if (seen[id]) return false;
|
|
5801
|
+
seen[id] = Date.now();
|
|
5802
|
+
await fs.mkdir(path.dirname(file), { recursive: true });
|
|
5803
|
+
await writeJsonAtomic(file, Object.fromEntries(Object.entries(seen).sort((x, y) => y[1] - x[1]).slice(0, SEAL_MAX)));
|
|
5804
|
+
return true;
|
|
5805
|
+
}
|
|
5806
|
+
|
|
5746
5807
|
async function runEvaluateStop() {
|
|
5747
5808
|
const projectRoot = process.env.CLAUDE_PROJECT_DIR || process.cwd();
|
|
5748
5809
|
gitMemo = new Map();
|
|
@@ -5757,7 +5818,7 @@ async function runEvaluateStop() {
|
|
|
5757
5818
|
// malformed payload starts blocking again.
|
|
5758
5819
|
await resetGateCrashCounter(projectRoot);
|
|
5759
5820
|
|
|
5760
|
-
|
|
5821
|
+
let state = await readRouteState(projectRoot, payload);
|
|
5761
5822
|
const ledger = await readExecutionLedger(projectRoot, payload) || {};
|
|
5762
5823
|
if (state?.routePublicationIncomplete) {
|
|
5763
5824
|
process.stdout.write(`${JSON.stringify({ decision: 'block', reason: 'UKit route publication incomplete: shared state and session route do not match; completion is unproven.' })}\n`);
|
|
@@ -5770,6 +5831,9 @@ async function runEvaluateStop() {
|
|
|
5770
5831
|
// ending silently there is indistinguishable from a mid-run stall. Surface the loss so the
|
|
5771
5832
|
// user sees WHY the run released. Sessions that were never routed (no ledger activity at
|
|
5772
5833
|
// all) stay silent: there is nothing to report (silent-success carve-out).
|
|
5834
|
+
if (!state) {
|
|
5835
|
+
state = await recoverRouteStateFromLedger(projectRoot, payload, ledger);
|
|
5836
|
+
}
|
|
5773
5837
|
if (!state) {
|
|
5774
5838
|
const hasActivity = ledger.sourceSucceeded || ledger.writeAttempted
|
|
5775
5839
|
|| ledger.verificationAttempted || (ledger.receipts || []).length > 0;
|
|
@@ -5785,11 +5849,20 @@ async function runEvaluateStop() {
|
|
|
5785
5849
|
// never heals a contract classified by an older classifier. Reconcile it from the task's own
|
|
5786
5850
|
// prompt at the gate boundary (in memory; the stored route state is left untouched).
|
|
5787
5851
|
const reconciled = await reconcileStaleContract(projectRoot, state);
|
|
5852
|
+
// Invariant violation = internal nondeterminism (the router legitimately mutates the stored contract over a task),
|
|
5853
|
+
// never a reason to trap the user: evaluate with the STORED contract (reconcile keeps it untouched, so accumulated
|
|
5854
|
+
// obligations such as release-publication stay enforced), keep the diagnostic, and advise once per task.
|
|
5855
|
+
let advisory = null;
|
|
5788
5856
|
if (reconciled.semanticDiagnostic?.status === 'invariant-violation') {
|
|
5789
|
-
|
|
5790
|
-
return;
|
|
5857
|
+
try { advisory = await takeInvariantAdvisory(projectRoot, payload, state, reconciled.semanticDiagnostic); } catch { advisory = null; }
|
|
5791
5858
|
}
|
|
5859
|
+
const emit = (obj) => process.stdout.write(`${JSON.stringify(advisory && !obj.systemMessage ? { ...obj, systemMessage: advisory } : obj)}\n`);
|
|
5792
5860
|
let result = evaluateCompletion({ state: reconciled, ledger, cwd: projectRoot, phase });
|
|
5861
|
+
if (result.playbookAdvisory) {
|
|
5862
|
+
let first = true;
|
|
5863
|
+
try { first = await takePlaybookNoteOnce(projectRoot, payload, state); } catch { first = true; }
|
|
5864
|
+
if (!first) { const { playbookAdvisory, ...rest } = result; result = rest; }
|
|
5865
|
+
}
|
|
5793
5866
|
if (result.continue && result.missingEvidence?.includes('release-publication')) {
|
|
5794
5867
|
const progress = await noteStopProgress(projectRoot, payload);
|
|
5795
5868
|
if (progress?.value?.reentrant === true) {
|
|
@@ -5884,7 +5957,7 @@ async function runEvaluateStop() {
|
|
|
5884
5957
|
// blocker.
|
|
5885
5958
|
if (result.gateRelease === 'handback-delivered') {
|
|
5886
5959
|
// The one handback for this state was already shown: no message, but never a silent success either.
|
|
5887
|
-
|
|
5960
|
+
emit({ outcome: 'blocked', complete: false, gateRelease: 'handback-delivered' });
|
|
5888
5961
|
return;
|
|
5889
5962
|
}
|
|
5890
5963
|
if (!result.continue && (result.outcome === 'handback' || result.capped === true)) {
|
|
@@ -5907,7 +5980,7 @@ async function runEvaluateStop() {
|
|
|
5907
5980
|
reason: result.reason,
|
|
5908
5981
|
});
|
|
5909
5982
|
} catch { /* advisory */ }
|
|
5910
|
-
|
|
5983
|
+
emit({ decision: 'block', reason: result.reason });
|
|
5911
5984
|
return;
|
|
5912
5985
|
}
|
|
5913
5986
|
if (result.capped || result.notify) {
|
|
@@ -5917,24 +5990,24 @@ async function runEvaluateStop() {
|
|
|
5917
5990
|
// single line (evaluator stdout is parsed first-line-wins by the stop coordinator).
|
|
5918
5991
|
const message = result.playbookAdvisory ? `${result.reason} ${result.playbookAdvisory}` : result.reason;
|
|
5919
5992
|
process.stderr.write(`[ukit-completion] ${result.reason}\n`);
|
|
5920
|
-
|
|
5993
|
+
emit({ systemMessage: advisory ? `${message} ${advisory}` : message,
|
|
5921
5994
|
...(result.outcome === 'blocked' || result.outcome === 'handback' ? { outcome: 'blocked', complete: false } : {}),
|
|
5922
|
-
})
|
|
5995
|
+
});
|
|
5923
5996
|
return;
|
|
5924
5997
|
}
|
|
5925
5998
|
if (result.complete) {
|
|
5926
5999
|
// A satisfied route stays a silent success — unless the routed playbook has
|
|
5927
6000
|
// steps missing, where the trace advisory IS the one-line release message.
|
|
5928
6001
|
if (result.playbookAdvisory) {
|
|
5929
|
-
|
|
5930
|
-
}
|
|
6002
|
+
emit({ systemMessage: advisory ? `${result.playbookAdvisory} ${advisory}` : result.playbookAdvisory });
|
|
6003
|
+
} else if (advisory) emit({});
|
|
5931
6004
|
return; // silent success: route present, all evidence satisfied
|
|
5932
6005
|
}
|
|
5933
|
-
if (result.gateRelease === 'no-routable-contract') return; // Advisory release, never VERIFIED.
|
|
6006
|
+
if (result.gateRelease === 'no-routable-contract') { if (advisory) emit({}); return; } // Advisory release, never VERIFIED.
|
|
5934
6007
|
// Defensive final else: no evaluation result may ever end a routed stop silently.
|
|
5935
6008
|
const fallback = `UKit completion gate: the stop was evaluated without a decision (missing evidence: ${(result.missingEvidence || []).join(', ') || 'none'}). If work is unfinished, re-send the task in a new message.`;
|
|
5936
6009
|
process.stderr.write(`[ukit-completion] ${fallback}\n`);
|
|
5937
|
-
|
|
6010
|
+
emit({ systemMessage: fallback });
|
|
5938
6011
|
}
|
|
5939
6012
|
|
|
5940
6013
|
async function main() {
|